From 9a51ceba0a18bb3b3acc8d51d4b6da3bf8b9a234 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Tue, 20 Jan 2026 16:12:57 -0800 Subject: [PATCH 01/33] Media: Add UltraHDR (ISO 21496-1) gain map support Introduces two new packages for UltraHDR/HDR gain map image support: - @wordpress/ultrahdr-wasm: Rust/WASM library implementing ISO 21496-1 gain map specification with JPEG parsing, XMP metadata handling, and gain map encode/decode functionality - @wordpress/ultrahdr: TypeScript bindings for the WASM library with async loading and WordPress-style API Key features: - Detect UltraHDR images via isUltraHdr() - Decode UltraHDR to extract SDR base, gain map, and metadata - Encode UltraHDR from SDR + HDR image pairs - Extract SDR base for backwards compatibility Also updates: - upload-media store with UltraHDR operation types - webpack config with WASM asset handling - Fixes import order in webpack.config.js Co-Authored-By: Claude Opus 4.5 --- package-lock.json | 30 + packages/scripts/config/webpack.config.js | 13 +- packages/ultrahdr-wasm/.gitignore | 6 + packages/ultrahdr-wasm/Cargo.lock | 533 ++++++++++++++++++ packages/ultrahdr-wasm/Cargo.toml | 39 ++ packages/ultrahdr-wasm/README.md | 81 +++ packages/ultrahdr-wasm/package.json | 47 ++ packages/ultrahdr-wasm/src/error.rs | 84 +++ packages/ultrahdr-wasm/src/gainmap/decode.rs | 343 +++++++++++ packages/ultrahdr-wasm/src/gainmap/encode.rs | 257 +++++++++ packages/ultrahdr-wasm/src/gainmap/math.rs | 432 ++++++++++++++ .../ultrahdr-wasm/src/gainmap/metadata.rs | 223 ++++++++ packages/ultrahdr-wasm/src/gainmap/mod.rs | 13 + packages/ultrahdr-wasm/src/jpeg/mod.rs | 14 + packages/ultrahdr-wasm/src/jpeg/parser.rs | 394 +++++++++++++ packages/ultrahdr-wasm/src/jpeg/writer.rs | 284 ++++++++++ packages/ultrahdr-wasm/src/jpeg/xmp.rs | 374 ++++++++++++ packages/ultrahdr-wasm/src/lib.rs | 293 ++++++++++ packages/ultrahdr-wasm/src/types.rs | 257 +++++++++ .../ultrahdr-wasm/src/ultrahdr/decoder.rs | 325 +++++++++++ .../ultrahdr-wasm/src/ultrahdr/encoder.rs | 255 +++++++++ packages/ultrahdr-wasm/src/ultrahdr/mod.rs | 10 + .../ultrahdr-wasm/tests/integration_tests.rs | 358 ++++++++++++ packages/ultrahdr/.gitignore | 4 + packages/ultrahdr/README.md | 139 +++++ packages/ultrahdr/package.json | 52 ++ packages/ultrahdr/src/index.ts | 324 +++++++++++ packages/ultrahdr/src/types.ts | 150 +++++ packages/ultrahdr/tsconfig.json | 4 + packages/upload-media/package.json | 1 + .../upload-media/src/store/private-actions.ts | 101 ++++ packages/upload-media/src/store/types.ts | 4 + tsconfig.json | 1 + 33 files changed, 5442 insertions(+), 3 deletions(-) create mode 100644 packages/ultrahdr-wasm/.gitignore create mode 100644 packages/ultrahdr-wasm/Cargo.lock create mode 100644 packages/ultrahdr-wasm/Cargo.toml create mode 100644 packages/ultrahdr-wasm/README.md create mode 100644 packages/ultrahdr-wasm/package.json create mode 100644 packages/ultrahdr-wasm/src/error.rs create mode 100644 packages/ultrahdr-wasm/src/gainmap/decode.rs create mode 100644 packages/ultrahdr-wasm/src/gainmap/encode.rs create mode 100644 packages/ultrahdr-wasm/src/gainmap/math.rs create mode 100644 packages/ultrahdr-wasm/src/gainmap/metadata.rs create mode 100644 packages/ultrahdr-wasm/src/gainmap/mod.rs create mode 100644 packages/ultrahdr-wasm/src/jpeg/mod.rs create mode 100644 packages/ultrahdr-wasm/src/jpeg/parser.rs create mode 100644 packages/ultrahdr-wasm/src/jpeg/writer.rs create mode 100644 packages/ultrahdr-wasm/src/jpeg/xmp.rs create mode 100644 packages/ultrahdr-wasm/src/lib.rs create mode 100644 packages/ultrahdr-wasm/src/types.rs create mode 100644 packages/ultrahdr-wasm/src/ultrahdr/decoder.rs create mode 100644 packages/ultrahdr-wasm/src/ultrahdr/encoder.rs create mode 100644 packages/ultrahdr-wasm/src/ultrahdr/mod.rs create mode 100644 packages/ultrahdr-wasm/tests/integration_tests.rs create mode 100644 packages/ultrahdr/.gitignore create mode 100644 packages/ultrahdr/README.md create mode 100644 packages/ultrahdr/package.json create mode 100644 packages/ultrahdr/src/index.ts create mode 100644 packages/ultrahdr/src/types.ts create mode 100644 packages/ultrahdr/tsconfig.json diff --git a/package-lock.json b/package-lock.json index 6baad99eca16ef..c3d0fcf3b95d6d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -21003,6 +21003,14 @@ "resolved": "packages/ui", "link": true }, + "node_modules/@wordpress/ultrahdr": { + "resolved": "packages/ultrahdr", + "link": true + }, + "node_modules/@wordpress/ultrahdr-wasm": { + "resolved": "packages/ultrahdr-wasm", + "link": true + }, "node_modules/@wordpress/undo-manager": { "resolved": "packages/undo-manager", "link": true @@ -62694,6 +62702,27 @@ "react-dom": "^18.0.0" } }, + "packages/ultrahdr": { + "name": "@wordpress/ultrahdr", + "version": "1.0.0-prerelease", + "license": "GPL-2.0-or-later", + "dependencies": { + "@wordpress/ultrahdr-wasm": "file:../ultrahdr-wasm" + }, + "engines": { + "node": ">=18.12.0", + "npm": ">=8.19.2" + } + }, + "packages/ultrahdr-wasm": { + "name": "@wordpress/ultrahdr-wasm", + "version": "1.0.0-prerelease", + "license": "GPL-2.0-or-later", + "engines": { + "node": ">=18.12.0", + "npm": ">=8.19.2" + } + }, "packages/undo-manager": { "name": "@wordpress/undo-manager", "version": "1.41.0", @@ -62721,6 +62750,7 @@ "@wordpress/i18n": "file:../i18n", "@wordpress/preferences": "file:../preferences", "@wordpress/private-apis": "file:../private-apis", + "@wordpress/ultrahdr": "file:../ultrahdr", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", "uuid": "^9.0.1" diff --git a/packages/scripts/config/webpack.config.js b/packages/scripts/config/webpack.config.js index 5674c78f1f88eb..80638b4a125235 100644 --- a/packages/scripts/config/webpack.config.js +++ b/packages/scripts/config/webpack.config.js @@ -1,17 +1,17 @@ /** * External dependencies */ +const { exec } = require( 'child_process' ); +const { realpathSync } = require( 'fs' ); +const { basename, dirname, relative, resolve, sep } = require( 'path' ); const { BundleAnalyzerPlugin } = require( 'webpack-bundle-analyzer' ); const CopyWebpackPlugin = require( 'copy-webpack-plugin' ); const webpack = require( 'webpack' ); const browserslist = require( 'browserslist' ); const MiniCSSExtractPlugin = require( 'mini-css-extract-plugin' ); -const { basename, dirname, relative, resolve, sep } = require( 'path' ); const ReactRefreshWebpackPlugin = require( '@pmmmwh/react-refresh-webpack-plugin' ); const TerserPlugin = require( 'terser-webpack-plugin' ); -const { realpathSync } = require( 'fs' ); const { sync: glob } = require( 'fast-glob' ); -const { exec } = require( 'child_process' ); /** * WordPress dependencies @@ -242,6 +242,13 @@ const baseConfig = { filename: 'fonts/[name].[hash:8][ext]', }, }, + { + test: /\.wasm$/, + type: 'asset/resource', + generator: { + filename: 'wasm/[name].[hash:8][ext]', + }, + }, ], }, stats: { diff --git a/packages/ultrahdr-wasm/.gitignore b/packages/ultrahdr-wasm/.gitignore new file mode 100644 index 00000000000000..5dfa8d566775c4 --- /dev/null +++ b/packages/ultrahdr-wasm/.gitignore @@ -0,0 +1,6 @@ +# Build artifacts +/target/ +/pkg/ + +# Cargo lock is typically committed for applications but not libraries +# However, for reproducible builds in monorepo, we commit it diff --git a/packages/ultrahdr-wasm/Cargo.lock b/packages/ultrahdr-wasm/Cargo.lock new file mode 100644 index 00000000000000..47abaa9a294ba1 --- /dev/null +++ b/packages/ultrahdr-wasm/Cargo.lock @@ -0,0 +1,533 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "async-trait" +version = "0.1.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "autocfg" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" + +[[package]] +name = "bumpalo" +version = "3.19.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" + +[[package]] +name = "bytemuck" +version = "1.24.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" + +[[package]] +name = "byteorder-lite" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" + +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + +[[package]] +name = "cc" +version = "1.2.53" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "find-msvc-tools" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db" + +[[package]] +name = "futures-core" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" + +[[package]] +name = "futures-task" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" + +[[package]] +name = "futures-util" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "pin-utils", + "slab", +] + +[[package]] +name = "image" +version = "0.25.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" +dependencies = [ + "bytemuck", + "byteorder-lite", + "moxcms", + "num-traits", + "zune-core 0.5.1", + "zune-jpeg 0.5.11", +] + +[[package]] +name = "itoa" +version = "1.0.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" + +[[package]] +name = "js-sys" +version = "0.3.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3" +dependencies = [ + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "libm" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" + +[[package]] +name = "memchr" +version = "2.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" + +[[package]] +name = "minicov" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d" +dependencies = [ + "cc", + "walkdir", +] + +[[package]] +name = "moxcms" +version = "0.7.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97" +dependencies = [ + "num-traits", + "pxfm", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "once_cell" +version = "1.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" + +[[package]] +name = "oorandom" +version = "11.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" + +[[package]] +name = "pin-project-lite" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" + +[[package]] +name = "pin-utils" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" + +[[package]] +name = "proc-macro2" +version = "1.0.105" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "pxfm" +version = "0.1.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8" +dependencies = [ + "num-traits", +] + +[[package]] +name = "quick-xml" +version = "0.31.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33" +dependencies = [ + "memchr", +] + +[[package]] +name = "quote" +version = "1.0.43" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "same-file" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" +dependencies = [ + "winapi-util", +] + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.149" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" + +[[package]] +name = "syn" +version = "2.0.114" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "unicode-ident" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" + +[[package]] +name = "walkdir" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" +dependencies = [ + "same-file", + "winapi-util", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" +dependencies = [ + "cfg-if", + "futures-util", + "js-sys", + "once_cell", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-bindgen-test" +version = "0.3.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45649196a53b0b7a15101d845d44d2dda7374fc1b5b5e2bbf58b7577ff4b346d" +dependencies = [ + "async-trait", + "cast", + "js-sys", + "libm", + "minicov", + "nu-ansi-term", + "num-traits", + "oorandom", + "serde", + "serde_json", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-bindgen-test-macro", + "wasm-bindgen-test-shared", +] + +[[package]] +name = "wasm-bindgen-test-macro" +version = "0.3.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f579cdd0123ac74b94e1a4a72bd963cf30ebac343f2df347da0b8df24cdebed2" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "wasm-bindgen-test-shared" +version = "0.2.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a8145dd1593bf0fb137dbfa85b8be79ec560a447298955877804640e40c2d6ea" + +[[package]] +name = "web-sys" +version = "0.3.85" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "winapi-util" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" +dependencies = [ + "windows-sys", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "wordpress-ultrahdr" +version = "0.1.0" +dependencies = [ + "image", + "js-sys", + "quick-xml", + "serde", + "serde_json", + "thiserror", + "wasm-bindgen", + "wasm-bindgen-test", + "web-sys", + "zune-jpeg 0.4.21", +] + +[[package]] +name = "zmij" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65" + +[[package]] +name = "zune-core" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a" + +[[package]] +name = "zune-core" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9" + +[[package]] +name = "zune-jpeg" +version = "0.4.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713" +dependencies = [ + "zune-core 0.4.12", +] + +[[package]] +name = "zune-jpeg" +version = "0.5.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2959ca473aae96a14ecedf501d20b3608d2825ba280d5adb57d651721885b0c2" +dependencies = [ + "zune-core 0.5.1", +] diff --git a/packages/ultrahdr-wasm/Cargo.toml b/packages/ultrahdr-wasm/Cargo.toml new file mode 100644 index 00000000000000..5d3bc8cabe8850 --- /dev/null +++ b/packages/ultrahdr-wasm/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = "wordpress-ultrahdr" +version = "0.1.0" +edition = "2021" +license = "GPL-2.0-or-later" +authors = ["The WordPress Contributors"] +description = "UltraHDR (ISO 21496-1) gain map implementation for WordPress Gutenberg" +repository = "https://github.com/WordPress/gutenberg" +readme = "README.md" + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +# WASM bindings (MIT/Apache-2.0) +wasm-bindgen = "0.2" +js-sys = "0.3" +web-sys = { version = "0.3", features = ["console"] } + +# Image processing (MIT/Apache-2.0) +image = { version = "0.25", default-features = false, features = ["jpeg"] } +zune-jpeg = { version = "0.4", default-features = false, features = ["std"] } + +# XMP/XML parsing (MIT) +quick-xml = "0.31" + +# Serialization (MIT/Apache-2.0) +serde = { version = "1.0", features = ["derive"] } +serde_json = "1.0" + +# Error handling (MIT/Apache-2.0) +thiserror = "1.0" + +[dev-dependencies] +wasm-bindgen-test = "0.3" + +[profile.release] +opt-level = "s" +lto = true diff --git a/packages/ultrahdr-wasm/README.md b/packages/ultrahdr-wasm/README.md new file mode 100644 index 00000000000000..4a65d5fcaeb8b2 --- /dev/null +++ b/packages/ultrahdr-wasm/README.md @@ -0,0 +1,81 @@ +# UltraHDR WASM Library + +A GPLv2-compatible Rust library implementing ISO 21496-1 (UltraHDR/gain map) specification, compiled to WebAssembly for integration with WordPress Gutenberg's client-side media processing. + +## Features + +- **Detection**: Check if a JPEG contains UltraHDR/gain map data +- **Decoding**: Extract SDR base, gain map, and metadata from UltraHDR JPEGs +- **Encoding**: Create UltraHDR JPEGs from SDR + HDR image pairs +- **SDR Extraction**: Extract backwards-compatible SDR image + +## Standards Support + +- [ISO 21496-1:2025](https://www.iso.org/standard/86775.html) - Gain map metadata for dynamic range conversion +- [Google UltraHDR v1](https://developer.android.com/media/platform/hdr-image-format) - Android compatibility +- [Adobe Gain Map Specification](https://helpx.adobe.com/camera-raw/using/gain-map.html) + +## Building + +### Prerequisites + +- [Rust](https://rustup.rs/) (stable) +- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) + +### Build Commands + +```bash +# Development build +npm run build:dev + +# Production build +npm run build + +# Run tests +npm run test +``` + +## Usage + +This package is intended to be used via the `@wordpress/ultrahdr` TypeScript wrapper. See that package for usage examples. + +## Architecture + +``` +src/ +├── lib.rs # WASM entry point and exports +├── types.rs # Shared types (GainMapMetadata, etc.) +├── error.rs # Error handling +├── gainmap/ +│ ├── mod.rs # Gain map module +│ ├── math.rs # Color space conversions +│ ├── metadata.rs # ISO 21496-1 metadata structures +│ ├── encode.rs # Gain map computation +│ └── decode.rs # Gain map application +├── jpeg/ +│ ├── mod.rs # JPEG handling +│ ├── parser.rs # APP1/APP2/MPF segment parsing +│ ├── writer.rs # JPEG segment writing +│ └── xmp.rs # XMP embedding/extraction +└── ultrahdr/ + ├── mod.rs # UltraHDR format + ├── encoder.rs # Create UltraHDR JPEG + └── decoder.rs # Extract components +``` + +## License + +GPL-2.0-or-later + +## Dependencies + +All dependencies are GPLv2-compatible (via MIT license): + +| Dependency | License | Purpose | +|------------|---------|---------| +| wasm-bindgen | MIT/Apache-2.0 | WASM bindings | +| image | MIT/Apache-2.0 | Image processing | +| zune-jpeg | MIT/Apache-2.0/Zlib | JPEG decoding | +| quick-xml | MIT | XMP parsing | +| serde | MIT/Apache-2.0 | Serialization | +| thiserror | MIT/Apache-2.0 | Error handling | diff --git a/packages/ultrahdr-wasm/package.json b/packages/ultrahdr-wasm/package.json new file mode 100644 index 00000000000000..b46c03f027acab --- /dev/null +++ b/packages/ultrahdr-wasm/package.json @@ -0,0 +1,47 @@ +{ + "name": "@wordpress/ultrahdr-wasm", + "version": "1.0.0-prerelease", + "private": true, + "description": "UltraHDR (ISO 21496-1) gain map WASM implementation for WordPress Gutenberg.", + "author": "The WordPress Contributors", + "license": "GPL-2.0-or-later", + "keywords": [ + "wordpress", + "media", + "ultrahdr", + "hdr", + "gain-map", + "wasm" + ], + "homepage": "https://github.com/WordPress/gutenberg/tree/HEAD/packages/ultrahdr-wasm/README.md", + "repository": { + "type": "git", + "url": "https://github.com/WordPress/gutenberg.git", + "directory": "packages/ultrahdr-wasm" + }, + "bugs": { + "url": "https://github.com/WordPress/gutenberg/issues" + }, + "engines": { + "node": ">=18.12.0", + "npm": ">=8.19.2" + }, + "files": [ + "pkg", + "*.md" + ], + "main": "pkg/wordpress_ultrahdr.js", + "module": "pkg/wordpress_ultrahdr.js", + "exports": { + ".": { + "types": "./pkg/wordpress_ultrahdr.d.ts", + "import": "./pkg/wordpress_ultrahdr.js", + "default": "./pkg/wordpress_ultrahdr.js" + }, + "./pkg/*": "./pkg/*", + "./package.json": "./package.json" + }, + "publishConfig": { + "access": "public" + } +} diff --git a/packages/ultrahdr-wasm/src/error.rs b/packages/ultrahdr-wasm/src/error.rs new file mode 100644 index 00000000000000..1656211e77f034 --- /dev/null +++ b/packages/ultrahdr-wasm/src/error.rs @@ -0,0 +1,84 @@ +//! Error types for UltraHDR operations. + +use thiserror::Error; + +/// Errors that can occur during UltraHDR operations. +#[derive(Error, Debug)] +pub enum UltraHdrError { + /// Invalid JPEG format or corrupted data + #[error("Invalid JPEG format: {0}")] + InvalidJpeg(String), + + /// Missing required marker or segment + #[error("Missing required JPEG marker: {0}")] + MissingMarker(String), + + /// XMP parsing or validation error + #[error("XMP error: {0}")] + XmpError(String), + + /// Gain map metadata error + #[error("Gain map metadata error: {0}")] + MetadataError(String), + + /// Image dimension mismatch + #[error("Image dimension mismatch: SDR {0}x{1}, HDR {2}x{3}")] + DimensionMismatch(u32, u32, u32, u32), + + /// Invalid dimensions (e.g., odd dimensions) + #[error("Invalid dimensions: {0}")] + InvalidDimensions(String), + + /// Invalid quality value + #[error("Invalid quality value: {0} (must be 1-100)")] + InvalidQuality(u8), + + /// Invalid HDR capacity values + #[error("Invalid HDR capacity: min ({0}) must be less than max ({1})")] + InvalidHdrCapacity(f32, f32), + + /// Image decoding error + #[error("Image decoding error: {0}")] + DecodeError(String), + + /// Image encoding error + #[error("Image encoding error: {0}")] + EncodeError(String), + + /// Color space conversion error + #[error("Color space error: {0}")] + ColorSpaceError(String), + + /// No gain map found in image + #[error("No gain map found in image")] + NoGainMap, + + /// I/O error + #[error("I/O error: {0}")] + IoError(String), + + /// Unsupported feature + #[error("Unsupported feature: {0}")] + Unsupported(String), +} + +/// Result type alias for UltraHDR operations. +pub type Result = std::result::Result; + +impl From for UltraHdrError { + fn from(err: std::io::Error) -> Self { + UltraHdrError::IoError(err.to_string()) + } +} + +impl From for UltraHdrError { + fn from(err: quick_xml::Error) -> Self { + UltraHdrError::XmpError(err.to_string()) + } +} + +impl From for UltraHdrError { + fn from(err: image::ImageError) -> Self { + UltraHdrError::DecodeError(err.to_string()) + } +} diff --git a/packages/ultrahdr-wasm/src/gainmap/decode.rs b/packages/ultrahdr-wasm/src/gainmap/decode.rs new file mode 100644 index 00000000000000..8fcd13cc73883a --- /dev/null +++ b/packages/ultrahdr-wasm/src/gainmap/decode.rs @@ -0,0 +1,343 @@ +//! Gain map decoding (application to reconstruct HDR). +//! +//! Implements the gain map application algorithm from ISO 21496-1. + +use crate::error::{Result, UltraHdrError}; +use crate::types::GainMapMetadata; +use super::math::{decode_gain, apply_gain_to_pixel, compute_hdr_weight, srgb_to_linear, linear_to_srgb}; + +/// Applies a gain map to an SDR image to produce an HDR result. +/// +/// # Arguments +/// * `sdr_rgb` - SDR image as RGB bytes (sRGB encoded, 3 bytes per pixel) +/// * `gain_map` - Gain map as grayscale bytes (1 byte per pixel) +/// * `metadata` - Gain map metadata +/// * `width` - SDR image width +/// * `height` - SDR image height +/// * `gm_width` - Gain map width +/// * `gm_height` - Gain map height +/// * `display_hdr_capacity` - Display's HDR capacity (in stops) +/// +/// # Returns +/// Linear HDR RGB image as floats (3 floats per pixel). +pub fn apply_gain_map( + sdr_rgb: &[u8], + gain_map: &[u8], + metadata: &GainMapMetadata, + width: u32, + height: u32, + gm_width: u32, + gm_height: u32, + display_hdr_capacity: f32, +) -> Result> { + let pixel_count = (width * height) as usize; + let gm_pixel_count = (gm_width * gm_height) as usize; + + // Validate input sizes + if sdr_rgb.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "SDR buffer size {} doesn't match {}x{}x3", + sdr_rgb.len(), width, height + ))); + } + if gain_map.len() != gm_pixel_count { + return Err(UltraHdrError::InvalidDimensions(format!( + "Gain map size {} doesn't match {}x{}", + gain_map.len(), gm_width, gm_height + ))); + } + + // Compute HDR weight based on display capability + let hdr_weight = compute_hdr_weight( + display_hdr_capacity, + metadata.hdr_capacity_min, + metadata.hdr_capacity_max, + ); + + let mut hdr_output = vec![0.0f32; pixel_count * 3]; + + // Scale factors for gain map sampling + let scale_x = gm_width as f32 / width as f32; + let scale_y = gm_height as f32 / height as f32; + + for y in 0..height { + for x in 0..width { + let idx = (y * width + x) as usize; + + // Get SDR pixel and convert to linear + let sdr_r = sdr_rgb[idx * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[idx * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[idx * 3 + 2] as f32 / 255.0; + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + // Sample gain map with bilinear interpolation + let gm_x = x as f32 * scale_x; + let gm_y = y as f32 * scale_y; + let gain_encoded = sample_gain_map_bilinear(gain_map, gm_width, gm_height, gm_x, gm_y); + + // Decode gain value (same for all channels in single-channel gain map) + // Interpolate between min and max gain based on HDR weight + let effective_min = interpolate_per_channel(&metadata.gain_map_min, hdr_weight); + let effective_max = interpolate_per_channel(&metadata.gain_map_max, hdr_weight); + + let gain_r = decode_gain(gain_encoded, effective_min[0], effective_max[0], metadata.gamma[0]); + let gain_g = decode_gain(gain_encoded, effective_min[1], effective_max[1], metadata.gamma[1]); + let gain_b = decode_gain(gain_encoded, effective_min[2], effective_max[2], metadata.gamma[2]); + + // Apply gain to each channel + let hdr_r = apply_gain_to_pixel( + sdr_lin_r, + gain_r, + metadata.offset_sdr[0], + metadata.offset_hdr[0], + ); + let hdr_g = apply_gain_to_pixel( + sdr_lin_g, + gain_g, + metadata.offset_sdr[1], + metadata.offset_hdr[1], + ); + let hdr_b = apply_gain_to_pixel( + sdr_lin_b, + gain_b, + metadata.offset_sdr[2], + metadata.offset_hdr[2], + ); + + hdr_output[idx * 3] = hdr_r; + hdr_output[idx * 3 + 1] = hdr_g; + hdr_output[idx * 3 + 2] = hdr_b; + } + } + + Ok(hdr_output) +} + +/// Applies a per-channel RGB gain map to an SDR image. +pub fn apply_gain_map_rgb( + sdr_rgb: &[u8], + gain_map_rgb: &[u8], + metadata: &GainMapMetadata, + width: u32, + height: u32, + gm_width: u32, + gm_height: u32, + display_hdr_capacity: f32, +) -> Result> { + let pixel_count = (width * height) as usize; + let gm_pixel_count = (gm_width * gm_height) as usize; + + if sdr_rgb.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "SDR buffer size {} doesn't match {}x{}x3", + sdr_rgb.len(), width, height + ))); + } + if gain_map_rgb.len() != gm_pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "RGB gain map size {} doesn't match {}x{}x3", + gain_map_rgb.len(), gm_width, gm_height + ))); + } + + let hdr_weight = compute_hdr_weight( + display_hdr_capacity, + metadata.hdr_capacity_min, + metadata.hdr_capacity_max, + ); + + let mut hdr_output = vec![0.0f32; pixel_count * 3]; + + let scale_x = gm_width as f32 / width as f32; + let scale_y = gm_height as f32 / height as f32; + + for y in 0..height { + for x in 0..width { + let idx = (y * width + x) as usize; + + let sdr_r = sdr_rgb[idx * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[idx * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[idx * 3 + 2] as f32 / 255.0; + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + let gm_x = x as f32 * scale_x; + let gm_y = y as f32 * scale_y; + let (gain_enc_r, gain_enc_g, gain_enc_b) = sample_gain_map_rgb_bilinear( + gain_map_rgb, gm_width, gm_height, gm_x, gm_y + ); + + let effective_min = interpolate_per_channel(&metadata.gain_map_min, hdr_weight); + let effective_max = interpolate_per_channel(&metadata.gain_map_max, hdr_weight); + + let gain_r = decode_gain(gain_enc_r, effective_min[0], effective_max[0], metadata.gamma[0]); + let gain_g = decode_gain(gain_enc_g, effective_min[1], effective_max[1], metadata.gamma[1]); + let gain_b = decode_gain(gain_enc_b, effective_min[2], effective_max[2], metadata.gamma[2]); + + hdr_output[idx * 3] = apply_gain_to_pixel(sdr_lin_r, gain_r, metadata.offset_sdr[0], metadata.offset_hdr[0]); + hdr_output[idx * 3 + 1] = apply_gain_to_pixel(sdr_lin_g, gain_g, metadata.offset_sdr[1], metadata.offset_hdr[1]); + hdr_output[idx * 3 + 2] = apply_gain_to_pixel(sdr_lin_b, gain_b, metadata.offset_sdr[2], metadata.offset_hdr[2]); + } + } + + Ok(hdr_output) +} + +/// Renders HDR output to sRGB for SDR displays. +/// +/// Applies tone mapping to bring HDR values into displayable range. +pub fn render_to_srgb(hdr_linear: &[f32], max_luminance: f32) -> Vec { + let pixel_count = hdr_linear.len() / 3; + let mut output = vec![0u8; pixel_count * 3]; + + for i in 0..pixel_count { + // Simple Reinhard tone mapping + let r = hdr_linear[i * 3]; + let g = hdr_linear[i * 3 + 1]; + let b = hdr_linear[i * 3 + 2]; + + let mapped_r = r / (1.0 + r / max_luminance); + let mapped_g = g / (1.0 + g / max_luminance); + let mapped_b = b / (1.0 + b / max_luminance); + + let (srgb_r, srgb_g, srgb_b) = linear_to_srgb(mapped_r, mapped_g, mapped_b); + + output[i * 3] = (srgb_r * 255.0).clamp(0.0, 255.0) as u8; + output[i * 3 + 1] = (srgb_g * 255.0).clamp(0.0, 255.0) as u8; + output[i * 3 + 2] = (srgb_b * 255.0).clamp(0.0, 255.0) as u8; + } + + output +} + +/// Samples gain map with bilinear interpolation. +fn sample_gain_map_bilinear(gain_map: &[u8], width: u32, height: u32, x: f32, y: f32) -> f32 { + let x0 = (x.floor() as u32).min(width - 1); + let y0 = (y.floor() as u32).min(height - 1); + let x1 = (x0 + 1).min(width - 1); + let y1 = (y0 + 1).min(height - 1); + + let fx = x - x0 as f32; + let fy = y - y0 as f32; + + let v00 = gain_map[(y0 * width + x0) as usize] as f32 / 255.0; + let v10 = gain_map[(y0 * width + x1) as usize] as f32 / 255.0; + let v01 = gain_map[(y1 * width + x0) as usize] as f32 / 255.0; + let v11 = gain_map[(y1 * width + x1) as usize] as f32 / 255.0; + + let v0 = v00 * (1.0 - fx) + v10 * fx; + let v1 = v01 * (1.0 - fx) + v11 * fx; + + v0 * (1.0 - fy) + v1 * fy +} + +/// Samples RGB gain map with bilinear interpolation. +fn sample_gain_map_rgb_bilinear( + gain_map: &[u8], + width: u32, + height: u32, + x: f32, + y: f32, +) -> (f32, f32, f32) { + let x0 = (x.floor() as u32).min(width - 1); + let y0 = (y.floor() as u32).min(height - 1); + let x1 = (x0 + 1).min(width - 1); + let y1 = (y0 + 1).min(height - 1); + + let fx = x - x0 as f32; + let fy = y - y0 as f32; + + let idx00 = ((y0 * width + x0) * 3) as usize; + let idx10 = ((y0 * width + x1) * 3) as usize; + let idx01 = ((y1 * width + x0) * 3) as usize; + let idx11 = ((y1 * width + x1) * 3) as usize; + + let mut result = [0.0f32; 3]; + + for c in 0..3 { + let v00 = gain_map[idx00 + c] as f32 / 255.0; + let v10 = gain_map[idx10 + c] as f32 / 255.0; + let v01 = gain_map[idx01 + c] as f32 / 255.0; + let v11 = gain_map[idx11 + c] as f32 / 255.0; + + let v0 = v00 * (1.0 - fx) + v10 * fx; + let v1 = v01 * (1.0 - fx) + v11 * fx; + + result[c] = v0 * (1.0 - fy) + v1 * fy; + } + + (result[0], result[1], result[2]) +} + +/// Interpolates per-channel values based on HDR weight. +fn interpolate_per_channel(values: &[f32], weight: f32) -> Vec { + // When weight = 0, use 0 (no HDR), when weight = 1, use full values + values.iter().map(|&v| v * weight).collect() +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_apply_gain_map_basic() { + let width = 2u32; + let height = 2u32; + + // Mid-gray SDR image + let sdr = vec![128u8; 12]; + + // Neutral gain map (mid-point = no change) + let gain_map = vec![128u8; 4]; + + let metadata = GainMapMetadata::default(); + + let result = apply_gain_map( + &sdr, &gain_map, &metadata, + width, height, width, height, + 3.0 + ); + + assert!(result.is_ok()); + let hdr = result.unwrap(); + assert_eq!(hdr.len(), 12); // 2x2x3 floats + } + + #[test] + fn test_apply_gain_map_different_sizes() { + let width = 4u32; + let height = 4u32; + let gm_width = 2u32; + let gm_height = 2u32; + + let sdr = vec![128u8; 48]; // 4x4x3 + let gain_map = vec![128u8; 4]; // 2x2 + + let metadata = GainMapMetadata::default(); + + let result = apply_gain_map( + &sdr, &gain_map, &metadata, + width, height, gm_width, gm_height, + 3.0 + ); + + assert!(result.is_ok()); + } + + #[test] + fn test_render_to_srgb() { + let hdr = vec![0.5f32, 0.5, 0.5, 1.0, 1.0, 1.0]; // 2 pixels + let srgb = render_to_srgb(&hdr, 4.0); + + assert_eq!(srgb.len(), 6); + // Verify we get valid u8 output (non-zero for these inputs) + assert!(srgb.iter().any(|&v| v > 0)); + } + + #[test] + fn test_bilinear_interpolation() { + let gain_map = vec![0u8, 255, 0, 255]; // 2x2 + let center = sample_gain_map_bilinear(&gain_map, 2, 2, 0.5, 0.5); + // Should be average of all 4 pixels + assert!((center - 0.5).abs() < 0.01); + } +} diff --git a/packages/ultrahdr-wasm/src/gainmap/encode.rs b/packages/ultrahdr-wasm/src/gainmap/encode.rs new file mode 100644 index 00000000000000..ca4a844dd734b8 --- /dev/null +++ b/packages/ultrahdr-wasm/src/gainmap/encode.rs @@ -0,0 +1,257 @@ +//! Gain map encoding (computation from SDR + HDR image pair). +//! +//! Implements the gain map computation algorithm from ISO 21496-1. + +use crate::error::{Result, UltraHdrError}; +use crate::types::GainMapMetadata; +use super::math::{encode_gain, compute_gain_ratio, srgb_to_linear}; +use super::metadata::MetadataComputer; + +/// Computes a gain map from an SDR and HDR image pair. +/// +/// # Arguments +/// * `sdr_rgb` - SDR image as RGB bytes (sRGB encoded, 3 bytes per pixel) +/// * `hdr_linear` - HDR image as linear RGB floats (3 floats per pixel, [0..1] normalized) +/// * `width` - Image width +/// * `height` - Image height +/// * `target_capacity` - Target HDR capacity (typically 2.0-4.0) +/// * `gain_map_scale` - Downscale factor for gain map (1 = full size, 2 = half, etc.) +/// +/// # Returns +/// A tuple of (gain_map_bytes, metadata) where gain_map_bytes is a grayscale +/// image representing the per-pixel gain values. +pub fn compute_gain_map( + sdr_rgb: &[u8], + hdr_linear: &[f32], + width: u32, + height: u32, + target_capacity: f32, + gain_map_scale: u8, +) -> Result<(Vec, GainMapMetadata)> { + let pixel_count = (width * height) as usize; + + // Validate input sizes + if sdr_rgb.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "SDR buffer size {} doesn't match {}x{}x3 = {}", + sdr_rgb.len(), width, height, pixel_count * 3 + ))); + } + if hdr_linear.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "HDR buffer size {} doesn't match {}x{}x3 = {}", + hdr_linear.len(), width, height, pixel_count * 3 + ))); + } + + let scale = gain_map_scale.max(1) as u32; + let gm_width = (width + scale - 1) / scale; + let gm_height = (height + scale - 1) / scale; + let gm_pixel_count = (gm_width * gm_height) as usize; + + // First pass: compute statistics for metadata + let mut metadata_computer = MetadataComputer::new(); + let offset = 1.0 / 64.0; // Standard offset + + // Sample every Nth pixel for statistics (for performance) + let sample_step = ((width * height) / 10000).max(1) as usize; + + for i in (0..pixel_count).step_by(sample_step) { + let sdr_r = sdr_rgb[i * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[i * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[i * 3 + 2] as f32 / 255.0; + + // Convert SDR from sRGB to linear + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + let hdr_r = hdr_linear[i * 3]; + let hdr_g = hdr_linear[i * 3 + 1]; + let hdr_b = hdr_linear[i * 3 + 2]; + + metadata_computer.add_sample( + [sdr_lin_r, sdr_lin_g, sdr_lin_b], + [hdr_r, hdr_g, hdr_b], + offset, + offset, + ); + } + + let metadata = metadata_computer.compute(target_capacity); + + // Second pass: compute gain map + let mut gain_map = vec![0u8; gm_pixel_count]; + + for gy in 0..gm_height { + for gx in 0..gm_width { + // Sample center of the gain map pixel's coverage area + let sx = ((gx * scale + scale / 2).min(width - 1)) as usize; + let sy = ((gy * scale + scale / 2).min(height - 1)) as usize; + let src_idx = sy * width as usize + sx; + + // Get SDR values and convert to linear + let sdr_r = sdr_rgb[src_idx * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[src_idx * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[src_idx * 3 + 2] as f32 / 255.0; + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + // Get HDR values (already linear) + let hdr_r = hdr_linear[src_idx * 3]; + let hdr_g = hdr_linear[src_idx * 3 + 1]; + let hdr_b = hdr_linear[src_idx * 3 + 2]; + + // Compute gain ratio for each channel + let ratio_r = compute_gain_ratio(sdr_lin_r, hdr_r, offset, offset); + let ratio_g = compute_gain_ratio(sdr_lin_g, hdr_g, offset, offset); + let ratio_b = compute_gain_ratio(sdr_lin_b, hdr_b, offset, offset); + + // Encode gains + let gain_r = encode_gain(ratio_r, metadata.gain_map_min[0], metadata.gain_map_max[0], metadata.gamma[0]); + let gain_g = encode_gain(ratio_g, metadata.gain_map_min[1], metadata.gain_map_max[1], metadata.gamma[1]); + let gain_b = encode_gain(ratio_b, metadata.gain_map_min[2], metadata.gain_map_max[2], metadata.gamma[2]); + + // For a single-channel gain map, use luminance-weighted average + // Using BT.709 weights + let gain = 0.2126 * gain_r + 0.7152 * gain_g + 0.0722 * gain_b; + + let gm_idx = (gy * gm_width + gx) as usize; + gain_map[gm_idx] = (gain * 255.0).clamp(0.0, 255.0) as u8; + } + } + + Ok((gain_map, metadata)) +} + +/// Computes a per-channel RGB gain map for higher quality. +/// +/// Returns a gain map with 3 bytes per pixel (RGB). +pub fn compute_gain_map_rgb( + sdr_rgb: &[u8], + hdr_linear: &[f32], + width: u32, + height: u32, + target_capacity: f32, + gain_map_scale: u8, +) -> Result<(Vec, GainMapMetadata)> { + let pixel_count = (width * height) as usize; + + if sdr_rgb.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "SDR buffer size {} doesn't match {}x{}x3", + sdr_rgb.len(), width, height + ))); + } + if hdr_linear.len() != pixel_count * 3 { + return Err(UltraHdrError::InvalidDimensions(format!( + "HDR buffer size {} doesn't match {}x{}x3", + hdr_linear.len(), width, height + ))); + } + + let scale = gain_map_scale.max(1) as u32; + let gm_width = (width + scale - 1) / scale; + let gm_height = (height + scale - 1) / scale; + let gm_pixel_count = (gm_width * gm_height) as usize; + + let mut metadata_computer = MetadataComputer::new(); + let offset = 1.0 / 64.0; + + // Statistics pass + let sample_step = ((width * height) / 10000).max(1) as usize; + for i in (0..pixel_count).step_by(sample_step) { + let sdr_r = sdr_rgb[i * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[i * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[i * 3 + 2] as f32 / 255.0; + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + metadata_computer.add_sample( + [sdr_lin_r, sdr_lin_g, sdr_lin_b], + [hdr_linear[i * 3], hdr_linear[i * 3 + 1], hdr_linear[i * 3 + 2]], + offset, + offset, + ); + } + + let metadata = metadata_computer.compute(target_capacity); + + // Compute RGB gain map + let mut gain_map = vec![0u8; gm_pixel_count * 3]; + + for gy in 0..gm_height { + for gx in 0..gm_width { + let sx = ((gx * scale + scale / 2).min(width - 1)) as usize; + let sy = ((gy * scale + scale / 2).min(height - 1)) as usize; + let src_idx = sy * width as usize + sx; + + let sdr_r = sdr_rgb[src_idx * 3] as f32 / 255.0; + let sdr_g = sdr_rgb[src_idx * 3 + 1] as f32 / 255.0; + let sdr_b = sdr_rgb[src_idx * 3 + 2] as f32 / 255.0; + let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); + + let hdr_r = hdr_linear[src_idx * 3]; + let hdr_g = hdr_linear[src_idx * 3 + 1]; + let hdr_b = hdr_linear[src_idx * 3 + 2]; + + let ratio_r = compute_gain_ratio(sdr_lin_r, hdr_r, offset, offset); + let ratio_g = compute_gain_ratio(sdr_lin_g, hdr_g, offset, offset); + let ratio_b = compute_gain_ratio(sdr_lin_b, hdr_b, offset, offset); + + let gain_r = encode_gain(ratio_r, metadata.gain_map_min[0], metadata.gain_map_max[0], metadata.gamma[0]); + let gain_g = encode_gain(ratio_g, metadata.gain_map_min[1], metadata.gain_map_max[1], metadata.gamma[1]); + let gain_b = encode_gain(ratio_b, metadata.gain_map_min[2], metadata.gain_map_max[2], metadata.gamma[2]); + + let gm_idx = (gy * gm_width + gx) as usize; + gain_map[gm_idx * 3] = (gain_r * 255.0).clamp(0.0, 255.0) as u8; + gain_map[gm_idx * 3 + 1] = (gain_g * 255.0).clamp(0.0, 255.0) as u8; + gain_map[gm_idx * 3 + 2] = (gain_b * 255.0).clamp(0.0, 255.0) as u8; + } + } + + Ok((gain_map, metadata)) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_compute_gain_map_basic() { + // Create a simple 2x2 test image + let width = 2u32; + let height = 2u32; + + // SDR image (mid-gray) + let sdr = vec![128u8; 12]; // 2x2x3 + + // HDR image (brighter) + let hdr = vec![0.5f32; 12]; // 2x2x3, linear + + let result = compute_gain_map(&sdr, &hdr, width, height, 3.0, 1); + assert!(result.is_ok()); + + let (gain_map, metadata) = result.unwrap(); + assert_eq!(gain_map.len(), 4); // 2x2 grayscale + assert_eq!(metadata.version, "1.0"); + } + + #[test] + fn test_compute_gain_map_invalid_size() { + let sdr = vec![128u8; 12]; + let hdr = vec![0.5f32; 6]; // Wrong size + + let result = compute_gain_map(&sdr, &hdr, 2, 2, 3.0, 1); + assert!(result.is_err()); + } + + #[test] + fn test_compute_gain_map_with_scale() { + let width = 4u32; + let height = 4u32; + + let sdr = vec![128u8; 48]; // 4x4x3 + let hdr = vec![0.5f32; 48]; // 4x4x3 + + // Scale factor 2 should give 2x2 gain map + let (gain_map, _) = compute_gain_map(&sdr, &hdr, width, height, 3.0, 2).unwrap(); + assert_eq!(gain_map.len(), 4); // 2x2 + } +} diff --git a/packages/ultrahdr-wasm/src/gainmap/math.rs b/packages/ultrahdr-wasm/src/gainmap/math.rs new file mode 100644 index 00000000000000..2e4109e2af8718 --- /dev/null +++ b/packages/ultrahdr-wasm/src/gainmap/math.rs @@ -0,0 +1,432 @@ +//! Color space and transfer function math for gain map processing. +//! +//! Implements color space conversions and transfer functions according to +//! ISO 21496-1 and related standards (BT.709, BT.2100, Display P3). + +use crate::types::{ColorGamut, TransferFunction}; + +/// Small epsilon value to avoid division by zero. +pub const EPSILON: f32 = 1e-6; + +/// sRGB transfer function threshold. +const SRGB_THRESHOLD: f32 = 0.04045; +const SRGB_LINEAR_SCALE: f32 = 12.92; +const SRGB_GAMMA: f32 = 2.4; +const SRGB_A: f32 = 0.055; + +/// BT.2100 PQ constants. +const PQ_M1: f32 = 0.1593017578125; // 2610/16384 +const PQ_M2: f32 = 78.84375; // 2523/32 * 128 +const PQ_C1: f32 = 0.8359375; // 3424/4096 +const PQ_C2: f32 = 18.8515625; // 2413/128 * 32 +const PQ_C3: f32 = 18.6875; // 2392/128 * 32 + +/// HLG constants. +const HLG_A: f32 = 0.17883277; +const HLG_B: f32 = 0.28466892; // 1 - 4*a +const HLG_C: f32 = 0.55991073; // 0.5 - a * ln(4*a) + +/// Reference white luminance in nits for SDR. +pub const SDR_WHITE_NITS: f32 = 203.0; + +/// Maximum luminance for PQ in nits. +pub const PQ_MAX_NITS: f32 = 10000.0; + +// ============================================================================ +// sRGB Transfer Functions +// ============================================================================ + +/// Applies the sRGB OETF (Opto-Electronic Transfer Function) - linear to sRGB. +#[inline] +pub fn srgb_oetf(linear: f32) -> f32 { + if linear <= 0.0031308 { + linear * SRGB_LINEAR_SCALE + } else { + (1.0 + SRGB_A) * linear.powf(1.0 / SRGB_GAMMA) - SRGB_A + } +} + +/// Applies the inverse sRGB OETF (sRGB to linear). +#[inline] +pub fn srgb_inverse_oetf(srgb: f32) -> f32 { + if srgb <= SRGB_THRESHOLD { + srgb / SRGB_LINEAR_SCALE + } else { + ((srgb + SRGB_A) / (1.0 + SRGB_A)).powf(SRGB_GAMMA) + } +} + +/// Converts sRGB color to linear RGB. +#[inline] +pub fn srgb_to_linear(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + ( + srgb_inverse_oetf(r), + srgb_inverse_oetf(g), + srgb_inverse_oetf(b), + ) +} + +/// Converts linear RGB to sRGB. +#[inline] +pub fn linear_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + ( + srgb_oetf(r), + srgb_oetf(g), + srgb_oetf(b), + ) +} + +// ============================================================================ +// BT.2100 PQ Transfer Functions +// ============================================================================ + +/// Applies the PQ OETF (Perceptual Quantizer) - linear to PQ. +/// Input is expected to be in the range [0, 1] representing [0, 10000] nits. +#[inline] +pub fn pq_oetf(linear: f32) -> f32 { + let y = linear.max(0.0); + let y_m1 = y.powf(PQ_M1); + let numerator = PQ_C1 + PQ_C2 * y_m1; + let denominator = 1.0 + PQ_C3 * y_m1; + (numerator / denominator).powf(PQ_M2) +} + +/// Applies the inverse PQ OETF (PQ to linear). +/// Output is in the range [0, 1] representing [0, 10000] nits. +#[inline] +pub fn pq_inverse_oetf(pq: f32) -> f32 { + let pq_clamped = pq.max(0.0).min(1.0); + let pq_m2_inv = pq_clamped.powf(1.0 / PQ_M2); + let numerator = (pq_m2_inv - PQ_C1).max(0.0); + let denominator = PQ_C2 - PQ_C3 * pq_m2_inv; + if denominator <= 0.0 { + 0.0 + } else { + (numerator / denominator).powf(1.0 / PQ_M1) + } +} + +/// Converts PQ-encoded value to nits. +#[inline] +pub fn pq_to_nits(pq: f32) -> f32 { + pq_inverse_oetf(pq) * PQ_MAX_NITS +} + +/// Converts nits to PQ-encoded value. +#[inline] +pub fn nits_to_pq(nits: f32) -> f32 { + pq_oetf(nits / PQ_MAX_NITS) +} + +// ============================================================================ +// BT.2100 HLG Transfer Functions +// ============================================================================ + +/// Applies the HLG OETF (Hybrid Log-Gamma) - linear to HLG. +/// Input is expected to be scene-referred linear light. +#[inline] +pub fn hlg_oetf(linear: f32) -> f32 { + let e = linear.max(0.0); + if e <= 1.0 / 12.0 { + (3.0 * e).sqrt() + } else { + HLG_A * (12.0 * e - HLG_B).ln() + HLG_C + } +} + +/// Applies the inverse HLG OETF (HLG to linear). +#[inline] +pub fn hlg_inverse_oetf(hlg: f32) -> f32 { + let hlg_clamped = hlg.max(0.0).min(1.0); + if hlg_clamped <= 0.5 { + hlg_clamped * hlg_clamped / 3.0 + } else { + (((hlg_clamped - HLG_C) / HLG_A).exp() + HLG_B) / 12.0 + } +} + +// ============================================================================ +// Luminance Calculations +// ============================================================================ + +/// BT.709 luminance coefficients (also used for sRGB). +pub const LUMA_R_BT709: f32 = 0.2126; +pub const LUMA_G_BT709: f32 = 0.7152; +pub const LUMA_B_BT709: f32 = 0.0722; + +/// BT.2020 luminance coefficients. +pub const LUMA_R_BT2020: f32 = 0.2627; +pub const LUMA_G_BT2020: f32 = 0.6780; +pub const LUMA_B_BT2020: f32 = 0.0593; + +/// Display P3 luminance coefficients (same primaries as DCI-P3 but D65 white). +pub const LUMA_R_P3: f32 = 0.2289; +pub const LUMA_G_P3: f32 = 0.6917; +pub const LUMA_B_P3: f32 = 0.0793; + +/// Calculates luminance from linear RGB using BT.709 coefficients. +#[inline] +pub fn luminance_bt709(r: f32, g: f32, b: f32) -> f32 { + LUMA_R_BT709 * r + LUMA_G_BT709 * g + LUMA_B_BT709 * b +} + +/// Calculates luminance from linear RGB using BT.2020 coefficients. +#[inline] +pub fn luminance_bt2020(r: f32, g: f32, b: f32) -> f32 { + LUMA_R_BT2020 * r + LUMA_G_BT2020 * g + LUMA_B_BT2020 * b +} + +/// Calculates luminance from linear RGB using Display P3 coefficients. +#[inline] +pub fn luminance_p3(r: f32, g: f32, b: f32) -> f32 { + LUMA_R_P3 * r + LUMA_G_P3 * g + LUMA_B_P3 * b +} + +/// Calculates luminance based on color gamut. +#[inline] +pub fn luminance(r: f32, g: f32, b: f32, gamut: ColorGamut) -> f32 { + match gamut { + ColorGamut::Srgb => luminance_bt709(r, g, b), + ColorGamut::DisplayP3 => luminance_p3(r, g, b), + ColorGamut::Bt2100 => luminance_bt2020(r, g, b), + } +} + +// ============================================================================ +// Color Space Conversions +// ============================================================================ + +/// sRGB to XYZ matrix (D65 illuminant). +#[rustfmt::skip] +pub const SRGB_TO_XYZ: [[f32; 3]; 3] = [ + [0.4124564, 0.3575761, 0.1804375], + [0.2126729, 0.7151522, 0.0721750], + [0.0193339, 0.1191920, 0.9503041], +]; + +/// XYZ to sRGB matrix (D65 illuminant). +#[rustfmt::skip] +pub const XYZ_TO_SRGB: [[f32; 3]; 3] = [ + [ 3.2404542, -1.5371385, -0.4985314], + [-0.9692660, 1.8760108, 0.0415560], + [ 0.0556434, -0.2040259, 1.0572252], +]; + +/// Display P3 to XYZ matrix (D65 illuminant). +#[rustfmt::skip] +pub const P3_TO_XYZ: [[f32; 3]; 3] = [ + [0.4865709, 0.2656677, 0.1982173], + [0.2289746, 0.6917385, 0.0792869], + [0.0000000, 0.0451134, 1.0439444], +]; + +/// XYZ to Display P3 matrix (D65 illuminant). +#[rustfmt::skip] +pub const XYZ_TO_P3: [[f32; 3]; 3] = [ + [ 2.4934969, -0.9313836, -0.4027108], + [-0.8294890, 1.7626641, 0.0236247], + [ 0.0358458, -0.0761724, 0.9568845], +]; + +/// BT.2020 to XYZ matrix (D65 illuminant). +#[rustfmt::skip] +pub const BT2020_TO_XYZ: [[f32; 3]; 3] = [ + [0.6369580, 0.1446169, 0.1688810], + [0.2627002, 0.6779981, 0.0593017], + [0.0000000, 0.0280727, 1.0609851], +]; + +/// XYZ to BT.2020 matrix (D65 illuminant). +#[rustfmt::skip] +pub const XYZ_TO_BT2020: [[f32; 3]; 3] = [ + [ 1.7166512, -0.3556708, -0.2533663], + [-0.6666844, 1.6164812, 0.0157685], + [ 0.0176399, -0.0427706, 0.9421031], +]; + +/// Applies a 3x3 color matrix to RGB values. +#[inline] +pub fn apply_matrix(r: f32, g: f32, b: f32, matrix: &[[f32; 3]; 3]) -> (f32, f32, f32) { + ( + matrix[0][0] * r + matrix[0][1] * g + matrix[0][2] * b, + matrix[1][0] * r + matrix[1][1] * g + matrix[1][2] * b, + matrix[2][0] * r + matrix[2][1] * g + matrix[2][2] * b, + ) +} + +/// Converts sRGB to Display P3 (both in linear space). +pub fn srgb_to_p3(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + let xyz = apply_matrix(r, g, b, &SRGB_TO_XYZ); + apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_P3) +} + +/// Converts Display P3 to sRGB (both in linear space). +pub fn p3_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + let xyz = apply_matrix(r, g, b, &P3_TO_XYZ); + apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_SRGB) +} + +/// Converts sRGB to BT.2020 (both in linear space). +pub fn srgb_to_bt2020(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + let xyz = apply_matrix(r, g, b, &SRGB_TO_XYZ); + apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_BT2020) +} + +/// Converts BT.2020 to sRGB (both in linear space). +pub fn bt2020_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { + let xyz = apply_matrix(r, g, b, &BT2020_TO_XYZ); + apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_SRGB) +} + +// ============================================================================ +// Transfer Function Application +// ============================================================================ + +/// Applies a transfer function to linear RGB values. +pub fn apply_transfer_function(r: f32, g: f32, b: f32, tf: TransferFunction) -> (f32, f32, f32) { + match tf { + TransferFunction::Srgb => linear_to_srgb(r, g, b), + TransferFunction::Linear => (r, g, b), + TransferFunction::Pq => (pq_oetf(r), pq_oetf(g), pq_oetf(b)), + TransferFunction::Hlg => (hlg_oetf(r), hlg_oetf(g), hlg_oetf(b)), + } +} + +/// Applies inverse transfer function to get linear RGB. +pub fn inverse_transfer_function(r: f32, g: f32, b: f32, tf: TransferFunction) -> (f32, f32, f32) { + match tf { + TransferFunction::Srgb => srgb_to_linear(r, g, b), + TransferFunction::Linear => (r, g, b), + TransferFunction::Pq => (pq_inverse_oetf(r), pq_inverse_oetf(g), pq_inverse_oetf(b)), + TransferFunction::Hlg => (hlg_inverse_oetf(r), hlg_inverse_oetf(g), hlg_inverse_oetf(b)), + } +} + +// ============================================================================ +// Gain Map Specific Math +// ============================================================================ + +/// Encodes a gain value to the [0, 1] range using the gain map formula. +/// +/// gain_encoded = ((log2(ratio) - min_log2) / (max_log2 - min_log2)) ^ (1/gamma) +#[inline] +pub fn encode_gain(ratio: f32, min_gain: f32, max_gain: f32, gamma: f32) -> f32 { + let log_ratio = ratio.max(EPSILON).log2(); + let normalized = (log_ratio - min_gain) / (max_gain - min_gain).max(EPSILON); + normalized.clamp(0.0, 1.0).powf(1.0 / gamma) +} + +/// Decodes a gain value from the [0, 1] range. +/// +/// ratio = 2 ^ (gain_decoded ^ gamma * (max_log2 - min_log2) + min_log2) +#[inline] +pub fn decode_gain(encoded: f32, min_gain: f32, max_gain: f32, gamma: f32) -> f32 { + let degamma = encoded.powf(gamma); + let log_ratio = degamma * (max_gain - min_gain) + min_gain; + 2.0_f32.powf(log_ratio) +} + +/// Applies gain to a pixel value with offset adjustment. +/// +/// output = (input + offset_sdr) * gain - offset_hdr +#[inline] +pub fn apply_gain_to_pixel(input: f32, gain: f32, offset_sdr: f32, offset_hdr: f32) -> f32 { + ((input + offset_sdr) * gain - offset_hdr).max(0.0) +} + +/// Computes the gain ratio between HDR and SDR pixel values. +/// +/// ratio = (hdr + offset_hdr) / (sdr + offset_sdr) +#[inline] +pub fn compute_gain_ratio(sdr: f32, hdr: f32, offset_sdr: f32, offset_hdr: f32) -> f32 { + (hdr + offset_hdr) / (sdr + offset_sdr).max(EPSILON) +} + +/// Interpolates between SDR and HDR based on display HDR capacity. +/// +/// weight = clamp((display_capacity - capacity_min) / (capacity_max - capacity_min), 0, 1) +#[inline] +pub fn compute_hdr_weight(display_capacity: f32, capacity_min: f32, capacity_max: f32) -> f32 { + if capacity_max <= capacity_min { + return 1.0; + } + ((display_capacity - capacity_min) / (capacity_max - capacity_min)).clamp(0.0, 1.0) +} + +#[cfg(test)] +mod tests { + use super::*; + + const TOLERANCE: f32 = 1e-5; + + fn approx_eq(a: f32, b: f32) -> bool { + (a - b).abs() < TOLERANCE + } + + #[test] + fn test_srgb_roundtrip() { + for i in 0..=100 { + let linear = i as f32 / 100.0; + let srgb = srgb_oetf(linear); + let back = srgb_inverse_oetf(srgb); + assert!(approx_eq(linear, back), "Failed at {}: {} vs {}", linear, linear, back); + } + } + + #[test] + fn test_pq_roundtrip() { + // PQ uses complex power functions with large exponents, so allow slightly larger tolerance + const PQ_TOLERANCE: f32 = 1e-4; + for i in 0..=100 { + let linear = i as f32 / 100.0; + let pq = pq_oetf(linear); + let back = pq_inverse_oetf(pq); + assert!((linear - back).abs() < PQ_TOLERANCE, "Failed at {}: {} vs {}", linear, linear, back); + } + } + + #[test] + fn test_hlg_roundtrip() { + for i in 0..=100 { + let linear = i as f32 / 100.0; + let hlg = hlg_oetf(linear); + let back = hlg_inverse_oetf(hlg); + assert!(approx_eq(linear, back), "Failed at {}: {} vs {}", linear, linear, back); + } + } + + #[test] + fn test_luminance_black() { + assert_eq!(luminance_bt709(0.0, 0.0, 0.0), 0.0); + } + + #[test] + fn test_luminance_white() { + let luma = luminance_bt709(1.0, 1.0, 1.0); + assert!(approx_eq(luma, 1.0)); + } + + #[test] + fn test_gain_encode_decode_roundtrip() { + let ratios = [0.5, 1.0, 2.0, 4.0, 8.0]; + let min_gain = -1.0; + let max_gain = 3.0; + let gamma = 1.0; + + for &ratio in &ratios { + let encoded = encode_gain(ratio, min_gain, max_gain, gamma); + let decoded = decode_gain(encoded, min_gain, max_gain, gamma); + assert!(approx_eq(ratio, decoded), "Failed at {}: {} vs {}", ratio, ratio, decoded); + } + } + + #[test] + fn test_hdr_weight_calculation() { + // Full SDR + assert_eq!(compute_hdr_weight(0.0, 0.0, 3.0), 0.0); + // Full HDR + assert_eq!(compute_hdr_weight(3.0, 0.0, 3.0), 1.0); + // Mid point + assert!(approx_eq(compute_hdr_weight(1.5, 0.0, 3.0), 0.5)); + } +} diff --git a/packages/ultrahdr-wasm/src/gainmap/metadata.rs b/packages/ultrahdr-wasm/src/gainmap/metadata.rs new file mode 100644 index 00000000000000..2d08579b596014 --- /dev/null +++ b/packages/ultrahdr-wasm/src/gainmap/metadata.rs @@ -0,0 +1,223 @@ +//! Gain map metadata processing. +//! +//! Provides utilities for working with ISO 21496-1 gain map metadata. + +use crate::error::{Result, UltraHdrError}; +use crate::types::GainMapMetadata; + +/// Validates gain map metadata for correctness. +pub fn validate_metadata(metadata: &GainMapMetadata) -> Result<()> { + // Validate channel counts + if metadata.gain_map_min.len() != 3 { + return Err(UltraHdrError::MetadataError( + format!("gain_map_min must have 3 values, got {}", metadata.gain_map_min.len()) + )); + } + if metadata.gain_map_max.len() != 3 { + return Err(UltraHdrError::MetadataError( + format!("gain_map_max must have 3 values, got {}", metadata.gain_map_max.len()) + )); + } + if metadata.gamma.len() != 3 { + return Err(UltraHdrError::MetadataError( + format!("gamma must have 3 values, got {}", metadata.gamma.len()) + )); + } + if metadata.offset_sdr.len() != 3 { + return Err(UltraHdrError::MetadataError( + format!("offset_sdr must have 3 values, got {}", metadata.offset_sdr.len()) + )); + } + if metadata.offset_hdr.len() != 3 { + return Err(UltraHdrError::MetadataError( + format!("offset_hdr must have 3 values, got {}", metadata.offset_hdr.len()) + )); + } + + // Validate gain range + for i in 0..3 { + if metadata.gain_map_min[i] > metadata.gain_map_max[i] { + return Err(UltraHdrError::MetadataError( + format!("gain_map_min[{}] ({}) > gain_map_max[{}] ({})", + i, metadata.gain_map_min[i], i, metadata.gain_map_max[i]) + )); + } + } + + // Validate gamma (must be positive) + for (i, &g) in metadata.gamma.iter().enumerate() { + if g <= 0.0 { + return Err(UltraHdrError::MetadataError( + format!("gamma[{}] must be positive, got {}", i, g) + )); + } + } + + // Validate HDR capacity range + if metadata.hdr_capacity_min > metadata.hdr_capacity_max { + return Err(UltraHdrError::InvalidHdrCapacity( + metadata.hdr_capacity_min, + metadata.hdr_capacity_max, + )); + } + + Ok(()) +} + +/// Computes optimal metadata parameters from SDR and HDR image statistics. +pub struct MetadataComputer { + /// Accumulated minimum gain ratios per channel + min_ratios: [f32; 3], + /// Accumulated maximum gain ratios per channel + max_ratios: [f32; 3], + /// Sample count + sample_count: usize, +} + +impl MetadataComputer { + /// Creates a new metadata computer. + pub fn new() -> Self { + Self { + min_ratios: [f32::MAX, f32::MAX, f32::MAX], + max_ratios: [f32::MIN, f32::MIN, f32::MIN], + sample_count: 0, + } + } + + /// Adds a sample of SDR and HDR pixel values. + pub fn add_sample(&mut self, sdr: [f32; 3], hdr: [f32; 3], offset_sdr: f32, offset_hdr: f32) { + for i in 0..3 { + let ratio = (hdr[i] + offset_hdr) / (sdr[i] + offset_sdr).max(super::math::EPSILON); + if ratio > 0.0 && ratio.is_finite() { + let log_ratio = ratio.log2(); + self.min_ratios[i] = self.min_ratios[i].min(log_ratio); + self.max_ratios[i] = self.max_ratios[i].max(log_ratio); + } + } + self.sample_count += 1; + } + + /// Computes the final metadata from accumulated samples. + pub fn compute(&self, target_capacity: f32) -> GainMapMetadata { + let offset = 1.0 / 64.0; // Standard offset value + + // Compute gain range with some margin + let mut min_gain = [0.0f32; 3]; + let mut max_gain = [target_capacity; 3]; + + for i in 0..3 { + if self.min_ratios[i] < f32::MAX { + min_gain[i] = (self.min_ratios[i] - 0.1).max(-2.0); + } + if self.max_ratios[i] > f32::MIN { + max_gain[i] = (self.max_ratios[i] + 0.1).min(target_capacity + 1.0); + } + } + + GainMapMetadata { + version: "1.0".to_string(), + base_rendition_is_hdr: false, + gain_map_min: min_gain.to_vec(), + gain_map_max: max_gain.to_vec(), + gamma: vec![1.0, 1.0, 1.0], + offset_sdr: vec![offset, offset, offset], + offset_hdr: vec![offset, offset, offset], + hdr_capacity_min: 0.0, + hdr_capacity_max: target_capacity, + } + } +} + +impl Default for MetadataComputer { + fn default() -> Self { + Self::new() + } +} + +/// Estimates the HDR headroom from metadata. +/// +/// Returns the maximum additional stops of dynamic range above SDR. +pub fn estimate_hdr_headroom(metadata: &GainMapMetadata) -> f32 { + let max_gain = metadata.gain_map_max.iter() + .copied() + .fold(f32::MIN, f32::max); + max_gain.max(0.0) +} + +/// Checks if metadata indicates a meaningful HDR image. +/// +/// Returns true if the gain map provides significant dynamic range extension. +pub fn is_meaningful_hdr(metadata: &GainMapMetadata) -> bool { + let headroom = estimate_hdr_headroom(metadata); + headroom > 0.5 // More than half a stop of additional range +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_validate_metadata_valid() { + let metadata = GainMapMetadata::default(); + assert!(validate_metadata(&metadata).is_ok()); + } + + #[test] + fn test_validate_metadata_invalid_channel_count() { + let mut metadata = GainMapMetadata::default(); + metadata.gain_map_min = vec![0.0, 0.0]; // Only 2 values + assert!(validate_metadata(&metadata).is_err()); + } + + #[test] + fn test_validate_metadata_invalid_gain_range() { + let mut metadata = GainMapMetadata::default(); + metadata.gain_map_min = vec![5.0, 5.0, 5.0]; + metadata.gain_map_max = vec![3.0, 3.0, 3.0]; // min > max + assert!(validate_metadata(&metadata).is_err()); + } + + #[test] + fn test_validate_metadata_invalid_gamma() { + let mut metadata = GainMapMetadata::default(); + metadata.gamma = vec![1.0, -1.0, 1.0]; // Negative gamma + assert!(validate_metadata(&metadata).is_err()); + } + + #[test] + fn test_metadata_computer() { + let mut computer = MetadataComputer::new(); + + // Add some samples + computer.add_sample([0.5, 0.5, 0.5], [1.0, 1.0, 1.0], 0.015625, 0.015625); + computer.add_sample([0.3, 0.3, 0.3], [0.9, 0.9, 0.9], 0.015625, 0.015625); + + let metadata = computer.compute(3.0); + assert_eq!(metadata.version, "1.0"); + assert!(!metadata.base_rendition_is_hdr); + } + + #[test] + fn test_estimate_hdr_headroom() { + let metadata = GainMapMetadata { + gain_map_max: vec![3.0, 3.0, 3.0], + ..Default::default() + }; + assert_eq!(estimate_hdr_headroom(&metadata), 3.0); + } + + #[test] + fn test_is_meaningful_hdr() { + let low_hdr = GainMapMetadata { + gain_map_max: vec![0.2, 0.2, 0.2], + ..Default::default() + }; + assert!(!is_meaningful_hdr(&low_hdr)); + + let high_hdr = GainMapMetadata { + gain_map_max: vec![3.0, 3.0, 3.0], + ..Default::default() + }; + assert!(is_meaningful_hdr(&high_hdr)); + } +} diff --git a/packages/ultrahdr-wasm/src/gainmap/mod.rs b/packages/ultrahdr-wasm/src/gainmap/mod.rs new file mode 100644 index 00000000000000..88f125b13635c9 --- /dev/null +++ b/packages/ultrahdr-wasm/src/gainmap/mod.rs @@ -0,0 +1,13 @@ +//! Gain map processing module. +//! +//! Implements ISO 21496-1 gain map computation and application. + +pub mod math; +pub mod metadata; +pub mod encode; +pub mod decode; + +pub use math::*; +pub use metadata::*; +pub use encode::compute_gain_map; +pub use decode::apply_gain_map; diff --git a/packages/ultrahdr-wasm/src/jpeg/mod.rs b/packages/ultrahdr-wasm/src/jpeg/mod.rs new file mode 100644 index 00000000000000..200e6316a9d6e2 --- /dev/null +++ b/packages/ultrahdr-wasm/src/jpeg/mod.rs @@ -0,0 +1,14 @@ +//! JPEG parsing and manipulation module. +//! +//! This module handles parsing and writing JPEG files, including: +//! - APP1 (Exif, XMP) segments +//! - APP2 (ICC profile, Extended XMP) segments +//! - MPF (Multi-Picture Format) for gain map storage + +pub mod parser; +pub mod writer; +pub mod xmp; + +pub use parser::{JpegParser, JpegSegment, MarkerType}; +pub use writer::JpegWriter; +pub use xmp::{XmpParser, XmpWriter}; diff --git a/packages/ultrahdr-wasm/src/jpeg/parser.rs b/packages/ultrahdr-wasm/src/jpeg/parser.rs new file mode 100644 index 00000000000000..cd893cbba433ee --- /dev/null +++ b/packages/ultrahdr-wasm/src/jpeg/parser.rs @@ -0,0 +1,394 @@ +//! JPEG segment parser. +//! +//! Parses JPEG files to extract APP1, APP2, and other relevant segments +//! for UltraHDR processing. + +use crate::error::{Result, UltraHdrError}; +use std::io::{Cursor, Read}; + +/// JPEG marker types. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MarkerType { + /// Start of Image + Soi, + /// End of Image + Eoi, + /// APP0 (JFIF) + App0, + /// APP1 (Exif, XMP) + App1, + /// APP2 (ICC profile, Extended XMP, MPF) + App2, + /// APP3-APP15 + AppN(u8), + /// Start of Frame (Baseline DCT) + Sof0, + /// Start of Frame (Progressive DCT) + Sof2, + /// Define Huffman Table + Dht, + /// Define Quantization Table + Dqt, + /// Define Restart Interval + Dri, + /// Start of Scan + Sos, + /// Comment + Com, + /// Other marker + Other(u8), +} + +impl MarkerType { + /// Creates a MarkerType from a byte value. + pub fn from_byte(byte: u8) -> Self { + match byte { + 0xD8 => MarkerType::Soi, + 0xD9 => MarkerType::Eoi, + 0xE0 => MarkerType::App0, + 0xE1 => MarkerType::App1, + 0xE2 => MarkerType::App2, + 0xE3..=0xEF => MarkerType::AppN(byte - 0xE0), + 0xC0 => MarkerType::Sof0, + 0xC2 => MarkerType::Sof2, + 0xC4 => MarkerType::Dht, + 0xDB => MarkerType::Dqt, + 0xDD => MarkerType::Dri, + 0xDA => MarkerType::Sos, + 0xFE => MarkerType::Com, + _ => MarkerType::Other(byte), + } + } + + /// Converts the marker type to its byte value. + pub fn to_byte(&self) -> u8 { + match self { + MarkerType::Soi => 0xD8, + MarkerType::Eoi => 0xD9, + MarkerType::App0 => 0xE0, + MarkerType::App1 => 0xE1, + MarkerType::App2 => 0xE2, + MarkerType::AppN(n) => 0xE0 + n, + MarkerType::Sof0 => 0xC0, + MarkerType::Sof2 => 0xC2, + MarkerType::Dht => 0xC4, + MarkerType::Dqt => 0xDB, + MarkerType::Dri => 0xDD, + MarkerType::Sos => 0xDA, + MarkerType::Com => 0xFE, + MarkerType::Other(b) => *b, + } + } + + /// Returns true if this marker has an associated length field. + pub fn has_length(&self) -> bool { + !matches!(self, MarkerType::Soi | MarkerType::Eoi | MarkerType::Other(0x00) | MarkerType::Other(0xFF)) + } +} + +/// A JPEG segment with marker and data. +#[derive(Debug, Clone)] +pub struct JpegSegment { + /// The marker type + pub marker: MarkerType, + /// The segment data (excluding marker and length bytes) + pub data: Vec, + /// Original offset in the file + pub offset: usize, +} + +impl JpegSegment { + /// Creates a new JPEG segment. + pub fn new(marker: MarkerType, data: Vec, offset: usize) -> Self { + Self { marker, data, offset } + } + + /// Checks if this segment contains XMP data. + pub fn is_xmp(&self) -> bool { + if self.marker != MarkerType::App1 { + return false; + } + self.data.starts_with(b"http://ns.adobe.com/xap/1.0/\0") + } + + /// Checks if this segment contains Extended XMP data. + pub fn is_extended_xmp(&self) -> bool { + if self.marker != MarkerType::App1 { + return false; + } + self.data.starts_with(b"http://ns.adobe.com/xmp/extension/\0") + } + + /// Checks if this segment contains Exif data. + pub fn is_exif(&self) -> bool { + if self.marker != MarkerType::App1 { + return false; + } + self.data.starts_with(b"Exif\0\0") + } + + /// Checks if this segment contains an ICC profile. + pub fn is_icc_profile(&self) -> bool { + if self.marker != MarkerType::App2 { + return false; + } + self.data.starts_with(b"ICC_PROFILE\0") + } + + /// Checks if this segment is an MPF (Multi-Picture Format) segment. + pub fn is_mpf(&self) -> bool { + if self.marker != MarkerType::App2 { + return false; + } + self.data.starts_with(b"MPF\0") + } + + /// Gets the XMP data if this is an XMP segment. + pub fn get_xmp_data(&self) -> Option<&[u8]> { + if !self.is_xmp() { + return None; + } + // Skip "http://ns.adobe.com/xap/1.0/\0" (29 bytes) + Some(&self.data[29..]) + } +} + +/// JPEG file parser. +pub struct JpegParser { + segments: Vec, + scan_data: Vec, + scan_offset: usize, +} + +impl JpegParser { + /// Parses a JPEG file from a byte buffer. + pub fn parse(data: &[u8]) -> Result { + if data.len() < 2 { + return Err(UltraHdrError::InvalidJpeg("File too small".to_string())); + } + + // Check for JPEG magic bytes + if data[0] != 0xFF || data[1] != 0xD8 { + return Err(UltraHdrError::InvalidJpeg("Missing JPEG SOI marker".to_string())); + } + + let mut segments = Vec::new(); + let mut cursor = Cursor::new(data); + let mut scan_data = Vec::new(); + let mut scan_offset = 0; + + // Add SOI segment + segments.push(JpegSegment::new(MarkerType::Soi, Vec::new(), 0)); + cursor.set_position(2); + + loop { + let pos = cursor.position() as usize; + if pos >= data.len() { + break; + } + + // Look for marker + let mut marker_byte = [0u8; 1]; + if cursor.read_exact(&mut marker_byte).is_err() { + break; + } + + if marker_byte[0] != 0xFF { + // Not a marker, might be in scan data + continue; + } + + // Skip padding 0xFF bytes + loop { + if cursor.read_exact(&mut marker_byte).is_err() { + break; + } + if marker_byte[0] != 0xFF { + break; + } + } + + let marker = MarkerType::from_byte(marker_byte[0]); + + match marker { + MarkerType::Eoi => { + segments.push(JpegSegment::new(MarkerType::Eoi, Vec::new(), cursor.position() as usize - 2)); + break; + } + MarkerType::Soi => { + // Shouldn't happen, but handle it + continue; + } + MarkerType::Sos => { + // Start of Scan - read length and data + let mut len_bytes = [0u8; 2]; + cursor.read_exact(&mut len_bytes)?; + let len = u16::from_be_bytes(len_bytes) as usize; + + let mut segment_data = vec![0u8; len - 2]; + cursor.read_exact(&mut segment_data)?; + + segments.push(JpegSegment::new(MarkerType::Sos, segment_data, pos)); + + // After SOS comes the entropy-coded data + scan_offset = cursor.position() as usize; + + // Read until we find EOI or another marker + let mut in_scan = true; + while in_scan && (cursor.position() as usize) < data.len() { + let mut byte = [0u8; 1]; + if cursor.read_exact(&mut byte).is_err() { + break; + } + + if byte[0] == 0xFF { + if cursor.read_exact(&mut byte).is_err() { + break; + } + + if byte[0] == 0x00 { + // Stuffed byte, part of scan data + scan_data.push(0xFF); + scan_data.push(0x00); + } else if byte[0] == 0xD9 { + // EOI + segments.push(JpegSegment::new(MarkerType::Eoi, Vec::new(), cursor.position() as usize - 2)); + in_scan = false; + } else if byte[0] >= 0xD0 && byte[0] <= 0xD7 { + // Restart marker + scan_data.push(0xFF); + scan_data.push(byte[0]); + } else { + // Another marker - back up + cursor.set_position(cursor.position() - 2); + in_scan = false; + } + } else { + scan_data.push(byte[0]); + } + } + } + _ if marker.has_length() => { + // Read length and data + let mut len_bytes = [0u8; 2]; + cursor.read_exact(&mut len_bytes)?; + let len = u16::from_be_bytes(len_bytes) as usize; + + if len < 2 { + return Err(UltraHdrError::InvalidJpeg(format!( + "Invalid segment length {} at offset {}", + len, pos + ))); + } + + let mut segment_data = vec![0u8; len - 2]; + cursor.read_exact(&mut segment_data)?; + + segments.push(JpegSegment::new(marker, segment_data, pos)); + } + _ => { + // Marker without length + segments.push(JpegSegment::new(marker, Vec::new(), pos)); + } + } + } + + Ok(Self { + segments, + scan_data, + scan_offset, + }) + } + + /// Returns all segments. + pub fn segments(&self) -> &[JpegSegment] { + &self.segments + } + + /// Returns the scan data (entropy-coded image data). + pub fn scan_data(&self) -> &[u8] { + &self.scan_data + } + + /// Returns the scan data offset in the original file. + pub fn scan_offset(&self) -> usize { + self.scan_offset + } + + /// Finds all APP1 segments. + pub fn find_app1_segments(&self) -> Vec<&JpegSegment> { + self.segments + .iter() + .filter(|s| s.marker == MarkerType::App1) + .collect() + } + + /// Finds all APP2 segments. + pub fn find_app2_segments(&self) -> Vec<&JpegSegment> { + self.segments + .iter() + .filter(|s| s.marker == MarkerType::App2) + .collect() + } + + /// Finds the XMP segment. + pub fn find_xmp_segment(&self) -> Option<&JpegSegment> { + self.segments.iter().find(|s| s.is_xmp()) + } + + /// Finds the Exif segment. + pub fn find_exif_segment(&self) -> Option<&JpegSegment> { + self.segments.iter().find(|s| s.is_exif()) + } + + /// Finds the MPF segment. + pub fn find_mpf_segment(&self) -> Option<&JpegSegment> { + self.segments.iter().find(|s| s.is_mpf()) + } + + /// Finds the SOF (Start of Frame) segment to get image dimensions. + pub fn find_sof_segment(&self) -> Option<&JpegSegment> { + self.segments + .iter() + .find(|s| matches!(s.marker, MarkerType::Sof0 | MarkerType::Sof2)) + } + + /// Gets image dimensions from the SOF segment. + pub fn get_dimensions(&self) -> Option<(u32, u32)> { + let sof = self.find_sof_segment()?; + if sof.data.len() < 5 { + return None; + } + let height = u16::from_be_bytes([sof.data[1], sof.data[2]]) as u32; + let width = u16::from_be_bytes([sof.data[3], sof.data[4]]) as u32; + Some((width, height)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_marker_type_conversion() { + assert_eq!(MarkerType::from_byte(0xD8), MarkerType::Soi); + assert_eq!(MarkerType::from_byte(0xE1), MarkerType::App1); + assert_eq!(MarkerType::App1.to_byte(), 0xE1); + } + + #[test] + fn test_minimal_jpeg() { + // Minimal valid JPEG: SOI + EOI + let data = vec![0xFF, 0xD8, 0xFF, 0xD9]; + let parser = JpegParser::parse(&data).unwrap(); + assert_eq!(parser.segments().len(), 2); + assert_eq!(parser.segments()[0].marker, MarkerType::Soi); + assert_eq!(parser.segments()[1].marker, MarkerType::Eoi); + } + + #[test] + fn test_invalid_jpeg() { + let data = vec![0x00, 0x00]; + assert!(JpegParser::parse(&data).is_err()); + } +} diff --git a/packages/ultrahdr-wasm/src/jpeg/writer.rs b/packages/ultrahdr-wasm/src/jpeg/writer.rs new file mode 100644 index 00000000000000..b6934b6b0606b3 --- /dev/null +++ b/packages/ultrahdr-wasm/src/jpeg/writer.rs @@ -0,0 +1,284 @@ +//! JPEG segment writer. +//! +//! Writes JPEG files with modified or added segments for UltraHDR. + +use crate::error::{Result, UltraHdrError}; +use super::parser::{JpegSegment, MarkerType}; +use std::io::Write; + +/// JPEG file writer for creating UltraHDR images. +pub struct JpegWriter { + segments: Vec, + scan_data: Vec, +} + +impl JpegWriter { + /// Creates a new JPEG writer with segments from a parsed JPEG. + pub fn new(segments: Vec, scan_data: Vec) -> Self { + Self { segments, scan_data } + } + + /// Creates an empty JPEG writer. + pub fn empty() -> Self { + Self { + segments: Vec::new(), + scan_data: Vec::new(), + } + } + + /// Adds a segment to the JPEG. + pub fn add_segment(&mut self, segment: JpegSegment) { + self.segments.push(segment); + } + + /// Inserts a segment at a specific index. + pub fn insert_segment(&mut self, index: usize, segment: JpegSegment) { + self.segments.insert(index, segment); + } + + /// Adds an XMP segment with the given XMP data. + pub fn add_xmp_segment(&mut self, xmp_data: &[u8]) -> Result<()> { + const XMP_NAMESPACE: &[u8] = b"http://ns.adobe.com/xap/1.0/\0"; + + if xmp_data.len() + XMP_NAMESPACE.len() > 65533 { + return Err(UltraHdrError::XmpError( + "XMP data too large for single segment".to_string() + )); + } + + let mut data = Vec::with_capacity(XMP_NAMESPACE.len() + xmp_data.len()); + data.extend_from_slice(XMP_NAMESPACE); + data.extend_from_slice(xmp_data); + + let segment = JpegSegment::new(MarkerType::App1, data, 0); + + // Insert after JFIF/Exif but before other segments + let insert_pos = self.find_xmp_insert_position(); + self.insert_segment(insert_pos, segment); + + Ok(()) + } + + /// Adds an Extended XMP segment. + pub fn add_extended_xmp_segment(&mut self, xmp_data: &[u8], md5_digest: &str, offset: u32, total_length: u32) -> Result<()> { + const EXT_XMP_NAMESPACE: &[u8] = b"http://ns.adobe.com/xmp/extension/\0"; + + let mut data = Vec::with_capacity(EXT_XMP_NAMESPACE.len() + 32 + 8 + xmp_data.len()); + data.extend_from_slice(EXT_XMP_NAMESPACE); + + // MD5 digest (32 bytes hex string) + data.extend_from_slice(md5_digest.as_bytes()); + + // Full length of extended XMP (4 bytes, big-endian) + data.extend_from_slice(&total_length.to_be_bytes()); + + // Offset of this chunk (4 bytes, big-endian) + data.extend_from_slice(&offset.to_be_bytes()); + + // XMP data + data.extend_from_slice(xmp_data); + + let segment = JpegSegment::new(MarkerType::App1, data, 0); + + // Insert after regular XMP + let insert_pos = self.find_extended_xmp_insert_position(); + self.insert_segment(insert_pos, segment); + + Ok(()) + } + + /// Adds an MPF (Multi-Picture Format) segment for the gain map. + pub fn add_mpf_segment(&mut self, gain_map_offset: u32, gain_map_size: u32) -> Result<()> { + let mpf_data = create_mpf_data(gain_map_offset, gain_map_size); + let segment = JpegSegment::new(MarkerType::App2, mpf_data, 0); + + // Insert MPF after APP1 segments + let insert_pos = self.find_mpf_insert_position(); + self.insert_segment(insert_pos, segment); + + Ok(()) + } + + /// Removes all XMP segments. + pub fn remove_xmp_segments(&mut self) { + self.segments.retain(|s| !s.is_xmp() && !s.is_extended_xmp()); + } + + /// Removes all MPF segments. + pub fn remove_mpf_segments(&mut self) { + self.segments.retain(|s| !s.is_mpf()); + } + + /// Sets the scan data. + pub fn set_scan_data(&mut self, data: Vec) { + self.scan_data = data; + } + + /// Writes the JPEG to a byte vector. + pub fn write(&self) -> Result> { + let mut output = Vec::new(); + + // Write SOI + output.write_all(&[0xFF, 0xD8])?; + + for segment in &self.segments { + match segment.marker { + MarkerType::Soi | MarkerType::Eoi => { + // These are handled separately + continue; + } + MarkerType::Sos => { + // Write SOS marker + output.write_all(&[0xFF, segment.marker.to_byte()])?; + let len = (segment.data.len() + 2) as u16; + output.write_all(&len.to_be_bytes())?; + output.write_all(&segment.data)?; + + // Write scan data + output.write_all(&self.scan_data)?; + } + _ if segment.marker.has_length() => { + output.write_all(&[0xFF, segment.marker.to_byte()])?; + let len = (segment.data.len() + 2) as u16; + output.write_all(&len.to_be_bytes())?; + output.write_all(&segment.data)?; + } + _ => { + output.write_all(&[0xFF, segment.marker.to_byte()])?; + } + } + } + + // Write EOI + output.write_all(&[0xFF, 0xD9])?; + + Ok(output) + } + + /// Writes the JPEG with an appended gain map. + pub fn write_with_gain_map(&self, gain_map_jpeg: &[u8]) -> Result> { + let base_jpeg = self.write()?; + + let mut output = Vec::with_capacity(base_jpeg.len() + gain_map_jpeg.len()); + output.extend_from_slice(&base_jpeg); + output.extend_from_slice(gain_map_jpeg); + + Ok(output) + } + + fn find_xmp_insert_position(&self) -> usize { + // Insert after SOI, JFIF (APP0), and Exif (APP1) + for (i, segment) in self.segments.iter().enumerate() { + match segment.marker { + MarkerType::Soi | MarkerType::App0 => continue, + MarkerType::App1 if segment.is_exif() => continue, + _ => return i, + } + } + self.segments.len() + } + + fn find_extended_xmp_insert_position(&self) -> usize { + // Insert after regular XMP + for (i, segment) in self.segments.iter().enumerate() { + if segment.is_xmp() { + return i + 1; + } + } + self.find_xmp_insert_position() + } + + fn find_mpf_insert_position(&self) -> usize { + // Insert after all APP1 segments + for (i, segment) in self.segments.iter().enumerate().rev() { + if segment.marker == MarkerType::App1 { + return i + 1; + } + } + // If no APP1, insert after APP0 + for (i, segment) in self.segments.iter().enumerate() { + if segment.marker == MarkerType::App0 { + return i + 1; + } + } + // Fallback: after SOI + 1 + } +} + +/// Creates MPF (Multi-Picture Format) data for the gain map reference. +fn create_mpf_data(gain_map_offset: u32, gain_map_size: u32) -> Vec { + const MPF_HEADER: &[u8] = b"MPF\0"; + + let mut data = Vec::new(); + data.extend_from_slice(MPF_HEADER); + + // Byte order (little-endian: II, big-endian: MM) + data.extend_from_slice(b"II"); + + // Fixed value 0x002A + data.extend_from_slice(&[0x2A, 0x00]); + + // Offset to first IFD (8 bytes from start of TIFF header) + data.extend_from_slice(&8u32.to_le_bytes()); + + // IFD Entry Count: 3 entries + data.extend_from_slice(&3u16.to_le_bytes()); + + // Entry 1: MPFVersion (0xB000) + data.extend_from_slice(&0xB000u16.to_le_bytes()); // Tag + data.extend_from_slice(&7u16.to_le_bytes()); // Type: UNDEFINED + data.extend_from_slice(&4u32.to_le_bytes()); // Count + data.extend_from_slice(b"0100"); // Value: "0100" + + // Entry 2: NumberOfImages (0xB001) + data.extend_from_slice(&0xB001u16.to_le_bytes()); // Tag + data.extend_from_slice(&4u32.to_le_bytes()); // Type: LONG + data.extend_from_slice(&1u32.to_le_bytes()); // Count + data.extend_from_slice(&2u32.to_le_bytes()); // Value: 2 images + + // Entry 3: MPEntry (0xB002) - offset to MP Entry + let mp_entry_offset: u32 = 8 + 2 + (3 * 12) + 4; // TIFF header + count + 3 entries + next IFD pointer + data.extend_from_slice(&0xB002u16.to_le_bytes()); // Tag + data.extend_from_slice(&7u16.to_le_bytes()); // Type: UNDEFINED + data.extend_from_slice(&32u32.to_le_bytes()); // Count: 16 bytes per entry * 2 entries + data.extend_from_slice(&mp_entry_offset.to_le_bytes()); // Offset + + // Next IFD pointer (0 = no more IFDs) + data.extend_from_slice(&0u32.to_le_bytes()); + + // MP Entry for primary image + data.extend_from_slice(&0x20030000u32.to_le_bytes()); // Image flags (primary, JPEG) + data.extend_from_slice(&0u32.to_le_bytes()); // Size (0 for primary = use actual) + data.extend_from_slice(&0u32.to_le_bytes()); // Offset (0 for primary) + data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 1 + data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 2 + + // MP Entry for gain map + data.extend_from_slice(&0x00030000u32.to_le_bytes()); // Image flags (JPEG, not primary) + data.extend_from_slice(&gain_map_size.to_le_bytes()); // Size + data.extend_from_slice(&gain_map_offset.to_le_bytes()); // Offset from start of file + data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 1 + data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 2 + + data +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_create_mpf_data() { + let data = create_mpf_data(1000, 500); + assert!(data.starts_with(b"MPF\0")); + } + + #[test] + fn test_empty_writer() { + let writer = JpegWriter::empty(); + let result = writer.write().unwrap(); + // Should have SOI + EOI + assert_eq!(result, vec![0xFF, 0xD8, 0xFF, 0xD9]); + } +} diff --git a/packages/ultrahdr-wasm/src/jpeg/xmp.rs b/packages/ultrahdr-wasm/src/jpeg/xmp.rs new file mode 100644 index 00000000000000..6f183cccebce24 --- /dev/null +++ b/packages/ultrahdr-wasm/src/jpeg/xmp.rs @@ -0,0 +1,374 @@ +//! XMP metadata parsing and writing for gain map metadata. +//! +//! Handles the ISO 21496-1 and UltraHDR v1 XMP namespaces. + +use crate::error::{Result, UltraHdrError}; +use crate::types::GainMapMetadata; +use quick_xml::events::{BytesEnd, BytesStart, Event}; +use quick_xml::{Reader, Writer}; +use std::io::Cursor; + +/// XMP namespace URIs +pub const HDRGM_NAMESPACE: &str = "http://ns.adobe.com/hdr-gain-map/1.0/"; +pub const HDRGM_PREFIX: &str = "hdrgm"; + +pub const CONTAINER_NAMESPACE: &str = "http://ns.google.com/photos/1.0/container/"; +pub const CONTAINER_PREFIX: &str = "Container"; + +pub const CONTAINER_ITEM_NAMESPACE: &str = "http://ns.google.com/photos/1.0/container/item/"; +pub const CONTAINER_ITEM_PREFIX: &str = "Item"; + +/// XMP parser for gain map metadata. +pub struct XmpParser; + +impl XmpParser { + /// Parses gain map metadata from XMP data. + pub fn parse(xmp_data: &[u8]) -> Result { + let xmp_str = std::str::from_utf8(xmp_data) + .map_err(|e| UltraHdrError::XmpError(format!("Invalid UTF-8 in XMP: {}", e)))?; + + Self::parse_str(xmp_str) + } + + /// Parses gain map metadata from an XMP string. + pub fn parse_str(xmp_str: &str) -> Result { + let mut metadata = GainMapMetadata::default(); + let mut reader = Reader::from_str(xmp_str); + reader.trim_text(true); + + let mut in_hdrgm = false; + let mut current_element = String::new(); + + loop { + match reader.read_event() { + Ok(Event::Start(e)) | Ok(Event::Empty(e)) => { + let name_bytes = e.name(); + let name = std::str::from_utf8(name_bytes.as_ref()).unwrap_or(""); + + // Check for hdrgm: prefix + if name.starts_with("hdrgm:") || name.contains(":hdrgm:") { + in_hdrgm = true; + current_element = name.to_string(); + } + + // Parse attributes for RDF property syntax + for attr in e.attributes().flatten() { + let attr_name = std::str::from_utf8(attr.key.as_ref()).unwrap_or(""); + let attr_value = std::str::from_utf8(&attr.value).unwrap_or(""); + + if attr_name.starts_with("hdrgm:") { + Self::set_metadata_field(&mut metadata, attr_name, attr_value)?; + } + } + } + Ok(Event::Text(e)) if in_hdrgm => { + let text = e.unescape().unwrap_or_default(); + Self::set_metadata_field(&mut metadata, ¤t_element, &text)?; + } + Ok(Event::End(e)) => { + let name_bytes = e.name(); + let name = std::str::from_utf8(name_bytes.as_ref()).unwrap_or(""); + if name.starts_with("hdrgm:") { + in_hdrgm = false; + current_element.clear(); + } + } + Ok(Event::Eof) => break, + Err(e) => return Err(UltraHdrError::XmpError(format!("XML parse error: {}", e))), + _ => {} + } + } + + Ok(metadata) + } + + /// Checks if XMP data contains gain map metadata. + pub fn has_gain_map_metadata(xmp_data: &[u8]) -> bool { + let xmp_str = match std::str::from_utf8(xmp_data) { + Ok(s) => s, + Err(_) => return false, + }; + + xmp_str.contains(HDRGM_NAMESPACE) || xmp_str.contains("hdrgm:") + } + + fn set_metadata_field(metadata: &mut GainMapMetadata, name: &str, value: &str) -> Result<()> { + // Strip namespace prefix + let field_name = name.split(':').last().unwrap_or(name); + + match field_name { + "Version" => metadata.version = value.to_string(), + "BaseRenditionIsHDR" => { + metadata.base_rendition_is_hdr = value.eq_ignore_ascii_case("true") || value == "1"; + } + "GainMapMin" => metadata.gain_map_min = Self::parse_float_array(value)?, + "GainMapMax" => metadata.gain_map_max = Self::parse_float_array(value)?, + "Gamma" => metadata.gamma = Self::parse_float_array(value)?, + "OffsetSDR" => metadata.offset_sdr = Self::parse_float_array(value)?, + "OffsetHDR" => metadata.offset_hdr = Self::parse_float_array(value)?, + "HDRCapacityMin" => { + metadata.hdr_capacity_min = value.parse().map_err(|_| { + UltraHdrError::MetadataError(format!("Invalid HDRCapacityMin: {}", value)) + })?; + } + "HDRCapacityMax" => { + metadata.hdr_capacity_max = value.parse().map_err(|_| { + UltraHdrError::MetadataError(format!("Invalid HDRCapacityMax: {}", value)) + })?; + } + _ => {} // Ignore unknown fields + } + + Ok(()) + } + + fn parse_float_array(value: &str) -> Result> { + // Handle single value (applied to all channels) + if !value.contains(',') && !value.contains(' ') { + let v: f32 = value.trim().parse().map_err(|_| { + UltraHdrError::MetadataError(format!("Invalid float value: {}", value)) + })?; + return Ok(vec![v, v, v]); + } + + // Handle comma or space separated values + let parts: Vec<&str> = value.split(|c| c == ',' || c == ' ') + .filter(|s| !s.is_empty()) + .collect(); + + let mut result = Vec::with_capacity(parts.len()); + for part in parts { + let v: f32 = part.trim().parse().map_err(|_| { + UltraHdrError::MetadataError(format!("Invalid float value: {}", part)) + })?; + result.push(v); + } + + // Ensure we have exactly 3 values (RGB) + match result.len() { + 1 => Ok(vec![result[0], result[0], result[0]]), + 3 => Ok(result), + _ => Err(UltraHdrError::MetadataError(format!( + "Expected 1 or 3 values, got {}", + result.len() + ))), + } + } +} + +/// XMP writer for gain map metadata. +pub struct XmpWriter; + +impl XmpWriter { + /// Creates XMP data for gain map metadata (ISO 21496-1 format). + pub fn create_iso_xmp(metadata: &GainMapMetadata) -> Result> { + let mut writer = Writer::new(Cursor::new(Vec::new())); + + // XML declaration + writer.write_event(Event::Decl(quick_xml::events::BytesDecl::new("1.0", Some("UTF-8"), None)))?; + + // XMP packet wrapper + let mut xmpmeta = BytesStart::new("x:xmpmeta"); + xmpmeta.push_attribute(("xmlns:x", "adobe:ns:meta/")); + writer.write_event(Event::Start(xmpmeta))?; + + // RDF root + let mut rdf = BytesStart::new("rdf:RDF"); + rdf.push_attribute(("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")); + rdf.push_attribute(("xmlns:hdrgm", HDRGM_NAMESPACE)); + writer.write_event(Event::Start(rdf))?; + + // RDF Description + let mut desc = BytesStart::new("rdf:Description"); + desc.push_attribute(("rdf:about", "")); + + // Add metadata as attributes + let gain_map_min = Self::format_float_array(&metadata.gain_map_min); + let gain_map_max = Self::format_float_array(&metadata.gain_map_max); + let gamma = Self::format_float_array(&metadata.gamma); + let offset_sdr = Self::format_float_array(&metadata.offset_sdr); + let offset_hdr = Self::format_float_array(&metadata.offset_hdr); + let hdr_capacity_min = format!("{:.6}", metadata.hdr_capacity_min); + let hdr_capacity_max = format!("{:.6}", metadata.hdr_capacity_max); + + desc.push_attribute(("hdrgm:Version", metadata.version.as_str())); + desc.push_attribute(("hdrgm:BaseRenditionIsHDR", if metadata.base_rendition_is_hdr { "True" } else { "False" })); + desc.push_attribute(("hdrgm:GainMapMin", gain_map_min.as_str())); + desc.push_attribute(("hdrgm:GainMapMax", gain_map_max.as_str())); + desc.push_attribute(("hdrgm:Gamma", gamma.as_str())); + desc.push_attribute(("hdrgm:OffsetSDR", offset_sdr.as_str())); + desc.push_attribute(("hdrgm:OffsetHDR", offset_hdr.as_str())); + desc.push_attribute(("hdrgm:HDRCapacityMin", hdr_capacity_min.as_str())); + desc.push_attribute(("hdrgm:HDRCapacityMax", hdr_capacity_max.as_str())); + + writer.write_event(Event::Empty(desc))?; + + // Close elements + writer.write_event(Event::End(BytesEnd::new("rdf:RDF")))?; + writer.write_event(Event::End(BytesEnd::new("x:xmpmeta")))?; + + Ok(writer.into_inner().into_inner()) + } + + /// Creates XMP data with UltraHDR v1 Container extension. + pub fn create_ultrahdr_v1_xmp(metadata: &GainMapMetadata, gain_map_mime: &str) -> Result> { + let mut writer = Writer::new(Cursor::new(Vec::new())); + + // XML declaration + writer.write_event(Event::Decl(quick_xml::events::BytesDecl::new("1.0", Some("UTF-8"), None)))?; + + // XMP packet wrapper + let mut xmpmeta = BytesStart::new("x:xmpmeta"); + xmpmeta.push_attribute(("xmlns:x", "adobe:ns:meta/")); + writer.write_event(Event::Start(xmpmeta))?; + + // RDF root + let mut rdf = BytesStart::new("rdf:RDF"); + rdf.push_attribute(("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")); + rdf.push_attribute(("xmlns:hdrgm", HDRGM_NAMESPACE)); + rdf.push_attribute(("xmlns:Container", CONTAINER_NAMESPACE)); + rdf.push_attribute(("xmlns:Item", CONTAINER_ITEM_NAMESPACE)); + writer.write_event(Event::Start(rdf))?; + + // RDF Description with gain map metadata + let gain_map_min = Self::format_float_array(&metadata.gain_map_min); + let gain_map_max = Self::format_float_array(&metadata.gain_map_max); + let gamma = Self::format_float_array(&metadata.gamma); + let offset_sdr = Self::format_float_array(&metadata.offset_sdr); + let offset_hdr = Self::format_float_array(&metadata.offset_hdr); + let hdr_capacity_min = format!("{:.6}", metadata.hdr_capacity_min); + let hdr_capacity_max = format!("{:.6}", metadata.hdr_capacity_max); + + let mut desc = BytesStart::new("rdf:Description"); + desc.push_attribute(("rdf:about", "")); + desc.push_attribute(("hdrgm:Version", metadata.version.as_str())); + desc.push_attribute(("hdrgm:BaseRenditionIsHDR", if metadata.base_rendition_is_hdr { "True" } else { "False" })); + desc.push_attribute(("hdrgm:GainMapMin", gain_map_min.as_str())); + desc.push_attribute(("hdrgm:GainMapMax", gain_map_max.as_str())); + desc.push_attribute(("hdrgm:Gamma", gamma.as_str())); + desc.push_attribute(("hdrgm:OffsetSDR", offset_sdr.as_str())); + desc.push_attribute(("hdrgm:OffsetHDR", offset_hdr.as_str())); + desc.push_attribute(("hdrgm:HDRCapacityMin", hdr_capacity_min.as_str())); + desc.push_attribute(("hdrgm:HDRCapacityMax", hdr_capacity_max.as_str())); + writer.write_event(Event::Start(desc))?; + + // Container:Directory + writer.write_event(Event::Start(BytesStart::new("Container:Directory")))?; + writer.write_event(Event::Start(BytesStart::new("rdf:Seq")))?; + + // Primary image item + writer.write_event(Event::Start(BytesStart::new("rdf:li")))?; + let mut primary_item = BytesStart::new("Container:Item"); + primary_item.push_attribute(("Item:Semantic", "Primary")); + primary_item.push_attribute(("Item:Mime", "image/jpeg")); + writer.write_event(Event::Empty(primary_item))?; + writer.write_event(Event::End(BytesEnd::new("rdf:li")))?; + + // Gain map item + writer.write_event(Event::Start(BytesStart::new("rdf:li")))?; + let mut gainmap_item = BytesStart::new("Container:Item"); + gainmap_item.push_attribute(("Item:Semantic", "GainMap")); + gainmap_item.push_attribute(("Item:Mime", gain_map_mime)); + writer.write_event(Event::Empty(gainmap_item))?; + writer.write_event(Event::End(BytesEnd::new("rdf:li")))?; + + writer.write_event(Event::End(BytesEnd::new("rdf:Seq")))?; + writer.write_event(Event::End(BytesEnd::new("Container:Directory")))?; + + // Close elements + writer.write_event(Event::End(BytesEnd::new("rdf:Description")))?; + writer.write_event(Event::End(BytesEnd::new("rdf:RDF")))?; + writer.write_event(Event::End(BytesEnd::new("x:xmpmeta")))?; + + Ok(writer.into_inner().into_inner()) + } + + /// Creates combined XMP data with both ISO 21496-1 and UltraHDR v1 metadata. + pub fn create_combined_xmp(metadata: &GainMapMetadata) -> Result> { + Self::create_ultrahdr_v1_xmp(metadata, "image/jpeg") + } + + fn format_float_array(values: &[f32]) -> String { + if values.len() == 3 && values[0] == values[1] && values[1] == values[2] { + // Single value if all channels are the same + format!("{:.6}", values[0]) + } else { + values.iter() + .map(|v| format!("{:.6}", v)) + .collect::>() + .join(", ") + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_gain_map_metadata() { + let xmp = r#" + + + + + "#; + + let metadata = XmpParser::parse_str(xmp).unwrap(); + assert_eq!(metadata.version, "1.0"); + assert!(!metadata.base_rendition_is_hdr); + assert_eq!(metadata.gain_map_max, vec![3.0, 3.0, 3.0]); + assert_eq!(metadata.hdr_capacity_max, 3.0); + } + + #[test] + fn test_write_iso_xmp() { + let metadata = GainMapMetadata::default(); + let xmp = XmpWriter::create_iso_xmp(&metadata).unwrap(); + let xmp_str = std::str::from_utf8(&xmp).unwrap(); + + assert!(xmp_str.contains("hdrgm:Version")); + assert!(xmp_str.contains(HDRGM_NAMESPACE)); + } + + #[test] + fn test_has_gain_map_metadata() { + let xmp_with = b""; + let xmp_without = b""; + + assert!(XmpParser::has_gain_map_metadata(xmp_with)); + assert!(!XmpParser::has_gain_map_metadata(xmp_without)); + } + + #[test] + fn test_roundtrip() { + let original = GainMapMetadata { + version: "1.0".to_string(), + base_rendition_is_hdr: false, + gain_map_min: vec![-1.0, -1.0, -1.0], + gain_map_max: vec![3.0, 3.0, 3.0], + gamma: vec![1.0, 1.0, 1.0], + offset_sdr: vec![0.015625, 0.015625, 0.015625], + offset_hdr: vec![0.015625, 0.015625, 0.015625], + hdr_capacity_min: 1.0, + hdr_capacity_max: 4.0, + }; + + let xmp = XmpWriter::create_iso_xmp(&original).unwrap(); + let parsed = XmpParser::parse(&xmp).unwrap(); + + assert_eq!(original.version, parsed.version); + assert_eq!(original.base_rendition_is_hdr, parsed.base_rendition_is_hdr); + assert_eq!(original.hdr_capacity_max, parsed.hdr_capacity_max); + } +} diff --git a/packages/ultrahdr-wasm/src/lib.rs b/packages/ultrahdr-wasm/src/lib.rs new file mode 100644 index 00000000000000..8eb29a9a11a694 --- /dev/null +++ b/packages/ultrahdr-wasm/src/lib.rs @@ -0,0 +1,293 @@ +//! WordPress UltraHDR WASM Library +//! +//! A GPLv2-compatible Rust library implementing ISO 21496-1 (UltraHDR/gain map) +//! specification, compiled to WebAssembly for integration with WordPress Gutenberg's +//! client-side media processing. +//! +//! # Features +//! +//! - **Detection**: Check if a JPEG contains UltraHDR/gain map data +//! - **Decoding**: Extract SDR base, gain map, and metadata from UltraHDR JPEGs +//! - **Encoding**: Create UltraHDR JPEGs from SDR + HDR image pairs +//! - **SDR Extraction**: Extract backwards-compatible SDR image +//! +//! # Standards Support +//! +//! - ISO 21496-1:2025 (Gain map metadata) +//! - Google UltraHDR v1 (Android compatibility) +//! - Adobe Gain Map specification +//! +//! # License +//! +//! GPL-2.0-or-later + +#![allow(clippy::unused_unit)] + +use wasm_bindgen::prelude::*; + +pub mod error; +pub mod gainmap; +pub mod jpeg; +pub mod types; +pub mod ultrahdr; + +pub use error::{Result, UltraHdrError}; +// Types are exported via wasm_bindgen annotations in types.rs + +/// Initializes the WASM module. +/// +/// This should be called before using any other functions. +#[wasm_bindgen(start)] +pub fn init() { + // Module initialization - currently no-op but reserved for future setup +} + +/// Checks if a JPEG buffer contains UltraHDR/gain map data. +/// +/// This is a fast check that looks for gain map metadata in the XMP +/// or MPF segments without fully decoding the image. +/// +/// # Arguments +/// * `buffer` - JPEG file contents as bytes +/// +/// # Returns +/// `true` if the image contains gain map metadata, `false` otherwise +/// +/// # Example (JavaScript) +/// ```js +/// const buffer = await file.arrayBuffer(); +/// const isHdr = isUltraHdr(new Uint8Array(buffer)); +/// ``` +#[wasm_bindgen(js_name = isUltraHdr)] +pub fn is_ultra_hdr(buffer: &[u8]) -> bool { + ultrahdr::has_gainmap_metadata(buffer) +} + +/// Decodes an UltraHDR JPEG, extracting SDR base, gain map, and metadata. +/// +/// # Arguments +/// * `buffer` - UltraHDR JPEG file contents as bytes +/// +/// # Returns +/// A `UltraHdrDecodeResult` containing: +/// - `sdrImage`: The SDR base image as JPEG bytes +/// - `gainMap`: The gain map as JPEG bytes +/// - `metadata`: Gain map metadata (version, gains, gamma, offsets, etc.) +/// - `width`, `height`: Image dimensions +/// - `gainMapWidth`, `gainMapHeight`: Gain map dimensions +/// +/// # Errors +/// Returns an error if the buffer is not a valid UltraHDR JPEG. +#[wasm_bindgen(js_name = decodeUltraHdr)] +pub fn decode_ultra_hdr(buffer: &[u8]) -> std::result::Result { + ultrahdr::decode(buffer).map_err(|e| JsValue::from_str(&e.to_string())) +} + +/// Encodes an UltraHDR JPEG from SDR and HDR inputs. +/// +/// # Arguments +/// * `sdr_buffer` - SDR JPEG image bytes +/// * `hdr_buffer` - HDR image as linear RGB float32 array (3 values per pixel, normalized to [0,1]) +/// * `options` - Encoding options (quality, HDR capacity, etc.) +/// +/// # Returns +/// The encoded UltraHDR JPEG as bytes. +/// +/// # Errors +/// Returns an error if: +/// - The SDR buffer is not a valid JPEG +/// - The HDR buffer size doesn't match the SDR dimensions +/// - The dimensions are invalid (e.g., odd width/height) +/// +/// # Example (JavaScript) +/// ```js +/// const options = new UltraHdrEncodeOptions(); +/// options.baseQuality = 90; +/// options.targetHdrCapacity = 3.0; +/// +/// const sdrBuffer = await sdrFile.arrayBuffer(); +/// const hdrBuffer = await getHdrLinearData(); // Float32Array +/// +/// const ultraHdr = encodeUltraHdr( +/// new Uint8Array(sdrBuffer), +/// new Float32Array(hdrBuffer), +/// options +/// ); +/// ``` +#[wasm_bindgen(js_name = encodeUltraHdr)] +pub fn encode_ultra_hdr( + sdr_buffer: &[u8], + hdr_buffer: &[f32], + options: &UltraHdrEncodeOptions, +) -> std::result::Result, JsValue> { + ultrahdr::encode(sdr_buffer, hdr_buffer, options) + .map_err(|e| JsValue::from_str(&e.to_string())) +} + +/// Extracts just the SDR base image from an UltraHDR JPEG. +/// +/// This produces a standard JPEG that can be displayed on any device, +/// without the gain map metadata. Useful for backwards compatibility. +/// +/// # Arguments +/// * `buffer` - UltraHDR JPEG file contents as bytes +/// +/// # Returns +/// A standard JPEG without gain map metadata. +/// +/// # Errors +/// Returns an error if the buffer is not a valid JPEG. +#[wasm_bindgen(js_name = extractSdrBase)] +pub fn extract_sdr_base(buffer: &[u8]) -> std::result::Result, JsValue> { + ultrahdr::extract_base(buffer).map_err(|e| JsValue::from_str(&e.to_string())) +} + +/// Gets gain map metadata from an UltraHDR JPEG without full decode. +/// +/// This is faster than `decodeUltraHdr` when you only need the metadata. +/// +/// # Arguments +/// * `buffer` - UltraHDR JPEG file contents as bytes +/// +/// # Returns +/// The gain map metadata. +/// +/// # Errors +/// Returns an error if the buffer doesn't contain gain map metadata. +#[wasm_bindgen(js_name = getMetadata)] +pub fn get_metadata(buffer: &[u8]) -> std::result::Result { + ultrahdr::extract_metadata(buffer).map_err(|e| JsValue::from_str(&e.to_string())) +} + +/// Creates default encoding options. +/// +/// # Returns +/// `UltraHdrEncodeOptions` with sensible defaults: +/// - baseQuality: 85 +/// - gainMapQuality: 75 +/// - targetHdrCapacity: 3.0 +/// - includeIsoMetadata: true +/// - includeUltrahdrV1: true +/// - gainMapScale: 1 +#[wasm_bindgen(js_name = createDefaultOptions)] +pub fn create_default_options() -> UltraHdrEncodeOptions { + UltraHdrEncodeOptions::default() +} + +/// Creates high quality encoding options. +/// +/// # Returns +/// `UltraHdrEncodeOptions` optimized for quality: +/// - baseQuality: 95 +/// - gainMapQuality: 85 +/// - targetHdrCapacity: 4.0 +#[wasm_bindgen(js_name = createHighQualityOptions)] +pub fn create_high_quality_options() -> UltraHdrEncodeOptions { + UltraHdrEncodeOptions::high_quality() +} + +/// Creates small size encoding options. +/// +/// # Returns +/// `UltraHdrEncodeOptions` optimized for file size: +/// - baseQuality: 75 +/// - gainMapQuality: 65 +/// - targetHdrCapacity: 3.0 +/// - gainMapScale: 2 (half-size gain map) +#[wasm_bindgen(js_name = createSmallSizeOptions)] +pub fn create_small_size_options() -> UltraHdrEncodeOptions { + UltraHdrEncodeOptions::small_size() +} + +/// Creates default gain map metadata. +/// +/// Useful for testing or when creating metadata programmatically. +#[wasm_bindgen(js_name = createDefaultMetadata)] +pub fn create_default_metadata() -> GainMapMetadata { + GainMapMetadata::default() +} + +/// Validates gain map metadata. +/// +/// # Arguments +/// * `metadata` - The metadata to validate +/// +/// # Returns +/// `true` if the metadata is valid, `false` otherwise +#[wasm_bindgen(js_name = validateMetadata)] +pub fn validate_metadata(metadata: &GainMapMetadata) -> bool { + gainmap::metadata::validate_metadata(metadata).is_ok() +} + +/// Estimates the HDR headroom from metadata. +/// +/// # Arguments +/// * `metadata` - The gain map metadata +/// +/// # Returns +/// The maximum additional stops of dynamic range above SDR. +#[wasm_bindgen(js_name = estimateHdrHeadroom)] +pub fn estimate_hdr_headroom(metadata: &GainMapMetadata) -> f32 { + gainmap::metadata::estimate_hdr_headroom(metadata) +} + +/// Checks if metadata indicates a meaningful HDR image. +/// +/// # Arguments +/// * `metadata` - The gain map metadata +/// +/// # Returns +/// `true` if the gain map provides significant dynamic range extension +/// (more than half a stop). +#[wasm_bindgen(js_name = isMeaningfulHdr)] +pub fn is_meaningful_hdr(metadata: &GainMapMetadata) -> bool { + gainmap::metadata::is_meaningful_hdr(metadata) +} + +// Re-export types for use in WASM +pub use types::{ColorGamut, GainMapMetadata, TransferFunction, UltraHdrDecodeResult, UltraHdrEncodeOptions}; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_is_ultra_hdr_non_jpeg() { + assert!(!is_ultra_hdr(&[])); + assert!(!is_ultra_hdr(&[0x89, 0x50, 0x4E, 0x47])); // PNG + } + + #[test] + fn test_is_ultra_hdr_regular_jpeg() { + // Minimal JPEG without gain map + let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; + assert!(!is_ultra_hdr(&jpeg)); + } + + #[test] + fn test_create_default_options() { + let opts = create_default_options(); + assert_eq!(opts.base_quality, 85); + assert_eq!(opts.gain_map_quality, 75); + assert_eq!(opts.target_hdr_capacity, 3.0); + } + + #[test] + fn test_create_high_quality_options() { + let opts = create_high_quality_options(); + assert_eq!(opts.base_quality, 95); + assert_eq!(opts.target_hdr_capacity, 4.0); + } + + #[test] + fn test_validate_metadata() { + let metadata = create_default_metadata(); + assert!(validate_metadata(&metadata)); + } + + #[test] + fn test_estimate_hdr_headroom() { + let metadata = create_default_metadata(); + assert!(estimate_hdr_headroom(&metadata) > 0.0); + } +} diff --git a/packages/ultrahdr-wasm/src/types.rs b/packages/ultrahdr-wasm/src/types.rs new file mode 100644 index 00000000000000..70eebcd3d09110 --- /dev/null +++ b/packages/ultrahdr-wasm/src/types.rs @@ -0,0 +1,257 @@ +//! Shared types for UltraHDR operations. + +use serde::{Deserialize, Serialize}; +use wasm_bindgen::prelude::*; + +/// ISO 21496-1 Gain Map Metadata. +/// +/// This structure contains all the metadata required to interpret and apply +/// a gain map according to the ISO 21496-1 specification. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[wasm_bindgen(getter_with_clone)] +pub struct GainMapMetadata { + /// Specification version (e.g., "1.0") + pub version: String, + + /// Whether the base rendition is HDR (false = SDR base, true = HDR base) + #[wasm_bindgen(js_name = baseRenditionIsHdr)] + pub base_rendition_is_hdr: bool, + + /// Minimum gain value per channel (RGB), in log2 scale + #[wasm_bindgen(js_name = gainMapMin)] + pub gain_map_min: Vec, + + /// Maximum gain value per channel (RGB), in log2 scale + #[wasm_bindgen(js_name = gainMapMax)] + pub gain_map_max: Vec, + + /// Gamma correction per channel (RGB) + pub gamma: Vec, + + /// SDR offset per channel (RGB), used for black point adjustment + #[wasm_bindgen(js_name = offsetSdr)] + pub offset_sdr: Vec, + + /// HDR offset per channel (RGB), used for black point adjustment + #[wasm_bindgen(js_name = offsetHdr)] + pub offset_hdr: Vec, + + /// Minimum HDR capacity (log2 scale) where gain map starts to apply + #[wasm_bindgen(js_name = hdrCapacityMin)] + pub hdr_capacity_min: f32, + + /// Maximum HDR capacity (log2 scale) for full HDR output + #[wasm_bindgen(js_name = hdrCapacityMax)] + pub hdr_capacity_max: f32, +} + +#[wasm_bindgen] +impl GainMapMetadata { + /// Creates a new GainMapMetadata with default values. + #[wasm_bindgen(constructor)] + pub fn new() -> Self { + Self::default() + } + + /// Creates metadata suitable for a typical SDR base with HDR gain map. + #[wasm_bindgen(js_name = forSdrBase)] + pub fn for_sdr_base(hdr_capacity_max: f32) -> Self { + Self { + version: "1.0".to_string(), + base_rendition_is_hdr: false, + gain_map_min: vec![0.0, 0.0, 0.0], + gain_map_max: vec![hdr_capacity_max, hdr_capacity_max, hdr_capacity_max], + gamma: vec![1.0, 1.0, 1.0], + offset_sdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], + offset_hdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], + hdr_capacity_min: 0.0, + hdr_capacity_max, + } + } +} + +impl Default for GainMapMetadata { + fn default() -> Self { + Self { + version: "1.0".to_string(), + base_rendition_is_hdr: false, + gain_map_min: vec![0.0, 0.0, 0.0], + gain_map_max: vec![3.0, 3.0, 3.0], + gamma: vec![1.0, 1.0, 1.0], + offset_sdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], + offset_hdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], + hdr_capacity_min: 0.0, + hdr_capacity_max: 3.0, + } + } +} + +/// Result of decoding an UltraHDR image. +#[derive(Debug, Clone)] +#[wasm_bindgen(getter_with_clone)] +pub struct UltraHdrDecodeResult { + /// The SDR base image as JPEG bytes + #[wasm_bindgen(js_name = sdrImage)] + pub sdr_image: Vec, + + /// The gain map as grayscale JPEG bytes + #[wasm_bindgen(js_name = gainMap)] + pub gain_map: Vec, + + /// Gain map metadata + pub metadata: GainMapMetadata, + + /// Image width in pixels + pub width: u32, + + /// Image height in pixels + pub height: u32, + + /// Gain map width in pixels (may differ from image width) + #[wasm_bindgen(js_name = gainMapWidth)] + pub gain_map_width: u32, + + /// Gain map height in pixels (may differ from image height) + #[wasm_bindgen(js_name = gainMapHeight)] + pub gain_map_height: u32, +} + +#[wasm_bindgen] +impl UltraHdrDecodeResult { + /// Creates a new decode result. + #[wasm_bindgen(constructor)] + pub fn new( + sdr_image: Vec, + gain_map: Vec, + metadata: GainMapMetadata, + width: u32, + height: u32, + gain_map_width: u32, + gain_map_height: u32, + ) -> Self { + Self { + sdr_image, + gain_map, + metadata, + width, + height, + gain_map_width, + gain_map_height, + } + } +} + +/// Options for encoding UltraHDR images. +#[derive(Debug, Clone, Serialize, Deserialize)] +#[wasm_bindgen] +pub struct UltraHdrEncodeOptions { + /// JPEG quality for the base image (1-100) + #[wasm_bindgen(js_name = baseQuality)] + pub base_quality: u8, + + /// JPEG quality for the gain map (1-100) + #[wasm_bindgen(js_name = gainMapQuality)] + pub gain_map_quality: u8, + + /// Target HDR capacity (typically 2.0-4.0) + #[wasm_bindgen(js_name = targetHdrCapacity)] + pub target_hdr_capacity: f32, + + /// Whether to include ISO 21496-1 metadata + #[wasm_bindgen(js_name = includeIsoMetadata)] + pub include_iso_metadata: bool, + + /// Whether to include UltraHDR v1 metadata for Android compatibility + #[wasm_bindgen(js_name = includeUltrahdrV1)] + pub include_ultrahdr_v1: bool, + + /// Downscale factor for the gain map (1 = same size, 2 = half, 4 = quarter) + #[wasm_bindgen(js_name = gainMapScale)] + pub gain_map_scale: u8, +} + +#[wasm_bindgen] +impl UltraHdrEncodeOptions { + /// Creates encoding options with default values. + #[wasm_bindgen(constructor)] + pub fn new() -> Self { + Self::default() + } + + /// Creates options optimized for high quality output. + #[wasm_bindgen(js_name = highQuality)] + pub fn high_quality() -> Self { + Self { + base_quality: 95, + gain_map_quality: 85, + target_hdr_capacity: 4.0, + include_iso_metadata: true, + include_ultrahdr_v1: true, + gain_map_scale: 1, + } + } + + /// Creates options optimized for smaller file size. + #[wasm_bindgen(js_name = smallSize)] + pub fn small_size() -> Self { + Self { + base_quality: 75, + gain_map_quality: 65, + target_hdr_capacity: 3.0, + include_iso_metadata: true, + include_ultrahdr_v1: true, + gain_map_scale: 2, + } + } +} + +impl Default for UltraHdrEncodeOptions { + fn default() -> Self { + Self { + base_quality: 85, + gain_map_quality: 75, + target_hdr_capacity: 3.0, + include_iso_metadata: true, + include_ultrahdr_v1: true, + gain_map_scale: 1, + } + } +} + +/// Color gamut enumeration for HDR images. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[wasm_bindgen] +pub enum ColorGamut { + /// Standard sRGB color space (BT.709 primaries) + Srgb = 0, + /// Display P3 wide color gamut + DisplayP3 = 1, + /// BT.2100/BT.2020 wide color gamut (HDR) + Bt2100 = 2, +} + +impl Default for ColorGamut { + fn default() -> Self { + ColorGamut::Srgb + } +} + +/// Transfer function for encoding luminance. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[wasm_bindgen] +pub enum TransferFunction { + /// sRGB transfer function (gamma ~2.2) + Srgb = 0, + /// Linear (no gamma) + Linear = 1, + /// Perceptual Quantizer (PQ) - SMPTE ST 2084 + Pq = 2, + /// Hybrid Log-Gamma (HLG) - BT.2100 + Hlg = 3, +} + +impl Default for TransferFunction { + fn default() -> Self { + TransferFunction::Srgb + } +} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs b/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs new file mode 100644 index 00000000000000..ade91fdb3d3759 --- /dev/null +++ b/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs @@ -0,0 +1,325 @@ +//! UltraHDR JPEG decoder. +//! +//! Extracts SDR base, gain map, and metadata from UltraHDR JPEG files. + +use crate::error::{Result, UltraHdrError}; +use crate::types::{GainMapMetadata, UltraHdrDecodeResult}; +use crate::jpeg::parser::JpegParser; +use crate::jpeg::xmp::XmpParser; + +/// Checks if a JPEG contains UltraHDR/gain map metadata. +pub fn has_gainmap_metadata(data: &[u8]) -> bool { + // Quick check for JPEG magic bytes + if data.len() < 2 || data[0] != 0xFF || data[1] != 0xD8 { + return false; + } + + // Try to parse and find XMP with gain map metadata + match JpegParser::parse(data) { + Ok(parser) => { + if let Some(xmp_segment) = parser.find_xmp_segment() { + if let Some(xmp_data) = xmp_segment.get_xmp_data() { + return XmpParser::has_gain_map_metadata(xmp_data); + } + } + // Also check for MPF segment as indicator + parser.find_mpf_segment().is_some() + } + Err(_) => false, + } +} + +/// Decodes an UltraHDR JPEG, extracting all components. +pub fn decode(data: &[u8]) -> Result { + let parser = JpegParser::parse(data)?; + + // Get image dimensions + let (width, height) = parser.get_dimensions() + .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine image dimensions".to_string()))?; + + // Extract metadata from XMP + let metadata = extract_metadata_from_parser(&parser)?; + + // Find and extract gain map + let (gain_map, gm_width, gm_height) = extract_gain_map(data, &parser)?; + + // Extract SDR base (the primary image without gain map) + let sdr_image = extract_sdr_from_parser(data, &parser)?; + + Ok(UltraHdrDecodeResult::new( + sdr_image, + gain_map, + metadata, + width, + height, + gm_width, + gm_height, + )) +} + +/// Extracts just the SDR base image from an UltraHDR JPEG. +/// +/// Returns a valid JPEG without gain map metadata. +pub fn extract_base(data: &[u8]) -> Result> { + let parser = JpegParser::parse(data)?; + extract_sdr_from_parser(data, &parser) +} + +/// Extracts just the metadata from an UltraHDR JPEG. +pub fn extract_metadata(data: &[u8]) -> Result { + let parser = JpegParser::parse(data)?; + extract_metadata_from_parser(&parser) +} + +/// Extracts gain map metadata from parsed JPEG. +fn extract_metadata_from_parser(parser: &JpegParser) -> Result { + // Find XMP segment + let xmp_segment = parser.find_xmp_segment() + .ok_or(UltraHdrError::NoGainMap)?; + + let xmp_data = xmp_segment.get_xmp_data() + .ok_or_else(|| UltraHdrError::XmpError("Invalid XMP segment".to_string()))?; + + if !XmpParser::has_gain_map_metadata(xmp_data) { + return Err(UltraHdrError::NoGainMap); + } + + XmpParser::parse(xmp_data) +} + +/// Extracts the SDR base image as clean JPEG. +fn extract_sdr_from_parser(data: &[u8], _parser: &JpegParser) -> Result> { + // Find where the gain map starts (after primary image EOI) + // The primary image ends at the first EOI marker + let eoi_offset = find_primary_eoi_offset(data)?; + + // Return data up to and including the first EOI + Ok(data[..eoi_offset + 2].to_vec()) +} + +/// Extracts the gain map JPEG from an UltraHDR image. +fn extract_gain_map(data: &[u8], parser: &JpegParser) -> Result<(Vec, u32, u32)> { + // Method 1: Try MPF segment + if let Some(mpf_segment) = parser.find_mpf_segment() { + if let Some((offset, size)) = parse_mpf_for_gainmap(&mpf_segment.data) { + let offset = offset as usize; + let size = size as usize; + + if offset + size <= data.len() { + let gain_map_jpeg = data[offset..offset + size].to_vec(); + let (gm_width, gm_height) = get_jpeg_dimensions(&gain_map_jpeg)?; + return Ok((gain_map_jpeg, gm_width, gm_height)); + } + } + } + + // Method 2: Look for second JPEG after primary image EOI + let eoi_offset = find_primary_eoi_offset(data)?; + let remaining = &data[eoi_offset + 2..]; + + if remaining.len() >= 2 && remaining[0] == 0xFF && remaining[1] == 0xD8 { + // Found another JPEG - this is the gain map + let gain_map_jpeg = remaining.to_vec(); + let (gm_width, gm_height) = get_jpeg_dimensions(&gain_map_jpeg)?; + return Ok((gain_map_jpeg, gm_width, gm_height)); + } + + Err(UltraHdrError::NoGainMap) +} + +/// Finds the offset of the primary image's EOI marker. +fn find_primary_eoi_offset(data: &[u8]) -> Result { + // Skip the initial SOI + let mut pos = 2; + + while pos < data.len() - 1 { + if data[pos] == 0xFF { + let marker = data[pos + 1]; + + // Skip padding FF bytes + if marker == 0xFF { + pos += 1; + continue; + } + + // EOI marker + if marker == 0xD9 { + return Ok(pos); + } + + // SOS marker - scan through entropy data + if marker == 0xDA { + // Skip SOS header + if pos + 3 >= data.len() { + break; + } + let len = u16::from_be_bytes([data[pos + 2], data[pos + 3]]) as usize; + pos += 2 + len; + + // Scan through entropy-coded data + while pos < data.len() - 1 { + if data[pos] == 0xFF { + let next = data[pos + 1]; + if next == 0x00 { + // Stuffed byte + pos += 2; + } else if next == 0xD9 { + // EOI + return Ok(pos); + } else if next >= 0xD0 && next <= 0xD7 { + // Restart marker + pos += 2; + } else if next != 0xFF { + // Another marker - shouldn't happen in valid JPEG + break; + } else { + pos += 1; + } + } else { + pos += 1; + } + } + } + + // Other marker with length + if marker != 0xD8 && marker != 0xD9 && !(marker >= 0xD0 && marker <= 0xD7) { + if pos + 3 >= data.len() { + break; + } + let len = u16::from_be_bytes([data[pos + 2], data[pos + 3]]) as usize; + pos += 2 + len; + } else { + pos += 2; + } + } else { + pos += 1; + } + } + + Err(UltraHdrError::InvalidJpeg("Could not find EOI marker".to_string())) +} + +/// Parses MPF segment data to find gain map offset and size. +fn parse_mpf_for_gainmap(mpf_data: &[u8]) -> Option<(u32, u32)> { + // Skip "MPF\0" header + if mpf_data.len() < 4 || &mpf_data[0..4] != b"MPF\0" { + return None; + } + + let data = &mpf_data[4..]; + if data.len() < 8 { + return None; + } + + // Determine byte order + let little_endian = data[0] == b'I' && data[1] == b'I'; + + // Read helper + let read_u16 = |offset: usize| -> Option { + if offset + 2 > data.len() { + return None; + } + Some(if little_endian { + u16::from_le_bytes([data[offset], data[offset + 1]]) + } else { + u16::from_be_bytes([data[offset], data[offset + 1]]) + }) + }; + + let read_u32 = |offset: usize| -> Option { + if offset + 4 > data.len() { + return None; + } + Some(if little_endian { + u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) + } else { + u32::from_be_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) + }) + }; + + // Skip to first IFD (offset at byte 4-7 in TIFF header) + let ifd_offset = read_u32(4)? as usize; + if ifd_offset >= data.len() { + return None; + } + + // Read number of entries + let entry_count = read_u16(ifd_offset)?; + + // Look for MPEntry tag (0xB002) + let mut mp_entry_offset: Option = None; + let mut mp_entry_count: Option = None; + + for i in 0..entry_count { + let entry_start = ifd_offset + 2 + (i as usize * 12); + if entry_start + 12 > data.len() { + break; + } + + let tag = read_u16(entry_start)?; + + if tag == 0xB002 { + // MPEntry + mp_entry_count = Some(read_u32(entry_start + 4)?); + mp_entry_offset = Some(read_u32(entry_start + 8)? as usize); + break; + } + } + + // Parse MP entries to find gain map (second image) + let entry_offset = mp_entry_offset?; + let count = mp_entry_count? / 16; // 16 bytes per entry + + if count >= 2 { + // Second entry is the gain map + let second_entry_offset = entry_offset + 16; + if second_entry_offset + 16 <= data.len() { + // Entry format: 4 bytes flags, 4 bytes size, 4 bytes offset, 4 bytes dependent + let size = read_u32(second_entry_offset + 4)?; + let offset = read_u32(second_entry_offset + 8)?; + return Some((offset, size)); + } + } + + None +} + +/// Gets dimensions from a JPEG. +fn get_jpeg_dimensions(jpeg_data: &[u8]) -> Result<(u32, u32)> { + let parser = JpegParser::parse(jpeg_data)?; + parser.get_dimensions() + .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine gain map dimensions".to_string())) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_has_gainmap_metadata_non_jpeg() { + assert!(!has_gainmap_metadata(&[0x89, 0x50, 0x4E, 0x47])); // PNG + assert!(!has_gainmap_metadata(&[])); + assert!(!has_gainmap_metadata(&[0xFF])); + } + + #[test] + fn test_has_gainmap_metadata_regular_jpeg() { + // Minimal JPEG without gain map + let minimal_jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; + assert!(!has_gainmap_metadata(&minimal_jpeg)); + } + + #[test] + fn test_find_eoi_minimal_jpeg() { + let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; + let result = find_primary_eoi_offset(&jpeg); + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 2); + } + + #[test] + fn test_parse_mpf_invalid() { + assert!(parse_mpf_for_gainmap(&[]).is_none()); + assert!(parse_mpf_for_gainmap(b"NOTMPF").is_none()); + } +} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs b/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs new file mode 100644 index 00000000000000..f56ecfc74c8e7f --- /dev/null +++ b/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs @@ -0,0 +1,255 @@ +//! UltraHDR JPEG encoder. +//! +//! Creates UltraHDR JPEG files from SDR + HDR image pairs. + +use crate::error::{Result, UltraHdrError}; +use crate::types::{GainMapMetadata, UltraHdrEncodeOptions}; +use crate::gainmap::encode::compute_gain_map; +use crate::jpeg::parser::JpegParser; +use crate::jpeg::writer::JpegWriter; +use crate::jpeg::xmp::XmpWriter; +use image::{ImageBuffer, Luma}; +use std::io::Cursor; + +/// Encodes an UltraHDR JPEG from SDR and HDR image data. +/// +/// # Arguments +/// * `sdr_jpeg` - SDR JPEG image bytes +/// * `hdr_linear` - HDR linear RGB data (3 floats per pixel, normalized to [0,1]) +/// * `options` - Encoding options +/// +/// # Returns +/// The encoded UltraHDR JPEG as bytes. +pub fn encode( + sdr_jpeg: &[u8], + hdr_linear: &[f32], + options: &UltraHdrEncodeOptions, +) -> Result> { + // Validate options + validate_options(options)?; + + // Parse the SDR JPEG to get segments and dimensions + let parser = JpegParser::parse(sdr_jpeg)?; + let (width, height) = parser.get_dimensions() + .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine image dimensions".to_string()))?; + + // Validate dimensions + if width % 2 != 0 { + return Err(UltraHdrError::InvalidDimensions( + format!("Width must be even, got {}", width) + )); + } + if height % 2 != 0 { + return Err(UltraHdrError::InvalidDimensions( + format!("Height must be even, got {}", height) + )); + } + + // Decode SDR JPEG to get raw RGB data + let sdr_rgb = decode_jpeg_to_rgb(sdr_jpeg)?; + let expected_size = (width * height * 3) as usize; + if sdr_rgb.len() != expected_size { + return Err(UltraHdrError::InvalidDimensions(format!( + "SDR RGB size {} doesn't match dimensions {}x{}", + sdr_rgb.len(), width, height + ))); + } + + // Validate HDR data size + if hdr_linear.len() != expected_size { + return Err(UltraHdrError::DimensionMismatch( + width, height, + (hdr_linear.len() / 3) as u32 / height, height + )); + } + + // Compute gain map + let (gain_map_data, metadata) = compute_gain_map( + &sdr_rgb, + hdr_linear, + width, + height, + options.target_hdr_capacity, + options.gain_map_scale, + )?; + + // Calculate gain map dimensions + let scale = options.gain_map_scale.max(1) as u32; + let gm_width = (width + scale - 1) / scale; + let gm_height = (height + scale - 1) / scale; + + // Encode gain map as JPEG + let gain_map_jpeg = encode_gain_map_jpeg(&gain_map_data, gm_width, gm_height, options.gain_map_quality)?; + + // Create the final UltraHDR JPEG + create_ultrahdr_jpeg( + sdr_jpeg, + &gain_map_jpeg, + &metadata, + options, + ) +} + +/// Encodes an UltraHDR JPEG from already-computed components. +/// +/// Useful when you have pre-computed gain map data. +pub fn encode_from_components( + sdr_jpeg: &[u8], + gain_map_jpeg: &[u8], + metadata: &GainMapMetadata, + options: &UltraHdrEncodeOptions, +) -> Result> { + create_ultrahdr_jpeg(sdr_jpeg, gain_map_jpeg, metadata, options) +} + +/// Validates encoding options. +fn validate_options(options: &UltraHdrEncodeOptions) -> Result<()> { + if options.base_quality == 0 || options.base_quality > 100 { + return Err(UltraHdrError::InvalidQuality(options.base_quality)); + } + if options.gain_map_quality == 0 || options.gain_map_quality > 100 { + return Err(UltraHdrError::InvalidQuality(options.gain_map_quality)); + } + if options.target_hdr_capacity <= 0.0 { + return Err(UltraHdrError::InvalidHdrCapacity(0.0, options.target_hdr_capacity)); + } + Ok(()) +} + +/// Decodes a JPEG to raw RGB bytes. +fn decode_jpeg_to_rgb(jpeg_data: &[u8]) -> Result> { + let img = image::load_from_memory_with_format(jpeg_data, image::ImageFormat::Jpeg)?; + let rgb = img.to_rgb8(); + Ok(rgb.into_raw()) +} + +/// Encodes a grayscale gain map as JPEG. +fn encode_gain_map_jpeg(data: &[u8], width: u32, height: u32, quality: u8) -> Result> { + let img: ImageBuffer, Vec> = ImageBuffer::from_raw(width, height, data.to_vec()) + .ok_or_else(|| UltraHdrError::EncodeError("Failed to create gain map image".to_string()))?; + + let mut output = Cursor::new(Vec::new()); + let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut output, quality); + encoder.encode( + img.as_raw(), + width, + height, + image::ExtendedColorType::L8, + )?; + + Ok(output.into_inner()) +} + +/// Creates the final UltraHDR JPEG by combining SDR base with gain map. +fn create_ultrahdr_jpeg( + sdr_jpeg: &[u8], + gain_map_jpeg: &[u8], + metadata: &GainMapMetadata, + options: &UltraHdrEncodeOptions, +) -> Result> { + // Parse the SDR JPEG + let parser = JpegParser::parse(sdr_jpeg)?; + + // Create writer with existing segments + let mut writer = JpegWriter::new( + parser.segments().to_vec(), + parser.scan_data().to_vec(), + ); + + // Remove any existing XMP/MPF segments + writer.remove_xmp_segments(); + writer.remove_mpf_segments(); + + // Create and add XMP metadata + let xmp_data = if options.include_ultrahdr_v1 { + XmpWriter::create_combined_xmp(metadata)? + } else if options.include_iso_metadata { + XmpWriter::create_iso_xmp(metadata)? + } else { + return Err(UltraHdrError::MetadataError( + "At least one metadata format must be enabled".to_string() + )); + }; + + writer.add_xmp_segment(&xmp_data)?; + + // Write base JPEG first to calculate gain map offset + let base_jpeg = writer.write()?; + let gain_map_offset = base_jpeg.len() as u32; + + // Add MPF segment pointing to gain map + // Need to re-parse and re-write with MPF included + let parser2 = JpegParser::parse(&base_jpeg)?; + let mut writer2 = JpegWriter::new( + parser2.segments().to_vec(), + parser2.scan_data().to_vec(), + ); + + // Recalculate offset after adding MPF (MPF segment is ~100 bytes) + let estimated_mpf_size = 120; + let final_gain_map_offset = gain_map_offset + estimated_mpf_size; + + writer2.add_mpf_segment(final_gain_map_offset, gain_map_jpeg.len() as u32)?; + + // Write final output with gain map appended + writer2.write_with_gain_map(gain_map_jpeg) +} + +/// Re-encodes an SDR JPEG with specified quality. +pub fn reencode_jpeg(jpeg_data: &[u8], quality: u8) -> Result> { + let img = image::load_from_memory_with_format(jpeg_data, image::ImageFormat::Jpeg)?; + let rgb = img.to_rgb8(); + + let mut output = Cursor::new(Vec::new()); + let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut output, quality); + encoder.encode( + rgb.as_raw(), + rgb.width(), + rgb.height(), + image::ExtendedColorType::Rgb8, + )?; + + Ok(output.into_inner()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_validate_options_valid() { + let options = UltraHdrEncodeOptions::default(); + assert!(validate_options(&options).is_ok()); + } + + #[test] + fn test_validate_options_invalid_quality() { + let mut options = UltraHdrEncodeOptions::default(); + options.base_quality = 0; + assert!(validate_options(&options).is_err()); + + options.base_quality = 101; + assert!(validate_options(&options).is_err()); + } + + #[test] + fn test_validate_options_invalid_capacity() { + let mut options = UltraHdrEncodeOptions::default(); + options.target_hdr_capacity = -1.0; + assert!(validate_options(&options).is_err()); + } + + #[test] + fn test_encode_gain_map_jpeg() { + // Create a simple 2x2 gain map + let data = vec![0u8, 64, 128, 255]; + let result = encode_gain_map_jpeg(&data, 2, 2, 75); + assert!(result.is_ok()); + + let jpeg = result.unwrap(); + // Should be valid JPEG (starts with magic bytes) + assert!(jpeg.len() >= 2); + assert_eq!(jpeg[0], 0xFF); + assert_eq!(jpeg[1], 0xD8); + } +} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/mod.rs b/packages/ultrahdr-wasm/src/ultrahdr/mod.rs new file mode 100644 index 00000000000000..a8095f026ea1f9 --- /dev/null +++ b/packages/ultrahdr-wasm/src/ultrahdr/mod.rs @@ -0,0 +1,10 @@ +//! UltraHDR format handling. +//! +//! Implements encoding and decoding of UltraHDR JPEG images according to +//! ISO 21496-1 and Google's UltraHDR v1 specification. + +pub mod encoder; +pub mod decoder; + +pub use encoder::encode; +pub use decoder::{decode, has_gainmap_metadata, extract_base, extract_metadata}; diff --git a/packages/ultrahdr-wasm/tests/integration_tests.rs b/packages/ultrahdr-wasm/tests/integration_tests.rs new file mode 100644 index 00000000000000..87e3e5e2a5b168 --- /dev/null +++ b/packages/ultrahdr-wasm/tests/integration_tests.rs @@ -0,0 +1,358 @@ +//! Integration tests for UltraHDR WASM library. +//! +//! These tests verify the complete encode/decode workflow. + +use wordpress_ultrahdr::*; + +/// Test that encoding options can be created and validated. +#[test] +fn test_encode_options() { + let default_opts = UltraHdrEncodeOptions::new(); + assert_eq!(default_opts.base_quality, 85); + assert_eq!(default_opts.gain_map_quality, 75); + assert_eq!(default_opts.target_hdr_capacity, 3.0); + assert!(default_opts.include_iso_metadata); + assert!(default_opts.include_ultrahdr_v1); + + let hq_opts = UltraHdrEncodeOptions::high_quality(); + assert_eq!(hq_opts.base_quality, 95); + assert_eq!(hq_opts.target_hdr_capacity, 4.0); + + let small_opts = UltraHdrEncodeOptions::small_size(); + assert_eq!(small_opts.gain_map_scale, 2); +} + +/// Test that default metadata can be created and validated. +#[test] +fn test_default_metadata() { + let metadata = GainMapMetadata::new(); + assert_eq!(metadata.version, "1.0"); + assert!(!metadata.base_rendition_is_hdr); + assert_eq!(metadata.gain_map_min.len(), 3); + assert_eq!(metadata.gain_map_max.len(), 3); + assert_eq!(metadata.gamma.len(), 3); + assert_eq!(metadata.offset_sdr.len(), 3); + assert_eq!(metadata.offset_hdr.len(), 3); + + assert!(gainmap::metadata::validate_metadata(&metadata).is_ok()); +} + +/// Test SDR base metadata creation. +#[test] +fn test_sdr_base_metadata() { + let metadata = GainMapMetadata::for_sdr_base(4.0); + assert!(!metadata.base_rendition_is_hdr); + assert_eq!(metadata.hdr_capacity_max, 4.0); + assert_eq!(metadata.gain_map_max, vec![4.0, 4.0, 4.0]); +} + +/// Test metadata validation catches errors. +#[test] +fn test_metadata_validation() { + // Valid metadata should pass + let valid = GainMapMetadata::default(); + assert!(gainmap::metadata::validate_metadata(&valid).is_ok()); + + // Invalid channel count + let mut invalid = GainMapMetadata::default(); + invalid.gain_map_min = vec![0.0, 0.0]; // Only 2 values + assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); + + // Invalid gain range (min > max) + let mut invalid = GainMapMetadata::default(); + invalid.gain_map_min = vec![5.0, 5.0, 5.0]; + invalid.gain_map_max = vec![3.0, 3.0, 3.0]; + assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); + + // Invalid gamma (negative) + let mut invalid = GainMapMetadata::default(); + invalid.gamma = vec![1.0, -1.0, 1.0]; + assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); +} + +/// Test HDR headroom estimation. +#[test] +fn test_hdr_headroom_estimation() { + let metadata = GainMapMetadata { + gain_map_max: vec![3.0, 3.0, 3.0], + ..Default::default() + }; + assert_eq!(gainmap::metadata::estimate_hdr_headroom(&metadata), 3.0); + + let low_hdr = GainMapMetadata { + gain_map_max: vec![0.2, 0.2, 0.2], + ..Default::default() + }; + assert!(!gainmap::metadata::is_meaningful_hdr(&low_hdr)); + + let high_hdr = GainMapMetadata { + gain_map_max: vec![3.0, 3.0, 3.0], + ..Default::default() + }; + assert!(gainmap::metadata::is_meaningful_hdr(&high_hdr)); +} + +/// Test color space math roundtrips. +mod color_math_tests { + use wordpress_ultrahdr::gainmap::math::*; + + const TOLERANCE: f32 = 1e-5; + + fn approx_eq(a: f32, b: f32) -> bool { + (a - b).abs() < TOLERANCE + } + + #[test] + fn test_srgb_roundtrip() { + for i in 0..=10 { + let linear = i as f32 / 10.0; + let srgb = srgb_oetf(linear); + let back = srgb_inverse_oetf(srgb); + assert!(approx_eq(linear, back), "sRGB roundtrip failed at {}", linear); + } + } + + #[test] + fn test_pq_roundtrip() { + // PQ uses complex power functions with large exponents, so allow slightly larger tolerance + const PQ_TOLERANCE: f32 = 1e-4; + for i in 0..=10 { + let linear = i as f32 / 10.0; + let pq = pq_oetf(linear); + let back = pq_inverse_oetf(pq); + assert!((linear - back).abs() < PQ_TOLERANCE, "PQ roundtrip failed at {}", linear); + } + } + + #[test] + fn test_hlg_roundtrip() { + for i in 0..=10 { + let linear = i as f32 / 10.0; + let hlg = hlg_oetf(linear); + let back = hlg_inverse_oetf(hlg); + assert!(approx_eq(linear, back), "HLG roundtrip failed at {}", linear); + } + } + + #[test] + fn test_luminance_values() { + // Black should have 0 luminance + assert_eq!(luminance_bt709(0.0, 0.0, 0.0), 0.0); + + // White should have ~1.0 luminance + let white_luma = luminance_bt709(1.0, 1.0, 1.0); + assert!(approx_eq(white_luma, 1.0)); + + // Red, green, blue should sum to 1.0 + let r_luma = luminance_bt709(1.0, 0.0, 0.0); + let g_luma = luminance_bt709(0.0, 1.0, 0.0); + let b_luma = luminance_bt709(0.0, 0.0, 1.0); + assert!(approx_eq(r_luma + g_luma + b_luma, 1.0)); + } + + #[test] + fn test_gain_encode_decode() { + let ratios = [0.5, 1.0, 2.0, 4.0, 8.0]; + let min_gain = -1.0; + let max_gain = 3.0; + let gamma = 1.0; + + for &ratio in &ratios { + let encoded = encode_gain(ratio, min_gain, max_gain, gamma); + let decoded = decode_gain(encoded, min_gain, max_gain, gamma); + assert!(approx_eq(ratio, decoded), "Gain roundtrip failed at {}", ratio); + } + } + + #[test] + fn test_hdr_weight() { + // Full SDR + assert_eq!(compute_hdr_weight(0.0, 0.0, 3.0), 0.0); + // Full HDR + assert_eq!(compute_hdr_weight(3.0, 0.0, 3.0), 1.0); + // Mid point + assert!(approx_eq(compute_hdr_weight(1.5, 0.0, 3.0), 0.5)); + } +} + +/// Test XMP parsing and writing. +mod xmp_tests { + use wordpress_ultrahdr::jpeg::xmp::{XmpParser, XmpWriter}; + use wordpress_ultrahdr::GainMapMetadata; + + #[test] + fn test_xmp_roundtrip() { + let original = GainMapMetadata { + version: "1.0".to_string(), + base_rendition_is_hdr: false, + gain_map_min: vec![-1.0, -1.0, -1.0], + gain_map_max: vec![3.0, 3.0, 3.0], + gamma: vec![1.0, 1.0, 1.0], + offset_sdr: vec![0.015625, 0.015625, 0.015625], + offset_hdr: vec![0.015625, 0.015625, 0.015625], + hdr_capacity_min: 1.0, + hdr_capacity_max: 4.0, + }; + + let xmp = XmpWriter::create_iso_xmp(&original).unwrap(); + let parsed = XmpParser::parse(&xmp).unwrap(); + + assert_eq!(original.version, parsed.version); + assert_eq!(original.base_rendition_is_hdr, parsed.base_rendition_is_hdr); + assert_eq!(original.hdr_capacity_max, parsed.hdr_capacity_max); + } + + #[test] + fn test_has_gain_map_metadata() { + let xmp_with = b""; + let xmp_without = b""; + + assert!(XmpParser::has_gain_map_metadata(xmp_with)); + assert!(!XmpParser::has_gain_map_metadata(xmp_without)); + } +} + +/// Test JPEG parsing. +mod jpeg_tests { + use wordpress_ultrahdr::jpeg::parser::{JpegParser, MarkerType}; + + #[test] + fn test_minimal_jpeg() { + let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; + let parser = JpegParser::parse(&jpeg).unwrap(); + assert_eq!(parser.segments().len(), 2); + assert_eq!(parser.segments()[0].marker, MarkerType::Soi); + assert_eq!(parser.segments()[1].marker, MarkerType::Eoi); + } + + #[test] + fn test_invalid_jpeg() { + let not_jpeg = vec![0x89, 0x50, 0x4E, 0x47]; // PNG magic + assert!(JpegParser::parse(¬_jpeg).is_err()); + } + + #[test] + fn test_marker_type_conversion() { + assert_eq!(MarkerType::from_byte(0xD8), MarkerType::Soi); + assert_eq!(MarkerType::from_byte(0xD9), MarkerType::Eoi); + assert_eq!(MarkerType::from_byte(0xE1), MarkerType::App1); + assert_eq!(MarkerType::from_byte(0xE2), MarkerType::App2); + assert_eq!(MarkerType::App1.to_byte(), 0xE1); + } +} + +/// Test UltraHDR detection. +mod detection_tests { + use wordpress_ultrahdr::ultrahdr; + + #[test] + fn test_non_jpeg_detection() { + assert!(!ultrahdr::has_gainmap_metadata(&[])); + assert!(!ultrahdr::has_gainmap_metadata(&[0x89, 0x50, 0x4E, 0x47])); // PNG + assert!(!ultrahdr::has_gainmap_metadata(&[0xFF])); // Truncated + } + + #[test] + fn test_regular_jpeg_detection() { + let minimal_jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; + assert!(!ultrahdr::has_gainmap_metadata(&minimal_jpeg)); + } +} + +/// Test gain map computation. +mod gainmap_tests { + use wordpress_ultrahdr::gainmap::encode::compute_gain_map; + + #[test] + fn test_compute_gain_map_basic() { + let width = 4u32; + let height = 4u32; + + // Mid-gray SDR image + let sdr = vec![128u8; (width * height * 3) as usize]; + + // Slightly brighter HDR image (linear) + let hdr = vec![0.3f32; (width * height * 3) as usize]; + + let result = compute_gain_map(&sdr, &hdr, width, height, 3.0, 1); + assert!(result.is_ok()); + + let (gain_map, metadata) = result.unwrap(); + assert_eq!(gain_map.len(), (width * height) as usize); + assert_eq!(metadata.version, "1.0"); + assert!(!metadata.base_rendition_is_hdr); + } + + #[test] + fn test_compute_gain_map_with_scale() { + let width = 8u32; + let height = 8u32; + + let sdr = vec![128u8; (width * height * 3) as usize]; + let hdr = vec![0.3f32; (width * height * 3) as usize]; + + // Scale factor 2 should give 4x4 gain map + let (gain_map, _) = compute_gain_map(&sdr, &hdr, width, height, 3.0, 2).unwrap(); + assert_eq!(gain_map.len(), 16); // 4x4 + } + + #[test] + fn test_compute_gain_map_invalid_size() { + let sdr = vec![128u8; 12]; // 2x2x3 + let hdr = vec![0.3f32; 6]; // Wrong size + + let result = compute_gain_map(&sdr, &hdr, 2, 2, 3.0, 1); + assert!(result.is_err()); + } +} + +/// Test gain map application. +mod gainmap_apply_tests { + use wordpress_ultrahdr::gainmap::decode::apply_gain_map; + use wordpress_ultrahdr::GainMapMetadata; + + #[test] + fn test_apply_gain_map_basic() { + let width = 2u32; + let height = 2u32; + + // Mid-gray SDR image + let sdr = vec![128u8; 12]; + + // Neutral gain map (128 = ~1.0x gain) + let gain_map = vec![128u8; 4]; + + let metadata = GainMapMetadata::default(); + + let result = apply_gain_map( + &sdr, &gain_map, &metadata, + width, height, width, height, + 3.0 + ); + + assert!(result.is_ok()); + let hdr = result.unwrap(); + assert_eq!(hdr.len(), 12); // 2x2x3 floats + } + + #[test] + fn test_apply_gain_map_different_sizes() { + let width = 4u32; + let height = 4u32; + let gm_width = 2u32; + let gm_height = 2u32; + + let sdr = vec![128u8; 48]; // 4x4x3 + let gain_map = vec![128u8; 4]; // 2x2 + + let metadata = GainMapMetadata::default(); + + let result = apply_gain_map( + &sdr, &gain_map, &metadata, + width, height, gm_width, gm_height, + 3.0 + ); + + assert!(result.is_ok()); + } +} diff --git a/packages/ultrahdr/.gitignore b/packages/ultrahdr/.gitignore new file mode 100644 index 00000000000000..37856c18f7a1d5 --- /dev/null +++ b/packages/ultrahdr/.gitignore @@ -0,0 +1,4 @@ +# Build artifacts +/build/ +/build-module/ +/build-types/ diff --git a/packages/ultrahdr/README.md b/packages/ultrahdr/README.md new file mode 100644 index 00000000000000..d1be53a8cf10f3 --- /dev/null +++ b/packages/ultrahdr/README.md @@ -0,0 +1,139 @@ +# UltraHDR + +TypeScript bindings for UltraHDR (ISO 21496-1) gain map support in WordPress Gutenberg. + +## Installation + +```bash +npm install @wordpress/ultrahdr +``` + +## Usage + +```typescript +import { + setLocation, + isUltraHdr, + decodeUltraHdr, + extractSdrBase, + encodeUltraHdr, + defaultEncodeOptions +} from '@wordpress/ultrahdr'; + +// Set the location for WASM files (required before other calls) +setLocation('/path/to/wasm/'); + +// Check if an image is UltraHDR +const buffer = await file.arrayBuffer(); +if (await isUltraHdr(buffer)) { + console.log('This is an UltraHDR image!'); + + // Decode to get components + const result = await decodeUltraHdr('item-1', buffer); + console.log('Image size:', result.width, 'x', result.height); + console.log('HDR headroom:', result.metadata.hdrCapacityMax, 'stops'); + + // Extract just the SDR base for backwards compatibility + const sdrBuffer = await extractSdrBase(buffer); + const sdrBlob = new Blob([sdrBuffer], { type: 'image/jpeg' }); +} + +// Create UltraHDR from SDR + HDR inputs +const sdrBuffer = await sdrFile.arrayBuffer(); +const hdrLinearData = await getHdrLinearData(); // Float32Array + +const ultraHdr = await encodeUltraHdr('encode-1', sdrBuffer, hdrLinearData, { + ...defaultEncodeOptions, + targetHdrCapacity: 4.0, +}); +``` + +## API Reference + +### `setLocation(path: string): void` + +Sets the location/public path for loading WASM files. Must be called before using any other functions. + +### `isUltraHdr(buffer: ArrayBuffer): Promise` + +Checks if a buffer contains an UltraHDR image. Fast check that looks for gain map metadata without fully decoding. + +### `decodeUltraHdr(id: ItemId, buffer: ArrayBuffer): Promise` + +Decodes an UltraHDR image, extracting all components: +- `sdrImage`: The SDR base image as JPEG bytes +- `gainMap`: The gain map as JPEG bytes +- `metadata`: Gain map metadata +- `width`, `height`: Image dimensions +- `gainMapWidth`, `gainMapHeight`: Gain map dimensions + +### `encodeUltraHdr(id: ItemId, sdrBuffer: ArrayBuffer, hdrBuffer: ArrayBuffer, options?: Partial): Promise` + +Encodes an UltraHDR JPEG from SDR and HDR inputs. + +### `extractSdrBase(buffer: ArrayBuffer): Promise` + +Extracts the SDR base image from an UltraHDR JPEG. Returns a standard JPEG that can be displayed on any device. + +### `getMetadata(buffer: ArrayBuffer): Promise` + +Gets gain map metadata from an UltraHDR JPEG without full decode. + +### `validateMetadata(metadata: GainMapMetadata): Promise` + +Validates gain map metadata. + +### `estimateHdrHeadroom(metadata: GainMapMetadata): Promise` + +Estimates the HDR headroom (additional stops of dynamic range) from metadata. + +### `isMeaningfulHdr(metadata: GainMapMetadata): Promise` + +Checks if metadata indicates a meaningful HDR image (>0.5 stops headroom). + +## Types + +### `GainMapMetadata` + +```typescript +interface GainMapMetadata { + version: string; + baseRenditionIsHdr: boolean; + gainMapMin: number[]; + gainMapMax: number[]; + gamma: number[]; + offsetSdr: number[]; + offsetHdr: number[]; + hdrCapacityMin: number; + hdrCapacityMax: number; +} +``` + +### `UltraHdrEncodeOptions` + +```typescript +interface UltraHdrEncodeOptions { + baseQuality: number; // 1-100 + gainMapQuality: number; // 1-100 + targetHdrCapacity: number; // typically 2.0-4.0 + includeIsoMetadata: boolean; + includeUltrahdrV1: boolean; + gainMapScale: number; // 1, 2, or 4 +} +``` + +## Predefined Options + +- `defaultEncodeOptions` - Balanced quality/size +- `highQualityEncodeOptions` - Maximum quality +- `smallSizeEncodeOptions` - Smaller file size + +## Standards + +This package implements: +- [ISO 21496-1:2025](https://www.iso.org/standard/86775.html) - Gain map metadata +- [Google UltraHDR v1](https://developer.android.com/media/platform/hdr-image-format) - Android compatibility + +## License + +GPL-2.0-or-later diff --git a/packages/ultrahdr/package.json b/packages/ultrahdr/package.json new file mode 100644 index 00000000000000..3e002d820ee4da --- /dev/null +++ b/packages/ultrahdr/package.json @@ -0,0 +1,52 @@ +{ + "name": "@wordpress/ultrahdr", + "version": "1.0.0-prerelease", + "private": true, + "description": "UltraHDR (ISO 21496-1) gain map support for WordPress Gutenberg.", + "author": "The WordPress Contributors", + "license": "GPL-2.0-or-later", + "keywords": [ + "wordpress", + "media", + "ultrahdr", + "hdr", + "gain-map" + ], + "homepage": "https://github.com/WordPress/gutenberg/tree/HEAD/packages/ultrahdr/README.md", + "repository": { + "type": "git", + "url": "https://github.com/WordPress/gutenberg.git", + "directory": "packages/ultrahdr" + }, + "bugs": { + "url": "https://github.com/WordPress/gutenberg/issues" + }, + "engines": { + "node": ">=18.12.0", + "npm": ">=8.19.2" + }, + "files": [ + "src", + "build", + "build-module", + "build-types", + "*.md" + ], + "main": "build/index.cjs", + "module": "build-module/index.mjs", + "exports": { + ".": { + "types": "./build-types/index.d.ts", + "import": "./build-module/index.mjs", + "default": "./build/index.cjs" + }, + "./package.json": "./package.json" + }, + "types": "build-types", + "dependencies": { + "@wordpress/ultrahdr-wasm": "file:../ultrahdr-wasm" + }, + "publishConfig": { + "access": "public" + } +} diff --git a/packages/ultrahdr/src/index.ts b/packages/ultrahdr/src/index.ts new file mode 100644 index 00000000000000..00f369522d289e --- /dev/null +++ b/packages/ultrahdr/src/index.ts @@ -0,0 +1,324 @@ +/** + * WordPress UltraHDR Library + * + * TypeScript bindings for the UltraHDR WASM library. + * Provides detection, encoding, and decoding of UltraHDR JPEG images + * implementing ISO 21496-1 (gain map) specification. + * + * @example + * ```typescript + * import { isUltraHdr, decodeUltraHdr, setLocation } from '@wordpress/ultrahdr'; + * + * // Set the location for WASM files + * setLocation('/path/to/wasm/'); + * + * // Check if an image is UltraHDR + * const buffer = await file.arrayBuffer(); + * if (await isUltraHdr(buffer)) { + * const result = await decodeUltraHdr('item-1', buffer); + * console.log('HDR headroom:', result.metadata.hdrCapacityMax); + * } + * ``` + */ + +// Re-export types +export type { + ItemId, + GainMapMetadata, + UltraHdrDecodeResult, + UltraHdrEncodeOptions, +} from './types'; + +export { + ColorGamut, + TransferFunction, + defaultEncodeOptions, + highQualityEncodeOptions, + smallSizeEncodeOptions, +} from './types'; + +import type { + ItemId, + GainMapMetadata, + UltraHdrDecodeResult, + UltraHdrEncodeOptions, +} from './types'; + +import { defaultEncodeOptions } from './types'; + +// WASM module type (these come from the generated WASM bindings) +interface UltraHdrWasmModule { + default: ( moduleOrPath?: string | URL | Response ) => Promise< unknown >; + isUltraHdr: ( buffer: Uint8Array ) => boolean; + decodeUltraHdr: ( buffer: Uint8Array ) => UltraHdrDecodeResult; + encodeUltraHdr: ( + sdrBuffer: Uint8Array, + hdrBuffer: Float32Array, + options: UltraHdrEncodeOptions + ) => Uint8Array; + extractSdrBase: ( buffer: Uint8Array ) => Uint8Array; + getMetadata: ( buffer: Uint8Array ) => GainMapMetadata; + createDefaultOptions: () => UltraHdrEncodeOptions; + createHighQualityOptions: () => UltraHdrEncodeOptions; + createSmallSizeOptions: () => UltraHdrEncodeOptions; + createDefaultMetadata: () => GainMapMetadata; + validateMetadata: ( metadata: GainMapMetadata ) => boolean; + estimateHdrHeadroom: ( metadata: GainMapMetadata ) => number; + isMeaningfulHdr: ( metadata: GainMapMetadata ) => boolean; +} + +/** + * Location prefix for WASM files. + * Set this before calling any other functions. + */ +let location = ''; + +/** + * Cached WASM module instance. + */ +let wasmInstance: UltraHdrWasmModule | null = null; + +/** + * Promise for ongoing WASM initialization. + */ +let initPromise: Promise< UltraHdrWasmModule > | null = null; + +/** + * Sets the location/public path for loading WASM files. + * + * This must be called before using any other functions when the WASM + * files are not in the same directory as the JavaScript bundle. + * + * @param newLocation - Base URL or path where WASM files are located. + * + * @example + * ```typescript + * // Set location before any other calls + * setLocation('/wp-content/plugins/gutenberg/build/'); + * ``` + */ +export function setLocation( newLocation: string ): void { + location = newLocation; +} + +/** + * Gets the WASM module, initializing it if necessary. + */ +async function getWasm(): Promise< UltraHdrWasmModule > { + if ( wasmInstance ) { + return wasmInstance; + } + + if ( initPromise ) { + return initPromise; + } + + initPromise = ( async () => { + // Dynamic import of the WASM package + const UltraHdrWasm = ( await import( + '@wordpress/ultrahdr-wasm' + ) ) as unknown as UltraHdrWasmModule; + + // Initialize WASM with the location prefix for the .wasm file + // If location is set, construct the full URL to the WASM file + if ( location ) { + const wasmUrl = location + 'wordpress_ultrahdr_bg.wasm'; + await UltraHdrWasm.default( wasmUrl ); + } else { + // Let the WASM module use its default URL resolution (import.meta.url) + await UltraHdrWasm.default(); + } + + wasmInstance = UltraHdrWasm as unknown as UltraHdrWasmModule; + return wasmInstance; + } )(); + + return initPromise; +} + +/** + * Checks if a buffer contains an UltraHDR image. + * + * This is a fast check that looks for gain map metadata without + * fully decoding the image. + * + * @param buffer - JPEG file contents. + * @return True if the image contains UltraHDR/gain map data. + * + * @example + * ```typescript + * const buffer = await file.arrayBuffer(); + * if (await isUltraHdr(buffer)) { + * console.log('This is an UltraHDR image!'); + * } + * ``` + */ +export async function isUltraHdr( buffer: ArrayBuffer ): Promise< boolean > { + const wasm = await getWasm(); + return wasm.isUltraHdr( new Uint8Array( buffer ) ); +} + +/** + * Decodes an UltraHDR image, extracting all components. + * + * @param id - Unique identifier for this operation (for cancellation). + * @param buffer - UltraHDR JPEG file contents. + * @return Decoded result with SDR image, gain map, and metadata. + * + * @throws Error if the buffer is not a valid UltraHDR JPEG. + * + * @example + * ```typescript + * const buffer = await file.arrayBuffer(); + * const result = await decodeUltraHdr('upload-1', buffer); + * + * // Access components + * const sdrBlob = new Blob([result.sdrImage], { type: 'image/jpeg' }); + * console.log('Image size:', result.width, 'x', result.height); + * console.log('HDR capacity:', result.metadata.hdrCapacityMax); + * ``` + */ +export async function decodeUltraHdr( + id: ItemId, + buffer: ArrayBuffer +): Promise< UltraHdrDecodeResult > { + const wasm = await getWasm(); + return wasm.decodeUltraHdr( new Uint8Array( buffer ) ); +} + +/** + * Encodes an UltraHDR JPEG from SDR and HDR inputs. + * + * @param id - Unique identifier for this operation. + * @param sdrBuffer - SDR JPEG image bytes. + * @param hdrBuffer - HDR linear RGB data (Float32Array, 3 values per pixel). + * @param options - Encoding options. + * @return Encoded UltraHDR JPEG as ArrayBuffer. + * + * @throws Error if inputs are invalid or dimensions don't match. + * + * @example + * ```typescript + * const sdrBuffer = await sdrFile.arrayBuffer(); + * const hdrData = await getHdrLinearData(); // Float32Array + * + * const ultraHdr = await encodeUltraHdr('encode-1', sdrBuffer, hdrData, { + * ...defaultEncodeOptions, + * targetHdrCapacity: 4.0, + * }); + * + * // Create downloadable file + * const blob = new Blob([ultraHdr], { type: 'image/jpeg' }); + * ``` + */ +export async function encodeUltraHdr( + id: ItemId, + sdrBuffer: ArrayBuffer, + hdrBuffer: ArrayBuffer, + options?: Partial< UltraHdrEncodeOptions > +): Promise< ArrayBuffer > { + const wasm = await getWasm(); + const opts = { + ...defaultEncodeOptions, + ...options, + } as UltraHdrEncodeOptions; + + const result = wasm.encodeUltraHdr( + new Uint8Array( sdrBuffer ), + new Float32Array( hdrBuffer ), + opts + ); + + // Ensure we return a proper ArrayBuffer (not SharedArrayBuffer) + return result.buffer.slice( 0 ) as ArrayBuffer; +} + +/** + * Extracts the SDR base image from an UltraHDR JPEG. + * + * This produces a standard JPEG that can be displayed on any device, + * without the gain map metadata. Useful for backwards compatibility. + * + * @param buffer - UltraHDR JPEG file contents. + * @return Standard JPEG without gain map. + * + * @example + * ```typescript + * const ultraHdrBuffer = await file.arrayBuffer(); + * const sdrBuffer = await extractSdrBase(ultraHdrBuffer); + * + * // Use the SDR image for non-HDR displays + * const blob = new Blob([sdrBuffer], { type: 'image/jpeg' }); + * ``` + */ +export async function extractSdrBase( + buffer: ArrayBuffer +): Promise< ArrayBuffer > { + const wasm = await getWasm(); + const result = wasm.extractSdrBase( new Uint8Array( buffer ) ); + // Ensure we return a proper ArrayBuffer (not SharedArrayBuffer) + return result.buffer.slice( 0 ) as ArrayBuffer; +} + +/** + * Gets gain map metadata from an UltraHDR JPEG. + * + * This is faster than `decodeUltraHdr` when you only need the metadata. + * + * @param buffer - UltraHDR JPEG file contents. + * @return Gain map metadata. + * + * @throws Error if the buffer doesn't contain gain map metadata. + * + * @example + * ```typescript + * const metadata = await getMetadata(buffer); + * console.log('Version:', metadata.version); + * console.log('HDR headroom:', metadata.hdrCapacityMax, 'stops'); + * ``` + */ +export async function getMetadata( + buffer: ArrayBuffer +): Promise< GainMapMetadata > { + const wasm = await getWasm(); + return wasm.getMetadata( new Uint8Array( buffer ) ); +} + +/** + * Validates gain map metadata. + * + * @param metadata - The metadata to validate. + * @return True if the metadata is valid. + */ +export async function validateMetadata( + metadata: GainMapMetadata +): Promise< boolean > { + const wasm = await getWasm(); + return wasm.validateMetadata( metadata ); +} + +/** + * Estimates the HDR headroom from metadata. + * + * @param metadata - The gain map metadata. + * @return Maximum additional stops of dynamic range above SDR. + */ +export async function estimateHdrHeadroom( + metadata: GainMapMetadata +): Promise< number > { + const wasm = await getWasm(); + return wasm.estimateHdrHeadroom( metadata ); +} + +/** + * Checks if metadata indicates a meaningful HDR image. + * + * @param metadata - The gain map metadata. + * @return True if the gain map provides significant dynamic range extension. + */ +export async function isMeaningfulHdr( + metadata: GainMapMetadata +): Promise< boolean > { + const wasm = await getWasm(); + return wasm.isMeaningfulHdr( metadata ); +} diff --git a/packages/ultrahdr/src/types.ts b/packages/ultrahdr/src/types.ts new file mode 100644 index 00000000000000..f3a04b5be8eb14 --- /dev/null +++ b/packages/ultrahdr/src/types.ts @@ -0,0 +1,150 @@ +/** + * Unique identifier for an item being processed. + */ +export type ItemId = string; + +/** + * ISO 21496-1 Gain Map Metadata. + * + * Contains all the metadata required to interpret and apply a gain map + * according to the ISO 21496-1 specification. + */ +export interface GainMapMetadata { + /** Specification version (e.g., "1.0") */ + version: string; + + /** Whether the base rendition is HDR (false = SDR base, true = HDR base) */ + baseRenditionIsHdr: boolean; + + /** Minimum gain value per channel (RGB), in log2 scale */ + gainMapMin: number[]; + + /** Maximum gain value per channel (RGB), in log2 scale */ + gainMapMax: number[]; + + /** Gamma correction per channel (RGB) */ + gamma: number[]; + + /** SDR offset per channel (RGB), used for black point adjustment */ + offsetSdr: number[]; + + /** HDR offset per channel (RGB), used for black point adjustment */ + offsetHdr: number[]; + + /** Minimum HDR capacity (log2 scale) where gain map starts to apply */ + hdrCapacityMin: number; + + /** Maximum HDR capacity (log2 scale) for full HDR output */ + hdrCapacityMax: number; +} + +/** + * Result of decoding an UltraHDR image. + */ +export interface UltraHdrDecodeResult { + /** The SDR base image as JPEG bytes */ + sdrImage: Uint8Array; + + /** The gain map as JPEG bytes */ + gainMap: Uint8Array; + + /** Gain map metadata */ + metadata: GainMapMetadata; + + /** Image width in pixels */ + width: number; + + /** Image height in pixels */ + height: number; + + /** Gain map width in pixels (may differ from image width) */ + gainMapWidth: number; + + /** Gain map height in pixels (may differ from image height) */ + gainMapHeight: number; +} + +/** + * Options for encoding UltraHDR images. + */ +export interface UltraHdrEncodeOptions { + /** JPEG quality for the base image (1-100) */ + baseQuality: number; + + /** JPEG quality for the gain map (1-100) */ + gainMapQuality: number; + + /** Target HDR capacity (typically 2.0-4.0) */ + targetHdrCapacity: number; + + /** Whether to include ISO 21496-1 metadata */ + includeIsoMetadata: boolean; + + /** Whether to include UltraHDR v1 metadata for Android compatibility */ + includeUltrahdrV1: boolean; + + /** Downscale factor for the gain map (1 = same size, 2 = half, 4 = quarter) */ + gainMapScale: number; +} + +/** + * Color gamut enumeration for HDR images. + */ +export enum ColorGamut { + /** Standard sRGB color space (BT.709 primaries) */ + Srgb = 0, + /** Display P3 wide color gamut */ + DisplayP3 = 1, + /** BT.2100/BT.2020 wide color gamut (HDR) */ + Bt2100 = 2, +} + +/** + * Transfer function for encoding luminance. + */ +export enum TransferFunction { + /** sRGB transfer function (gamma ~2.2) */ + Srgb = 0, + /** Linear (no gamma) */ + Linear = 1, + /** Perceptual Quantizer (PQ) - SMPTE ST 2084 */ + Pq = 2, + /** Hybrid Log-Gamma (HLG) - BT.2100 */ + Hlg = 3, +} + +/** + * Default encoding options. + */ +export const defaultEncodeOptions: UltraHdrEncodeOptions = { + baseQuality: 85, + gainMapQuality: 75, + targetHdrCapacity: 3.0, + includeIsoMetadata: true, + includeUltrahdrV1: true, + gainMapScale: 1, +}; + +/** + * High quality encoding options. + */ +export const highQualityEncodeOptions: UltraHdrEncodeOptions = { + baseQuality: 95, + gainMapQuality: 85, + targetHdrCapacity: 4.0, + includeIsoMetadata: true, + includeUltrahdrV1: true, + gainMapScale: 1, +}; + +/** + * Small size encoding options. + */ +export const smallSizeEncodeOptions: UltraHdrEncodeOptions = { + baseQuality: 75, + gainMapQuality: 65, + targetHdrCapacity: 3.0, + includeIsoMetadata: true, + includeUltrahdrV1: true, + gainMapScale: 2, +}; diff --git a/packages/ultrahdr/tsconfig.json b/packages/ultrahdr/tsconfig.json new file mode 100644 index 00000000000000..7ff060ab6ce105 --- /dev/null +++ b/packages/ultrahdr/tsconfig.json @@ -0,0 +1,4 @@ +{ + "$schema": "https://json.schemastore.org/tsconfig.json", + "extends": "../../tsconfig.base.json" +} diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index 0d967ab5472bc9..5aede4a22ce5e7 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -56,6 +56,7 @@ "@wordpress/i18n": "file:../i18n", "@wordpress/preferences": "file:../preferences", "@wordpress/private-apis": "file:../private-apis", + "@wordpress/ultrahdr": "file:../ultrahdr", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", "uuid": "^9.0.1" diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index b06af25f2d6d43..3a806a28b62e06 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -76,6 +76,8 @@ type ActionCreators = { finalizeItem: typeof finalizeItem; updateItemProgress: typeof updateItemProgress; revokeBlobUrls: typeof revokeBlobUrls; + detectUltraHdr: typeof detectUltraHdr; + extractSdrItem: typeof extractSdrItem; < T = Record< string, unknown > >( args: T ): void; }; @@ -467,6 +469,14 @@ export function processItem( id: QueueItemId ) { case OperationType.Finalize: dispatch.finalizeItem( id ); break; + + case OperationType.DetectUltraHdr: + dispatch.detectUltraHdr( id ); + break; + + case OperationType.ExtractSdr: + dispatch.extractSdrItem( id ); + break; } }; } @@ -718,6 +728,9 @@ export async function getTranscodeImageOperation( * Or videos need to be compressed, and then need poster generation * before upload. * + * UltraHDR JPEG images will have their SDR base extracted for + * backwards compatibility. + * * @param id Item ID. */ export function prepareItem( id: QueueItemId ) { @@ -736,6 +749,11 @@ export function prepareItem( id: QueueItemId ) { file.type ); + // Check for UltraHDR in JPEG files before other operations. + if ( file.type === 'image/jpeg' ) { + operations.push( OperationType.DetectUltraHdr ); + } + // For images that can be processed by vips, check if we need to scale down based on threshold. if ( isImage && isVipsSupported ) { const { imageOutputFormats } = settings; @@ -786,6 +804,89 @@ export function prepareItem( id: QueueItemId ) { }; } +/** + * Detects if a JPEG is an UltraHDR image and queues SDR extraction if needed. + * + * @param id Item ID. + */ +export function detectUltraHdr( id: QueueItemId ) { + return async ( { select, dispatch }: ThunkArgs ) => { + const item = select.getItem( id ); + if ( ! item ) { + return; + } + + try { + // Dynamically import to avoid loading WASM unless needed + const { isUltraHdr } = await import( '@wordpress/ultrahdr' ); + const buffer = await item.file.arrayBuffer(); + + if ( await isUltraHdr( buffer ) ) { + // Add SDR extraction operation before upload + dispatch< AddOperationsAction >( { + type: Type.AddOperations, + id, + operations: [ OperationType.ExtractSdr ], + } ); + } + } catch ( error ) { + // If UltraHDR detection fails, continue with regular upload + // eslint-disable-next-line no-console + console.warn( 'UltraHDR detection failed:', error ); + } + + dispatch.finishOperation( id, {} ); + }; +} + +/** + * Extracts the SDR base from an UltraHDR JPEG. + * + * This creates a backwards-compatible JPEG that can be displayed + * on non-HDR displays while preserving the original UltraHDR file. + * + * @param id Item ID. + */ +export function extractSdrItem( id: QueueItemId ) { + return async ( { select, dispatch }: ThunkArgs ) => { + const item = select.getItem( id ); + if ( ! item ) { + return; + } + + try { + const { extractSdrBase } = await import( '@wordpress/ultrahdr' ); + const buffer = await item.file.arrayBuffer(); + const sdrBuffer = await extractSdrBase( buffer ); + + // Create a new file with the SDR base + // Keep original as sourceFile, use SDR for upload + const sdrBlob = new Blob( [ sdrBuffer ], { type: 'image/jpeg' } ); + const sdrFile = new File( [ sdrBlob ], item.file.name, { + type: 'image/jpeg', + } ); + + // Update item with SDR file while keeping original as source + dispatch.finishOperation( id, { + file: sdrFile, + attachment: { + ...item.attachment, + // Mark as having HDR variant available + meta: { + ...( item.attachment?.meta || {} ), + ultrahdr_original: true, + }, + }, + } ); + } catch ( error ) { + // If extraction fails, continue with original file + // eslint-disable-next-line no-console + console.warn( 'UltraHDR SDR extraction failed:', error ); + dispatch.finishOperation( id, {} ); + } + }; +} + /** * Uploads an item to the server. * diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index da9c1d11661f8c..98d91a5f6c3e90 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -238,6 +238,10 @@ export enum OperationType { TranscodeImage = 'TRANSCODE_IMAGE', ThumbnailGeneration = 'THUMBNAIL_GENERATION', Finalize = 'FINALIZE', + // UltraHDR operations + DetectUltraHdr = 'DETECT_ULTRAHDR', + ExtractSdr = 'EXTRACT_SDR', + CreateUltraHdr = 'CREATE_ULTRAHDR', } /** diff --git a/tsconfig.json b/tsconfig.json index 7489ddc31c0bf7..2fe0ecc3d5ae25 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -73,6 +73,7 @@ { "path": "packages/token-list" }, { "path": "packages/ui" }, { "path": "packages/undo-manager" }, + { "path": "packages/ultrahdr" }, { "path": "packages/upload-media" }, { "path": "packages/url" }, { "path": "packages/views" }, From 86f2549285df1ad4125888b762d943526aaca128 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 22 Jan 2026 08:25:48 -0800 Subject: [PATCH 02/33] UltraHDR: Switch to open-ultrahdr-wasm npm package Replace the local @wordpress/ultrahdr-wasm dependency with the published open-ultrahdr-wasm package from npm, updating imports and WASM file paths accordingly. Co-Authored-By: Claude Opus 4.5 --- package-lock.json | 11 ++++++++++- packages/ultrahdr/package.json | 2 +- packages/ultrahdr/src/index.ts | 4 ++-- 3 files changed, 13 insertions(+), 4 deletions(-) diff --git a/package-lock.json b/package-lock.json index c3d0fcf3b95d6d..eb99e1fbe9ae88 100644 --- a/package-lock.json +++ b/package-lock.json @@ -44522,6 +44522,15 @@ "node": ">=8" } }, + "node_modules/open-ultrahdr-wasm": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.1.tgz", + "integrity": "sha512-y/OmK8QW2FN0SuTKGoIZtMI1p4A3YaqHuIM8491tdCWN+LX1Qmc4VI8A4QVv6RkBI+H2J3MNsw/Rx0SH/PdcAw==", + "license": "GPL-2.0-or-later", + "engines": { + "node": ">=18.0.0" + } + }, "node_modules/opencv-bindings": { "version": "4.5.5", "resolved": "https://registry.npmjs.org/opencv-bindings/-/opencv-bindings-4.5.5.tgz", @@ -62707,7 +62716,7 @@ "version": "1.0.0-prerelease", "license": "GPL-2.0-or-later", "dependencies": { - "@wordpress/ultrahdr-wasm": "file:../ultrahdr-wasm" + "open-ultrahdr-wasm": "^0.1.1" }, "engines": { "node": ">=18.12.0", diff --git a/packages/ultrahdr/package.json b/packages/ultrahdr/package.json index 3e002d820ee4da..94e796cd01e5f7 100644 --- a/packages/ultrahdr/package.json +++ b/packages/ultrahdr/package.json @@ -44,7 +44,7 @@ }, "types": "build-types", "dependencies": { - "@wordpress/ultrahdr-wasm": "file:../ultrahdr-wasm" + "open-ultrahdr-wasm": "^0.1.1" }, "publishConfig": { "access": "public" diff --git a/packages/ultrahdr/src/index.ts b/packages/ultrahdr/src/index.ts index 00f369522d289e..83d8ae2a43afdb 100644 --- a/packages/ultrahdr/src/index.ts +++ b/packages/ultrahdr/src/index.ts @@ -116,13 +116,13 @@ async function getWasm(): Promise< UltraHdrWasmModule > { initPromise = ( async () => { // Dynamic import of the WASM package const UltraHdrWasm = ( await import( - '@wordpress/ultrahdr-wasm' + 'open-ultrahdr-wasm' ) ) as unknown as UltraHdrWasmModule; // Initialize WASM with the location prefix for the .wasm file // If location is set, construct the full URL to the WASM file if ( location ) { - const wasmUrl = location + 'wordpress_ultrahdr_bg.wasm'; + const wasmUrl = location + 'open_ultrahdr_bg.wasm'; await UltraHdrWasm.default( wasmUrl ); } else { // Let the WASM module use its default URL resolution (import.meta.url) From 536b5130a1a17377e6ea18a2837d9dac562809bb Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 22 Jan 2026 12:02:50 -0800 Subject: [PATCH 03/33] UltraHDR: Replace local packages with open-ultrahdr npm package Switch from the local @wordpress/ultrahdr and @wordpress/ultrahdr-wasm packages to the published open-ultrahdr npm package, which provides identical functionality. This removes ~28 local files and simplifies the dependency chain. Co-Authored-By: Claude Opus 4.5 --- package-lock.json | 6316 +++++++++-------- packages/ultrahdr-wasm/.gitignore | 6 - packages/ultrahdr-wasm/Cargo.lock | 533 -- packages/ultrahdr-wasm/Cargo.toml | 39 - packages/ultrahdr-wasm/README.md | 81 - packages/ultrahdr-wasm/package.json | 47 - packages/ultrahdr-wasm/src/error.rs | 84 - packages/ultrahdr-wasm/src/gainmap/decode.rs | 343 - packages/ultrahdr-wasm/src/gainmap/encode.rs | 257 - packages/ultrahdr-wasm/src/gainmap/math.rs | 432 -- .../ultrahdr-wasm/src/gainmap/metadata.rs | 223 - packages/ultrahdr-wasm/src/gainmap/mod.rs | 13 - packages/ultrahdr-wasm/src/jpeg/mod.rs | 14 - packages/ultrahdr-wasm/src/jpeg/parser.rs | 394 - packages/ultrahdr-wasm/src/jpeg/writer.rs | 284 - packages/ultrahdr-wasm/src/jpeg/xmp.rs | 374 - packages/ultrahdr-wasm/src/lib.rs | 293 - packages/ultrahdr-wasm/src/types.rs | 257 - .../ultrahdr-wasm/src/ultrahdr/decoder.rs | 325 - .../ultrahdr-wasm/src/ultrahdr/encoder.rs | 255 - packages/ultrahdr-wasm/src/ultrahdr/mod.rs | 10 - .../ultrahdr-wasm/tests/integration_tests.rs | 358 - packages/ultrahdr/.gitignore | 4 - packages/ultrahdr/README.md | 139 - packages/ultrahdr/package.json | 52 - packages/ultrahdr/src/index.ts | 324 - packages/ultrahdr/src/types.ts | 150 - packages/ultrahdr/tsconfig.json | 4 - packages/upload-media/package.json | 2 +- .../upload-media/src/store/private-actions.ts | 4 +- tsconfig.json | 1 - 31 files changed, 3311 insertions(+), 8307 deletions(-) delete mode 100644 packages/ultrahdr-wasm/.gitignore delete mode 100644 packages/ultrahdr-wasm/Cargo.lock delete mode 100644 packages/ultrahdr-wasm/Cargo.toml delete mode 100644 packages/ultrahdr-wasm/README.md delete mode 100644 packages/ultrahdr-wasm/package.json delete mode 100644 packages/ultrahdr-wasm/src/error.rs delete mode 100644 packages/ultrahdr-wasm/src/gainmap/decode.rs delete mode 100644 packages/ultrahdr-wasm/src/gainmap/encode.rs delete mode 100644 packages/ultrahdr-wasm/src/gainmap/math.rs delete mode 100644 packages/ultrahdr-wasm/src/gainmap/metadata.rs delete mode 100644 packages/ultrahdr-wasm/src/gainmap/mod.rs delete mode 100644 packages/ultrahdr-wasm/src/jpeg/mod.rs delete mode 100644 packages/ultrahdr-wasm/src/jpeg/parser.rs delete mode 100644 packages/ultrahdr-wasm/src/jpeg/writer.rs delete mode 100644 packages/ultrahdr-wasm/src/jpeg/xmp.rs delete mode 100644 packages/ultrahdr-wasm/src/lib.rs delete mode 100644 packages/ultrahdr-wasm/src/types.rs delete mode 100644 packages/ultrahdr-wasm/src/ultrahdr/decoder.rs delete mode 100644 packages/ultrahdr-wasm/src/ultrahdr/encoder.rs delete mode 100644 packages/ultrahdr-wasm/src/ultrahdr/mod.rs delete mode 100644 packages/ultrahdr-wasm/tests/integration_tests.rs delete mode 100644 packages/ultrahdr/.gitignore delete mode 100644 packages/ultrahdr/README.md delete mode 100644 packages/ultrahdr/package.json delete mode 100644 packages/ultrahdr/src/index.ts delete mode 100644 packages/ultrahdr/src/types.ts delete mode 100644 packages/ultrahdr/tsconfig.json diff --git a/package-lock.json b/package-lock.json index eb99e1fbe9ae88..7de5b7797d8c9f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1339,69 +1339,17 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@ariakit/core": { - "version": "0.4.18", - "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", - "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", - "license": "MIT" - }, - "node_modules/@ariakit/react": { - "version": "0.4.21", - "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.21.tgz", - "integrity": "sha512-UjP99Y7cWxA5seRECEE0RPZFImkLGFIWPflp65t0BVZwlMw4wp9OJZRHMrnkEkKl5KBE2NR/gbbzwHc6VNGzsA==", + "node_modules/@arraypress/waveform-player": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@arraypress/waveform-player/-/waveform-player-1.2.1.tgz", + "integrity": "sha512-PsgOZStUN+1GnY0tujbwk2PYE3HMT/Vl3wEvunqH16hIJWzisf8GEngy5EbswTAjQ1aV3Tk4XBkAskc8eslY1A==", "license": "MIT", - "dependencies": { - "@ariakit/react-core": "0.4.21" + "engines": { + "node": ">=14.0.0" }, "funding": { - "type": "opencollective", - "url": "https://opencollective.com/ariakit" - }, - "peerDependencies": { - "react": "^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, - "node_modules/@ariakit/react-core": { - "version": "0.4.21", - "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.21.tgz", - "integrity": "sha512-rUI9uB/gT3mROFja/ka7/JukkdljIZR3eq3BGiQqX4Ni/KBMDvPK8FvVLnC0TGzWcqNY2bbfve8QllvHzuw4fQ==", - "license": "MIT", - "dependencies": { - "@ariakit/core": "0.4.18", - "@floating-ui/dom": "^1.0.0", - "use-sync-external-store": "^1.2.0" - }, - "peerDependencies": { - "react": "^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, - "node_modules/@ariakit/test": { - "version": "0.4.13", - "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", - "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@ariakit/core": "0.4.18", - "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" - }, - "peerDependencies": { - "@playwright/test": "^1.27.0", - "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", - "react": "^17.0.0 || ^18.0.0 || ^19.0.0" - }, - "peerDependenciesMeta": { - "@playwright/test": { - "optional": true - }, - "@testing-library/react": { - "optional": true - }, - "react": { - "optional": true - } + "type": "github", + "url": "https://github.com/sponsors/arraypress" } }, "node_modules/@asamuzakjp/css-color": { @@ -1432,9 +1380,9 @@ } }, "node_modules/@babel/code-frame": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.28.6.tgz", - "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", "license": "MIT", "dependencies": { "@babel/helper-validator-identifier": "^7.28.5", @@ -1498,13 +1446,13 @@ } }, "node_modules/@babel/generator": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.6.tgz", - "integrity": "sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==", + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", "license": "MIT", "dependencies": { - "@babel/parser": "^7.28.6", - "@babel/types": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" @@ -2093,12 +2041,12 @@ } }, "node_modules/@babel/parser": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.6.tgz", - "integrity": "sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==", + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", "license": "MIT", "dependencies": { - "@babel/types": "^7.28.6" + "@babel/types": "^7.29.0" }, "bin": { "parser": "bin/babel-parser.js" @@ -3986,9 +3934,9 @@ } }, "node_modules/@babel/runtime": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz", - "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz", + "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==", "license": "MIT", "engines": { "node": ">=6.9.0" @@ -4053,9 +4001,9 @@ } }, "node_modules/@babel/types": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.6.tgz", - "integrity": "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.27.1", @@ -4065,72 +4013,6 @@ "node": ">=6.9.0" } }, - "node_modules/@base-ui/react": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@base-ui/react/-/react-1.2.0.tgz", - "integrity": "sha512-O6aEQHcm+QyGTFY28xuwRD3SEJGZOBDpyjN2WvpfWYFVhg+3zfXPysAILqtM0C1kWC82MccOE/v1j+GHXE4qIw==", - "license": "MIT", - "dependencies": { - "@babel/runtime": "^7.28.6", - "@base-ui/utils": "0.2.5", - "@floating-ui/react-dom": "^2.1.6", - "@floating-ui/utils": "^0.2.10", - "tabbable": "^6.4.0", - "use-sync-external-store": "^1.6.0" - }, - "engines": { - "node": ">=14.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/mui-org" - }, - "peerDependencies": { - "@types/react": "^17 || ^18 || ^19", - "react": "^17 || ^18 || ^19", - "react-dom": "^17 || ^18 || ^19" - }, - "peerDependenciesMeta": { - "@types/react": { - "optional": true - } - } - }, - "node_modules/@base-ui/react/node_modules/@floating-ui/react-dom": { - "version": "2.1.6", - "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.6.tgz", - "integrity": "sha512-4JX6rEatQEvlmgU80wZyq9RT96HZJa88q8hp0pBd+LrczeDI4o6uA2M+uvxngVHo4Ihr8uibXxH6+70zhAFrVw==", - "license": "MIT", - "dependencies": { - "@floating-ui/dom": "^1.7.4" - }, - "peerDependencies": { - "react": ">=16.8.0", - "react-dom": ">=16.8.0" - } - }, - "node_modules/@base-ui/utils": { - "version": "0.2.5", - "resolved": "https://registry.npmjs.org/@base-ui/utils/-/utils-0.2.5.tgz", - "integrity": "sha512-oYC7w0gp76RI5MxprlGLV0wze0SErZaRl3AAkeP3OnNB/UBMb6RqNf6ZSIlxOc9Qp68Ab3C2VOcJQyRs7Xc7Vw==", - "license": "MIT", - "dependencies": { - "@babel/runtime": "^7.28.6", - "@floating-ui/utils": "^0.2.10", - "reselect": "^5.1.1", - "use-sync-external-store": "^1.6.0" - }, - "peerDependencies": { - "@types/react": "^17 || ^18 || ^19", - "react": "^17 || ^18 || ^19", - "react-dom": "^17 || ^18 || ^19" - }, - "peerDependenciesMeta": { - "@types/react": { - "optional": true - } - } - }, "node_modules/@bcoe/v8-coverage": { "version": "0.2.3", "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", @@ -4487,7 +4369,6 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", - "license": "MIT", "engines": { "node": ">=10" }, @@ -4499,7 +4380,6 @@ "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", - "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } @@ -5953,9 +5833,9 @@ } }, "node_modules/@jest/diff-sequences": { - "version": "30.0.1", - "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.0.1.tgz", - "integrity": "sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.3.0.tgz", + "integrity": "sha512-cG51MVnLq1ecVUaQ3fr6YuuAOitHK1S4WUJHnsPFE/quQr33ADUx1FfrTCpMCRxvy0Yr9BThKpDjSlcTi91tMA==", "dev": true, "license": "MIT", "engines": { @@ -6404,13 +6284,13 @@ } }, "node_modules/@jest/snapshot-utils": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.2.0.tgz", - "integrity": "sha512-0aVxM3RH6DaiLcjj/b0KrIBZhSX1373Xci4l3cW5xiUWPctZ59zQ7jj4rqcJQ/Z8JuN/4wX3FpJSa3RssVvCug==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.3.0.tgz", + "integrity": "sha512-ORbRN9sf5PP82v3FXNSwmO1OTDR2vzR2YTaR+E3VkSBZ8zadQE6IqYdYEeFH1NIkeB2HIGdF02dapb6K0Mj05g==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", "natural-compare": "^1.4.0" @@ -6433,9 +6313,9 @@ } }, "node_modules/@jest/snapshot-utils/node_modules/@jest/types": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", - "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", + "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", "dev": true, "license": "MIT", "dependencies": { @@ -6597,120 +6477,6 @@ "node": "^14.15.0 || ^16.10.0 || >=18.0.0" } }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/lru-cache": { - "version": "11.2.6", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.6.tgz", - "integrity": "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "node_modules/@jridgewell/gen-mapping": { "version": "0.3.13", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", @@ -7857,18 +7623,6 @@ "node": ">=8.0.0" } }, - "node_modules/@noble/hashes": { - "version": "1.4.0", - "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.4.0.tgz", - "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==", - "license": "MIT", - "engines": { - "node": ">= 16" - }, - "funding": { - "url": "https://paulmillr.com/funding/" - } - }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", @@ -10588,176 +10342,25 @@ "integrity": "sha512-KxWFdRNbv13U8bhYaQvH6gLG9CVEt2jKeosyOOYILVntWEVWhovbgDrbOiZ12pJO3vjZs0Zgbd3/Zgde98woEA==", "license": "BSD-3-Clause" }, - "node_modules/@peculiar/asn1-cms": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz", - "integrity": "sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "@peculiar/asn1-x509-attr": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-csr": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz", - "integrity": "sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-ecc": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz", - "integrity": "sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-pfx": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz", - "integrity": "sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-cms": "^2.6.1", - "@peculiar/asn1-pkcs8": "^2.6.1", - "@peculiar/asn1-rsa": "^2.6.1", - "@peculiar/asn1-schema": "^2.6.0", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-pkcs8": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz", - "integrity": "sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-pkcs9": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz", - "integrity": "sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-cms": "^2.6.1", - "@peculiar/asn1-pfx": "^2.6.1", - "@peculiar/asn1-pkcs8": "^2.6.1", - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "@peculiar/asn1-x509-attr": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-rsa": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz", - "integrity": "sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-schema": { - "version": "2.6.0", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz", - "integrity": "sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==", - "license": "MIT", - "dependencies": { - "asn1js": "^3.0.6", - "pvtsutils": "^1.3.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-x509": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz", - "integrity": "sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "asn1js": "^3.0.6", - "pvtsutils": "^1.3.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/asn1-x509-attr": { - "version": "2.6.1", - "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz", - "integrity": "sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.1", - "asn1js": "^3.0.6", - "tslib": "^2.8.1" - } - }, - "node_modules/@peculiar/x509": { - "version": "1.14.3", - "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz", - "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==", - "license": "MIT", - "dependencies": { - "@peculiar/asn1-cms": "^2.6.0", - "@peculiar/asn1-csr": "^2.6.0", - "@peculiar/asn1-ecc": "^2.6.0", - "@peculiar/asn1-pkcs9": "^2.6.0", - "@peculiar/asn1-rsa": "^2.6.0", - "@peculiar/asn1-schema": "^2.6.0", - "@peculiar/asn1-x509": "^2.6.0", - "pvtsutils": "^1.3.6", - "reflect-metadata": "^0.2.2", - "tslib": "^2.8.1", - "tsyringe": "^4.10.0" - }, - "engines": { - "node": ">=20.0.0" - } - }, "node_modules/@php-wasm/cli-util": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/cli-util/-/cli-util-3.0.52.tgz", - "integrity": "sha512-znW/+lDWIqlCxe4vhaNuT7Cw3PkTwCFZ0raiivjvYtlHmQc0nSKGMY+8gH3bBkpxEnjXrR0RSmU2UuzQFUM5JA==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/cli-util/-/cli-util-3.1.12.tgz", + "integrity": "sha512-DpOeQotdE4QVF0/ynmC1PawelIIzk6DkLuOZ1oF/+S/kXAyrMp8LoAbDGf4Iii8CordDmIOp+Ab2JTllTvEd2Q==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/util": "3.0.52", - "fast-xml-parser": "^5.3.4", + "@php-wasm/util": "3.1.12", + "fast-xml-parser": "^5.5.1", "jsonc-parser": "3.3.1" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/cli-util/node_modules/fast-xml-parser": { - "version": "5.3.5", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.5.tgz", - "integrity": "sha512-JeaA2Vm9ffQKp9VjvfzObuMCjUYAp5WDYhRYL5LrBPY/jUDlUtOvDfot0vKSkB9tuX885BDHjtw4fZadD95wnA==", + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", "funding": [ { "type": "github", @@ -10766,6 +10369,8 @@ ], "license": "MIT", "dependencies": { + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", "strnum": "^2.1.2" }, "bin": { @@ -10773,9 +10378,9 @@ } }, "node_modules/@php-wasm/cli-util/node_modules/strnum": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.1.2.tgz", - "integrity": "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", "funding": [ { "type": "github", @@ -10784,540 +10389,176 @@ ], "license": "MIT" }, - "node_modules/@php-wasm/fs-journal": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/fs-journal/-/fs-journal-3.0.52.tgz", - "integrity": "sha512-OaG1VAIvG2c/7IXfM4Q7tSETq116kXsf+EPzqtWev4oNGU/fMlAEDByRmHC7DYI4Da0tT9YwpVYPiByj4zae1g==", + "node_modules/@php-wasm/logger": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/logger/-/logger-3.1.12.tgz", + "integrity": "sha512-6isXP5+KDaTB11034XGDtYW7/y+5ZhOODAePHs97k52TIvUQn9T0BfKYR1Zbcvdtuh/jy7i2Q3JYlIHTvxBUEg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/node-polyfills": "3.1.12" + }, + "engines": { + "node": ">=20.10.0", + "npm": ">=10.2.3" + } + }, + "node_modules/@php-wasm/node": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node/-/node-3.1.12.tgz", + "integrity": "sha512-gOl1VQ+/I39euhU+2GpLsSFDaExdDwAb7INkqMDviXrz7pShAtxG18dezYX7gsKM8Gr0Okdyccv0lE0KsQnGWA==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", + "@php-wasm/cli-util": "3.1.12", + "@php-wasm/logger": "3.1.12", + "@php-wasm/node-7-4": "3.1.12", + "@php-wasm/node-8-0": "3.1.12", + "@php-wasm/node-8-1": "3.1.12", + "@php-wasm/node-8-2": "3.1.12", + "@php-wasm/node-8-3": "3.1.12", + "@php-wasm/node-8-4": "3.1.12", + "@php-wasm/node-8-5": "3.1.12", + "@php-wasm/node-polyfills": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", + "@wp-playground/common": "3.1.12", "express": "4.22.0", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", "ini": "4.1.2", + "jsonc-parser": "3.3.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/fs-journal/node_modules/body-parser": { - "version": "1.20.4", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", - "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", - "license": "MIT", + "node_modules/@php-wasm/node-7-4": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-7-4/-/node-7-4-3.1.12.tgz", + "integrity": "sha512-5Sb/b8u6J7Q4iDqm0bF0UHj38xqti7K9Xtzf/j54AwOy4lTDfDbnMlw3QOVSxY2iEOLn7qHDGPZc4dAuFmxVrQ==", + "license": "GPL-2.0-or-later", "dependencies": { - "bytes": "~3.1.2", - "content-type": "~1.0.5", - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "~1.2.0", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "on-finished": "~2.4.1", - "qs": "~6.14.0", - "raw-body": "~2.5.3", - "type-is": "~1.6.18", - "unpipe": "~1.0.0" + "@php-wasm/universal": "3.1.12", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" }, "engines": { - "node": ">= 0.8", - "npm": "1.2.8000 || >= 1.4.16" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/fs-journal/node_modules/bytes": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", - "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", - "license": "MIT", + "node_modules/@php-wasm/node-7-4/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", "engines": { - "node": ">= 0.8" + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, - "node_modules/@php-wasm/fs-journal/node_modules/cookie": { - "version": "0.7.2", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", - "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "node_modules/@php-wasm/node-7-4/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", "license": "MIT", "engines": { - "node": ">= 0.6" + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } } }, - "node_modules/@php-wasm/fs-journal/node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "license": "MIT", + "node_modules/@php-wasm/node-8-0": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-0/-/node-8-0-3.1.12.tgz", + "integrity": "sha512-I1OxJJN5Hh9t81TQ73lbRjAP++Uz7uteilGETRqtPQi/kDa2iweYM+vuwLAp1t5DW3XZw0+O0cq2dTzyW9FXwA==", + "license": "GPL-2.0-or-later", "dependencies": { - "ms": "2.0.0" + "@php-wasm/universal": "3.1.12", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" + }, + "engines": { + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/fs-journal/node_modules/depd": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", - "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", - "license": "MIT", + "node_modules/@php-wasm/node-8-0/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", "engines": { - "node": ">= 0.8" + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, - "node_modules/@php-wasm/fs-journal/node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "node_modules/@php-wasm/node-8-0/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", "license": "MIT", "engines": { - "node": ">= 0.8" + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } } }, - "node_modules/@php-wasm/fs-journal/node_modules/express": { - "version": "4.22.0", - "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", - "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", - "license": "MIT", + "node_modules/@php-wasm/node-8-1": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-1/-/node-8-1-3.1.12.tgz", + "integrity": "sha512-CYROT4gdgxbnS3vCrogQMz5sqT2rzeSuNdn7wTDV43uGRyLONfj7jkqjlGalIIe2rVhrP1JIRTMW5Ju+N0OMHg==", + "license": "GPL-2.0-or-later", "dependencies": { - "accepts": "~1.3.8", - "array-flatten": "1.1.1", - "body-parser": "~1.20.3", - "content-disposition": "~0.5.4", - "content-type": "~1.0.4", - "cookie": "~0.7.1", - "cookie-signature": "~1.0.6", - "debug": "2.6.9", - "depd": "2.0.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "~1.3.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.0", - "merge-descriptors": "1.0.3", - "methods": "~1.1.2", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "path-to-regexp": "~0.1.12", - "proxy-addr": "~2.0.7", - "qs": "~6.14.0", - "range-parser": "~1.2.1", - "safe-buffer": "5.2.1", - "send": "~0.19.0", - "serve-static": "~1.16.2", - "setprototypeof": "1.2.0", - "statuses": "~2.0.1", - "type-is": "~1.6.18", - "utils-merge": "1.0.1", - "vary": "~1.1.2" + "@php-wasm/universal": "3.1.12", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" }, "engines": { - "node": ">= 0.10.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/fs-journal/node_modules/finalhandler": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", - "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "statuses": "~2.0.2", - "unpipe": "~1.0.0" - }, + "node_modules/@php-wasm/node-8-1/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", "engines": { - "node": ">= 0.8" + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, - "node_modules/@php-wasm/fs-journal/node_modules/http-errors": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", - "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "node_modules/@php-wasm/node-8-1/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", "license": "MIT", - "dependencies": { - "depd": "~2.0.0", - "inherits": "~2.0.4", - "setprototypeof": "~1.2.0", - "statuses": "~2.0.2", - "toidentifier": "~1.0.1" - }, "engines": { - "node": ">= 0.8" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "license": "ISC" - }, - "node_modules/@php-wasm/fs-journal/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/merge-descriptors": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", - "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/mime": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", - "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", - "license": "MIT", - "bin": { - "mime": "cli.js" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/on-finished": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", - "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", - "license": "MIT", - "dependencies": { - "ee-first": "1.1.1" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/path-to-regexp": { - "version": "0.1.12", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", - "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", - "license": "MIT" - }, - "node_modules/@php-wasm/fs-journal/node_modules/raw-body": { - "version": "2.5.3", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", - "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/safe-buffer": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", - "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ], - "license": "MIT" - }, - "node_modules/@php-wasm/fs-journal/node_modules/send": { - "version": "0.19.2", - "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", - "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "1.2.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.1", - "mime": "1.6.0", - "ms": "2.1.3", - "on-finished": "~2.4.1", - "range-parser": "~1.2.1", - "statuses": "~2.0.2" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, - "node_modules/@php-wasm/fs-journal/node_modules/serve-static": { - "version": "1.16.3", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", - "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", - "license": "MIT", - "dependencies": { - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "parseurl": "~1.3.3", - "send": "~0.19.1" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/statuses": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", - "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/fs-journal/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "node_modules/@php-wasm/logger": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/logger/-/logger-3.0.52.tgz", - "integrity": "sha512-9NlGe5sV0SC1Zb6UfuNJ4XO3HT9pr0NKjv5PRAHlaF2yNCJ3T6O+LCGJiaojWjs2nKqw293LMeHEKFEwe+Pfgg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/node-polyfills": "3.0.52" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/node": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node/-/node-3.0.52.tgz", - "integrity": "sha512-V+ds3PtPrzuSCDHnrDahZdTZbGXynLH1SEH+dSny1taF9WDyp/7Gc73s3E/pCn/8iAB6kSut25dpc1gkzmktOQ==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node-7-4": "3.0.52", - "@php-wasm/node-8-0": "3.0.52", - "@php-wasm/node-8-1": "3.0.52", - "@php-wasm/node-8-2": "3.0.52", - "@php-wasm/node-8-3": "3.0.52", - "@php-wasm/node-8-4": "3.0.52", - "@php-wasm/node-8-5": "3.0.52", - "@php-wasm/node-polyfills": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@wp-playground/common": "3.0.52", - "express": "4.22.0", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3", - "yargs": "17.7.2" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/node-7-4": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-7-4/-/node-7-4-3.0.52.tgz", - "integrity": "sha512-P30l0/lleRLnhob9p3L3o4h2EDH76Fd9fQ+fFvGH8N3aYaNJysug3lKR6hnbQzTQab/xU2JFFUg5Faw3cJfT1w==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/node-7-4/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/node-7-4/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "node_modules/@php-wasm/node-8-0": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-0/-/node-8-0-3.0.52.tgz", - "integrity": "sha512-sm3zsGyGDLd6+b5/VsMxfHJvaREOlYcqPI7WqyrieQCVAg5IckQzeYdVpbQjMhfiAHRprSqyvEV6bz+iQCFiwg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/node-8-0/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/node-8-0/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "node_modules/@php-wasm/node-8-1": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-1/-/node-8-1-3.0.52.tgz", - "integrity": "sha512-6jnMLEsGH6JNHst52Wv9/UHEL5BJb+IOhMW4cG+OwcaqHb5cXq16j9Ak2djwnGgxOJ6geg2wqr1dVXR6fLeXXw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/node-8-1/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/node-8-1/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" + "node": ">=10.0.0" }, "peerDependencies": { "bufferutil": "^4.0.1", @@ -11333,22 +10574,19 @@ } }, "node_modules/@php-wasm/node-8-2": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-2/-/node-8-2-3.0.52.tgz", - "integrity": "sha512-fjGd/J2vUApLgQbviCpnqAZ6dxhVy6faBxL3Rg3ZCajH/NASd+Tn+z9GacnLjQms0zlphk/SbFLZdAU2WY6x8A==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-2/-/node-8-2-3.1.12.tgz", + "integrity": "sha512-nZuHxpptMlTk58L6dDieAp3RVjtd6VHhtV77KANDGFOxp7l+DCxQ77npS2pX5vW9fzl6h6NTMfa9GezZXV1xnA==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", + "@php-wasm/universal": "3.1.12", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/node-8-2/node_modules/ini": { @@ -11382,22 +10620,19 @@ } }, "node_modules/@php-wasm/node-8-3": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-3/-/node-8-3-3.0.52.tgz", - "integrity": "sha512-88q2+OoQ0Zq1DVC+LFhc+F/bG9QnoRRDBZUgFSAOV0GB055F+oU9YXbM9du8OSuUDQ1OEVe+L0VM5sgDfDStIw==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-3/-/node-8-3-3.1.12.tgz", + "integrity": "sha512-PzLKJyvPbBzRfDJ15fyIt8xihpisTM15rp1t4HaPhqa5FYGnrh751pkQYEjurzygqh7M4S2k8U+GUy5OS452UQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", + "@php-wasm/universal": "3.1.12", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/node-8-3/node_modules/ini": { @@ -11431,22 +10666,19 @@ } }, "node_modules/@php-wasm/node-8-4": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-4/-/node-8-4-3.0.52.tgz", - "integrity": "sha512-8B38E1yZQV/8fy9wkQHj23n/uW+2UhZIfcwoBcnRTztONeVKHzPl6rOLBylzJwpg3CXwJ7YJam/MhVkQEfP28g==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-4/-/node-8-4-3.1.12.tgz", + "integrity": "sha512-52LnvStQ5jm+q8oqyIw0HvDelZkSAIOrArbyO/jUakrLFkUlgvXG8E67uHVsr3x1QUOvFNe2HMTcAdZ5oNLk5A==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", + "@php-wasm/universal": "3.1.12", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/node-8-4/node_modules/ini": { @@ -11480,22 +10712,19 @@ } }, "node_modules/@php-wasm/node-8-5": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-5/-/node-8-5-3.0.52.tgz", - "integrity": "sha512-4UawC56VhV6m2YHuxsY0e/Je9F7JWAvFppJo3aBGUWEqQsOvD5lmiZZF/DgyfWJacfvimw3/eeqo1U63+G3e5Q==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-5/-/node-8-5-3.1.12.tgz", + "integrity": "sha512-6KswpSyMXTLinakkHRnVJZ3ft42g+odM4SlZJJ2rFhgQ4uFTLJ6Pz+WEybHGcIwE7e7Z1+2Ip8g8CBDDuVSRXQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", + "@php-wasm/universal": "3.1.12", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/node-8-5/node_modules/ini": { @@ -11529,13 +10758,10 @@ } }, "node_modules/@php-wasm/node-polyfills": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/node-polyfills/-/node-polyfills-3.0.52.tgz", - "integrity": "sha512-lMvGe+SHQVROSfAGpX/w8bCQukmBrS21TAOdoMUoFwUmxKwp1Ztfw+oYqm5maBR1jVoporog3F/KomtUcgab5Q==", - "license": "GPL-2.0-or-later", - "optionalDependencies": { - "fs-ext": "2.1.1" - } + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/node-polyfills/-/node-polyfills-3.1.12.tgz", + "integrity": "sha512-PTIojNH3oKnb63M48kZ3k2L5AirRj5pxlPX6BCET6FIqAzBh/KkFrHJE4enynGYQEiJLsgj43MuY/ZqU0c5nPA==", + "license": "GPL-2.0-or-later" }, "node_modules/@php-wasm/node/node_modules/body-parser": { "version": "1.20.4", @@ -11652,6 +10878,26 @@ "url": "https://opencollective.com/express" } }, + "node_modules/@php-wasm/node/node_modules/fast-xml-parser": { + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", + "strnum": "^2.1.2" + }, + "bin": { + "fxparser": "src/cli/cli.js" + } + }, "node_modules/@php-wasm/node/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -11845,6 +11091,18 @@ "node": ">= 0.8" } }, + "node_modules/@php-wasm/node/node_modules/strnum": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, "node_modules/@php-wasm/node/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -11867,67 +11125,55 @@ } }, "node_modules/@php-wasm/progress": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/progress/-/progress-3.0.52.tgz", - "integrity": "sha512-v41iBYG4nDNWdfQCZDbrn2Tmh0JnPQ1ElFl9kUXX/GExvM8LLXycVOp3O5y3+0i/tXuciJoKWj+9NF/PEuLDvw==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/progress/-/progress-3.1.12.tgz", + "integrity": "sha512-KZBtzod+P3tQ7yDX70ExMbjEfJRG1ENOcR1wh+1TJXqsXjvqx+Vx5PBKrV9zP7x6yQX5mxqEP2YRrcrt9M3H1w==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node-polyfills": "3.0.52" + "@php-wasm/logger": "3.1.12", + "@php-wasm/node-polyfills": "3.1.12" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/scopes": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/scopes/-/scopes-3.0.52.tgz", - "integrity": "sha512-AMb8RcVqIyqGe2wS7Lp4i3lDwsQlKXkqwarRCxJpgWCUP2CkYELOXTJqrR2SvLUf8HOYO5suH69CvAq+N15zeg==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/scopes/-/scopes-3.1.12.tgz", + "integrity": "sha512-Y0ZoWGJWAfROlnwGf2N1+WbL1NTa0nXrx+aiceOg5jrh5X1yToESI9hnERh0vrV91RHC7IA3GEKX7XtA/M8AxQ==", "license": "GPL-2.0-or-later", "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/stream-compression": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/stream-compression/-/stream-compression-3.0.52.tgz", - "integrity": "sha512-BF4RzHm4kwaAIuL6SZG4V9YxtmDkEHWg4+nOOooM7KEzwc63V6lbujeAq/HwM/mqNBO2J+LW9ZJ+k4yCF7okSg==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/stream-compression/-/stream-compression-3.1.12.tgz", + "integrity": "sha512-9oNPQ4V81SDfCHDEofK8eA69fd0Bbkl0evGVdDlvJLhOJNhjby2auVdDQwlynPGifeNzLAq05uBSPlT4yu7rDw==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/node-polyfills": "3.0.52", - "@php-wasm/util": "3.0.52" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "@php-wasm/node-polyfills": "3.1.12", + "@php-wasm/util": "3.1.12" } }, "node_modules/@php-wasm/universal": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/universal/-/universal-3.0.52.tgz", - "integrity": "sha512-P88tyWsOjr35MSNOvQPono2bzkuorjXvQ3RFUV6yGHhRZXOMe+dzPcJ7EsJ5AOxxvhvshB4VLwxpyUAcFtj6Ww==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/universal/-/universal-3.1.12.tgz", + "integrity": "sha512-kL12Pwfn1MeofK/9hT5Ilh5mi5XvM9P3pznAEDYSlaa+7zhQ4t/VkONelokrOEswwW2R1i9fd35E/narLCnLjg==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node-polyfills": "3.0.52", - "@php-wasm/progress": "3.0.52", - "@php-wasm/stream-compression": "3.0.52", - "@php-wasm/util": "3.0.52", + "@php-wasm/logger": "3.1.12", + "@php-wasm/node-polyfills": "3.1.12", + "@php-wasm/progress": "3.1.12", + "@php-wasm/stream-compression": "3.1.12", + "@php-wasm/util": "3.1.12", "ini": "4.1.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@php-wasm/universal/node_modules/ini": { @@ -11940,205 +11186,30 @@ } }, "node_modules/@php-wasm/util": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/util/-/util-3.0.52.tgz", - "integrity": "sha512-82u4Q13IPcL91CusRDy8k9L38zQrqqRO04pnTBJ3uMH1wZy4pAYZ305mKxce1EIU7QqPay/S69VdnWh+K4tOvA==", - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web/-/web-3.0.52.tgz", - "integrity": "sha512-fjSgAOMo2dX5yknN8nAM6Ctd/sovZGIf6dEQeDzXoJm+dHlop6AMUa7FSj4/KXyENim6xcDRpAgf5yMcGiRyFw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/fs-journal": "3.0.52", - "@php-wasm/logger": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@php-wasm/web-7-4": "3.0.52", - "@php-wasm/web-8-0": "3.0.52", - "@php-wasm/web-8-1": "3.0.52", - "@php-wasm/web-8-2": "3.0.52", - "@php-wasm/web-8-3": "3.0.52", - "@php-wasm/web-8-4": "3.0.52", - "@php-wasm/web-8-5": "3.0.52", - "@php-wasm/web-service-worker": "3.0.52", - "@wp-playground/common": "3.0.52", - "express": "4.22.0", - "ini": "4.1.2", - "selfsigned": "5.5.0", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3", - "yargs": "17.7.2" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-7-4": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-7-4/-/web-7-4-3.0.52.tgz", - "integrity": "sha512-t+y8GXOl5WkaD7LeRfOn6iatgFy5ntc2X480FyoJoZmhDVj8e+wsMfZ/aAWDrkrV84tVLWj1GKTVAcBSGmuS2w==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-7-4/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web-8-0": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-0/-/web-8-0-3.0.52.tgz", - "integrity": "sha512-iJlCd8cwk2GbKiTtUE1VmUzv4Z5yiJDmHgcNVdRh2tu1zVxLO4pLlG938bx7UPo6mm6L9SmgBx2kdgjOCmCcWQ==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-8-0/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web-8-1": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-1/-/web-8-1-3.0.52.tgz", - "integrity": "sha512-0XfiFIOBIpYAb9zVuyOpXCQn/2g6OgIDAX/u2M3a3x4NxeLg2txvazU+cWRzhGRsSRFgptpqO69ojmhF1JaG7w==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-8-1/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web-8-2": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-2/-/web-8-2-3.0.52.tgz", - "integrity": "sha512-btSMCor5I3735zudkQ0fKthfUxjx+KUgqf6ZHxjSkZ/baKXMpzVH7hTMhh1HjWWOmjQhqNBQ2KyeHzzAlm9+KQ==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-8-2/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web-8-3": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-3/-/web-8-3-3.0.52.tgz", - "integrity": "sha512-ahmusrtgmi/TIsWlHCfHX0GXxI0RdeCYGzrIYxQeFH3eEchX7J5ssqImL7sPFvP6tT/bluwn9rLef0Z2hki8bg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/util/-/util-3.1.12.tgz", + "integrity": "sha512-f5LdqCTQGne3MQcu2UJsoG9HBWLmZ8eq+Et6Mdy1ud0K4Y08ssX/ztg8YQIvrxpReCoigrQBVmARObkXB/NdQA==", "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-8-3/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/web-8-4": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-4/-/web-8-4-3.0.52.tgz", - "integrity": "sha512-/5Ah8+tIhnO4RQbQZdkwasJ1NCubKlIfOTWi1N/uQlk0OrQ2KmVj5wB4PGDeYoP41FY2Qawffa8DYf4pdypM4w==", + "node_modules/@php-wasm/web-service-worker": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/web-service-worker/-/web-service-worker-3.1.12.tgz", + "integrity": "sha512-yOZ48wc9PP3/80hZ8tr7V6DW2Mb11cFflwA1gvH4KFwQ2yB0RgPhVGdLsgVwoAy/lYlDAeW9DHh1f9CqiIBGzg==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" + "@php-wasm/scopes": "3.1.12", + "@php-wasm/universal": "3.1.12", + "ini": "4.1.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/web-8-4/node_modules/ini": { + "node_modules/@php-wasm/web-service-worker/node_modules/ini": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", @@ -12147,50 +11218,35 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, - "node_modules/@php-wasm/web-8-5": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-8-5/-/web-8-5-3.0.52.tgz", - "integrity": "sha512-DlEhsPKFxXRaTXeuikrl8/de3Ru2putx6iWqPe8qaGNW4mKXQKjBNcwgR5NK83BzNa8ajnxDtl8tTYcTRY1iVg==", + "node_modules/@php-wasm/xdebug-bridge": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@php-wasm/xdebug-bridge/-/xdebug-bridge-3.1.12.tgz", + "integrity": "sha512-A+HKXMwYlFKu704ZCPaioevNWxVqU3KARYzItCvDo2STlL/bRULLPMZyfO0MddNfOKSkes2Ny7PQVLuEUHVQXA==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", + "@php-wasm/logger": "3.1.12", + "@php-wasm/node": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@wp-playground/common": "3.1.12", + "express": "4.22.0", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", "ini": "4.1.2", - "wasm-feature-detect": "1.8.0" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" + "jsonc-parser": "3.3.1", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3", + "xml2js": "0.6.2", + "yargs": "17.7.2" }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/web-8-5/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web-service-worker": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/web-service-worker/-/web-service-worker-3.0.52.tgz", - "integrity": "sha512-eKOLRvXexO5XyiY9wsy8DGXKOnGcovLqxhJeez2eTZ7uQ95k5oOV0Vf9w9OUkLNOWpGg4/qts6Yh4BOgEABLOw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/scopes": "3.0.52" + "bin": { + "xdebug-bridge": "xdebug-bridge.js" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@php-wasm/web/node_modules/body-parser": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/body-parser": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", @@ -12214,7 +11270,7 @@ "npm": "1.2.8000 || >= 1.4.16" } }, - "node_modules/@php-wasm/web/node_modules/bytes": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/bytes": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", @@ -12223,7 +11279,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/web/node_modules/cookie": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/cookie": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", @@ -12232,7 +11288,7 @@ "node": ">= 0.6" } }, - "node_modules/@php-wasm/web/node_modules/debug": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", @@ -12241,7 +11297,7 @@ "ms": "2.0.0" } }, - "node_modules/@php-wasm/web/node_modules/depd": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", @@ -12250,7 +11306,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/web/node_modules/encodeurl": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/encodeurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", @@ -12259,7 +11315,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/web/node_modules/express": { + "node_modules/@php-wasm/xdebug-bridge/node_modules/express": { "version": "4.22.0", "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", @@ -12305,374 +11361,24 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@php-wasm/web/node_modules/finalhandler": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", - "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "node_modules/@php-wasm/xdebug-bridge/node_modules/fast-xml-parser": { + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], "license": "MIT", "dependencies": { - "debug": "2.6.9", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "statuses": "~2.0.2", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/web/node_modules/http-errors": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", - "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", - "license": "MIT", - "dependencies": { - "depd": "~2.0.0", - "inherits": "~2.0.4", - "setprototypeof": "~1.2.0", - "statuses": "~2.0.2", - "toidentifier": "~1.0.1" - }, - "engines": { - "node": ">= 0.8" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/@php-wasm/web/node_modules/iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/@php-wasm/web/node_modules/inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "license": "ISC" - }, - "node_modules/@php-wasm/web/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@php-wasm/web/node_modules/merge-descriptors": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", - "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@php-wasm/web/node_modules/mime": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", - "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", - "license": "MIT", - "bin": { - "mime": "cli.js" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/@php-wasm/web/node_modules/on-finished": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", - "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", - "license": "MIT", - "dependencies": { - "ee-first": "1.1.1" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/web/node_modules/path-to-regexp": { - "version": "0.1.12", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", - "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", - "license": "MIT" - }, - "node_modules/@php-wasm/web/node_modules/raw-body": { - "version": "2.5.3", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", - "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/web/node_modules/safe-buffer": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", - "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ], - "license": "MIT" - }, - "node_modules/@php-wasm/web/node_modules/selfsigned": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", - "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", - "license": "MIT", - "dependencies": { - "@peculiar/x509": "^1.14.2", - "pkijs": "^3.3.3" - }, - "engines": { - "node": ">=18" - } - }, - "node_modules/@php-wasm/web/node_modules/send": { - "version": "0.19.2", - "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", - "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "1.2.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.1", - "mime": "1.6.0", - "ms": "2.1.3", - "on-finished": "~2.4.1", - "range-parser": "~1.2.1", - "statuses": "~2.0.2" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@php-wasm/web/node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, - "node_modules/@php-wasm/web/node_modules/serve-static": { - "version": "1.16.3", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", - "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", - "license": "MIT", - "dependencies": { - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "parseurl": "~1.3.3", - "send": "~0.19.1" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@php-wasm/web/node_modules/statuses": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", - "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/web/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "node_modules/@php-wasm/xdebug-bridge": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@php-wasm/xdebug-bridge/-/xdebug-bridge-3.0.52.tgz", - "integrity": "sha512-lqVwXpjMuD4niKU3cmAiqTnTg6tk6gRqI7PLbMlmDDXJ7g59HebYkBd5NCXRCphGSj47ge44Fy/itoa0EOiluw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@wp-playground/common": "3.0.52", - "express": "4.22.0", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3", - "xml2js": "0.6.2", - "yargs": "17.7.2" + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", + "strnum": "^2.1.2" }, "bin": { - "xdebug-bridge": "xdebug-bridge.js" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/body-parser": { - "version": "1.20.4", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", - "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "content-type": "~1.0.5", - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "~1.2.0", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "on-finished": "~2.4.1", - "qs": "~6.14.0", - "raw-body": "~2.5.3", - "type-is": "~1.6.18", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8", - "npm": "1.2.8000 || >= 1.4.16" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/bytes": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", - "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/cookie": { - "version": "0.7.2", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", - "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/depd": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", - "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/express": { - "version": "4.22.0", - "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", - "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", - "license": "MIT", - "dependencies": { - "accepts": "~1.3.8", - "array-flatten": "1.1.1", - "body-parser": "~1.20.3", - "content-disposition": "~0.5.4", - "content-type": "~1.0.4", - "cookie": "~0.7.1", - "cookie-signature": "~1.0.6", - "debug": "2.6.9", - "depd": "2.0.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "~1.3.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.0", - "merge-descriptors": "1.0.3", - "methods": "~1.1.2", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "path-to-regexp": "~0.1.12", - "proxy-addr": "~2.0.7", - "qs": "~6.14.0", - "range-parser": "~1.2.1", - "safe-buffer": "5.2.1", - "send": "~0.19.0", - "serve-static": "~1.16.2", - "setprototypeof": "1.2.0", - "statuses": "~2.0.1", - "type-is": "~1.6.18", - "utils-merge": "1.0.1", - "vary": "~1.1.2" - }, - "engines": { - "node": ">= 0.10.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" + "fxparser": "src/cli/cli.js" } }, "node_modules/@php-wasm/xdebug-bridge/node_modules/finalhandler": { @@ -12868,6 +11574,18 @@ "node": ">= 0.8" } }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/strnum": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, "node_modules/@php-wasm/xdebug-bridge/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -16671,101 +15389,6 @@ "lilconfig": ">=2" } }, - "node_modules/@storybook/addon-a11y": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/addon-a11y/-/addon-a11y-10.2.17.tgz", - "integrity": "sha512-J0ogEc4/XFC+Ytz+X1we6TOKreEk/shgUs/mtxdsLa0xJ6bp2n2OQPSjNtQHH/nK4SRBSfHWPm8ztfcXTzeG9w==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "axe-core": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.17" - } - }, - "node_modules/@storybook/addon-docs": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.17.tgz", - "integrity": "sha512-c414xi7rxlaHn92qWOxtEkcOMm0/+cvBui0gUsgiWOZOM8dHChGZ/RjMuf1pPDyOrSsybLsPjZhP0WthsMDkdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@mdx-js/react": "^3.0.0", - "@storybook/csf-plugin": "10.2.17", - "@storybook/icons": "^2.0.1", - "@storybook/react-dom-shim": "10.2.17", - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.17" - } - }, - "node_modules/@storybook/builder-vite": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.17.tgz", - "integrity": "sha512-m/OBveTLm5ds/tUgHmmbKzgSi/oeCpQwm5rZa49vP2BpAd41Q7ER6TzkOoISzPoNNMAcbVmVc5vn7k6hdbPSHw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.17", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.17", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" - } - }, - "node_modules/@storybook/csf-plugin": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.17.tgz", - "integrity": "sha512-crHH8i/4mwzeXpWRPgwvwX2vjytW42zyzTRySUax5dTU8o9sjk4y+Z9hkGx3Nmu1TvqseS8v1Z20saZr/tQcWw==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.17", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, "node_modules/@storybook/global": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/@storybook/global/-/global-5.0.0.tgz", @@ -16784,14 +15407,14 @@ } }, "node_modules/@storybook/react": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.2.17.tgz", - "integrity": "sha512-875AVMYil2X9Civil6GFZ8koIzlKxcXbl2eJ7+/GPbhIonTNmwx0qbWPHttjZXUvFuQ4RRtb9KkBwy4TCb/LeA==", + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.2.19.tgz", + "integrity": "sha512-gm2qxLyYSsGp7fee5i+d8jSVUKMla8yRaTJ1wxPEnyaJMd0QUu6U2v3p2rW7PH1DWop3D6NqWOY8kmZjmSZKlA==", "dev": true, "license": "MIT", "dependencies": { "@storybook/global": "^5.0.0", - "@storybook/react-dom-shim": "10.2.17", + "@storybook/react-dom-shim": "10.2.19", "react-docgen": "^8.0.2" }, "funding": { @@ -16801,7 +15424,7 @@ "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.17", + "storybook": "^10.2.19", "typescript": ">= 4.9.x" }, "peerDependenciesMeta": { @@ -16811,38 +15434,11 @@ } }, "node_modules/@storybook/react-dom-shim": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.2.17.tgz", - "integrity": "sha512-x9Kb7eUSZ1zGsEw/TtWrvs1LwWIdNp8qoOQCgPEjdB07reSJcE8R3+ASWHJThmd4eZf66ZALPJyerejake4Osw==", - "dev": true, - "license": "MIT", - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.17" - } - }, - "node_modules/@storybook/react-vite": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.17.tgz", - "integrity": "sha512-E/1hNmxVsjy9l3TuaNufSqkdz8saTJUGEs8GRCjKlF7be2wljIwewUxjAT3efk+bxOCw76ZmqGHk6MnRa3y7Gw==", + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.2.19.tgz", + "integrity": "sha512-BXCEfBGVBRYBTYeBeH/PJsy0Bq5MERe/HiaylR+ah/XrvIr2Z9bkne1J8yYiXCjiyq5HQa7Bj11roz0+vyUaEw==", "dev": true, "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.17", - "@storybook/react": "10.2.17", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, "funding": { "type": "opencollective", "url": "https://opencollective.com/storybook" @@ -16850,33 +15446,7 @@ "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.17", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" - } - }, - "node_modules/@storybook/react-vite/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "node_modules/@storybook/react-vite/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" + "storybook": "^10.2.19" } }, "node_modules/@stylistic/stylelint-plugin": { @@ -17836,9 +16406,9 @@ "license": "MIT" }, "node_modules/@types/aws-lambda": { - "version": "8.10.159", - "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.159.tgz", - "integrity": "sha512-SAP22WSGNN12OQ8PlCzGzRCZ7QDCwI85dQZbmpz7+mAk+L7j+wI7qnvmdKh+o7A5LaOp6QnOZ2NJphAZQTTHQg==", + "version": "8.10.161", + "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.161.tgz", + "integrity": "sha512-rUYdp+MQwSFocxIOcSsYSF3YYYC/uUpMbCY/mbO21vGqfrEYvNSoPyKYDj6RhXXpPfS0KstW9RwG3qXh9sL7FQ==", "license": "MIT" }, "node_modules/@types/babel__code-frame": { @@ -21003,14 +19573,6 @@ "resolved": "packages/ui", "link": true }, - "node_modules/@wordpress/ultrahdr": { - "resolved": "packages/ultrahdr", - "link": true - }, - "node_modules/@wordpress/ultrahdr-wasm": { - "resolved": "packages/ultrahdr-wasm", - "link": true - }, "node_modules/@wordpress/undo-manager": { "resolved": "packages/undo-manager", "link": true @@ -21056,22 +19618,22 @@ "link": true }, "node_modules/@wp-playground/blueprints": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/blueprints/-/blueprints-3.0.52.tgz", - "integrity": "sha512-WQ11urt2O6YItvwwwOYYFqw5wqDPwc5qgaYDsI8cp3hQqH/8bn6xIAwPR55ITNiZYhxl39+aOW1fqRzmymCkyA==", - "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node": "3.0.52", - "@php-wasm/node-polyfills": "3.0.52", - "@php-wasm/progress": "3.0.52", - "@php-wasm/scopes": "3.0.52", - "@php-wasm/stream-compression": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@php-wasm/web-service-worker": "3.0.52", - "@wp-playground/common": "3.0.52", - "@wp-playground/storage": "3.0.52", - "@wp-playground/wordpress": "3.0.52", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/blueprints/-/blueprints-3.1.12.tgz", + "integrity": "sha512-NQsQSCDbyjTBHFF+k7PNZEiOA5LxqAqGjThOIiagZKrFYx7MrLNbfB0TuVbGEYHl4lz4G00WfRjVA8594rzCFg==", + "dependencies": { + "@php-wasm/logger": "3.1.12", + "@php-wasm/node": "3.1.12", + "@php-wasm/node-polyfills": "3.1.12", + "@php-wasm/progress": "3.1.12", + "@php-wasm/scopes": "3.1.12", + "@php-wasm/stream-compression": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", + "@php-wasm/web-service-worker": "3.1.12", + "@wp-playground/common": "3.1.12", + "@wp-playground/storage": "3.1.12", + "@wp-playground/wordpress": "3.1.12", "@zip.js/zip.js": "2.7.57", "ajv": "8.12.0", "async-lock": "1.4.1", @@ -21079,14 +19641,16 @@ "crc-32": "1.2.2", "diff3": "0.0.4", "express": "4.22.0", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", "ignore": "5.3.2", "ini": "4.1.2", + "jsonc-parser": "3.3.1", "minimisted": "2.0.1", "octokit": "3.1.2", "pako": "1.0.10", "pify": "2.3.0", "readable-stream": "3.6.2", - "selfsigned": "5.5.0", "sha.js": "2.4.12", "simple-get": "4.0.1", "wasm-feature-detect": "1.8.0", @@ -21094,11 +19658,8 @@ "yargs": "17.7.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@wp-playground/blueprints/node_modules/ajv": { @@ -21238,6 +19799,26 @@ "url": "https://opencollective.com/express" } }, + "node_modules/@wp-playground/blueprints/node_modules/fast-xml-parser": { + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", + "strnum": "^2.1.2" + }, + "bin": { + "fxparser": "src/cli/cli.js" + } + }, "node_modules/@wp-playground/blueprints/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -21415,19 +19996,6 @@ ], "license": "MIT" }, - "node_modules/@wp-playground/blueprints/node_modules/selfsigned": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", - "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", - "license": "MIT", - "dependencies": { - "@peculiar/x509": "^1.14.2", - "pkijs": "^3.3.3" - }, - "engines": { - "node": ">=18" - } - }, "node_modules/@wp-playground/blueprints/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -21482,6 +20050,18 @@ "node": ">= 0.8" } }, + "node_modules/@wp-playground/blueprints/node_modules/strnum": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, "node_modules/@wp-playground/blueprints/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -21504,23 +20084,23 @@ } }, "node_modules/@wp-playground/cli": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/cli/-/cli-3.0.52.tgz", - "integrity": "sha512-IU3JnEetWQUyewnB3a8I9o3r+9D2nEqoisQje6Fs5kO4QfVgCluiP4ek6HmKEd0pBSaby9Qt2OAdRrKaPQBwIQ==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/cli/-/cli-3.1.12.tgz", + "integrity": "sha512-7NBUEz7NcfirYGWCV+KjG1fkavenbVEQAXhfF6P8svlrc6ZqphJPuLHBmurQUANxmCv8wURpxH8Vx4fxVMWH3Q==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/cli-util": "3.0.52", - "@php-wasm/logger": "3.0.52", - "@php-wasm/node": "3.0.52", - "@php-wasm/progress": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@php-wasm/xdebug-bridge": "3.0.52", - "@wp-playground/blueprints": "3.0.52", - "@wp-playground/common": "3.0.52", - "@wp-playground/storage": "3.0.52", - "@wp-playground/tools": "3.0.52", - "@wp-playground/wordpress": "3.0.52", + "@php-wasm/cli-util": "3.1.12", + "@php-wasm/logger": "3.1.12", + "@php-wasm/node": "3.1.12", + "@php-wasm/progress": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", + "@php-wasm/xdebug-bridge": "3.1.12", + "@wp-playground/blueprints": "3.1.12", + "@wp-playground/common": "3.1.12", + "@wp-playground/storage": "3.1.12", + "@wp-playground/tools": "3.1.12", + "@wp-playground/wordpress": "3.1.12", "@zip.js/zip.js": "2.7.57", "ajv": "8.12.0", "async-lock": "1.4.1", @@ -21528,7 +20108,8 @@ "crc-32": "1.2.2", "diff3": "0.0.4", "express": "4.22.0", - "fast-xml-parser": "^5.3.4", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", "fs-extra": "11.1.1", "ignore": "5.3.2", "ini": "4.1.2", @@ -21537,9 +20118,7 @@ "octokit": "3.1.2", "pako": "1.0.10", "pify": "2.3.0", - "ps-man": "1.1.8", "readable-stream": "3.6.2", - "selfsigned": "5.5.0", "sha.js": "2.4.12", "simple-get": "4.0.1", "tmp-promise": "3.0.3", @@ -21550,9 +20129,6 @@ }, "bin": { "wp-playground-cli": "wp-playground.js" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" } }, "node_modules/@wp-playground/cli/node_modules/ajv": { @@ -21693,9 +20269,9 @@ } }, "node_modules/@wp-playground/cli/node_modules/fast-xml-parser": { - "version": "5.3.5", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.5.tgz", - "integrity": "sha512-JeaA2Vm9ffQKp9VjvfzObuMCjUYAp5WDYhRYL5LrBPY/jUDlUtOvDfot0vKSkB9tuX885BDHjtw4fZadD95wnA==", + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", "funding": [ { "type": "github", @@ -21704,6 +20280,8 @@ ], "license": "MIT", "dependencies": { + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", "strnum": "^2.1.2" }, "bin": { @@ -21913,19 +20491,6 @@ ], "license": "MIT" }, - "node_modules/@wp-playground/cli/node_modules/selfsigned": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", - "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", - "license": "MIT", - "dependencies": { - "@peculiar/x509": "^1.14.2", - "pkijs": "^3.3.3" - }, - "engines": { - "node": ">=18" - } - }, "node_modules/@wp-playground/cli/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -21981,9 +20546,9 @@ } }, "node_modules/@wp-playground/cli/node_modules/strnum": { - "version": "2.1.2", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.1.2.tgz", - "integrity": "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", "funding": [ { "type": "github", @@ -22023,21 +20588,18 @@ } }, "node_modules/@wp-playground/common": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/common/-/common-3.0.52.tgz", - "integrity": "sha512-umfP5lCzjAWqJ3woSrlff+SGDal5y4QHftSk/w5L8SuwlZ0Rq8Q9X5CC2jA0adl8dfyb8auJPqpDbTf4+wWP8A==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/common/-/common-3.1.12.tgz", + "integrity": "sha512-UGUaGL3JQB15eBU+yJ6MQAl/dGXr9LKDDsSNwpYRizmzQ3727D99vzOx8LJ4cS3TCSq7W3T6vbfCIbbrT0/SsA==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", "ini": "4.1.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@wp-playground/common/node_modules/ini": { @@ -22050,21 +20612,19 @@ } }, "node_modules/@wp-playground/storage": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/storage/-/storage-3.0.52.tgz", - "integrity": "sha512-/oZeM5GIELessrzhLFJJscKXtLn34FT2IgqKLg4Vi2uqQ1gdYWx9A24tnLs59MeHa8Mvu0jEAPcAd6AM/ze1yQ==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/storage/-/storage-3.1.12.tgz", + "integrity": "sha512-6ItiAFsUnbj4D1PLQEc6RSooX+WszOgN6s2nhrjYuHqI7QB5YB+4RtVjJYDnHOViSpljslMEaInVF6Y2GvaWuQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/stream-compression": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@php-wasm/web": "3.0.52", + "@php-wasm/stream-compression": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", "@zip.js/zip.js": "2.7.57", "async-lock": "^1.4.1", "clean-git-ref": "^2.0.1", "crc-32": "^1.2.0", "diff3": "0.0.3", - "express": "4.22.0", "ignore": "^5.1.4", "ini": "4.1.2", "minimisted": "^2.0.0", @@ -22072,24 +20632,112 @@ "pako": "^1.0.10", "pify": "^4.0.1", "readable-stream": "^3.4.0", - "selfsigned": "5.5.0", "sha.js": "^2.4.9", - "simple-get": "^4.0.1", + "simple-get": "^4.0.1" + } + }, + "node_modules/@wp-playground/storage/node_modules/async-lock": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", + "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/diff3": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/diff3/-/diff3-0.0.3.tgz", + "integrity": "sha512-iSq8ngPOt0K53A6eVr4d5Kn6GNrM2nQZtC740pzIriHtn4pOQ2lyzEXQMBeVcWERN0ye7fhBsk9PbLLQOnUx/g==", + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@wp-playground/storage/node_modules/pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@wp-playground/storage/node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/@wp-playground/tools": { + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/tools/-/tools-3.1.12.tgz", + "integrity": "sha512-p/nIRdA8uYEl9z89gSgbmwxNYEranpW7ilyP9YKQKz2xWNcmEJLa1gfcgVCBuFYo+9jL8SrqP5BWoKu52cq9Ug==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@wp-playground/blueprints": "3.1.12", + "@zip.js/zip.js": "2.7.57", + "ajv": "8.12.0", + "async-lock": "1.4.1", + "clean-git-ref": "2.0.1", + "crc-32": "1.2.2", + "diff3": "0.0.4", + "express": "4.22.0", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", + "ignore": "5.3.2", + "ini": "4.1.2", + "jsonc-parser": "3.3.1", + "minimisted": "2.0.1", + "octokit": "3.1.2", + "pako": "1.0.10", + "pify": "2.3.0", + "readable-stream": "3.6.2", + "sha.js": "2.4.12", + "simple-get": "4.0.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "engines": { + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, - "node_modules/@wp-playground/storage/node_modules/async-lock": { + "node_modules/@wp-playground/tools/node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/@wp-playground/tools/node_modules/async-lock": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", "license": "MIT" }, - "node_modules/@wp-playground/storage/node_modules/body-parser": { + "node_modules/@wp-playground/tools/node_modules/body-parser": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", @@ -22113,7 +20761,7 @@ "npm": "1.2.8000 || >= 1.4.16" } }, - "node_modules/@wp-playground/storage/node_modules/bytes": { + "node_modules/@wp-playground/tools/node_modules/bytes": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", @@ -22122,7 +20770,7 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/storage/node_modules/cookie": { + "node_modules/@wp-playground/tools/node_modules/cookie": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", @@ -22131,7 +20779,7 @@ "node": ">= 0.6" } }, - "node_modules/@wp-playground/storage/node_modules/debug": { + "node_modules/@wp-playground/tools/node_modules/debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", @@ -22140,7 +20788,7 @@ "ms": "2.0.0" } }, - "node_modules/@wp-playground/storage/node_modules/depd": { + "node_modules/@wp-playground/tools/node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", @@ -22149,13 +20797,7 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/storage/node_modules/diff3": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/diff3/-/diff3-0.0.3.tgz", - "integrity": "sha512-iSq8ngPOt0K53A6eVr4d5Kn6GNrM2nQZtC740pzIriHtn4pOQ2lyzEXQMBeVcWERN0ye7fhBsk9PbLLQOnUx/g==", - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/encodeurl": { + "node_modules/@wp-playground/tools/node_modules/encodeurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", @@ -22164,7 +20806,7 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/storage/node_modules/express": { + "node_modules/@wp-playground/tools/node_modules/express": { "version": "4.22.0", "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", @@ -22210,427 +20852,24 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@wp-playground/storage/node_modules/finalhandler": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", - "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "statuses": "~2.0.2", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/storage/node_modules/http-errors": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", - "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", - "license": "MIT", - "dependencies": { - "depd": "~2.0.0", - "inherits": "~2.0.4", - "setprototypeof": "~1.2.0", - "statuses": "~2.0.2", - "toidentifier": "~1.0.1" - }, - "engines": { - "node": ">= 0.8" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" - } - }, - "node_modules/@wp-playground/storage/node_modules/iconv-lite": { - "version": "0.4.24", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", - "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/@wp-playground/storage/node_modules/inherits": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", - "license": "ISC" - }, - "node_modules/@wp-playground/storage/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@wp-playground/storage/node_modules/merge-descriptors": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", - "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", - "license": "MIT", - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@wp-playground/storage/node_modules/mime": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", - "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", - "license": "MIT", - "bin": { - "mime": "cli.js" - }, - "engines": { - "node": ">=4" - } - }, - "node_modules/@wp-playground/storage/node_modules/on-finished": { - "version": "2.4.1", - "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", - "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", - "license": "MIT", - "dependencies": { - "ee-first": "1.1.1" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/storage/node_modules/path-to-regexp": { - "version": "0.1.12", - "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", - "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/pify": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", - "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/@wp-playground/storage/node_modules/raw-body": { - "version": "2.5.3", - "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", - "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/storage/node_modules/readable-stream": { - "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", - "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "string_decoder": "^1.1.1", - "util-deprecate": "^1.0.1" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/@wp-playground/storage/node_modules/safe-buffer": { - "version": "5.2.1", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", - "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "node_modules/@wp-playground/tools/node_modules/fast-xml-parser": { + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", "funding": [ { "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" + "url": "https://github.com/sponsors/NaturalIntelligence" } ], - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/selfsigned": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", - "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", - "license": "MIT", - "dependencies": { - "@peculiar/x509": "^1.14.2", - "pkijs": "^3.3.3" - }, - "engines": { - "node": ">=18" - } - }, - "node_modules/@wp-playground/storage/node_modules/send": { - "version": "0.19.2", - "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", - "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "1.2.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.1", - "mime": "1.6.0", - "ms": "2.1.3", - "on-finished": "~2.4.1", - "range-parser": "~1.2.1", - "statuses": "~2.0.2" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@wp-playground/storage/node_modules/send/node_modules/ms": { - "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/serve-static": { - "version": "1.16.3", - "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", - "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", - "license": "MIT", - "dependencies": { - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "parseurl": "~1.3.3", - "send": "~0.19.1" - }, - "engines": { - "node": ">= 0.8.0" - } - }, - "node_modules/@wp-playground/storage/node_modules/statuses": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", - "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/storage/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "node_modules/@wp-playground/tools": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/tools/-/tools-3.0.52.tgz", - "integrity": "sha512-uBCbO5rztC1cObHy+ehlDGXiFeZOuqHMCYgZJSUX4q7oqXa+AMua1IMc33AVkfSVjPFnp3f+/oR24hM2nYAWCg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@wp-playground/blueprints": "3.0.52", - "@zip.js/zip.js": "2.7.57", - "ajv": "8.12.0", - "async-lock": "1.4.1", - "clean-git-ref": "2.0.1", - "crc-32": "1.2.2", - "diff3": "0.0.4", - "express": "4.22.0", - "ignore": "5.3.2", - "ini": "4.1.2", - "minimisted": "2.0.1", - "octokit": "3.1.2", - "pako": "1.0.10", - "pify": "2.3.0", - "readable-stream": "3.6.2", - "selfsigned": "5.5.0", - "sha.js": "2.4.12", - "simple-get": "4.0.1", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3", - "yargs": "17.7.2" - }, - "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" - } - }, - "node_modules/@wp-playground/tools/node_modules/ajv": { - "version": "8.12.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", - "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", - "license": "MIT", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" - } - }, - "node_modules/@wp-playground/tools/node_modules/async-lock": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", - "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", - "license": "MIT" - }, - "node_modules/@wp-playground/tools/node_modules/body-parser": { - "version": "1.20.4", - "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", - "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", - "license": "MIT", - "dependencies": { - "bytes": "~3.1.2", - "content-type": "~1.0.5", - "debug": "2.6.9", - "depd": "2.0.0", - "destroy": "~1.2.0", - "http-errors": "~2.0.1", - "iconv-lite": "~0.4.24", - "on-finished": "~2.4.1", - "qs": "~6.14.0", - "raw-body": "~2.5.3", - "type-is": "~1.6.18", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8", - "npm": "1.2.8000 || >= 1.4.16" - } - }, - "node_modules/@wp-playground/tools/node_modules/bytes": { - "version": "3.1.2", - "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", - "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/tools/node_modules/cookie": { - "version": "0.7.2", - "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", - "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "node_modules/@wp-playground/tools/node_modules/debug": { - "version": "2.6.9", - "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", - "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", "license": "MIT", "dependencies": { - "ms": "2.0.0" - } - }, - "node_modules/@wp-playground/tools/node_modules/depd": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", - "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/tools/node_modules/encodeurl": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", - "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "node_modules/@wp-playground/tools/node_modules/express": { - "version": "4.22.0", - "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", - "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", - "license": "MIT", - "dependencies": { - "accepts": "~1.3.8", - "array-flatten": "1.1.1", - "body-parser": "~1.20.3", - "content-disposition": "~0.5.4", - "content-type": "~1.0.4", - "cookie": "~0.7.1", - "cookie-signature": "~1.0.6", - "debug": "2.6.9", - "depd": "2.0.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "~1.3.1", - "fresh": "~0.5.2", - "http-errors": "~2.0.0", - "merge-descriptors": "1.0.3", - "methods": "~1.1.2", - "on-finished": "~2.4.1", - "parseurl": "~1.3.3", - "path-to-regexp": "~0.1.12", - "proxy-addr": "~2.0.7", - "qs": "~6.14.0", - "range-parser": "~1.2.1", - "safe-buffer": "5.2.1", - "send": "~0.19.0", - "serve-static": "~1.16.2", - "setprototypeof": "1.2.0", - "statuses": "~2.0.1", - "type-is": "~1.6.18", - "utils-merge": "1.0.1", - "vary": "~1.1.2" - }, - "engines": { - "node": ">= 0.10.0" + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", + "strnum": "^2.1.2" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/express" + "bin": { + "fxparser": "src/cli/cli.js" } }, "node_modules/@wp-playground/tools/node_modules/finalhandler": { @@ -22810,19 +21049,6 @@ ], "license": "MIT" }, - "node_modules/@wp-playground/tools/node_modules/selfsigned": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", - "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", - "license": "MIT", - "dependencies": { - "@peculiar/x509": "^1.14.2", - "pkijs": "^3.3.3" - }, - "engines": { - "node": ">=18" - } - }, "node_modules/@wp-playground/tools/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -22877,6 +21103,18 @@ "node": ">= 0.8" } }, + "node_modules/@wp-playground/tools/node_modules/strnum": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, "node_modules/@wp-playground/tools/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -22899,28 +21137,28 @@ } }, "node_modules/@wp-playground/wordpress": { - "version": "3.0.52", - "resolved": "https://registry.npmjs.org/@wp-playground/wordpress/-/wordpress-3.0.52.tgz", - "integrity": "sha512-P37YCxJuDSBCi0JIL4mkYUJsCSW1GrnL2LWTgups/NKWf1MCODEhmCSFfixfbMb7BFOvlC6Tb8RXw+O2dG1Ouw==", + "version": "3.1.12", + "resolved": "https://registry.npmjs.org/@wp-playground/wordpress/-/wordpress-3.1.12.tgz", + "integrity": "sha512-RSpU1YyC5tc0djdh9AL5NIBetHD0eJIZvj7S/fl/1jKFCDzJ0wGp+pxiFSUufXySHAT8oRD890dB9mHNri+sTQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.0.52", - "@php-wasm/node": "3.0.52", - "@php-wasm/universal": "3.0.52", - "@php-wasm/util": "3.0.52", - "@wp-playground/common": "3.0.52", + "@php-wasm/logger": "3.1.12", + "@php-wasm/node": "3.1.12", + "@php-wasm/universal": "3.1.12", + "@php-wasm/util": "3.1.12", + "@wp-playground/common": "3.1.12", "express": "4.22.0", + "fast-xml-parser": "^5.5.1", + "fs-ext-extra-prebuilt": "2.2.7", "ini": "4.1.2", + "jsonc-parser": "3.3.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, "engines": { - "node": ">=20.18.3", - "npm": ">=10.1.0" - }, - "optionalDependencies": { - "fs-ext": "2.1.1" + "node": ">=20.10.0", + "npm": ">=10.2.3" } }, "node_modules/@wp-playground/wordpress/node_modules/body-parser": { @@ -23038,6 +21276,26 @@ "url": "https://opencollective.com/express" } }, + "node_modules/@wp-playground/wordpress/node_modules/fast-xml-parser": { + "version": "5.5.6", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", + "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "fast-xml-builder": "^1.1.4", + "path-expression-matcher": "^1.1.3", + "strnum": "^2.1.2" + }, + "bin": { + "fxparser": "src/cli/cli.js" + } + }, "node_modules/@wp-playground/wordpress/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -23231,6 +21489,18 @@ "node": ">= 0.8" } }, + "node_modules/@wp-playground/wordpress/node_modules/strnum": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", + "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT" + }, "node_modules/@wp-playground/wordpress/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -24462,20 +22732,6 @@ "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, - "node_modules/asn1js": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.7.tgz", - "integrity": "sha512-uLvq6KJu04qoQM6gvBfKFjlh6Gl0vOKQuR5cJMDHQkmwfMOQeN3F3SHCv9SNYSL+CRoHvOGFfllDlVz03GQjvQ==", - "license": "BSD-3-Clause", - "dependencies": { - "pvtsutils": "^1.3.6", - "pvutils": "^1.1.3", - "tslib": "^2.8.1" - }, - "engines": { - "node": ">=12.0.0" - } - }, "node_modules/assert": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.1.tgz", @@ -25929,15 +24185,6 @@ "node": ">= 0.8" } }, - "node_modules/bytestreamjs": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/bytestreamjs/-/bytestreamjs-2.0.1.tgz", - "integrity": "sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ==", - "license": "BSD-3-Clause", - "engines": { - "node": ">=6.0.0" - } - }, "node_modules/cacache": { "version": "12.0.4", "resolved": "https://registry.npmjs.org/cacache/-/cacache-12.0.4.tgz", @@ -26683,6 +24930,12 @@ "node": ">=0.10.0" } }, + "node_modules/clean-git-ref": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/clean-git-ref/-/clean-git-ref-2.0.1.tgz", + "integrity": "sha512-bLSptAy2P0s6hU4PzuIMKmMJJSE6gLXGH1cntDu7bWJUksvuM+7ReOK61mozULErYvP6a15rnYl0zFDef+pyPw==", + "license": "Apache-2.0" + }, "node_modules/clean-stack": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", @@ -27154,9 +25407,9 @@ } }, "node_modules/comctx": { - "version": "1.4.3", - "resolved": "https://registry.npmjs.org/comctx/-/comctx-1.4.3.tgz", - "integrity": "sha512-Z1fisV3l6kucW+GZDg3AI2+ffWGd+Q/RCBKGbpQ8oe6U3p6wmTM/NciP4RRgLYYDW4aZgZIXRUQz1YnFX1QsjQ==", + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/comctx/-/comctx-1.6.1.tgz", + "integrity": "sha512-ZMRGAYASYRdVfEoB7oxH8Nqu5Ay8I+YvAsQni+td0pYV9eww/PrtSFVyvc2JkNQyHXGDknCB4wJfxFYP6fuqZg==", "license": "MIT" }, "node_modules/command-exists": { @@ -32492,6 +30745,21 @@ "integrity": "sha512-MWipKbbYiYI0UC7cl8m/i/IWTqfC8YXsqjzybjddLsFjStroQzsHXkc73JutMvBiXmOvapk+axIl79ig5t55Bw==", "license": "MIT" }, + "node_modules/fast-xml-builder": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.1.4.tgz", + "integrity": "sha512-f2jhpN4Eccy0/Uz9csxh3Nu6q4ErKxf0XIsasomfOihuSUa3/xw6w8dnOtCDgEItQFJG8KyXPzQXzcODDrrbOg==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "dependencies": { + "path-expression-matcher": "^1.1.3" + } + }, "node_modules/fast-xml-parser": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-4.5.0.tgz", @@ -33222,14 +31490,14 @@ "node": ">=0.10.0" } }, - "node_modules/fs-ext": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/fs-ext/-/fs-ext-2.1.1.tgz", - "integrity": "sha512-/TrISPOFhCkbgIRWK9lzscRzwPCu0PqtCcvMc9jsHKBgZGoqA0VzhspVht5Zu8lxaXjIYIBWILHpRotYkCCcQA==", + "node_modules/fs-ext-extra-prebuilt": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/fs-ext-extra-prebuilt/-/fs-ext-extra-prebuilt-2.2.7.tgz", + "integrity": "sha512-Q7rayYRBDIvDF01HWOwSSjoaP+05N1g+o3BXL1Zf8Frw2JkjSmi4EtvCBITuW30l6hB2m2TW1pehdh8wyU/+gw==", "hasInstallScript": true, - "optional": true, + "license": "MIT", "dependencies": { - "nan": "^2.21.0" + "nan": "^2.24.0" }, "engines": { "node": ">= 8.0.0" @@ -39002,27 +37270,6 @@ "node": ">= 0.8.0" } }, - "node_modules/lib0": { - "version": "0.2.99", - "resolved": "https://registry.npmjs.org/lib0/-/lib0-0.2.99.tgz", - "integrity": "sha512-vwztYuUf1uf/1zQxfzRfO5yzfNKhTtgOByCruuiQQxWQXnPb8Itaube5ylofcV0oM0aKal9Mv+S1s1Ky0UYP1w==", - "license": "MIT", - "dependencies": { - "isomorphic.js": "^0.2.4" - }, - "bin": { - "0ecdsa-generate-keypair": "bin/0ecdsa-generate-keypair.js", - "0gentesthtml": "bin/gentesthtml.js", - "0serve": "bin/0serve.js" - }, - "engines": { - "node": ">=16" - }, - "funding": { - "type": "GitHub Sponsors ❤", - "url": "https://github.com/sponsors/dmonad" - } - }, "node_modules/libnpmaccess": { "version": "8.0.6", "resolved": "https://registry.npmjs.org/libnpmaccess/-/libnpmaccess-8.0.6.tgz", @@ -42564,11 +40811,10 @@ } }, "node_modules/nan": { - "version": "2.24.0", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.24.0.tgz", - "integrity": "sha512-Vpf9qnVW1RaDkoNKFUvfxqAbtI8ncb8OJlqZ9wwpXzWPEsvsB1nvdUi6oYrHIkQ1Y/tMDnr1h4nczS0VB9Xykg==", - "license": "MIT", - "optional": true + "version": "2.26.1", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.26.1.tgz", + "integrity": "sha512-vodKprLlmaKmraa9E/TxHQwpH4eKYTJbLdeQE49pb9GOmrLs68zESjJu0LQOz1W6JwJmftOWD5Ls4dpd/elQtQ==", + "license": "MIT" }, "node_modules/nanoid": { "version": "3.3.11", @@ -44522,6 +42768,18 @@ "node": ">=8" } }, + "node_modules/open-ultrahdr": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.0.tgz", + "integrity": "sha512-fbrqu28YTRtPu6j+kY/JKqg3cddyxPWvYRqYqVuRchAs1F2QrtvwW/WIqTjhP021k8o4XkDMLy0/tu6OTQUE2w==", + "license": "GPL-2.0-or-later", + "dependencies": { + "open-ultrahdr-wasm": "^0.1.1" + }, + "engines": { + "node": ">=18.0.0" + } + }, "node_modules/open-ultrahdr-wasm": { "version": "0.1.1", "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.1.tgz", @@ -45628,6 +43886,21 @@ "node": ">=4" } }, + "node_modules/path-expression-matcher": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.1.3.tgz", + "integrity": "sha512-qdVgY8KXmVdJZRSS1JdEPOKPdTiEK/pi0RkcT2sw1RhXxohdujUlJFPuS1TSkevZ9vzd3ZlL7ULl1MHGTApKzQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, "node_modules/path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", @@ -45848,23 +44121,6 @@ "node": ">=4" } }, - "node_modules/pkijs": { - "version": "3.3.3", - "resolved": "https://registry.npmjs.org/pkijs/-/pkijs-3.3.3.tgz", - "integrity": "sha512-+KD8hJtqQMYoTuL1bbGOqxb4z+nZkTAwVdNtWwe8Tc2xNbEmdJYIYoc6Qt0uF55e6YW6KuTHw1DjQ18gMhzepw==", - "license": "BSD-3-Clause", - "dependencies": { - "@noble/hashes": "1.4.0", - "asn1js": "^3.0.6", - "bytestreamjs": "^2.0.1", - "pvtsutils": "^1.3.6", - "pvutils": "^1.1.3", - "tslib": "^2.8.1" - }, - "engines": { - "node": ">=16.0.0" - } - }, "node_modules/platform": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.5.tgz", @@ -46981,12 +45237,6 @@ "integrity": "sha512-yPw4Sng1gWghHQWj0B3ZggWUm4qVbPwPFcRG8KyxiU7J2OHFSoEHKS+EZ3fv5l1t9CyCiop6l/ZYeWbrgoQejw==", "dev": true }, - "node_modules/ps-man": { - "version": "1.1.8", - "resolved": "https://registry.npmjs.org/ps-man/-/ps-man-1.1.8.tgz", - "integrity": "sha512-ZKDPZwHLYVWIk/Q75N7jCFbuQyokSg2+3WBlt8l35S/uBvxoc+LiRUbb3RUt83pwW82dzwiCpoQIHd9PAxUzHg==", - "license": "MIT" - }, "node_modules/public-encrypt": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", @@ -47243,28 +45493,10 @@ } ] }, - "node_modules/pvtsutils": { - "version": "1.3.6", - "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz", - "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==", - "license": "MIT", - "dependencies": { - "tslib": "^2.8.1" - } - }, - "node_modules/pvutils": { - "version": "1.1.5", - "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.1.5.tgz", - "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==", - "license": "MIT", - "engines": { - "node": ">=16.0.0" - } - }, "node_modules/qs": { - "version": "6.14.1", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", - "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", + "version": "6.14.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz", + "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==", "license": "BSD-3-Clause", "dependencies": { "side-channel": "^1.1.0" @@ -47556,9 +45788,9 @@ } }, "node_modules/react-docgen": { - "version": "8.0.2", - "resolved": "https://registry.npmjs.org/react-docgen/-/react-docgen-8.0.2.tgz", - "integrity": "sha512-+NRMYs2DyTP4/tqWz371Oo50JqmWltR1h2gcdgUMAWZJIAvrd0/SqlCfx7tpzpl/s36rzw6qH2MjoNrxtRNYhA==", + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/react-docgen/-/react-docgen-8.0.3.tgz", + "integrity": "sha512-aEZ9qP+/M+58x2qgfSFEWH1BxLyHe5+qkLNJOZQb5iGS017jpbRnoKhNRrXPeA6RfBrZO5wZrT9DMC1UqE1f1w==", "dev": true, "license": "MIT", "dependencies": { @@ -47587,21 +45819,6 @@ "typescript": ">= 4.3.x" } }, - "node_modules/react-docgen/node_modules/@babel/code-frame": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", - "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@babel/helper-validator-identifier": "^7.28.5", - "js-tokens": "^4.0.0", - "picocolors": "^1.1.1" - }, - "engines": { - "node": ">=6.9.0" - } - }, "node_modules/react-docgen/node_modules/@babel/core": { "version": "7.29.0", "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", @@ -47633,39 +45850,6 @@ "url": "https://opencollective.com/babel" } }, - "node_modules/react-docgen/node_modules/@babel/generator": { - "version": "7.29.1", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", - "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@babel/parser": "^7.29.0", - "@babel/types": "^7.29.0", - "@jridgewell/gen-mapping": "^0.3.12", - "@jridgewell/trace-mapping": "^0.3.28", - "jsesc": "^3.0.2" - }, - "engines": { - "node": ">=6.9.0" - } - }, - "node_modules/react-docgen/node_modules/@babel/parser": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", - "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", - "dev": true, - "license": "MIT", - "dependencies": { - "@babel/types": "^7.29.0" - }, - "bin": { - "parser": "bin/babel-parser.js" - }, - "engines": { - "node": ">=6.0.0" - } - }, "node_modules/react-docgen/node_modules/@babel/traverse": { "version": "7.29.0", "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", @@ -47685,20 +45869,6 @@ "node": ">=6.9.0" } }, - "node_modules/react-docgen/node_modules/@babel/types": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", - "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", - "dev": true, - "license": "MIT", - "dependencies": { - "@babel/helper-string-parser": "^7.27.1", - "@babel/helper-validator-identifier": "^7.28.5" - }, - "engines": { - "node": ">=6.9.0" - } - }, "node_modules/react-docgen/node_modules/convert-source-map": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", @@ -48682,12 +46852,6 @@ "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz", "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==" }, - "node_modules/reflect-metadata": { - "version": "0.2.2", - "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz", - "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==", - "license": "Apache-2.0" - }, "node_modules/regenerate": { "version": "1.4.2", "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", @@ -50137,9 +48301,9 @@ } }, "node_modules/sax": { - "version": "1.4.4", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz", - "integrity": "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==", + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz", + "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==", "license": "BlueOak-1.0.0", "engines": { "node": ">=11.0.0" @@ -51698,42 +49862,6 @@ "node": ">= 0.4" } }, - "node_modules/storybook": { - "version": "10.2.17", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.17.tgz", - "integrity": "sha512-yueTpl5YJqLzQqs3CanxNdAAfFU23iP0j+JVJURE4ghfEtRmWfWoZWLGkVcyjmgum7UmjwAlqRuOjQDNvH89kw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, "node_modules/storybook-addon-tag-badges": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/storybook-addon-tag-badges/-/storybook-addon-tag-badges-3.0.4.tgz", @@ -51747,149 +49875,6 @@ "storybook": "^10.0.0" } }, - "node_modules/storybook/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/default-browser": { - "version": "5.4.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.4.0.tgz", - "integrity": "sha512-XDuvSq38Hr1MdN47EDvYtx3U0MTqpCEn+F6ft8z2vYDzMrvQhVp0ui9oQdqW3MvK3vqUETglt1tVGgjLuJ5izg==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "node_modules/storybook/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/storybook/node_modules/semver": { - "version": "7.7.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", - "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/storybook/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, "node_modules/stream-browserify": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.2.tgz", @@ -52875,12 +50860,6 @@ "url": "https://opencollective.com/unts" } }, - "node_modules/tabbable": { - "version": "6.4.0", - "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", - "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", - "license": "MIT" - }, "node_modules/table": { "version": "6.8.2", "resolved": "https://registry.npmjs.org/table/-/table-6.8.2.tgz", @@ -53867,9 +51846,9 @@ } }, "node_modules/tslib": { - "version": "2.8.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", - "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.0.tgz", + "integrity": "sha512-jWVzBLplnCmoaTr13V9dYbiQ99wvZRd0vNWaDRg+aVYRcjDF3nDksxFDE/+fkXnKhpnUUkmx5pK/v8mCtLVqZA==", "license": "0BSD" }, "node_modules/tsutils": { @@ -53891,24 +51870,6 @@ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" }, - "node_modules/tsyringe": { - "version": "4.10.0", - "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz", - "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==", - "license": "MIT", - "dependencies": { - "tslib": "^1.9.3" - }, - "engines": { - "node": ">= 6.0.0" - } - }, - "node_modules/tsyringe/node_modules/tslib": { - "version": "1.14.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", - "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", - "license": "0BSD" - }, "node_modules/tty-browserify": { "version": "0.0.0", "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", @@ -54470,9 +52431,9 @@ } }, "node_modules/unplugin/node_modules/acorn": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", - "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "dev": true, "license": "MIT", "bin": { @@ -57731,23 +55692,6 @@ "fd-slicer": "~1.1.0" } }, - "node_modules/yjs": { - "version": "13.6.29", - "resolved": "https://registry.npmjs.org/yjs/-/yjs-13.6.29.tgz", - "integrity": "sha512-kHqDPdltoXH+X4w1lVmMtddE3Oeqq48nM40FD5ojTd8xYhQpzIDcfE2keMSU5bAgRPJBe225WTUdyUgj1DtbiQ==", - "license": "MIT", - "dependencies": { - "lib0": "^0.2.99" - }, - "engines": { - "node": ">=16.0.0", - "npm": ">=8.0.0" - }, - "funding": { - "type": "GitHub Sponsors ❤", - "url": "https://github.com/sponsors/dmonad" - } - }, "node_modules/yn": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", @@ -58317,6 +56261,40 @@ "react-dom": "^18.0.0" } }, + "packages/block-editor/node_modules/@ariakit/core": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", + "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", + "dev": true, + "license": "MIT" + }, + "packages/block-editor/node_modules/@ariakit/test": { + "version": "0.4.13", + "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", + "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ariakit/core": "0.4.18", + "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" + }, + "peerDependencies": { + "@playwright/test": "^1.27.0", + "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@playwright/test": { + "optional": true + }, + "@testing-library/react": { + "optional": true + }, + "react": { + "optional": true + } + } + }, "packages/block-editor/node_modules/postcss-urlrebase": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/postcss-urlrebase/-/postcss-urlrebase-1.4.0.tgz", @@ -58399,19 +56377,6 @@ "react-dom": "^18.0.0" } }, - "packages/block-library/node_modules/@arraypress/waveform-player": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@arraypress/waveform-player/-/waveform-player-1.2.1.tgz", - "integrity": "sha512-PsgOZStUN+1GnY0tujbwk2PYE3HMT/Vl3wEvunqH16hIJWzisf8GEngy5EbswTAjQ1aV3Tk4XBkAskc8eslY1A==", - "license": "MIT", - "engines": { - "node": ">=14.0.0" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/arraypress" - } - }, "packages/block-serialization-default-parser": { "name": "@wordpress/block-serialization-default-parser", "version": "5.41.0", @@ -58633,13 +56598,19 @@ "react-dom": "^18.0.0" } }, + "packages/components/node_modules/@ariakit/core": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", + "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", + "license": "MIT" + }, "packages/components/node_modules/@ariakit/react": { - "version": "0.4.22", - "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.22.tgz", - "integrity": "sha512-NKVBwMIGGfgMr2AoxvmUWmAeE/g6X/pDozR1S0yInF5tyem2DZQm+Td/9mKmZPu5e0x0hbEX1AQrb8SvL4VoBg==", + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.23.tgz", + "integrity": "sha512-zokuZ7C/pUtFi5x1d/0h5ulLGlJpnPXG1aFKU3F4Sj6sD9uNN/J+fXFsg3sZlWdg7u9ZhBLcjsheLypDjjf6WQ==", "license": "MIT", "dependencies": { - "@ariakit/react-core": "0.4.22" + "@ariakit/react-core": "0.4.23" }, "funding": { "type": "opencollective", @@ -58651,9 +56622,9 @@ } }, "packages/components/node_modules/@ariakit/react-core": { - "version": "0.4.22", - "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.22.tgz", - "integrity": "sha512-fWzQjMDhMCPGXDJ0/MkYF9vktclwF9XPxKm2fCwYfJMFtAha3ZKXnme2t+IAxguBLtklzW+5xTAEjKV4xn9s7A==", + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.23.tgz", + "integrity": "sha512-cqcgYBgn+rCsZ05o8f3qKQW4ukOdZPgGgiu2BXv889LksbdjdvTMZ6Fd6JTHXm2vmqdnAkmpVulrhKe6NMETDQ==", "license": "MIT", "dependencies": { "@ariakit/core": "0.4.18", @@ -58665,6 +56636,33 @@ "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" } }, + "packages/components/node_modules/@ariakit/test": { + "version": "0.4.13", + "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", + "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ariakit/core": "0.4.18", + "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" + }, + "peerDependencies": { + "@playwright/test": "^1.27.0", + "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@playwright/test": { + "optional": true + }, + "@testing-library/react": { + "optional": true + }, + "react": { + "optional": true + } + } + }, "packages/components/node_modules/@emotion/css": { "version": "11.13.5", "resolved": "https://registry.npmjs.org/@emotion/css/-/css-11.13.5.tgz", @@ -58678,6 +56676,213 @@ "@emotion/utils": "^1.4.2" } }, + "packages/components/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "packages/components/node_modules/@storybook/addon-docs": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", + "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.2.19", + "@storybook/icons": "^2.0.1", + "@storybook/react-dom-shim": "10.2.19", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19" + } + }, + "packages/components/node_modules/@storybook/builder-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", + "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.19", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/components/node_modules/@storybook/csf-plugin": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", + "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.19", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "packages/components/node_modules/@storybook/react-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", + "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.19", + "@storybook/react": "10.2.19", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/components/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/components/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/components/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/components/node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/components/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/components/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "packages/components/node_modules/framer-motion": { "version": "11.15.0", "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-11.15.0.tgz", @@ -58704,6 +56909,96 @@ } } }, + "packages/components/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/components/node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "packages/components/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/components/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "packages/components/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/components/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "packages/components/node_modules/path-to-regexp": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", @@ -58720,6 +57015,132 @@ "react-dom": ">=16.8.0" } }, + "packages/components/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "packages/components/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/components/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "packages/components/node_modules/storybook": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", + "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, + "packages/components/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "packages/components/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "packages/components/node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "packages/compose": { "name": "@wordpress/compose", "version": "7.41.0", @@ -58846,21 +57267,21 @@ } }, "packages/core-data/node_modules/@babel/core": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.6.tgz", - "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.28.6", - "@babel/generator": "^7.28.6", + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-module-transforms": "^7.28.6", "@babel/helpers": "^7.28.6", - "@babel/parser": "^7.28.6", + "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", - "@babel/traverse": "^7.28.6", - "@babel/types": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", @@ -58919,18 +57340,18 @@ } }, "packages/core-data/node_modules/@babel/traverse": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz", - "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.28.6", - "@babel/generator": "^7.28.6", + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", "@babel/helper-globals": "^7.28.0", - "@babel/parser": "^7.28.6", + "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", - "@babel/types": "^7.28.6", + "@babel/types": "^7.29.0", "debug": "^4.3.1" }, "engines": { @@ -58938,39 +57359,39 @@ } }, "packages/core-data/node_modules/@jest/environment": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.2.0.tgz", - "integrity": "sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.3.0.tgz", + "integrity": "sha512-SlLSF4Be735yQXyh2+mctBOzNDx5s5uLv88/j8Qn1wH679PDcwy67+YdADn8NJnGjzlXtN62asGH/T4vWOkfaw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/fake-timers": "30.2.0", - "@jest/types": "30.2.0", + "@jest/fake-timers": "30.3.0", + "@jest/types": "30.3.0", "@types/node": "*", - "jest-mock": "30.2.0" + "jest-mock": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/expect": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.2.0.tgz", - "integrity": "sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.3.0.tgz", + "integrity": "sha512-76Nlh4xJxk2D/9URCn3wFi98d2hb19uWE1idLsTt2ywhvdOldbw3S570hBgn25P4ICUZ/cBjybrBex2g17IDbg==", "dev": true, "license": "MIT", "dependencies": { - "expect": "30.2.0", - "jest-snapshot": "30.2.0" + "expect": "30.3.0", + "jest-snapshot": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/expect-utils": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.2.0.tgz", - "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.3.0.tgz", + "integrity": "sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==", "dev": true, "license": "MIT", "dependencies": { @@ -58981,34 +57402,34 @@ } }, "packages/core-data/node_modules/@jest/fake-timers": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.2.0.tgz", - "integrity": "sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.3.0.tgz", + "integrity": "sha512-WUQDs8SOP9URStX1DzhD425CqbN/HxUYCTwVrT8sTVBfMvFqYt/s61EK5T05qnHu0po6RitXIvP9otZxYDzTGQ==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", - "@sinonjs/fake-timers": "^13.0.0", + "@jest/types": "30.3.0", + "@sinonjs/fake-timers": "^15.0.0", "@types/node": "*", - "jest-message-util": "30.2.0", - "jest-mock": "30.2.0", - "jest-util": "30.2.0" + "jest-message-util": "30.3.0", + "jest-mock": "30.3.0", + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/globals": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.2.0.tgz", - "integrity": "sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.3.0.tgz", + "integrity": "sha512-+owLCBBdfpgL3HU+BD5etr1SvbXpSitJK0is1kiYjJxAAJggYMRQz5hSdd5pq1sSggfxPbw2ld71pt4x5wwViA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/environment": "30.2.0", - "@jest/expect": "30.2.0", - "@jest/types": "30.2.0", - "jest-mock": "30.2.0" + "@jest/environment": "30.3.0", + "@jest/expect": "30.3.0", + "@jest/types": "30.3.0", + "jest-mock": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -59028,24 +57449,23 @@ } }, "packages/core-data/node_modules/@jest/transform": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.2.0.tgz", - "integrity": "sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.3.0.tgz", + "integrity": "sha512-TLKY33fSLVd/lKB2YI1pH69ijyUblO/BQvCj566YvnwuzoTNr648iE0j22vRvVNk2HsPwByPxATg3MleS3gf5A==", "dev": true, "license": "MIT", "dependencies": { "@babel/core": "^7.27.4", - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@jridgewell/trace-mapping": "^0.3.25", "babel-plugin-istanbul": "^7.0.1", "chalk": "^4.1.2", "convert-source-map": "^2.0.0", "fast-json-stable-stringify": "^2.1.0", "graceful-fs": "^4.2.11", - "jest-haste-map": "30.2.0", + "jest-haste-map": "30.3.0", "jest-regex-util": "30.0.1", - "jest-util": "30.2.0", - "micromatch": "^4.0.8", + "jest-util": "30.3.0", "pirates": "^4.0.7", "slash": "^3.0.0", "write-file-atomic": "^5.0.1" @@ -59055,9 +57475,9 @@ } }, "packages/core-data/node_modules/@jest/types": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", - "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", + "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", "dev": true, "license": "MIT", "dependencies": { @@ -59081,9 +57501,9 @@ "license": "MIT" }, "packages/core-data/node_modules/@sinonjs/fake-timers": { - "version": "13.0.5", - "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-13.0.5.tgz", - "integrity": "sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==", + "version": "15.1.1", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.1.1.tgz", + "integrity": "sha512-cO5W33JgAPbOh07tvZjUOJ7oWhtaqGHiZw+11DPbyqh2kHTBc3eF/CjJDeQ4205RLQsX6rxCuYOroFQwl7JDRw==", "dev": true, "license": "BSD-3-Clause", "dependencies": { @@ -59091,9 +57511,9 @@ } }, "packages/core-data/node_modules/@types/node": { - "version": "20.19.30", - "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.30.tgz", - "integrity": "sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==", + "version": "20.19.37", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz", + "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==", "dev": true, "license": "MIT", "dependencies": { @@ -59175,9 +57595,9 @@ } }, "packages/core-data/node_modules/ci-info": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz", - "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==", + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz", + "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==", "dev": true, "funding": [ { @@ -59198,18 +57618,18 @@ "license": "MIT" }, "packages/core-data/node_modules/expect": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/expect/-/expect-30.2.0.tgz", - "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-30.3.0.tgz", + "integrity": "sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==", "dev": true, "license": "MIT", "dependencies": { - "@jest/expect-utils": "30.2.0", + "@jest/expect-utils": "30.3.0", "@jest/get-type": "30.1.0", - "jest-matcher-utils": "30.2.0", - "jest-message-util": "30.2.0", - "jest-mock": "30.2.0", - "jest-util": "30.2.0" + "jest-matcher-utils": "30.3.0", + "jest-message-util": "30.3.0", + "jest-mock": "30.3.0", + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -59268,37 +57688,37 @@ } }, "packages/core-data/node_modules/jest-diff": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.2.0.tgz", - "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.3.0.tgz", + "integrity": "sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==", "dev": true, "license": "MIT", "dependencies": { - "@jest/diff-sequences": "30.0.1", + "@jest/diff-sequences": "30.3.0", "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "pretty-format": "30.2.0" + "pretty-format": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-haste-map": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.2.0.tgz", - "integrity": "sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.3.0.tgz", + "integrity": "sha512-mMi2oqG4KRU0R9QEtscl87JzMXfUhbKaFqOxmjb2CKcbHcUGFrJCBWHmnTiUqi6JcnzoBlO4rWfpdl2k/RfLCA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", "anymatch": "^3.1.3", "fb-watchman": "^2.0.2", "graceful-fs": "^4.2.11", "jest-regex-util": "30.0.1", - "jest-util": "30.2.0", - "jest-worker": "30.2.0", - "micromatch": "^4.0.8", + "jest-util": "30.3.0", + "jest-worker": "30.3.0", + "picomatch": "^4.0.3", "walker": "^1.0.8" }, "engines": { @@ -59309,35 +57729,35 @@ } }, "packages/core-data/node_modules/jest-matcher-utils": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz", - "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.3.0.tgz", + "integrity": "sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==", "dev": true, "license": "MIT", "dependencies": { "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "jest-diff": "30.2.0", - "pretty-format": "30.2.0" + "jest-diff": "30.3.0", + "pretty-format": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-message-util": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.2.0.tgz", - "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.3.0.tgz", + "integrity": "sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==", "dev": true, "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/stack-utils": "^2.0.3", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", - "micromatch": "^4.0.8", - "pretty-format": "30.2.0", + "picomatch": "^4.0.3", + "pretty-format": "30.3.0", "slash": "^3.0.0", "stack-utils": "^2.0.6" }, @@ -59346,15 +57766,15 @@ } }, "packages/core-data/node_modules/jest-mock": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.2.0.tgz", - "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.3.0.tgz", + "integrity": "sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", - "jest-util": "30.2.0" + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -59371,9 +57791,9 @@ } }, "packages/core-data/node_modules/jest-snapshot": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.2.0.tgz", - "integrity": "sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.3.0.tgz", + "integrity": "sha512-f14c7atpb4O2DeNhwcvS810Y63wEn8O1HqK/luJ4F6M4NjvxmAKQwBUWjbExUtMxWJQ0wVgmCKymeJK6NZMnfQ==", "dev": true, "license": "MIT", "dependencies": { @@ -59382,20 +57802,20 @@ "@babel/plugin-syntax-jsx": "^7.27.1", "@babel/plugin-syntax-typescript": "^7.27.1", "@babel/types": "^7.27.3", - "@jest/expect-utils": "30.2.0", + "@jest/expect-utils": "30.3.0", "@jest/get-type": "30.1.0", - "@jest/snapshot-utils": "30.2.0", - "@jest/transform": "30.2.0", - "@jest/types": "30.2.0", + "@jest/snapshot-utils": "30.3.0", + "@jest/transform": "30.3.0", + "@jest/types": "30.3.0", "babel-preset-current-node-syntax": "^1.2.0", "chalk": "^4.1.2", - "expect": "30.2.0", + "expect": "30.3.0", "graceful-fs": "^4.2.11", - "jest-diff": "30.2.0", - "jest-matcher-utils": "30.2.0", - "jest-message-util": "30.2.0", - "jest-util": "30.2.0", - "pretty-format": "30.2.0", + "jest-diff": "30.3.0", + "jest-matcher-utils": "30.3.0", + "jest-message-util": "30.3.0", + "jest-util": "30.3.0", + "pretty-format": "30.3.0", "semver": "^7.7.2", "synckit": "^0.11.8" }, @@ -59404,33 +57824,33 @@ } }, "packages/core-data/node_modules/jest-util": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.2.0.tgz", - "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.3.0.tgz", + "integrity": "sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", "chalk": "^4.1.2", "ci-info": "^4.2.0", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.2" + "picomatch": "^4.0.3" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-worker": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.2.0.tgz", - "integrity": "sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.3.0.tgz", + "integrity": "sha512-DrCKkaQwHexjRUFTmPzs7sHQe0TSj9nvDALKGdwmK5mW9v7j90BudWirKAJHt3QQ9Dhrg1F7DogPzhChppkJpQ==", "dev": true, "license": "MIT", "dependencies": { "@types/node": "*", "@ungap/structured-clone": "^1.3.0", - "jest-util": "30.2.0", + "jest-util": "30.3.0", "merge-stream": "^2.0.0", "supports-color": "^8.1.1" }, @@ -59478,9 +57898,9 @@ } }, "packages/core-data/node_modules/pretty-format": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.2.0.tgz", - "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.3.0.tgz", + "integrity": "sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==", "dev": true, "license": "MIT", "dependencies": { @@ -59513,9 +57933,9 @@ "license": "MIT" }, "packages/core-data/node_modules/semver": { - "version": "7.7.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", - "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "dev": true, "license": "ISC", "bin": { @@ -59763,6 +58183,208 @@ "react-dom": "^18.0.0" } }, + "packages/dataviews/node_modules/@ariakit/core": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", + "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", + "license": "MIT" + }, + "packages/dataviews/node_modules/@ariakit/react": { + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.23.tgz", + "integrity": "sha512-zokuZ7C/pUtFi5x1d/0h5ulLGlJpnPXG1aFKU3F4Sj6sD9uNN/J+fXFsg3sZlWdg7u9ZhBLcjsheLypDjjf6WQ==", + "license": "MIT", + "dependencies": { + "@ariakit/react-core": "0.4.23" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/ariakit" + }, + "peerDependencies": { + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "packages/dataviews/node_modules/@ariakit/react-core": { + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.23.tgz", + "integrity": "sha512-cqcgYBgn+rCsZ05o8f3qKQW4ukOdZPgGgiu2BXv889LksbdjdvTMZ6Fd6JTHXm2vmqdnAkmpVulrhKe6NMETDQ==", + "license": "MIT", + "dependencies": { + "@ariakit/core": "0.4.18", + "@floating-ui/dom": "^1.0.0", + "use-sync-external-store": "^1.2.0" + }, + "peerDependencies": { + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "packages/dataviews/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "packages/dataviews/node_modules/@storybook/addon-docs": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", + "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.2.19", + "@storybook/icons": "^2.0.1", + "@storybook/react-dom-shim": "10.2.19", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19" + } + }, + "packages/dataviews/node_modules/@storybook/builder-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", + "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.19", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/dataviews/node_modules/@storybook/csf-plugin": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", + "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.19", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "packages/dataviews/node_modules/@storybook/react-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", + "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.19", + "@storybook/react": "10.2.19", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/dataviews/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/dataviews/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/dataviews/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "packages/dataviews/node_modules/date-fns": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz", @@ -59773,11 +58395,223 @@ "url": "https://github.com/sponsors/kossnocorp" } }, + "packages/dataviews/node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/dataviews/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/dataviews/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/dataviews/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/dataviews/node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "packages/dataviews/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/dataviews/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "packages/dataviews/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/dataviews/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/dataviews/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "packages/dataviews/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/dataviews/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "packages/dataviews/node_modules/storybook": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", + "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, "packages/dataviews/node_modules/storybook/node_modules/esbuild": { "version": "0.25.12", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", - "extraneous": true, + "dev": true, "hasInstallScript": true, "license": "MIT", "bin": { @@ -59815,6 +58649,53 @@ "@esbuild/win32-x64": "0.25.12" } }, + "packages/dataviews/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "packages/dataviews/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "packages/dataviews/node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "packages/date": { "name": "@wordpress/date", "version": "5.41.0", @@ -61234,6 +60115,16 @@ "npm": ">=8.19.2" } }, + "packages/react-native-editor/node_modules/@babel/helper-plugin-utils": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", + "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "packages/react-native-editor/node_modules/@babel/plugin-transform-arrow-functions": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", @@ -61867,21 +60758,21 @@ } }, "packages/sync/node_modules/@babel/core": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.6.tgz", - "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.28.6", - "@babel/generator": "^7.28.6", + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-module-transforms": "^7.28.6", "@babel/helpers": "^7.28.6", - "@babel/parser": "^7.28.6", + "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", - "@babel/traverse": "^7.28.6", - "@babel/types": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", @@ -61940,18 +60831,18 @@ } }, "packages/sync/node_modules/@babel/traverse": { - "version": "7.28.6", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz", - "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==", + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.28.6", - "@babel/generator": "^7.28.6", + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", "@babel/helper-globals": "^7.28.0", - "@babel/parser": "^7.28.6", + "@babel/parser": "^7.29.0", "@babel/template": "^7.28.6", - "@babel/types": "^7.28.6", + "@babel/types": "^7.29.0", "debug": "^4.3.1" }, "engines": { @@ -61959,39 +60850,39 @@ } }, "packages/sync/node_modules/@jest/environment": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.2.0.tgz", - "integrity": "sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.3.0.tgz", + "integrity": "sha512-SlLSF4Be735yQXyh2+mctBOzNDx5s5uLv88/j8Qn1wH679PDcwy67+YdADn8NJnGjzlXtN62asGH/T4vWOkfaw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/fake-timers": "30.2.0", - "@jest/types": "30.2.0", + "@jest/fake-timers": "30.3.0", + "@jest/types": "30.3.0", "@types/node": "*", - "jest-mock": "30.2.0" + "jest-mock": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/expect": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.2.0.tgz", - "integrity": "sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.3.0.tgz", + "integrity": "sha512-76Nlh4xJxk2D/9URCn3wFi98d2hb19uWE1idLsTt2ywhvdOldbw3S570hBgn25P4ICUZ/cBjybrBex2g17IDbg==", "dev": true, "license": "MIT", "dependencies": { - "expect": "30.2.0", - "jest-snapshot": "30.2.0" + "expect": "30.3.0", + "jest-snapshot": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/expect-utils": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.2.0.tgz", - "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.3.0.tgz", + "integrity": "sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==", "dev": true, "license": "MIT", "dependencies": { @@ -62002,34 +60893,34 @@ } }, "packages/sync/node_modules/@jest/fake-timers": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.2.0.tgz", - "integrity": "sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.3.0.tgz", + "integrity": "sha512-WUQDs8SOP9URStX1DzhD425CqbN/HxUYCTwVrT8sTVBfMvFqYt/s61EK5T05qnHu0po6RitXIvP9otZxYDzTGQ==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", - "@sinonjs/fake-timers": "^13.0.0", + "@jest/types": "30.3.0", + "@sinonjs/fake-timers": "^15.0.0", "@types/node": "*", - "jest-message-util": "30.2.0", - "jest-mock": "30.2.0", - "jest-util": "30.2.0" + "jest-message-util": "30.3.0", + "jest-mock": "30.3.0", + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/globals": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.2.0.tgz", - "integrity": "sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.3.0.tgz", + "integrity": "sha512-+owLCBBdfpgL3HU+BD5etr1SvbXpSitJK0is1kiYjJxAAJggYMRQz5hSdd5pq1sSggfxPbw2ld71pt4x5wwViA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/environment": "30.2.0", - "@jest/expect": "30.2.0", - "@jest/types": "30.2.0", - "jest-mock": "30.2.0" + "@jest/environment": "30.3.0", + "@jest/expect": "30.3.0", + "@jest/types": "30.3.0", + "jest-mock": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -62049,24 +60940,23 @@ } }, "packages/sync/node_modules/@jest/transform": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.2.0.tgz", - "integrity": "sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.3.0.tgz", + "integrity": "sha512-TLKY33fSLVd/lKB2YI1pH69ijyUblO/BQvCj566YvnwuzoTNr648iE0j22vRvVNk2HsPwByPxATg3MleS3gf5A==", "dev": true, "license": "MIT", "dependencies": { "@babel/core": "^7.27.4", - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@jridgewell/trace-mapping": "^0.3.25", "babel-plugin-istanbul": "^7.0.1", "chalk": "^4.1.2", "convert-source-map": "^2.0.0", "fast-json-stable-stringify": "^2.1.0", "graceful-fs": "^4.2.11", - "jest-haste-map": "30.2.0", + "jest-haste-map": "30.3.0", "jest-regex-util": "30.0.1", - "jest-util": "30.2.0", - "micromatch": "^4.0.8", + "jest-util": "30.3.0", "pirates": "^4.0.7", "slash": "^3.0.0", "write-file-atomic": "^5.0.1" @@ -62076,9 +60966,9 @@ } }, "packages/sync/node_modules/@jest/types": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", - "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", + "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", "dev": true, "license": "MIT", "dependencies": { @@ -62102,9 +60992,9 @@ "license": "MIT" }, "packages/sync/node_modules/@sinonjs/fake-timers": { - "version": "13.0.5", - "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-13.0.5.tgz", - "integrity": "sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==", + "version": "15.1.1", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.1.1.tgz", + "integrity": "sha512-cO5W33JgAPbOh07tvZjUOJ7oWhtaqGHiZw+11DPbyqh2kHTBc3eF/CjJDeQ4205RLQsX6rxCuYOroFQwl7JDRw==", "dev": true, "license": "BSD-3-Clause", "dependencies": { @@ -62186,9 +61076,9 @@ } }, "packages/sync/node_modules/ci-info": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz", - "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==", + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz", + "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==", "dev": true, "funding": [ { @@ -62218,18 +61108,18 @@ } }, "packages/sync/node_modules/expect": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/expect/-/expect-30.2.0.tgz", - "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-30.3.0.tgz", + "integrity": "sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==", "dev": true, "license": "MIT", "dependencies": { - "@jest/expect-utils": "30.2.0", + "@jest/expect-utils": "30.3.0", "@jest/get-type": "30.1.0", - "jest-matcher-utils": "30.2.0", - "jest-message-util": "30.2.0", - "jest-mock": "30.2.0", - "jest-util": "30.2.0" + "jest-matcher-utils": "30.3.0", + "jest-message-util": "30.3.0", + "jest-mock": "30.3.0", + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -62288,37 +61178,37 @@ } }, "packages/sync/node_modules/jest-diff": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.2.0.tgz", - "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.3.0.tgz", + "integrity": "sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==", "dev": true, "license": "MIT", "dependencies": { - "@jest/diff-sequences": "30.0.1", + "@jest/diff-sequences": "30.3.0", "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "pretty-format": "30.2.0" + "pretty-format": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-haste-map": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.2.0.tgz", - "integrity": "sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.3.0.tgz", + "integrity": "sha512-mMi2oqG4KRU0R9QEtscl87JzMXfUhbKaFqOxmjb2CKcbHcUGFrJCBWHmnTiUqi6JcnzoBlO4rWfpdl2k/RfLCA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", "anymatch": "^3.1.3", "fb-watchman": "^2.0.2", "graceful-fs": "^4.2.11", "jest-regex-util": "30.0.1", - "jest-util": "30.2.0", - "jest-worker": "30.2.0", - "micromatch": "^4.0.8", + "jest-util": "30.3.0", + "jest-worker": "30.3.0", + "picomatch": "^4.0.3", "walker": "^1.0.8" }, "engines": { @@ -62329,35 +61219,35 @@ } }, "packages/sync/node_modules/jest-matcher-utils": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz", - "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.3.0.tgz", + "integrity": "sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==", "dev": true, "license": "MIT", "dependencies": { "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "jest-diff": "30.2.0", - "pretty-format": "30.2.0" + "jest-diff": "30.3.0", + "pretty-format": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-message-util": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.2.0.tgz", - "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.3.0.tgz", + "integrity": "sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==", "dev": true, "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/stack-utils": "^2.0.3", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", - "micromatch": "^4.0.8", - "pretty-format": "30.2.0", + "picomatch": "^4.0.3", + "pretty-format": "30.3.0", "slash": "^3.0.0", "stack-utils": "^2.0.6" }, @@ -62366,15 +61256,15 @@ } }, "packages/sync/node_modules/jest-mock": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.2.0.tgz", - "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.3.0.tgz", + "integrity": "sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", - "jest-util": "30.2.0" + "jest-util": "30.3.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -62391,9 +61281,9 @@ } }, "packages/sync/node_modules/jest-snapshot": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.2.0.tgz", - "integrity": "sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.3.0.tgz", + "integrity": "sha512-f14c7atpb4O2DeNhwcvS810Y63wEn8O1HqK/luJ4F6M4NjvxmAKQwBUWjbExUtMxWJQ0wVgmCKymeJK6NZMnfQ==", "dev": true, "license": "MIT", "dependencies": { @@ -62402,20 +61292,20 @@ "@babel/plugin-syntax-jsx": "^7.27.1", "@babel/plugin-syntax-typescript": "^7.27.1", "@babel/types": "^7.27.3", - "@jest/expect-utils": "30.2.0", + "@jest/expect-utils": "30.3.0", "@jest/get-type": "30.1.0", - "@jest/snapshot-utils": "30.2.0", - "@jest/transform": "30.2.0", - "@jest/types": "30.2.0", + "@jest/snapshot-utils": "30.3.0", + "@jest/transform": "30.3.0", + "@jest/types": "30.3.0", "babel-preset-current-node-syntax": "^1.2.0", "chalk": "^4.1.2", - "expect": "30.2.0", + "expect": "30.3.0", "graceful-fs": "^4.2.11", - "jest-diff": "30.2.0", - "jest-matcher-utils": "30.2.0", - "jest-message-util": "30.2.0", - "jest-util": "30.2.0", - "pretty-format": "30.2.0", + "jest-diff": "30.3.0", + "jest-matcher-utils": "30.3.0", + "jest-message-util": "30.3.0", + "jest-util": "30.3.0", + "pretty-format": "30.3.0", "semver": "^7.7.2", "synckit": "^0.11.8" }, @@ -62424,33 +61314,33 @@ } }, "packages/sync/node_modules/jest-util": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.2.0.tgz", - "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.3.0.tgz", + "integrity": "sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.2.0", + "@jest/types": "30.3.0", "@types/node": "*", "chalk": "^4.1.2", "ci-info": "^4.2.0", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.2" + "picomatch": "^4.0.3" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-worker": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.2.0.tgz", - "integrity": "sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.3.0.tgz", + "integrity": "sha512-DrCKkaQwHexjRUFTmPzs7sHQe0TSj9nvDALKGdwmK5mW9v7j90BudWirKAJHt3QQ9Dhrg1F7DogPzhChppkJpQ==", "dev": true, "license": "MIT", "dependencies": { "@types/node": "*", "@ungap/structured-clone": "^1.3.0", - "jest-util": "30.2.0", + "jest-util": "30.3.0", "merge-stream": "^2.0.0", "supports-color": "^8.1.1" }, @@ -62474,6 +61364,27 @@ "url": "https://github.com/chalk/supports-color?sponsor=1" } }, + "packages/sync/node_modules/lib0": { + "version": "0.2.99", + "resolved": "https://registry.npmjs.org/lib0/-/lib0-0.2.99.tgz", + "integrity": "sha512-vwztYuUf1uf/1zQxfzRfO5yzfNKhTtgOByCruuiQQxWQXnPb8Itaube5ylofcV0oM0aKal9Mv+S1s1Ky0UYP1w==", + "license": "MIT", + "dependencies": { + "isomorphic.js": "^0.2.4" + }, + "bin": { + "0ecdsa-generate-keypair": "bin/0ecdsa-generate-keypair.js", + "0gentesthtml": "bin/gentesthtml.js", + "0serve": "bin/0serve.js" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "type": "GitHub Sponsors ❤", + "url": "https://github.com/sponsors/dmonad" + } + }, "packages/sync/node_modules/picomatch": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", @@ -62498,9 +61409,9 @@ } }, "packages/sync/node_modules/pretty-format": { - "version": "30.2.0", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.2.0.tgz", - "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==", + "version": "30.3.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.3.0.tgz", + "integrity": "sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==", "dev": true, "license": "MIT", "dependencies": { @@ -62533,9 +61444,9 @@ "license": "MIT" }, "packages/sync/node_modules/semver": { - "version": "7.7.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", - "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", "dev": true, "license": "ISC", "bin": { @@ -62621,6 +61532,23 @@ "yjs": "^13.0.0" } }, + "packages/sync/node_modules/yjs": { + "version": "13.6.29", + "resolved": "https://registry.npmjs.org/yjs/-/yjs-13.6.29.tgz", + "integrity": "sha512-kHqDPdltoXH+X4w1lVmMtddE3Oeqq48nM40FD5ojTd8xYhQpzIDcfE2keMSU5bAgRPJBe225WTUdyUgj1DtbiQ==", + "license": "MIT", + "dependencies": { + "lib0": "^0.2.99" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=8.0.0" + }, + "funding": { + "type": "GitHub Sponsors ❤", + "url": "https://github.com/sponsors/dmonad" + } + }, "packages/theme": { "name": "@wordpress/theme", "version": "0.8.0", @@ -62658,6 +61586,147 @@ } } }, + "packages/theme/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "packages/theme/node_modules/@storybook/builder-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", + "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.19", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/theme/node_modules/@storybook/csf-plugin": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", + "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.19", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "packages/theme/node_modules/@storybook/react-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", + "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.19", + "@storybook/react": "10.2.19", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/theme/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/theme/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/theme/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "packages/theme/node_modules/colorjs.io": { "version": "0.6.0", "resolved": "https://registry.npmjs.org/colorjs.io/-/colorjs.io-0.6.0.tgz", @@ -62668,6 +61737,265 @@ "url": "https://opencollective.com/color" } }, + "packages/theme/node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/theme/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/theme/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/theme/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/theme/node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "packages/theme/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/theme/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "packages/theme/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/theme/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/theme/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "packages/theme/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/theme/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "packages/theme/node_modules/storybook": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", + "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, + "packages/theme/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "packages/theme/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "packages/theme/node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "packages/token-list": { "name": "@wordpress/token-list", "version": "3.41.0", @@ -62711,9 +62039,539 @@ "react-dom": "^18.0.0" } }, + "packages/ui/node_modules/@babel/runtime": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz", + "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "packages/ui/node_modules/@base-ui/react": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@base-ui/react/-/react-1.3.0.tgz", + "integrity": "sha512-FwpKqZbPz14AITp1CVgf4AjhKPe1OeeVKSBMdgD10zbFlj3QSWelmtCMLi2+/PFZZcIm3l87G7rwtCZJwHyXWA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.28.6", + "@base-ui/utils": "0.2.6", + "@floating-ui/react-dom": "^2.1.8", + "@floating-ui/utils": "^0.2.11", + "tabbable": "^6.4.0", + "use-sync-external-store": "^1.6.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@types/react": "^17 || ^18 || ^19", + "react": "^17 || ^18 || ^19", + "react-dom": "^17 || ^18 || ^19" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "packages/ui/node_modules/@base-ui/utils": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/@base-ui/utils/-/utils-0.2.6.tgz", + "integrity": "sha512-yQ+qeuqohwhsNpoYDqqXaLllYAkPCP4vYdDrVo8FQXaAPfHWm1pG/Vm+jmGTA5JFS0BAIjookyapuJFY8F9PIw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.28.6", + "@floating-ui/utils": "^0.2.11", + "reselect": "^5.1.1", + "use-sync-external-store": "^1.6.0" + }, + "peerDependencies": { + "@types/react": "^17 || ^18 || ^19", + "react": "^17 || ^18 || ^19", + "react-dom": "^17 || ^18 || ^19" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "packages/ui/node_modules/@floating-ui/core": { + "version": "1.7.5", + "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz", + "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==", + "license": "MIT", + "dependencies": { + "@floating-ui/utils": "^0.2.11" + } + }, + "packages/ui/node_modules/@floating-ui/dom": { + "version": "1.7.6", + "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz", + "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==", + "license": "MIT", + "dependencies": { + "@floating-ui/core": "^1.7.5", + "@floating-ui/utils": "^0.2.11" + } + }, + "packages/ui/node_modules/@floating-ui/react-dom": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.8.tgz", + "integrity": "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==", + "license": "MIT", + "dependencies": { + "@floating-ui/dom": "^1.7.6" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "packages/ui/node_modules/@floating-ui/utils": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz", + "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==", + "license": "MIT" + }, + "packages/ui/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "packages/ui/node_modules/@storybook/addon-docs": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", + "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.2.19", + "@storybook/icons": "^2.0.1", + "@storybook/react-dom-shim": "10.2.19", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19" + } + }, + "packages/ui/node_modules/@storybook/builder-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", + "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.19", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/ui/node_modules/@storybook/csf-plugin": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", + "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.19", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "packages/ui/node_modules/@storybook/react-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", + "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.19", + "@storybook/react": "10.2.19", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "packages/ui/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/ui/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "packages/ui/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/ui/node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "packages/ui/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/ui/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "packages/ui/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "packages/ui/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "packages/ui/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "packages/ui/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "packages/ui/node_modules/storybook": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", + "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, + "packages/ui/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "packages/ui/node_modules/tabbable": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", + "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", + "license": "MIT" + }, + "packages/ui/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "packages/ui/node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "packages/ultrahdr": { "name": "@wordpress/ultrahdr", "version": "1.0.0-prerelease", + "extraneous": true, "license": "GPL-2.0-or-later", "dependencies": { "open-ultrahdr-wasm": "^0.1.1" @@ -62726,6 +62584,7 @@ "packages/ultrahdr-wasm": { "name": "@wordpress/ultrahdr-wasm", "version": "1.0.0-prerelease", + "extraneous": true, "license": "GPL-2.0-or-later", "engines": { "node": ">=18.12.0", @@ -62759,9 +62618,9 @@ "@wordpress/i18n": "file:../i18n", "@wordpress/preferences": "file:../preferences", "@wordpress/private-apis": "file:../private-apis", - "@wordpress/ultrahdr": "file:../ultrahdr", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", + "open-ultrahdr": "^0.1.0", "uuid": "^9.0.1" }, "engines": { @@ -63297,6 +63156,149 @@ "terser": "^5.37.0" } }, + "storybook/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "storybook/node_modules/@storybook/addon-a11y": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/addon-a11y/-/addon-a11y-10.2.19.tgz", + "integrity": "sha512-SJGf1ghCoRVlwyiRwz5GiHuNvu7C5iCDNIRJW8WGOJlnoQa3rYaY7WJ/8a/eT9N8buIscL9AYWudhh5zsI1W3g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "axe-core": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19" + } + }, + "storybook/node_modules/@storybook/addon-docs": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", + "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.2.19", + "@storybook/icons": "^2.0.1", + "@storybook/react-dom-shim": "10.2.19", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19" + } + }, + "storybook/node_modules/@storybook/builder-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", + "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.19", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "storybook/node_modules/@storybook/csf-plugin": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", + "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.19", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "storybook/node_modules/@storybook/react-vite": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", + "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.19", + "@storybook/react": "10.2.19", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.19", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, "storybook/node_modules/acorn": { "version": "8.15.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", @@ -63310,6 +63312,45 @@ "node": ">=0.4.0" } }, + "storybook/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "storybook/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "storybook/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "storybook/node_modules/commander": { "version": "2.20.3", "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", @@ -63317,6 +63358,228 @@ "dev": true, "license": "MIT" }, + "storybook/node_modules/default-browser": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", + "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "storybook/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "storybook/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "storybook/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "storybook/node_modules/lru-cache": { + "version": "11.2.7", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", + "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "storybook/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "storybook/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "storybook/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "storybook/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "storybook/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "storybook/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "storybook/node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "storybook/node_modules/storybook": { + "version": "10.2.19", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", + "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, + "storybook/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, "storybook/node_modules/terser": { "version": "5.46.0", "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.0.tgz", @@ -63335,6 +63598,43 @@ "engines": { "node": ">=10" } + }, + "storybook/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "storybook/node_modules/ws": { + "version": "8.19.0", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", + "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } } } } diff --git a/packages/ultrahdr-wasm/.gitignore b/packages/ultrahdr-wasm/.gitignore deleted file mode 100644 index 5dfa8d566775c4..00000000000000 --- a/packages/ultrahdr-wasm/.gitignore +++ /dev/null @@ -1,6 +0,0 @@ -# Build artifacts -/target/ -/pkg/ - -# Cargo lock is typically committed for applications but not libraries -# However, for reproducible builds in monorepo, we commit it diff --git a/packages/ultrahdr-wasm/Cargo.lock b/packages/ultrahdr-wasm/Cargo.lock deleted file mode 100644 index 47abaa9a294ba1..00000000000000 --- a/packages/ultrahdr-wasm/Cargo.lock +++ /dev/null @@ -1,533 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 4 - -[[package]] -name = "async-trait" -version = "0.1.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "autocfg" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8" - -[[package]] -name = "bumpalo" -version = "3.19.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510" - -[[package]] -name = "bytemuck" -version = "1.24.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4" - -[[package]] -name = "byteorder-lite" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495" - -[[package]] -name = "cast" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" - -[[package]] -name = "cc" -version = "1.2.53" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932" -dependencies = [ - "find-msvc-tools", - "shlex", -] - -[[package]] -name = "cfg-if" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" - -[[package]] -name = "find-msvc-tools" -version = "0.1.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db" - -[[package]] -name = "futures-core" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" - -[[package]] -name = "futures-task" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988" - -[[package]] -name = "futures-util" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81" -dependencies = [ - "futures-core", - "futures-task", - "pin-project-lite", - "pin-utils", - "slab", -] - -[[package]] -name = "image" -version = "0.25.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a" -dependencies = [ - "bytemuck", - "byteorder-lite", - "moxcms", - "num-traits", - "zune-core 0.5.1", - "zune-jpeg 0.5.11", -] - -[[package]] -name = "itoa" -version = "1.0.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" - -[[package]] -name = "js-sys" -version = "0.3.85" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3" -dependencies = [ - "once_cell", - "wasm-bindgen", -] - -[[package]] -name = "libm" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de" - -[[package]] -name = "memchr" -version = "2.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273" - -[[package]] -name = "minicov" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d" -dependencies = [ - "cc", - "walkdir", -] - -[[package]] -name = "moxcms" -version = "0.7.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac9557c559cd6fc9867e122e20d2cbefc9ca29d80d027a8e39310920ed2f0a97" -dependencies = [ - "num-traits", - "pxfm", -] - -[[package]] -name = "nu-ansi-term" -version = "0.50.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" -dependencies = [ - "windows-sys", -] - -[[package]] -name = "num-traits" -version = "0.2.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" -dependencies = [ - "autocfg", - "libm", -] - -[[package]] -name = "once_cell" -version = "1.21.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d" - -[[package]] -name = "oorandom" -version = "11.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e" - -[[package]] -name = "pin-project-lite" -version = "0.2.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "proc-macro2" -version = "1.0.105" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "pxfm" -version = "0.1.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7186d3822593aa4393561d186d1393b3923e9d6163d3fbfd6e825e3e6cf3e6a8" -dependencies = [ - "num-traits", -] - -[[package]] -name = "quick-xml" -version = "0.31.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33" -dependencies = [ - "memchr", -] - -[[package]] -name = "quote" -version = "1.0.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "rustversion" -version = "1.0.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "serde" -version = "1.0.228" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" -dependencies = [ - "serde_core", - "serde_derive", -] - -[[package]] -name = "serde_core" -version = "1.0.228" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_derive" -version = "1.0.228" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "serde_json" -version = "1.0.149" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" -dependencies = [ - "itoa", - "memchr", - "serde", - "serde_core", - "zmij", -] - -[[package]] -name = "shlex" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" - -[[package]] -name = "slab" -version = "0.4.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589" - -[[package]] -name = "syn" -version = "2.0.114" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "thiserror" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "unicode-ident" -version = "1.0.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5" - -[[package]] -name = "walkdir" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" -dependencies = [ - "same-file", - "winapi-util", -] - -[[package]] -name = "wasm-bindgen" -version = "0.2.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566" -dependencies = [ - "cfg-if", - "once_cell", - "rustversion", - "wasm-bindgen-macro", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70a6e77fd0ae8029c9ea0063f87c46fde723e7d887703d74ad2616d792e51e6f" -dependencies = [ - "cfg-if", - "futures-util", - "js-sys", - "once_cell", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55" -dependencies = [ - "bumpalo", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "wasm-bindgen-test" -version = "0.3.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45649196a53b0b7a15101d845d44d2dda7374fc1b5b5e2bbf58b7577ff4b346d" -dependencies = [ - "async-trait", - "cast", - "js-sys", - "libm", - "minicov", - "nu-ansi-term", - "num-traits", - "oorandom", - "serde", - "serde_json", - "wasm-bindgen", - "wasm-bindgen-futures", - "wasm-bindgen-test-macro", - "wasm-bindgen-test-shared", -] - -[[package]] -name = "wasm-bindgen-test-macro" -version = "0.3.58" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f579cdd0123ac74b94e1a4a72bd963cf30ebac343f2df347da0b8df24cdebed2" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "wasm-bindgen-test-shared" -version = "0.2.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8145dd1593bf0fb137dbfa85b8be79ec560a447298955877804640e40c2d6ea" - -[[package]] -name = "web-sys" -version = "0.3.85" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "312e32e551d92129218ea9a2452120f4aabc03529ef03e4d0d82fb2780608598" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "winapi-util" -version = "0.1.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" -dependencies = [ - "windows-sys", -] - -[[package]] -name = "windows-link" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" - -[[package]] -name = "windows-sys" -version = "0.61.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" -dependencies = [ - "windows-link", -] - -[[package]] -name = "wordpress-ultrahdr" -version = "0.1.0" -dependencies = [ - "image", - "js-sys", - "quick-xml", - "serde", - "serde_json", - "thiserror", - "wasm-bindgen", - "wasm-bindgen-test", - "web-sys", - "zune-jpeg 0.4.21", -] - -[[package]] -name = "zmij" -version = "1.0.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65" - -[[package]] -name = "zune-core" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a" - -[[package]] -name = "zune-core" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9" - -[[package]] -name = "zune-jpeg" -version = "0.4.21" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29ce2c8a9384ad323cf564b67da86e21d3cfdff87908bc1223ed5c99bc792713" -dependencies = [ - "zune-core 0.4.12", -] - -[[package]] -name = "zune-jpeg" -version = "0.5.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2959ca473aae96a14ecedf501d20b3608d2825ba280d5adb57d651721885b0c2" -dependencies = [ - "zune-core 0.5.1", -] diff --git a/packages/ultrahdr-wasm/Cargo.toml b/packages/ultrahdr-wasm/Cargo.toml deleted file mode 100644 index 5d3bc8cabe8850..00000000000000 --- a/packages/ultrahdr-wasm/Cargo.toml +++ /dev/null @@ -1,39 +0,0 @@ -[package] -name = "wordpress-ultrahdr" -version = "0.1.0" -edition = "2021" -license = "GPL-2.0-or-later" -authors = ["The WordPress Contributors"] -description = "UltraHDR (ISO 21496-1) gain map implementation for WordPress Gutenberg" -repository = "https://github.com/WordPress/gutenberg" -readme = "README.md" - -[lib] -crate-type = ["cdylib", "rlib"] - -[dependencies] -# WASM bindings (MIT/Apache-2.0) -wasm-bindgen = "0.2" -js-sys = "0.3" -web-sys = { version = "0.3", features = ["console"] } - -# Image processing (MIT/Apache-2.0) -image = { version = "0.25", default-features = false, features = ["jpeg"] } -zune-jpeg = { version = "0.4", default-features = false, features = ["std"] } - -# XMP/XML parsing (MIT) -quick-xml = "0.31" - -# Serialization (MIT/Apache-2.0) -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" - -# Error handling (MIT/Apache-2.0) -thiserror = "1.0" - -[dev-dependencies] -wasm-bindgen-test = "0.3" - -[profile.release] -opt-level = "s" -lto = true diff --git a/packages/ultrahdr-wasm/README.md b/packages/ultrahdr-wasm/README.md deleted file mode 100644 index 4a65d5fcaeb8b2..00000000000000 --- a/packages/ultrahdr-wasm/README.md +++ /dev/null @@ -1,81 +0,0 @@ -# UltraHDR WASM Library - -A GPLv2-compatible Rust library implementing ISO 21496-1 (UltraHDR/gain map) specification, compiled to WebAssembly for integration with WordPress Gutenberg's client-side media processing. - -## Features - -- **Detection**: Check if a JPEG contains UltraHDR/gain map data -- **Decoding**: Extract SDR base, gain map, and metadata from UltraHDR JPEGs -- **Encoding**: Create UltraHDR JPEGs from SDR + HDR image pairs -- **SDR Extraction**: Extract backwards-compatible SDR image - -## Standards Support - -- [ISO 21496-1:2025](https://www.iso.org/standard/86775.html) - Gain map metadata for dynamic range conversion -- [Google UltraHDR v1](https://developer.android.com/media/platform/hdr-image-format) - Android compatibility -- [Adobe Gain Map Specification](https://helpx.adobe.com/camera-raw/using/gain-map.html) - -## Building - -### Prerequisites - -- [Rust](https://rustup.rs/) (stable) -- [wasm-pack](https://rustwasm.github.io/wasm-pack/installer/) - -### Build Commands - -```bash -# Development build -npm run build:dev - -# Production build -npm run build - -# Run tests -npm run test -``` - -## Usage - -This package is intended to be used via the `@wordpress/ultrahdr` TypeScript wrapper. See that package for usage examples. - -## Architecture - -``` -src/ -├── lib.rs # WASM entry point and exports -├── types.rs # Shared types (GainMapMetadata, etc.) -├── error.rs # Error handling -├── gainmap/ -│ ├── mod.rs # Gain map module -│ ├── math.rs # Color space conversions -│ ├── metadata.rs # ISO 21496-1 metadata structures -│ ├── encode.rs # Gain map computation -│ └── decode.rs # Gain map application -├── jpeg/ -│ ├── mod.rs # JPEG handling -│ ├── parser.rs # APP1/APP2/MPF segment parsing -│ ├── writer.rs # JPEG segment writing -│ └── xmp.rs # XMP embedding/extraction -└── ultrahdr/ - ├── mod.rs # UltraHDR format - ├── encoder.rs # Create UltraHDR JPEG - └── decoder.rs # Extract components -``` - -## License - -GPL-2.0-or-later - -## Dependencies - -All dependencies are GPLv2-compatible (via MIT license): - -| Dependency | License | Purpose | -|------------|---------|---------| -| wasm-bindgen | MIT/Apache-2.0 | WASM bindings | -| image | MIT/Apache-2.0 | Image processing | -| zune-jpeg | MIT/Apache-2.0/Zlib | JPEG decoding | -| quick-xml | MIT | XMP parsing | -| serde | MIT/Apache-2.0 | Serialization | -| thiserror | MIT/Apache-2.0 | Error handling | diff --git a/packages/ultrahdr-wasm/package.json b/packages/ultrahdr-wasm/package.json deleted file mode 100644 index b46c03f027acab..00000000000000 --- a/packages/ultrahdr-wasm/package.json +++ /dev/null @@ -1,47 +0,0 @@ -{ - "name": "@wordpress/ultrahdr-wasm", - "version": "1.0.0-prerelease", - "private": true, - "description": "UltraHDR (ISO 21496-1) gain map WASM implementation for WordPress Gutenberg.", - "author": "The WordPress Contributors", - "license": "GPL-2.0-or-later", - "keywords": [ - "wordpress", - "media", - "ultrahdr", - "hdr", - "gain-map", - "wasm" - ], - "homepage": "https://github.com/WordPress/gutenberg/tree/HEAD/packages/ultrahdr-wasm/README.md", - "repository": { - "type": "git", - "url": "https://github.com/WordPress/gutenberg.git", - "directory": "packages/ultrahdr-wasm" - }, - "bugs": { - "url": "https://github.com/WordPress/gutenberg/issues" - }, - "engines": { - "node": ">=18.12.0", - "npm": ">=8.19.2" - }, - "files": [ - "pkg", - "*.md" - ], - "main": "pkg/wordpress_ultrahdr.js", - "module": "pkg/wordpress_ultrahdr.js", - "exports": { - ".": { - "types": "./pkg/wordpress_ultrahdr.d.ts", - "import": "./pkg/wordpress_ultrahdr.js", - "default": "./pkg/wordpress_ultrahdr.js" - }, - "./pkg/*": "./pkg/*", - "./package.json": "./package.json" - }, - "publishConfig": { - "access": "public" - } -} diff --git a/packages/ultrahdr-wasm/src/error.rs b/packages/ultrahdr-wasm/src/error.rs deleted file mode 100644 index 1656211e77f034..00000000000000 --- a/packages/ultrahdr-wasm/src/error.rs +++ /dev/null @@ -1,84 +0,0 @@ -//! Error types for UltraHDR operations. - -use thiserror::Error; - -/// Errors that can occur during UltraHDR operations. -#[derive(Error, Debug)] -pub enum UltraHdrError { - /// Invalid JPEG format or corrupted data - #[error("Invalid JPEG format: {0}")] - InvalidJpeg(String), - - /// Missing required marker or segment - #[error("Missing required JPEG marker: {0}")] - MissingMarker(String), - - /// XMP parsing or validation error - #[error("XMP error: {0}")] - XmpError(String), - - /// Gain map metadata error - #[error("Gain map metadata error: {0}")] - MetadataError(String), - - /// Image dimension mismatch - #[error("Image dimension mismatch: SDR {0}x{1}, HDR {2}x{3}")] - DimensionMismatch(u32, u32, u32, u32), - - /// Invalid dimensions (e.g., odd dimensions) - #[error("Invalid dimensions: {0}")] - InvalidDimensions(String), - - /// Invalid quality value - #[error("Invalid quality value: {0} (must be 1-100)")] - InvalidQuality(u8), - - /// Invalid HDR capacity values - #[error("Invalid HDR capacity: min ({0}) must be less than max ({1})")] - InvalidHdrCapacity(f32, f32), - - /// Image decoding error - #[error("Image decoding error: {0}")] - DecodeError(String), - - /// Image encoding error - #[error("Image encoding error: {0}")] - EncodeError(String), - - /// Color space conversion error - #[error("Color space error: {0}")] - ColorSpaceError(String), - - /// No gain map found in image - #[error("No gain map found in image")] - NoGainMap, - - /// I/O error - #[error("I/O error: {0}")] - IoError(String), - - /// Unsupported feature - #[error("Unsupported feature: {0}")] - Unsupported(String), -} - -/// Result type alias for UltraHDR operations. -pub type Result = std::result::Result; - -impl From for UltraHdrError { - fn from(err: std::io::Error) -> Self { - UltraHdrError::IoError(err.to_string()) - } -} - -impl From for UltraHdrError { - fn from(err: quick_xml::Error) -> Self { - UltraHdrError::XmpError(err.to_string()) - } -} - -impl From for UltraHdrError { - fn from(err: image::ImageError) -> Self { - UltraHdrError::DecodeError(err.to_string()) - } -} diff --git a/packages/ultrahdr-wasm/src/gainmap/decode.rs b/packages/ultrahdr-wasm/src/gainmap/decode.rs deleted file mode 100644 index 8fcd13cc73883a..00000000000000 --- a/packages/ultrahdr-wasm/src/gainmap/decode.rs +++ /dev/null @@ -1,343 +0,0 @@ -//! Gain map decoding (application to reconstruct HDR). -//! -//! Implements the gain map application algorithm from ISO 21496-1. - -use crate::error::{Result, UltraHdrError}; -use crate::types::GainMapMetadata; -use super::math::{decode_gain, apply_gain_to_pixel, compute_hdr_weight, srgb_to_linear, linear_to_srgb}; - -/// Applies a gain map to an SDR image to produce an HDR result. -/// -/// # Arguments -/// * `sdr_rgb` - SDR image as RGB bytes (sRGB encoded, 3 bytes per pixel) -/// * `gain_map` - Gain map as grayscale bytes (1 byte per pixel) -/// * `metadata` - Gain map metadata -/// * `width` - SDR image width -/// * `height` - SDR image height -/// * `gm_width` - Gain map width -/// * `gm_height` - Gain map height -/// * `display_hdr_capacity` - Display's HDR capacity (in stops) -/// -/// # Returns -/// Linear HDR RGB image as floats (3 floats per pixel). -pub fn apply_gain_map( - sdr_rgb: &[u8], - gain_map: &[u8], - metadata: &GainMapMetadata, - width: u32, - height: u32, - gm_width: u32, - gm_height: u32, - display_hdr_capacity: f32, -) -> Result> { - let pixel_count = (width * height) as usize; - let gm_pixel_count = (gm_width * gm_height) as usize; - - // Validate input sizes - if sdr_rgb.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "SDR buffer size {} doesn't match {}x{}x3", - sdr_rgb.len(), width, height - ))); - } - if gain_map.len() != gm_pixel_count { - return Err(UltraHdrError::InvalidDimensions(format!( - "Gain map size {} doesn't match {}x{}", - gain_map.len(), gm_width, gm_height - ))); - } - - // Compute HDR weight based on display capability - let hdr_weight = compute_hdr_weight( - display_hdr_capacity, - metadata.hdr_capacity_min, - metadata.hdr_capacity_max, - ); - - let mut hdr_output = vec![0.0f32; pixel_count * 3]; - - // Scale factors for gain map sampling - let scale_x = gm_width as f32 / width as f32; - let scale_y = gm_height as f32 / height as f32; - - for y in 0..height { - for x in 0..width { - let idx = (y * width + x) as usize; - - // Get SDR pixel and convert to linear - let sdr_r = sdr_rgb[idx * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[idx * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[idx * 3 + 2] as f32 / 255.0; - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - // Sample gain map with bilinear interpolation - let gm_x = x as f32 * scale_x; - let gm_y = y as f32 * scale_y; - let gain_encoded = sample_gain_map_bilinear(gain_map, gm_width, gm_height, gm_x, gm_y); - - // Decode gain value (same for all channels in single-channel gain map) - // Interpolate between min and max gain based on HDR weight - let effective_min = interpolate_per_channel(&metadata.gain_map_min, hdr_weight); - let effective_max = interpolate_per_channel(&metadata.gain_map_max, hdr_weight); - - let gain_r = decode_gain(gain_encoded, effective_min[0], effective_max[0], metadata.gamma[0]); - let gain_g = decode_gain(gain_encoded, effective_min[1], effective_max[1], metadata.gamma[1]); - let gain_b = decode_gain(gain_encoded, effective_min[2], effective_max[2], metadata.gamma[2]); - - // Apply gain to each channel - let hdr_r = apply_gain_to_pixel( - sdr_lin_r, - gain_r, - metadata.offset_sdr[0], - metadata.offset_hdr[0], - ); - let hdr_g = apply_gain_to_pixel( - sdr_lin_g, - gain_g, - metadata.offset_sdr[1], - metadata.offset_hdr[1], - ); - let hdr_b = apply_gain_to_pixel( - sdr_lin_b, - gain_b, - metadata.offset_sdr[2], - metadata.offset_hdr[2], - ); - - hdr_output[idx * 3] = hdr_r; - hdr_output[idx * 3 + 1] = hdr_g; - hdr_output[idx * 3 + 2] = hdr_b; - } - } - - Ok(hdr_output) -} - -/// Applies a per-channel RGB gain map to an SDR image. -pub fn apply_gain_map_rgb( - sdr_rgb: &[u8], - gain_map_rgb: &[u8], - metadata: &GainMapMetadata, - width: u32, - height: u32, - gm_width: u32, - gm_height: u32, - display_hdr_capacity: f32, -) -> Result> { - let pixel_count = (width * height) as usize; - let gm_pixel_count = (gm_width * gm_height) as usize; - - if sdr_rgb.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "SDR buffer size {} doesn't match {}x{}x3", - sdr_rgb.len(), width, height - ))); - } - if gain_map_rgb.len() != gm_pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "RGB gain map size {} doesn't match {}x{}x3", - gain_map_rgb.len(), gm_width, gm_height - ))); - } - - let hdr_weight = compute_hdr_weight( - display_hdr_capacity, - metadata.hdr_capacity_min, - metadata.hdr_capacity_max, - ); - - let mut hdr_output = vec![0.0f32; pixel_count * 3]; - - let scale_x = gm_width as f32 / width as f32; - let scale_y = gm_height as f32 / height as f32; - - for y in 0..height { - for x in 0..width { - let idx = (y * width + x) as usize; - - let sdr_r = sdr_rgb[idx * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[idx * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[idx * 3 + 2] as f32 / 255.0; - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - let gm_x = x as f32 * scale_x; - let gm_y = y as f32 * scale_y; - let (gain_enc_r, gain_enc_g, gain_enc_b) = sample_gain_map_rgb_bilinear( - gain_map_rgb, gm_width, gm_height, gm_x, gm_y - ); - - let effective_min = interpolate_per_channel(&metadata.gain_map_min, hdr_weight); - let effective_max = interpolate_per_channel(&metadata.gain_map_max, hdr_weight); - - let gain_r = decode_gain(gain_enc_r, effective_min[0], effective_max[0], metadata.gamma[0]); - let gain_g = decode_gain(gain_enc_g, effective_min[1], effective_max[1], metadata.gamma[1]); - let gain_b = decode_gain(gain_enc_b, effective_min[2], effective_max[2], metadata.gamma[2]); - - hdr_output[idx * 3] = apply_gain_to_pixel(sdr_lin_r, gain_r, metadata.offset_sdr[0], metadata.offset_hdr[0]); - hdr_output[idx * 3 + 1] = apply_gain_to_pixel(sdr_lin_g, gain_g, metadata.offset_sdr[1], metadata.offset_hdr[1]); - hdr_output[idx * 3 + 2] = apply_gain_to_pixel(sdr_lin_b, gain_b, metadata.offset_sdr[2], metadata.offset_hdr[2]); - } - } - - Ok(hdr_output) -} - -/// Renders HDR output to sRGB for SDR displays. -/// -/// Applies tone mapping to bring HDR values into displayable range. -pub fn render_to_srgb(hdr_linear: &[f32], max_luminance: f32) -> Vec { - let pixel_count = hdr_linear.len() / 3; - let mut output = vec![0u8; pixel_count * 3]; - - for i in 0..pixel_count { - // Simple Reinhard tone mapping - let r = hdr_linear[i * 3]; - let g = hdr_linear[i * 3 + 1]; - let b = hdr_linear[i * 3 + 2]; - - let mapped_r = r / (1.0 + r / max_luminance); - let mapped_g = g / (1.0 + g / max_luminance); - let mapped_b = b / (1.0 + b / max_luminance); - - let (srgb_r, srgb_g, srgb_b) = linear_to_srgb(mapped_r, mapped_g, mapped_b); - - output[i * 3] = (srgb_r * 255.0).clamp(0.0, 255.0) as u8; - output[i * 3 + 1] = (srgb_g * 255.0).clamp(0.0, 255.0) as u8; - output[i * 3 + 2] = (srgb_b * 255.0).clamp(0.0, 255.0) as u8; - } - - output -} - -/// Samples gain map with bilinear interpolation. -fn sample_gain_map_bilinear(gain_map: &[u8], width: u32, height: u32, x: f32, y: f32) -> f32 { - let x0 = (x.floor() as u32).min(width - 1); - let y0 = (y.floor() as u32).min(height - 1); - let x1 = (x0 + 1).min(width - 1); - let y1 = (y0 + 1).min(height - 1); - - let fx = x - x0 as f32; - let fy = y - y0 as f32; - - let v00 = gain_map[(y0 * width + x0) as usize] as f32 / 255.0; - let v10 = gain_map[(y0 * width + x1) as usize] as f32 / 255.0; - let v01 = gain_map[(y1 * width + x0) as usize] as f32 / 255.0; - let v11 = gain_map[(y1 * width + x1) as usize] as f32 / 255.0; - - let v0 = v00 * (1.0 - fx) + v10 * fx; - let v1 = v01 * (1.0 - fx) + v11 * fx; - - v0 * (1.0 - fy) + v1 * fy -} - -/// Samples RGB gain map with bilinear interpolation. -fn sample_gain_map_rgb_bilinear( - gain_map: &[u8], - width: u32, - height: u32, - x: f32, - y: f32, -) -> (f32, f32, f32) { - let x0 = (x.floor() as u32).min(width - 1); - let y0 = (y.floor() as u32).min(height - 1); - let x1 = (x0 + 1).min(width - 1); - let y1 = (y0 + 1).min(height - 1); - - let fx = x - x0 as f32; - let fy = y - y0 as f32; - - let idx00 = ((y0 * width + x0) * 3) as usize; - let idx10 = ((y0 * width + x1) * 3) as usize; - let idx01 = ((y1 * width + x0) * 3) as usize; - let idx11 = ((y1 * width + x1) * 3) as usize; - - let mut result = [0.0f32; 3]; - - for c in 0..3 { - let v00 = gain_map[idx00 + c] as f32 / 255.0; - let v10 = gain_map[idx10 + c] as f32 / 255.0; - let v01 = gain_map[idx01 + c] as f32 / 255.0; - let v11 = gain_map[idx11 + c] as f32 / 255.0; - - let v0 = v00 * (1.0 - fx) + v10 * fx; - let v1 = v01 * (1.0 - fx) + v11 * fx; - - result[c] = v0 * (1.0 - fy) + v1 * fy; - } - - (result[0], result[1], result[2]) -} - -/// Interpolates per-channel values based on HDR weight. -fn interpolate_per_channel(values: &[f32], weight: f32) -> Vec { - // When weight = 0, use 0 (no HDR), when weight = 1, use full values - values.iter().map(|&v| v * weight).collect() -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_apply_gain_map_basic() { - let width = 2u32; - let height = 2u32; - - // Mid-gray SDR image - let sdr = vec![128u8; 12]; - - // Neutral gain map (mid-point = no change) - let gain_map = vec![128u8; 4]; - - let metadata = GainMapMetadata::default(); - - let result = apply_gain_map( - &sdr, &gain_map, &metadata, - width, height, width, height, - 3.0 - ); - - assert!(result.is_ok()); - let hdr = result.unwrap(); - assert_eq!(hdr.len(), 12); // 2x2x3 floats - } - - #[test] - fn test_apply_gain_map_different_sizes() { - let width = 4u32; - let height = 4u32; - let gm_width = 2u32; - let gm_height = 2u32; - - let sdr = vec![128u8; 48]; // 4x4x3 - let gain_map = vec![128u8; 4]; // 2x2 - - let metadata = GainMapMetadata::default(); - - let result = apply_gain_map( - &sdr, &gain_map, &metadata, - width, height, gm_width, gm_height, - 3.0 - ); - - assert!(result.is_ok()); - } - - #[test] - fn test_render_to_srgb() { - let hdr = vec![0.5f32, 0.5, 0.5, 1.0, 1.0, 1.0]; // 2 pixels - let srgb = render_to_srgb(&hdr, 4.0); - - assert_eq!(srgb.len(), 6); - // Verify we get valid u8 output (non-zero for these inputs) - assert!(srgb.iter().any(|&v| v > 0)); - } - - #[test] - fn test_bilinear_interpolation() { - let gain_map = vec![0u8, 255, 0, 255]; // 2x2 - let center = sample_gain_map_bilinear(&gain_map, 2, 2, 0.5, 0.5); - // Should be average of all 4 pixels - assert!((center - 0.5).abs() < 0.01); - } -} diff --git a/packages/ultrahdr-wasm/src/gainmap/encode.rs b/packages/ultrahdr-wasm/src/gainmap/encode.rs deleted file mode 100644 index ca4a844dd734b8..00000000000000 --- a/packages/ultrahdr-wasm/src/gainmap/encode.rs +++ /dev/null @@ -1,257 +0,0 @@ -//! Gain map encoding (computation from SDR + HDR image pair). -//! -//! Implements the gain map computation algorithm from ISO 21496-1. - -use crate::error::{Result, UltraHdrError}; -use crate::types::GainMapMetadata; -use super::math::{encode_gain, compute_gain_ratio, srgb_to_linear}; -use super::metadata::MetadataComputer; - -/// Computes a gain map from an SDR and HDR image pair. -/// -/// # Arguments -/// * `sdr_rgb` - SDR image as RGB bytes (sRGB encoded, 3 bytes per pixel) -/// * `hdr_linear` - HDR image as linear RGB floats (3 floats per pixel, [0..1] normalized) -/// * `width` - Image width -/// * `height` - Image height -/// * `target_capacity` - Target HDR capacity (typically 2.0-4.0) -/// * `gain_map_scale` - Downscale factor for gain map (1 = full size, 2 = half, etc.) -/// -/// # Returns -/// A tuple of (gain_map_bytes, metadata) where gain_map_bytes is a grayscale -/// image representing the per-pixel gain values. -pub fn compute_gain_map( - sdr_rgb: &[u8], - hdr_linear: &[f32], - width: u32, - height: u32, - target_capacity: f32, - gain_map_scale: u8, -) -> Result<(Vec, GainMapMetadata)> { - let pixel_count = (width * height) as usize; - - // Validate input sizes - if sdr_rgb.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "SDR buffer size {} doesn't match {}x{}x3 = {}", - sdr_rgb.len(), width, height, pixel_count * 3 - ))); - } - if hdr_linear.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "HDR buffer size {} doesn't match {}x{}x3 = {}", - hdr_linear.len(), width, height, pixel_count * 3 - ))); - } - - let scale = gain_map_scale.max(1) as u32; - let gm_width = (width + scale - 1) / scale; - let gm_height = (height + scale - 1) / scale; - let gm_pixel_count = (gm_width * gm_height) as usize; - - // First pass: compute statistics for metadata - let mut metadata_computer = MetadataComputer::new(); - let offset = 1.0 / 64.0; // Standard offset - - // Sample every Nth pixel for statistics (for performance) - let sample_step = ((width * height) / 10000).max(1) as usize; - - for i in (0..pixel_count).step_by(sample_step) { - let sdr_r = sdr_rgb[i * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[i * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[i * 3 + 2] as f32 / 255.0; - - // Convert SDR from sRGB to linear - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - let hdr_r = hdr_linear[i * 3]; - let hdr_g = hdr_linear[i * 3 + 1]; - let hdr_b = hdr_linear[i * 3 + 2]; - - metadata_computer.add_sample( - [sdr_lin_r, sdr_lin_g, sdr_lin_b], - [hdr_r, hdr_g, hdr_b], - offset, - offset, - ); - } - - let metadata = metadata_computer.compute(target_capacity); - - // Second pass: compute gain map - let mut gain_map = vec![0u8; gm_pixel_count]; - - for gy in 0..gm_height { - for gx in 0..gm_width { - // Sample center of the gain map pixel's coverage area - let sx = ((gx * scale + scale / 2).min(width - 1)) as usize; - let sy = ((gy * scale + scale / 2).min(height - 1)) as usize; - let src_idx = sy * width as usize + sx; - - // Get SDR values and convert to linear - let sdr_r = sdr_rgb[src_idx * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[src_idx * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[src_idx * 3 + 2] as f32 / 255.0; - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - // Get HDR values (already linear) - let hdr_r = hdr_linear[src_idx * 3]; - let hdr_g = hdr_linear[src_idx * 3 + 1]; - let hdr_b = hdr_linear[src_idx * 3 + 2]; - - // Compute gain ratio for each channel - let ratio_r = compute_gain_ratio(sdr_lin_r, hdr_r, offset, offset); - let ratio_g = compute_gain_ratio(sdr_lin_g, hdr_g, offset, offset); - let ratio_b = compute_gain_ratio(sdr_lin_b, hdr_b, offset, offset); - - // Encode gains - let gain_r = encode_gain(ratio_r, metadata.gain_map_min[0], metadata.gain_map_max[0], metadata.gamma[0]); - let gain_g = encode_gain(ratio_g, metadata.gain_map_min[1], metadata.gain_map_max[1], metadata.gamma[1]); - let gain_b = encode_gain(ratio_b, metadata.gain_map_min[2], metadata.gain_map_max[2], metadata.gamma[2]); - - // For a single-channel gain map, use luminance-weighted average - // Using BT.709 weights - let gain = 0.2126 * gain_r + 0.7152 * gain_g + 0.0722 * gain_b; - - let gm_idx = (gy * gm_width + gx) as usize; - gain_map[gm_idx] = (gain * 255.0).clamp(0.0, 255.0) as u8; - } - } - - Ok((gain_map, metadata)) -} - -/// Computes a per-channel RGB gain map for higher quality. -/// -/// Returns a gain map with 3 bytes per pixel (RGB). -pub fn compute_gain_map_rgb( - sdr_rgb: &[u8], - hdr_linear: &[f32], - width: u32, - height: u32, - target_capacity: f32, - gain_map_scale: u8, -) -> Result<(Vec, GainMapMetadata)> { - let pixel_count = (width * height) as usize; - - if sdr_rgb.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "SDR buffer size {} doesn't match {}x{}x3", - sdr_rgb.len(), width, height - ))); - } - if hdr_linear.len() != pixel_count * 3 { - return Err(UltraHdrError::InvalidDimensions(format!( - "HDR buffer size {} doesn't match {}x{}x3", - hdr_linear.len(), width, height - ))); - } - - let scale = gain_map_scale.max(1) as u32; - let gm_width = (width + scale - 1) / scale; - let gm_height = (height + scale - 1) / scale; - let gm_pixel_count = (gm_width * gm_height) as usize; - - let mut metadata_computer = MetadataComputer::new(); - let offset = 1.0 / 64.0; - - // Statistics pass - let sample_step = ((width * height) / 10000).max(1) as usize; - for i in (0..pixel_count).step_by(sample_step) { - let sdr_r = sdr_rgb[i * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[i * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[i * 3 + 2] as f32 / 255.0; - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - metadata_computer.add_sample( - [sdr_lin_r, sdr_lin_g, sdr_lin_b], - [hdr_linear[i * 3], hdr_linear[i * 3 + 1], hdr_linear[i * 3 + 2]], - offset, - offset, - ); - } - - let metadata = metadata_computer.compute(target_capacity); - - // Compute RGB gain map - let mut gain_map = vec![0u8; gm_pixel_count * 3]; - - for gy in 0..gm_height { - for gx in 0..gm_width { - let sx = ((gx * scale + scale / 2).min(width - 1)) as usize; - let sy = ((gy * scale + scale / 2).min(height - 1)) as usize; - let src_idx = sy * width as usize + sx; - - let sdr_r = sdr_rgb[src_idx * 3] as f32 / 255.0; - let sdr_g = sdr_rgb[src_idx * 3 + 1] as f32 / 255.0; - let sdr_b = sdr_rgb[src_idx * 3 + 2] as f32 / 255.0; - let (sdr_lin_r, sdr_lin_g, sdr_lin_b) = srgb_to_linear(sdr_r, sdr_g, sdr_b); - - let hdr_r = hdr_linear[src_idx * 3]; - let hdr_g = hdr_linear[src_idx * 3 + 1]; - let hdr_b = hdr_linear[src_idx * 3 + 2]; - - let ratio_r = compute_gain_ratio(sdr_lin_r, hdr_r, offset, offset); - let ratio_g = compute_gain_ratio(sdr_lin_g, hdr_g, offset, offset); - let ratio_b = compute_gain_ratio(sdr_lin_b, hdr_b, offset, offset); - - let gain_r = encode_gain(ratio_r, metadata.gain_map_min[0], metadata.gain_map_max[0], metadata.gamma[0]); - let gain_g = encode_gain(ratio_g, metadata.gain_map_min[1], metadata.gain_map_max[1], metadata.gamma[1]); - let gain_b = encode_gain(ratio_b, metadata.gain_map_min[2], metadata.gain_map_max[2], metadata.gamma[2]); - - let gm_idx = (gy * gm_width + gx) as usize; - gain_map[gm_idx * 3] = (gain_r * 255.0).clamp(0.0, 255.0) as u8; - gain_map[gm_idx * 3 + 1] = (gain_g * 255.0).clamp(0.0, 255.0) as u8; - gain_map[gm_idx * 3 + 2] = (gain_b * 255.0).clamp(0.0, 255.0) as u8; - } - } - - Ok((gain_map, metadata)) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_compute_gain_map_basic() { - // Create a simple 2x2 test image - let width = 2u32; - let height = 2u32; - - // SDR image (mid-gray) - let sdr = vec![128u8; 12]; // 2x2x3 - - // HDR image (brighter) - let hdr = vec![0.5f32; 12]; // 2x2x3, linear - - let result = compute_gain_map(&sdr, &hdr, width, height, 3.0, 1); - assert!(result.is_ok()); - - let (gain_map, metadata) = result.unwrap(); - assert_eq!(gain_map.len(), 4); // 2x2 grayscale - assert_eq!(metadata.version, "1.0"); - } - - #[test] - fn test_compute_gain_map_invalid_size() { - let sdr = vec![128u8; 12]; - let hdr = vec![0.5f32; 6]; // Wrong size - - let result = compute_gain_map(&sdr, &hdr, 2, 2, 3.0, 1); - assert!(result.is_err()); - } - - #[test] - fn test_compute_gain_map_with_scale() { - let width = 4u32; - let height = 4u32; - - let sdr = vec![128u8; 48]; // 4x4x3 - let hdr = vec![0.5f32; 48]; // 4x4x3 - - // Scale factor 2 should give 2x2 gain map - let (gain_map, _) = compute_gain_map(&sdr, &hdr, width, height, 3.0, 2).unwrap(); - assert_eq!(gain_map.len(), 4); // 2x2 - } -} diff --git a/packages/ultrahdr-wasm/src/gainmap/math.rs b/packages/ultrahdr-wasm/src/gainmap/math.rs deleted file mode 100644 index 2e4109e2af8718..00000000000000 --- a/packages/ultrahdr-wasm/src/gainmap/math.rs +++ /dev/null @@ -1,432 +0,0 @@ -//! Color space and transfer function math for gain map processing. -//! -//! Implements color space conversions and transfer functions according to -//! ISO 21496-1 and related standards (BT.709, BT.2100, Display P3). - -use crate::types::{ColorGamut, TransferFunction}; - -/// Small epsilon value to avoid division by zero. -pub const EPSILON: f32 = 1e-6; - -/// sRGB transfer function threshold. -const SRGB_THRESHOLD: f32 = 0.04045; -const SRGB_LINEAR_SCALE: f32 = 12.92; -const SRGB_GAMMA: f32 = 2.4; -const SRGB_A: f32 = 0.055; - -/// BT.2100 PQ constants. -const PQ_M1: f32 = 0.1593017578125; // 2610/16384 -const PQ_M2: f32 = 78.84375; // 2523/32 * 128 -const PQ_C1: f32 = 0.8359375; // 3424/4096 -const PQ_C2: f32 = 18.8515625; // 2413/128 * 32 -const PQ_C3: f32 = 18.6875; // 2392/128 * 32 - -/// HLG constants. -const HLG_A: f32 = 0.17883277; -const HLG_B: f32 = 0.28466892; // 1 - 4*a -const HLG_C: f32 = 0.55991073; // 0.5 - a * ln(4*a) - -/// Reference white luminance in nits for SDR. -pub const SDR_WHITE_NITS: f32 = 203.0; - -/// Maximum luminance for PQ in nits. -pub const PQ_MAX_NITS: f32 = 10000.0; - -// ============================================================================ -// sRGB Transfer Functions -// ============================================================================ - -/// Applies the sRGB OETF (Opto-Electronic Transfer Function) - linear to sRGB. -#[inline] -pub fn srgb_oetf(linear: f32) -> f32 { - if linear <= 0.0031308 { - linear * SRGB_LINEAR_SCALE - } else { - (1.0 + SRGB_A) * linear.powf(1.0 / SRGB_GAMMA) - SRGB_A - } -} - -/// Applies the inverse sRGB OETF (sRGB to linear). -#[inline] -pub fn srgb_inverse_oetf(srgb: f32) -> f32 { - if srgb <= SRGB_THRESHOLD { - srgb / SRGB_LINEAR_SCALE - } else { - ((srgb + SRGB_A) / (1.0 + SRGB_A)).powf(SRGB_GAMMA) - } -} - -/// Converts sRGB color to linear RGB. -#[inline] -pub fn srgb_to_linear(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - ( - srgb_inverse_oetf(r), - srgb_inverse_oetf(g), - srgb_inverse_oetf(b), - ) -} - -/// Converts linear RGB to sRGB. -#[inline] -pub fn linear_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - ( - srgb_oetf(r), - srgb_oetf(g), - srgb_oetf(b), - ) -} - -// ============================================================================ -// BT.2100 PQ Transfer Functions -// ============================================================================ - -/// Applies the PQ OETF (Perceptual Quantizer) - linear to PQ. -/// Input is expected to be in the range [0, 1] representing [0, 10000] nits. -#[inline] -pub fn pq_oetf(linear: f32) -> f32 { - let y = linear.max(0.0); - let y_m1 = y.powf(PQ_M1); - let numerator = PQ_C1 + PQ_C2 * y_m1; - let denominator = 1.0 + PQ_C3 * y_m1; - (numerator / denominator).powf(PQ_M2) -} - -/// Applies the inverse PQ OETF (PQ to linear). -/// Output is in the range [0, 1] representing [0, 10000] nits. -#[inline] -pub fn pq_inverse_oetf(pq: f32) -> f32 { - let pq_clamped = pq.max(0.0).min(1.0); - let pq_m2_inv = pq_clamped.powf(1.0 / PQ_M2); - let numerator = (pq_m2_inv - PQ_C1).max(0.0); - let denominator = PQ_C2 - PQ_C3 * pq_m2_inv; - if denominator <= 0.0 { - 0.0 - } else { - (numerator / denominator).powf(1.0 / PQ_M1) - } -} - -/// Converts PQ-encoded value to nits. -#[inline] -pub fn pq_to_nits(pq: f32) -> f32 { - pq_inverse_oetf(pq) * PQ_MAX_NITS -} - -/// Converts nits to PQ-encoded value. -#[inline] -pub fn nits_to_pq(nits: f32) -> f32 { - pq_oetf(nits / PQ_MAX_NITS) -} - -// ============================================================================ -// BT.2100 HLG Transfer Functions -// ============================================================================ - -/// Applies the HLG OETF (Hybrid Log-Gamma) - linear to HLG. -/// Input is expected to be scene-referred linear light. -#[inline] -pub fn hlg_oetf(linear: f32) -> f32 { - let e = linear.max(0.0); - if e <= 1.0 / 12.0 { - (3.0 * e).sqrt() - } else { - HLG_A * (12.0 * e - HLG_B).ln() + HLG_C - } -} - -/// Applies the inverse HLG OETF (HLG to linear). -#[inline] -pub fn hlg_inverse_oetf(hlg: f32) -> f32 { - let hlg_clamped = hlg.max(0.0).min(1.0); - if hlg_clamped <= 0.5 { - hlg_clamped * hlg_clamped / 3.0 - } else { - (((hlg_clamped - HLG_C) / HLG_A).exp() + HLG_B) / 12.0 - } -} - -// ============================================================================ -// Luminance Calculations -// ============================================================================ - -/// BT.709 luminance coefficients (also used for sRGB). -pub const LUMA_R_BT709: f32 = 0.2126; -pub const LUMA_G_BT709: f32 = 0.7152; -pub const LUMA_B_BT709: f32 = 0.0722; - -/// BT.2020 luminance coefficients. -pub const LUMA_R_BT2020: f32 = 0.2627; -pub const LUMA_G_BT2020: f32 = 0.6780; -pub const LUMA_B_BT2020: f32 = 0.0593; - -/// Display P3 luminance coefficients (same primaries as DCI-P3 but D65 white). -pub const LUMA_R_P3: f32 = 0.2289; -pub const LUMA_G_P3: f32 = 0.6917; -pub const LUMA_B_P3: f32 = 0.0793; - -/// Calculates luminance from linear RGB using BT.709 coefficients. -#[inline] -pub fn luminance_bt709(r: f32, g: f32, b: f32) -> f32 { - LUMA_R_BT709 * r + LUMA_G_BT709 * g + LUMA_B_BT709 * b -} - -/// Calculates luminance from linear RGB using BT.2020 coefficients. -#[inline] -pub fn luminance_bt2020(r: f32, g: f32, b: f32) -> f32 { - LUMA_R_BT2020 * r + LUMA_G_BT2020 * g + LUMA_B_BT2020 * b -} - -/// Calculates luminance from linear RGB using Display P3 coefficients. -#[inline] -pub fn luminance_p3(r: f32, g: f32, b: f32) -> f32 { - LUMA_R_P3 * r + LUMA_G_P3 * g + LUMA_B_P3 * b -} - -/// Calculates luminance based on color gamut. -#[inline] -pub fn luminance(r: f32, g: f32, b: f32, gamut: ColorGamut) -> f32 { - match gamut { - ColorGamut::Srgb => luminance_bt709(r, g, b), - ColorGamut::DisplayP3 => luminance_p3(r, g, b), - ColorGamut::Bt2100 => luminance_bt2020(r, g, b), - } -} - -// ============================================================================ -// Color Space Conversions -// ============================================================================ - -/// sRGB to XYZ matrix (D65 illuminant). -#[rustfmt::skip] -pub const SRGB_TO_XYZ: [[f32; 3]; 3] = [ - [0.4124564, 0.3575761, 0.1804375], - [0.2126729, 0.7151522, 0.0721750], - [0.0193339, 0.1191920, 0.9503041], -]; - -/// XYZ to sRGB matrix (D65 illuminant). -#[rustfmt::skip] -pub const XYZ_TO_SRGB: [[f32; 3]; 3] = [ - [ 3.2404542, -1.5371385, -0.4985314], - [-0.9692660, 1.8760108, 0.0415560], - [ 0.0556434, -0.2040259, 1.0572252], -]; - -/// Display P3 to XYZ matrix (D65 illuminant). -#[rustfmt::skip] -pub const P3_TO_XYZ: [[f32; 3]; 3] = [ - [0.4865709, 0.2656677, 0.1982173], - [0.2289746, 0.6917385, 0.0792869], - [0.0000000, 0.0451134, 1.0439444], -]; - -/// XYZ to Display P3 matrix (D65 illuminant). -#[rustfmt::skip] -pub const XYZ_TO_P3: [[f32; 3]; 3] = [ - [ 2.4934969, -0.9313836, -0.4027108], - [-0.8294890, 1.7626641, 0.0236247], - [ 0.0358458, -0.0761724, 0.9568845], -]; - -/// BT.2020 to XYZ matrix (D65 illuminant). -#[rustfmt::skip] -pub const BT2020_TO_XYZ: [[f32; 3]; 3] = [ - [0.6369580, 0.1446169, 0.1688810], - [0.2627002, 0.6779981, 0.0593017], - [0.0000000, 0.0280727, 1.0609851], -]; - -/// XYZ to BT.2020 matrix (D65 illuminant). -#[rustfmt::skip] -pub const XYZ_TO_BT2020: [[f32; 3]; 3] = [ - [ 1.7166512, -0.3556708, -0.2533663], - [-0.6666844, 1.6164812, 0.0157685], - [ 0.0176399, -0.0427706, 0.9421031], -]; - -/// Applies a 3x3 color matrix to RGB values. -#[inline] -pub fn apply_matrix(r: f32, g: f32, b: f32, matrix: &[[f32; 3]; 3]) -> (f32, f32, f32) { - ( - matrix[0][0] * r + matrix[0][1] * g + matrix[0][2] * b, - matrix[1][0] * r + matrix[1][1] * g + matrix[1][2] * b, - matrix[2][0] * r + matrix[2][1] * g + matrix[2][2] * b, - ) -} - -/// Converts sRGB to Display P3 (both in linear space). -pub fn srgb_to_p3(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - let xyz = apply_matrix(r, g, b, &SRGB_TO_XYZ); - apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_P3) -} - -/// Converts Display P3 to sRGB (both in linear space). -pub fn p3_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - let xyz = apply_matrix(r, g, b, &P3_TO_XYZ); - apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_SRGB) -} - -/// Converts sRGB to BT.2020 (both in linear space). -pub fn srgb_to_bt2020(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - let xyz = apply_matrix(r, g, b, &SRGB_TO_XYZ); - apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_BT2020) -} - -/// Converts BT.2020 to sRGB (both in linear space). -pub fn bt2020_to_srgb(r: f32, g: f32, b: f32) -> (f32, f32, f32) { - let xyz = apply_matrix(r, g, b, &BT2020_TO_XYZ); - apply_matrix(xyz.0, xyz.1, xyz.2, &XYZ_TO_SRGB) -} - -// ============================================================================ -// Transfer Function Application -// ============================================================================ - -/// Applies a transfer function to linear RGB values. -pub fn apply_transfer_function(r: f32, g: f32, b: f32, tf: TransferFunction) -> (f32, f32, f32) { - match tf { - TransferFunction::Srgb => linear_to_srgb(r, g, b), - TransferFunction::Linear => (r, g, b), - TransferFunction::Pq => (pq_oetf(r), pq_oetf(g), pq_oetf(b)), - TransferFunction::Hlg => (hlg_oetf(r), hlg_oetf(g), hlg_oetf(b)), - } -} - -/// Applies inverse transfer function to get linear RGB. -pub fn inverse_transfer_function(r: f32, g: f32, b: f32, tf: TransferFunction) -> (f32, f32, f32) { - match tf { - TransferFunction::Srgb => srgb_to_linear(r, g, b), - TransferFunction::Linear => (r, g, b), - TransferFunction::Pq => (pq_inverse_oetf(r), pq_inverse_oetf(g), pq_inverse_oetf(b)), - TransferFunction::Hlg => (hlg_inverse_oetf(r), hlg_inverse_oetf(g), hlg_inverse_oetf(b)), - } -} - -// ============================================================================ -// Gain Map Specific Math -// ============================================================================ - -/// Encodes a gain value to the [0, 1] range using the gain map formula. -/// -/// gain_encoded = ((log2(ratio) - min_log2) / (max_log2 - min_log2)) ^ (1/gamma) -#[inline] -pub fn encode_gain(ratio: f32, min_gain: f32, max_gain: f32, gamma: f32) -> f32 { - let log_ratio = ratio.max(EPSILON).log2(); - let normalized = (log_ratio - min_gain) / (max_gain - min_gain).max(EPSILON); - normalized.clamp(0.0, 1.0).powf(1.0 / gamma) -} - -/// Decodes a gain value from the [0, 1] range. -/// -/// ratio = 2 ^ (gain_decoded ^ gamma * (max_log2 - min_log2) + min_log2) -#[inline] -pub fn decode_gain(encoded: f32, min_gain: f32, max_gain: f32, gamma: f32) -> f32 { - let degamma = encoded.powf(gamma); - let log_ratio = degamma * (max_gain - min_gain) + min_gain; - 2.0_f32.powf(log_ratio) -} - -/// Applies gain to a pixel value with offset adjustment. -/// -/// output = (input + offset_sdr) * gain - offset_hdr -#[inline] -pub fn apply_gain_to_pixel(input: f32, gain: f32, offset_sdr: f32, offset_hdr: f32) -> f32 { - ((input + offset_sdr) * gain - offset_hdr).max(0.0) -} - -/// Computes the gain ratio between HDR and SDR pixel values. -/// -/// ratio = (hdr + offset_hdr) / (sdr + offset_sdr) -#[inline] -pub fn compute_gain_ratio(sdr: f32, hdr: f32, offset_sdr: f32, offset_hdr: f32) -> f32 { - (hdr + offset_hdr) / (sdr + offset_sdr).max(EPSILON) -} - -/// Interpolates between SDR and HDR based on display HDR capacity. -/// -/// weight = clamp((display_capacity - capacity_min) / (capacity_max - capacity_min), 0, 1) -#[inline] -pub fn compute_hdr_weight(display_capacity: f32, capacity_min: f32, capacity_max: f32) -> f32 { - if capacity_max <= capacity_min { - return 1.0; - } - ((display_capacity - capacity_min) / (capacity_max - capacity_min)).clamp(0.0, 1.0) -} - -#[cfg(test)] -mod tests { - use super::*; - - const TOLERANCE: f32 = 1e-5; - - fn approx_eq(a: f32, b: f32) -> bool { - (a - b).abs() < TOLERANCE - } - - #[test] - fn test_srgb_roundtrip() { - for i in 0..=100 { - let linear = i as f32 / 100.0; - let srgb = srgb_oetf(linear); - let back = srgb_inverse_oetf(srgb); - assert!(approx_eq(linear, back), "Failed at {}: {} vs {}", linear, linear, back); - } - } - - #[test] - fn test_pq_roundtrip() { - // PQ uses complex power functions with large exponents, so allow slightly larger tolerance - const PQ_TOLERANCE: f32 = 1e-4; - for i in 0..=100 { - let linear = i as f32 / 100.0; - let pq = pq_oetf(linear); - let back = pq_inverse_oetf(pq); - assert!((linear - back).abs() < PQ_TOLERANCE, "Failed at {}: {} vs {}", linear, linear, back); - } - } - - #[test] - fn test_hlg_roundtrip() { - for i in 0..=100 { - let linear = i as f32 / 100.0; - let hlg = hlg_oetf(linear); - let back = hlg_inverse_oetf(hlg); - assert!(approx_eq(linear, back), "Failed at {}: {} vs {}", linear, linear, back); - } - } - - #[test] - fn test_luminance_black() { - assert_eq!(luminance_bt709(0.0, 0.0, 0.0), 0.0); - } - - #[test] - fn test_luminance_white() { - let luma = luminance_bt709(1.0, 1.0, 1.0); - assert!(approx_eq(luma, 1.0)); - } - - #[test] - fn test_gain_encode_decode_roundtrip() { - let ratios = [0.5, 1.0, 2.0, 4.0, 8.0]; - let min_gain = -1.0; - let max_gain = 3.0; - let gamma = 1.0; - - for &ratio in &ratios { - let encoded = encode_gain(ratio, min_gain, max_gain, gamma); - let decoded = decode_gain(encoded, min_gain, max_gain, gamma); - assert!(approx_eq(ratio, decoded), "Failed at {}: {} vs {}", ratio, ratio, decoded); - } - } - - #[test] - fn test_hdr_weight_calculation() { - // Full SDR - assert_eq!(compute_hdr_weight(0.0, 0.0, 3.0), 0.0); - // Full HDR - assert_eq!(compute_hdr_weight(3.0, 0.0, 3.0), 1.0); - // Mid point - assert!(approx_eq(compute_hdr_weight(1.5, 0.0, 3.0), 0.5)); - } -} diff --git a/packages/ultrahdr-wasm/src/gainmap/metadata.rs b/packages/ultrahdr-wasm/src/gainmap/metadata.rs deleted file mode 100644 index 2d08579b596014..00000000000000 --- a/packages/ultrahdr-wasm/src/gainmap/metadata.rs +++ /dev/null @@ -1,223 +0,0 @@ -//! Gain map metadata processing. -//! -//! Provides utilities for working with ISO 21496-1 gain map metadata. - -use crate::error::{Result, UltraHdrError}; -use crate::types::GainMapMetadata; - -/// Validates gain map metadata for correctness. -pub fn validate_metadata(metadata: &GainMapMetadata) -> Result<()> { - // Validate channel counts - if metadata.gain_map_min.len() != 3 { - return Err(UltraHdrError::MetadataError( - format!("gain_map_min must have 3 values, got {}", metadata.gain_map_min.len()) - )); - } - if metadata.gain_map_max.len() != 3 { - return Err(UltraHdrError::MetadataError( - format!("gain_map_max must have 3 values, got {}", metadata.gain_map_max.len()) - )); - } - if metadata.gamma.len() != 3 { - return Err(UltraHdrError::MetadataError( - format!("gamma must have 3 values, got {}", metadata.gamma.len()) - )); - } - if metadata.offset_sdr.len() != 3 { - return Err(UltraHdrError::MetadataError( - format!("offset_sdr must have 3 values, got {}", metadata.offset_sdr.len()) - )); - } - if metadata.offset_hdr.len() != 3 { - return Err(UltraHdrError::MetadataError( - format!("offset_hdr must have 3 values, got {}", metadata.offset_hdr.len()) - )); - } - - // Validate gain range - for i in 0..3 { - if metadata.gain_map_min[i] > metadata.gain_map_max[i] { - return Err(UltraHdrError::MetadataError( - format!("gain_map_min[{}] ({}) > gain_map_max[{}] ({})", - i, metadata.gain_map_min[i], i, metadata.gain_map_max[i]) - )); - } - } - - // Validate gamma (must be positive) - for (i, &g) in metadata.gamma.iter().enumerate() { - if g <= 0.0 { - return Err(UltraHdrError::MetadataError( - format!("gamma[{}] must be positive, got {}", i, g) - )); - } - } - - // Validate HDR capacity range - if metadata.hdr_capacity_min > metadata.hdr_capacity_max { - return Err(UltraHdrError::InvalidHdrCapacity( - metadata.hdr_capacity_min, - metadata.hdr_capacity_max, - )); - } - - Ok(()) -} - -/// Computes optimal metadata parameters from SDR and HDR image statistics. -pub struct MetadataComputer { - /// Accumulated minimum gain ratios per channel - min_ratios: [f32; 3], - /// Accumulated maximum gain ratios per channel - max_ratios: [f32; 3], - /// Sample count - sample_count: usize, -} - -impl MetadataComputer { - /// Creates a new metadata computer. - pub fn new() -> Self { - Self { - min_ratios: [f32::MAX, f32::MAX, f32::MAX], - max_ratios: [f32::MIN, f32::MIN, f32::MIN], - sample_count: 0, - } - } - - /// Adds a sample of SDR and HDR pixel values. - pub fn add_sample(&mut self, sdr: [f32; 3], hdr: [f32; 3], offset_sdr: f32, offset_hdr: f32) { - for i in 0..3 { - let ratio = (hdr[i] + offset_hdr) / (sdr[i] + offset_sdr).max(super::math::EPSILON); - if ratio > 0.0 && ratio.is_finite() { - let log_ratio = ratio.log2(); - self.min_ratios[i] = self.min_ratios[i].min(log_ratio); - self.max_ratios[i] = self.max_ratios[i].max(log_ratio); - } - } - self.sample_count += 1; - } - - /// Computes the final metadata from accumulated samples. - pub fn compute(&self, target_capacity: f32) -> GainMapMetadata { - let offset = 1.0 / 64.0; // Standard offset value - - // Compute gain range with some margin - let mut min_gain = [0.0f32; 3]; - let mut max_gain = [target_capacity; 3]; - - for i in 0..3 { - if self.min_ratios[i] < f32::MAX { - min_gain[i] = (self.min_ratios[i] - 0.1).max(-2.0); - } - if self.max_ratios[i] > f32::MIN { - max_gain[i] = (self.max_ratios[i] + 0.1).min(target_capacity + 1.0); - } - } - - GainMapMetadata { - version: "1.0".to_string(), - base_rendition_is_hdr: false, - gain_map_min: min_gain.to_vec(), - gain_map_max: max_gain.to_vec(), - gamma: vec![1.0, 1.0, 1.0], - offset_sdr: vec![offset, offset, offset], - offset_hdr: vec![offset, offset, offset], - hdr_capacity_min: 0.0, - hdr_capacity_max: target_capacity, - } - } -} - -impl Default for MetadataComputer { - fn default() -> Self { - Self::new() - } -} - -/// Estimates the HDR headroom from metadata. -/// -/// Returns the maximum additional stops of dynamic range above SDR. -pub fn estimate_hdr_headroom(metadata: &GainMapMetadata) -> f32 { - let max_gain = metadata.gain_map_max.iter() - .copied() - .fold(f32::MIN, f32::max); - max_gain.max(0.0) -} - -/// Checks if metadata indicates a meaningful HDR image. -/// -/// Returns true if the gain map provides significant dynamic range extension. -pub fn is_meaningful_hdr(metadata: &GainMapMetadata) -> bool { - let headroom = estimate_hdr_headroom(metadata); - headroom > 0.5 // More than half a stop of additional range -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_validate_metadata_valid() { - let metadata = GainMapMetadata::default(); - assert!(validate_metadata(&metadata).is_ok()); - } - - #[test] - fn test_validate_metadata_invalid_channel_count() { - let mut metadata = GainMapMetadata::default(); - metadata.gain_map_min = vec![0.0, 0.0]; // Only 2 values - assert!(validate_metadata(&metadata).is_err()); - } - - #[test] - fn test_validate_metadata_invalid_gain_range() { - let mut metadata = GainMapMetadata::default(); - metadata.gain_map_min = vec![5.0, 5.0, 5.0]; - metadata.gain_map_max = vec![3.0, 3.0, 3.0]; // min > max - assert!(validate_metadata(&metadata).is_err()); - } - - #[test] - fn test_validate_metadata_invalid_gamma() { - let mut metadata = GainMapMetadata::default(); - metadata.gamma = vec![1.0, -1.0, 1.0]; // Negative gamma - assert!(validate_metadata(&metadata).is_err()); - } - - #[test] - fn test_metadata_computer() { - let mut computer = MetadataComputer::new(); - - // Add some samples - computer.add_sample([0.5, 0.5, 0.5], [1.0, 1.0, 1.0], 0.015625, 0.015625); - computer.add_sample([0.3, 0.3, 0.3], [0.9, 0.9, 0.9], 0.015625, 0.015625); - - let metadata = computer.compute(3.0); - assert_eq!(metadata.version, "1.0"); - assert!(!metadata.base_rendition_is_hdr); - } - - #[test] - fn test_estimate_hdr_headroom() { - let metadata = GainMapMetadata { - gain_map_max: vec![3.0, 3.0, 3.0], - ..Default::default() - }; - assert_eq!(estimate_hdr_headroom(&metadata), 3.0); - } - - #[test] - fn test_is_meaningful_hdr() { - let low_hdr = GainMapMetadata { - gain_map_max: vec![0.2, 0.2, 0.2], - ..Default::default() - }; - assert!(!is_meaningful_hdr(&low_hdr)); - - let high_hdr = GainMapMetadata { - gain_map_max: vec![3.0, 3.0, 3.0], - ..Default::default() - }; - assert!(is_meaningful_hdr(&high_hdr)); - } -} diff --git a/packages/ultrahdr-wasm/src/gainmap/mod.rs b/packages/ultrahdr-wasm/src/gainmap/mod.rs deleted file mode 100644 index 88f125b13635c9..00000000000000 --- a/packages/ultrahdr-wasm/src/gainmap/mod.rs +++ /dev/null @@ -1,13 +0,0 @@ -//! Gain map processing module. -//! -//! Implements ISO 21496-1 gain map computation and application. - -pub mod math; -pub mod metadata; -pub mod encode; -pub mod decode; - -pub use math::*; -pub use metadata::*; -pub use encode::compute_gain_map; -pub use decode::apply_gain_map; diff --git a/packages/ultrahdr-wasm/src/jpeg/mod.rs b/packages/ultrahdr-wasm/src/jpeg/mod.rs deleted file mode 100644 index 200e6316a9d6e2..00000000000000 --- a/packages/ultrahdr-wasm/src/jpeg/mod.rs +++ /dev/null @@ -1,14 +0,0 @@ -//! JPEG parsing and manipulation module. -//! -//! This module handles parsing and writing JPEG files, including: -//! - APP1 (Exif, XMP) segments -//! - APP2 (ICC profile, Extended XMP) segments -//! - MPF (Multi-Picture Format) for gain map storage - -pub mod parser; -pub mod writer; -pub mod xmp; - -pub use parser::{JpegParser, JpegSegment, MarkerType}; -pub use writer::JpegWriter; -pub use xmp::{XmpParser, XmpWriter}; diff --git a/packages/ultrahdr-wasm/src/jpeg/parser.rs b/packages/ultrahdr-wasm/src/jpeg/parser.rs deleted file mode 100644 index cd893cbba433ee..00000000000000 --- a/packages/ultrahdr-wasm/src/jpeg/parser.rs +++ /dev/null @@ -1,394 +0,0 @@ -//! JPEG segment parser. -//! -//! Parses JPEG files to extract APP1, APP2, and other relevant segments -//! for UltraHDR processing. - -use crate::error::{Result, UltraHdrError}; -use std::io::{Cursor, Read}; - -/// JPEG marker types. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum MarkerType { - /// Start of Image - Soi, - /// End of Image - Eoi, - /// APP0 (JFIF) - App0, - /// APP1 (Exif, XMP) - App1, - /// APP2 (ICC profile, Extended XMP, MPF) - App2, - /// APP3-APP15 - AppN(u8), - /// Start of Frame (Baseline DCT) - Sof0, - /// Start of Frame (Progressive DCT) - Sof2, - /// Define Huffman Table - Dht, - /// Define Quantization Table - Dqt, - /// Define Restart Interval - Dri, - /// Start of Scan - Sos, - /// Comment - Com, - /// Other marker - Other(u8), -} - -impl MarkerType { - /// Creates a MarkerType from a byte value. - pub fn from_byte(byte: u8) -> Self { - match byte { - 0xD8 => MarkerType::Soi, - 0xD9 => MarkerType::Eoi, - 0xE0 => MarkerType::App0, - 0xE1 => MarkerType::App1, - 0xE2 => MarkerType::App2, - 0xE3..=0xEF => MarkerType::AppN(byte - 0xE0), - 0xC0 => MarkerType::Sof0, - 0xC2 => MarkerType::Sof2, - 0xC4 => MarkerType::Dht, - 0xDB => MarkerType::Dqt, - 0xDD => MarkerType::Dri, - 0xDA => MarkerType::Sos, - 0xFE => MarkerType::Com, - _ => MarkerType::Other(byte), - } - } - - /// Converts the marker type to its byte value. - pub fn to_byte(&self) -> u8 { - match self { - MarkerType::Soi => 0xD8, - MarkerType::Eoi => 0xD9, - MarkerType::App0 => 0xE0, - MarkerType::App1 => 0xE1, - MarkerType::App2 => 0xE2, - MarkerType::AppN(n) => 0xE0 + n, - MarkerType::Sof0 => 0xC0, - MarkerType::Sof2 => 0xC2, - MarkerType::Dht => 0xC4, - MarkerType::Dqt => 0xDB, - MarkerType::Dri => 0xDD, - MarkerType::Sos => 0xDA, - MarkerType::Com => 0xFE, - MarkerType::Other(b) => *b, - } - } - - /// Returns true if this marker has an associated length field. - pub fn has_length(&self) -> bool { - !matches!(self, MarkerType::Soi | MarkerType::Eoi | MarkerType::Other(0x00) | MarkerType::Other(0xFF)) - } -} - -/// A JPEG segment with marker and data. -#[derive(Debug, Clone)] -pub struct JpegSegment { - /// The marker type - pub marker: MarkerType, - /// The segment data (excluding marker and length bytes) - pub data: Vec, - /// Original offset in the file - pub offset: usize, -} - -impl JpegSegment { - /// Creates a new JPEG segment. - pub fn new(marker: MarkerType, data: Vec, offset: usize) -> Self { - Self { marker, data, offset } - } - - /// Checks if this segment contains XMP data. - pub fn is_xmp(&self) -> bool { - if self.marker != MarkerType::App1 { - return false; - } - self.data.starts_with(b"http://ns.adobe.com/xap/1.0/\0") - } - - /// Checks if this segment contains Extended XMP data. - pub fn is_extended_xmp(&self) -> bool { - if self.marker != MarkerType::App1 { - return false; - } - self.data.starts_with(b"http://ns.adobe.com/xmp/extension/\0") - } - - /// Checks if this segment contains Exif data. - pub fn is_exif(&self) -> bool { - if self.marker != MarkerType::App1 { - return false; - } - self.data.starts_with(b"Exif\0\0") - } - - /// Checks if this segment contains an ICC profile. - pub fn is_icc_profile(&self) -> bool { - if self.marker != MarkerType::App2 { - return false; - } - self.data.starts_with(b"ICC_PROFILE\0") - } - - /// Checks if this segment is an MPF (Multi-Picture Format) segment. - pub fn is_mpf(&self) -> bool { - if self.marker != MarkerType::App2 { - return false; - } - self.data.starts_with(b"MPF\0") - } - - /// Gets the XMP data if this is an XMP segment. - pub fn get_xmp_data(&self) -> Option<&[u8]> { - if !self.is_xmp() { - return None; - } - // Skip "http://ns.adobe.com/xap/1.0/\0" (29 bytes) - Some(&self.data[29..]) - } -} - -/// JPEG file parser. -pub struct JpegParser { - segments: Vec, - scan_data: Vec, - scan_offset: usize, -} - -impl JpegParser { - /// Parses a JPEG file from a byte buffer. - pub fn parse(data: &[u8]) -> Result { - if data.len() < 2 { - return Err(UltraHdrError::InvalidJpeg("File too small".to_string())); - } - - // Check for JPEG magic bytes - if data[0] != 0xFF || data[1] != 0xD8 { - return Err(UltraHdrError::InvalidJpeg("Missing JPEG SOI marker".to_string())); - } - - let mut segments = Vec::new(); - let mut cursor = Cursor::new(data); - let mut scan_data = Vec::new(); - let mut scan_offset = 0; - - // Add SOI segment - segments.push(JpegSegment::new(MarkerType::Soi, Vec::new(), 0)); - cursor.set_position(2); - - loop { - let pos = cursor.position() as usize; - if pos >= data.len() { - break; - } - - // Look for marker - let mut marker_byte = [0u8; 1]; - if cursor.read_exact(&mut marker_byte).is_err() { - break; - } - - if marker_byte[0] != 0xFF { - // Not a marker, might be in scan data - continue; - } - - // Skip padding 0xFF bytes - loop { - if cursor.read_exact(&mut marker_byte).is_err() { - break; - } - if marker_byte[0] != 0xFF { - break; - } - } - - let marker = MarkerType::from_byte(marker_byte[0]); - - match marker { - MarkerType::Eoi => { - segments.push(JpegSegment::new(MarkerType::Eoi, Vec::new(), cursor.position() as usize - 2)); - break; - } - MarkerType::Soi => { - // Shouldn't happen, but handle it - continue; - } - MarkerType::Sos => { - // Start of Scan - read length and data - let mut len_bytes = [0u8; 2]; - cursor.read_exact(&mut len_bytes)?; - let len = u16::from_be_bytes(len_bytes) as usize; - - let mut segment_data = vec![0u8; len - 2]; - cursor.read_exact(&mut segment_data)?; - - segments.push(JpegSegment::new(MarkerType::Sos, segment_data, pos)); - - // After SOS comes the entropy-coded data - scan_offset = cursor.position() as usize; - - // Read until we find EOI or another marker - let mut in_scan = true; - while in_scan && (cursor.position() as usize) < data.len() { - let mut byte = [0u8; 1]; - if cursor.read_exact(&mut byte).is_err() { - break; - } - - if byte[0] == 0xFF { - if cursor.read_exact(&mut byte).is_err() { - break; - } - - if byte[0] == 0x00 { - // Stuffed byte, part of scan data - scan_data.push(0xFF); - scan_data.push(0x00); - } else if byte[0] == 0xD9 { - // EOI - segments.push(JpegSegment::new(MarkerType::Eoi, Vec::new(), cursor.position() as usize - 2)); - in_scan = false; - } else if byte[0] >= 0xD0 && byte[0] <= 0xD7 { - // Restart marker - scan_data.push(0xFF); - scan_data.push(byte[0]); - } else { - // Another marker - back up - cursor.set_position(cursor.position() - 2); - in_scan = false; - } - } else { - scan_data.push(byte[0]); - } - } - } - _ if marker.has_length() => { - // Read length and data - let mut len_bytes = [0u8; 2]; - cursor.read_exact(&mut len_bytes)?; - let len = u16::from_be_bytes(len_bytes) as usize; - - if len < 2 { - return Err(UltraHdrError::InvalidJpeg(format!( - "Invalid segment length {} at offset {}", - len, pos - ))); - } - - let mut segment_data = vec![0u8; len - 2]; - cursor.read_exact(&mut segment_data)?; - - segments.push(JpegSegment::new(marker, segment_data, pos)); - } - _ => { - // Marker without length - segments.push(JpegSegment::new(marker, Vec::new(), pos)); - } - } - } - - Ok(Self { - segments, - scan_data, - scan_offset, - }) - } - - /// Returns all segments. - pub fn segments(&self) -> &[JpegSegment] { - &self.segments - } - - /// Returns the scan data (entropy-coded image data). - pub fn scan_data(&self) -> &[u8] { - &self.scan_data - } - - /// Returns the scan data offset in the original file. - pub fn scan_offset(&self) -> usize { - self.scan_offset - } - - /// Finds all APP1 segments. - pub fn find_app1_segments(&self) -> Vec<&JpegSegment> { - self.segments - .iter() - .filter(|s| s.marker == MarkerType::App1) - .collect() - } - - /// Finds all APP2 segments. - pub fn find_app2_segments(&self) -> Vec<&JpegSegment> { - self.segments - .iter() - .filter(|s| s.marker == MarkerType::App2) - .collect() - } - - /// Finds the XMP segment. - pub fn find_xmp_segment(&self) -> Option<&JpegSegment> { - self.segments.iter().find(|s| s.is_xmp()) - } - - /// Finds the Exif segment. - pub fn find_exif_segment(&self) -> Option<&JpegSegment> { - self.segments.iter().find(|s| s.is_exif()) - } - - /// Finds the MPF segment. - pub fn find_mpf_segment(&self) -> Option<&JpegSegment> { - self.segments.iter().find(|s| s.is_mpf()) - } - - /// Finds the SOF (Start of Frame) segment to get image dimensions. - pub fn find_sof_segment(&self) -> Option<&JpegSegment> { - self.segments - .iter() - .find(|s| matches!(s.marker, MarkerType::Sof0 | MarkerType::Sof2)) - } - - /// Gets image dimensions from the SOF segment. - pub fn get_dimensions(&self) -> Option<(u32, u32)> { - let sof = self.find_sof_segment()?; - if sof.data.len() < 5 { - return None; - } - let height = u16::from_be_bytes([sof.data[1], sof.data[2]]) as u32; - let width = u16::from_be_bytes([sof.data[3], sof.data[4]]) as u32; - Some((width, height)) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_marker_type_conversion() { - assert_eq!(MarkerType::from_byte(0xD8), MarkerType::Soi); - assert_eq!(MarkerType::from_byte(0xE1), MarkerType::App1); - assert_eq!(MarkerType::App1.to_byte(), 0xE1); - } - - #[test] - fn test_minimal_jpeg() { - // Minimal valid JPEG: SOI + EOI - let data = vec![0xFF, 0xD8, 0xFF, 0xD9]; - let parser = JpegParser::parse(&data).unwrap(); - assert_eq!(parser.segments().len(), 2); - assert_eq!(parser.segments()[0].marker, MarkerType::Soi); - assert_eq!(parser.segments()[1].marker, MarkerType::Eoi); - } - - #[test] - fn test_invalid_jpeg() { - let data = vec![0x00, 0x00]; - assert!(JpegParser::parse(&data).is_err()); - } -} diff --git a/packages/ultrahdr-wasm/src/jpeg/writer.rs b/packages/ultrahdr-wasm/src/jpeg/writer.rs deleted file mode 100644 index b6934b6b0606b3..00000000000000 --- a/packages/ultrahdr-wasm/src/jpeg/writer.rs +++ /dev/null @@ -1,284 +0,0 @@ -//! JPEG segment writer. -//! -//! Writes JPEG files with modified or added segments for UltraHDR. - -use crate::error::{Result, UltraHdrError}; -use super::parser::{JpegSegment, MarkerType}; -use std::io::Write; - -/// JPEG file writer for creating UltraHDR images. -pub struct JpegWriter { - segments: Vec, - scan_data: Vec, -} - -impl JpegWriter { - /// Creates a new JPEG writer with segments from a parsed JPEG. - pub fn new(segments: Vec, scan_data: Vec) -> Self { - Self { segments, scan_data } - } - - /// Creates an empty JPEG writer. - pub fn empty() -> Self { - Self { - segments: Vec::new(), - scan_data: Vec::new(), - } - } - - /// Adds a segment to the JPEG. - pub fn add_segment(&mut self, segment: JpegSegment) { - self.segments.push(segment); - } - - /// Inserts a segment at a specific index. - pub fn insert_segment(&mut self, index: usize, segment: JpegSegment) { - self.segments.insert(index, segment); - } - - /// Adds an XMP segment with the given XMP data. - pub fn add_xmp_segment(&mut self, xmp_data: &[u8]) -> Result<()> { - const XMP_NAMESPACE: &[u8] = b"http://ns.adobe.com/xap/1.0/\0"; - - if xmp_data.len() + XMP_NAMESPACE.len() > 65533 { - return Err(UltraHdrError::XmpError( - "XMP data too large for single segment".to_string() - )); - } - - let mut data = Vec::with_capacity(XMP_NAMESPACE.len() + xmp_data.len()); - data.extend_from_slice(XMP_NAMESPACE); - data.extend_from_slice(xmp_data); - - let segment = JpegSegment::new(MarkerType::App1, data, 0); - - // Insert after JFIF/Exif but before other segments - let insert_pos = self.find_xmp_insert_position(); - self.insert_segment(insert_pos, segment); - - Ok(()) - } - - /// Adds an Extended XMP segment. - pub fn add_extended_xmp_segment(&mut self, xmp_data: &[u8], md5_digest: &str, offset: u32, total_length: u32) -> Result<()> { - const EXT_XMP_NAMESPACE: &[u8] = b"http://ns.adobe.com/xmp/extension/\0"; - - let mut data = Vec::with_capacity(EXT_XMP_NAMESPACE.len() + 32 + 8 + xmp_data.len()); - data.extend_from_slice(EXT_XMP_NAMESPACE); - - // MD5 digest (32 bytes hex string) - data.extend_from_slice(md5_digest.as_bytes()); - - // Full length of extended XMP (4 bytes, big-endian) - data.extend_from_slice(&total_length.to_be_bytes()); - - // Offset of this chunk (4 bytes, big-endian) - data.extend_from_slice(&offset.to_be_bytes()); - - // XMP data - data.extend_from_slice(xmp_data); - - let segment = JpegSegment::new(MarkerType::App1, data, 0); - - // Insert after regular XMP - let insert_pos = self.find_extended_xmp_insert_position(); - self.insert_segment(insert_pos, segment); - - Ok(()) - } - - /// Adds an MPF (Multi-Picture Format) segment for the gain map. - pub fn add_mpf_segment(&mut self, gain_map_offset: u32, gain_map_size: u32) -> Result<()> { - let mpf_data = create_mpf_data(gain_map_offset, gain_map_size); - let segment = JpegSegment::new(MarkerType::App2, mpf_data, 0); - - // Insert MPF after APP1 segments - let insert_pos = self.find_mpf_insert_position(); - self.insert_segment(insert_pos, segment); - - Ok(()) - } - - /// Removes all XMP segments. - pub fn remove_xmp_segments(&mut self) { - self.segments.retain(|s| !s.is_xmp() && !s.is_extended_xmp()); - } - - /// Removes all MPF segments. - pub fn remove_mpf_segments(&mut self) { - self.segments.retain(|s| !s.is_mpf()); - } - - /// Sets the scan data. - pub fn set_scan_data(&mut self, data: Vec) { - self.scan_data = data; - } - - /// Writes the JPEG to a byte vector. - pub fn write(&self) -> Result> { - let mut output = Vec::new(); - - // Write SOI - output.write_all(&[0xFF, 0xD8])?; - - for segment in &self.segments { - match segment.marker { - MarkerType::Soi | MarkerType::Eoi => { - // These are handled separately - continue; - } - MarkerType::Sos => { - // Write SOS marker - output.write_all(&[0xFF, segment.marker.to_byte()])?; - let len = (segment.data.len() + 2) as u16; - output.write_all(&len.to_be_bytes())?; - output.write_all(&segment.data)?; - - // Write scan data - output.write_all(&self.scan_data)?; - } - _ if segment.marker.has_length() => { - output.write_all(&[0xFF, segment.marker.to_byte()])?; - let len = (segment.data.len() + 2) as u16; - output.write_all(&len.to_be_bytes())?; - output.write_all(&segment.data)?; - } - _ => { - output.write_all(&[0xFF, segment.marker.to_byte()])?; - } - } - } - - // Write EOI - output.write_all(&[0xFF, 0xD9])?; - - Ok(output) - } - - /// Writes the JPEG with an appended gain map. - pub fn write_with_gain_map(&self, gain_map_jpeg: &[u8]) -> Result> { - let base_jpeg = self.write()?; - - let mut output = Vec::with_capacity(base_jpeg.len() + gain_map_jpeg.len()); - output.extend_from_slice(&base_jpeg); - output.extend_from_slice(gain_map_jpeg); - - Ok(output) - } - - fn find_xmp_insert_position(&self) -> usize { - // Insert after SOI, JFIF (APP0), and Exif (APP1) - for (i, segment) in self.segments.iter().enumerate() { - match segment.marker { - MarkerType::Soi | MarkerType::App0 => continue, - MarkerType::App1 if segment.is_exif() => continue, - _ => return i, - } - } - self.segments.len() - } - - fn find_extended_xmp_insert_position(&self) -> usize { - // Insert after regular XMP - for (i, segment) in self.segments.iter().enumerate() { - if segment.is_xmp() { - return i + 1; - } - } - self.find_xmp_insert_position() - } - - fn find_mpf_insert_position(&self) -> usize { - // Insert after all APP1 segments - for (i, segment) in self.segments.iter().enumerate().rev() { - if segment.marker == MarkerType::App1 { - return i + 1; - } - } - // If no APP1, insert after APP0 - for (i, segment) in self.segments.iter().enumerate() { - if segment.marker == MarkerType::App0 { - return i + 1; - } - } - // Fallback: after SOI - 1 - } -} - -/// Creates MPF (Multi-Picture Format) data for the gain map reference. -fn create_mpf_data(gain_map_offset: u32, gain_map_size: u32) -> Vec { - const MPF_HEADER: &[u8] = b"MPF\0"; - - let mut data = Vec::new(); - data.extend_from_slice(MPF_HEADER); - - // Byte order (little-endian: II, big-endian: MM) - data.extend_from_slice(b"II"); - - // Fixed value 0x002A - data.extend_from_slice(&[0x2A, 0x00]); - - // Offset to first IFD (8 bytes from start of TIFF header) - data.extend_from_slice(&8u32.to_le_bytes()); - - // IFD Entry Count: 3 entries - data.extend_from_slice(&3u16.to_le_bytes()); - - // Entry 1: MPFVersion (0xB000) - data.extend_from_slice(&0xB000u16.to_le_bytes()); // Tag - data.extend_from_slice(&7u16.to_le_bytes()); // Type: UNDEFINED - data.extend_from_slice(&4u32.to_le_bytes()); // Count - data.extend_from_slice(b"0100"); // Value: "0100" - - // Entry 2: NumberOfImages (0xB001) - data.extend_from_slice(&0xB001u16.to_le_bytes()); // Tag - data.extend_from_slice(&4u32.to_le_bytes()); // Type: LONG - data.extend_from_slice(&1u32.to_le_bytes()); // Count - data.extend_from_slice(&2u32.to_le_bytes()); // Value: 2 images - - // Entry 3: MPEntry (0xB002) - offset to MP Entry - let mp_entry_offset: u32 = 8 + 2 + (3 * 12) + 4; // TIFF header + count + 3 entries + next IFD pointer - data.extend_from_slice(&0xB002u16.to_le_bytes()); // Tag - data.extend_from_slice(&7u16.to_le_bytes()); // Type: UNDEFINED - data.extend_from_slice(&32u32.to_le_bytes()); // Count: 16 bytes per entry * 2 entries - data.extend_from_slice(&mp_entry_offset.to_le_bytes()); // Offset - - // Next IFD pointer (0 = no more IFDs) - data.extend_from_slice(&0u32.to_le_bytes()); - - // MP Entry for primary image - data.extend_from_slice(&0x20030000u32.to_le_bytes()); // Image flags (primary, JPEG) - data.extend_from_slice(&0u32.to_le_bytes()); // Size (0 for primary = use actual) - data.extend_from_slice(&0u32.to_le_bytes()); // Offset (0 for primary) - data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 1 - data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 2 - - // MP Entry for gain map - data.extend_from_slice(&0x00030000u32.to_le_bytes()); // Image flags (JPEG, not primary) - data.extend_from_slice(&gain_map_size.to_le_bytes()); // Size - data.extend_from_slice(&gain_map_offset.to_le_bytes()); // Offset from start of file - data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 1 - data.extend_from_slice(&0u16.to_le_bytes()); // Dependent image 2 - - data -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_create_mpf_data() { - let data = create_mpf_data(1000, 500); - assert!(data.starts_with(b"MPF\0")); - } - - #[test] - fn test_empty_writer() { - let writer = JpegWriter::empty(); - let result = writer.write().unwrap(); - // Should have SOI + EOI - assert_eq!(result, vec![0xFF, 0xD8, 0xFF, 0xD9]); - } -} diff --git a/packages/ultrahdr-wasm/src/jpeg/xmp.rs b/packages/ultrahdr-wasm/src/jpeg/xmp.rs deleted file mode 100644 index 6f183cccebce24..00000000000000 --- a/packages/ultrahdr-wasm/src/jpeg/xmp.rs +++ /dev/null @@ -1,374 +0,0 @@ -//! XMP metadata parsing and writing for gain map metadata. -//! -//! Handles the ISO 21496-1 and UltraHDR v1 XMP namespaces. - -use crate::error::{Result, UltraHdrError}; -use crate::types::GainMapMetadata; -use quick_xml::events::{BytesEnd, BytesStart, Event}; -use quick_xml::{Reader, Writer}; -use std::io::Cursor; - -/// XMP namespace URIs -pub const HDRGM_NAMESPACE: &str = "http://ns.adobe.com/hdr-gain-map/1.0/"; -pub const HDRGM_PREFIX: &str = "hdrgm"; - -pub const CONTAINER_NAMESPACE: &str = "http://ns.google.com/photos/1.0/container/"; -pub const CONTAINER_PREFIX: &str = "Container"; - -pub const CONTAINER_ITEM_NAMESPACE: &str = "http://ns.google.com/photos/1.0/container/item/"; -pub const CONTAINER_ITEM_PREFIX: &str = "Item"; - -/// XMP parser for gain map metadata. -pub struct XmpParser; - -impl XmpParser { - /// Parses gain map metadata from XMP data. - pub fn parse(xmp_data: &[u8]) -> Result { - let xmp_str = std::str::from_utf8(xmp_data) - .map_err(|e| UltraHdrError::XmpError(format!("Invalid UTF-8 in XMP: {}", e)))?; - - Self::parse_str(xmp_str) - } - - /// Parses gain map metadata from an XMP string. - pub fn parse_str(xmp_str: &str) -> Result { - let mut metadata = GainMapMetadata::default(); - let mut reader = Reader::from_str(xmp_str); - reader.trim_text(true); - - let mut in_hdrgm = false; - let mut current_element = String::new(); - - loop { - match reader.read_event() { - Ok(Event::Start(e)) | Ok(Event::Empty(e)) => { - let name_bytes = e.name(); - let name = std::str::from_utf8(name_bytes.as_ref()).unwrap_or(""); - - // Check for hdrgm: prefix - if name.starts_with("hdrgm:") || name.contains(":hdrgm:") { - in_hdrgm = true; - current_element = name.to_string(); - } - - // Parse attributes for RDF property syntax - for attr in e.attributes().flatten() { - let attr_name = std::str::from_utf8(attr.key.as_ref()).unwrap_or(""); - let attr_value = std::str::from_utf8(&attr.value).unwrap_or(""); - - if attr_name.starts_with("hdrgm:") { - Self::set_metadata_field(&mut metadata, attr_name, attr_value)?; - } - } - } - Ok(Event::Text(e)) if in_hdrgm => { - let text = e.unescape().unwrap_or_default(); - Self::set_metadata_field(&mut metadata, ¤t_element, &text)?; - } - Ok(Event::End(e)) => { - let name_bytes = e.name(); - let name = std::str::from_utf8(name_bytes.as_ref()).unwrap_or(""); - if name.starts_with("hdrgm:") { - in_hdrgm = false; - current_element.clear(); - } - } - Ok(Event::Eof) => break, - Err(e) => return Err(UltraHdrError::XmpError(format!("XML parse error: {}", e))), - _ => {} - } - } - - Ok(metadata) - } - - /// Checks if XMP data contains gain map metadata. - pub fn has_gain_map_metadata(xmp_data: &[u8]) -> bool { - let xmp_str = match std::str::from_utf8(xmp_data) { - Ok(s) => s, - Err(_) => return false, - }; - - xmp_str.contains(HDRGM_NAMESPACE) || xmp_str.contains("hdrgm:") - } - - fn set_metadata_field(metadata: &mut GainMapMetadata, name: &str, value: &str) -> Result<()> { - // Strip namespace prefix - let field_name = name.split(':').last().unwrap_or(name); - - match field_name { - "Version" => metadata.version = value.to_string(), - "BaseRenditionIsHDR" => { - metadata.base_rendition_is_hdr = value.eq_ignore_ascii_case("true") || value == "1"; - } - "GainMapMin" => metadata.gain_map_min = Self::parse_float_array(value)?, - "GainMapMax" => metadata.gain_map_max = Self::parse_float_array(value)?, - "Gamma" => metadata.gamma = Self::parse_float_array(value)?, - "OffsetSDR" => metadata.offset_sdr = Self::parse_float_array(value)?, - "OffsetHDR" => metadata.offset_hdr = Self::parse_float_array(value)?, - "HDRCapacityMin" => { - metadata.hdr_capacity_min = value.parse().map_err(|_| { - UltraHdrError::MetadataError(format!("Invalid HDRCapacityMin: {}", value)) - })?; - } - "HDRCapacityMax" => { - metadata.hdr_capacity_max = value.parse().map_err(|_| { - UltraHdrError::MetadataError(format!("Invalid HDRCapacityMax: {}", value)) - })?; - } - _ => {} // Ignore unknown fields - } - - Ok(()) - } - - fn parse_float_array(value: &str) -> Result> { - // Handle single value (applied to all channels) - if !value.contains(',') && !value.contains(' ') { - let v: f32 = value.trim().parse().map_err(|_| { - UltraHdrError::MetadataError(format!("Invalid float value: {}", value)) - })?; - return Ok(vec![v, v, v]); - } - - // Handle comma or space separated values - let parts: Vec<&str> = value.split(|c| c == ',' || c == ' ') - .filter(|s| !s.is_empty()) - .collect(); - - let mut result = Vec::with_capacity(parts.len()); - for part in parts { - let v: f32 = part.trim().parse().map_err(|_| { - UltraHdrError::MetadataError(format!("Invalid float value: {}", part)) - })?; - result.push(v); - } - - // Ensure we have exactly 3 values (RGB) - match result.len() { - 1 => Ok(vec![result[0], result[0], result[0]]), - 3 => Ok(result), - _ => Err(UltraHdrError::MetadataError(format!( - "Expected 1 or 3 values, got {}", - result.len() - ))), - } - } -} - -/// XMP writer for gain map metadata. -pub struct XmpWriter; - -impl XmpWriter { - /// Creates XMP data for gain map metadata (ISO 21496-1 format). - pub fn create_iso_xmp(metadata: &GainMapMetadata) -> Result> { - let mut writer = Writer::new(Cursor::new(Vec::new())); - - // XML declaration - writer.write_event(Event::Decl(quick_xml::events::BytesDecl::new("1.0", Some("UTF-8"), None)))?; - - // XMP packet wrapper - let mut xmpmeta = BytesStart::new("x:xmpmeta"); - xmpmeta.push_attribute(("xmlns:x", "adobe:ns:meta/")); - writer.write_event(Event::Start(xmpmeta))?; - - // RDF root - let mut rdf = BytesStart::new("rdf:RDF"); - rdf.push_attribute(("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")); - rdf.push_attribute(("xmlns:hdrgm", HDRGM_NAMESPACE)); - writer.write_event(Event::Start(rdf))?; - - // RDF Description - let mut desc = BytesStart::new("rdf:Description"); - desc.push_attribute(("rdf:about", "")); - - // Add metadata as attributes - let gain_map_min = Self::format_float_array(&metadata.gain_map_min); - let gain_map_max = Self::format_float_array(&metadata.gain_map_max); - let gamma = Self::format_float_array(&metadata.gamma); - let offset_sdr = Self::format_float_array(&metadata.offset_sdr); - let offset_hdr = Self::format_float_array(&metadata.offset_hdr); - let hdr_capacity_min = format!("{:.6}", metadata.hdr_capacity_min); - let hdr_capacity_max = format!("{:.6}", metadata.hdr_capacity_max); - - desc.push_attribute(("hdrgm:Version", metadata.version.as_str())); - desc.push_attribute(("hdrgm:BaseRenditionIsHDR", if metadata.base_rendition_is_hdr { "True" } else { "False" })); - desc.push_attribute(("hdrgm:GainMapMin", gain_map_min.as_str())); - desc.push_attribute(("hdrgm:GainMapMax", gain_map_max.as_str())); - desc.push_attribute(("hdrgm:Gamma", gamma.as_str())); - desc.push_attribute(("hdrgm:OffsetSDR", offset_sdr.as_str())); - desc.push_attribute(("hdrgm:OffsetHDR", offset_hdr.as_str())); - desc.push_attribute(("hdrgm:HDRCapacityMin", hdr_capacity_min.as_str())); - desc.push_attribute(("hdrgm:HDRCapacityMax", hdr_capacity_max.as_str())); - - writer.write_event(Event::Empty(desc))?; - - // Close elements - writer.write_event(Event::End(BytesEnd::new("rdf:RDF")))?; - writer.write_event(Event::End(BytesEnd::new("x:xmpmeta")))?; - - Ok(writer.into_inner().into_inner()) - } - - /// Creates XMP data with UltraHDR v1 Container extension. - pub fn create_ultrahdr_v1_xmp(metadata: &GainMapMetadata, gain_map_mime: &str) -> Result> { - let mut writer = Writer::new(Cursor::new(Vec::new())); - - // XML declaration - writer.write_event(Event::Decl(quick_xml::events::BytesDecl::new("1.0", Some("UTF-8"), None)))?; - - // XMP packet wrapper - let mut xmpmeta = BytesStart::new("x:xmpmeta"); - xmpmeta.push_attribute(("xmlns:x", "adobe:ns:meta/")); - writer.write_event(Event::Start(xmpmeta))?; - - // RDF root - let mut rdf = BytesStart::new("rdf:RDF"); - rdf.push_attribute(("xmlns:rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#")); - rdf.push_attribute(("xmlns:hdrgm", HDRGM_NAMESPACE)); - rdf.push_attribute(("xmlns:Container", CONTAINER_NAMESPACE)); - rdf.push_attribute(("xmlns:Item", CONTAINER_ITEM_NAMESPACE)); - writer.write_event(Event::Start(rdf))?; - - // RDF Description with gain map metadata - let gain_map_min = Self::format_float_array(&metadata.gain_map_min); - let gain_map_max = Self::format_float_array(&metadata.gain_map_max); - let gamma = Self::format_float_array(&metadata.gamma); - let offset_sdr = Self::format_float_array(&metadata.offset_sdr); - let offset_hdr = Self::format_float_array(&metadata.offset_hdr); - let hdr_capacity_min = format!("{:.6}", metadata.hdr_capacity_min); - let hdr_capacity_max = format!("{:.6}", metadata.hdr_capacity_max); - - let mut desc = BytesStart::new("rdf:Description"); - desc.push_attribute(("rdf:about", "")); - desc.push_attribute(("hdrgm:Version", metadata.version.as_str())); - desc.push_attribute(("hdrgm:BaseRenditionIsHDR", if metadata.base_rendition_is_hdr { "True" } else { "False" })); - desc.push_attribute(("hdrgm:GainMapMin", gain_map_min.as_str())); - desc.push_attribute(("hdrgm:GainMapMax", gain_map_max.as_str())); - desc.push_attribute(("hdrgm:Gamma", gamma.as_str())); - desc.push_attribute(("hdrgm:OffsetSDR", offset_sdr.as_str())); - desc.push_attribute(("hdrgm:OffsetHDR", offset_hdr.as_str())); - desc.push_attribute(("hdrgm:HDRCapacityMin", hdr_capacity_min.as_str())); - desc.push_attribute(("hdrgm:HDRCapacityMax", hdr_capacity_max.as_str())); - writer.write_event(Event::Start(desc))?; - - // Container:Directory - writer.write_event(Event::Start(BytesStart::new("Container:Directory")))?; - writer.write_event(Event::Start(BytesStart::new("rdf:Seq")))?; - - // Primary image item - writer.write_event(Event::Start(BytesStart::new("rdf:li")))?; - let mut primary_item = BytesStart::new("Container:Item"); - primary_item.push_attribute(("Item:Semantic", "Primary")); - primary_item.push_attribute(("Item:Mime", "image/jpeg")); - writer.write_event(Event::Empty(primary_item))?; - writer.write_event(Event::End(BytesEnd::new("rdf:li")))?; - - // Gain map item - writer.write_event(Event::Start(BytesStart::new("rdf:li")))?; - let mut gainmap_item = BytesStart::new("Container:Item"); - gainmap_item.push_attribute(("Item:Semantic", "GainMap")); - gainmap_item.push_attribute(("Item:Mime", gain_map_mime)); - writer.write_event(Event::Empty(gainmap_item))?; - writer.write_event(Event::End(BytesEnd::new("rdf:li")))?; - - writer.write_event(Event::End(BytesEnd::new("rdf:Seq")))?; - writer.write_event(Event::End(BytesEnd::new("Container:Directory")))?; - - // Close elements - writer.write_event(Event::End(BytesEnd::new("rdf:Description")))?; - writer.write_event(Event::End(BytesEnd::new("rdf:RDF")))?; - writer.write_event(Event::End(BytesEnd::new("x:xmpmeta")))?; - - Ok(writer.into_inner().into_inner()) - } - - /// Creates combined XMP data with both ISO 21496-1 and UltraHDR v1 metadata. - pub fn create_combined_xmp(metadata: &GainMapMetadata) -> Result> { - Self::create_ultrahdr_v1_xmp(metadata, "image/jpeg") - } - - fn format_float_array(values: &[f32]) -> String { - if values.len() == 3 && values[0] == values[1] && values[1] == values[2] { - // Single value if all channels are the same - format!("{:.6}", values[0]) - } else { - values.iter() - .map(|v| format!("{:.6}", v)) - .collect::>() - .join(", ") - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_parse_gain_map_metadata() { - let xmp = r#" - - - - - "#; - - let metadata = XmpParser::parse_str(xmp).unwrap(); - assert_eq!(metadata.version, "1.0"); - assert!(!metadata.base_rendition_is_hdr); - assert_eq!(metadata.gain_map_max, vec![3.0, 3.0, 3.0]); - assert_eq!(metadata.hdr_capacity_max, 3.0); - } - - #[test] - fn test_write_iso_xmp() { - let metadata = GainMapMetadata::default(); - let xmp = XmpWriter::create_iso_xmp(&metadata).unwrap(); - let xmp_str = std::str::from_utf8(&xmp).unwrap(); - - assert!(xmp_str.contains("hdrgm:Version")); - assert!(xmp_str.contains(HDRGM_NAMESPACE)); - } - - #[test] - fn test_has_gain_map_metadata() { - let xmp_with = b""; - let xmp_without = b""; - - assert!(XmpParser::has_gain_map_metadata(xmp_with)); - assert!(!XmpParser::has_gain_map_metadata(xmp_without)); - } - - #[test] - fn test_roundtrip() { - let original = GainMapMetadata { - version: "1.0".to_string(), - base_rendition_is_hdr: false, - gain_map_min: vec![-1.0, -1.0, -1.0], - gain_map_max: vec![3.0, 3.0, 3.0], - gamma: vec![1.0, 1.0, 1.0], - offset_sdr: vec![0.015625, 0.015625, 0.015625], - offset_hdr: vec![0.015625, 0.015625, 0.015625], - hdr_capacity_min: 1.0, - hdr_capacity_max: 4.0, - }; - - let xmp = XmpWriter::create_iso_xmp(&original).unwrap(); - let parsed = XmpParser::parse(&xmp).unwrap(); - - assert_eq!(original.version, parsed.version); - assert_eq!(original.base_rendition_is_hdr, parsed.base_rendition_is_hdr); - assert_eq!(original.hdr_capacity_max, parsed.hdr_capacity_max); - } -} diff --git a/packages/ultrahdr-wasm/src/lib.rs b/packages/ultrahdr-wasm/src/lib.rs deleted file mode 100644 index 8eb29a9a11a694..00000000000000 --- a/packages/ultrahdr-wasm/src/lib.rs +++ /dev/null @@ -1,293 +0,0 @@ -//! WordPress UltraHDR WASM Library -//! -//! A GPLv2-compatible Rust library implementing ISO 21496-1 (UltraHDR/gain map) -//! specification, compiled to WebAssembly for integration with WordPress Gutenberg's -//! client-side media processing. -//! -//! # Features -//! -//! - **Detection**: Check if a JPEG contains UltraHDR/gain map data -//! - **Decoding**: Extract SDR base, gain map, and metadata from UltraHDR JPEGs -//! - **Encoding**: Create UltraHDR JPEGs from SDR + HDR image pairs -//! - **SDR Extraction**: Extract backwards-compatible SDR image -//! -//! # Standards Support -//! -//! - ISO 21496-1:2025 (Gain map metadata) -//! - Google UltraHDR v1 (Android compatibility) -//! - Adobe Gain Map specification -//! -//! # License -//! -//! GPL-2.0-or-later - -#![allow(clippy::unused_unit)] - -use wasm_bindgen::prelude::*; - -pub mod error; -pub mod gainmap; -pub mod jpeg; -pub mod types; -pub mod ultrahdr; - -pub use error::{Result, UltraHdrError}; -// Types are exported via wasm_bindgen annotations in types.rs - -/// Initializes the WASM module. -/// -/// This should be called before using any other functions. -#[wasm_bindgen(start)] -pub fn init() { - // Module initialization - currently no-op but reserved for future setup -} - -/// Checks if a JPEG buffer contains UltraHDR/gain map data. -/// -/// This is a fast check that looks for gain map metadata in the XMP -/// or MPF segments without fully decoding the image. -/// -/// # Arguments -/// * `buffer` - JPEG file contents as bytes -/// -/// # Returns -/// `true` if the image contains gain map metadata, `false` otherwise -/// -/// # Example (JavaScript) -/// ```js -/// const buffer = await file.arrayBuffer(); -/// const isHdr = isUltraHdr(new Uint8Array(buffer)); -/// ``` -#[wasm_bindgen(js_name = isUltraHdr)] -pub fn is_ultra_hdr(buffer: &[u8]) -> bool { - ultrahdr::has_gainmap_metadata(buffer) -} - -/// Decodes an UltraHDR JPEG, extracting SDR base, gain map, and metadata. -/// -/// # Arguments -/// * `buffer` - UltraHDR JPEG file contents as bytes -/// -/// # Returns -/// A `UltraHdrDecodeResult` containing: -/// - `sdrImage`: The SDR base image as JPEG bytes -/// - `gainMap`: The gain map as JPEG bytes -/// - `metadata`: Gain map metadata (version, gains, gamma, offsets, etc.) -/// - `width`, `height`: Image dimensions -/// - `gainMapWidth`, `gainMapHeight`: Gain map dimensions -/// -/// # Errors -/// Returns an error if the buffer is not a valid UltraHDR JPEG. -#[wasm_bindgen(js_name = decodeUltraHdr)] -pub fn decode_ultra_hdr(buffer: &[u8]) -> std::result::Result { - ultrahdr::decode(buffer).map_err(|e| JsValue::from_str(&e.to_string())) -} - -/// Encodes an UltraHDR JPEG from SDR and HDR inputs. -/// -/// # Arguments -/// * `sdr_buffer` - SDR JPEG image bytes -/// * `hdr_buffer` - HDR image as linear RGB float32 array (3 values per pixel, normalized to [0,1]) -/// * `options` - Encoding options (quality, HDR capacity, etc.) -/// -/// # Returns -/// The encoded UltraHDR JPEG as bytes. -/// -/// # Errors -/// Returns an error if: -/// - The SDR buffer is not a valid JPEG -/// - The HDR buffer size doesn't match the SDR dimensions -/// - The dimensions are invalid (e.g., odd width/height) -/// -/// # Example (JavaScript) -/// ```js -/// const options = new UltraHdrEncodeOptions(); -/// options.baseQuality = 90; -/// options.targetHdrCapacity = 3.0; -/// -/// const sdrBuffer = await sdrFile.arrayBuffer(); -/// const hdrBuffer = await getHdrLinearData(); // Float32Array -/// -/// const ultraHdr = encodeUltraHdr( -/// new Uint8Array(sdrBuffer), -/// new Float32Array(hdrBuffer), -/// options -/// ); -/// ``` -#[wasm_bindgen(js_name = encodeUltraHdr)] -pub fn encode_ultra_hdr( - sdr_buffer: &[u8], - hdr_buffer: &[f32], - options: &UltraHdrEncodeOptions, -) -> std::result::Result, JsValue> { - ultrahdr::encode(sdr_buffer, hdr_buffer, options) - .map_err(|e| JsValue::from_str(&e.to_string())) -} - -/// Extracts just the SDR base image from an UltraHDR JPEG. -/// -/// This produces a standard JPEG that can be displayed on any device, -/// without the gain map metadata. Useful for backwards compatibility. -/// -/// # Arguments -/// * `buffer` - UltraHDR JPEG file contents as bytes -/// -/// # Returns -/// A standard JPEG without gain map metadata. -/// -/// # Errors -/// Returns an error if the buffer is not a valid JPEG. -#[wasm_bindgen(js_name = extractSdrBase)] -pub fn extract_sdr_base(buffer: &[u8]) -> std::result::Result, JsValue> { - ultrahdr::extract_base(buffer).map_err(|e| JsValue::from_str(&e.to_string())) -} - -/// Gets gain map metadata from an UltraHDR JPEG without full decode. -/// -/// This is faster than `decodeUltraHdr` when you only need the metadata. -/// -/// # Arguments -/// * `buffer` - UltraHDR JPEG file contents as bytes -/// -/// # Returns -/// The gain map metadata. -/// -/// # Errors -/// Returns an error if the buffer doesn't contain gain map metadata. -#[wasm_bindgen(js_name = getMetadata)] -pub fn get_metadata(buffer: &[u8]) -> std::result::Result { - ultrahdr::extract_metadata(buffer).map_err(|e| JsValue::from_str(&e.to_string())) -} - -/// Creates default encoding options. -/// -/// # Returns -/// `UltraHdrEncodeOptions` with sensible defaults: -/// - baseQuality: 85 -/// - gainMapQuality: 75 -/// - targetHdrCapacity: 3.0 -/// - includeIsoMetadata: true -/// - includeUltrahdrV1: true -/// - gainMapScale: 1 -#[wasm_bindgen(js_name = createDefaultOptions)] -pub fn create_default_options() -> UltraHdrEncodeOptions { - UltraHdrEncodeOptions::default() -} - -/// Creates high quality encoding options. -/// -/// # Returns -/// `UltraHdrEncodeOptions` optimized for quality: -/// - baseQuality: 95 -/// - gainMapQuality: 85 -/// - targetHdrCapacity: 4.0 -#[wasm_bindgen(js_name = createHighQualityOptions)] -pub fn create_high_quality_options() -> UltraHdrEncodeOptions { - UltraHdrEncodeOptions::high_quality() -} - -/// Creates small size encoding options. -/// -/// # Returns -/// `UltraHdrEncodeOptions` optimized for file size: -/// - baseQuality: 75 -/// - gainMapQuality: 65 -/// - targetHdrCapacity: 3.0 -/// - gainMapScale: 2 (half-size gain map) -#[wasm_bindgen(js_name = createSmallSizeOptions)] -pub fn create_small_size_options() -> UltraHdrEncodeOptions { - UltraHdrEncodeOptions::small_size() -} - -/// Creates default gain map metadata. -/// -/// Useful for testing or when creating metadata programmatically. -#[wasm_bindgen(js_name = createDefaultMetadata)] -pub fn create_default_metadata() -> GainMapMetadata { - GainMapMetadata::default() -} - -/// Validates gain map metadata. -/// -/// # Arguments -/// * `metadata` - The metadata to validate -/// -/// # Returns -/// `true` if the metadata is valid, `false` otherwise -#[wasm_bindgen(js_name = validateMetadata)] -pub fn validate_metadata(metadata: &GainMapMetadata) -> bool { - gainmap::metadata::validate_metadata(metadata).is_ok() -} - -/// Estimates the HDR headroom from metadata. -/// -/// # Arguments -/// * `metadata` - The gain map metadata -/// -/// # Returns -/// The maximum additional stops of dynamic range above SDR. -#[wasm_bindgen(js_name = estimateHdrHeadroom)] -pub fn estimate_hdr_headroom(metadata: &GainMapMetadata) -> f32 { - gainmap::metadata::estimate_hdr_headroom(metadata) -} - -/// Checks if metadata indicates a meaningful HDR image. -/// -/// # Arguments -/// * `metadata` - The gain map metadata -/// -/// # Returns -/// `true` if the gain map provides significant dynamic range extension -/// (more than half a stop). -#[wasm_bindgen(js_name = isMeaningfulHdr)] -pub fn is_meaningful_hdr(metadata: &GainMapMetadata) -> bool { - gainmap::metadata::is_meaningful_hdr(metadata) -} - -// Re-export types for use in WASM -pub use types::{ColorGamut, GainMapMetadata, TransferFunction, UltraHdrDecodeResult, UltraHdrEncodeOptions}; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_is_ultra_hdr_non_jpeg() { - assert!(!is_ultra_hdr(&[])); - assert!(!is_ultra_hdr(&[0x89, 0x50, 0x4E, 0x47])); // PNG - } - - #[test] - fn test_is_ultra_hdr_regular_jpeg() { - // Minimal JPEG without gain map - let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; - assert!(!is_ultra_hdr(&jpeg)); - } - - #[test] - fn test_create_default_options() { - let opts = create_default_options(); - assert_eq!(opts.base_quality, 85); - assert_eq!(opts.gain_map_quality, 75); - assert_eq!(opts.target_hdr_capacity, 3.0); - } - - #[test] - fn test_create_high_quality_options() { - let opts = create_high_quality_options(); - assert_eq!(opts.base_quality, 95); - assert_eq!(opts.target_hdr_capacity, 4.0); - } - - #[test] - fn test_validate_metadata() { - let metadata = create_default_metadata(); - assert!(validate_metadata(&metadata)); - } - - #[test] - fn test_estimate_hdr_headroom() { - let metadata = create_default_metadata(); - assert!(estimate_hdr_headroom(&metadata) > 0.0); - } -} diff --git a/packages/ultrahdr-wasm/src/types.rs b/packages/ultrahdr-wasm/src/types.rs deleted file mode 100644 index 70eebcd3d09110..00000000000000 --- a/packages/ultrahdr-wasm/src/types.rs +++ /dev/null @@ -1,257 +0,0 @@ -//! Shared types for UltraHDR operations. - -use serde::{Deserialize, Serialize}; -use wasm_bindgen::prelude::*; - -/// ISO 21496-1 Gain Map Metadata. -/// -/// This structure contains all the metadata required to interpret and apply -/// a gain map according to the ISO 21496-1 specification. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[wasm_bindgen(getter_with_clone)] -pub struct GainMapMetadata { - /// Specification version (e.g., "1.0") - pub version: String, - - /// Whether the base rendition is HDR (false = SDR base, true = HDR base) - #[wasm_bindgen(js_name = baseRenditionIsHdr)] - pub base_rendition_is_hdr: bool, - - /// Minimum gain value per channel (RGB), in log2 scale - #[wasm_bindgen(js_name = gainMapMin)] - pub gain_map_min: Vec, - - /// Maximum gain value per channel (RGB), in log2 scale - #[wasm_bindgen(js_name = gainMapMax)] - pub gain_map_max: Vec, - - /// Gamma correction per channel (RGB) - pub gamma: Vec, - - /// SDR offset per channel (RGB), used for black point adjustment - #[wasm_bindgen(js_name = offsetSdr)] - pub offset_sdr: Vec, - - /// HDR offset per channel (RGB), used for black point adjustment - #[wasm_bindgen(js_name = offsetHdr)] - pub offset_hdr: Vec, - - /// Minimum HDR capacity (log2 scale) where gain map starts to apply - #[wasm_bindgen(js_name = hdrCapacityMin)] - pub hdr_capacity_min: f32, - - /// Maximum HDR capacity (log2 scale) for full HDR output - #[wasm_bindgen(js_name = hdrCapacityMax)] - pub hdr_capacity_max: f32, -} - -#[wasm_bindgen] -impl GainMapMetadata { - /// Creates a new GainMapMetadata with default values. - #[wasm_bindgen(constructor)] - pub fn new() -> Self { - Self::default() - } - - /// Creates metadata suitable for a typical SDR base with HDR gain map. - #[wasm_bindgen(js_name = forSdrBase)] - pub fn for_sdr_base(hdr_capacity_max: f32) -> Self { - Self { - version: "1.0".to_string(), - base_rendition_is_hdr: false, - gain_map_min: vec![0.0, 0.0, 0.0], - gain_map_max: vec![hdr_capacity_max, hdr_capacity_max, hdr_capacity_max], - gamma: vec![1.0, 1.0, 1.0], - offset_sdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], - offset_hdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], - hdr_capacity_min: 0.0, - hdr_capacity_max, - } - } -} - -impl Default for GainMapMetadata { - fn default() -> Self { - Self { - version: "1.0".to_string(), - base_rendition_is_hdr: false, - gain_map_min: vec![0.0, 0.0, 0.0], - gain_map_max: vec![3.0, 3.0, 3.0], - gamma: vec![1.0, 1.0, 1.0], - offset_sdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], - offset_hdr: vec![1.0 / 64.0, 1.0 / 64.0, 1.0 / 64.0], - hdr_capacity_min: 0.0, - hdr_capacity_max: 3.0, - } - } -} - -/// Result of decoding an UltraHDR image. -#[derive(Debug, Clone)] -#[wasm_bindgen(getter_with_clone)] -pub struct UltraHdrDecodeResult { - /// The SDR base image as JPEG bytes - #[wasm_bindgen(js_name = sdrImage)] - pub sdr_image: Vec, - - /// The gain map as grayscale JPEG bytes - #[wasm_bindgen(js_name = gainMap)] - pub gain_map: Vec, - - /// Gain map metadata - pub metadata: GainMapMetadata, - - /// Image width in pixels - pub width: u32, - - /// Image height in pixels - pub height: u32, - - /// Gain map width in pixels (may differ from image width) - #[wasm_bindgen(js_name = gainMapWidth)] - pub gain_map_width: u32, - - /// Gain map height in pixels (may differ from image height) - #[wasm_bindgen(js_name = gainMapHeight)] - pub gain_map_height: u32, -} - -#[wasm_bindgen] -impl UltraHdrDecodeResult { - /// Creates a new decode result. - #[wasm_bindgen(constructor)] - pub fn new( - sdr_image: Vec, - gain_map: Vec, - metadata: GainMapMetadata, - width: u32, - height: u32, - gain_map_width: u32, - gain_map_height: u32, - ) -> Self { - Self { - sdr_image, - gain_map, - metadata, - width, - height, - gain_map_width, - gain_map_height, - } - } -} - -/// Options for encoding UltraHDR images. -#[derive(Debug, Clone, Serialize, Deserialize)] -#[wasm_bindgen] -pub struct UltraHdrEncodeOptions { - /// JPEG quality for the base image (1-100) - #[wasm_bindgen(js_name = baseQuality)] - pub base_quality: u8, - - /// JPEG quality for the gain map (1-100) - #[wasm_bindgen(js_name = gainMapQuality)] - pub gain_map_quality: u8, - - /// Target HDR capacity (typically 2.0-4.0) - #[wasm_bindgen(js_name = targetHdrCapacity)] - pub target_hdr_capacity: f32, - - /// Whether to include ISO 21496-1 metadata - #[wasm_bindgen(js_name = includeIsoMetadata)] - pub include_iso_metadata: bool, - - /// Whether to include UltraHDR v1 metadata for Android compatibility - #[wasm_bindgen(js_name = includeUltrahdrV1)] - pub include_ultrahdr_v1: bool, - - /// Downscale factor for the gain map (1 = same size, 2 = half, 4 = quarter) - #[wasm_bindgen(js_name = gainMapScale)] - pub gain_map_scale: u8, -} - -#[wasm_bindgen] -impl UltraHdrEncodeOptions { - /// Creates encoding options with default values. - #[wasm_bindgen(constructor)] - pub fn new() -> Self { - Self::default() - } - - /// Creates options optimized for high quality output. - #[wasm_bindgen(js_name = highQuality)] - pub fn high_quality() -> Self { - Self { - base_quality: 95, - gain_map_quality: 85, - target_hdr_capacity: 4.0, - include_iso_metadata: true, - include_ultrahdr_v1: true, - gain_map_scale: 1, - } - } - - /// Creates options optimized for smaller file size. - #[wasm_bindgen(js_name = smallSize)] - pub fn small_size() -> Self { - Self { - base_quality: 75, - gain_map_quality: 65, - target_hdr_capacity: 3.0, - include_iso_metadata: true, - include_ultrahdr_v1: true, - gain_map_scale: 2, - } - } -} - -impl Default for UltraHdrEncodeOptions { - fn default() -> Self { - Self { - base_quality: 85, - gain_map_quality: 75, - target_hdr_capacity: 3.0, - include_iso_metadata: true, - include_ultrahdr_v1: true, - gain_map_scale: 1, - } - } -} - -/// Color gamut enumeration for HDR images. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[wasm_bindgen] -pub enum ColorGamut { - /// Standard sRGB color space (BT.709 primaries) - Srgb = 0, - /// Display P3 wide color gamut - DisplayP3 = 1, - /// BT.2100/BT.2020 wide color gamut (HDR) - Bt2100 = 2, -} - -impl Default for ColorGamut { - fn default() -> Self { - ColorGamut::Srgb - } -} - -/// Transfer function for encoding luminance. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[wasm_bindgen] -pub enum TransferFunction { - /// sRGB transfer function (gamma ~2.2) - Srgb = 0, - /// Linear (no gamma) - Linear = 1, - /// Perceptual Quantizer (PQ) - SMPTE ST 2084 - Pq = 2, - /// Hybrid Log-Gamma (HLG) - BT.2100 - Hlg = 3, -} - -impl Default for TransferFunction { - fn default() -> Self { - TransferFunction::Srgb - } -} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs b/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs deleted file mode 100644 index ade91fdb3d3759..00000000000000 --- a/packages/ultrahdr-wasm/src/ultrahdr/decoder.rs +++ /dev/null @@ -1,325 +0,0 @@ -//! UltraHDR JPEG decoder. -//! -//! Extracts SDR base, gain map, and metadata from UltraHDR JPEG files. - -use crate::error::{Result, UltraHdrError}; -use crate::types::{GainMapMetadata, UltraHdrDecodeResult}; -use crate::jpeg::parser::JpegParser; -use crate::jpeg::xmp::XmpParser; - -/// Checks if a JPEG contains UltraHDR/gain map metadata. -pub fn has_gainmap_metadata(data: &[u8]) -> bool { - // Quick check for JPEG magic bytes - if data.len() < 2 || data[0] != 0xFF || data[1] != 0xD8 { - return false; - } - - // Try to parse and find XMP with gain map metadata - match JpegParser::parse(data) { - Ok(parser) => { - if let Some(xmp_segment) = parser.find_xmp_segment() { - if let Some(xmp_data) = xmp_segment.get_xmp_data() { - return XmpParser::has_gain_map_metadata(xmp_data); - } - } - // Also check for MPF segment as indicator - parser.find_mpf_segment().is_some() - } - Err(_) => false, - } -} - -/// Decodes an UltraHDR JPEG, extracting all components. -pub fn decode(data: &[u8]) -> Result { - let parser = JpegParser::parse(data)?; - - // Get image dimensions - let (width, height) = parser.get_dimensions() - .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine image dimensions".to_string()))?; - - // Extract metadata from XMP - let metadata = extract_metadata_from_parser(&parser)?; - - // Find and extract gain map - let (gain_map, gm_width, gm_height) = extract_gain_map(data, &parser)?; - - // Extract SDR base (the primary image without gain map) - let sdr_image = extract_sdr_from_parser(data, &parser)?; - - Ok(UltraHdrDecodeResult::new( - sdr_image, - gain_map, - metadata, - width, - height, - gm_width, - gm_height, - )) -} - -/// Extracts just the SDR base image from an UltraHDR JPEG. -/// -/// Returns a valid JPEG without gain map metadata. -pub fn extract_base(data: &[u8]) -> Result> { - let parser = JpegParser::parse(data)?; - extract_sdr_from_parser(data, &parser) -} - -/// Extracts just the metadata from an UltraHDR JPEG. -pub fn extract_metadata(data: &[u8]) -> Result { - let parser = JpegParser::parse(data)?; - extract_metadata_from_parser(&parser) -} - -/// Extracts gain map metadata from parsed JPEG. -fn extract_metadata_from_parser(parser: &JpegParser) -> Result { - // Find XMP segment - let xmp_segment = parser.find_xmp_segment() - .ok_or(UltraHdrError::NoGainMap)?; - - let xmp_data = xmp_segment.get_xmp_data() - .ok_or_else(|| UltraHdrError::XmpError("Invalid XMP segment".to_string()))?; - - if !XmpParser::has_gain_map_metadata(xmp_data) { - return Err(UltraHdrError::NoGainMap); - } - - XmpParser::parse(xmp_data) -} - -/// Extracts the SDR base image as clean JPEG. -fn extract_sdr_from_parser(data: &[u8], _parser: &JpegParser) -> Result> { - // Find where the gain map starts (after primary image EOI) - // The primary image ends at the first EOI marker - let eoi_offset = find_primary_eoi_offset(data)?; - - // Return data up to and including the first EOI - Ok(data[..eoi_offset + 2].to_vec()) -} - -/// Extracts the gain map JPEG from an UltraHDR image. -fn extract_gain_map(data: &[u8], parser: &JpegParser) -> Result<(Vec, u32, u32)> { - // Method 1: Try MPF segment - if let Some(mpf_segment) = parser.find_mpf_segment() { - if let Some((offset, size)) = parse_mpf_for_gainmap(&mpf_segment.data) { - let offset = offset as usize; - let size = size as usize; - - if offset + size <= data.len() { - let gain_map_jpeg = data[offset..offset + size].to_vec(); - let (gm_width, gm_height) = get_jpeg_dimensions(&gain_map_jpeg)?; - return Ok((gain_map_jpeg, gm_width, gm_height)); - } - } - } - - // Method 2: Look for second JPEG after primary image EOI - let eoi_offset = find_primary_eoi_offset(data)?; - let remaining = &data[eoi_offset + 2..]; - - if remaining.len() >= 2 && remaining[0] == 0xFF && remaining[1] == 0xD8 { - // Found another JPEG - this is the gain map - let gain_map_jpeg = remaining.to_vec(); - let (gm_width, gm_height) = get_jpeg_dimensions(&gain_map_jpeg)?; - return Ok((gain_map_jpeg, gm_width, gm_height)); - } - - Err(UltraHdrError::NoGainMap) -} - -/// Finds the offset of the primary image's EOI marker. -fn find_primary_eoi_offset(data: &[u8]) -> Result { - // Skip the initial SOI - let mut pos = 2; - - while pos < data.len() - 1 { - if data[pos] == 0xFF { - let marker = data[pos + 1]; - - // Skip padding FF bytes - if marker == 0xFF { - pos += 1; - continue; - } - - // EOI marker - if marker == 0xD9 { - return Ok(pos); - } - - // SOS marker - scan through entropy data - if marker == 0xDA { - // Skip SOS header - if pos + 3 >= data.len() { - break; - } - let len = u16::from_be_bytes([data[pos + 2], data[pos + 3]]) as usize; - pos += 2 + len; - - // Scan through entropy-coded data - while pos < data.len() - 1 { - if data[pos] == 0xFF { - let next = data[pos + 1]; - if next == 0x00 { - // Stuffed byte - pos += 2; - } else if next == 0xD9 { - // EOI - return Ok(pos); - } else if next >= 0xD0 && next <= 0xD7 { - // Restart marker - pos += 2; - } else if next != 0xFF { - // Another marker - shouldn't happen in valid JPEG - break; - } else { - pos += 1; - } - } else { - pos += 1; - } - } - } - - // Other marker with length - if marker != 0xD8 && marker != 0xD9 && !(marker >= 0xD0 && marker <= 0xD7) { - if pos + 3 >= data.len() { - break; - } - let len = u16::from_be_bytes([data[pos + 2], data[pos + 3]]) as usize; - pos += 2 + len; - } else { - pos += 2; - } - } else { - pos += 1; - } - } - - Err(UltraHdrError::InvalidJpeg("Could not find EOI marker".to_string())) -} - -/// Parses MPF segment data to find gain map offset and size. -fn parse_mpf_for_gainmap(mpf_data: &[u8]) -> Option<(u32, u32)> { - // Skip "MPF\0" header - if mpf_data.len() < 4 || &mpf_data[0..4] != b"MPF\0" { - return None; - } - - let data = &mpf_data[4..]; - if data.len() < 8 { - return None; - } - - // Determine byte order - let little_endian = data[0] == b'I' && data[1] == b'I'; - - // Read helper - let read_u16 = |offset: usize| -> Option { - if offset + 2 > data.len() { - return None; - } - Some(if little_endian { - u16::from_le_bytes([data[offset], data[offset + 1]]) - } else { - u16::from_be_bytes([data[offset], data[offset + 1]]) - }) - }; - - let read_u32 = |offset: usize| -> Option { - if offset + 4 > data.len() { - return None; - } - Some(if little_endian { - u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) - } else { - u32::from_be_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) - }) - }; - - // Skip to first IFD (offset at byte 4-7 in TIFF header) - let ifd_offset = read_u32(4)? as usize; - if ifd_offset >= data.len() { - return None; - } - - // Read number of entries - let entry_count = read_u16(ifd_offset)?; - - // Look for MPEntry tag (0xB002) - let mut mp_entry_offset: Option = None; - let mut mp_entry_count: Option = None; - - for i in 0..entry_count { - let entry_start = ifd_offset + 2 + (i as usize * 12); - if entry_start + 12 > data.len() { - break; - } - - let tag = read_u16(entry_start)?; - - if tag == 0xB002 { - // MPEntry - mp_entry_count = Some(read_u32(entry_start + 4)?); - mp_entry_offset = Some(read_u32(entry_start + 8)? as usize); - break; - } - } - - // Parse MP entries to find gain map (second image) - let entry_offset = mp_entry_offset?; - let count = mp_entry_count? / 16; // 16 bytes per entry - - if count >= 2 { - // Second entry is the gain map - let second_entry_offset = entry_offset + 16; - if second_entry_offset + 16 <= data.len() { - // Entry format: 4 bytes flags, 4 bytes size, 4 bytes offset, 4 bytes dependent - let size = read_u32(second_entry_offset + 4)?; - let offset = read_u32(second_entry_offset + 8)?; - return Some((offset, size)); - } - } - - None -} - -/// Gets dimensions from a JPEG. -fn get_jpeg_dimensions(jpeg_data: &[u8]) -> Result<(u32, u32)> { - let parser = JpegParser::parse(jpeg_data)?; - parser.get_dimensions() - .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine gain map dimensions".to_string())) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_has_gainmap_metadata_non_jpeg() { - assert!(!has_gainmap_metadata(&[0x89, 0x50, 0x4E, 0x47])); // PNG - assert!(!has_gainmap_metadata(&[])); - assert!(!has_gainmap_metadata(&[0xFF])); - } - - #[test] - fn test_has_gainmap_metadata_regular_jpeg() { - // Minimal JPEG without gain map - let minimal_jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; - assert!(!has_gainmap_metadata(&minimal_jpeg)); - } - - #[test] - fn test_find_eoi_minimal_jpeg() { - let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; - let result = find_primary_eoi_offset(&jpeg); - assert!(result.is_ok()); - assert_eq!(result.unwrap(), 2); - } - - #[test] - fn test_parse_mpf_invalid() { - assert!(parse_mpf_for_gainmap(&[]).is_none()); - assert!(parse_mpf_for_gainmap(b"NOTMPF").is_none()); - } -} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs b/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs deleted file mode 100644 index f56ecfc74c8e7f..00000000000000 --- a/packages/ultrahdr-wasm/src/ultrahdr/encoder.rs +++ /dev/null @@ -1,255 +0,0 @@ -//! UltraHDR JPEG encoder. -//! -//! Creates UltraHDR JPEG files from SDR + HDR image pairs. - -use crate::error::{Result, UltraHdrError}; -use crate::types::{GainMapMetadata, UltraHdrEncodeOptions}; -use crate::gainmap::encode::compute_gain_map; -use crate::jpeg::parser::JpegParser; -use crate::jpeg::writer::JpegWriter; -use crate::jpeg::xmp::XmpWriter; -use image::{ImageBuffer, Luma}; -use std::io::Cursor; - -/// Encodes an UltraHDR JPEG from SDR and HDR image data. -/// -/// # Arguments -/// * `sdr_jpeg` - SDR JPEG image bytes -/// * `hdr_linear` - HDR linear RGB data (3 floats per pixel, normalized to [0,1]) -/// * `options` - Encoding options -/// -/// # Returns -/// The encoded UltraHDR JPEG as bytes. -pub fn encode( - sdr_jpeg: &[u8], - hdr_linear: &[f32], - options: &UltraHdrEncodeOptions, -) -> Result> { - // Validate options - validate_options(options)?; - - // Parse the SDR JPEG to get segments and dimensions - let parser = JpegParser::parse(sdr_jpeg)?; - let (width, height) = parser.get_dimensions() - .ok_or_else(|| UltraHdrError::InvalidJpeg("Cannot determine image dimensions".to_string()))?; - - // Validate dimensions - if width % 2 != 0 { - return Err(UltraHdrError::InvalidDimensions( - format!("Width must be even, got {}", width) - )); - } - if height % 2 != 0 { - return Err(UltraHdrError::InvalidDimensions( - format!("Height must be even, got {}", height) - )); - } - - // Decode SDR JPEG to get raw RGB data - let sdr_rgb = decode_jpeg_to_rgb(sdr_jpeg)?; - let expected_size = (width * height * 3) as usize; - if sdr_rgb.len() != expected_size { - return Err(UltraHdrError::InvalidDimensions(format!( - "SDR RGB size {} doesn't match dimensions {}x{}", - sdr_rgb.len(), width, height - ))); - } - - // Validate HDR data size - if hdr_linear.len() != expected_size { - return Err(UltraHdrError::DimensionMismatch( - width, height, - (hdr_linear.len() / 3) as u32 / height, height - )); - } - - // Compute gain map - let (gain_map_data, metadata) = compute_gain_map( - &sdr_rgb, - hdr_linear, - width, - height, - options.target_hdr_capacity, - options.gain_map_scale, - )?; - - // Calculate gain map dimensions - let scale = options.gain_map_scale.max(1) as u32; - let gm_width = (width + scale - 1) / scale; - let gm_height = (height + scale - 1) / scale; - - // Encode gain map as JPEG - let gain_map_jpeg = encode_gain_map_jpeg(&gain_map_data, gm_width, gm_height, options.gain_map_quality)?; - - // Create the final UltraHDR JPEG - create_ultrahdr_jpeg( - sdr_jpeg, - &gain_map_jpeg, - &metadata, - options, - ) -} - -/// Encodes an UltraHDR JPEG from already-computed components. -/// -/// Useful when you have pre-computed gain map data. -pub fn encode_from_components( - sdr_jpeg: &[u8], - gain_map_jpeg: &[u8], - metadata: &GainMapMetadata, - options: &UltraHdrEncodeOptions, -) -> Result> { - create_ultrahdr_jpeg(sdr_jpeg, gain_map_jpeg, metadata, options) -} - -/// Validates encoding options. -fn validate_options(options: &UltraHdrEncodeOptions) -> Result<()> { - if options.base_quality == 0 || options.base_quality > 100 { - return Err(UltraHdrError::InvalidQuality(options.base_quality)); - } - if options.gain_map_quality == 0 || options.gain_map_quality > 100 { - return Err(UltraHdrError::InvalidQuality(options.gain_map_quality)); - } - if options.target_hdr_capacity <= 0.0 { - return Err(UltraHdrError::InvalidHdrCapacity(0.0, options.target_hdr_capacity)); - } - Ok(()) -} - -/// Decodes a JPEG to raw RGB bytes. -fn decode_jpeg_to_rgb(jpeg_data: &[u8]) -> Result> { - let img = image::load_from_memory_with_format(jpeg_data, image::ImageFormat::Jpeg)?; - let rgb = img.to_rgb8(); - Ok(rgb.into_raw()) -} - -/// Encodes a grayscale gain map as JPEG. -fn encode_gain_map_jpeg(data: &[u8], width: u32, height: u32, quality: u8) -> Result> { - let img: ImageBuffer, Vec> = ImageBuffer::from_raw(width, height, data.to_vec()) - .ok_or_else(|| UltraHdrError::EncodeError("Failed to create gain map image".to_string()))?; - - let mut output = Cursor::new(Vec::new()); - let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut output, quality); - encoder.encode( - img.as_raw(), - width, - height, - image::ExtendedColorType::L8, - )?; - - Ok(output.into_inner()) -} - -/// Creates the final UltraHDR JPEG by combining SDR base with gain map. -fn create_ultrahdr_jpeg( - sdr_jpeg: &[u8], - gain_map_jpeg: &[u8], - metadata: &GainMapMetadata, - options: &UltraHdrEncodeOptions, -) -> Result> { - // Parse the SDR JPEG - let parser = JpegParser::parse(sdr_jpeg)?; - - // Create writer with existing segments - let mut writer = JpegWriter::new( - parser.segments().to_vec(), - parser.scan_data().to_vec(), - ); - - // Remove any existing XMP/MPF segments - writer.remove_xmp_segments(); - writer.remove_mpf_segments(); - - // Create and add XMP metadata - let xmp_data = if options.include_ultrahdr_v1 { - XmpWriter::create_combined_xmp(metadata)? - } else if options.include_iso_metadata { - XmpWriter::create_iso_xmp(metadata)? - } else { - return Err(UltraHdrError::MetadataError( - "At least one metadata format must be enabled".to_string() - )); - }; - - writer.add_xmp_segment(&xmp_data)?; - - // Write base JPEG first to calculate gain map offset - let base_jpeg = writer.write()?; - let gain_map_offset = base_jpeg.len() as u32; - - // Add MPF segment pointing to gain map - // Need to re-parse and re-write with MPF included - let parser2 = JpegParser::parse(&base_jpeg)?; - let mut writer2 = JpegWriter::new( - parser2.segments().to_vec(), - parser2.scan_data().to_vec(), - ); - - // Recalculate offset after adding MPF (MPF segment is ~100 bytes) - let estimated_mpf_size = 120; - let final_gain_map_offset = gain_map_offset + estimated_mpf_size; - - writer2.add_mpf_segment(final_gain_map_offset, gain_map_jpeg.len() as u32)?; - - // Write final output with gain map appended - writer2.write_with_gain_map(gain_map_jpeg) -} - -/// Re-encodes an SDR JPEG with specified quality. -pub fn reencode_jpeg(jpeg_data: &[u8], quality: u8) -> Result> { - let img = image::load_from_memory_with_format(jpeg_data, image::ImageFormat::Jpeg)?; - let rgb = img.to_rgb8(); - - let mut output = Cursor::new(Vec::new()); - let mut encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut output, quality); - encoder.encode( - rgb.as_raw(), - rgb.width(), - rgb.height(), - image::ExtendedColorType::Rgb8, - )?; - - Ok(output.into_inner()) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_validate_options_valid() { - let options = UltraHdrEncodeOptions::default(); - assert!(validate_options(&options).is_ok()); - } - - #[test] - fn test_validate_options_invalid_quality() { - let mut options = UltraHdrEncodeOptions::default(); - options.base_quality = 0; - assert!(validate_options(&options).is_err()); - - options.base_quality = 101; - assert!(validate_options(&options).is_err()); - } - - #[test] - fn test_validate_options_invalid_capacity() { - let mut options = UltraHdrEncodeOptions::default(); - options.target_hdr_capacity = -1.0; - assert!(validate_options(&options).is_err()); - } - - #[test] - fn test_encode_gain_map_jpeg() { - // Create a simple 2x2 gain map - let data = vec![0u8, 64, 128, 255]; - let result = encode_gain_map_jpeg(&data, 2, 2, 75); - assert!(result.is_ok()); - - let jpeg = result.unwrap(); - // Should be valid JPEG (starts with magic bytes) - assert!(jpeg.len() >= 2); - assert_eq!(jpeg[0], 0xFF); - assert_eq!(jpeg[1], 0xD8); - } -} diff --git a/packages/ultrahdr-wasm/src/ultrahdr/mod.rs b/packages/ultrahdr-wasm/src/ultrahdr/mod.rs deleted file mode 100644 index a8095f026ea1f9..00000000000000 --- a/packages/ultrahdr-wasm/src/ultrahdr/mod.rs +++ /dev/null @@ -1,10 +0,0 @@ -//! UltraHDR format handling. -//! -//! Implements encoding and decoding of UltraHDR JPEG images according to -//! ISO 21496-1 and Google's UltraHDR v1 specification. - -pub mod encoder; -pub mod decoder; - -pub use encoder::encode; -pub use decoder::{decode, has_gainmap_metadata, extract_base, extract_metadata}; diff --git a/packages/ultrahdr-wasm/tests/integration_tests.rs b/packages/ultrahdr-wasm/tests/integration_tests.rs deleted file mode 100644 index 87e3e5e2a5b168..00000000000000 --- a/packages/ultrahdr-wasm/tests/integration_tests.rs +++ /dev/null @@ -1,358 +0,0 @@ -//! Integration tests for UltraHDR WASM library. -//! -//! These tests verify the complete encode/decode workflow. - -use wordpress_ultrahdr::*; - -/// Test that encoding options can be created and validated. -#[test] -fn test_encode_options() { - let default_opts = UltraHdrEncodeOptions::new(); - assert_eq!(default_opts.base_quality, 85); - assert_eq!(default_opts.gain_map_quality, 75); - assert_eq!(default_opts.target_hdr_capacity, 3.0); - assert!(default_opts.include_iso_metadata); - assert!(default_opts.include_ultrahdr_v1); - - let hq_opts = UltraHdrEncodeOptions::high_quality(); - assert_eq!(hq_opts.base_quality, 95); - assert_eq!(hq_opts.target_hdr_capacity, 4.0); - - let small_opts = UltraHdrEncodeOptions::small_size(); - assert_eq!(small_opts.gain_map_scale, 2); -} - -/// Test that default metadata can be created and validated. -#[test] -fn test_default_metadata() { - let metadata = GainMapMetadata::new(); - assert_eq!(metadata.version, "1.0"); - assert!(!metadata.base_rendition_is_hdr); - assert_eq!(metadata.gain_map_min.len(), 3); - assert_eq!(metadata.gain_map_max.len(), 3); - assert_eq!(metadata.gamma.len(), 3); - assert_eq!(metadata.offset_sdr.len(), 3); - assert_eq!(metadata.offset_hdr.len(), 3); - - assert!(gainmap::metadata::validate_metadata(&metadata).is_ok()); -} - -/// Test SDR base metadata creation. -#[test] -fn test_sdr_base_metadata() { - let metadata = GainMapMetadata::for_sdr_base(4.0); - assert!(!metadata.base_rendition_is_hdr); - assert_eq!(metadata.hdr_capacity_max, 4.0); - assert_eq!(metadata.gain_map_max, vec![4.0, 4.0, 4.0]); -} - -/// Test metadata validation catches errors. -#[test] -fn test_metadata_validation() { - // Valid metadata should pass - let valid = GainMapMetadata::default(); - assert!(gainmap::metadata::validate_metadata(&valid).is_ok()); - - // Invalid channel count - let mut invalid = GainMapMetadata::default(); - invalid.gain_map_min = vec![0.0, 0.0]; // Only 2 values - assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); - - // Invalid gain range (min > max) - let mut invalid = GainMapMetadata::default(); - invalid.gain_map_min = vec![5.0, 5.0, 5.0]; - invalid.gain_map_max = vec![3.0, 3.0, 3.0]; - assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); - - // Invalid gamma (negative) - let mut invalid = GainMapMetadata::default(); - invalid.gamma = vec![1.0, -1.0, 1.0]; - assert!(gainmap::metadata::validate_metadata(&invalid).is_err()); -} - -/// Test HDR headroom estimation. -#[test] -fn test_hdr_headroom_estimation() { - let metadata = GainMapMetadata { - gain_map_max: vec![3.0, 3.0, 3.0], - ..Default::default() - }; - assert_eq!(gainmap::metadata::estimate_hdr_headroom(&metadata), 3.0); - - let low_hdr = GainMapMetadata { - gain_map_max: vec![0.2, 0.2, 0.2], - ..Default::default() - }; - assert!(!gainmap::metadata::is_meaningful_hdr(&low_hdr)); - - let high_hdr = GainMapMetadata { - gain_map_max: vec![3.0, 3.0, 3.0], - ..Default::default() - }; - assert!(gainmap::metadata::is_meaningful_hdr(&high_hdr)); -} - -/// Test color space math roundtrips. -mod color_math_tests { - use wordpress_ultrahdr::gainmap::math::*; - - const TOLERANCE: f32 = 1e-5; - - fn approx_eq(a: f32, b: f32) -> bool { - (a - b).abs() < TOLERANCE - } - - #[test] - fn test_srgb_roundtrip() { - for i in 0..=10 { - let linear = i as f32 / 10.0; - let srgb = srgb_oetf(linear); - let back = srgb_inverse_oetf(srgb); - assert!(approx_eq(linear, back), "sRGB roundtrip failed at {}", linear); - } - } - - #[test] - fn test_pq_roundtrip() { - // PQ uses complex power functions with large exponents, so allow slightly larger tolerance - const PQ_TOLERANCE: f32 = 1e-4; - for i in 0..=10 { - let linear = i as f32 / 10.0; - let pq = pq_oetf(linear); - let back = pq_inverse_oetf(pq); - assert!((linear - back).abs() < PQ_TOLERANCE, "PQ roundtrip failed at {}", linear); - } - } - - #[test] - fn test_hlg_roundtrip() { - for i in 0..=10 { - let linear = i as f32 / 10.0; - let hlg = hlg_oetf(linear); - let back = hlg_inverse_oetf(hlg); - assert!(approx_eq(linear, back), "HLG roundtrip failed at {}", linear); - } - } - - #[test] - fn test_luminance_values() { - // Black should have 0 luminance - assert_eq!(luminance_bt709(0.0, 0.0, 0.0), 0.0); - - // White should have ~1.0 luminance - let white_luma = luminance_bt709(1.0, 1.0, 1.0); - assert!(approx_eq(white_luma, 1.0)); - - // Red, green, blue should sum to 1.0 - let r_luma = luminance_bt709(1.0, 0.0, 0.0); - let g_luma = luminance_bt709(0.0, 1.0, 0.0); - let b_luma = luminance_bt709(0.0, 0.0, 1.0); - assert!(approx_eq(r_luma + g_luma + b_luma, 1.0)); - } - - #[test] - fn test_gain_encode_decode() { - let ratios = [0.5, 1.0, 2.0, 4.0, 8.0]; - let min_gain = -1.0; - let max_gain = 3.0; - let gamma = 1.0; - - for &ratio in &ratios { - let encoded = encode_gain(ratio, min_gain, max_gain, gamma); - let decoded = decode_gain(encoded, min_gain, max_gain, gamma); - assert!(approx_eq(ratio, decoded), "Gain roundtrip failed at {}", ratio); - } - } - - #[test] - fn test_hdr_weight() { - // Full SDR - assert_eq!(compute_hdr_weight(0.0, 0.0, 3.0), 0.0); - // Full HDR - assert_eq!(compute_hdr_weight(3.0, 0.0, 3.0), 1.0); - // Mid point - assert!(approx_eq(compute_hdr_weight(1.5, 0.0, 3.0), 0.5)); - } -} - -/// Test XMP parsing and writing. -mod xmp_tests { - use wordpress_ultrahdr::jpeg::xmp::{XmpParser, XmpWriter}; - use wordpress_ultrahdr::GainMapMetadata; - - #[test] - fn test_xmp_roundtrip() { - let original = GainMapMetadata { - version: "1.0".to_string(), - base_rendition_is_hdr: false, - gain_map_min: vec![-1.0, -1.0, -1.0], - gain_map_max: vec![3.0, 3.0, 3.0], - gamma: vec![1.0, 1.0, 1.0], - offset_sdr: vec![0.015625, 0.015625, 0.015625], - offset_hdr: vec![0.015625, 0.015625, 0.015625], - hdr_capacity_min: 1.0, - hdr_capacity_max: 4.0, - }; - - let xmp = XmpWriter::create_iso_xmp(&original).unwrap(); - let parsed = XmpParser::parse(&xmp).unwrap(); - - assert_eq!(original.version, parsed.version); - assert_eq!(original.base_rendition_is_hdr, parsed.base_rendition_is_hdr); - assert_eq!(original.hdr_capacity_max, parsed.hdr_capacity_max); - } - - #[test] - fn test_has_gain_map_metadata() { - let xmp_with = b""; - let xmp_without = b""; - - assert!(XmpParser::has_gain_map_metadata(xmp_with)); - assert!(!XmpParser::has_gain_map_metadata(xmp_without)); - } -} - -/// Test JPEG parsing. -mod jpeg_tests { - use wordpress_ultrahdr::jpeg::parser::{JpegParser, MarkerType}; - - #[test] - fn test_minimal_jpeg() { - let jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; - let parser = JpegParser::parse(&jpeg).unwrap(); - assert_eq!(parser.segments().len(), 2); - assert_eq!(parser.segments()[0].marker, MarkerType::Soi); - assert_eq!(parser.segments()[1].marker, MarkerType::Eoi); - } - - #[test] - fn test_invalid_jpeg() { - let not_jpeg = vec![0x89, 0x50, 0x4E, 0x47]; // PNG magic - assert!(JpegParser::parse(¬_jpeg).is_err()); - } - - #[test] - fn test_marker_type_conversion() { - assert_eq!(MarkerType::from_byte(0xD8), MarkerType::Soi); - assert_eq!(MarkerType::from_byte(0xD9), MarkerType::Eoi); - assert_eq!(MarkerType::from_byte(0xE1), MarkerType::App1); - assert_eq!(MarkerType::from_byte(0xE2), MarkerType::App2); - assert_eq!(MarkerType::App1.to_byte(), 0xE1); - } -} - -/// Test UltraHDR detection. -mod detection_tests { - use wordpress_ultrahdr::ultrahdr; - - #[test] - fn test_non_jpeg_detection() { - assert!(!ultrahdr::has_gainmap_metadata(&[])); - assert!(!ultrahdr::has_gainmap_metadata(&[0x89, 0x50, 0x4E, 0x47])); // PNG - assert!(!ultrahdr::has_gainmap_metadata(&[0xFF])); // Truncated - } - - #[test] - fn test_regular_jpeg_detection() { - let minimal_jpeg = vec![0xFF, 0xD8, 0xFF, 0xD9]; - assert!(!ultrahdr::has_gainmap_metadata(&minimal_jpeg)); - } -} - -/// Test gain map computation. -mod gainmap_tests { - use wordpress_ultrahdr::gainmap::encode::compute_gain_map; - - #[test] - fn test_compute_gain_map_basic() { - let width = 4u32; - let height = 4u32; - - // Mid-gray SDR image - let sdr = vec![128u8; (width * height * 3) as usize]; - - // Slightly brighter HDR image (linear) - let hdr = vec![0.3f32; (width * height * 3) as usize]; - - let result = compute_gain_map(&sdr, &hdr, width, height, 3.0, 1); - assert!(result.is_ok()); - - let (gain_map, metadata) = result.unwrap(); - assert_eq!(gain_map.len(), (width * height) as usize); - assert_eq!(metadata.version, "1.0"); - assert!(!metadata.base_rendition_is_hdr); - } - - #[test] - fn test_compute_gain_map_with_scale() { - let width = 8u32; - let height = 8u32; - - let sdr = vec![128u8; (width * height * 3) as usize]; - let hdr = vec![0.3f32; (width * height * 3) as usize]; - - // Scale factor 2 should give 4x4 gain map - let (gain_map, _) = compute_gain_map(&sdr, &hdr, width, height, 3.0, 2).unwrap(); - assert_eq!(gain_map.len(), 16); // 4x4 - } - - #[test] - fn test_compute_gain_map_invalid_size() { - let sdr = vec![128u8; 12]; // 2x2x3 - let hdr = vec![0.3f32; 6]; // Wrong size - - let result = compute_gain_map(&sdr, &hdr, 2, 2, 3.0, 1); - assert!(result.is_err()); - } -} - -/// Test gain map application. -mod gainmap_apply_tests { - use wordpress_ultrahdr::gainmap::decode::apply_gain_map; - use wordpress_ultrahdr::GainMapMetadata; - - #[test] - fn test_apply_gain_map_basic() { - let width = 2u32; - let height = 2u32; - - // Mid-gray SDR image - let sdr = vec![128u8; 12]; - - // Neutral gain map (128 = ~1.0x gain) - let gain_map = vec![128u8; 4]; - - let metadata = GainMapMetadata::default(); - - let result = apply_gain_map( - &sdr, &gain_map, &metadata, - width, height, width, height, - 3.0 - ); - - assert!(result.is_ok()); - let hdr = result.unwrap(); - assert_eq!(hdr.len(), 12); // 2x2x3 floats - } - - #[test] - fn test_apply_gain_map_different_sizes() { - let width = 4u32; - let height = 4u32; - let gm_width = 2u32; - let gm_height = 2u32; - - let sdr = vec![128u8; 48]; // 4x4x3 - let gain_map = vec![128u8; 4]; // 2x2 - - let metadata = GainMapMetadata::default(); - - let result = apply_gain_map( - &sdr, &gain_map, &metadata, - width, height, gm_width, gm_height, - 3.0 - ); - - assert!(result.is_ok()); - } -} diff --git a/packages/ultrahdr/.gitignore b/packages/ultrahdr/.gitignore deleted file mode 100644 index 37856c18f7a1d5..00000000000000 --- a/packages/ultrahdr/.gitignore +++ /dev/null @@ -1,4 +0,0 @@ -# Build artifacts -/build/ -/build-module/ -/build-types/ diff --git a/packages/ultrahdr/README.md b/packages/ultrahdr/README.md deleted file mode 100644 index d1be53a8cf10f3..00000000000000 --- a/packages/ultrahdr/README.md +++ /dev/null @@ -1,139 +0,0 @@ -# UltraHDR - -TypeScript bindings for UltraHDR (ISO 21496-1) gain map support in WordPress Gutenberg. - -## Installation - -```bash -npm install @wordpress/ultrahdr -``` - -## Usage - -```typescript -import { - setLocation, - isUltraHdr, - decodeUltraHdr, - extractSdrBase, - encodeUltraHdr, - defaultEncodeOptions -} from '@wordpress/ultrahdr'; - -// Set the location for WASM files (required before other calls) -setLocation('/path/to/wasm/'); - -// Check if an image is UltraHDR -const buffer = await file.arrayBuffer(); -if (await isUltraHdr(buffer)) { - console.log('This is an UltraHDR image!'); - - // Decode to get components - const result = await decodeUltraHdr('item-1', buffer); - console.log('Image size:', result.width, 'x', result.height); - console.log('HDR headroom:', result.metadata.hdrCapacityMax, 'stops'); - - // Extract just the SDR base for backwards compatibility - const sdrBuffer = await extractSdrBase(buffer); - const sdrBlob = new Blob([sdrBuffer], { type: 'image/jpeg' }); -} - -// Create UltraHDR from SDR + HDR inputs -const sdrBuffer = await sdrFile.arrayBuffer(); -const hdrLinearData = await getHdrLinearData(); // Float32Array - -const ultraHdr = await encodeUltraHdr('encode-1', sdrBuffer, hdrLinearData, { - ...defaultEncodeOptions, - targetHdrCapacity: 4.0, -}); -``` - -## API Reference - -### `setLocation(path: string): void` - -Sets the location/public path for loading WASM files. Must be called before using any other functions. - -### `isUltraHdr(buffer: ArrayBuffer): Promise` - -Checks if a buffer contains an UltraHDR image. Fast check that looks for gain map metadata without fully decoding. - -### `decodeUltraHdr(id: ItemId, buffer: ArrayBuffer): Promise` - -Decodes an UltraHDR image, extracting all components: -- `sdrImage`: The SDR base image as JPEG bytes -- `gainMap`: The gain map as JPEG bytes -- `metadata`: Gain map metadata -- `width`, `height`: Image dimensions -- `gainMapWidth`, `gainMapHeight`: Gain map dimensions - -### `encodeUltraHdr(id: ItemId, sdrBuffer: ArrayBuffer, hdrBuffer: ArrayBuffer, options?: Partial): Promise` - -Encodes an UltraHDR JPEG from SDR and HDR inputs. - -### `extractSdrBase(buffer: ArrayBuffer): Promise` - -Extracts the SDR base image from an UltraHDR JPEG. Returns a standard JPEG that can be displayed on any device. - -### `getMetadata(buffer: ArrayBuffer): Promise` - -Gets gain map metadata from an UltraHDR JPEG without full decode. - -### `validateMetadata(metadata: GainMapMetadata): Promise` - -Validates gain map metadata. - -### `estimateHdrHeadroom(metadata: GainMapMetadata): Promise` - -Estimates the HDR headroom (additional stops of dynamic range) from metadata. - -### `isMeaningfulHdr(metadata: GainMapMetadata): Promise` - -Checks if metadata indicates a meaningful HDR image (>0.5 stops headroom). - -## Types - -### `GainMapMetadata` - -```typescript -interface GainMapMetadata { - version: string; - baseRenditionIsHdr: boolean; - gainMapMin: number[]; - gainMapMax: number[]; - gamma: number[]; - offsetSdr: number[]; - offsetHdr: number[]; - hdrCapacityMin: number; - hdrCapacityMax: number; -} -``` - -### `UltraHdrEncodeOptions` - -```typescript -interface UltraHdrEncodeOptions { - baseQuality: number; // 1-100 - gainMapQuality: number; // 1-100 - targetHdrCapacity: number; // typically 2.0-4.0 - includeIsoMetadata: boolean; - includeUltrahdrV1: boolean; - gainMapScale: number; // 1, 2, or 4 -} -``` - -## Predefined Options - -- `defaultEncodeOptions` - Balanced quality/size -- `highQualityEncodeOptions` - Maximum quality -- `smallSizeEncodeOptions` - Smaller file size - -## Standards - -This package implements: -- [ISO 21496-1:2025](https://www.iso.org/standard/86775.html) - Gain map metadata -- [Google UltraHDR v1](https://developer.android.com/media/platform/hdr-image-format) - Android compatibility - -## License - -GPL-2.0-or-later diff --git a/packages/ultrahdr/package.json b/packages/ultrahdr/package.json deleted file mode 100644 index 94e796cd01e5f7..00000000000000 --- a/packages/ultrahdr/package.json +++ /dev/null @@ -1,52 +0,0 @@ -{ - "name": "@wordpress/ultrahdr", - "version": "1.0.0-prerelease", - "private": true, - "description": "UltraHDR (ISO 21496-1) gain map support for WordPress Gutenberg.", - "author": "The WordPress Contributors", - "license": "GPL-2.0-or-later", - "keywords": [ - "wordpress", - "media", - "ultrahdr", - "hdr", - "gain-map" - ], - "homepage": "https://github.com/WordPress/gutenberg/tree/HEAD/packages/ultrahdr/README.md", - "repository": { - "type": "git", - "url": "https://github.com/WordPress/gutenberg.git", - "directory": "packages/ultrahdr" - }, - "bugs": { - "url": "https://github.com/WordPress/gutenberg/issues" - }, - "engines": { - "node": ">=18.12.0", - "npm": ">=8.19.2" - }, - "files": [ - "src", - "build", - "build-module", - "build-types", - "*.md" - ], - "main": "build/index.cjs", - "module": "build-module/index.mjs", - "exports": { - ".": { - "types": "./build-types/index.d.ts", - "import": "./build-module/index.mjs", - "default": "./build/index.cjs" - }, - "./package.json": "./package.json" - }, - "types": "build-types", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.1" - }, - "publishConfig": { - "access": "public" - } -} diff --git a/packages/ultrahdr/src/index.ts b/packages/ultrahdr/src/index.ts deleted file mode 100644 index 83d8ae2a43afdb..00000000000000 --- a/packages/ultrahdr/src/index.ts +++ /dev/null @@ -1,324 +0,0 @@ -/** - * WordPress UltraHDR Library - * - * TypeScript bindings for the UltraHDR WASM library. - * Provides detection, encoding, and decoding of UltraHDR JPEG images - * implementing ISO 21496-1 (gain map) specification. - * - * @example - * ```typescript - * import { isUltraHdr, decodeUltraHdr, setLocation } from '@wordpress/ultrahdr'; - * - * // Set the location for WASM files - * setLocation('/path/to/wasm/'); - * - * // Check if an image is UltraHDR - * const buffer = await file.arrayBuffer(); - * if (await isUltraHdr(buffer)) { - * const result = await decodeUltraHdr('item-1', buffer); - * console.log('HDR headroom:', result.metadata.hdrCapacityMax); - * } - * ``` - */ - -// Re-export types -export type { - ItemId, - GainMapMetadata, - UltraHdrDecodeResult, - UltraHdrEncodeOptions, -} from './types'; - -export { - ColorGamut, - TransferFunction, - defaultEncodeOptions, - highQualityEncodeOptions, - smallSizeEncodeOptions, -} from './types'; - -import type { - ItemId, - GainMapMetadata, - UltraHdrDecodeResult, - UltraHdrEncodeOptions, -} from './types'; - -import { defaultEncodeOptions } from './types'; - -// WASM module type (these come from the generated WASM bindings) -interface UltraHdrWasmModule { - default: ( moduleOrPath?: string | URL | Response ) => Promise< unknown >; - isUltraHdr: ( buffer: Uint8Array ) => boolean; - decodeUltraHdr: ( buffer: Uint8Array ) => UltraHdrDecodeResult; - encodeUltraHdr: ( - sdrBuffer: Uint8Array, - hdrBuffer: Float32Array, - options: UltraHdrEncodeOptions - ) => Uint8Array; - extractSdrBase: ( buffer: Uint8Array ) => Uint8Array; - getMetadata: ( buffer: Uint8Array ) => GainMapMetadata; - createDefaultOptions: () => UltraHdrEncodeOptions; - createHighQualityOptions: () => UltraHdrEncodeOptions; - createSmallSizeOptions: () => UltraHdrEncodeOptions; - createDefaultMetadata: () => GainMapMetadata; - validateMetadata: ( metadata: GainMapMetadata ) => boolean; - estimateHdrHeadroom: ( metadata: GainMapMetadata ) => number; - isMeaningfulHdr: ( metadata: GainMapMetadata ) => boolean; -} - -/** - * Location prefix for WASM files. - * Set this before calling any other functions. - */ -let location = ''; - -/** - * Cached WASM module instance. - */ -let wasmInstance: UltraHdrWasmModule | null = null; - -/** - * Promise for ongoing WASM initialization. - */ -let initPromise: Promise< UltraHdrWasmModule > | null = null; - -/** - * Sets the location/public path for loading WASM files. - * - * This must be called before using any other functions when the WASM - * files are not in the same directory as the JavaScript bundle. - * - * @param newLocation - Base URL or path where WASM files are located. - * - * @example - * ```typescript - * // Set location before any other calls - * setLocation('/wp-content/plugins/gutenberg/build/'); - * ``` - */ -export function setLocation( newLocation: string ): void { - location = newLocation; -} - -/** - * Gets the WASM module, initializing it if necessary. - */ -async function getWasm(): Promise< UltraHdrWasmModule > { - if ( wasmInstance ) { - return wasmInstance; - } - - if ( initPromise ) { - return initPromise; - } - - initPromise = ( async () => { - // Dynamic import of the WASM package - const UltraHdrWasm = ( await import( - 'open-ultrahdr-wasm' - ) ) as unknown as UltraHdrWasmModule; - - // Initialize WASM with the location prefix for the .wasm file - // If location is set, construct the full URL to the WASM file - if ( location ) { - const wasmUrl = location + 'open_ultrahdr_bg.wasm'; - await UltraHdrWasm.default( wasmUrl ); - } else { - // Let the WASM module use its default URL resolution (import.meta.url) - await UltraHdrWasm.default(); - } - - wasmInstance = UltraHdrWasm as unknown as UltraHdrWasmModule; - return wasmInstance; - } )(); - - return initPromise; -} - -/** - * Checks if a buffer contains an UltraHDR image. - * - * This is a fast check that looks for gain map metadata without - * fully decoding the image. - * - * @param buffer - JPEG file contents. - * @return True if the image contains UltraHDR/gain map data. - * - * @example - * ```typescript - * const buffer = await file.arrayBuffer(); - * if (await isUltraHdr(buffer)) { - * console.log('This is an UltraHDR image!'); - * } - * ``` - */ -export async function isUltraHdr( buffer: ArrayBuffer ): Promise< boolean > { - const wasm = await getWasm(); - return wasm.isUltraHdr( new Uint8Array( buffer ) ); -} - -/** - * Decodes an UltraHDR image, extracting all components. - * - * @param id - Unique identifier for this operation (for cancellation). - * @param buffer - UltraHDR JPEG file contents. - * @return Decoded result with SDR image, gain map, and metadata. - * - * @throws Error if the buffer is not a valid UltraHDR JPEG. - * - * @example - * ```typescript - * const buffer = await file.arrayBuffer(); - * const result = await decodeUltraHdr('upload-1', buffer); - * - * // Access components - * const sdrBlob = new Blob([result.sdrImage], { type: 'image/jpeg' }); - * console.log('Image size:', result.width, 'x', result.height); - * console.log('HDR capacity:', result.metadata.hdrCapacityMax); - * ``` - */ -export async function decodeUltraHdr( - id: ItemId, - buffer: ArrayBuffer -): Promise< UltraHdrDecodeResult > { - const wasm = await getWasm(); - return wasm.decodeUltraHdr( new Uint8Array( buffer ) ); -} - -/** - * Encodes an UltraHDR JPEG from SDR and HDR inputs. - * - * @param id - Unique identifier for this operation. - * @param sdrBuffer - SDR JPEG image bytes. - * @param hdrBuffer - HDR linear RGB data (Float32Array, 3 values per pixel). - * @param options - Encoding options. - * @return Encoded UltraHDR JPEG as ArrayBuffer. - * - * @throws Error if inputs are invalid or dimensions don't match. - * - * @example - * ```typescript - * const sdrBuffer = await sdrFile.arrayBuffer(); - * const hdrData = await getHdrLinearData(); // Float32Array - * - * const ultraHdr = await encodeUltraHdr('encode-1', sdrBuffer, hdrData, { - * ...defaultEncodeOptions, - * targetHdrCapacity: 4.0, - * }); - * - * // Create downloadable file - * const blob = new Blob([ultraHdr], { type: 'image/jpeg' }); - * ``` - */ -export async function encodeUltraHdr( - id: ItemId, - sdrBuffer: ArrayBuffer, - hdrBuffer: ArrayBuffer, - options?: Partial< UltraHdrEncodeOptions > -): Promise< ArrayBuffer > { - const wasm = await getWasm(); - const opts = { - ...defaultEncodeOptions, - ...options, - } as UltraHdrEncodeOptions; - - const result = wasm.encodeUltraHdr( - new Uint8Array( sdrBuffer ), - new Float32Array( hdrBuffer ), - opts - ); - - // Ensure we return a proper ArrayBuffer (not SharedArrayBuffer) - return result.buffer.slice( 0 ) as ArrayBuffer; -} - -/** - * Extracts the SDR base image from an UltraHDR JPEG. - * - * This produces a standard JPEG that can be displayed on any device, - * without the gain map metadata. Useful for backwards compatibility. - * - * @param buffer - UltraHDR JPEG file contents. - * @return Standard JPEG without gain map. - * - * @example - * ```typescript - * const ultraHdrBuffer = await file.arrayBuffer(); - * const sdrBuffer = await extractSdrBase(ultraHdrBuffer); - * - * // Use the SDR image for non-HDR displays - * const blob = new Blob([sdrBuffer], { type: 'image/jpeg' }); - * ``` - */ -export async function extractSdrBase( - buffer: ArrayBuffer -): Promise< ArrayBuffer > { - const wasm = await getWasm(); - const result = wasm.extractSdrBase( new Uint8Array( buffer ) ); - // Ensure we return a proper ArrayBuffer (not SharedArrayBuffer) - return result.buffer.slice( 0 ) as ArrayBuffer; -} - -/** - * Gets gain map metadata from an UltraHDR JPEG. - * - * This is faster than `decodeUltraHdr` when you only need the metadata. - * - * @param buffer - UltraHDR JPEG file contents. - * @return Gain map metadata. - * - * @throws Error if the buffer doesn't contain gain map metadata. - * - * @example - * ```typescript - * const metadata = await getMetadata(buffer); - * console.log('Version:', metadata.version); - * console.log('HDR headroom:', metadata.hdrCapacityMax, 'stops'); - * ``` - */ -export async function getMetadata( - buffer: ArrayBuffer -): Promise< GainMapMetadata > { - const wasm = await getWasm(); - return wasm.getMetadata( new Uint8Array( buffer ) ); -} - -/** - * Validates gain map metadata. - * - * @param metadata - The metadata to validate. - * @return True if the metadata is valid. - */ -export async function validateMetadata( - metadata: GainMapMetadata -): Promise< boolean > { - const wasm = await getWasm(); - return wasm.validateMetadata( metadata ); -} - -/** - * Estimates the HDR headroom from metadata. - * - * @param metadata - The gain map metadata. - * @return Maximum additional stops of dynamic range above SDR. - */ -export async function estimateHdrHeadroom( - metadata: GainMapMetadata -): Promise< number > { - const wasm = await getWasm(); - return wasm.estimateHdrHeadroom( metadata ); -} - -/** - * Checks if metadata indicates a meaningful HDR image. - * - * @param metadata - The gain map metadata. - * @return True if the gain map provides significant dynamic range extension. - */ -export async function isMeaningfulHdr( - metadata: GainMapMetadata -): Promise< boolean > { - const wasm = await getWasm(); - return wasm.isMeaningfulHdr( metadata ); -} diff --git a/packages/ultrahdr/src/types.ts b/packages/ultrahdr/src/types.ts deleted file mode 100644 index f3a04b5be8eb14..00000000000000 --- a/packages/ultrahdr/src/types.ts +++ /dev/null @@ -1,150 +0,0 @@ -/** - * Unique identifier for an item being processed. - */ -export type ItemId = string; - -/** - * ISO 21496-1 Gain Map Metadata. - * - * Contains all the metadata required to interpret and apply a gain map - * according to the ISO 21496-1 specification. - */ -export interface GainMapMetadata { - /** Specification version (e.g., "1.0") */ - version: string; - - /** Whether the base rendition is HDR (false = SDR base, true = HDR base) */ - baseRenditionIsHdr: boolean; - - /** Minimum gain value per channel (RGB), in log2 scale */ - gainMapMin: number[]; - - /** Maximum gain value per channel (RGB), in log2 scale */ - gainMapMax: number[]; - - /** Gamma correction per channel (RGB) */ - gamma: number[]; - - /** SDR offset per channel (RGB), used for black point adjustment */ - offsetSdr: number[]; - - /** HDR offset per channel (RGB), used for black point adjustment */ - offsetHdr: number[]; - - /** Minimum HDR capacity (log2 scale) where gain map starts to apply */ - hdrCapacityMin: number; - - /** Maximum HDR capacity (log2 scale) for full HDR output */ - hdrCapacityMax: number; -} - -/** - * Result of decoding an UltraHDR image. - */ -export interface UltraHdrDecodeResult { - /** The SDR base image as JPEG bytes */ - sdrImage: Uint8Array; - - /** The gain map as JPEG bytes */ - gainMap: Uint8Array; - - /** Gain map metadata */ - metadata: GainMapMetadata; - - /** Image width in pixels */ - width: number; - - /** Image height in pixels */ - height: number; - - /** Gain map width in pixels (may differ from image width) */ - gainMapWidth: number; - - /** Gain map height in pixels (may differ from image height) */ - gainMapHeight: number; -} - -/** - * Options for encoding UltraHDR images. - */ -export interface UltraHdrEncodeOptions { - /** JPEG quality for the base image (1-100) */ - baseQuality: number; - - /** JPEG quality for the gain map (1-100) */ - gainMapQuality: number; - - /** Target HDR capacity (typically 2.0-4.0) */ - targetHdrCapacity: number; - - /** Whether to include ISO 21496-1 metadata */ - includeIsoMetadata: boolean; - - /** Whether to include UltraHDR v1 metadata for Android compatibility */ - includeUltrahdrV1: boolean; - - /** Downscale factor for the gain map (1 = same size, 2 = half, 4 = quarter) */ - gainMapScale: number; -} - -/** - * Color gamut enumeration for HDR images. - */ -export enum ColorGamut { - /** Standard sRGB color space (BT.709 primaries) */ - Srgb = 0, - /** Display P3 wide color gamut */ - DisplayP3 = 1, - /** BT.2100/BT.2020 wide color gamut (HDR) */ - Bt2100 = 2, -} - -/** - * Transfer function for encoding luminance. - */ -export enum TransferFunction { - /** sRGB transfer function (gamma ~2.2) */ - Srgb = 0, - /** Linear (no gamma) */ - Linear = 1, - /** Perceptual Quantizer (PQ) - SMPTE ST 2084 */ - Pq = 2, - /** Hybrid Log-Gamma (HLG) - BT.2100 */ - Hlg = 3, -} - -/** - * Default encoding options. - */ -export const defaultEncodeOptions: UltraHdrEncodeOptions = { - baseQuality: 85, - gainMapQuality: 75, - targetHdrCapacity: 3.0, - includeIsoMetadata: true, - includeUltrahdrV1: true, - gainMapScale: 1, -}; - -/** - * High quality encoding options. - */ -export const highQualityEncodeOptions: UltraHdrEncodeOptions = { - baseQuality: 95, - gainMapQuality: 85, - targetHdrCapacity: 4.0, - includeIsoMetadata: true, - includeUltrahdrV1: true, - gainMapScale: 1, -}; - -/** - * Small size encoding options. - */ -export const smallSizeEncodeOptions: UltraHdrEncodeOptions = { - baseQuality: 75, - gainMapQuality: 65, - targetHdrCapacity: 3.0, - includeIsoMetadata: true, - includeUltrahdrV1: true, - gainMapScale: 2, -}; diff --git a/packages/ultrahdr/tsconfig.json b/packages/ultrahdr/tsconfig.json deleted file mode 100644 index 7ff060ab6ce105..00000000000000 --- a/packages/ultrahdr/tsconfig.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "$schema": "https://json.schemastore.org/tsconfig.json", - "extends": "../../tsconfig.base.json" -} diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index 5aede4a22ce5e7..b031779630d901 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -56,9 +56,9 @@ "@wordpress/i18n": "file:../i18n", "@wordpress/preferences": "file:../preferences", "@wordpress/private-apis": "file:../private-apis", - "@wordpress/ultrahdr": "file:../ultrahdr", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", + "open-ultrahdr": "^0.1.0", "uuid": "^9.0.1" }, "peerDependencies": { diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 3a806a28b62e06..6b04049846a669 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -818,7 +818,7 @@ export function detectUltraHdr( id: QueueItemId ) { try { // Dynamically import to avoid loading WASM unless needed - const { isUltraHdr } = await import( '@wordpress/ultrahdr' ); + const { isUltraHdr } = await import( 'open-ultrahdr' ); const buffer = await item.file.arrayBuffer(); if ( await isUltraHdr( buffer ) ) { @@ -855,7 +855,7 @@ export function extractSdrItem( id: QueueItemId ) { } try { - const { extractSdrBase } = await import( '@wordpress/ultrahdr' ); + const { extractSdrBase } = await import( 'open-ultrahdr' ); const buffer = await item.file.arrayBuffer(); const sdrBuffer = await extractSdrBase( buffer ); diff --git a/tsconfig.json b/tsconfig.json index 2fe0ecc3d5ae25..7489ddc31c0bf7 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -73,7 +73,6 @@ { "path": "packages/token-list" }, { "path": "packages/ui" }, { "path": "packages/undo-manager" }, - { "path": "packages/ultrahdr" }, { "path": "packages/upload-media" }, { "path": "packages/url" }, { "path": "packages/views" }, From 6ed5fca8469de556ab93bb1d74b0c0f9d267975f Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 22 Jan 2026 13:35:30 -0800 Subject: [PATCH 04/33] Fix TypeScript error: Add meta property to Attachment interface The Attachment interface in upload-media was missing the `meta` property that exists in the media-utils package. This caused TypeScript errors when trying to use the meta field for UltraHDR metadata storage. Co-Authored-By: Claude Opus 4.5 --- packages/upload-media/src/store/types.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index 98d91a5f6c3e90..5262f1f54e742e 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -199,6 +199,11 @@ export interface Attachment { featured_media?: number; missing_image_sizes?: string[]; poster?: string; + meta?: + | [] + | { + [ k: string ]: unknown; + }; /** * EXIF orientation value from the original image. * Values 1-8 follow the EXIF specification. From e724e528a99692d33f4a8d1dfce92b1fc2730dbc Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Tue, 17 Mar 2026 15:27:57 -0700 Subject: [PATCH 05/33] UltraHDR: Use probeUltraHdr, upload originals unmodified Switch from isUltraHdr() to probeUltraHdr() for richer probe results including hdrCapacity. Upload UltraHDR JPEGs unmodified since they already embed a backwards-compatible SDR base that non-HDR displays can use. Remove ExtractSdr operation and the console.warn for non-UltraHDR JPEGs (per reviewer feedback). --- package-lock.json | 44 +++++----- packages/upload-media/package.json | 2 +- .../upload-media/src/store/private-actions.ts | 88 +++++-------------- packages/upload-media/src/store/types.ts | 1 - 4 files changed, 44 insertions(+), 91 deletions(-) diff --git a/package-lock.json b/package-lock.json index 7de5b7797d8c9f..9797e55bf0b008 100644 --- a/package-lock.json +++ b/package-lock.json @@ -42768,27 +42768,6 @@ "node": ">=8" } }, - "node_modules/open-ultrahdr": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.0.tgz", - "integrity": "sha512-fbrqu28YTRtPu6j+kY/JKqg3cddyxPWvYRqYqVuRchAs1F2QrtvwW/WIqTjhP021k8o4XkDMLy0/tu6OTQUE2w==", - "license": "GPL-2.0-or-later", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.1" - }, - "engines": { - "node": ">=18.0.0" - } - }, - "node_modules/open-ultrahdr-wasm": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.1.tgz", - "integrity": "sha512-y/OmK8QW2FN0SuTKGoIZtMI1p4A3YaqHuIM8491tdCWN+LX1Qmc4VI8A4QVv6RkBI+H2J3MNsw/Rx0SH/PdcAw==", - "license": "GPL-2.0-or-later", - "engines": { - "node": ">=18.0.0" - } - }, "node_modules/opencv-bindings": { "version": "4.5.5", "resolved": "https://registry.npmjs.org/opencv-bindings/-/opencv-bindings-4.5.5.tgz", @@ -62620,7 +62599,7 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "^0.1.0", + "open-ultrahdr": "^0.1.1", "uuid": "^9.0.1" }, "engines": { @@ -62632,6 +62611,27 @@ "react-dom": "^18.0.0" } }, + "packages/upload-media/node_modules/open-ultrahdr": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.1.tgz", + "integrity": "sha512-Q6WZZc9A114u1QGgblp0VamDE16hV+Br94+1ydkB8zSGx9SZ4CBK5ctVUUx2xILyN7i9+RfTsrtZtLUQ7oaByw==", + "license": "GPL-2.0-or-later", + "dependencies": { + "open-ultrahdr-wasm": "^0.1.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "packages/upload-media/node_modules/open-ultrahdr-wasm": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.2.tgz", + "integrity": "sha512-gqz/KZk5l6zpwcqaHF4Sc0u66xOmaa6nKPJCpXKj3yb84mJbwZF2SSu6OatocaiqsdvX2Fjiai+voEz8Oos1zg==", + "license": "GPL-2.0-or-later", + "engines": { + "node": ">=18.0.0" + } + }, "packages/url": { "name": "@wordpress/url", "version": "4.41.0", diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index b031779630d901..b4348b7db889ed 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -58,7 +58,7 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "^0.1.0", + "open-ultrahdr": "^0.1.1", "uuid": "^9.0.1" }, "peerDependencies": { diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 6b04049846a669..a4755349bd5c3a 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -77,7 +77,6 @@ type ActionCreators = { updateItemProgress: typeof updateItemProgress; revokeBlobUrls: typeof revokeBlobUrls; detectUltraHdr: typeof detectUltraHdr; - extractSdrItem: typeof extractSdrItem; < T = Record< string, unknown > >( args: T ): void; }; @@ -473,10 +472,6 @@ export function processItem( id: QueueItemId ) { case OperationType.DetectUltraHdr: dispatch.detectUltraHdr( id ); break; - - case OperationType.ExtractSdr: - dispatch.extractSdrItem( id ); - break; } }; } @@ -728,8 +723,8 @@ export async function getTranscodeImageOperation( * Or videos need to be compressed, and then need poster generation * before upload. * - * UltraHDR JPEG images will have their SDR base extracted for - * backwards compatibility. + * UltraHDR JPEG images are detected and uploaded unmodified — they are + * already backwards compatible (SDR displays use the embedded base image). * * @param id Item ID. */ @@ -805,7 +800,7 @@ export function prepareItem( id: QueueItemId ) { } /** - * Detects if a JPEG is an UltraHDR image and queues SDR extraction if needed. + * Detects if a JPEG is an UltraHDR image and stores probe metadata. * * @param id Item ID. */ @@ -818,75 +813,34 @@ export function detectUltraHdr( id: QueueItemId ) { try { // Dynamically import to avoid loading WASM unless needed - const { isUltraHdr } = await import( 'open-ultrahdr' ); + const { probeUltraHdr } = await import( 'open-ultrahdr' ); const buffer = await item.file.arrayBuffer(); + const result = await probeUltraHdr( buffer ); - if ( await isUltraHdr( buffer ) ) { - // Add SDR extraction operation before upload - dispatch< AddOperationsAction >( { - type: Type.AddOperations, - id, - operations: [ OperationType.ExtractSdr ], + if ( result.isValid ) { + // Mark attachment metadata with UltraHDR info. + // The original file is uploaded unmodified — UltraHDR JPEGs are + // already backwards compatible (SDR displays use the embedded base image). + dispatch.finishOperation( id, { + attachment: { + ...item.attachment, + meta: { + ...( item.attachment?.meta || {} ), + ultrahdr: true, + hdr_capacity: result.hdrCapacity, + }, + }, } ); + return; } - } catch ( error ) { - // If UltraHDR detection fails, continue with regular upload - // eslint-disable-next-line no-console - console.warn( 'UltraHDR detection failed:', error ); + } catch { + // If UltraHDR detection fails, continue with regular upload. } dispatch.finishOperation( id, {} ); }; } -/** - * Extracts the SDR base from an UltraHDR JPEG. - * - * This creates a backwards-compatible JPEG that can be displayed - * on non-HDR displays while preserving the original UltraHDR file. - * - * @param id Item ID. - */ -export function extractSdrItem( id: QueueItemId ) { - return async ( { select, dispatch }: ThunkArgs ) => { - const item = select.getItem( id ); - if ( ! item ) { - return; - } - - try { - const { extractSdrBase } = await import( 'open-ultrahdr' ); - const buffer = await item.file.arrayBuffer(); - const sdrBuffer = await extractSdrBase( buffer ); - - // Create a new file with the SDR base - // Keep original as sourceFile, use SDR for upload - const sdrBlob = new Blob( [ sdrBuffer ], { type: 'image/jpeg' } ); - const sdrFile = new File( [ sdrBlob ], item.file.name, { - type: 'image/jpeg', - } ); - - // Update item with SDR file while keeping original as source - dispatch.finishOperation( id, { - file: sdrFile, - attachment: { - ...item.attachment, - // Mark as having HDR variant available - meta: { - ...( item.attachment?.meta || {} ), - ultrahdr_original: true, - }, - }, - } ); - } catch ( error ) { - // If extraction fails, continue with original file - // eslint-disable-next-line no-console - console.warn( 'UltraHDR SDR extraction failed:', error ); - dispatch.finishOperation( id, {} ); - } - }; -} - /** * Uploads an item to the server. * diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index 5262f1f54e742e..1d2d6a92693981 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -245,7 +245,6 @@ export enum OperationType { Finalize = 'FINALIZE', // UltraHDR operations DetectUltraHdr = 'DETECT_ULTRAHDR', - ExtractSdr = 'EXTRACT_SDR', CreateUltraHdr = 'CREATE_ULTRAHDR', } From cae597eb2d1b5a673447f4855ebde8673ce222f1 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Tue, 17 Mar 2026 16:46:15 -0700 Subject: [PATCH 06/33] Fix package-lock.json: preserve esbuild version pinning from trunk --- package-lock.json | 6362 +++++++++++++++++++++------------------------ 1 file changed, 3024 insertions(+), 3338 deletions(-) diff --git a/package-lock.json b/package-lock.json index 9797e55bf0b008..9f7f32cc410df4 100644 --- a/package-lock.json +++ b/package-lock.json @@ -14,6 +14,9 @@ "routes/*", "storybook" ], + "dependencies": { + "open-ultrahdr": "0.1.1" + }, "devDependencies": { "@apidevtools/json-schema-ref-parser": "11.6.4", "@babel/core": "7.25.7", @@ -1339,17 +1342,69 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@arraypress/waveform-player": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@arraypress/waveform-player/-/waveform-player-1.2.1.tgz", - "integrity": "sha512-PsgOZStUN+1GnY0tujbwk2PYE3HMT/Vl3wEvunqH16hIJWzisf8GEngy5EbswTAjQ1aV3Tk4XBkAskc8eslY1A==", + "node_modules/@ariakit/core": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", + "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", + "license": "MIT" + }, + "node_modules/@ariakit/react": { + "version": "0.4.21", + "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.21.tgz", + "integrity": "sha512-UjP99Y7cWxA5seRECEE0RPZFImkLGFIWPflp65t0BVZwlMw4wp9OJZRHMrnkEkKl5KBE2NR/gbbzwHc6VNGzsA==", "license": "MIT", - "engines": { - "node": ">=14.0.0" + "dependencies": { + "@ariakit/react-core": "0.4.21" }, "funding": { - "type": "github", - "url": "https://github.com/sponsors/arraypress" + "type": "opencollective", + "url": "https://opencollective.com/ariakit" + }, + "peerDependencies": { + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/@ariakit/react-core": { + "version": "0.4.21", + "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.21.tgz", + "integrity": "sha512-rUI9uB/gT3mROFja/ka7/JukkdljIZR3eq3BGiQqX4Ni/KBMDvPK8FvVLnC0TGzWcqNY2bbfve8QllvHzuw4fQ==", + "license": "MIT", + "dependencies": { + "@ariakit/core": "0.4.18", + "@floating-ui/dom": "^1.0.0", + "use-sync-external-store": "^1.2.0" + }, + "peerDependencies": { + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/@ariakit/test": { + "version": "0.4.13", + "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", + "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@ariakit/core": "0.4.18", + "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" + }, + "peerDependencies": { + "@playwright/test": "^1.27.0", + "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@playwright/test": { + "optional": true + }, + "@testing-library/react": { + "optional": true + }, + "react": { + "optional": true + } } }, "node_modules/@asamuzakjp/css-color": { @@ -1380,9 +1435,9 @@ } }, "node_modules/@babel/code-frame": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", - "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.28.6.tgz", + "integrity": "sha512-JYgintcMjRiCvS8mMECzaEn+m3PfoQiyqukOMCCVQtoJGYJw8j/8LBJEiqkHLkfwCcs74E3pbAUFNg7d9VNJ+Q==", "license": "MIT", "dependencies": { "@babel/helper-validator-identifier": "^7.28.5", @@ -1446,13 +1501,13 @@ } }, "node_modules/@babel/generator": { - "version": "7.29.1", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", - "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.6.tgz", + "integrity": "sha512-lOoVRwADj8hjf7al89tvQ2a1lf53Z+7tiXMgpZJL3maQPDxh0DgLMN62B2MKUOFcoodBHLMbDM6WAbKgNy5Suw==", "license": "MIT", "dependencies": { - "@babel/parser": "^7.29.0", - "@babel/types": "^7.29.0", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6", "@jridgewell/gen-mapping": "^0.3.12", "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" @@ -2041,12 +2096,12 @@ } }, "node_modules/@babel/parser": { - "version": "7.29.2", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", - "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.6.tgz", + "integrity": "sha512-TeR9zWR18BvbfPmGbLampPMW+uW1NZnJlRuuHso8i87QZNq2JRF9i6RgxRqtEq+wQGsS19NNTWr2duhnE49mfQ==", "license": "MIT", "dependencies": { - "@babel/types": "^7.29.0" + "@babel/types": "^7.28.6" }, "bin": { "parser": "bin/babel-parser.js" @@ -3934,9 +3989,9 @@ } }, "node_modules/@babel/runtime": { - "version": "7.28.4", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz", - "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.6.tgz", + "integrity": "sha512-05WQkdpL9COIMz4LjTxGpPNCdlpyimKppYNoJ5Di5EUObifl8t4tuLuUBBZEpoLYOmfvIWrsp9fCl0HoPRVTdA==", "license": "MIT", "engines": { "node": ">=6.9.0" @@ -4001,9 +4056,9 @@ } }, "node_modules/@babel/types": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", - "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.6.tgz", + "integrity": "sha512-0ZrskXVEHSWIqZM/sQZ4EV3jZJXRkio/WCxaqKZP1g//CEWEPSfeZFcms4XeKBCHU0ZKnIkdJeU/kF+eRp5lBg==", "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.27.1", @@ -4013,6 +4068,72 @@ "node": ">=6.9.0" } }, + "node_modules/@base-ui/react": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@base-ui/react/-/react-1.2.0.tgz", + "integrity": "sha512-O6aEQHcm+QyGTFY28xuwRD3SEJGZOBDpyjN2WvpfWYFVhg+3zfXPysAILqtM0C1kWC82MccOE/v1j+GHXE4qIw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.28.6", + "@base-ui/utils": "0.2.5", + "@floating-ui/react-dom": "^2.1.6", + "@floating-ui/utils": "^0.2.10", + "tabbable": "^6.4.0", + "use-sync-external-store": "^1.6.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@types/react": "^17 || ^18 || ^19", + "react": "^17 || ^18 || ^19", + "react-dom": "^17 || ^18 || ^19" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@base-ui/react/node_modules/@floating-ui/react-dom": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.6.tgz", + "integrity": "sha512-4JX6rEatQEvlmgU80wZyq9RT96HZJa88q8hp0pBd+LrczeDI4o6uA2M+uvxngVHo4Ihr8uibXxH6+70zhAFrVw==", + "license": "MIT", + "dependencies": { + "@floating-ui/dom": "^1.7.4" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/@base-ui/utils": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/@base-ui/utils/-/utils-0.2.5.tgz", + "integrity": "sha512-oYC7w0gp76RI5MxprlGLV0wze0SErZaRl3AAkeP3OnNB/UBMb6RqNf6ZSIlxOc9Qp68Ab3C2VOcJQyRs7Xc7Vw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.28.6", + "@floating-ui/utils": "^0.2.10", + "reselect": "^5.1.1", + "use-sync-external-store": "^1.6.0" + }, + "peerDependencies": { + "@types/react": "^17 || ^18 || ^19", + "react": "^17 || ^18 || ^19", + "react-dom": "^17 || ^18 || ^19" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, "node_modules/@bcoe/v8-coverage": { "version": "0.2.3", "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", @@ -4369,6 +4490,7 @@ "version": "4.0.0", "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "license": "MIT", "engines": { "node": ">=10" }, @@ -4380,6 +4502,7 @@ "version": "0.5.7", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", + "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } @@ -5833,9 +5956,9 @@ } }, "node_modules/@jest/diff-sequences": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.3.0.tgz", - "integrity": "sha512-cG51MVnLq1ecVUaQ3fr6YuuAOitHK1S4WUJHnsPFE/quQr33ADUx1FfrTCpMCRxvy0Yr9BThKpDjSlcTi91tMA==", + "version": "30.0.1", + "resolved": "https://registry.npmjs.org/@jest/diff-sequences/-/diff-sequences-30.0.1.tgz", + "integrity": "sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==", "dev": true, "license": "MIT", "engines": { @@ -6284,13 +6407,13 @@ } }, "node_modules/@jest/snapshot-utils": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.3.0.tgz", - "integrity": "sha512-ORbRN9sf5PP82v3FXNSwmO1OTDR2vzR2YTaR+E3VkSBZ8zadQE6IqYdYEeFH1NIkeB2HIGdF02dapb6K0Mj05g==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/snapshot-utils/-/snapshot-utils-30.2.0.tgz", + "integrity": "sha512-0aVxM3RH6DaiLcjj/b0KrIBZhSX1373Xci4l3cW5xiUWPctZ59zQ7jj4rqcJQ/Z8JuN/4wX3FpJSa3RssVvCug==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", "natural-compare": "^1.4.0" @@ -6313,9 +6436,9 @@ } }, "node_modules/@jest/snapshot-utils/node_modules/@jest/types": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", - "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", + "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", "dev": true, "license": "MIT", "dependencies": { @@ -6477,6 +6600,120 @@ "node": "^14.15.0 || ^16.10.0 || >=18.0.0" } }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", + "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", + "dev": true, + "license": "MIT", + "dependencies": { + "glob": "^13.0.1", + "react-docgen-typescript": "^2.2.2" + }, + "peerDependencies": { + "typescript": ">= 4.3.x", + "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/balanced-match": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", + "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", + "dev": true, + "license": "MIT", + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/brace-expansion": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", + "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^4.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/glob": { + "version": "13.0.6", + "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", + "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "minimatch": "^10.2.2", + "minipass": "^7.1.3", + "path-scurry": "^2.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/lru-cache": { + "version": "11.2.6", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.6.tgz", + "integrity": "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": "20 || >=22" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/minimatch": { + "version": "10.2.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", + "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "brace-expansion": "^5.0.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/minipass": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", + "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", + "dev": true, + "license": "BlueOak-1.0.0", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/@joshwooding/vite-plugin-react-docgen-typescript/node_modules/path-scurry": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", + "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", + "dev": true, + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^11.0.0", + "minipass": "^7.1.2" + }, + "engines": { + "node": "18 || 20 || >=22" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/@jridgewell/gen-mapping": { "version": "0.3.13", "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", @@ -7623,6 +7860,18 @@ "node": ">=8.0.0" } }, + "node_modules/@noble/hashes": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.4.0.tgz", + "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==", + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", @@ -10342,25 +10591,176 @@ "integrity": "sha512-KxWFdRNbv13U8bhYaQvH6gLG9CVEt2jKeosyOOYILVntWEVWhovbgDrbOiZ12pJO3vjZs0Zgbd3/Zgde98woEA==", "license": "BSD-3-Clause" }, + "node_modules/@peculiar/asn1-cms": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.6.1.tgz", + "integrity": "sha512-vdG4fBF6Lkirkcl53q6eOdn3XYKt+kJTG59edgRZORlg/3atWWEReRCx5rYE1ZzTTX6vLK5zDMjHh7vbrcXGtw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "@peculiar/asn1-x509-attr": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-csr": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.6.1.tgz", + "integrity": "sha512-WRWnKfIocHyzFYQTka8O/tXCiBquAPSrRjXbOkHbO4qdmS6loffCEGs+rby6WxxGdJCuunnhS2duHURhjyio6w==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-ecc": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.6.1.tgz", + "integrity": "sha512-+Vqw8WFxrtDIN5ehUdvlN2m73exS2JVG0UAyfVB31gIfor3zWEAQPD+K9ydCxaj3MLen9k0JhKpu9LqviuCE1g==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pfx": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.6.1.tgz", + "integrity": "sha512-nB5jVQy3MAAWvq0KY0R2JUZG8bO/bTLpnwyOzXyEh/e54ynGTatAR+csOnXkkVD9AFZ2uL8Z7EV918+qB1qDvw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.1", + "@peculiar/asn1-pkcs8": "^2.6.1", + "@peculiar/asn1-rsa": "^2.6.1", + "@peculiar/asn1-schema": "^2.6.0", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pkcs8": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.6.1.tgz", + "integrity": "sha512-JB5iQ9Izn5yGMw3ZG4Nw3Xn/hb/G38GYF3lf7WmJb8JZUydhVGEjK/ZlFSWhnlB7K/4oqEs8HnfFIKklhR58Tw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-pkcs9": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.6.1.tgz", + "integrity": "sha512-5EV8nZoMSxeWmcxWmmcolg22ojZRgJg+Y9MX2fnE2bGRo5KQLqV5IL9kdSQDZxlHz95tHvIq9F//bvL1OeNILw==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.1", + "@peculiar/asn1-pfx": "^2.6.1", + "@peculiar/asn1-pkcs8": "^2.6.1", + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "@peculiar/asn1-x509-attr": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-rsa": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.6.1.tgz", + "integrity": "sha512-1nVMEh46SElUt5CB3RUTV4EG/z7iYc7EoaDY5ECwganibQPkZ/Y2eMsTKB/LeyrUJ+W/tKoD9WUqIy8vB+CEdA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-schema": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.6.0.tgz", + "integrity": "sha512-xNLYLBFTBKkCzEZIw842BxytQQATQv+lDTCEMZ8C196iJcJJMBUZxrhSTxLaohMyKK8QlzRNTRkUmanucnDSqg==", + "license": "MIT", + "dependencies": { + "asn1js": "^3.0.6", + "pvtsutils": "^1.3.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-x509": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.6.1.tgz", + "integrity": "sha512-O9jT5F1A2+t3r7C4VT7LYGXqkGLK7Kj1xFpz7U0isPrubwU5PbDoyYtx6MiGst29yq7pXN5vZbQFKRCP+lLZlA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "asn1js": "^3.0.6", + "pvtsutils": "^1.3.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/asn1-x509-attr": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.6.1.tgz", + "integrity": "sha512-tlW6cxoHwgcQghnJwv3YS+9OO1737zgPogZ+CgWRUK4roEwIPzRH4JEiG770xe5HX2ATfCpmX60gurfWIF9dcQ==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.1", + "asn1js": "^3.0.6", + "tslib": "^2.8.1" + } + }, + "node_modules/@peculiar/x509": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz", + "integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==", + "license": "MIT", + "dependencies": { + "@peculiar/asn1-cms": "^2.6.0", + "@peculiar/asn1-csr": "^2.6.0", + "@peculiar/asn1-ecc": "^2.6.0", + "@peculiar/asn1-pkcs9": "^2.6.0", + "@peculiar/asn1-rsa": "^2.6.0", + "@peculiar/asn1-schema": "^2.6.0", + "@peculiar/asn1-x509": "^2.6.0", + "pvtsutils": "^1.3.6", + "reflect-metadata": "^0.2.2", + "tslib": "^2.8.1", + "tsyringe": "^4.10.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, "node_modules/@php-wasm/cli-util": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/cli-util/-/cli-util-3.1.12.tgz", - "integrity": "sha512-DpOeQotdE4QVF0/ynmC1PawelIIzk6DkLuOZ1oF/+S/kXAyrMp8LoAbDGf4Iii8CordDmIOp+Ab2JTllTvEd2Q==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/cli-util/-/cli-util-3.0.52.tgz", + "integrity": "sha512-znW/+lDWIqlCxe4vhaNuT7Cw3PkTwCFZ0raiivjvYtlHmQc0nSKGMY+8gH3bBkpxEnjXrR0RSmU2UuzQFUM5JA==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/util": "3.1.12", - "fast-xml-parser": "^5.5.1", + "@php-wasm/util": "3.0.52", + "fast-xml-parser": "^5.3.4", "jsonc-parser": "3.3.1" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/cli-util/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "version": "5.3.5", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.5.tgz", + "integrity": "sha512-JeaA2Vm9ffQKp9VjvfzObuMCjUYAp5WDYhRYL5LrBPY/jUDlUtOvDfot0vKSkB9tuX885BDHjtw4fZadD95wnA==", "funding": [ { "type": "github", @@ -10369,8 +10769,6 @@ ], "license": "MIT", "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", "strnum": "^2.1.2" }, "bin": { @@ -10378,9 +10776,9 @@ } }, "node_modules/@php-wasm/cli-util/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.1.2.tgz", + "integrity": "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==", "funding": [ { "type": "github", @@ -10389,173 +10787,537 @@ ], "license": "MIT" }, - "node_modules/@php-wasm/logger": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/logger/-/logger-3.1.12.tgz", - "integrity": "sha512-6isXP5+KDaTB11034XGDtYW7/y+5ZhOODAePHs97k52TIvUQn9T0BfKYR1Zbcvdtuh/jy7i2Q3JYlIHTvxBUEg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@php-wasm/node-polyfills": "3.1.12" - }, - "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" - } - }, - "node_modules/@php-wasm/node": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node/-/node-3.1.12.tgz", - "integrity": "sha512-gOl1VQ+/I39euhU+2GpLsSFDaExdDwAb7INkqMDviXrz7pShAtxG18dezYX7gsKM8Gr0Okdyccv0lE0KsQnGWA==", + "node_modules/@php-wasm/fs-journal": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/fs-journal/-/fs-journal-3.0.52.tgz", + "integrity": "sha512-OaG1VAIvG2c/7IXfM4Q7tSETq116kXsf+EPzqtWev4oNGU/fMlAEDByRmHC7DYI4Da0tT9YwpVYPiByj4zae1g==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/cli-util": "3.1.12", - "@php-wasm/logger": "3.1.12", - "@php-wasm/node-7-4": "3.1.12", - "@php-wasm/node-8-0": "3.1.12", - "@php-wasm/node-8-1": "3.1.12", - "@php-wasm/node-8-2": "3.1.12", - "@php-wasm/node-8-3": "3.1.12", - "@php-wasm/node-8-4": "3.1.12", - "@php-wasm/node-8-5": "3.1.12", - "@php-wasm/node-polyfills": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", - "@wp-playground/common": "3.1.12", + "@php-wasm/logger": "3.0.52", + "@php-wasm/node": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", "ini": "4.1.2", - "jsonc-parser": "3.3.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, - "node_modules/@php-wasm/node-7-4": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-7-4/-/node-7-4-3.1.12.tgz", - "integrity": "sha512-5Sb/b8u6J7Q4iDqm0bF0UHj38xqti7K9Xtzf/j54AwOy4lTDfDbnMlw3QOVSxY2iEOLn7qHDGPZc4dAuFmxVrQ==", - "license": "GPL-2.0-or-later", + "node_modules/@php-wasm/fs-journal/node_modules/body-parser": { + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", + "license": "MIT", "dependencies": { - "@php-wasm/universal": "3.1.12", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" } }, - "node_modules/@php-wasm/node-7-4/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", + "node_modules/@php-wasm/fs-journal/node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": ">= 0.8" } }, - "node_modules/@php-wasm/node-7-4/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "node_modules/@php-wasm/fs-journal/node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", "license": "MIT", "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } + "node": ">= 0.6" } }, - "node_modules/@php-wasm/node-8-0": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-0/-/node-8-0-3.1.12.tgz", - "integrity": "sha512-I1OxJJN5Hh9t81TQ73lbRjAP++Uz7uteilGETRqtPQi/kDa2iweYM+vuwLAp1t5DW3XZw0+O0cq2dTzyW9FXwA==", - "license": "GPL-2.0-or-later", + "node_modules/@php-wasm/fs-journal/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", "dependencies": { - "@php-wasm/universal": "3.1.12", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" - }, - "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "ms": "2.0.0" } }, - "node_modules/@php-wasm/node-8-0/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", + "node_modules/@php-wasm/fs-journal/node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": ">= 0.8" } }, - "node_modules/@php-wasm/node-8-0/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "node_modules/@php-wasm/fs-journal/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", "license": "MIT", "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } + "node": ">= 0.8" } }, - "node_modules/@php-wasm/node-8-1": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-1/-/node-8-1-3.1.12.tgz", - "integrity": "sha512-CYROT4gdgxbnS3vCrogQMz5sqT2rzeSuNdn7wTDV43uGRyLONfj7jkqjlGalIIe2rVhrP1JIRTMW5Ju+N0OMHg==", - "license": "GPL-2.0-or-later", + "node_modules/@php-wasm/fs-journal/node_modules/express": { + "version": "4.22.0", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", + "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", + "license": "MIT", "dependencies": { - "@php-wasm/universal": "3.1.12", - "ini": "4.1.2", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3" + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.3", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.12", + "proxy-addr": "~2.0.7", + "qs": "~6.14.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, - "node_modules/@php-wasm/node-8-1/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", + "node_modules/@php-wasm/fs-journal/node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": ">= 0.8" } }, - "node_modules/@php-wasm/node-8-1/node_modules/ws": { - "version": "8.18.3", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", - "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "node_modules/@php-wasm/fs-journal/node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/@php-wasm/fs-journal/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/@php-wasm/fs-journal/node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/@php-wasm/fs-journal/node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/@php-wasm/fs-journal/node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/fs-journal/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@php-wasm/logger": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/logger/-/logger-3.0.52.tgz", + "integrity": "sha512-9NlGe5sV0SC1Zb6UfuNJ4XO3HT9pr0NKjv5PRAHlaF2yNCJ3T6O+LCGJiaojWjs2nKqw293LMeHEKFEwe+Pfgg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/node-polyfills": "3.0.52" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/node": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node/-/node-3.0.52.tgz", + "integrity": "sha512-V+ds3PtPrzuSCDHnrDahZdTZbGXynLH1SEH+dSny1taF9WDyp/7Gc73s3E/pCn/8iAB6kSut25dpc1gkzmktOQ==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/logger": "3.0.52", + "@php-wasm/node-7-4": "3.0.52", + "@php-wasm/node-8-0": "3.0.52", + "@php-wasm/node-8-1": "3.0.52", + "@php-wasm/node-8-2": "3.0.52", + "@php-wasm/node-8-3": "3.0.52", + "@php-wasm/node-8-4": "3.0.52", + "@php-wasm/node-8-5": "3.0.52", + "@php-wasm/node-polyfills": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@wp-playground/common": "3.0.52", + "express": "4.22.0", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3", + "yargs": "17.7.2" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/node-7-4": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-7-4/-/node-7-4-3.0.52.tgz", + "integrity": "sha512-P30l0/lleRLnhob9p3L3o4h2EDH76Fd9fQ+fFvGH8N3aYaNJysug3lKR6hnbQzTQab/xU2JFFUg5Faw3cJfT1w==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/node-7-4/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/node-7-4/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@php-wasm/node-8-0": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-0/-/node-8-0-3.0.52.tgz", + "integrity": "sha512-sm3zsGyGDLd6+b5/VsMxfHJvaREOlYcqPI7WqyrieQCVAg5IckQzeYdVpbQjMhfiAHRprSqyvEV6bz+iQCFiwg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/node-8-0/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/node-8-0/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@php-wasm/node-8-1": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-1/-/node-8-1-3.0.52.tgz", + "integrity": "sha512-6jnMLEsGH6JNHst52Wv9/UHEL5BJb+IOhMW4cG+OwcaqHb5cXq16j9Ak2djwnGgxOJ6geg2wqr1dVXR6fLeXXw==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/node-8-1/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/node-8-1/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", "license": "MIT", "engines": { "node": ">=10.0.0" @@ -10574,19 +11336,22 @@ } }, "node_modules/@php-wasm/node-8-2": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-2/-/node-8-2-3.1.12.tgz", - "integrity": "sha512-nZuHxpptMlTk58L6dDieAp3RVjtd6VHhtV77KANDGFOxp7l+DCxQ77npS2pX5vW9fzl6h6NTMfa9GezZXV1xnA==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-2/-/node-8-2-3.0.52.tgz", + "integrity": "sha512-fjGd/J2vUApLgQbviCpnqAZ6dxhVy6faBxL3Rg3ZCajH/NASd+Tn+z9GacnLjQms0zlphk/SbFLZdAU2WY6x8A==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.1.12", + "@php-wasm/universal": "3.0.52", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/node-8-2/node_modules/ini": { @@ -10620,19 +11385,22 @@ } }, "node_modules/@php-wasm/node-8-3": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-3/-/node-8-3-3.1.12.tgz", - "integrity": "sha512-PzLKJyvPbBzRfDJ15fyIt8xihpisTM15rp1t4HaPhqa5FYGnrh751pkQYEjurzygqh7M4S2k8U+GUy5OS452UQ==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-3/-/node-8-3-3.0.52.tgz", + "integrity": "sha512-88q2+OoQ0Zq1DVC+LFhc+F/bG9QnoRRDBZUgFSAOV0GB055F+oU9YXbM9du8OSuUDQ1OEVe+L0VM5sgDfDStIw==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.1.12", + "@php-wasm/universal": "3.0.52", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/node-8-3/node_modules/ini": { @@ -10666,19 +11434,22 @@ } }, "node_modules/@php-wasm/node-8-4": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-4/-/node-8-4-3.1.12.tgz", - "integrity": "sha512-52LnvStQ5jm+q8oqyIw0HvDelZkSAIOrArbyO/jUakrLFkUlgvXG8E67uHVsr3x1QUOvFNe2HMTcAdZ5oNLk5A==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-4/-/node-8-4-3.0.52.tgz", + "integrity": "sha512-8B38E1yZQV/8fy9wkQHj23n/uW+2UhZIfcwoBcnRTztONeVKHzPl6rOLBylzJwpg3CXwJ7YJam/MhVkQEfP28g==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.1.12", + "@php-wasm/universal": "3.0.52", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/node-8-4/node_modules/ini": { @@ -10712,19 +11483,22 @@ } }, "node_modules/@php-wasm/node-8-5": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-8-5/-/node-8-5-3.1.12.tgz", - "integrity": "sha512-6KswpSyMXTLinakkHRnVJZ3ft42g+odM4SlZJJ2rFhgQ4uFTLJ6Pz+WEybHGcIwE7e7Z1+2Ip8g8CBDDuVSRXQ==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-8-5/-/node-8-5-3.0.52.tgz", + "integrity": "sha512-4UawC56VhV6m2YHuxsY0e/Je9F7JWAvFppJo3aBGUWEqQsOvD5lmiZZF/DgyfWJacfvimw3/eeqo1U63+G3e5Q==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.1.12", + "@php-wasm/universal": "3.0.52", "ini": "4.1.2", "wasm-feature-detect": "1.8.0", "ws": "8.18.3" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/node-8-5/node_modules/ini": { @@ -10758,10 +11532,13 @@ } }, "node_modules/@php-wasm/node-polyfills": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/node-polyfills/-/node-polyfills-3.1.12.tgz", - "integrity": "sha512-PTIojNH3oKnb63M48kZ3k2L5AirRj5pxlPX6BCET6FIqAzBh/KkFrHJE4enynGYQEiJLsgj43MuY/ZqU0c5nPA==", - "license": "GPL-2.0-or-later" + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/node-polyfills/-/node-polyfills-3.0.52.tgz", + "integrity": "sha512-lMvGe+SHQVROSfAGpX/w8bCQukmBrS21TAOdoMUoFwUmxKwp1Ztfw+oYqm5maBR1jVoporog3F/KomtUcgab5Q==", + "license": "GPL-2.0-or-later", + "optionalDependencies": { + "fs-ext": "2.1.1" + } }, "node_modules/@php-wasm/node/node_modules/body-parser": { "version": "1.20.4", @@ -10878,26 +11655,6 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@php-wasm/node/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", - "strnum": "^2.1.2" - }, - "bin": { - "fxparser": "src/cli/cli.js" - } - }, "node_modules/@php-wasm/node/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -11091,18 +11848,6 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/node/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT" - }, "node_modules/@php-wasm/node/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -11125,55 +11870,67 @@ } }, "node_modules/@php-wasm/progress": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/progress/-/progress-3.1.12.tgz", - "integrity": "sha512-KZBtzod+P3tQ7yDX70ExMbjEfJRG1ENOcR1wh+1TJXqsXjvqx+Vx5PBKrV9zP7x6yQX5mxqEP2YRrcrt9M3H1w==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/progress/-/progress-3.0.52.tgz", + "integrity": "sha512-v41iBYG4nDNWdfQCZDbrn2Tmh0JnPQ1ElFl9kUXX/GExvM8LLXycVOp3O5y3+0i/tXuciJoKWj+9NF/PEuLDvw==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.1.12", - "@php-wasm/node-polyfills": "3.1.12" + "@php-wasm/logger": "3.0.52", + "@php-wasm/node-polyfills": "3.0.52" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/scopes": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/scopes/-/scopes-3.1.12.tgz", - "integrity": "sha512-Y0ZoWGJWAfROlnwGf2N1+WbL1NTa0nXrx+aiceOg5jrh5X1yToESI9hnERh0vrV91RHC7IA3GEKX7XtA/M8AxQ==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/scopes/-/scopes-3.0.52.tgz", + "integrity": "sha512-AMb8RcVqIyqGe2wS7Lp4i3lDwsQlKXkqwarRCxJpgWCUP2CkYELOXTJqrR2SvLUf8HOYO5suH69CvAq+N15zeg==", "license": "GPL-2.0-or-later", "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/stream-compression": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/stream-compression/-/stream-compression-3.1.12.tgz", - "integrity": "sha512-9oNPQ4V81SDfCHDEofK8eA69fd0Bbkl0evGVdDlvJLhOJNhjby2auVdDQwlynPGifeNzLAq05uBSPlT4yu7rDw==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/stream-compression/-/stream-compression-3.0.52.tgz", + "integrity": "sha512-BF4RzHm4kwaAIuL6SZG4V9YxtmDkEHWg4+nOOooM7KEzwc63V6lbujeAq/HwM/mqNBO2J+LW9ZJ+k4yCF7okSg==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/node-polyfills": "3.1.12", - "@php-wasm/util": "3.1.12" + "@php-wasm/node-polyfills": "3.0.52", + "@php-wasm/util": "3.0.52" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/universal": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/universal/-/universal-3.1.12.tgz", - "integrity": "sha512-kL12Pwfn1MeofK/9hT5Ilh5mi5XvM9P3pznAEDYSlaa+7zhQ4t/VkONelokrOEswwW2R1i9fd35E/narLCnLjg==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/universal/-/universal-3.0.52.tgz", + "integrity": "sha512-P88tyWsOjr35MSNOvQPono2bzkuorjXvQ3RFUV6yGHhRZXOMe+dzPcJ7EsJ5AOxxvhvshB4VLwxpyUAcFtj6Ww==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.1.12", - "@php-wasm/node-polyfills": "3.1.12", - "@php-wasm/progress": "3.1.12", - "@php-wasm/stream-compression": "3.1.12", - "@php-wasm/util": "3.1.12", + "@php-wasm/logger": "3.0.52", + "@php-wasm/node-polyfills": "3.0.52", + "@php-wasm/progress": "3.0.52", + "@php-wasm/stream-compression": "3.0.52", + "@php-wasm/util": "3.0.52", "ini": "4.1.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@php-wasm/universal/node_modules/ini": { @@ -11186,30 +11943,70 @@ } }, "node_modules/@php-wasm/util": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/util/-/util-3.1.12.tgz", - "integrity": "sha512-f5LdqCTQGne3MQcu2UJsoG9HBWLmZ8eq+Et6Mdy1ud0K4Y08ssX/ztg8YQIvrxpReCoigrQBVmARObkXB/NdQA==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/util/-/util-3.0.52.tgz", + "integrity": "sha512-82u4Q13IPcL91CusRDy8k9L38zQrqqRO04pnTBJ3uMH1wZy4pAYZ305mKxce1EIU7QqPay/S69VdnWh+K4tOvA==", "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, - "node_modules/@php-wasm/web-service-worker": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/web-service-worker/-/web-service-worker-3.1.12.tgz", - "integrity": "sha512-yOZ48wc9PP3/80hZ8tr7V6DW2Mb11cFflwA1gvH4KFwQ2yB0RgPhVGdLsgVwoAy/lYlDAeW9DHh1f9CqiIBGzg==", + "node_modules/@php-wasm/web": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web/-/web-3.0.52.tgz", + "integrity": "sha512-fjSgAOMo2dX5yknN8nAM6Ctd/sovZGIf6dEQeDzXoJm+dHlop6AMUa7FSj4/KXyENim6xcDRpAgf5yMcGiRyFw==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/scopes": "3.1.12", - "@php-wasm/universal": "3.1.12", - "ini": "4.1.2" + "@php-wasm/fs-journal": "3.0.52", + "@php-wasm/logger": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@php-wasm/web-7-4": "3.0.52", + "@php-wasm/web-8-0": "3.0.52", + "@php-wasm/web-8-1": "3.0.52", + "@php-wasm/web-8-2": "3.0.52", + "@php-wasm/web-8-3": "3.0.52", + "@php-wasm/web-8-4": "3.0.52", + "@php-wasm/web-8-5": "3.0.52", + "@php-wasm/web-service-worker": "3.0.52", + "@wp-playground/common": "3.0.52", + "express": "4.22.0", + "ini": "4.1.2", + "selfsigned": "5.5.0", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3", + "yargs": "17.7.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-7-4": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-7-4/-/web-7-4-3.0.52.tgz", + "integrity": "sha512-t+y8GXOl5WkaD7LeRfOn6iatgFy5ntc2X480FyoJoZmhDVj8e+wsMfZ/aAWDrkrV84tVLWj1GKTVAcBSGmuS2w==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, - "node_modules/@php-wasm/web-service-worker/node_modules/ini": { + "node_modules/@php-wasm/web-7-4/node_modules/ini": { "version": "4.1.2", "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", @@ -11218,35 +12015,185 @@ "node": "^14.17.0 || ^16.13.0 || >=18.0.0" } }, - "node_modules/@php-wasm/xdebug-bridge": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@php-wasm/xdebug-bridge/-/xdebug-bridge-3.1.12.tgz", - "integrity": "sha512-A+HKXMwYlFKu704ZCPaioevNWxVqU3KARYzItCvDo2STlL/bRULLPMZyfO0MddNfOKSkes2Ny7PQVLuEUHVQXA==", + "node_modules/@php-wasm/web-8-0": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-0/-/web-8-0-3.0.52.tgz", + "integrity": "sha512-iJlCd8cwk2GbKiTtUE1VmUzv4Z5yiJDmHgcNVdRh2tu1zVxLO4pLlG938bx7UPo6mm6L9SmgBx2kdgjOCmCcWQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.1.12", - "@php-wasm/node": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@wp-playground/common": "3.1.12", - "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", + "@php-wasm/universal": "3.0.52", "ini": "4.1.2", - "jsonc-parser": "3.3.1", - "wasm-feature-detect": "1.8.0", - "ws": "8.18.3", - "xml2js": "0.6.2", - "yargs": "17.7.2" + "wasm-feature-detect": "1.8.0" }, - "bin": { - "xdebug-bridge": "xdebug-bridge.js" + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-8-0/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-8-1": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-1/-/web-8-1-3.0.52.tgz", + "integrity": "sha512-0XfiFIOBIpYAb9zVuyOpXCQn/2g6OgIDAX/u2M3a3x4NxeLg2txvazU+cWRzhGRsSRFgptpqO69ojmhF1JaG7w==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/body-parser": { + "node_modules/@php-wasm/web-8-1/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-8-2": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-2/-/web-8-2-3.0.52.tgz", + "integrity": "sha512-btSMCor5I3735zudkQ0fKthfUxjx+KUgqf6ZHxjSkZ/baKXMpzVH7hTMhh1HjWWOmjQhqNBQ2KyeHzzAlm9+KQ==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-8-2/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-8-3": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-3/-/web-8-3-3.0.52.tgz", + "integrity": "sha512-ahmusrtgmi/TIsWlHCfHX0GXxI0RdeCYGzrIYxQeFH3eEchX7J5ssqImL7sPFvP6tT/bluwn9rLef0Z2hki8bg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-8-3/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-8-4": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-4/-/web-8-4-3.0.52.tgz", + "integrity": "sha512-/5Ah8+tIhnO4RQbQZdkwasJ1NCubKlIfOTWi1N/uQlk0OrQ2KmVj5wB4PGDeYoP41FY2Qawffa8DYf4pdypM4w==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-8-4/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-8-5": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-8-5/-/web-8-5-3.0.52.tgz", + "integrity": "sha512-DlEhsPKFxXRaTXeuikrl8/de3Ru2putx6iWqPe8qaGNW4mKXQKjBNcwgR5NK83BzNa8ajnxDtl8tTYcTRY1iVg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/universal": "3.0.52", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web-8-5/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web-service-worker": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/web-service-worker/-/web-service-worker-3.0.52.tgz", + "integrity": "sha512-eKOLRvXexO5XyiY9wsy8DGXKOnGcovLqxhJeez2eTZ7uQ95k5oOV0Vf9w9OUkLNOWpGg4/qts6Yh4BOgEABLOw==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/scopes": "3.0.52" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/web/node_modules/body-parser": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", @@ -11270,7 +12217,7 @@ "npm": "1.2.8000 || >= 1.4.16" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/bytes": { + "node_modules/@php-wasm/web/node_modules/bytes": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", @@ -11279,7 +12226,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/cookie": { + "node_modules/@php-wasm/web/node_modules/cookie": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", @@ -11288,7 +12235,7 @@ "node": ">= 0.6" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/debug": { + "node_modules/@php-wasm/web/node_modules/debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", @@ -11297,7 +12244,7 @@ "ms": "2.0.0" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/depd": { + "node_modules/@php-wasm/web/node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", @@ -11306,7 +12253,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/encodeurl": { + "node_modules/@php-wasm/web/node_modules/encodeurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", @@ -11315,7 +12262,7 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/express": { + "node_modules/@php-wasm/web/node_modules/express": { "version": "4.22.0", "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", @@ -11361,24 +12308,374 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", - "strnum": "^2.1.2" + "node_modules/@php-wasm/web/node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/web/node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/@php-wasm/web/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@php-wasm/web/node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/@php-wasm/web/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@php-wasm/web/node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@php-wasm/web/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", "bin": { - "fxparser": "src/cli/cli.js" + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@php-wasm/web/node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/web/node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/@php-wasm/web/node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/web/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/@php-wasm/web/node_modules/selfsigned": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", + "license": "MIT", + "dependencies": { + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@php-wasm/web/node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@php-wasm/web/node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/@php-wasm/web/node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@php-wasm/web/node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/web/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@php-wasm/xdebug-bridge": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@php-wasm/xdebug-bridge/-/xdebug-bridge-3.0.52.tgz", + "integrity": "sha512-lqVwXpjMuD4niKU3cmAiqTnTg6tk6gRqI7PLbMlmDDXJ7g59HebYkBd5NCXRCphGSj47ge44Fy/itoa0EOiluw==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@php-wasm/logger": "3.0.52", + "@php-wasm/node": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@wp-playground/common": "3.0.52", + "express": "4.22.0", + "ini": "4.1.2", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3", + "xml2js": "0.6.2", + "yargs": "17.7.2" + }, + "bin": { + "xdebug-bridge": "xdebug-bridge.js" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/body-parser": { + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@php-wasm/xdebug-bridge/node_modules/express": { + "version": "4.22.0", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", + "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.3", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.12", + "proxy-addr": "~2.0.7", + "qs": "~6.14.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/@php-wasm/xdebug-bridge/node_modules/finalhandler": { @@ -11574,18 +12871,6 @@ "node": ">= 0.8" } }, - "node_modules/@php-wasm/xdebug-bridge/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT" - }, "node_modules/@php-wasm/xdebug-bridge/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -15389,6 +16674,101 @@ "lilconfig": ">=2" } }, + "node_modules/@storybook/addon-a11y": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/addon-a11y/-/addon-a11y-10.2.17.tgz", + "integrity": "sha512-J0ogEc4/XFC+Ytz+X1we6TOKreEk/shgUs/mtxdsLa0xJ6bp2n2OQPSjNtQHH/nK4SRBSfHWPm8ztfcXTzeG9w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "axe-core": "^4.2.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.17" + } + }, + "node_modules/@storybook/addon-docs": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.17.tgz", + "integrity": "sha512-c414xi7rxlaHn92qWOxtEkcOMm0/+cvBui0gUsgiWOZOM8dHChGZ/RjMuf1pPDyOrSsybLsPjZhP0WthsMDkdQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@mdx-js/react": "^3.0.0", + "@storybook/csf-plugin": "10.2.17", + "@storybook/icons": "^2.0.1", + "@storybook/react-dom-shim": "10.2.17", + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.17" + } + }, + "node_modules/@storybook/builder-vite": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.17.tgz", + "integrity": "sha512-m/OBveTLm5ds/tUgHmmbKzgSi/oeCpQwm5rZa49vP2BpAd41Q7ER6TzkOoISzPoNNMAcbVmVc5vn7k6hdbPSHw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/csf-plugin": "10.2.17", + "ts-dedent": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "storybook": "^10.2.17", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@storybook/csf-plugin": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.17.tgz", + "integrity": "sha512-crHH8i/4mwzeXpWRPgwvwX2vjytW42zyzTRySUax5dTU8o9sjk4y+Z9hkGx3Nmu1TvqseS8v1Z20saZr/tQcWw==", + "dev": true, + "license": "MIT", + "dependencies": { + "unplugin": "^2.3.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "esbuild": "*", + "rollup": "*", + "storybook": "^10.2.17", + "vite": "*", + "webpack": "*" + }, + "peerDependenciesMeta": { + "esbuild": { + "optional": true + }, + "rollup": { + "optional": true + }, + "vite": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, "node_modules/@storybook/global": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/@storybook/global/-/global-5.0.0.tgz", @@ -15407,14 +16787,14 @@ } }, "node_modules/@storybook/react": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.2.19.tgz", - "integrity": "sha512-gm2qxLyYSsGp7fee5i+d8jSVUKMla8yRaTJ1wxPEnyaJMd0QUu6U2v3p2rW7PH1DWop3D6NqWOY8kmZjmSZKlA==", + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/react/-/react-10.2.17.tgz", + "integrity": "sha512-875AVMYil2X9Civil6GFZ8koIzlKxcXbl2eJ7+/GPbhIonTNmwx0qbWPHttjZXUvFuQ4RRtb9KkBwy4TCb/LeA==", "dev": true, "license": "MIT", "dependencies": { "@storybook/global": "^5.0.0", - "@storybook/react-dom-shim": "10.2.19", + "@storybook/react-dom-shim": "10.2.17", "react-docgen": "^8.0.2" }, "funding": { @@ -15424,7 +16804,7 @@ "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", + "storybook": "^10.2.17", "typescript": ">= 4.9.x" }, "peerDependenciesMeta": { @@ -15434,11 +16814,38 @@ } }, "node_modules/@storybook/react-dom-shim": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.2.19.tgz", - "integrity": "sha512-BXCEfBGVBRYBTYeBeH/PJsy0Bq5MERe/HiaylR+ah/XrvIr2Z9bkne1J8yYiXCjiyq5HQa7Bj11roz0+vyUaEw==", + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/react-dom-shim/-/react-dom-shim-10.2.17.tgz", + "integrity": "sha512-x9Kb7eUSZ1zGsEw/TtWrvs1LwWIdNp8qoOQCgPEjdB07reSJcE8R3+ASWHJThmd4eZf66ZALPJyerejake4Osw==", + "dev": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "storybook": "^10.2.17" + } + }, + "node_modules/@storybook/react-vite": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.17.tgz", + "integrity": "sha512-E/1hNmxVsjy9l3TuaNufSqkdz8saTJUGEs8GRCjKlF7be2wljIwewUxjAT3efk+bxOCw76ZmqGHk6MnRa3y7Gw==", "dev": true, "license": "MIT", + "dependencies": { + "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", + "@rollup/pluginutils": "^5.0.2", + "@storybook/builder-vite": "10.2.17", + "@storybook/react": "10.2.17", + "empathic": "^2.0.0", + "magic-string": "^0.30.0", + "react-docgen": "^8.0.0", + "resolve": "^1.22.8", + "tsconfig-paths": "^4.2.0" + }, "funding": { "type": "opencollective", "url": "https://opencollective.com/storybook" @@ -15446,7 +16853,33 @@ "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19" + "storybook": "^10.2.17", + "vite": "^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/@storybook/react-vite/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@storybook/react-vite/node_modules/tsconfig-paths": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", + "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", + "dev": true, + "license": "MIT", + "dependencies": { + "json5": "^2.2.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + }, + "engines": { + "node": ">=6" } }, "node_modules/@stylistic/stylelint-plugin": { @@ -16406,9 +17839,9 @@ "license": "MIT" }, "node_modules/@types/aws-lambda": { - "version": "8.10.161", - "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.161.tgz", - "integrity": "sha512-rUYdp+MQwSFocxIOcSsYSF3YYYC/uUpMbCY/mbO21vGqfrEYvNSoPyKYDj6RhXXpPfS0KstW9RwG3qXh9sL7FQ==", + "version": "8.10.159", + "resolved": "https://registry.npmjs.org/@types/aws-lambda/-/aws-lambda-8.10.159.tgz", + "integrity": "sha512-SAP22WSGNN12OQ8PlCzGzRCZ7QDCwI85dQZbmpz7+mAk+L7j+wI7qnvmdKh+o7A5LaOp6QnOZ2NJphAZQTTHQg==", "license": "MIT" }, "node_modules/@types/babel__code-frame": { @@ -19618,22 +21051,22 @@ "link": true }, "node_modules/@wp-playground/blueprints": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/blueprints/-/blueprints-3.1.12.tgz", - "integrity": "sha512-NQsQSCDbyjTBHFF+k7PNZEiOA5LxqAqGjThOIiagZKrFYx7MrLNbfB0TuVbGEYHl4lz4G00WfRjVA8594rzCFg==", - "dependencies": { - "@php-wasm/logger": "3.1.12", - "@php-wasm/node": "3.1.12", - "@php-wasm/node-polyfills": "3.1.12", - "@php-wasm/progress": "3.1.12", - "@php-wasm/scopes": "3.1.12", - "@php-wasm/stream-compression": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", - "@php-wasm/web-service-worker": "3.1.12", - "@wp-playground/common": "3.1.12", - "@wp-playground/storage": "3.1.12", - "@wp-playground/wordpress": "3.1.12", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/blueprints/-/blueprints-3.0.52.tgz", + "integrity": "sha512-WQ11urt2O6YItvwwwOYYFqw5wqDPwc5qgaYDsI8cp3hQqH/8bn6xIAwPR55ITNiZYhxl39+aOW1fqRzmymCkyA==", + "dependencies": { + "@php-wasm/logger": "3.0.52", + "@php-wasm/node": "3.0.52", + "@php-wasm/node-polyfills": "3.0.52", + "@php-wasm/progress": "3.0.52", + "@php-wasm/scopes": "3.0.52", + "@php-wasm/stream-compression": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@php-wasm/web-service-worker": "3.0.52", + "@wp-playground/common": "3.0.52", + "@wp-playground/storage": "3.0.52", + "@wp-playground/wordpress": "3.0.52", "@zip.js/zip.js": "2.7.57", "ajv": "8.12.0", "async-lock": "1.4.1", @@ -19641,16 +21074,14 @@ "crc-32": "1.2.2", "diff3": "0.0.4", "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", "ignore": "5.3.2", "ini": "4.1.2", - "jsonc-parser": "3.3.1", "minimisted": "2.0.1", "octokit": "3.1.2", "pako": "1.0.10", "pify": "2.3.0", "readable-stream": "3.6.2", + "selfsigned": "5.5.0", "sha.js": "2.4.12", "simple-get": "4.0.1", "wasm-feature-detect": "1.8.0", @@ -19658,8 +21089,11 @@ "yargs": "17.7.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@wp-playground/blueprints/node_modules/ajv": { @@ -19799,26 +21233,6 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@wp-playground/blueprints/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", - "strnum": "^2.1.2" - }, - "bin": { - "fxparser": "src/cli/cli.js" - } - }, "node_modules/@wp-playground/blueprints/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -19996,6 +21410,19 @@ ], "license": "MIT" }, + "node_modules/@wp-playground/blueprints/node_modules/selfsigned": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", + "license": "MIT", + "dependencies": { + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/@wp-playground/blueprints/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -20050,18 +21477,6 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/blueprints/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT" - }, "node_modules/@wp-playground/blueprints/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -20084,23 +21499,23 @@ } }, "node_modules/@wp-playground/cli": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/cli/-/cli-3.1.12.tgz", - "integrity": "sha512-7NBUEz7NcfirYGWCV+KjG1fkavenbVEQAXhfF6P8svlrc6ZqphJPuLHBmurQUANxmCv8wURpxH8Vx4fxVMWH3Q==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/cli/-/cli-3.0.52.tgz", + "integrity": "sha512-IU3JnEetWQUyewnB3a8I9o3r+9D2nEqoisQje6Fs5kO4QfVgCluiP4ek6HmKEd0pBSaby9Qt2OAdRrKaPQBwIQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/cli-util": "3.1.12", - "@php-wasm/logger": "3.1.12", - "@php-wasm/node": "3.1.12", - "@php-wasm/progress": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", - "@php-wasm/xdebug-bridge": "3.1.12", - "@wp-playground/blueprints": "3.1.12", - "@wp-playground/common": "3.1.12", - "@wp-playground/storage": "3.1.12", - "@wp-playground/tools": "3.1.12", - "@wp-playground/wordpress": "3.1.12", + "@php-wasm/cli-util": "3.0.52", + "@php-wasm/logger": "3.0.52", + "@php-wasm/node": "3.0.52", + "@php-wasm/progress": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@php-wasm/xdebug-bridge": "3.0.52", + "@wp-playground/blueprints": "3.0.52", + "@wp-playground/common": "3.0.52", + "@wp-playground/storage": "3.0.52", + "@wp-playground/tools": "3.0.52", + "@wp-playground/wordpress": "3.0.52", "@zip.js/zip.js": "2.7.57", "ajv": "8.12.0", "async-lock": "1.4.1", @@ -20108,8 +21523,7 @@ "crc-32": "1.2.2", "diff3": "0.0.4", "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", + "fast-xml-parser": "^5.3.4", "fs-extra": "11.1.1", "ignore": "5.3.2", "ini": "4.1.2", @@ -20118,7 +21532,9 @@ "octokit": "3.1.2", "pako": "1.0.10", "pify": "2.3.0", + "ps-man": "1.1.8", "readable-stream": "3.6.2", + "selfsigned": "5.5.0", "sha.js": "2.4.12", "simple-get": "4.0.1", "tmp-promise": "3.0.3", @@ -20129,6 +21545,9 @@ }, "bin": { "wp-playground-cli": "wp-playground.js" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@wp-playground/cli/node_modules/ajv": { @@ -20269,9 +21688,9 @@ } }, "node_modules/@wp-playground/cli/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "version": "5.3.5", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.5.tgz", + "integrity": "sha512-JeaA2Vm9ffQKp9VjvfzObuMCjUYAp5WDYhRYL5LrBPY/jUDlUtOvDfot0vKSkB9tuX885BDHjtw4fZadD95wnA==", "funding": [ { "type": "github", @@ -20280,8 +21699,6 @@ ], "license": "MIT", "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", "strnum": "^2.1.2" }, "bin": { @@ -20491,6 +21908,19 @@ ], "license": "MIT" }, + "node_modules/@wp-playground/cli/node_modules/selfsigned": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", + "license": "MIT", + "dependencies": { + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/@wp-playground/cli/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -20546,9 +21976,9 @@ } }, "node_modules/@wp-playground/cli/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.1.2.tgz", + "integrity": "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==", "funding": [ { "type": "github", @@ -20588,18 +22018,21 @@ } }, "node_modules/@wp-playground/common": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/common/-/common-3.1.12.tgz", - "integrity": "sha512-UGUaGL3JQB15eBU+yJ6MQAl/dGXr9LKDDsSNwpYRizmzQ3727D99vzOx8LJ4cS3TCSq7W3T6vbfCIbbrT0/SsA==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/common/-/common-3.0.52.tgz", + "integrity": "sha512-umfP5lCzjAWqJ3woSrlff+SGDal5y4QHftSk/w5L8SuwlZ0Rq8Q9X5CC2jA0adl8dfyb8auJPqpDbTf4+wWP8A==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", "ini": "4.1.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@wp-playground/common/node_modules/ini": { @@ -20612,19 +22045,21 @@ } }, "node_modules/@wp-playground/storage": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/storage/-/storage-3.1.12.tgz", - "integrity": "sha512-6ItiAFsUnbj4D1PLQEc6RSooX+WszOgN6s2nhrjYuHqI7QB5YB+4RtVjJYDnHOViSpljslMEaInVF6Y2GvaWuQ==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/storage/-/storage-3.0.52.tgz", + "integrity": "sha512-/oZeM5GIELessrzhLFJJscKXtLn34FT2IgqKLg4Vi2uqQ1gdYWx9A24tnLs59MeHa8Mvu0jEAPcAd6AM/ze1yQ==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/stream-compression": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", + "@php-wasm/stream-compression": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@php-wasm/web": "3.0.52", "@zip.js/zip.js": "2.7.57", "async-lock": "^1.4.1", "clean-git-ref": "^2.0.1", "crc-32": "^1.2.0", "diff3": "0.0.3", + "express": "4.22.0", "ignore": "^5.1.4", "ini": "4.1.2", "minimisted": "^2.0.0", @@ -20632,112 +22067,24 @@ "pako": "^1.0.10", "pify": "^4.0.1", "readable-stream": "^3.4.0", + "selfsigned": "5.5.0", "sha.js": "^2.4.9", - "simple-get": "^4.0.1" - } - }, - "node_modules/@wp-playground/storage/node_modules/async-lock": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", - "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/diff3": { - "version": "0.0.3", - "resolved": "https://registry.npmjs.org/diff3/-/diff3-0.0.3.tgz", - "integrity": "sha512-iSq8ngPOt0K53A6eVr4d5Kn6GNrM2nQZtC740pzIriHtn4pOQ2lyzEXQMBeVcWERN0ye7fhBsk9PbLLQOnUx/g==", - "license": "MIT" - }, - "node_modules/@wp-playground/storage/node_modules/ini": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", - "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", - "license": "ISC", - "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" - } - }, - "node_modules/@wp-playground/storage/node_modules/pify": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", - "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", - "license": "MIT", - "engines": { - "node": ">=6" - } - }, - "node_modules/@wp-playground/storage/node_modules/readable-stream": { - "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", - "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", - "license": "MIT", - "dependencies": { - "inherits": "^2.0.3", - "string_decoder": "^1.1.1", - "util-deprecate": "^1.0.1" - }, - "engines": { - "node": ">= 6" - } - }, - "node_modules/@wp-playground/tools": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/tools/-/tools-3.1.12.tgz", - "integrity": "sha512-p/nIRdA8uYEl9z89gSgbmwxNYEranpW7ilyP9YKQKz2xWNcmEJLa1gfcgVCBuFYo+9jL8SrqP5BWoKu52cq9Ug==", - "license": "GPL-2.0-or-later", - "dependencies": { - "@wp-playground/blueprints": "3.1.12", - "@zip.js/zip.js": "2.7.57", - "ajv": "8.12.0", - "async-lock": "1.4.1", - "clean-git-ref": "2.0.1", - "crc-32": "1.2.2", - "diff3": "0.0.4", - "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", - "ignore": "5.3.2", - "ini": "4.1.2", - "jsonc-parser": "3.3.1", - "minimisted": "2.0.1", - "octokit": "3.1.2", - "pako": "1.0.10", - "pify": "2.3.0", - "readable-stream": "3.6.2", - "sha.js": "2.4.12", - "simple-get": "4.0.1", + "simple-get": "^4.0.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, - "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" - } - }, - "node_modules/@wp-playground/tools/node_modules/ajv": { - "version": "8.12.0", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", - "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", - "license": "MIT", - "dependencies": { - "fast-deep-equal": "^3.1.1", - "json-schema-traverse": "^1.0.0", - "require-from-string": "^2.0.2", - "uri-js": "^4.2.2" - }, - "funding": { - "type": "github", - "url": "https://github.com/sponsors/epoberezkin" + "optionalDependencies": { + "fs-ext": "2.1.1" } }, - "node_modules/@wp-playground/tools/node_modules/async-lock": { + "node_modules/@wp-playground/storage/node_modules/async-lock": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", "license": "MIT" }, - "node_modules/@wp-playground/tools/node_modules/body-parser": { + "node_modules/@wp-playground/storage/node_modules/body-parser": { "version": "1.20.4", "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", @@ -20761,7 +22108,7 @@ "npm": "1.2.8000 || >= 1.4.16" } }, - "node_modules/@wp-playground/tools/node_modules/bytes": { + "node_modules/@wp-playground/storage/node_modules/bytes": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", @@ -20770,7 +22117,7 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/tools/node_modules/cookie": { + "node_modules/@wp-playground/storage/node_modules/cookie": { "version": "0.7.2", "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", @@ -20779,7 +22126,7 @@ "node": ">= 0.6" } }, - "node_modules/@wp-playground/tools/node_modules/debug": { + "node_modules/@wp-playground/storage/node_modules/debug": { "version": "2.6.9", "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", @@ -20788,7 +22135,7 @@ "ms": "2.0.0" } }, - "node_modules/@wp-playground/tools/node_modules/depd": { + "node_modules/@wp-playground/storage/node_modules/depd": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", @@ -20797,7 +22144,13 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/tools/node_modules/encodeurl": { + "node_modules/@wp-playground/storage/node_modules/diff3": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/diff3/-/diff3-0.0.3.tgz", + "integrity": "sha512-iSq8ngPOt0K53A6eVr4d5Kn6GNrM2nQZtC740pzIriHtn4pOQ2lyzEXQMBeVcWERN0ye7fhBsk9PbLLQOnUx/g==", + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/encodeurl": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", @@ -20806,7 +22159,7 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/tools/node_modules/express": { + "node_modules/@wp-playground/storage/node_modules/express": { "version": "4.22.0", "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", @@ -20852,24 +22205,427 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@wp-playground/tools/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", + "node_modules/@wp-playground/storage/node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/storage/node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/@wp-playground/storage/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@wp-playground/storage/node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/@wp-playground/storage/node_modules/ini": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.2.tgz", + "integrity": "sha512-AMB1mvwR1pyBFY/nSevUX6y8nJWS63/SzUKD3JyQn97s4xgIdgQPT75IRouIiBAN4yLQBUShNYVW0+UG25daCw==", + "license": "ISC", + "engines": { + "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + } + }, + "node_modules/@wp-playground/storage/node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@wp-playground/storage/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@wp-playground/storage/node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/storage/node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@wp-playground/storage/node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/storage/node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/@wp-playground/storage/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "funding": [ { "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" } ], + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/selfsigned": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", "license": "MIT", "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", - "strnum": "^2.1.2" + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" }, - "bin": { - "fxparser": "src/cli/cli.js" + "engines": { + "node": ">=18" + } + }, + "node_modules/@wp-playground/storage/node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@wp-playground/storage/node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/@wp-playground/storage/node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/@wp-playground/storage/node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/storage/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@wp-playground/tools": { + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/tools/-/tools-3.0.52.tgz", + "integrity": "sha512-uBCbO5rztC1cObHy+ehlDGXiFeZOuqHMCYgZJSUX4q7oqXa+AMua1IMc33AVkfSVjPFnp3f+/oR24hM2nYAWCg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "@wp-playground/blueprints": "3.0.52", + "@zip.js/zip.js": "2.7.57", + "ajv": "8.12.0", + "async-lock": "1.4.1", + "clean-git-ref": "2.0.1", + "crc-32": "1.2.2", + "diff3": "0.0.4", + "express": "4.22.0", + "ignore": "5.3.2", + "ini": "4.1.2", + "minimisted": "2.0.1", + "octokit": "3.1.2", + "pako": "1.0.10", + "pify": "2.3.0", + "readable-stream": "3.6.2", + "selfsigned": "5.5.0", + "sha.js": "2.4.12", + "simple-get": "4.0.1", + "wasm-feature-detect": "1.8.0", + "ws": "8.18.3", + "yargs": "17.7.2" + }, + "engines": { + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" + } + }, + "node_modules/@wp-playground/tools/node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/@wp-playground/tools/node_modules/async-lock": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/async-lock/-/async-lock-1.4.1.tgz", + "integrity": "sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==", + "license": "MIT" + }, + "node_modules/@wp-playground/tools/node_modules/body-parser": { + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/@wp-playground/tools/node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/tools/node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/@wp-playground/tools/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/@wp-playground/tools/node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/tools/node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/@wp-playground/tools/node_modules/express": { + "version": "4.22.0", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.0.tgz", + "integrity": "sha512-c2iPh3xp5vvCLgaHK03+mWLFPhox7j1LwyxcZwFVApEv5i0X+IjPpbT50SJJwwLpdBVfp45AkK/v+AFgv/XlfQ==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.3", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.12", + "proxy-addr": "~2.0.7", + "qs": "~6.14.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" } }, "node_modules/@wp-playground/tools/node_modules/finalhandler": { @@ -21049,6 +22805,19 @@ ], "license": "MIT" }, + "node_modules/@wp-playground/tools/node_modules/selfsigned": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-5.5.0.tgz", + "integrity": "sha512-ftnu3TW4+3eBfLRFnDEkzGxSF/10BJBkaLJuBHZX0kiPS7bRdlpZGu6YGt4KngMkdTwJE6MbjavFpqHvqVt+Ew==", + "license": "MIT", + "dependencies": { + "@peculiar/x509": "^1.14.2", + "pkijs": "^3.3.3" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/@wp-playground/tools/node_modules/send": { "version": "0.19.2", "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", @@ -21103,18 +22872,6 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/tools/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT" - }, "node_modules/@wp-playground/tools/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -21137,28 +22894,28 @@ } }, "node_modules/@wp-playground/wordpress": { - "version": "3.1.12", - "resolved": "https://registry.npmjs.org/@wp-playground/wordpress/-/wordpress-3.1.12.tgz", - "integrity": "sha512-RSpU1YyC5tc0djdh9AL5NIBetHD0eJIZvj7S/fl/1jKFCDzJ0wGp+pxiFSUufXySHAT8oRD890dB9mHNri+sTQ==", + "version": "3.0.52", + "resolved": "https://registry.npmjs.org/@wp-playground/wordpress/-/wordpress-3.0.52.tgz", + "integrity": "sha512-P37YCxJuDSBCi0JIL4mkYUJsCSW1GrnL2LWTgups/NKWf1MCODEhmCSFfixfbMb7BFOvlC6Tb8RXw+O2dG1Ouw==", "license": "GPL-2.0-or-later", "dependencies": { - "@php-wasm/logger": "3.1.12", - "@php-wasm/node": "3.1.12", - "@php-wasm/universal": "3.1.12", - "@php-wasm/util": "3.1.12", - "@wp-playground/common": "3.1.12", + "@php-wasm/logger": "3.0.52", + "@php-wasm/node": "3.0.52", + "@php-wasm/universal": "3.0.52", + "@php-wasm/util": "3.0.52", + "@wp-playground/common": "3.0.52", "express": "4.22.0", - "fast-xml-parser": "^5.5.1", - "fs-ext-extra-prebuilt": "2.2.7", "ini": "4.1.2", - "jsonc-parser": "3.3.1", "wasm-feature-detect": "1.8.0", "ws": "8.18.3", "yargs": "17.7.2" }, "engines": { - "node": ">=20.10.0", - "npm": ">=10.2.3" + "node": ">=20.18.3", + "npm": ">=10.1.0" + }, + "optionalDependencies": { + "fs-ext": "2.1.1" } }, "node_modules/@wp-playground/wordpress/node_modules/body-parser": { @@ -21276,26 +23033,6 @@ "url": "https://opencollective.com/express" } }, - "node_modules/@wp-playground/wordpress/node_modules/fast-xml-parser": { - "version": "5.5.6", - "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.5.6.tgz", - "integrity": "sha512-3+fdZyBRVg29n4rXP0joHthhcHdPUHaIC16cuyyd1iLsuaO6Vea36MPrxgAzbZna8lhvZeRL8Bc9GP56/J9xEw==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "dependencies": { - "fast-xml-builder": "^1.1.4", - "path-expression-matcher": "^1.1.3", - "strnum": "^2.1.2" - }, - "bin": { - "fxparser": "src/cli/cli.js" - } - }, "node_modules/@wp-playground/wordpress/node_modules/finalhandler": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", @@ -21489,18 +23226,6 @@ "node": ">= 0.8" } }, - "node_modules/@wp-playground/wordpress/node_modules/strnum": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.2.0.tgz", - "integrity": "sha512-Y7Bj8XyJxnPAORMZj/xltsfo55uOiyHcU2tnAVzHUnSJR/KsEX+9RoDeXEnsXtl/CX4fAcrt64gZ13aGaWPeBg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT" - }, "node_modules/@wp-playground/wordpress/node_modules/ws": { "version": "8.18.3", "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", @@ -22732,6 +24457,20 @@ "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", "dev": true }, + "node_modules/asn1js": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.7.tgz", + "integrity": "sha512-uLvq6KJu04qoQM6gvBfKFjlh6Gl0vOKQuR5cJMDHQkmwfMOQeN3F3SHCv9SNYSL+CRoHvOGFfllDlVz03GQjvQ==", + "license": "BSD-3-Clause", + "dependencies": { + "pvtsutils": "^1.3.6", + "pvutils": "^1.1.3", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=12.0.0" + } + }, "node_modules/assert": { "version": "1.5.1", "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.1.tgz", @@ -24185,6 +25924,15 @@ "node": ">= 0.8" } }, + "node_modules/bytestreamjs": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/bytestreamjs/-/bytestreamjs-2.0.1.tgz", + "integrity": "sha512-U1Z/ob71V/bXfVABvNr/Kumf5VyeQRBEm6Txb0PQ6S7V5GpBM3w4Cbqz/xPDicR5tN0uvDifng8C+5qECeGwyQ==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/cacache": { "version": "12.0.4", "resolved": "https://registry.npmjs.org/cacache/-/cacache-12.0.4.tgz", @@ -24930,12 +26678,6 @@ "node": ">=0.10.0" } }, - "node_modules/clean-git-ref": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/clean-git-ref/-/clean-git-ref-2.0.1.tgz", - "integrity": "sha512-bLSptAy2P0s6hU4PzuIMKmMJJSE6gLXGH1cntDu7bWJUksvuM+7ReOK61mozULErYvP6a15rnYl0zFDef+pyPw==", - "license": "Apache-2.0" - }, "node_modules/clean-stack": { "version": "2.2.0", "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", @@ -25407,9 +27149,9 @@ } }, "node_modules/comctx": { - "version": "1.6.1", - "resolved": "https://registry.npmjs.org/comctx/-/comctx-1.6.1.tgz", - "integrity": "sha512-ZMRGAYASYRdVfEoB7oxH8Nqu5Ay8I+YvAsQni+td0pYV9eww/PrtSFVyvc2JkNQyHXGDknCB4wJfxFYP6fuqZg==", + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/comctx/-/comctx-1.4.3.tgz", + "integrity": "sha512-Z1fisV3l6kucW+GZDg3AI2+ffWGd+Q/RCBKGbpQ8oe6U3p6wmTM/NciP4RRgLYYDW4aZgZIXRUQz1YnFX1QsjQ==", "license": "MIT" }, "node_modules/command-exists": { @@ -30745,21 +32487,6 @@ "integrity": "sha512-MWipKbbYiYI0UC7cl8m/i/IWTqfC8YXsqjzybjddLsFjStroQzsHXkc73JutMvBiXmOvapk+axIl79ig5t55Bw==", "license": "MIT" }, - "node_modules/fast-xml-builder": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.1.4.tgz", - "integrity": "sha512-f2jhpN4Eccy0/Uz9csxh3Nu6q4ErKxf0XIsasomfOihuSUa3/xw6w8dnOtCDgEItQFJG8KyXPzQXzcODDrrbOg==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "dependencies": { - "path-expression-matcher": "^1.1.3" - } - }, "node_modules/fast-xml-parser": { "version": "4.5.0", "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-4.5.0.tgz", @@ -31490,14 +33217,14 @@ "node": ">=0.10.0" } }, - "node_modules/fs-ext-extra-prebuilt": { - "version": "2.2.7", - "resolved": "https://registry.npmjs.org/fs-ext-extra-prebuilt/-/fs-ext-extra-prebuilt-2.2.7.tgz", - "integrity": "sha512-Q7rayYRBDIvDF01HWOwSSjoaP+05N1g+o3BXL1Zf8Frw2JkjSmi4EtvCBITuW30l6hB2m2TW1pehdh8wyU/+gw==", + "node_modules/fs-ext": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/fs-ext/-/fs-ext-2.1.1.tgz", + "integrity": "sha512-/TrISPOFhCkbgIRWK9lzscRzwPCu0PqtCcvMc9jsHKBgZGoqA0VzhspVht5Zu8lxaXjIYIBWILHpRotYkCCcQA==", "hasInstallScript": true, - "license": "MIT", + "optional": true, "dependencies": { - "nan": "^2.24.0" + "nan": "^2.21.0" }, "engines": { "node": ">= 8.0.0" @@ -37270,6 +38997,27 @@ "node": ">= 0.8.0" } }, + "node_modules/lib0": { + "version": "0.2.99", + "resolved": "https://registry.npmjs.org/lib0/-/lib0-0.2.99.tgz", + "integrity": "sha512-vwztYuUf1uf/1zQxfzRfO5yzfNKhTtgOByCruuiQQxWQXnPb8Itaube5ylofcV0oM0aKal9Mv+S1s1Ky0UYP1w==", + "license": "MIT", + "dependencies": { + "isomorphic.js": "^0.2.4" + }, + "bin": { + "0ecdsa-generate-keypair": "bin/0ecdsa-generate-keypair.js", + "0gentesthtml": "bin/gentesthtml.js", + "0serve": "bin/0serve.js" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "type": "GitHub Sponsors ❤", + "url": "https://github.com/sponsors/dmonad" + } + }, "node_modules/libnpmaccess": { "version": "8.0.6", "resolved": "https://registry.npmjs.org/libnpmaccess/-/libnpmaccess-8.0.6.tgz", @@ -40811,10 +42559,11 @@ } }, "node_modules/nan": { - "version": "2.26.1", - "resolved": "https://registry.npmjs.org/nan/-/nan-2.26.1.tgz", - "integrity": "sha512-vodKprLlmaKmraa9E/TxHQwpH4eKYTJbLdeQE49pb9GOmrLs68zESjJu0LQOz1W6JwJmftOWD5Ls4dpd/elQtQ==", - "license": "MIT" + "version": "2.24.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.24.0.tgz", + "integrity": "sha512-Vpf9qnVW1RaDkoNKFUvfxqAbtI8ncb8OJlqZ9wwpXzWPEsvsB1nvdUi6oYrHIkQ1Y/tMDnr1h4nczS0VB9Xykg==", + "license": "MIT", + "optional": true }, "node_modules/nanoid": { "version": "3.3.11", @@ -42768,6 +44517,27 @@ "node": ">=8" } }, + "node_modules/open-ultrahdr": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.1.tgz", + "integrity": "sha512-Q6WZZc9A114u1QGgblp0VamDE16hV+Br94+1ydkB8zSGx9SZ4CBK5ctVUUx2xILyN7i9+RfTsrtZtLUQ7oaByw==", + "license": "GPL-2.0-or-later", + "dependencies": { + "open-ultrahdr-wasm": "^0.1.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/open-ultrahdr-wasm": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.2.tgz", + "integrity": "sha512-gqz/KZk5l6zpwcqaHF4Sc0u66xOmaa6nKPJCpXKj3yb84mJbwZF2SSu6OatocaiqsdvX2Fjiai+voEz8Oos1zg==", + "license": "GPL-2.0-or-later", + "engines": { + "node": ">=18.0.0" + } + }, "node_modules/opencv-bindings": { "version": "4.5.5", "resolved": "https://registry.npmjs.org/opencv-bindings/-/opencv-bindings-4.5.5.tgz", @@ -43865,21 +45635,6 @@ "node": ">=4" } }, - "node_modules/path-expression-matcher": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.1.3.tgz", - "integrity": "sha512-qdVgY8KXmVdJZRSS1JdEPOKPdTiEK/pi0RkcT2sw1RhXxohdujUlJFPuS1TSkevZ9vzd3ZlL7ULl1MHGTApKzQ==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/NaturalIntelligence" - } - ], - "license": "MIT", - "engines": { - "node": ">=14.0.0" - } - }, "node_modules/path-is-absolute": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", @@ -44100,6 +45855,23 @@ "node": ">=4" } }, + "node_modules/pkijs": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/pkijs/-/pkijs-3.3.3.tgz", + "integrity": "sha512-+KD8hJtqQMYoTuL1bbGOqxb4z+nZkTAwVdNtWwe8Tc2xNbEmdJYIYoc6Qt0uF55e6YW6KuTHw1DjQ18gMhzepw==", + "license": "BSD-3-Clause", + "dependencies": { + "@noble/hashes": "1.4.0", + "asn1js": "^3.0.6", + "bytestreamjs": "^2.0.1", + "pvtsutils": "^1.3.6", + "pvutils": "^1.1.3", + "tslib": "^2.8.1" + }, + "engines": { + "node": ">=16.0.0" + } + }, "node_modules/platform": { "version": "1.3.5", "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.5.tgz", @@ -45216,6 +46988,12 @@ "integrity": "sha512-yPw4Sng1gWghHQWj0B3ZggWUm4qVbPwPFcRG8KyxiU7J2OHFSoEHKS+EZ3fv5l1t9CyCiop6l/ZYeWbrgoQejw==", "dev": true }, + "node_modules/ps-man": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/ps-man/-/ps-man-1.1.8.tgz", + "integrity": "sha512-ZKDPZwHLYVWIk/Q75N7jCFbuQyokSg2+3WBlt8l35S/uBvxoc+LiRUbb3RUt83pwW82dzwiCpoQIHd9PAxUzHg==", + "license": "MIT" + }, "node_modules/public-encrypt": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", @@ -45472,10 +47250,28 @@ } ] }, + "node_modules/pvtsutils": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz", + "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.8.1" + } + }, + "node_modules/pvutils": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.1.5.tgz", + "integrity": "sha512-KTqnxsgGiQ6ZAzZCVlJH5eOjSnvlyEgx1m8bkRJfOhmGRqfo5KLvmAlACQkrjEtOQ4B7wF9TdSLIs9O90MX9xA==", + "license": "MIT", + "engines": { + "node": ">=16.0.0" + } + }, "node_modules/qs": { - "version": "6.14.2", - "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz", - "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==", + "version": "6.14.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.1.tgz", + "integrity": "sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==", "license": "BSD-3-Clause", "dependencies": { "side-channel": "^1.1.0" @@ -45767,9 +47563,9 @@ } }, "node_modules/react-docgen": { - "version": "8.0.3", - "resolved": "https://registry.npmjs.org/react-docgen/-/react-docgen-8.0.3.tgz", - "integrity": "sha512-aEZ9qP+/M+58x2qgfSFEWH1BxLyHe5+qkLNJOZQb5iGS017jpbRnoKhNRrXPeA6RfBrZO5wZrT9DMC1UqE1f1w==", + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/react-docgen/-/react-docgen-8.0.2.tgz", + "integrity": "sha512-+NRMYs2DyTP4/tqWz371Oo50JqmWltR1h2gcdgUMAWZJIAvrd0/SqlCfx7tpzpl/s36rzw6qH2MjoNrxtRNYhA==", "dev": true, "license": "MIT", "dependencies": { @@ -45798,6 +47594,21 @@ "typescript": ">= 4.3.x" } }, + "node_modules/react-docgen/node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/react-docgen/node_modules/@babel/core": { "version": "7.29.0", "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", @@ -45829,6 +47640,39 @@ "url": "https://opencollective.com/babel" } }, + "node_modules/react-docgen/node_modules/@babel/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/react-docgen/node_modules/@babel/parser": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/react-docgen/node_modules/@babel/traverse": { "version": "7.29.0", "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", @@ -45848,6 +47692,20 @@ "node": ">=6.9.0" } }, + "node_modules/react-docgen/node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/react-docgen/node_modules/convert-source-map": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", @@ -46831,6 +48689,12 @@ "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz", "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==" }, + "node_modules/reflect-metadata": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz", + "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==", + "license": "Apache-2.0" + }, "node_modules/regenerate": { "version": "1.4.2", "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", @@ -48280,9 +50144,9 @@ } }, "node_modules/sax": { - "version": "1.6.0", - "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz", - "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==", + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.4.4.tgz", + "integrity": "sha512-1n3r/tGXO6b6VXMdFT54SHzT9ytu9yr7TaELowdYpMqY/Ao7EnlQGmAQ1+RatX7Tkkdm6hONI2owqNx2aZj5Sw==", "license": "BlueOak-1.0.0", "engines": { "node": ">=11.0.0" @@ -49841,6 +51705,42 @@ "node": ">= 0.4" } }, + "node_modules/storybook": { + "version": "10.2.17", + "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.17.tgz", + "integrity": "sha512-yueTpl5YJqLzQqs3CanxNdAAfFU23iP0j+JVJURE4ghfEtRmWfWoZWLGkVcyjmgum7UmjwAlqRuOjQDNvH89kw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@storybook/global": "^5.0.0", + "@storybook/icons": "^2.0.1", + "@testing-library/jest-dom": "^6.6.3", + "@testing-library/user-event": "^14.6.1", + "@vitest/expect": "3.2.4", + "@vitest/spy": "3.2.4", + "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", + "open": "^10.2.0", + "recast": "^0.23.5", + "semver": "^7.7.3", + "use-sync-external-store": "^1.5.0", + "ws": "^8.18.0" + }, + "bin": { + "storybook": "dist/bin/dispatcher.js" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/storybook" + }, + "peerDependencies": { + "prettier": "^2 || ^3" + }, + "peerDependenciesMeta": { + "prettier": { + "optional": true + } + } + }, "node_modules/storybook-addon-tag-badges": { "version": "3.0.4", "resolved": "https://registry.npmjs.org/storybook-addon-tag-badges/-/storybook-addon-tag-badges-3.0.4.tgz", @@ -49854,6 +51754,149 @@ "storybook": "^10.0.0" } }, + "node_modules/storybook/node_modules/bundle-name": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", + "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "run-applescript": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/default-browser": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.4.0.tgz", + "integrity": "sha512-XDuvSq38Hr1MdN47EDvYtx3U0MTqpCEn+F6ft8z2vYDzMrvQhVp0ui9oQdqW3MvK3vqUETglt1tVGgjLuJ5izg==", + "dev": true, + "license": "MIT", + "dependencies": { + "bundle-name": "^4.1.0", + "default-browser-id": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/default-browser-id": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", + "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/define-lazy-prop": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", + "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/open": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", + "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "default-browser": "^5.2.1", + "define-lazy-prop": "^3.0.0", + "is-inside-container": "^1.0.0", + "wsl-utils": "^0.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/recast": { + "version": "0.23.11", + "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", + "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ast-types": "^0.16.1", + "esprima": "~4.0.0", + "source-map": "~0.6.1", + "tiny-invariant": "^1.3.3", + "tslib": "^2.0.1" + }, + "engines": { + "node": ">= 4" + } + }, + "node_modules/storybook/node_modules/run-applescript": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", + "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/storybook/node_modules/semver": { + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/storybook/node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, "node_modules/stream-browserify": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.2.tgz", @@ -50839,6 +52882,12 @@ "url": "https://opencollective.com/unts" } }, + "node_modules/tabbable": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", + "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", + "license": "MIT" + }, "node_modules/table": { "version": "6.8.2", "resolved": "https://registry.npmjs.org/table/-/table-6.8.2.tgz", @@ -51825,9 +53874,9 @@ } }, "node_modules/tslib": { - "version": "2.8.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.0.tgz", - "integrity": "sha512-jWVzBLplnCmoaTr13V9dYbiQ99wvZRd0vNWaDRg+aVYRcjDF3nDksxFDE/+fkXnKhpnUUkmx5pK/v8mCtLVqZA==", + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", "license": "0BSD" }, "node_modules/tsutils": { @@ -51849,6 +53898,24 @@ "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==" }, + "node_modules/tsyringe": { + "version": "4.10.0", + "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz", + "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==", + "license": "MIT", + "dependencies": { + "tslib": "^1.9.3" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/tsyringe/node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "license": "0BSD" + }, "node_modules/tty-browserify": { "version": "0.0.0", "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", @@ -52410,9 +54477,9 @@ } }, "node_modules/unplugin/node_modules/acorn": { - "version": "8.15.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", - "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", "dev": true, "license": "MIT", "bin": { @@ -55671,6 +57738,23 @@ "fd-slicer": "~1.1.0" } }, + "node_modules/yjs": { + "version": "13.6.29", + "resolved": "https://registry.npmjs.org/yjs/-/yjs-13.6.29.tgz", + "integrity": "sha512-kHqDPdltoXH+X4w1lVmMtddE3Oeqq48nM40FD5ojTd8xYhQpzIDcfE2keMSU5bAgRPJBe225WTUdyUgj1DtbiQ==", + "license": "MIT", + "dependencies": { + "lib0": "^0.2.99" + }, + "engines": { + "node": ">=16.0.0", + "npm": ">=8.0.0" + }, + "funding": { + "type": "GitHub Sponsors ❤", + "url": "https://github.com/sponsors/dmonad" + } + }, "node_modules/yn": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", @@ -56240,40 +58324,6 @@ "react-dom": "^18.0.0" } }, - "packages/block-editor/node_modules/@ariakit/core": { - "version": "0.4.18", - "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", - "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", - "dev": true, - "license": "MIT" - }, - "packages/block-editor/node_modules/@ariakit/test": { - "version": "0.4.13", - "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", - "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@ariakit/core": "0.4.18", - "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" - }, - "peerDependencies": { - "@playwright/test": "^1.27.0", - "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", - "react": "^17.0.0 || ^18.0.0 || ^19.0.0" - }, - "peerDependenciesMeta": { - "@playwright/test": { - "optional": true - }, - "@testing-library/react": { - "optional": true - }, - "react": { - "optional": true - } - } - }, "packages/block-editor/node_modules/postcss-urlrebase": { "version": "1.4.0", "resolved": "https://registry.npmjs.org/postcss-urlrebase/-/postcss-urlrebase-1.4.0.tgz", @@ -56356,6 +58406,19 @@ "react-dom": "^18.0.0" } }, + "packages/block-library/node_modules/@arraypress/waveform-player": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@arraypress/waveform-player/-/waveform-player-1.2.1.tgz", + "integrity": "sha512-PsgOZStUN+1GnY0tujbwk2PYE3HMT/Vl3wEvunqH16hIJWzisf8GEngy5EbswTAjQ1aV3Tk4XBkAskc8eslY1A==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/arraypress" + } + }, "packages/block-serialization-default-parser": { "name": "@wordpress/block-serialization-default-parser", "version": "5.41.0", @@ -56577,19 +58640,13 @@ "react-dom": "^18.0.0" } }, - "packages/components/node_modules/@ariakit/core": { - "version": "0.4.18", - "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", - "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", - "license": "MIT" - }, "packages/components/node_modules/@ariakit/react": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.23.tgz", - "integrity": "sha512-zokuZ7C/pUtFi5x1d/0h5ulLGlJpnPXG1aFKU3F4Sj6sD9uNN/J+fXFsg3sZlWdg7u9ZhBLcjsheLypDjjf6WQ==", + "version": "0.4.22", + "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.22.tgz", + "integrity": "sha512-NKVBwMIGGfgMr2AoxvmUWmAeE/g6X/pDozR1S0yInF5tyem2DZQm+Td/9mKmZPu5e0x0hbEX1AQrb8SvL4VoBg==", "license": "MIT", "dependencies": { - "@ariakit/react-core": "0.4.23" + "@ariakit/react-core": "0.4.22" }, "funding": { "type": "opencollective", @@ -56601,9 +58658,9 @@ } }, "packages/components/node_modules/@ariakit/react-core": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.23.tgz", - "integrity": "sha512-cqcgYBgn+rCsZ05o8f3qKQW4ukOdZPgGgiu2BXv889LksbdjdvTMZ6Fd6JTHXm2vmqdnAkmpVulrhKe6NMETDQ==", + "version": "0.4.22", + "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.22.tgz", + "integrity": "sha512-fWzQjMDhMCPGXDJ0/MkYF9vktclwF9XPxKm2fCwYfJMFtAha3ZKXnme2t+IAxguBLtklzW+5xTAEjKV4xn9s7A==", "license": "MIT", "dependencies": { "@ariakit/core": "0.4.18", @@ -56615,33 +58672,6 @@ "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" } }, - "packages/components/node_modules/@ariakit/test": { - "version": "0.4.13", - "resolved": "https://registry.npmjs.org/@ariakit/test/-/test-0.4.13.tgz", - "integrity": "sha512-Kk0FDiHgvPnQw0HrU6B+XHTherTgvpAeI9kXBwCMcZXfLgYO9dh4BUrn1p0vT6EcMDJePEd9nrwZdAfnBFl0cg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@ariakit/core": "0.4.18", - "@testing-library/dom": "^8.0.0 || ^9.0.0 || ^10.0.0" - }, - "peerDependencies": { - "@playwright/test": "^1.27.0", - "@testing-library/react": "^12.0.0 || ^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0", - "react": "^17.0.0 || ^18.0.0 || ^19.0.0" - }, - "peerDependenciesMeta": { - "@playwright/test": { - "optional": true - }, - "@testing-library/react": { - "optional": true - }, - "react": { - "optional": true - } - } - }, "packages/components/node_modules/@emotion/css": { "version": "11.13.5", "resolved": "https://registry.npmjs.org/@emotion/css/-/css-11.13.5.tgz", @@ -56655,213 +58685,6 @@ "@emotion/utils": "^1.4.2" } }, - "packages/components/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "packages/components/node_modules/@storybook/addon-docs": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", - "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@mdx-js/react": "^3.0.0", - "@storybook/csf-plugin": "10.2.19", - "@storybook/icons": "^2.0.1", - "@storybook/react-dom-shim": "10.2.19", - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19" - } - }, - "packages/components/node_modules/@storybook/builder-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", - "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.19", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/components/node_modules/@storybook/csf-plugin": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", - "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.19", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, - "packages/components/node_modules/@storybook/react-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", - "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.19", - "@storybook/react": "10.2.19", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/components/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/components/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/components/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/components/node_modules/default-browser": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", - "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/components/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/components/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "packages/components/node_modules/framer-motion": { "version": "11.15.0", "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-11.15.0.tgz", @@ -56888,96 +58711,6 @@ } } }, - "packages/components/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/components/node_modules/lru-cache": { - "version": "11.2.7", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", - "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "packages/components/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/components/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "packages/components/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/components/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, "packages/components/node_modules/path-to-regexp": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", @@ -56994,132 +58727,6 @@ "react-dom": ">=16.8.0" } }, - "packages/components/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "packages/components/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/components/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "packages/components/node_modules/storybook": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", - "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, - "packages/components/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "packages/components/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "packages/components/node_modules/ws": { - "version": "8.19.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", - "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, "packages/compose": { "name": "@wordpress/compose", "version": "7.41.0", @@ -57246,21 +58853,21 @@ } }, "packages/core-data/node_modules/@babel/core": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", - "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.6.tgz", + "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.29.0", - "@babel/generator": "^7.29.0", + "@babel/code-frame": "^7.28.6", + "@babel/generator": "^7.28.6", "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-module-transforms": "^7.28.6", "@babel/helpers": "^7.28.6", - "@babel/parser": "^7.29.0", + "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", - "@babel/traverse": "^7.29.0", - "@babel/types": "^7.29.0", + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", @@ -57319,18 +58926,18 @@ } }, "packages/core-data/node_modules/@babel/traverse": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", - "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz", + "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.29.0", - "@babel/generator": "^7.29.0", + "@babel/code-frame": "^7.28.6", + "@babel/generator": "^7.28.6", "@babel/helper-globals": "^7.28.0", - "@babel/parser": "^7.29.0", + "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", - "@babel/types": "^7.29.0", + "@babel/types": "^7.28.6", "debug": "^4.3.1" }, "engines": { @@ -57338,39 +58945,39 @@ } }, "packages/core-data/node_modules/@jest/environment": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.3.0.tgz", - "integrity": "sha512-SlLSF4Be735yQXyh2+mctBOzNDx5s5uLv88/j8Qn1wH679PDcwy67+YdADn8NJnGjzlXtN62asGH/T4vWOkfaw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.2.0.tgz", + "integrity": "sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==", "dev": true, "license": "MIT", "dependencies": { - "@jest/fake-timers": "30.3.0", - "@jest/types": "30.3.0", + "@jest/fake-timers": "30.2.0", + "@jest/types": "30.2.0", "@types/node": "*", - "jest-mock": "30.3.0" + "jest-mock": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/expect": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.3.0.tgz", - "integrity": "sha512-76Nlh4xJxk2D/9URCn3wFi98d2hb19uWE1idLsTt2ywhvdOldbw3S570hBgn25P4ICUZ/cBjybrBex2g17IDbg==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.2.0.tgz", + "integrity": "sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==", "dev": true, "license": "MIT", "dependencies": { - "expect": "30.3.0", - "jest-snapshot": "30.3.0" + "expect": "30.2.0", + "jest-snapshot": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/expect-utils": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.3.0.tgz", - "integrity": "sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.2.0.tgz", + "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==", "dev": true, "license": "MIT", "dependencies": { @@ -57381,34 +58988,34 @@ } }, "packages/core-data/node_modules/@jest/fake-timers": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.3.0.tgz", - "integrity": "sha512-WUQDs8SOP9URStX1DzhD425CqbN/HxUYCTwVrT8sTVBfMvFqYt/s61EK5T05qnHu0po6RitXIvP9otZxYDzTGQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.2.0.tgz", + "integrity": "sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", - "@sinonjs/fake-timers": "^15.0.0", + "@jest/types": "30.2.0", + "@sinonjs/fake-timers": "^13.0.0", "@types/node": "*", - "jest-message-util": "30.3.0", - "jest-mock": "30.3.0", - "jest-util": "30.3.0" + "jest-message-util": "30.2.0", + "jest-mock": "30.2.0", + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/@jest/globals": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.3.0.tgz", - "integrity": "sha512-+owLCBBdfpgL3HU+BD5etr1SvbXpSitJK0is1kiYjJxAAJggYMRQz5hSdd5pq1sSggfxPbw2ld71pt4x5wwViA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.2.0.tgz", + "integrity": "sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/environment": "30.3.0", - "@jest/expect": "30.3.0", - "@jest/types": "30.3.0", - "jest-mock": "30.3.0" + "@jest/environment": "30.2.0", + "@jest/expect": "30.2.0", + "@jest/types": "30.2.0", + "jest-mock": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -57428,23 +59035,24 @@ } }, "packages/core-data/node_modules/@jest/transform": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.3.0.tgz", - "integrity": "sha512-TLKY33fSLVd/lKB2YI1pH69ijyUblO/BQvCj566YvnwuzoTNr648iE0j22vRvVNk2HsPwByPxATg3MleS3gf5A==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.2.0.tgz", + "integrity": "sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==", "dev": true, "license": "MIT", "dependencies": { "@babel/core": "^7.27.4", - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@jridgewell/trace-mapping": "^0.3.25", "babel-plugin-istanbul": "^7.0.1", "chalk": "^4.1.2", "convert-source-map": "^2.0.0", "fast-json-stable-stringify": "^2.1.0", "graceful-fs": "^4.2.11", - "jest-haste-map": "30.3.0", + "jest-haste-map": "30.2.0", "jest-regex-util": "30.0.1", - "jest-util": "30.3.0", + "jest-util": "30.2.0", + "micromatch": "^4.0.8", "pirates": "^4.0.7", "slash": "^3.0.0", "write-file-atomic": "^5.0.1" @@ -57454,9 +59062,9 @@ } }, "packages/core-data/node_modules/@jest/types": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", - "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", + "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", "dev": true, "license": "MIT", "dependencies": { @@ -57480,9 +59088,9 @@ "license": "MIT" }, "packages/core-data/node_modules/@sinonjs/fake-timers": { - "version": "15.1.1", - "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.1.1.tgz", - "integrity": "sha512-cO5W33JgAPbOh07tvZjUOJ7oWhtaqGHiZw+11DPbyqh2kHTBc3eF/CjJDeQ4205RLQsX6rxCuYOroFQwl7JDRw==", + "version": "13.0.5", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-13.0.5.tgz", + "integrity": "sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==", "dev": true, "license": "BSD-3-Clause", "dependencies": { @@ -57490,9 +59098,9 @@ } }, "packages/core-data/node_modules/@types/node": { - "version": "20.19.37", - "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.37.tgz", - "integrity": "sha512-8kzdPJ3FsNsVIurqBs7oodNnCEVbni9yUEkaHbgptDACOPW04jimGagZ51E6+lXUwJjgnBw+hyko/lkFWCldqw==", + "version": "20.19.30", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.30.tgz", + "integrity": "sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==", "dev": true, "license": "MIT", "dependencies": { @@ -57574,9 +59182,9 @@ } }, "packages/core-data/node_modules/ci-info": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz", - "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz", + "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==", "dev": true, "funding": [ { @@ -57597,18 +59205,18 @@ "license": "MIT" }, "packages/core-data/node_modules/expect": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/expect/-/expect-30.3.0.tgz", - "integrity": "sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-30.2.0.tgz", + "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/expect-utils": "30.3.0", + "@jest/expect-utils": "30.2.0", "@jest/get-type": "30.1.0", - "jest-matcher-utils": "30.3.0", - "jest-message-util": "30.3.0", - "jest-mock": "30.3.0", - "jest-util": "30.3.0" + "jest-matcher-utils": "30.2.0", + "jest-message-util": "30.2.0", + "jest-mock": "30.2.0", + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -57667,37 +59275,37 @@ } }, "packages/core-data/node_modules/jest-diff": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.3.0.tgz", - "integrity": "sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.2.0.tgz", + "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==", "dev": true, "license": "MIT", "dependencies": { - "@jest/diff-sequences": "30.3.0", + "@jest/diff-sequences": "30.0.1", "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "pretty-format": "30.3.0" + "pretty-format": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-haste-map": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.3.0.tgz", - "integrity": "sha512-mMi2oqG4KRU0R9QEtscl87JzMXfUhbKaFqOxmjb2CKcbHcUGFrJCBWHmnTiUqi6JcnzoBlO4rWfpdl2k/RfLCA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.2.0.tgz", + "integrity": "sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", "anymatch": "^3.1.3", "fb-watchman": "^2.0.2", "graceful-fs": "^4.2.11", "jest-regex-util": "30.0.1", - "jest-util": "30.3.0", - "jest-worker": "30.3.0", - "picomatch": "^4.0.3", + "jest-util": "30.2.0", + "jest-worker": "30.2.0", + "micromatch": "^4.0.8", "walker": "^1.0.8" }, "engines": { @@ -57708,35 +59316,35 @@ } }, "packages/core-data/node_modules/jest-matcher-utils": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.3.0.tgz", - "integrity": "sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz", + "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==", "dev": true, "license": "MIT", "dependencies": { "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "jest-diff": "30.3.0", - "pretty-format": "30.3.0" + "jest-diff": "30.2.0", + "pretty-format": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-message-util": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.3.0.tgz", - "integrity": "sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.2.0.tgz", + "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==", "dev": true, "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/stack-utils": "^2.0.3", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.3", - "pretty-format": "30.3.0", + "micromatch": "^4.0.8", + "pretty-format": "30.2.0", "slash": "^3.0.0", "stack-utils": "^2.0.6" }, @@ -57745,15 +59353,15 @@ } }, "packages/core-data/node_modules/jest-mock": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.3.0.tgz", - "integrity": "sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.2.0.tgz", + "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", - "jest-util": "30.3.0" + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -57770,9 +59378,9 @@ } }, "packages/core-data/node_modules/jest-snapshot": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.3.0.tgz", - "integrity": "sha512-f14c7atpb4O2DeNhwcvS810Y63wEn8O1HqK/luJ4F6M4NjvxmAKQwBUWjbExUtMxWJQ0wVgmCKymeJK6NZMnfQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.2.0.tgz", + "integrity": "sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==", "dev": true, "license": "MIT", "dependencies": { @@ -57781,20 +59389,20 @@ "@babel/plugin-syntax-jsx": "^7.27.1", "@babel/plugin-syntax-typescript": "^7.27.1", "@babel/types": "^7.27.3", - "@jest/expect-utils": "30.3.0", + "@jest/expect-utils": "30.2.0", "@jest/get-type": "30.1.0", - "@jest/snapshot-utils": "30.3.0", - "@jest/transform": "30.3.0", - "@jest/types": "30.3.0", + "@jest/snapshot-utils": "30.2.0", + "@jest/transform": "30.2.0", + "@jest/types": "30.2.0", "babel-preset-current-node-syntax": "^1.2.0", "chalk": "^4.1.2", - "expect": "30.3.0", + "expect": "30.2.0", "graceful-fs": "^4.2.11", - "jest-diff": "30.3.0", - "jest-matcher-utils": "30.3.0", - "jest-message-util": "30.3.0", - "jest-util": "30.3.0", - "pretty-format": "30.3.0", + "jest-diff": "30.2.0", + "jest-matcher-utils": "30.2.0", + "jest-message-util": "30.2.0", + "jest-util": "30.2.0", + "pretty-format": "30.2.0", "semver": "^7.7.2", "synckit": "^0.11.8" }, @@ -57803,33 +59411,33 @@ } }, "packages/core-data/node_modules/jest-util": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.3.0.tgz", - "integrity": "sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.2.0.tgz", + "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", "chalk": "^4.1.2", "ci-info": "^4.2.0", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.3" + "picomatch": "^4.0.2" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/core-data/node_modules/jest-worker": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.3.0.tgz", - "integrity": "sha512-DrCKkaQwHexjRUFTmPzs7sHQe0TSj9nvDALKGdwmK5mW9v7j90BudWirKAJHt3QQ9Dhrg1F7DogPzhChppkJpQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.2.0.tgz", + "integrity": "sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==", "dev": true, "license": "MIT", "dependencies": { "@types/node": "*", "@ungap/structured-clone": "^1.3.0", - "jest-util": "30.3.0", + "jest-util": "30.2.0", "merge-stream": "^2.0.0", "supports-color": "^8.1.1" }, @@ -57877,9 +59485,9 @@ } }, "packages/core-data/node_modules/pretty-format": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.3.0.tgz", - "integrity": "sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.2.0.tgz", + "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==", "dev": true, "license": "MIT", "dependencies": { @@ -57912,9 +59520,9 @@ "license": "MIT" }, "packages/core-data/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", "dev": true, "license": "ISC", "bin": { @@ -58162,208 +59770,6 @@ "react-dom": "^18.0.0" } }, - "packages/dataviews/node_modules/@ariakit/core": { - "version": "0.4.18", - "resolved": "https://registry.npmjs.org/@ariakit/core/-/core-0.4.18.tgz", - "integrity": "sha512-9urEa+GbZTSyredq3B/3thQjTcSZSUC68XctwCkJNH/xNfKN5O+VThiem2rcJxpsGw8sRUQenhagZi0yB4foyg==", - "license": "MIT" - }, - "packages/dataviews/node_modules/@ariakit/react": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/@ariakit/react/-/react-0.4.23.tgz", - "integrity": "sha512-zokuZ7C/pUtFi5x1d/0h5ulLGlJpnPXG1aFKU3F4Sj6sD9uNN/J+fXFsg3sZlWdg7u9ZhBLcjsheLypDjjf6WQ==", - "license": "MIT", - "dependencies": { - "@ariakit/react-core": "0.4.23" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/ariakit" - }, - "peerDependencies": { - "react": "^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, - "packages/dataviews/node_modules/@ariakit/react-core": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/@ariakit/react-core/-/react-core-0.4.23.tgz", - "integrity": "sha512-cqcgYBgn+rCsZ05o8f3qKQW4ukOdZPgGgiu2BXv889LksbdjdvTMZ6Fd6JTHXm2vmqdnAkmpVulrhKe6NMETDQ==", - "license": "MIT", - "dependencies": { - "@ariakit/core": "0.4.18", - "@floating-ui/dom": "^1.0.0", - "use-sync-external-store": "^1.2.0" - }, - "peerDependencies": { - "react": "^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" - } - }, - "packages/dataviews/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "packages/dataviews/node_modules/@storybook/addon-docs": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", - "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@mdx-js/react": "^3.0.0", - "@storybook/csf-plugin": "10.2.19", - "@storybook/icons": "^2.0.1", - "@storybook/react-dom-shim": "10.2.19", - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19" - } - }, - "packages/dataviews/node_modules/@storybook/builder-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", - "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.19", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/dataviews/node_modules/@storybook/csf-plugin": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", - "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.19", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, - "packages/dataviews/node_modules/@storybook/react-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", - "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.19", - "@storybook/react": "10.2.19", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/dataviews/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/dataviews/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/dataviews/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "packages/dataviews/node_modules/date-fns": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.1.0.tgz", @@ -58374,223 +59780,11 @@ "url": "https://github.com/sponsors/kossnocorp" } }, - "packages/dataviews/node_modules/default-browser": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", - "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/dataviews/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/dataviews/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/dataviews/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/dataviews/node_modules/lru-cache": { - "version": "11.2.7", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", - "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "packages/dataviews/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/dataviews/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "packages/dataviews/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/dataviews/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/dataviews/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "packages/dataviews/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/dataviews/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "packages/dataviews/node_modules/storybook": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", - "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, "packages/dataviews/node_modules/storybook/node_modules/esbuild": { "version": "0.25.12", "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz", "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==", - "dev": true, + "extraneous": true, "hasInstallScript": true, "license": "MIT", "bin": { @@ -58628,53 +59822,6 @@ "@esbuild/win32-x64": "0.25.12" } }, - "packages/dataviews/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "packages/dataviews/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "packages/dataviews/node_modules/ws": { - "version": "8.19.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", - "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, "packages/date": { "name": "@wordpress/date", "version": "5.41.0", @@ -60094,16 +61241,6 @@ "npm": ">=8.19.2" } }, - "packages/react-native-editor/node_modules/@babel/helper-plugin-utils": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", - "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=6.9.0" - } - }, "packages/react-native-editor/node_modules/@babel/plugin-transform-arrow-functions": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", @@ -60737,21 +61874,21 @@ } }, "packages/sync/node_modules/@babel/core": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", - "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.6.tgz", + "integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.29.0", - "@babel/generator": "^7.29.0", + "@babel/code-frame": "^7.28.6", + "@babel/generator": "^7.28.6", "@babel/helper-compilation-targets": "^7.28.6", "@babel/helper-module-transforms": "^7.28.6", "@babel/helpers": "^7.28.6", - "@babel/parser": "^7.29.0", + "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", - "@babel/traverse": "^7.29.0", - "@babel/types": "^7.29.0", + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6", "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", @@ -60810,18 +61947,18 @@ } }, "packages/sync/node_modules/@babel/traverse": { - "version": "7.29.0", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", - "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.6.tgz", + "integrity": "sha512-fgWX62k02qtjqdSNTAGxmKYY/7FSL9WAS1o2Hu5+I5m9T0yxZzr4cnrfXQ/MX0rIifthCSs6FKTlzYbJcPtMNg==", "dev": true, "license": "MIT", "dependencies": { - "@babel/code-frame": "^7.29.0", - "@babel/generator": "^7.29.0", + "@babel/code-frame": "^7.28.6", + "@babel/generator": "^7.28.6", "@babel/helper-globals": "^7.28.0", - "@babel/parser": "^7.29.0", + "@babel/parser": "^7.28.6", "@babel/template": "^7.28.6", - "@babel/types": "^7.29.0", + "@babel/types": "^7.28.6", "debug": "^4.3.1" }, "engines": { @@ -60829,39 +61966,39 @@ } }, "packages/sync/node_modules/@jest/environment": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.3.0.tgz", - "integrity": "sha512-SlLSF4Be735yQXyh2+mctBOzNDx5s5uLv88/j8Qn1wH679PDcwy67+YdADn8NJnGjzlXtN62asGH/T4vWOkfaw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-30.2.0.tgz", + "integrity": "sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==", "dev": true, "license": "MIT", "dependencies": { - "@jest/fake-timers": "30.3.0", - "@jest/types": "30.3.0", + "@jest/fake-timers": "30.2.0", + "@jest/types": "30.2.0", "@types/node": "*", - "jest-mock": "30.3.0" + "jest-mock": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/expect": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.3.0.tgz", - "integrity": "sha512-76Nlh4xJxk2D/9URCn3wFi98d2hb19uWE1idLsTt2ywhvdOldbw3S570hBgn25P4ICUZ/cBjybrBex2g17IDbg==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/expect/-/expect-30.2.0.tgz", + "integrity": "sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==", "dev": true, "license": "MIT", "dependencies": { - "expect": "30.3.0", - "jest-snapshot": "30.3.0" + "expect": "30.2.0", + "jest-snapshot": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/expect-utils": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.3.0.tgz", - "integrity": "sha512-j0+W5iQQ8hBh7tHZkTQv3q2Fh/M7Je72cIsYqC4OaktgtO7v1So9UTjp6uPBHIaB6beoF/RRsCgMJKvti0wADA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-30.2.0.tgz", + "integrity": "sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==", "dev": true, "license": "MIT", "dependencies": { @@ -60872,34 +62009,34 @@ } }, "packages/sync/node_modules/@jest/fake-timers": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.3.0.tgz", - "integrity": "sha512-WUQDs8SOP9URStX1DzhD425CqbN/HxUYCTwVrT8sTVBfMvFqYt/s61EK5T05qnHu0po6RitXIvP9otZxYDzTGQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-30.2.0.tgz", + "integrity": "sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", - "@sinonjs/fake-timers": "^15.0.0", + "@jest/types": "30.2.0", + "@sinonjs/fake-timers": "^13.0.0", "@types/node": "*", - "jest-message-util": "30.3.0", - "jest-mock": "30.3.0", - "jest-util": "30.3.0" + "jest-message-util": "30.2.0", + "jest-mock": "30.2.0", + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/@jest/globals": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.3.0.tgz", - "integrity": "sha512-+owLCBBdfpgL3HU+BD5etr1SvbXpSitJK0is1kiYjJxAAJggYMRQz5hSdd5pq1sSggfxPbw2ld71pt4x5wwViA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-30.2.0.tgz", + "integrity": "sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/environment": "30.3.0", - "@jest/expect": "30.3.0", - "@jest/types": "30.3.0", - "jest-mock": "30.3.0" + "@jest/environment": "30.2.0", + "@jest/expect": "30.2.0", + "@jest/types": "30.2.0", + "jest-mock": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -60919,23 +62056,24 @@ } }, "packages/sync/node_modules/@jest/transform": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.3.0.tgz", - "integrity": "sha512-TLKY33fSLVd/lKB2YI1pH69ijyUblO/BQvCj566YvnwuzoTNr648iE0j22vRvVNk2HsPwByPxATg3MleS3gf5A==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-30.2.0.tgz", + "integrity": "sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==", "dev": true, "license": "MIT", "dependencies": { "@babel/core": "^7.27.4", - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@jridgewell/trace-mapping": "^0.3.25", "babel-plugin-istanbul": "^7.0.1", "chalk": "^4.1.2", "convert-source-map": "^2.0.0", "fast-json-stable-stringify": "^2.1.0", "graceful-fs": "^4.2.11", - "jest-haste-map": "30.3.0", + "jest-haste-map": "30.2.0", "jest-regex-util": "30.0.1", - "jest-util": "30.3.0", + "jest-util": "30.2.0", + "micromatch": "^4.0.8", "pirates": "^4.0.7", "slash": "^3.0.0", "write-file-atomic": "^5.0.1" @@ -60945,9 +62083,9 @@ } }, "packages/sync/node_modules/@jest/types": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.3.0.tgz", - "integrity": "sha512-JHm87k7bA33hpBngtU8h6UBub/fqqA9uXfw+21j5Hmk7ooPHlboRNxHq0JcMtC+n8VJGP1mcfnD3Mk+XKe1oSw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-30.2.0.tgz", + "integrity": "sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==", "dev": true, "license": "MIT", "dependencies": { @@ -60971,9 +62109,9 @@ "license": "MIT" }, "packages/sync/node_modules/@sinonjs/fake-timers": { - "version": "15.1.1", - "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-15.1.1.tgz", - "integrity": "sha512-cO5W33JgAPbOh07tvZjUOJ7oWhtaqGHiZw+11DPbyqh2kHTBc3eF/CjJDeQ4205RLQsX6rxCuYOroFQwl7JDRw==", + "version": "13.0.5", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-13.0.5.tgz", + "integrity": "sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==", "dev": true, "license": "BSD-3-Clause", "dependencies": { @@ -61055,9 +62193,9 @@ } }, "packages/sync/node_modules/ci-info": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz", - "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz", + "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==", "dev": true, "funding": [ { @@ -61087,18 +62225,18 @@ } }, "packages/sync/node_modules/expect": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/expect/-/expect-30.3.0.tgz", - "integrity": "sha512-1zQrciTiQfRdo7qJM1uG4navm8DayFa2TgCSRlzUyNkhcJ6XUZF3hjnpkyr3VhAqPH7i/9GkG7Tv5abz6fqz0Q==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-30.2.0.tgz", + "integrity": "sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/expect-utils": "30.3.0", + "@jest/expect-utils": "30.2.0", "@jest/get-type": "30.1.0", - "jest-matcher-utils": "30.3.0", - "jest-message-util": "30.3.0", - "jest-mock": "30.3.0", - "jest-util": "30.3.0" + "jest-matcher-utils": "30.2.0", + "jest-message-util": "30.2.0", + "jest-mock": "30.2.0", + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -61157,37 +62295,37 @@ } }, "packages/sync/node_modules/jest-diff": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.3.0.tgz", - "integrity": "sha512-n3q4PDQjS4LrKxfWB3Z5KNk1XjXtZTBwQp71OP0Jo03Z6V60x++K5L8k6ZrW8MY8pOFylZvHM0zsjS1RqlHJZQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-30.2.0.tgz", + "integrity": "sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==", "dev": true, "license": "MIT", "dependencies": { - "@jest/diff-sequences": "30.3.0", + "@jest/diff-sequences": "30.0.1", "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "pretty-format": "30.3.0" + "pretty-format": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-haste-map": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.3.0.tgz", - "integrity": "sha512-mMi2oqG4KRU0R9QEtscl87JzMXfUhbKaFqOxmjb2CKcbHcUGFrJCBWHmnTiUqi6JcnzoBlO4rWfpdl2k/RfLCA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-30.2.0.tgz", + "integrity": "sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", "anymatch": "^3.1.3", "fb-watchman": "^2.0.2", "graceful-fs": "^4.2.11", "jest-regex-util": "30.0.1", - "jest-util": "30.3.0", - "jest-worker": "30.3.0", - "picomatch": "^4.0.3", + "jest-util": "30.2.0", + "jest-worker": "30.2.0", + "micromatch": "^4.0.8", "walker": "^1.0.8" }, "engines": { @@ -61198,35 +62336,35 @@ } }, "packages/sync/node_modules/jest-matcher-utils": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.3.0.tgz", - "integrity": "sha512-HEtc9uFQgaUHkC7nLSlQL3Tph4Pjxt/yiPvkIrrDCt9jhoLIgxaubo1G+CFOnmHYMxHwwdaSN7mkIFs6ZK8OhA==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz", + "integrity": "sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==", "dev": true, "license": "MIT", "dependencies": { "@jest/get-type": "30.1.0", "chalk": "^4.1.2", - "jest-diff": "30.3.0", - "pretty-format": "30.3.0" + "jest-diff": "30.2.0", + "pretty-format": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-message-util": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.3.0.tgz", - "integrity": "sha512-Z/j4Bo+4ySJ+JPJN3b2Qbl9hDq3VrXmnjjGEWD/x0BCXeOXPTV1iZYYzl2X8c1MaCOL+ewMyNBcm88sboE6YWw==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-30.2.0.tgz", + "integrity": "sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==", "dev": true, "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/stack-utils": "^2.0.3", "chalk": "^4.1.2", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.3", - "pretty-format": "30.3.0", + "micromatch": "^4.0.8", + "pretty-format": "30.2.0", "slash": "^3.0.0", "stack-utils": "^2.0.6" }, @@ -61235,15 +62373,15 @@ } }, "packages/sync/node_modules/jest-mock": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.3.0.tgz", - "integrity": "sha512-OTzICK8CpE+t4ndhKrwlIdbM6Pn8j00lvmSmq5ejiO+KxukbLjgOflKWMn3KE34EZdQm5RqTuKj+5RIEniYhog==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-30.2.0.tgz", + "integrity": "sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", - "jest-util": "30.3.0" + "jest-util": "30.2.0" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" @@ -61260,9 +62398,9 @@ } }, "packages/sync/node_modules/jest-snapshot": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.3.0.tgz", - "integrity": "sha512-f14c7atpb4O2DeNhwcvS810Y63wEn8O1HqK/luJ4F6M4NjvxmAKQwBUWjbExUtMxWJQ0wVgmCKymeJK6NZMnfQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-30.2.0.tgz", + "integrity": "sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==", "dev": true, "license": "MIT", "dependencies": { @@ -61271,20 +62409,20 @@ "@babel/plugin-syntax-jsx": "^7.27.1", "@babel/plugin-syntax-typescript": "^7.27.1", "@babel/types": "^7.27.3", - "@jest/expect-utils": "30.3.0", + "@jest/expect-utils": "30.2.0", "@jest/get-type": "30.1.0", - "@jest/snapshot-utils": "30.3.0", - "@jest/transform": "30.3.0", - "@jest/types": "30.3.0", + "@jest/snapshot-utils": "30.2.0", + "@jest/transform": "30.2.0", + "@jest/types": "30.2.0", "babel-preset-current-node-syntax": "^1.2.0", "chalk": "^4.1.2", - "expect": "30.3.0", + "expect": "30.2.0", "graceful-fs": "^4.2.11", - "jest-diff": "30.3.0", - "jest-matcher-utils": "30.3.0", - "jest-message-util": "30.3.0", - "jest-util": "30.3.0", - "pretty-format": "30.3.0", + "jest-diff": "30.2.0", + "jest-matcher-utils": "30.2.0", + "jest-message-util": "30.2.0", + "jest-util": "30.2.0", + "pretty-format": "30.2.0", "semver": "^7.7.2", "synckit": "^0.11.8" }, @@ -61293,33 +62431,33 @@ } }, "packages/sync/node_modules/jest-util": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.3.0.tgz", - "integrity": "sha512-/jZDa00a3Sz7rdyu55NLrQCIrbyIkbBxareejQI315f/i8HjYN+ZWsDLLpoQSiUIEIyZF/R8fDg3BmB8AtHttg==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-30.2.0.tgz", + "integrity": "sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==", "dev": true, "license": "MIT", "dependencies": { - "@jest/types": "30.3.0", + "@jest/types": "30.2.0", "@types/node": "*", "chalk": "^4.1.2", "ci-info": "^4.2.0", "graceful-fs": "^4.2.11", - "picomatch": "^4.0.3" + "picomatch": "^4.0.2" }, "engines": { "node": "^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0" } }, "packages/sync/node_modules/jest-worker": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.3.0.tgz", - "integrity": "sha512-DrCKkaQwHexjRUFTmPzs7sHQe0TSj9nvDALKGdwmK5mW9v7j90BudWirKAJHt3QQ9Dhrg1F7DogPzhChppkJpQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-30.2.0.tgz", + "integrity": "sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==", "dev": true, "license": "MIT", "dependencies": { "@types/node": "*", "@ungap/structured-clone": "^1.3.0", - "jest-util": "30.3.0", + "jest-util": "30.2.0", "merge-stream": "^2.0.0", "supports-color": "^8.1.1" }, @@ -61343,27 +62481,6 @@ "url": "https://github.com/chalk/supports-color?sponsor=1" } }, - "packages/sync/node_modules/lib0": { - "version": "0.2.99", - "resolved": "https://registry.npmjs.org/lib0/-/lib0-0.2.99.tgz", - "integrity": "sha512-vwztYuUf1uf/1zQxfzRfO5yzfNKhTtgOByCruuiQQxWQXnPb8Itaube5ylofcV0oM0aKal9Mv+S1s1Ky0UYP1w==", - "license": "MIT", - "dependencies": { - "isomorphic.js": "^0.2.4" - }, - "bin": { - "0ecdsa-generate-keypair": "bin/0ecdsa-generate-keypair.js", - "0gentesthtml": "bin/gentesthtml.js", - "0serve": "bin/0serve.js" - }, - "engines": { - "node": ">=16" - }, - "funding": { - "type": "GitHub Sponsors ❤", - "url": "https://github.com/sponsors/dmonad" - } - }, "packages/sync/node_modules/picomatch": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", @@ -61388,9 +62505,9 @@ } }, "packages/sync/node_modules/pretty-format": { - "version": "30.3.0", - "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.3.0.tgz", - "integrity": "sha512-oG4T3wCbfeuvljnyAzhBvpN45E8iOTXCU/TD3zXW80HA3dQ4ahdqMkWGiPWZvjpQwlbyHrPTWUAqUzGzv4l1JQ==", + "version": "30.2.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-30.2.0.tgz", + "integrity": "sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==", "dev": true, "license": "MIT", "dependencies": { @@ -61423,9 +62540,9 @@ "license": "MIT" }, "packages/sync/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", "dev": true, "license": "ISC", "bin": { @@ -61511,23 +62628,6 @@ "yjs": "^13.0.0" } }, - "packages/sync/node_modules/yjs": { - "version": "13.6.29", - "resolved": "https://registry.npmjs.org/yjs/-/yjs-13.6.29.tgz", - "integrity": "sha512-kHqDPdltoXH+X4w1lVmMtddE3Oeqq48nM40FD5ojTd8xYhQpzIDcfE2keMSU5bAgRPJBe225WTUdyUgj1DtbiQ==", - "license": "MIT", - "dependencies": { - "lib0": "^0.2.99" - }, - "engines": { - "node": ">=16.0.0", - "npm": ">=8.0.0" - }, - "funding": { - "type": "GitHub Sponsors ❤", - "url": "https://github.com/sponsors/dmonad" - } - }, "packages/theme": { "name": "@wordpress/theme", "version": "0.8.0", @@ -61565,147 +62665,6 @@ } } }, - "packages/theme/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "packages/theme/node_modules/@storybook/builder-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", - "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.19", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/theme/node_modules/@storybook/csf-plugin": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", - "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.19", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, - "packages/theme/node_modules/@storybook/react-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", - "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.19", - "@storybook/react": "10.2.19", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/theme/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/theme/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/theme/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "packages/theme/node_modules/colorjs.io": { "version": "0.6.0", "resolved": "https://registry.npmjs.org/colorjs.io/-/colorjs.io-0.6.0.tgz", @@ -61716,265 +62675,6 @@ "url": "https://opencollective.com/color" } }, - "packages/theme/node_modules/default-browser": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", - "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/theme/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/theme/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/theme/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/theme/node_modules/lru-cache": { - "version": "11.2.7", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", - "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "packages/theme/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/theme/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "packages/theme/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/theme/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/theme/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "packages/theme/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/theme/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "packages/theme/node_modules/storybook": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", - "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, - "packages/theme/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "packages/theme/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "packages/theme/node_modules/ws": { - "version": "8.19.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", - "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, "packages/token-list": { "name": "@wordpress/token-list", "version": "3.41.0", @@ -62018,558 +62718,6 @@ "react-dom": "^18.0.0" } }, - "packages/ui/node_modules/@babel/runtime": { - "version": "7.29.2", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz", - "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==", - "license": "MIT", - "engines": { - "node": ">=6.9.0" - } - }, - "packages/ui/node_modules/@base-ui/react": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/@base-ui/react/-/react-1.3.0.tgz", - "integrity": "sha512-FwpKqZbPz14AITp1CVgf4AjhKPe1OeeVKSBMdgD10zbFlj3QSWelmtCMLi2+/PFZZcIm3l87G7rwtCZJwHyXWA==", - "license": "MIT", - "dependencies": { - "@babel/runtime": "^7.28.6", - "@base-ui/utils": "0.2.6", - "@floating-ui/react-dom": "^2.1.8", - "@floating-ui/utils": "^0.2.11", - "tabbable": "^6.4.0", - "use-sync-external-store": "^1.6.0" - }, - "engines": { - "node": ">=14.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/mui-org" - }, - "peerDependencies": { - "@types/react": "^17 || ^18 || ^19", - "react": "^17 || ^18 || ^19", - "react-dom": "^17 || ^18 || ^19" - }, - "peerDependenciesMeta": { - "@types/react": { - "optional": true - } - } - }, - "packages/ui/node_modules/@base-ui/utils": { - "version": "0.2.6", - "resolved": "https://registry.npmjs.org/@base-ui/utils/-/utils-0.2.6.tgz", - "integrity": "sha512-yQ+qeuqohwhsNpoYDqqXaLllYAkPCP4vYdDrVo8FQXaAPfHWm1pG/Vm+jmGTA5JFS0BAIjookyapuJFY8F9PIw==", - "license": "MIT", - "dependencies": { - "@babel/runtime": "^7.28.6", - "@floating-ui/utils": "^0.2.11", - "reselect": "^5.1.1", - "use-sync-external-store": "^1.6.0" - }, - "peerDependencies": { - "@types/react": "^17 || ^18 || ^19", - "react": "^17 || ^18 || ^19", - "react-dom": "^17 || ^18 || ^19" - }, - "peerDependenciesMeta": { - "@types/react": { - "optional": true - } - } - }, - "packages/ui/node_modules/@floating-ui/core": { - "version": "1.7.5", - "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.5.tgz", - "integrity": "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==", - "license": "MIT", - "dependencies": { - "@floating-ui/utils": "^0.2.11" - } - }, - "packages/ui/node_modules/@floating-ui/dom": { - "version": "1.7.6", - "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.6.tgz", - "integrity": "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==", - "license": "MIT", - "dependencies": { - "@floating-ui/core": "^1.7.5", - "@floating-ui/utils": "^0.2.11" - } - }, - "packages/ui/node_modules/@floating-ui/react-dom": { - "version": "2.1.8", - "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.8.tgz", - "integrity": "sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==", - "license": "MIT", - "dependencies": { - "@floating-ui/dom": "^1.7.6" - }, - "peerDependencies": { - "react": ">=16.8.0", - "react-dom": ">=16.8.0" - } - }, - "packages/ui/node_modules/@floating-ui/utils": { - "version": "0.2.11", - "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.11.tgz", - "integrity": "sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==", - "license": "MIT" - }, - "packages/ui/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "packages/ui/node_modules/@storybook/addon-docs": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", - "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@mdx-js/react": "^3.0.0", - "@storybook/csf-plugin": "10.2.19", - "@storybook/icons": "^2.0.1", - "@storybook/react-dom-shim": "10.2.19", - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19" - } - }, - "packages/ui/node_modules/@storybook/builder-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", - "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.19", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/ui/node_modules/@storybook/csf-plugin": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", - "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.19", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, - "packages/ui/node_modules/@storybook/react-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", - "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.19", - "@storybook/react": "10.2.19", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "packages/ui/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/ui/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "packages/ui/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/default-browser": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", - "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/ui/node_modules/lru-cache": { - "version": "11.2.7", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", - "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "packages/ui/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/ui/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "packages/ui/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "packages/ui/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "packages/ui/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "packages/ui/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "packages/ui/node_modules/storybook": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", - "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, - "packages/ui/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, - "packages/ui/node_modules/tabbable": { - "version": "6.4.0", - "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", - "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", - "license": "MIT" - }, - "packages/ui/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "packages/ui/node_modules/ws": { - "version": "8.19.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", - "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } - }, - "packages/ultrahdr": { - "name": "@wordpress/ultrahdr", - "version": "1.0.0-prerelease", - "extraneous": true, - "license": "GPL-2.0-or-later", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.1" - }, - "engines": { - "node": ">=18.12.0", - "npm": ">=8.19.2" - } - }, - "packages/ultrahdr-wasm": { - "name": "@wordpress/ultrahdr-wasm", - "version": "1.0.0-prerelease", - "extraneous": true, - "license": "GPL-2.0-or-later", - "engines": { - "node": ">=18.12.0", - "npm": ">=8.19.2" - } - }, "packages/undo-manager": { "name": "@wordpress/undo-manager", "version": "1.41.0", @@ -62611,27 +62759,6 @@ "react-dom": "^18.0.0" } }, - "packages/upload-media/node_modules/open-ultrahdr": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.1.tgz", - "integrity": "sha512-Q6WZZc9A114u1QGgblp0VamDE16hV+Br94+1ydkB8zSGx9SZ4CBK5ctVUUx2xILyN7i9+RfTsrtZtLUQ7oaByw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.2" - }, - "engines": { - "node": ">=20.0.0" - } - }, - "packages/upload-media/node_modules/open-ultrahdr-wasm": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.2.tgz", - "integrity": "sha512-gqz/KZk5l6zpwcqaHF4Sc0u66xOmaa6nKPJCpXKj3yb84mJbwZF2SSu6OatocaiqsdvX2Fjiai+voEz8Oos1zg==", - "license": "GPL-2.0-or-later", - "engines": { - "node": ">=18.0.0" - } - }, "packages/url": { "name": "@wordpress/url", "version": "4.41.0", @@ -63156,149 +63283,6 @@ "terser": "^5.37.0" } }, - "storybook/node_modules/@joshwooding/vite-plugin-react-docgen-typescript": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@joshwooding/vite-plugin-react-docgen-typescript/-/vite-plugin-react-docgen-typescript-0.6.4.tgz", - "integrity": "sha512-6PyZBYKnnVNqOSB0YFly+62R7dmov8segT27A+RVTBVd4iAE6kbW9QBJGlyR2yG4D4ohzhZSTIu7BK1UTtmFFA==", - "dev": true, - "license": "MIT", - "dependencies": { - "glob": "^13.0.1", - "react-docgen-typescript": "^2.2.2" - }, - "peerDependencies": { - "typescript": ">= 4.3.x", - "vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" - }, - "peerDependenciesMeta": { - "typescript": { - "optional": true - } - } - }, - "storybook/node_modules/@storybook/addon-a11y": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/addon-a11y/-/addon-a11y-10.2.19.tgz", - "integrity": "sha512-SJGf1ghCoRVlwyiRwz5GiHuNvu7C5iCDNIRJW8WGOJlnoQa3rYaY7WJ/8a/eT9N8buIscL9AYWudhh5zsI1W3g==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "axe-core": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19" - } - }, - "storybook/node_modules/@storybook/addon-docs": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/addon-docs/-/addon-docs-10.2.19.tgz", - "integrity": "sha512-tXugthdzjX5AkGWDSP4pnRgA/CWlOaEKp/+y9JOGXHLQmm1GHjW+4brNvNkKbjBl06LALXwlcTOyU4lyVRDLAw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@mdx-js/react": "^3.0.0", - "@storybook/csf-plugin": "10.2.19", - "@storybook/icons": "^2.0.1", - "@storybook/react-dom-shim": "10.2.19", - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19" - } - }, - "storybook/node_modules/@storybook/builder-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/builder-vite/-/builder-vite-10.2.19.tgz", - "integrity": "sha512-a59xALzM9GeYh6p+wzAeBbDyIe+qyrC4nxS3QNzb5i2ZOhrq1iIpvnDaOWe80NC8mV3IlqUEGY8Uawkf//1Rmg==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/csf-plugin": "10.2.19", - "ts-dedent": "^2.0.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, - "storybook/node_modules/@storybook/csf-plugin": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/csf-plugin/-/csf-plugin-10.2.19.tgz", - "integrity": "sha512-BpjYIOdyQn/Rm6MjUAc5Gl8HlARZrskD/OhUNShiOh2fznb523dHjiE5mbU1kKM/+L1uvRlEqqih40rTx+xCrg==", - "dev": true, - "license": "MIT", - "dependencies": { - "unplugin": "^2.3.5" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "esbuild": "*", - "rollup": "*", - "storybook": "^10.2.19", - "vite": "*", - "webpack": "*" - }, - "peerDependenciesMeta": { - "esbuild": { - "optional": true - }, - "rollup": { - "optional": true - }, - "vite": { - "optional": true - }, - "webpack": { - "optional": true - } - } - }, - "storybook/node_modules/@storybook/react-vite": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/@storybook/react-vite/-/react-vite-10.2.19.tgz", - "integrity": "sha512-2/yMKrK4IqMIZicRpPMoIg+foBuWnkaEWt0R4V4hjErDj/SC3D9ov+GUqhjKJ81TegijhKzNpwnSD7Nf87haKw==", - "dev": true, - "license": "MIT", - "dependencies": { - "@joshwooding/vite-plugin-react-docgen-typescript": "^0.6.4", - "@rollup/pluginutils": "^5.0.2", - "@storybook/builder-vite": "10.2.19", - "@storybook/react": "10.2.19", - "empathic": "^2.0.0", - "magic-string": "^0.30.0", - "react-docgen": "^8.0.0", - "resolve": "^1.22.8", - "tsconfig-paths": "^4.2.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", - "storybook": "^10.2.19", - "vite": "^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0" - } - }, "storybook/node_modules/acorn": { "version": "8.15.0", "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", @@ -63312,45 +63296,6 @@ "node": ">=0.4.0" } }, - "storybook/node_modules/balanced-match": { - "version": "4.0.4", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz", - "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==", - "dev": true, - "license": "MIT", - "engines": { - "node": "18 || 20 || >=22" - } - }, - "storybook/node_modules/brace-expansion": { - "version": "5.0.4", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.4.tgz", - "integrity": "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg==", - "dev": true, - "license": "MIT", - "dependencies": { - "balanced-match": "^4.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - } - }, - "storybook/node_modules/bundle-name": { - "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", - "dev": true, - "license": "MIT", - "dependencies": { - "run-applescript": "^7.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "storybook/node_modules/commander": { "version": "2.20.3", "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", @@ -63358,228 +63303,6 @@ "dev": true, "license": "MIT" }, - "storybook/node_modules/default-browser": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.5.0.tgz", - "integrity": "sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==", - "dev": true, - "license": "MIT", - "dependencies": { - "bundle-name": "^4.1.0", - "default-browser-id": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "storybook/node_modules/default-browser-id": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.1.tgz", - "integrity": "sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "storybook/node_modules/define-lazy-prop": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=12" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "storybook/node_modules/glob": { - "version": "13.0.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz", - "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "minimatch": "^10.2.2", - "minipass": "^7.1.3", - "path-scurry": "^2.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "storybook/node_modules/lru-cache": { - "version": "11.2.7", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz", - "integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": "20 || >=22" - } - }, - "storybook/node_modules/minimatch": { - "version": "10.2.4", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz", - "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "brace-expansion": "^5.0.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "storybook/node_modules/minipass": { - "version": "7.1.3", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz", - "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==", - "dev": true, - "license": "BlueOak-1.0.0", - "engines": { - "node": ">=16 || 14 >=14.17" - } - }, - "storybook/node_modules/open": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.2.0.tgz", - "integrity": "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==", - "dev": true, - "license": "MIT", - "dependencies": { - "default-browser": "^5.2.1", - "define-lazy-prop": "^3.0.0", - "is-inside-container": "^1.0.0", - "wsl-utils": "^0.1.0" - }, - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "storybook/node_modules/path-scurry": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz", - "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==", - "dev": true, - "license": "BlueOak-1.0.0", - "dependencies": { - "lru-cache": "^11.0.0", - "minipass": "^7.1.2" - }, - "engines": { - "node": "18 || 20 || >=22" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "storybook/node_modules/recast": { - "version": "0.23.11", - "resolved": "https://registry.npmjs.org/recast/-/recast-0.23.11.tgz", - "integrity": "sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==", - "dev": true, - "license": "MIT", - "dependencies": { - "ast-types": "^0.16.1", - "esprima": "~4.0.0", - "source-map": "~0.6.1", - "tiny-invariant": "^1.3.3", - "tslib": "^2.0.1" - }, - "engines": { - "node": ">= 4" - } - }, - "storybook/node_modules/run-applescript": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz", - "integrity": "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "storybook/node_modules/semver": { - "version": "7.7.4", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", - "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", - "dev": true, - "license": "ISC", - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "storybook/node_modules/storybook": { - "version": "10.2.19", - "resolved": "https://registry.npmjs.org/storybook/-/storybook-10.2.19.tgz", - "integrity": "sha512-UUm5eGSm6BLhkcFP0WbxkmAHJZfVN2ViLpIZOqiIPS++q32VYn+CLFC0lrTYTDqYvaG7i4BK4uowXYujzE4NdQ==", - "dev": true, - "license": "MIT", - "dependencies": { - "@storybook/global": "^5.0.0", - "@storybook/icons": "^2.0.1", - "@testing-library/jest-dom": "^6.6.3", - "@testing-library/user-event": "^14.6.1", - "@vitest/expect": "3.2.4", - "@vitest/spy": "3.2.4", - "esbuild": "^0.18.0 || ^0.19.0 || ^0.20.0 || ^0.21.0 || ^0.22.0 || ^0.23.0 || ^0.24.0 || ^0.25.0 || ^0.26.0 || ^0.27.0", - "open": "^10.2.0", - "recast": "^0.23.5", - "semver": "^7.7.3", - "use-sync-external-store": "^1.5.0", - "ws": "^8.18.0" - }, - "bin": { - "storybook": "dist/bin/dispatcher.js" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/storybook" - }, - "peerDependencies": { - "prettier": "^2 || ^3" - }, - "peerDependenciesMeta": { - "prettier": { - "optional": true - } - } - }, - "storybook/node_modules/strip-bom": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=4" - } - }, "storybook/node_modules/terser": { "version": "5.46.0", "resolved": "https://registry.npmjs.org/terser/-/terser-5.46.0.tgz", @@ -63598,43 +63321,6 @@ "engines": { "node": ">=10" } - }, - "storybook/node_modules/tsconfig-paths": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", - "dev": true, - "license": "MIT", - "dependencies": { - "json5": "^2.2.2", - "minimist": "^1.2.6", - "strip-bom": "^3.0.0" - }, - "engines": { - "node": ">=6" - } - }, - "storybook/node_modules/ws": { - "version": "8.19.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.19.0.tgz", - "integrity": "sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=10.0.0" - }, - "peerDependencies": { - "bufferutil": "^4.0.1", - "utf-8-validate": ">=5.0.2" - }, - "peerDependenciesMeta": { - "bufferutil": { - "optional": true - }, - "utf-8-validate": { - "optional": true - } - } } } } From 9ffad4b7c826e023d77c73b97c873ff2d8871ad0 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Tue, 17 Mar 2026 16:57:36 -0700 Subject: [PATCH 07/33] Remove open-ultrahdr from root package.json The dependency belongs only in the upload-media workspace package, not at the monorepo root. Regenerate lockfile from trunk's base to fix CI check-local-changes failure. --- package-lock.json | 3 --- 1 file changed, 3 deletions(-) diff --git a/package-lock.json b/package-lock.json index 9f7f32cc410df4..11d5cf954adfd7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -14,9 +14,6 @@ "routes/*", "storybook" ], - "dependencies": { - "open-ultrahdr": "0.1.1" - }, "devDependencies": { "@apidevtools/json-schema-ref-parser": "11.6.4", "@babel/core": "7.25.7", From 1156564e63cf1fc12a97967f400454173ba0b6fe Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Tue, 17 Mar 2026 17:03:41 -0700 Subject: [PATCH 08/33] UltraHDR: Skip transcoding and handle array meta When an UltraHDR JPEG is detected, replace remaining operations with Upload/ThumbnailGeneration/Finalize to skip any transcoding that would strip HDR gain map data. Also normalize meta before spreading since the Attachment type allows empty arrays. --- packages/upload-media/src/store/private-actions.ts | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index a4755349bd5c3a..41230b8f2dc64b 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -821,11 +821,20 @@ export function detectUltraHdr( id: QueueItemId ) { // Mark attachment metadata with UltraHDR info. // The original file is uploaded unmodified — UltraHDR JPEGs are // already backwards compatible (SDR displays use the embedded base image). + // Skip any subsequent transcoding to preserve HDR gain map data. + const existingMeta = Array.isArray( item.attachment?.meta ) + ? {} + : item.attachment?.meta || {}; dispatch.finishOperation( id, { + operations: [ + OperationType.Upload, + OperationType.ThumbnailGeneration, + OperationType.Finalize, + ], attachment: { ...item.attachment, meta: { - ...( item.attachment?.meta || {} ), + ...existingMeta, ultrahdr: true, hdr_capacity: result.hdrCapacity, }, From 3a78c3707e8f60f7788bd7642d898995710b5827 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 25 Mar 2026 17:20:26 -0700 Subject: [PATCH 09/33] Address PR feedback: tighten try/catch scope and remove unused enum Narrow the try/catch in detectUltraHdr to only wrap the probe logic, making it clearer what errors are being caught. Move the UltraHDR detection result check outside the try block. Add comment explaining why operations are replaced (to skip transcoding that would strip HDR gain map data). Remove unused CreateUltraHdr enum value. --- .../upload-media/src/store/private-actions.ts | 60 ++++++++++--------- packages/upload-media/src/store/types.ts | 1 - 2 files changed, 32 insertions(+), 29 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 41230b8f2dc64b..162714d4cf8a06 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -811,41 +811,45 @@ export function detectUltraHdr( id: QueueItemId ) { return; } + let result; try { - // Dynamically import to avoid loading WASM unless needed + // Dynamically import to avoid loading WASM unless needed. const { probeUltraHdr } = await import( 'open-ultrahdr' ); const buffer = await item.file.arrayBuffer(); - const result = await probeUltraHdr( buffer ); - - if ( result.isValid ) { - // Mark attachment metadata with UltraHDR info. - // The original file is uploaded unmodified — UltraHDR JPEGs are - // already backwards compatible (SDR displays use the embedded base image). - // Skip any subsequent transcoding to preserve HDR gain map data. - const existingMeta = Array.isArray( item.attachment?.meta ) - ? {} - : item.attachment?.meta || {}; - dispatch.finishOperation( id, { - operations: [ - OperationType.Upload, - OperationType.ThumbnailGeneration, - OperationType.Finalize, - ], - attachment: { - ...item.attachment, - meta: { - ...existingMeta, - ultrahdr: true, - hdr_capacity: result.hdrCapacity, - }, - }, - } ); - return; - } + result = await probeUltraHdr( buffer ); } catch { // If UltraHDR detection fails, continue with regular upload. } + if ( result?.isValid ) { + // Mark attachment metadata with UltraHDR info. + // The original file is uploaded unmodified — UltraHDR JPEGs are + // already backwards compatible (SDR displays use the embedded base image). + // + // Replace the remaining operations to skip any transcoding that + // prepareItem may have queued (e.g. format conversion). Transcoding + // would strip the HDR gain map data from the file. + const existingMeta = Array.isArray( item.attachment?.meta ) + ? {} + : item.attachment?.meta || {}; + dispatch.finishOperation( id, { + operations: [ + OperationType.Upload, + OperationType.ThumbnailGeneration, + OperationType.Finalize, + ], + attachment: { + ...item.attachment, + meta: { + ...existingMeta, + ultrahdr: true, + hdr_capacity: result.hdrCapacity, + }, + }, + } ); + return; + } + dispatch.finishOperation( id, {} ); }; } diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index 1d2d6a92693981..9c1a7bafd69347 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -245,7 +245,6 @@ export enum OperationType { Finalize = 'FINALIZE', // UltraHDR operations DetectUltraHdr = 'DETECT_ULTRAHDR', - CreateUltraHdr = 'CREATE_ULTRAHDR', } /** From 813c371cb476ee646b20490df4c04626639c763b Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 26 Mar 2026 09:21:10 -0700 Subject: [PATCH 10/33] Inline UltraHDR WASM as base64 data URL like vips Revert the webpack asset/resource rule for .wasm files and instead inline the UltraHDR WASM binary at build time using the existing esbuild wasmInlinePlugin, matching the pattern used by vips. This avoids separate file downloads and MIME type serving issues. Use the new setWasmUrl() API from open-ultrahdr 0.1.2 to pass the inlined data URL directly to the WASM initialization. --- package-lock.json | 27 ++++++++++--------- packages/upload-media/package.json | 3 ++- .../upload-media/src/store/private-actions.ts | 9 ++++++- 3 files changed, 24 insertions(+), 15 deletions(-) diff --git a/package-lock.json b/package-lock.json index 11d5cf954adfd7..ecabe4adec7f6f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -44514,18 +44514,6 @@ "node": ">=8" } }, - "node_modules/open-ultrahdr": { - "version": "0.1.1", - "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.1.tgz", - "integrity": "sha512-Q6WZZc9A114u1QGgblp0VamDE16hV+Br94+1ydkB8zSGx9SZ4CBK5ctVUUx2xILyN7i9+RfTsrtZtLUQ7oaByw==", - "license": "GPL-2.0-or-later", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.2" - }, - "engines": { - "node": ">=20.0.0" - } - }, "node_modules/open-ultrahdr-wasm": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.2.tgz", @@ -62744,7 +62732,8 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "^0.1.1", + "open-ultrahdr": "0.1.2", + "open-ultrahdr-wasm": "0.1.2", "uuid": "^9.0.1" }, "engines": { @@ -62756,6 +62745,18 @@ "react-dom": "^18.0.0" } }, + "packages/upload-media/node_modules/open-ultrahdr": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.2.tgz", + "integrity": "sha512-hftXYkSPZ/2+dDeqcdK/SgcCcGzFyYQOFb8leWa7Z3YiwUaGDLHuZL/7s7kpTYv32hAnLiwuqIveXlfvBHdoMg==", + "license": "GPL-2.0-or-later", + "dependencies": { + "open-ultrahdr-wasm": "^0.1.2" + }, + "engines": { + "node": ">=20.0.0" + } + }, "packages/url": { "name": "@wordpress/url", "version": "4.41.0", diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index b4348b7db889ed..e8a824fa9ab41c 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -58,7 +58,8 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "^0.1.1", + "open-ultrahdr": "0.1.2", + "open-ultrahdr-wasm": "0.1.2", "uuid": "^9.0.1" }, "peerDependencies": { diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 162714d4cf8a06..f2086c4e7c21e0 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -3,6 +3,9 @@ */ import { v4 as uuidv4 } from 'uuid'; +// @ts-expect-error - WASM files are inlined as base64 data URLs at build time +import ultraHdrWasm from 'open-ultrahdr-wasm/pkg/open_ultrahdr_bg.wasm'; + /** * WordPress dependencies */ @@ -814,7 +817,11 @@ export function detectUltraHdr( id: QueueItemId ) { let result; try { // Dynamically import to avoid loading WASM unless needed. - const { probeUltraHdr } = await import( 'open-ultrahdr' ); + const { setWasmUrl, probeUltraHdr } = await import( + 'open-ultrahdr' + ); + // Pass the build-time inlined WASM data URL to the library. + setWasmUrl( ultraHdrWasm ); const buffer = await item.file.arrayBuffer(); result = await probeUltraHdr( buffer ); } catch { From 38c96cc4e85b1876559513f94e08086acbbeb134 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 26 Mar 2026 09:21:19 -0700 Subject: [PATCH 11/33] Revert unrelated webpack.config.js import reordering --- packages/scripts/config/webpack.config.js | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/packages/scripts/config/webpack.config.js b/packages/scripts/config/webpack.config.js index 80638b4a125235..5674c78f1f88eb 100644 --- a/packages/scripts/config/webpack.config.js +++ b/packages/scripts/config/webpack.config.js @@ -1,17 +1,17 @@ /** * External dependencies */ -const { exec } = require( 'child_process' ); -const { realpathSync } = require( 'fs' ); -const { basename, dirname, relative, resolve, sep } = require( 'path' ); const { BundleAnalyzerPlugin } = require( 'webpack-bundle-analyzer' ); const CopyWebpackPlugin = require( 'copy-webpack-plugin' ); const webpack = require( 'webpack' ); const browserslist = require( 'browserslist' ); const MiniCSSExtractPlugin = require( 'mini-css-extract-plugin' ); +const { basename, dirname, relative, resolve, sep } = require( 'path' ); const ReactRefreshWebpackPlugin = require( '@pmmmwh/react-refresh-webpack-plugin' ); const TerserPlugin = require( 'terser-webpack-plugin' ); +const { realpathSync } = require( 'fs' ); const { sync: glob } = require( 'fast-glob' ); +const { exec } = require( 'child_process' ); /** * WordPress dependencies @@ -242,13 +242,6 @@ const baseConfig = { filename: 'fonts/[name].[hash:8][ext]', }, }, - { - test: /\.wasm$/, - type: 'asset/resource', - generator: { - filename: 'wasm/[name].[hash:8][ext]', - }, - }, ], }, stats: { From bd66a87e702c32316e587f66b411070250910a97 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Mon, 6 Apr 2026 10:30:25 -0700 Subject: [PATCH 12/33] Preserve ISO gain maps in sub-sized images When an UltraHDR/ISO 21496-1 image is uploaded, sub-sizes (thumbnails, scaled versions) now retain the gain map data. During detection, the gain map and metadata are decoded and cached. Each sub-size is resized normally via vips, then re-encoded as UltraHDR by reconstructing HDR pixel data from the SDR base and gain map using the ISO 21496-1 formula. Format transcoding is skipped for UltraHDR images since it would strip the gain map. Cache entries are cleaned up when the parent is finalized. --- .../upload-media/src/store/private-actions.ts | 233 +++++++++++++++++- packages/upload-media/src/store/types.ts | 1 + 2 files changed, 223 insertions(+), 11 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index f2086c4e7c21e0..02d5a1a6418a08 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -60,6 +60,25 @@ import type { cancelItem } from './actions'; const DEFAULT_OUTPUT_QUALITY = 0.82; +/** + * Cached UltraHDR decoded data, keyed by parent item ID. + * Holds gain map and metadata needed for re-encoding sub-sizes. + * Entries are cleaned up when the parent item is finalized. + */ +interface UltraHdrCacheEntry { + gainMap: Uint8Array; + metadata: { + gainMapMin: number[]; + gainMapMax: number[]; + gamma: number[]; + offsetSdr: number[]; + offsetHdr: number[]; + hdrCapacityMin: number; + hdrCapacityMax: number; + }; +} +const ultraHdrCache = new Map< QueueItemId, UltraHdrCacheEntry >(); + type ActionCreators = { cancelItem: typeof cancelItem; addItem: typeof addItem; @@ -80,6 +99,7 @@ type ActionCreators = { updateItemProgress: typeof updateItemProgress; revokeBlobUrls: typeof revokeBlobUrls; detectUltraHdr: typeof detectUltraHdr; + encodeUltraHdrItem: typeof encodeUltraHdrItem; < T = Record< string, unknown > >( args: T ): void; }; @@ -475,6 +495,10 @@ export function processItem( id: QueueItemId ) { case OperationType.DetectUltraHdr: dispatch.detectUltraHdr( id ); break; + + case OperationType.EncodeUltraHdr: + dispatch.encodeUltraHdrItem( id ); + break; } }; } @@ -803,7 +827,8 @@ export function prepareItem( id: QueueItemId ) { } /** - * Detects if a JPEG is an UltraHDR image and stores probe metadata. + * Detects if a JPEG is an UltraHDR image, decodes it, and caches + * the gain map data for re-encoding into sub-sizes. * * @param id Item ID. */ @@ -814,7 +839,7 @@ export function detectUltraHdr( id: QueueItemId ) { return; } - let result; + let probeResult; try { // Dynamically import to avoid loading WASM unless needed. const { setWasmUrl, probeUltraHdr } = await import( @@ -823,12 +848,27 @@ export function detectUltraHdr( id: QueueItemId ) { // Pass the build-time inlined WASM data URL to the library. setWasmUrl( ultraHdrWasm ); const buffer = await item.file.arrayBuffer(); - result = await probeUltraHdr( buffer ); + probeResult = await probeUltraHdr( buffer ); } catch { // If UltraHDR detection fails, continue with regular upload. } - if ( result?.isValid ) { + if ( probeResult?.isValid ) { + // Decode to extract gain map and metadata for sub-size re-encoding. + try { + const { decodeUltraHdr } = await import( 'open-ultrahdr' ); + const buffer = await item.file.arrayBuffer(); + const decoded = await decodeUltraHdr( id, buffer ); + + ultraHdrCache.set( id, { + gainMap: decoded.gainMap, + metadata: decoded.metadata, + } ); + } catch { + // If decode fails, still upload the original but skip + // gain map preservation in sub-sizes. + } + // Mark attachment metadata with UltraHDR info. // The original file is uploaded unmodified — UltraHDR JPEGs are // already backwards compatible (SDR displays use the embedded base image). @@ -850,7 +890,7 @@ export function detectUltraHdr( id: QueueItemId ) { meta: { ...existingMeta, ultrahdr: true, - hdr_capacity: result.hdrCapacity, + hdr_capacity: probeResult.hdrCapacity, }, }, } ); @@ -861,6 +901,159 @@ export function detectUltraHdr( id: QueueItemId ) { }; } +/** + * Converts sRGB component (0-255) to linear light (0-1). + * + * @param c sRGB component value (0-255). + * @return Linear light value (0-1). + */ +function srgbToLinear( c: number ): number { + const s = c / 255; + return s <= 0.04045 ? s / 12.92 : Math.pow( ( s + 0.055 ) / 1.055, 2.4 ); +} + +/** + * Re-encodes a resized SDR JPEG as an UltraHDR image by reconstructing + * HDR data from the cached gain map and metadata. + * + * Uses the ISO 21496-1 gain map application formula to derive HDR linear + * pixel data from the SDR image and gain map, then passes both to the + * UltraHDR encoder which produces a JPEG with an embedded gain map. + * + * @param id Item ID. + */ +export function encodeUltraHdrItem( id: QueueItemId ) { + return async ( { select, dispatch }: ThunkArgs ) => { + const item = select.getItem( id ); + if ( ! item ) { + return; + } + + const parentId = item.parentId; + if ( ! parentId ) { + dispatch.finishOperation( id, {} ); + return; + } + + const cached = ultraHdrCache.get( parentId ); + if ( ! cached ) { + // No gain map data available, skip re-encoding. + dispatch.finishOperation( id, {} ); + return; + } + + try { + const { setWasmUrl, encodeUltraHdr } = await import( + 'open-ultrahdr' + ); + setWasmUrl( ultraHdrWasm ); + + // Decode resized SDR JPEG to pixel data via OffscreenCanvas. + const sdrBlob = new Blob( [ await item.file.arrayBuffer() ], { + type: 'image/jpeg', + } ); + const sdrBitmap = await createImageBitmap( sdrBlob ); + const sdrWidth = sdrBitmap.width; + const sdrHeight = sdrBitmap.height; + + const sdrCanvas = new OffscreenCanvas( sdrWidth, sdrHeight ); + const sdrCtx = sdrCanvas.getContext( '2d' )!; + sdrCtx.drawImage( sdrBitmap, 0, 0 ); + sdrBitmap.close(); + const sdrImageData = sdrCtx.getImageData( + 0, + 0, + sdrWidth, + sdrHeight + ); + + // Decode gain map JPEG to pixel data, resized to match sub-size. + const gainBlob = new Blob( [ cached.gainMap ], { + type: 'image/jpeg', + } ); + const gainBitmap = await createImageBitmap( gainBlob, { + resizeWidth: sdrWidth, + resizeHeight: sdrHeight, + resizeQuality: 'high', + } ); + const gainCanvas = new OffscreenCanvas( sdrWidth, sdrHeight ); + const gainCtx = gainCanvas.getContext( '2d' )!; + gainCtx.drawImage( gainBitmap, 0, 0 ); + gainBitmap.close(); + const gainImageData = gainCtx.getImageData( + 0, + 0, + sdrWidth, + sdrHeight + ); + + // Apply ISO 21496-1 gain map formula to reconstruct HDR. + const pixelCount = sdrWidth * sdrHeight; + const hdrFloat = new Float32Array( pixelCount * 3 ); + const meta = cached.metadata; + + for ( let i = 0; i < pixelCount; i++ ) { + const sdrIdx = i * 4; // RGBA + const hdrIdx = i * 3; // RGB + + for ( let c = 0; c < 3; c++ ) { + const sdrLinear = srgbToLinear( + sdrImageData.data[ sdrIdx + c ] + ); + // Gain map is stored gamma-encoded; decode to linear. + const gainNorm = gainImageData.data[ sdrIdx + c ] / 255; + const gainLinear = Math.pow( gainNorm, meta.gamma[ c ] ); + // Compute log2 recovery from gain map range. + const logRecovery = + meta.gainMapMin[ c ] + + gainLinear * + ( meta.gainMapMax[ c ] - meta.gainMapMin[ c ] ); + // Apply full HDR weight (weight = 1.0). + const recovery = Math.pow( 2, logRecovery ); + // Reconstruct HDR linear value. + hdrFloat[ hdrIdx + c ] = + ( sdrLinear + meta.offsetSdr[ c ] ) * recovery - + meta.offsetHdr[ c ]; + } + } + + // Re-encode as UltraHDR JPEG. + const sdrBuffer = await item.file.arrayBuffer(); + const encoded = await encodeUltraHdr( + id, + sdrBuffer, + hdrFloat.buffer as ArrayBuffer + ); + + const file = new File( + [ new Blob( [ encoded ], { type: 'image/jpeg' } ) ], + item.file.name, + { type: 'image/jpeg' } + ); + + const blobUrl = createBlobURL( file ); + dispatch< CacheBlobUrlAction >( { + type: Type.CacheBlobUrl, + id, + blobUrl, + } ); + + dispatch.finishOperation( id, { + file, + attachment: { + url: blobUrl, + }, + } ); + } catch ( error ) { + // If re-encoding fails, continue with the SDR-only sub-size. + // This is non-fatal — the sub-size simply won't have HDR data. + // eslint-disable-next-line no-console + console.warn( 'UltraHDR sub-size encoding failed:', error ); + dispatch.finishOperation( id, {} ); + } + }; +} + /** * Uploads an item to the server. * @@ -1219,11 +1412,16 @@ export function generateThumbnails( id: QueueItemId ) { : item.sourceFile; const batchId = uuidv4(); + // Check if this is an UltraHDR image with cached gain map data. + // If so, sub-sizes need gain map re-encoding instead of format transcoding. + const hasUltraHdrData = ultraHdrCache.has( item.id ); + const { imageOutputFormats } = settings; // Check if thumbnails should be transcoded to a different format. // Uses the same transparency-aware logic as the main image // to avoid converting transparent PNGs to JPEG. + // Skip transcoding for UltraHDR — format conversion strips gain maps. const sourceType = item.sourceFile.type; const outputMimeType = imageOutputFormats?.[ sourceType ]; @@ -1234,7 +1432,11 @@ export function generateThumbnails( id: QueueItemId ) { ] | null = null; - if ( outputMimeType && outputMimeType !== sourceType ) { + if ( + ! hasUltraHdrData && + outputMimeType && + outputMimeType !== sourceType + ) { thumbnailTranscodeOperation = await getTranscodeImageOperation( item.sourceFile, outputMimeType, @@ -1257,9 +1459,12 @@ export function generateThumbnails( id: QueueItemId ) { [ OperationType.ResizeCrop, { resize: imageSize } ], ]; - // Add transcoding if format conversion is configured and - // the transparency check passed. - if ( thumbnailTranscodeOperation ) { + if ( hasUltraHdrData ) { + // Re-encode as UltraHDR after resize to preserve gain map. + thumbnailOperations.push( OperationType.EncodeUltraHdr ); + } else if ( thumbnailTranscodeOperation ) { + // Add transcoding if format conversion is configured and + // the transparency check passed. thumbnailOperations.push( thumbnailTranscodeOperation ); } @@ -1324,8 +1529,11 @@ export function generateThumbnails( id: QueueItemId ) { ], ]; - // Add transcoding if format conversion is configured. - if ( thumbnailTranscodeOperation ) { + if ( hasUltraHdrData ) { + // Re-encode as UltraHDR after resize to preserve gain map. + scaledOperations.push( OperationType.EncodeUltraHdr ); + } else if ( thumbnailTranscodeOperation ) { + // Add transcoding if format conversion is configured. scaledOperations.push( thumbnailTranscodeOperation ); } @@ -1386,6 +1594,9 @@ export function finalizeItem( id: QueueItemId ) { } } + // Clean up cached UltraHDR data — all sub-sizes are done by now. + ultraHdrCache.delete( id ); + dispatch.finishOperation( id, {} ); }; } diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index 9c1a7bafd69347..5f5c07b763bc2c 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -245,6 +245,7 @@ export enum OperationType { Finalize = 'FINALIZE', // UltraHDR operations DetectUltraHdr = 'DETECT_ULTRAHDR', + EncodeUltraHdr = 'ENCODE_ULTRAHDR', } /** From eec22499d7294e2af18fb100f755a9a28386b88b Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Mon, 6 Apr 2026 10:52:01 -0700 Subject: [PATCH 13/33] Fix Uint8Array to BlobPart type error in gain map decoding Use .buffer to get the underlying ArrayBuffer from the Uint8Array when constructing a Blob, satisfying stricter TypeScript BlobPart type. --- packages/upload-media/src/store/private-actions.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 02d5a1a6418a08..ef1d657870a0ee 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -968,7 +968,7 @@ export function encodeUltraHdrItem( id: QueueItemId ) { ); // Decode gain map JPEG to pixel data, resized to match sub-size. - const gainBlob = new Blob( [ cached.gainMap ], { + const gainBlob = new Blob( [ cached.gainMap.buffer ], { type: 'image/jpeg', } ); const gainBitmap = await createImageBitmap( gainBlob, { From 84f8ea10f018d70cfc587f3c9a35964246a775f0 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Mon, 6 Apr 2026 11:18:10 -0700 Subject: [PATCH 14/33] Fix ArrayBufferLike to BlobPart TypeScript error in gain map decoding Wrap cached.gainMap.buffer with new Uint8Array() to convert ArrayBufferLike (which includes SharedArrayBuffer) to a valid BlobPart type accepted by the Blob constructor. --- packages/upload-media/src/store/private-actions.ts | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index ef1d657870a0ee..ba15fe4362d8a8 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -968,9 +968,12 @@ export function encodeUltraHdrItem( id: QueueItemId ) { ); // Decode gain map JPEG to pixel data, resized to match sub-size. - const gainBlob = new Blob( [ cached.gainMap.buffer ], { - type: 'image/jpeg', - } ); + const gainBlob = new Blob( + [ new Uint8Array( cached.gainMap.buffer ) ], + { + type: 'image/jpeg', + } + ); const gainBitmap = await createImageBitmap( gainBlob, { resizeWidth: sdrWidth, resizeHeight: sdrHeight, From d7d1d4823327ebd53cf0dc6ed486341bdfaaa9c3 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Mon, 6 Apr 2026 12:01:19 -0700 Subject: [PATCH 15/33] Fix gain map buffer type: cast ArrayBufferLike to ArrayBuffer for Blob TypeScript 5.9 treats Uint8Array.buffer as ArrayBufferLike which includes SharedArrayBuffer, but Blob only accepts ArrayBuffer. Use explicit cast since decoded JPEG data is always ArrayBuffer. --- packages/upload-media/src/store/private-actions.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index ba15fe4362d8a8..4a7be05bae7a2a 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -969,7 +969,7 @@ export function encodeUltraHdrItem( id: QueueItemId ) { // Decode gain map JPEG to pixel data, resized to match sub-size. const gainBlob = new Blob( - [ new Uint8Array( cached.gainMap.buffer ) ], + [ cached.gainMap.buffer as ArrayBuffer ], { type: 'image/jpeg', } From dbd21b24a801fb3c888232a922d4523d33757e67 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Mon, 13 Apr 2026 15:40:55 -0600 Subject: [PATCH 16/33] Integrate copyMemory() batch thumbnail path with UltraHDR Preserve trunk's vipsBatchResizeImage() optimization for non-UltraHDR uploads while keeping the per-thumbnail fallback as the primary path for UltraHDR images. The batch routine uses thumbnailImage() which strips gain maps, so UltraHDR sub-sizes must be resized individually with EncodeUltraHdr to preserve HDR data. --- .../upload-media/src/store/private-actions.ts | 197 +++++++++++++----- 1 file changed, 145 insertions(+), 52 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 4a7be05bae7a2a..88ca751d661686 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -22,6 +22,7 @@ import { StubFile } from '../stub-file'; import { UploadError } from '../upload-error'; import { vipsResizeImage, + vipsBatchResizeImage, vipsRotateImage, vipsConvertImageFormat, vipsHasTransparency, @@ -1447,6 +1448,35 @@ export function generateThumbnails( id: QueueItemId ) { ); } + // Determine the actual output type for thumbnails. + // If transcoding is configured, use that format; otherwise + // use the source format. + const thumbnailOutputType = thumbnailTranscodeOperation + ? `image/${ thumbnailTranscodeOperation[ 1 ].outputFormat }` + : sourceType; + + const quality = thumbnailTranscodeOperation + ? thumbnailTranscodeOperation[ 1 ].outputQuality ?? + DEFAULT_OUTPUT_QUALITY + : DEFAULT_OUTPUT_QUALITY; + + // Collect all resize configs for batch processing. + const batchConfigs: Array< { + name: string; + resize: { + width: number; + height: number; + crop?: + | boolean + | [ + 'left' | 'center' | 'right', + 'top' | 'center' | 'bottom', + ]; + }; + quality: number; + scaledSuffix?: boolean; + } > = []; + for ( const name of sizesToGenerate ) { const imageSize = allImageSizes[ name ]; if ( ! imageSize ) { @@ -1457,68 +1487,132 @@ export function generateThumbnails( id: QueueItemId ) { continue; } - // Build operations list for this thumbnail. - const thumbnailOperations: Operation[] = [ - [ OperationType.ResizeCrop, { resize: imageSize } ], - ]; - - if ( hasUltraHdrData ) { - // Re-encode as UltraHDR after resize to preserve gain map. - thumbnailOperations.push( OperationType.EncodeUltraHdr ); - } else if ( thumbnailTranscodeOperation ) { - // Add transcoding if format conversion is configured and - // the transparency check passed. - thumbnailOperations.push( thumbnailTranscodeOperation ); - } - - thumbnailOperations.push( OperationType.Upload ); - - dispatch.addSideloadItem( { - file, - onChange: ( [ updatedAttachment ] ) => { - // If the sub-size is still being generated, there is no need - // to invoke the callback below. It would just override - // the main image in the editor with the sub-size. - if ( isBlobURL( updatedAttachment.url ) ) { - return; - } - - // This might be confusing, but the idea is to update the original - // image item in the editor with the new one with the added sub-size. - item.onChange?.( [ updatedAttachment ] ); - }, - batchId, - parentId: item.id, - additionalData: { - // Sideloading does not use the parent post ID but the - // attachment ID as the image sizes need to be added to it. - post: attachment.id, - image_size: name, - convert_format: false, - }, - operations: thumbnailOperations, + batchConfigs.push( { + name, + resize: imageSize, + quality, } ); } - // Create and sideload the scaled version. + // Check if a scaled version is needed. const { bigImageSizeThreshold } = settings; + let needsScaling = false; if ( bigImageSizeThreshold && attachment.id ) { - // Check if the image actually exceeds the threshold. - // Only create a scaled version for images larger than the threshold, - // matching WordPress core's wp_create_image_subsizes() behavior. const bitmap = await createImageBitmap( item.sourceFile ); - const needsScaling = + needsScaling = bitmap.width > bigImageSizeThreshold || bitmap.height > bigImageSizeThreshold; bitmap.close(); if ( needsScaling ) { - // Rename sourceFile to match the server attachment filename. - const sourceForScaled = attachment.filename - ? renameFile( item.sourceFile, attachment.filename ) - : item.sourceFile; + batchConfigs.push( { + name: 'scaled', + resize: { + width: bigImageSizeThreshold, + height: bigImageSizeThreshold, + }, + quality, + scaledSuffix: true, + } ); + } + } + + // Batch resize: decode source once via copyMemory(), + // generate all sub-sizes with thumbnailImage(), and + // write each directly to the output format. + // Falls back to per-thumbnail processing on failure. + // UltraHDR images skip the batch path entirely — the + // batch routine uses thumbnailImage() which drops gain + // maps, so sub-sizes must be processed individually via + // the EncodeUltraHdr operation to preserve HDR data. + let batchResults: Awaited< + ReturnType< typeof vipsBatchResizeImage > + > | null = null; + + if ( ! hasUltraHdrData && batchConfigs.length > 0 ) { + try { + batchResults = await vipsBatchResizeImage( + item.id, + file, + thumbnailOutputType, + batchConfigs, + false + ); + } catch { + // eslint-disable-next-line no-console + console.warn( + 'Batch resize failed, falling back to per-thumbnail processing' + ); + } + } + + if ( batchResults ) { + // Batch succeeded — enqueue upload-only sideloads. + for ( const result of batchResults ) { + dispatch.addSideloadItem( { + file: result.file, + onChange: ( [ updatedAttachment ] ) => { + if ( isBlobURL( updatedAttachment.url ) ) { + return; + } + item.onChange?.( [ updatedAttachment ] ); + }, + batchId, + parentId: item.id, + additionalData: { + post: attachment.id, + image_size: result.name, + convert_format: false, + }, + operations: [ OperationType.Upload ], + } ); + } + } else { + // Fallback: per-thumbnail processing. Also the primary + // path for UltraHDR images, which need gain map + // re-encoding after each resize. + for ( const name of sizesToGenerate ) { + const imageSize = allImageSizes[ name ]; + if ( ! imageSize ) { + continue; + } + + const thumbnailOperations: Operation[] = [ + [ OperationType.ResizeCrop, { resize: imageSize } ], + ]; + + if ( hasUltraHdrData ) { + // Re-encode as UltraHDR after resize to preserve gain map. + thumbnailOperations.push( + OperationType.EncodeUltraHdr + ); + } else if ( thumbnailTranscodeOperation ) { + thumbnailOperations.push( thumbnailTranscodeOperation ); + } + + thumbnailOperations.push( OperationType.Upload ); + + dispatch.addSideloadItem( { + file, + onChange: ( [ updatedAttachment ] ) => { + if ( isBlobURL( updatedAttachment.url ) ) { + return; + } + item.onChange?.( [ updatedAttachment ] ); + }, + batchId, + parentId: item.id, + additionalData: { + post: attachment.id, + image_size: name, + convert_format: false, + }, + operations: thumbnailOperations, + } ); + } - // Add scaling to queue. + // Fallback scaled version. + if ( needsScaling && bigImageSizeThreshold && attachment.id ) { const scaledOperations: Operation[] = [ [ OperationType.ResizeCrop, @@ -1536,14 +1630,13 @@ export function generateThumbnails( id: QueueItemId ) { // Re-encode as UltraHDR after resize to preserve gain map. scaledOperations.push( OperationType.EncodeUltraHdr ); } else if ( thumbnailTranscodeOperation ) { - // Add transcoding if format conversion is configured. scaledOperations.push( thumbnailTranscodeOperation ); } scaledOperations.push( OperationType.Upload ); dispatch.addSideloadItem( { - file: sourceForScaled, + file, onChange: ( [ updatedAttachment ] ) => { if ( isBlobURL( updatedAttachment.url ) ) { return; From 086dba52513b7ebef56600aa1fc6bd7269b27ec1 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Thu, 7 May 2026 23:34:06 -0700 Subject: [PATCH 17/33] Upload Media: Bump open-ultrahdr to 0.2.0 (Apache-2.0 OR MIT) open-ultrahdr 0.2.0 swaps the in-house Rust UltraHDR reimplementation for an Emscripten/embind build of upstream google/libultrahdr, now that upstream is dual-licensed Apache-2.0 OR MIT. The WASM filename changes from open_ultrahdr_bg.wasm (wasm-pack convention) to open_ultrahdr.wasm (Emscripten convention), so the inline import path moves accordingly. Public JS API is unchanged. Tracks adamsilverstein/lib-open-ultrahdr#14 / PR #15. Note: package-lock.json regen will be needed once open-ultrahdr@0.2.0 is published to npm; CI installs will fail until then. --- packages/upload-media/package.json | 4 ++-- packages/upload-media/src/store/private-actions.ts | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index 7690515ac2e98f..843a2053b90937 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -58,8 +58,8 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "0.1.2", - "open-ultrahdr-wasm": "0.1.2", + "open-ultrahdr": "0.2.0", + "open-ultrahdr-wasm": "0.2.0", "uuid": "^9.0.1" }, "peerDependencies": { diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index c991413f556388..e80c4e4892afd4 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -4,7 +4,7 @@ import { v4 as uuidv4 } from 'uuid'; // @ts-expect-error - WASM files are inlined as base64 data URLs at build time -import ultraHdrWasm from 'open-ultrahdr-wasm/pkg/open_ultrahdr_bg.wasm'; +import ultraHdrWasm from 'open-ultrahdr-wasm/pkg/open_ultrahdr.wasm'; /** * WordPress dependencies From 5975eec06de760c61e7c08e274c3d7754c4c1c51 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 8 May 2026 13:51:46 -0700 Subject: [PATCH 18/33] Upload Media: Refresh package-lock for open-ultrahdr 0.2.0 open-ultrahdr@0.2.0 and open-ultrahdr-wasm@0.2.0 are now published on npm (Apache-2.0 OR MIT, backed by upstream libultrahdr via Emscripten). Regenerate the lockfile entries so npm ci picks up the new tarballs and integrity hashes. --- package-lock.json | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/package-lock.json b/package-lock.json index d3a2fcd4b219a6..5740222d8c5b2b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -44122,11 +44122,23 @@ "node": ">=8" } }, + "node_modules/open-ultrahdr": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.2.0.tgz", + "integrity": "sha512-AYDJEt1rdAV8Yu3arlMfaIf0psjNyIWPytDyc93ltJcEKQ53M43CNQxvpMZh81l49omY5BChbhN9gKcElEce/A==", + "license": "Apache-2.0 OR MIT", + "dependencies": { + "open-ultrahdr-wasm": "^0.2.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, "node_modules/open-ultrahdr-wasm": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.1.2.tgz", - "integrity": "sha512-gqz/KZk5l6zpwcqaHF4Sc0u66xOmaa6nKPJCpXKj3yb84mJbwZF2SSu6OatocaiqsdvX2Fjiai+voEz8Oos1zg==", - "license": "GPL-2.0-or-later", + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.2.0.tgz", + "integrity": "sha512-36PYnCLJRUBcJ77vJStqx2N5CxiHUyVLY+mFY08JuY1xImoIT4gvI2U/tlM68ZzeZy0nwxP75KanBBepDj2Usw==", + "license": "Apache-2.0 OR MIT", "engines": { "node": ">=18.0.0" } @@ -62775,8 +62787,8 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "0.1.2", - "open-ultrahdr-wasm": "0.1.2", + "open-ultrahdr": "0.2.0", + "open-ultrahdr-wasm": "0.2.0", "uuid": "^9.0.1" }, "engines": { @@ -62788,18 +62800,6 @@ "react-dom": "^18.0.0" } }, - "packages/upload-media/node_modules/open-ultrahdr": { - "version": "0.1.2", - "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.1.2.tgz", - "integrity": "sha512-hftXYkSPZ/2+dDeqcdK/SgcCcGzFyYQOFb8leWa7Z3YiwUaGDLHuZL/7s7kpTYv32hAnLiwuqIveXlfvBHdoMg==", - "license": "GPL-2.0-or-later", - "dependencies": { - "open-ultrahdr-wasm": "^0.1.2" - }, - "engines": { - "node": ">=20.0.0" - } - }, "packages/url": { "name": "@wordpress/url", "version": "4.44.0", From 183046219005b324f8f4cdff5b5d2ed9044c3a81 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 8 May 2026 14:53:00 -0700 Subject: [PATCH 19/33] Vips: Add UltraHDR-aware resize via wasm-vips 0.0.17 Bump wasm-vips to ^0.0.17 to pick up libvips's native UltraHDR (ISO 21496-1 gain map) support, which was introduced upstream once libultrahdr dual-licensed under Apache-2.0 OR MIT. Add a getUltraHdrInfo helper that probes a buffer via uhdrloadBuffer and returns dimensions plus HDR headroom in stops, and an isUltraHdr flag on resizeImage so callers can route through uhdrloadBuffer + uhdrsaveBuffer. The thumbnail path uses thumbnailImage on the already-loaded image so the gain map is downsized in lockstep with the base image and re-embedded on save. --- packages/vips/CHANGELOG.md | 5 ++ packages/vips/README.md | 30 +++++++++ packages/vips/package.json | 2 +- packages/vips/src/index.ts | 112 ++++++++++++++++++++++++++++--- packages/vips/src/vips-worker.ts | 45 ++++++++++--- packages/vips/src/worker.ts | 2 + 6 files changed, 177 insertions(+), 19 deletions(-) diff --git a/packages/vips/CHANGELOG.md b/packages/vips/CHANGELOG.md index 31eb7d798be4a4..96e3297e90a707 100644 --- a/packages/vips/CHANGELOG.md +++ b/packages/vips/CHANGELOG.md @@ -2,6 +2,11 @@ ## Unreleased +### New Features + +- Add `getUltraHdrInfo` for probing UltraHDR (ISO 21496-1 gain map) JPEGs and an `isUltraHdr` flag on `resizeImage` that routes through `uhdrloadBuffer`/`uhdrsaveBuffer` so the gain map is preserved through resize ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). +- Bump `wasm-vips` to `^0.0.17` for native UltraHDR support ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). + ## 1.4.0 (2026-04-15) ## 1.3.0 (2026-04-01) diff --git a/packages/vips/README.md b/packages/vips/README.md index 3aee99f699bb54..5b74f472bfbfb6 100644 --- a/packages/vips/README.md +++ b/packages/vips/README.md @@ -76,6 +76,20 @@ _Parameters_ - _quality_ Desired quality. - _interlaced_ Whether to use interlaced/progressive mode. Only used if the outputType supports it. +### getUltraHdrInfo + +Probes a JPEG to determine whether it is an UltraHDR image with an embedded gain map. + +Returns dimensions and HDR headroom on success, or `null` if the buffer is not a valid UltraHDR JPEG (no gain map, decode failure, or unsupported format). + +_Parameters_ + +- _buffer_ `ArrayBuffer`: Image buffer. + +_Returns_ + +- `Promise< UltraHdrInfo | null >`: UltraHDR info, or null when the buffer is not UltraHDR. + ### hasTransparency Determines whether an image has an alpha channel. @@ -100,6 +114,7 @@ _Parameters_ - _resize_ `ImageSizeCrop`: Resize options. - _smartCrop_ Whether to use smart cropping (i.e. saliency-aware). - _quality_ Desired quality (0-1). +- _isUltraHdr_ Whether the input is an UltraHDR JPEG with a gain map. When true, the image is loaded via uhdrload so libvips resizes the gain map alongside the base image, and the output is saved via uhdrsave so the gain map is re-embedded in the resulting JPEG. _Returns_ @@ -184,6 +199,20 @@ _Parameters_ - _quality_ Desired quality. - _interlaced_ Whether to use interlaced/progressive mode. Only used if the outputType supports it. +### vipsGetUltraHdrInfo + +Probes a JPEG to determine whether it is an UltraHDR image with an embedded gain map. + +Returns dimensions and HDR headroom on success, or `null` if the buffer is not a valid UltraHDR JPEG (no gain map, decode failure, or unsupported format). + +_Parameters_ + +- _buffer_ `ArrayBuffer`: Image buffer. + +_Returns_ + +- `Promise< UltraHdrInfo | null >`: UltraHDR info, or null when the buffer is not UltraHDR. + ### vipsHasTransparency Determines whether an image has an alpha channel. @@ -208,6 +237,7 @@ _Parameters_ - _resize_ `ImageSizeCrop`: Resize options. - _smartCrop_ Whether to use smart cropping (i.e. saliency-aware). - _quality_ Desired quality (0-1). +- _isUltraHdr_ Whether the input is an UltraHDR JPEG with a gain map. When true, the image is loaded via uhdrload so libvips resizes the gain map alongside the base image, and the output is saved via uhdrsave so the gain map is re-embedded in the resulting JPEG. _Returns_ diff --git a/packages/vips/package.json b/packages/vips/package.json index 28eeb2b5d28d3b..dbc4dba99d9598 100644 --- a/packages/vips/package.json +++ b/packages/vips/package.json @@ -56,7 +56,7 @@ "types": "build-types", "dependencies": { "@wordpress/worker-threads": "file:../worker-threads", - "wasm-vips": "^0.0.16" + "wasm-vips": "^0.0.17" }, "publishConfig": { "access": "public" diff --git a/packages/vips/src/index.ts b/packages/vips/src/index.ts index 3a2657bed4d6b5..190299af619172 100644 --- a/packages/vips/src/index.ts +++ b/packages/vips/src/index.ts @@ -316,12 +316,17 @@ function buildSaveOptions( /** * Resizes an image using vips. * - * @param id Item ID. - * @param buffer Original file buffer. - * @param type Mime type. - * @param resize Resize options. - * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). - * @param quality Desired quality (0-1). + * @param id Item ID. + * @param buffer Original file buffer. + * @param type Mime type. + * @param resize Resize options. + * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). + * @param quality Desired quality (0-1). + * @param isUltraHdr Whether the input is an UltraHDR JPEG with a gain map. + * When true, the image is loaded via uhdrload so libvips + * resizes the gain map alongside the base image, and the + * output is saved via uhdrsave so the gain map is + * re-embedded in the resulting JPEG. * @return Processed file data plus the old and new dimensions. */ export async function resizeImage( @@ -330,7 +335,8 @@ export async function resizeImage( type: string, resize: ImageSizeCrop, smartCrop = false, - quality = 0.82 + quality = 0.82, + isUltraHdr = false ): Promise< { buffer: ArrayBuffer | ArrayBufferLike; width: number; @@ -362,7 +368,11 @@ export async function resizeImage( } }; - let image = vips.Image.newFromBuffer( buffer, strOptions, loadOptions ); + // For UltraHDR JPEGs, load via uhdrload so the gain map is decoded + // alongside the base image and tracked through the thumbnail pipeline. + let image = isUltraHdr + ? vips.Image.uhdrloadBuffer( buffer ) + : vips.Image.newFromBuffer( buffer, strOptions, loadOptions ); image.onProgress = onProgress; @@ -374,6 +384,18 @@ export async function resizeImage( pageHeight, smartCrop, ( resizeWidth, thumbnailOptions ) => { + // thumbnailImage downsizes the already-loaded image (including + // the attached gain map for UltraHDR inputs), avoiding a + // reload via thumbnailBuffer which would not preserve the + // gain map link for UltraHDR sources. + if ( isUltraHdr ) { + const thumb = image.thumbnailImage( + resizeWidth, + thumbnailOptions + ); + thumb.onProgress = onProgress; + return thumb; + } if ( strOptions ) { thumbnailOptions.option_string = strOptions; } @@ -387,8 +409,17 @@ export async function resizeImage( } ); - const saveOptions = buildSaveOptions( type, quality ); - const outBuffer = image.writeToBuffer( `.${ ext }`, saveOptions ); + let outBuffer: Uint8Array; + if ( isUltraHdr ) { + // Default metadata retention — UltraHDR's gain map structure is + // stored in XMP, so stripping metadata would invalidate the file. + outBuffer = image.uhdrsaveBuffer( { + Q: quality * 100, + } ); + } else { + const saveOptions = buildSaveOptions( type, quality ); + outBuffer = image.writeToBuffer( `.${ ext }`, saveOptions ); + } const result = { buffer: outBuffer.buffer, @@ -407,6 +438,66 @@ export async function resizeImage( } } +/** + * Information returned by getUltraHdrInfo() for a successfully probed + * UltraHDR JPEG. + */ +interface UltraHdrInfo { + width: number; + height: number; + /** HDR headroom in stops (log2 of the linear capacity). */ + hdrCapacity: number; +} + +/** + * Probes a JPEG to determine whether it is an UltraHDR image with an embedded + * gain map. + * + * Returns dimensions and HDR headroom on success, or `null` if the buffer is + * not a valid UltraHDR JPEG (no gain map, decode failure, or unsupported + * format). + * + * @param buffer Image buffer. + * @return UltraHDR info, or null when the buffer is not UltraHDR. + */ +export async function getUltraHdrInfo( + buffer: ArrayBuffer +): Promise< UltraHdrInfo | null > { + try { + const vips = await getVips(); + const image = vips.Image.uhdrloadBuffer( buffer ); + if ( ! image.gainmap ) { + cleanup?.(); + return null; + } + + // `gainmap-hdr-capacity-max` is libultrahdr's linear-scale max capacity. + // Convert to log2 stops so the value stored in attachment metadata + // represents HDR headroom in stops. + let hdrCapacityLinear = 1; + try { + hdrCapacityLinear = image.getDouble( 'gainmap-hdr-capacity-max' ); + } catch { + // Field may be missing; fall back to no headroom. + } + const hdrCapacity = + hdrCapacityLinear > 0 ? Math.log2( hdrCapacityLinear ) : 0; + + const info: UltraHdrInfo = { + width: image.width, + height: image.pageHeight, + hdrCapacity, + }; + + cleanup?.(); + return info; + } catch { + // Not an UltraHDR image (or libultrahdr decoder unavailable). + cleanup?.(); + return null; + } +} + /** * Configuration for a single resize operation within a batch. */ @@ -646,5 +737,6 @@ export { batchResizeImage as vipsBatchResizeImage, rotateImage as vipsRotateImage, hasTransparency as vipsHasTransparency, + getUltraHdrInfo as vipsGetUltraHdrInfo, cancelOperations as vipsCancelOperations, }; diff --git a/packages/vips/src/vips-worker.ts b/packages/vips/src/vips-worker.ts index 86655c5db55123..553a376ad0a35f 100644 --- a/packages/vips/src/vips-worker.ts +++ b/packages/vips/src/vips-worker.ts @@ -103,12 +103,15 @@ export async function vipsCompressImage( /** * Resizes an image using vips in a worker. * - * @param id Item ID. - * @param buffer Original file buffer. - * @param type Mime type. - * @param resize Resize options. - * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). - * @param quality Desired quality (0-1). Defaults to 0.82. + * @param id Item ID. + * @param buffer Original file buffer. + * @param type Mime type. + * @param resize Resize options. + * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). + * @param quality Desired quality (0-1). Defaults to 0.82. + * @param isUltraHdr Whether the input is an UltraHDR JPEG with a gain map. + * When true, libvips loads via uhdrload and saves via + * uhdrsave so the gain map is preserved through resize. * @return Processed file data plus the old and new dimensions. */ export async function vipsResizeImage( @@ -117,7 +120,8 @@ export async function vipsResizeImage( type: string, resize: ImageSizeCrop, smartCrop = false, - quality = 0.82 + quality = 0.82, + isUltraHdr = false ): Promise< { buffer: ArrayBuffer | ArrayBufferLike; width: number; @@ -126,7 +130,15 @@ export async function vipsResizeImage( originalHeight: number; } > { const api = getWorkerAPI(); - return api.resizeImage( id, buffer, type, resize, smartCrop, quality ); + return api.resizeImage( + id, + buffer, + type, + resize, + smartCrop, + quality, + isUltraHdr + ); } /** @@ -186,6 +198,23 @@ export async function vipsHasTransparency( return api.hasTransparency( buffer ); } +/** + * Probes a JPEG buffer for UltraHDR (ISO 21496-1 gain map) support using vips + * in a worker. + * + * @param buffer Image buffer to probe. + * @return UltraHDR info (dimensions and HDR headroom in stops) if the buffer + * is a valid UltraHDR JPEG; otherwise null. + */ +export async function vipsGetUltraHdrInfo( buffer: ArrayBuffer ): Promise< { + width: number; + height: number; + hdrCapacity: number; +} | null > { + const api = getWorkerAPI(); + return api.getUltraHdrInfo( buffer ); +} + /** * Rotates an image based on EXIF orientation using vips in a worker. * diff --git a/packages/vips/src/worker.ts b/packages/vips/src/worker.ts index fcd7bf9c5ff2a0..d1fc07cfcba85a 100644 --- a/packages/vips/src/worker.ts +++ b/packages/vips/src/worker.ts @@ -22,6 +22,7 @@ import { batchResizeImage, rotateImage, hasTransparency, + getUltraHdrInfo, } from './index'; /** @@ -35,6 +36,7 @@ const api = { batchResizeImage, rotateImage, hasTransparency, + getUltraHdrInfo, }; expose( api ); From 5ddd06556aa2fb32516860521c85f68cc6a9d505 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 8 May 2026 14:53:13 -0700 Subject: [PATCH 20/33] Upload Media: Use wasm-vips's native UltraHDR support Drop the open-ultrahdr and open-ultrahdr-wasm dependencies in favor of the UltraHDR pipeline now built into wasm-vips. libultrahdr's recent relicensing to Apache-2.0 OR MIT made it compatible with the GPL-2.0 WordPress codebase, removing the original reason to maintain a separate in-house WASM build. Replace the open-ultrahdr probe + decode + manual ISO 21496-1 re-encode round-trip with a single isUltraHdr flag passed through vipsResizeImage. libvips loads the source via uhdrload, resizes the base image and gain map together via thumbnailImage, and saves via uhdrsave, eliminating the OffscreenCanvas pixel reconstruction path along with the EncodeUltraHdr operation type and the per-item gain-map cache. --- package-lock.json | 43 +-- packages/upload-media/CHANGELOG.md | 1 + packages/upload-media/package.json | 2 - .../upload-media/src/store/private-actions.ts | 276 +++--------------- packages/upload-media/src/store/types.ts | 1 - .../upload-media/src/store/utils/index.ts | 20 +- 6 files changed, 67 insertions(+), 276 deletions(-) diff --git a/package-lock.json b/package-lock.json index 5740222d8c5b2b..f8a4a39895b42b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -44122,27 +44122,6 @@ "node": ">=8" } }, - "node_modules/open-ultrahdr": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/open-ultrahdr/-/open-ultrahdr-0.2.0.tgz", - "integrity": "sha512-AYDJEt1rdAV8Yu3arlMfaIf0psjNyIWPytDyc93ltJcEKQ53M43CNQxvpMZh81l49omY5BChbhN9gKcElEce/A==", - "license": "Apache-2.0 OR MIT", - "dependencies": { - "open-ultrahdr-wasm": "^0.2.0" - }, - "engines": { - "node": ">=20.0.0" - } - }, - "node_modules/open-ultrahdr-wasm": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/open-ultrahdr-wasm/-/open-ultrahdr-wasm-0.2.0.tgz", - "integrity": "sha512-36PYnCLJRUBcJ77vJStqx2N5CxiHUyVLY+mFY08JuY1xImoIT4gvI2U/tlM68ZzeZy0nwxP75KanBBepDj2Usw==", - "license": "Apache-2.0 OR MIT", - "engines": { - "node": ">=18.0.0" - } - }, "node_modules/opencv-bindings": { "version": "4.5.5", "resolved": "https://registry.npmjs.org/opencv-bindings/-/opencv-bindings-4.5.5.tgz", @@ -54955,6 +54934,15 @@ "integrity": "sha512-zksaLKM2fVlnB5jQQDqKXXwYHLQUVH9es+5TOOHwGOVJOCeRBCiPjwSg+3tN2AdTCzjgli4jijCH290kXb/zWQ==", "license": "Apache-2.0" }, + "node_modules/wasm-vips": { + "version": "0.0.17", + "resolved": "https://registry.npmjs.org/wasm-vips/-/wasm-vips-0.0.17.tgz", + "integrity": "sha512-nhkqUNJDUymImoXGrVfImC4wzIFTb9KfBpAngb7dcEQNPP1gVTx4+WL3VVVDSXQpMsyeacsQDOx0+DM33Rpurg==", + "license": "MIT", + "engines": { + "node": ">=16.4.0" + } + }, "node_modules/watchpack": { "version": "1.7.5", "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.7.5.tgz", @@ -62787,8 +62775,6 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "0.2.0", - "open-ultrahdr-wasm": "0.2.0", "uuid": "^9.0.1" }, "engines": { @@ -62856,22 +62842,13 @@ "license": "GPL-2.0-or-later", "dependencies": { "@wordpress/worker-threads": "file:../worker-threads", - "wasm-vips": "^0.0.16" + "wasm-vips": "^0.0.17" }, "engines": { "node": ">=18.12.0", "npm": ">=8.19.2" } }, - "packages/vips/node_modules/wasm-vips": { - "version": "0.0.16", - "resolved": "https://registry.npmjs.org/wasm-vips/-/wasm-vips-0.0.16.tgz", - "integrity": "sha512-4/bEq8noAFt7DX3VT+Vt5AgNtnnOLwvmrDbduWfiv9AV+VYkbUU4f9Dam9e6khRqPinyClFHCqiwATTTJEiGwA==", - "license": "MIT", - "engines": { - "node": ">=16.4.0" - } - }, "packages/warning": { "name": "@wordpress/warning", "version": "3.44.0", diff --git a/packages/upload-media/CHANGELOG.md b/packages/upload-media/CHANGELOG.md index 3c5b417053db4f..2b3819ee19143b 100644 --- a/packages/upload-media/CHANGELOG.md +++ b/packages/upload-media/CHANGELOG.md @@ -5,6 +5,7 @@ ### Enhancement - Remove sideload upload serialization: thumbnail uploads now run concurrently, governed by `maxConcurrentUploads` instead of being queued one-at-a-time per attachment ([#75257](https://github.com/WordPress/gutenberg/pull/75257)). +- UltraHDR (ISO 21496-1 gain map) JPEGs are now detected and resized via libvips's native `uhdrload`/`uhdrsave` pipeline. The standalone `open-ultrahdr` and `open-ultrahdr-wasm` dependencies have been removed; gain maps are preserved automatically through the existing resize step ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). ## 0.29.0 (2026-04-15) diff --git a/packages/upload-media/package.json b/packages/upload-media/package.json index 843a2053b90937..6fca5b80641911 100644 --- a/packages/upload-media/package.json +++ b/packages/upload-media/package.json @@ -58,8 +58,6 @@ "@wordpress/private-apis": "file:../private-apis", "@wordpress/url": "file:../url", "@wordpress/vips": "file:../vips", - "open-ultrahdr": "0.2.0", - "open-ultrahdr-wasm": "0.2.0", "uuid": "^9.0.1" }, "peerDependencies": { diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index e80c4e4892afd4..4d97b86ebfde7c 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -3,9 +3,6 @@ */ import { v4 as uuidv4 } from 'uuid'; -// @ts-expect-error - WASM files are inlined as base64 data URLs at build time -import ultraHdrWasm from 'open-ultrahdr-wasm/pkg/open_ultrahdr.wasm'; - /** * WordPress dependencies */ @@ -27,6 +24,7 @@ import { vipsRotateImage, vipsConvertImageFormat, vipsHasTransparency, + vipsGetUltraHdrInfo, terminateVipsWorker, } from './utils'; import type { @@ -64,23 +62,11 @@ import type { cancelItem } from './actions'; const DEFAULT_OUTPUT_QUALITY = 0.82; /** - * Cached UltraHDR decoded data, keyed by parent item ID. - * Holds gain map and metadata needed for re-encoding sub-sizes. - * Entries are cleaned up when the parent item is finalized. + * Tracks parent item IDs whose source file is an UltraHDR JPEG so that + * sub-size resize operations can route through libvips's uhdrload/uhdrsave + * to preserve the gain map. Entries are cleared when the parent finalizes. */ -interface UltraHdrCacheEntry { - gainMap: Uint8Array; - metadata: { - gainMapMin: number[]; - gainMapMax: number[]; - gamma: number[]; - offsetSdr: number[]; - offsetHdr: number[]; - hdrCapacityMin: number; - hdrCapacityMax: number; - }; -} -const ultraHdrCache = new Map< QueueItemId, UltraHdrCacheEntry >(); +const ultraHdrItems = new Set< QueueItemId >(); type ActionCreators = { cancelItem: typeof cancelItem; @@ -101,7 +87,6 @@ type ActionCreators = { updateItemProgress: typeof updateItemProgress; revokeBlobUrls: typeof revokeBlobUrls; detectUltraHdr: typeof detectUltraHdr; - encodeUltraHdrItem: typeof encodeUltraHdrItem; < T = Record< string, unknown > >( args: T ): void; }; @@ -467,10 +452,6 @@ export function processItem( id: QueueItemId ) { case OperationType.DetectUltraHdr: dispatch.detectUltraHdr( id ); break; - - case OperationType.EncodeUltraHdr: - dispatch.encodeUltraHdrItem( id ); - break; } }; } @@ -810,8 +791,9 @@ export function prepareItem( id: QueueItemId ) { } /** - * Detects if a JPEG is an UltraHDR image, decodes it, and caches - * the gain map data for re-encoding into sub-sizes. + * Detects whether a JPEG is an UltraHDR image and records the parent item + * ID so that downstream resize operations route through libvips's + * uhdrload/uhdrsave pipeline (which preserves the gain map). * * @param id Item ID. */ @@ -822,58 +804,30 @@ export function detectUltraHdr( id: QueueItemId ) { return; } - let probeResult; + let info; try { - // Dynamically import to avoid loading WASM unless needed. - const { setWasmUrl, probeUltraHdr } = await import( - 'open-ultrahdr' - ); - // Pass the build-time inlined WASM data URL to the library. - setWasmUrl( ultraHdrWasm ); const buffer = await item.file.arrayBuffer(); - probeResult = await probeUltraHdr( buffer ); + info = await vipsGetUltraHdrInfo( buffer ); } catch { // If UltraHDR detection fails, continue with regular upload. } - if ( probeResult?.isValid ) { - // Decode to extract gain map and metadata for sub-size re-encoding. - try { - const { decodeUltraHdr } = await import( 'open-ultrahdr' ); - const buffer = await item.file.arrayBuffer(); - const decoded = await decodeUltraHdr( id, buffer ); - - ultraHdrCache.set( id, { - gainMap: decoded.gainMap, - metadata: decoded.metadata, - } ); - } catch { - // If decode fails, still upload the original but skip - // gain map preservation in sub-sizes. - } + if ( info ) { + ultraHdrItems.add( id ); - // Mark attachment metadata with UltraHDR info. - // The original file is uploaded unmodified — UltraHDR JPEGs are - // already backwards compatible (SDR displays use the embedded base image). - // - // Replace the remaining operations to skip any transcoding that - // prepareItem may have queued (e.g. format conversion). Transcoding - // would strip the HDR gain map data from the file. + // Mark attachment metadata with UltraHDR info. The original file + // is uploaded unmodified — UltraHDR JPEGs are already backwards + // compatible (SDR displays use the embedded base image). const existingMeta = Array.isArray( item.attachment?.meta ) ? {} : item.attachment?.meta || {}; dispatch.finishOperation( id, { - operations: [ - OperationType.Upload, - OperationType.ThumbnailGeneration, - OperationType.Finalize, - ], attachment: { ...item.attachment, meta: { ...existingMeta, ultrahdr: true, - hdr_capacity: probeResult.hdrCapacity, + hdr_capacity: info.hdrCapacity, }, }, } ); @@ -884,162 +838,6 @@ export function detectUltraHdr( id: QueueItemId ) { }; } -/** - * Converts sRGB component (0-255) to linear light (0-1). - * - * @param c sRGB component value (0-255). - * @return Linear light value (0-1). - */ -function srgbToLinear( c: number ): number { - const s = c / 255; - return s <= 0.04045 ? s / 12.92 : Math.pow( ( s + 0.055 ) / 1.055, 2.4 ); -} - -/** - * Re-encodes a resized SDR JPEG as an UltraHDR image by reconstructing - * HDR data from the cached gain map and metadata. - * - * Uses the ISO 21496-1 gain map application formula to derive HDR linear - * pixel data from the SDR image and gain map, then passes both to the - * UltraHDR encoder which produces a JPEG with an embedded gain map. - * - * @param id Item ID. - */ -export function encodeUltraHdrItem( id: QueueItemId ) { - return async ( { select, dispatch }: ThunkArgs ) => { - const item = select.getItem( id ); - if ( ! item ) { - return; - } - - const parentId = item.parentId; - if ( ! parentId ) { - dispatch.finishOperation( id, {} ); - return; - } - - const cached = ultraHdrCache.get( parentId ); - if ( ! cached ) { - // No gain map data available, skip re-encoding. - dispatch.finishOperation( id, {} ); - return; - } - - try { - const { setWasmUrl, encodeUltraHdr } = await import( - 'open-ultrahdr' - ); - setWasmUrl( ultraHdrWasm ); - - // Decode resized SDR JPEG to pixel data via OffscreenCanvas. - const sdrBlob = new Blob( [ await item.file.arrayBuffer() ], { - type: 'image/jpeg', - } ); - const sdrBitmap = await createImageBitmap( sdrBlob ); - const sdrWidth = sdrBitmap.width; - const sdrHeight = sdrBitmap.height; - - const sdrCanvas = new OffscreenCanvas( sdrWidth, sdrHeight ); - const sdrCtx = sdrCanvas.getContext( '2d' )!; - sdrCtx.drawImage( sdrBitmap, 0, 0 ); - sdrBitmap.close(); - const sdrImageData = sdrCtx.getImageData( - 0, - 0, - sdrWidth, - sdrHeight - ); - - // Decode gain map JPEG to pixel data, resized to match sub-size. - const gainBlob = new Blob( - [ cached.gainMap.buffer as ArrayBuffer ], - { - type: 'image/jpeg', - } - ); - const gainBitmap = await createImageBitmap( gainBlob, { - resizeWidth: sdrWidth, - resizeHeight: sdrHeight, - resizeQuality: 'high', - } ); - const gainCanvas = new OffscreenCanvas( sdrWidth, sdrHeight ); - const gainCtx = gainCanvas.getContext( '2d' )!; - gainCtx.drawImage( gainBitmap, 0, 0 ); - gainBitmap.close(); - const gainImageData = gainCtx.getImageData( - 0, - 0, - sdrWidth, - sdrHeight - ); - - // Apply ISO 21496-1 gain map formula to reconstruct HDR. - const pixelCount = sdrWidth * sdrHeight; - const hdrFloat = new Float32Array( pixelCount * 3 ); - const meta = cached.metadata; - - for ( let i = 0; i < pixelCount; i++ ) { - const sdrIdx = i * 4; // RGBA - const hdrIdx = i * 3; // RGB - - for ( let c = 0; c < 3; c++ ) { - const sdrLinear = srgbToLinear( - sdrImageData.data[ sdrIdx + c ] - ); - // Gain map is stored gamma-encoded; decode to linear. - const gainNorm = gainImageData.data[ sdrIdx + c ] / 255; - const gainLinear = Math.pow( gainNorm, meta.gamma[ c ] ); - // Compute log2 recovery from gain map range. - const logRecovery = - meta.gainMapMin[ c ] + - gainLinear * - ( meta.gainMapMax[ c ] - meta.gainMapMin[ c ] ); - // Apply full HDR weight (weight = 1.0). - const recovery = Math.pow( 2, logRecovery ); - // Reconstruct HDR linear value. - hdrFloat[ hdrIdx + c ] = - ( sdrLinear + meta.offsetSdr[ c ] ) * recovery - - meta.offsetHdr[ c ]; - } - } - - // Re-encode as UltraHDR JPEG. - const sdrBuffer = await item.file.arrayBuffer(); - const encoded = await encodeUltraHdr( - id, - sdrBuffer, - hdrFloat.buffer as ArrayBuffer - ); - - const file = new File( - [ new Blob( [ encoded ], { type: 'image/jpeg' } ) ], - item.file.name, - { type: 'image/jpeg' } - ); - - const blobUrl = createBlobURL( file ); - dispatch< CacheBlobUrlAction >( { - type: Type.CacheBlobUrl, - id, - blobUrl, - } ); - - dispatch.finishOperation( id, { - file, - attachment: { - url: blobUrl, - }, - } ); - } catch ( error ) { - // If re-encoding fails, continue with the SDR-only sub-size. - // This is non-fatal — the sub-size simply won't have HDR data. - // eslint-disable-next-line no-console - console.warn( 'UltraHDR sub-size encoding failed:', error ); - dispatch.finishOperation( id, {} ); - } - }; -} - /** * Uploads an item to the server. * @@ -1146,6 +944,10 @@ export function resizeCropItem( id: QueueItemId, args?: ResizeCropItemArgs ) { const addSuffix = Boolean( item.parentId ); // Add '-scaled' suffix for big image threshold resizing. const scaledSuffix = Boolean( args.isThresholdResize ); + // UltraHDR status is tracked on the parent item ID. For sub-sizes, + // look up the parentId; for threshold-resize on the parent itself, + // look up its own id. + const isUltraHdr = ultraHdrItems.has( item.parentId ?? item.id ); try { const file = await vipsResizeImage( @@ -1155,7 +957,9 @@ export function resizeCropItem( id: QueueItemId, args?: ResizeCropItemArgs ) { false, // smartCrop addSuffix, item.abortController?.signal, - scaledSuffix + scaledSuffix, + undefined, // quality (defaults inside vipsResizeImage) + isUltraHdr ); const blobUrl = createBlobURL( file ); @@ -1424,9 +1228,12 @@ export function generateThumbnails( id: QueueItemId ) { : thumbnailSource; const batchId = uuidv4(); - // Check if this is an UltraHDR image with cached gain map data. - // If so, sub-sizes need gain map re-encoding instead of format transcoding. - const hasUltraHdrData = ultraHdrCache.has( item.id ); + // Sub-sizes inherit the parent's UltraHDR status so that the + // resize step routes through libvips's uhdrload/uhdrsave pipeline + // (which preserves the gain map). Format transcoding is skipped + // for UltraHDR sources because converting to a different codec + // would strip the ISO 21496-1 gain map data. + const isUltraHdr = ultraHdrItems.has( item.id ); // Read per-file format conversion data from the attachment response. const outputMimeType = attachment.image_output_format; @@ -1435,7 +1242,6 @@ export function generateThumbnails( id: QueueItemId ) { // Check if thumbnails should be transcoded to a different format. // Uses the same transparency-aware logic as the main image // to avoid converting transparent PNGs to JPEG. - // Skip transcoding for UltraHDR — format conversion strips gain maps. let thumbnailTranscodeOperation: | [ OperationType.TranscodeImage, @@ -1443,7 +1249,7 @@ export function generateThumbnails( id: QueueItemId ) { ] | null = null; - if ( ! hasUltraHdrData && outputMimeType ) { + if ( ! isUltraHdr && outputMimeType ) { thumbnailTranscodeOperation = await getTranscodeImageOperation( thumbnailSource, outputMimeType, @@ -1477,15 +1283,13 @@ export function generateThumbnails( id: QueueItemId ) { for ( const [ , names ] of dimensionGroups ) { const imageSize = allImageSizes[ names[ 0 ] ]; - // Build operations list for this thumbnail. + // Build operations list for this thumbnail. The resize step + // is UltraHDR-aware and will preserve the gain map automatically. const thumbnailOperations: Operation[] = [ [ OperationType.ResizeCrop, { resize: imageSize } ], ]; - if ( hasUltraHdrData ) { - // Re-encode as UltraHDR after resize to preserve gain map. - thumbnailOperations.push( OperationType.EncodeUltraHdr ); - } else if ( thumbnailTranscodeOperation ) { + if ( ! isUltraHdr && thumbnailTranscodeOperation ) { // Add transcoding if format conversion is configured and // the transparency check passed. thumbnailOperations.push( thumbnailTranscodeOperation ); @@ -1531,7 +1335,8 @@ export function generateThumbnails( id: QueueItemId ) { ? renameFile( thumbnailSource, attachment.filename ) : thumbnailSource; - // Add scaling to queue. + // Add scaling to queue. The resize step is UltraHDR-aware + // and will preserve the gain map automatically. const scaledOperations: Operation[] = [ [ OperationType.ResizeCrop, @@ -1545,12 +1350,7 @@ export function generateThumbnails( id: QueueItemId ) { ], ]; - if ( hasUltraHdrData ) { - // Re-encode as UltraHDR after resize to preserve gain map. - scaledOperations.push( - OperationType.EncodeUltraHdr - ); - } else if ( thumbnailTranscodeOperation ) { + if ( ! isUltraHdr && thumbnailTranscodeOperation ) { // Add transcoding if format conversion is configured. scaledOperations.push( thumbnailTranscodeOperation @@ -1609,8 +1409,8 @@ export function finalizeItem( id: QueueItemId ) { } } - // Clean up cached UltraHDR data — all sub-sizes are done by now. - ultraHdrCache.delete( id ); + // Clean up UltraHDR tracking — all sub-sizes are done by now. + ultraHdrItems.delete( id ); dispatch.finishOperation( id, {} ); }; diff --git a/packages/upload-media/src/store/types.ts b/packages/upload-media/src/store/types.ts index e77d76f0f39c35..31b72be3c26e8f 100644 --- a/packages/upload-media/src/store/types.ts +++ b/packages/upload-media/src/store/types.ts @@ -271,7 +271,6 @@ export enum OperationType { Finalize = 'FINALIZE', // UltraHDR operations DetectUltraHdr = 'DETECT_ULTRAHDR', - EncodeUltraHdr = 'ENCODE_ULTRAHDR', } /** diff --git a/packages/upload-media/src/store/utils/index.ts b/packages/upload-media/src/store/utils/index.ts index 6109c85781211d..83ff7384546426 100644 --- a/packages/upload-media/src/store/utils/index.ts +++ b/packages/upload-media/src/store/utils/index.ts @@ -125,6 +125,18 @@ export async function vipsHasTransparency( url: string ) { return hasTransparency( await response.arrayBuffer() ); } +/** + * Probes a JPEG buffer for UltraHDR (ISO 21496-1 gain map) support using vips + * in a web worker. + * + * @param buffer Image buffer to probe. + * @return UltraHDR info if the buffer is a valid UltraHDR JPEG, otherwise null. + */ +export async function vipsGetUltraHdrInfo( buffer: ArrayBuffer ) { + const { vipsGetUltraHdrInfo: getUltraHdrInfo } = await loadVipsModule(); + return getUltraHdrInfo( buffer ); +} + /** * Resizes an image using vips in a web worker. * @@ -136,6 +148,8 @@ export async function vipsHasTransparency( url: string ) { * @param signal Optional abort signal to cancel the operation. * @param scaledSuffix Whether to add '-scaled' suffix instead of dimensions (for big image threshold). * @param quality Desired quality (0-1). Defaults to 0.82. + * @param isUltraHdr Whether the source is an UltraHDR JPEG; routes through + * uhdrload/uhdrsave so the gain map is preserved. * @return Resized ImageFile with dimension metadata. */ export async function vipsResizeImage( @@ -146,7 +160,8 @@ export async function vipsResizeImage( addSuffix: boolean, signal?: AbortSignal, scaledSuffix?: boolean, - quality?: number + quality?: number, + isUltraHdr?: boolean ) { if ( signal?.aborted ) { throw new Error( 'Operation aborted' ); @@ -160,7 +175,8 @@ export async function vipsResizeImage( file.type, resize, smartCrop, - quality + quality, + isUltraHdr ); let fileName = file.name; From 1edd5d72c2aa927271b3475b713e188949a2f0ae Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 8 May 2026 23:31:34 -0700 Subject: [PATCH 21/33] Upload Media: Add UltraHDR test coverage Cover the new UltraHDR pipeline at three levels. Vips unit (packages/vips/src/test/ultrahdr.ts): mock wasm-vips and verify getUltraHdrInfo returns dims + log2-stop capacity for valid inputs, returns null on missing gain map / decode failure, and falls back to zero capacity when the metadata field is absent. Verify resizeImage with isUltraHdr=true routes through uhdrloadBuffer + thumbnailImage + uhdrsaveBuffer instead of newFromBuffer + thumbnailBuffer + writeToBuffer. Upload Media unit (packages/upload-media/src/store/test/ private-actions.js): mock vipsGetUltraHdrInfo and exercise the detectUltraHdr thunk. Cover: positive detection writes attachment.meta.ultrahdr + hdr_capacity, no metadata change when not UltraHDR, graceful pass-through when probing throws, normalization when REST returns meta as [] (rather than {}), and early return when the queue item is missing. E2E (test/e2e/specs/editor/various/client-side-media-processing.spec .js): upload a synthesized 1024x768 UltraHDR JPEG fixture, fetch the medium sub-size from REST, and re-probe it through wasm-vips to confirm the gain map survived the resize. The fixture is generated deterministically by .gen-ultrahdr-fixture.mjs (committed alongside so it can be regenerated without vendoring a third-party binary). --- .../src/store/test/private-actions.js | 114 +++++++++++- packages/vips/src/test/ultrahdr.ts | 167 ++++++++++++++++++ test/e2e/assets/.gen-ultrahdr-fixture.mjs | 75 ++++++++ .../1024x768_e2e_test_image_ultrahdr.jpeg | Bin 0 -> 28105 bytes .../client-side-media-processing.spec.js | 53 ++++++ 5 files changed, 407 insertions(+), 2 deletions(-) create mode 100644 packages/vips/src/test/ultrahdr.ts create mode 100644 test/e2e/assets/.gen-ultrahdr-fixture.mjs create mode 100644 test/e2e/assets/1024x768_e2e_test_image_ultrahdr.jpeg diff --git a/packages/upload-media/src/store/test/private-actions.js b/packages/upload-media/src/store/test/private-actions.js index 0928751b317463..bc6421a15c167e 100644 --- a/packages/upload-media/src/store/test/private-actions.js +++ b/packages/upload-media/src/store/test/private-actions.js @@ -6,9 +6,13 @@ import { createBlobURL, revokeBlobURL } from '@wordpress/blob'; /** * Internal dependencies */ -import { getTranscodeImageOperation, finalizeItem } from '../private-actions'; +import { + getTranscodeImageOperation, + finalizeItem, + detectUltraHdr, +} from '../private-actions'; import { OperationType } from '../types'; -import { vipsHasTransparency } from '../utils'; +import { vipsHasTransparency, vipsGetUltraHdrInfo } from '../utils'; // Mock @wordpress/blob jest.mock( '@wordpress/blob', () => ( { @@ -19,6 +23,7 @@ jest.mock( '@wordpress/blob', () => ( { // Mock vips utilities jest.mock( '../utils', () => ( { vipsHasTransparency: jest.fn(), + vipsGetUltraHdrInfo: jest.fn(), } ) ); describe( 'private actions', () => { @@ -379,4 +384,109 @@ describe( 'private actions', () => { expect( finishOperation ).not.toHaveBeenCalled(); } ); } ); + + describe( 'detectUltraHdr', () => { + const makeItem = () => ( { + file: new File( [ 'fake' ], 'photo.jpg', { + type: 'image/jpeg', + } ), + attachment: { meta: {} }, + } ); + + beforeEach( () => { + jest.clearAllMocks(); + } ); + + it( 'tags the attachment when the buffer is UltraHDR', async () => { + vipsGetUltraHdrInfo.mockResolvedValue( { + width: 1024, + height: 768, + hdrCapacity: 3, + } ); + const finishOperation = jest.fn(); + const item = makeItem(); + const select = { getItem: () => item }; + const dispatch = { finishOperation }; + + const thunk = detectUltraHdr( 'test-id' ); + await thunk( { select, dispatch } ); + + expect( vipsGetUltraHdrInfo ).toHaveBeenCalledTimes( 1 ); + expect( finishOperation ).toHaveBeenCalledWith( 'test-id', { + attachment: { + meta: { + ultrahdr: true, + hdr_capacity: 3, + }, + }, + } ); + } ); + + it( 'finishes with no metadata when buffer is not UltraHDR', async () => { + vipsGetUltraHdrInfo.mockResolvedValue( null ); + const finishOperation = jest.fn(); + const select = { getItem: () => makeItem() }; + const dispatch = { finishOperation }; + + const thunk = detectUltraHdr( 'test-id' ); + await thunk( { select, dispatch } ); + + expect( finishOperation ).toHaveBeenCalledWith( 'test-id', {} ); + } ); + + it( 'falls through gracefully when probe throws', async () => { + vipsGetUltraHdrInfo.mockRejectedValue( + new Error( 'wasm module unavailable' ) + ); + const finishOperation = jest.fn(); + const select = { getItem: () => makeItem() }; + const dispatch = { finishOperation }; + + const thunk = detectUltraHdr( 'test-id' ); + await thunk( { select, dispatch } ); + + // Probe failure must not cancel the upload — pass-through finish. + expect( finishOperation ).toHaveBeenCalledWith( 'test-id', {} ); + } ); + + it( 'normalizes meta when attachment.meta is an array', async () => { + vipsGetUltraHdrInfo.mockResolvedValue( { + width: 800, + height: 600, + hdrCapacity: 2, + } ); + const finishOperation = jest.fn(); + // WP REST sometimes returns `meta: []` for empty meta; + // the thunk must spread an object, not the array. + const item = { + file: new File( [ 'fake' ], 'photo.jpg', { + type: 'image/jpeg', + } ), + attachment: { meta: [] }, + }; + const select = { getItem: () => item }; + const dispatch = { finishOperation }; + + const thunk = detectUltraHdr( 'test-id' ); + await thunk( { select, dispatch } ); + + const call = finishOperation.mock.calls[ 0 ]; + expect( call[ 1 ].attachment.meta ).toEqual( { + ultrahdr: true, + hdr_capacity: 2, + } ); + } ); + + it( 'returns early when item is not found', async () => { + const finishOperation = jest.fn(); + const select = { getItem: () => undefined }; + const dispatch = { finishOperation }; + + const thunk = detectUltraHdr( 'missing' ); + await thunk( { select, dispatch } ); + + expect( vipsGetUltraHdrInfo ).not.toHaveBeenCalled(); + expect( finishOperation ).not.toHaveBeenCalled(); + } ); + } ); } ); diff --git a/packages/vips/src/test/ultrahdr.ts b/packages/vips/src/test/ultrahdr.ts new file mode 100644 index 00000000000000..072bac87919f76 --- /dev/null +++ b/packages/vips/src/test/ultrahdr.ts @@ -0,0 +1,167 @@ +/** + * Internal dependencies + */ +import { getUltraHdrInfo, resizeImage } from '../'; + +const mockThumbnailImage = jest.fn(); +const mockThumbnailBuffer = jest.fn(); +const mockNewFromBuffer = jest.fn(); +const mockUhdrLoadBuffer = jest.fn(); +const mockUhdrSaveBuffer = jest.fn( + () => new Uint8Array( [ 0xff, 0xd8, 0xff ] ) +); +const mockWriteToBuffer = jest.fn( () => ( { buffer: new ArrayBuffer( 0 ) } ) ); +const mockGetDouble = jest.fn(); + +class MockImage { + width = 100; + height = 100; + pageHeight = 100; + gainmap: MockImage | undefined; + thumbnailImage = mockThumbnailImage.mockImplementation( () => this ); + uhdrsaveBuffer = mockUhdrSaveBuffer; + writeToBuffer = mockWriteToBuffer; + getDouble = mockGetDouble; + crop = jest.fn( () => this ); +} + +class MockVipsImage { + static thumbnailBuffer = mockThumbnailBuffer.mockImplementation( + () => new MockImage() + ); + static newFromBuffer = mockNewFromBuffer.mockImplementation( + () => new MockImage() + ); + static uhdrloadBuffer = mockUhdrLoadBuffer; +} + +jest.mock( 'wasm-vips', () => + jest.fn( () => ( { + Image: MockVipsImage, + } ) ) +); + +describe( 'UltraHDR helpers', () => { + afterEach( () => { + jest.clearAllMocks(); + } ); + + describe( 'getUltraHdrInfo', () => { + it( 'returns dims + log2 capacity for valid UltraHDR', async () => { + const image = new MockImage(); + image.width = 1024; + image.pageHeight = 768; + // Mark as having a gain map so the helper recognizes it. + image.gainmap = new MockImage(); + mockGetDouble.mockReturnValueOnce( 8 ); // linear capacity 8 → 3 stops + mockUhdrLoadBuffer.mockReturnValueOnce( image ); + + const buffer = new ArrayBuffer( 16 ); + const result = await getUltraHdrInfo( buffer ); + + expect( mockUhdrLoadBuffer ).toHaveBeenCalledWith( buffer ); + expect( mockGetDouble ).toHaveBeenCalledWith( + 'gainmap-hdr-capacity-max' + ); + expect( result ).toEqual( { + width: 1024, + height: 768, + hdrCapacity: 3, + } ); + } ); + + it( 'returns null when image has no gain map', async () => { + const image = new MockImage(); + // gainmap stays undefined. + mockUhdrLoadBuffer.mockReturnValueOnce( image ); + + const result = await getUltraHdrInfo( new ArrayBuffer( 16 ) ); + + expect( result ).toBeNull(); + expect( mockGetDouble ).not.toHaveBeenCalled(); + } ); + + it( 'returns null when uhdrloadBuffer throws', async () => { + mockUhdrLoadBuffer.mockImplementationOnce( () => { + throw new Error( 'not an UltraHDR jpeg' ); + } ); + + const result = await getUltraHdrInfo( new ArrayBuffer( 16 ) ); + + expect( result ).toBeNull(); + } ); + + it( 'falls back to zero capacity when metadata missing', async () => { + const image = new MockImage(); + image.width = 256; + image.pageHeight = 256; + image.gainmap = new MockImage(); + mockGetDouble.mockImplementationOnce( () => { + throw new Error( 'no such field' ); + } ); + mockUhdrLoadBuffer.mockReturnValueOnce( image ); + + const result = await getUltraHdrInfo( new ArrayBuffer( 16 ) ); + + expect( result ).toEqual( { + width: 256, + height: 256, + hdrCapacity: 0, + } ); + } ); + } ); + + describe( 'resizeImage with isUltraHdr', () => { + it( 'loads via uhdrloadBuffer and saves via uhdrsaveBuffer when isUltraHdr=true', async () => { + const image = new MockImage(); + image.width = 1024; + image.pageHeight = 768; + image.gainmap = new MockImage(); + mockUhdrLoadBuffer.mockReturnValueOnce( image ); + + const buffer = new ArrayBuffer( 16 ); + await resizeImage( + 'itemId', + buffer, + 'image/jpeg', + { width: 200, height: 0 }, + false, + 0.7, + true + ); + + // Should NOT use the regular load path. + expect( mockNewFromBuffer ).not.toHaveBeenCalled(); + expect( mockThumbnailBuffer ).not.toHaveBeenCalled(); + + // UltraHDR path: uhdrload, then thumbnailImage on the loaded image. + expect( mockUhdrLoadBuffer ).toHaveBeenCalledWith( buffer ); + expect( mockThumbnailImage ).toHaveBeenCalledWith( 200, { + size: 'down', + height: 150, + } ); + // Saves with quality scaled to 0..100; no `keep` so XMP gain map metadata is preserved. + expect( mockUhdrSaveBuffer ).toHaveBeenCalledWith( { + Q: 70, + } ); + } ); + + it( 'uses the regular path when isUltraHdr=false', async () => { + await resizeImage( + 'itemId', + new ArrayBuffer( 16 ), + 'image/jpeg', + { width: 200, height: 200 }, + false, + 0.82, + false + ); + + expect( mockUhdrLoadBuffer ).not.toHaveBeenCalled(); + expect( mockUhdrSaveBuffer ).not.toHaveBeenCalled(); + expect( mockNewFromBuffer ).toHaveBeenCalled(); + expect( mockThumbnailBuffer ).toHaveBeenCalled(); + expect( mockWriteToBuffer ).toHaveBeenCalled(); + } ); + } ); +} ); diff --git a/test/e2e/assets/.gen-ultrahdr-fixture.mjs b/test/e2e/assets/.gen-ultrahdr-fixture.mjs new file mode 100644 index 00000000000000..cae2b1c031d71f --- /dev/null +++ b/test/e2e/assets/.gen-ultrahdr-fixture.mjs @@ -0,0 +1,75 @@ +/** + * One-shot generator for the UltraHDR e2e fixture. + * + * Regenerate with: + * cd test/e2e/assets + * node .gen-ultrahdr-fixture.mjs 1024x768_e2e_test_image_ultrahdr.jpeg + * + * Synthesizes a small UltraHDR JPEG (ISO 21496-1 gain map) using wasm-vips's + * encoder so we don't need to vendor a binary asset from a third-party source. + */ +import Vips from 'wasm-vips'; +import fs from 'node:fs'; + +const out = process.argv[ 2 ]; +if ( ! out ) { + console.error( 'Usage: node .gen-ultrahdr-fixture.mjs ' ); + process.exit( 1 ); +} + +const vips = await Vips( {} ); + +const w = 1024; +const h = 768; + +// Base sRGB SDR rendition: simple horizontal gradient. +const xramp = vips.Image.identity( { size: w } ) + .cast( 'uchar' ) + .embed( 0, 0, w, h, { extend: 'copy' } ); +const yramp = vips.Image.identity( { size: h } ) + .cast( 'uchar' ) + .rot90() + .embed( 0, 0, w, h, { extend: 'copy' } ); +const constB = vips.Image.black( w, h ).add( 80 ).cast( 'uchar' ); +const base = xramp + .bandjoin( [ yramp, constB ] ) + .copy( { interpretation: 'srgb' } ); + +// Gain map: half-resolution greyscale, mid-grey for moderate boost. +const gw = w / 2; +const gh = h / 2; +const gainmap = vips.Image.black( gw, gh ) + .add( 128 ) + .cast( 'uchar' ) + .copy( { interpretation: 'b-w' } ); + +// Attach the gain map to the base. libvips understands the `gainmap` +// metadata key and embeds it in the saved UltraHDR JPEG. +base.setImage( 'gainmap', gainmap ); + +// Required ISO 21496-1 metadata fields libvips/libultrahdr expects on +// the base image. Per-channel fields are RGB triplets; capacity fields are +// scalars. Values match a moderate 3-stop boost. +base.setArrayDouble( 'gainmap-min-content-boost', [ 1.0, 1.0, 1.0 ] ); +base.setArrayDouble( 'gainmap-max-content-boost', [ 8.0, 8.0, 8.0 ] ); +base.setDouble( 'gainmap-hdr-capacity-min', 1.0 ); +base.setDouble( 'gainmap-hdr-capacity-max', 8.0 ); +base.setArrayDouble( 'gainmap-gamma', [ 1.0, 1.0, 1.0 ] ); +base.setArrayDouble( 'gainmap-offset-sdr', [ + 0.015625, 0.015625, 0.015625, +] ); +base.setArrayDouble( 'gainmap-offset-hdr', [ + 0.015625, 0.015625, 0.015625, +] ); +base.setInt( 'gainmap-base-rendition-is-hdr', 0 ); +base.setInt( 'gainmap-use-base-cg', 1 ); + +try { + const buf = base.uhdrsaveBuffer( { Q: 85 } ); + fs.writeFileSync( out, Buffer.from( buf ) ); + console.log( `Wrote ${ buf.length } bytes to ${ out }` ); +} catch ( err ) { + console.error( 'uhdrsaveBuffer failed:', err.message ); + console.error( vips.error || vips.Error?.message || '(no extra detail)' ); + process.exit( 1 ); +} diff --git a/test/e2e/assets/1024x768_e2e_test_image_ultrahdr.jpeg b/test/e2e/assets/1024x768_e2e_test_image_ultrahdr.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..405327cb42b5942a66ff333eddfdfecedba42ab2 GIT binary patch literal 28105 zcmeHQ4^&iD8ox6G%pjzVjHvu~pd2VX3?c@~@ed7PhtwI+l-hOWuR~xqfEs(+{#e;! zSd*{|tFeYA(%Px`=i2URb4wGB<+30(;GVNunVIa-O8dL9-@W(U_uh;%pq*XzAouB; zx%1}U``*3x`+nbdf8Te8p$~^nqd%KATMH3dvLps+5JEm^vOsBvPA37w*9eD_yQz69OeGqz1jlAHyxOiin!cNNy=mG5(t{dax z6uW7ULqiBDcheqmBNZz{b$kq+QQo&CHFeE$%d)g3nI@!wM^hrhi+5(hH|L$1TNdMEvZnhgR-HBmfynVTv|Sd%Xu4YP+xg7l;@Y0RN#Bz1230< z!TJ?h@SY532r5Gsl#Ujo2zXtKN>K$Whw>(5h4*z(lD^MIHmI>4t`wpIC?jdk9%zKs zy9{&xoOCU>9-)IzA~daEx)!w?p-C`?juX-~X&yJMwXKC`f`x%oSqS3sMH50dtp@4& z8$uKACEvlzf4iQC`H6sAg}|&l0RM_m35+=cErIdpp;=IhM{#h*51m2!3fuZ*YuN+I zW##$gy}T?r-k6Y-m>g>)j|_EI-Mu^w-F-KTfeRX>dJQ2pl)U0Vj$c!d@haf6@--#7 z9s%WeIAKEZOYTPeDjj~XdTVaSpN9reD)Lr&d3mY4;lATVTVfG%i?Ry%FRw4l(?@bK_}sro2=SX4+@co^WLc7#4w#!7k1sp z&|65WQNc)53O!P46)LS_=p7Ue66dWT2YY-_V=s70jqe0MsL*~hQYus`B|JY20BS#s z)!a+#J$Z(4kxzhmty=$}F8(q5i<-#AuOFUb>An~>JJ3B$-WOhbo8G-^U=qj zoc;9NXXh_{@#R;SuYCQ@x8LD$DPWxJpd)h`mlnpQgk|wk<8djJo8VMwy}V}_eI_q5 ztJgjlppSn{qg!l$@%6*Lk+Urqr{vnYCj>?%oWA7}9vT_hwGHg?pENRYVA8nyk-tg- zi>K0}1?b!9mc7|cFK1WPe!Vn(PLds$^e<&JuRau7b2hEn5|dq3bNQ~$V}ngb{6z}X zK5%M#e_3R9^OP9VU3N>WZJzabHC%3<5`DgQhkama9xk}_0iO#$-q=$g1YIwKs<+LI z?AUcQChMeYAMp7-xLN!h=(+)JzjA4MLDDny31xlY=c?TaH_I=UKh-qSIrM=aI6kzd z(!R(+PtFn;FSGmC)(a*)%MgSb$xGetW5l+xwU`$FL)C^VE94OeS%@O;M*&JfH zuo;kSj-;(u*_^qNEt1V454@Gyg6uDYxdj-nGw|tF>f_igZw?;&aTWz!?9LD$MUdhK z>=3n`H8N*ObUlbBER|~lI7HFMJ!rzPHb<@rNpkP&I&6+y6R-!DitPXh`9sx*DDsvU{xg#~vfrgL$239agUisDXaeSJBu#Mg>Iu0c z`Z6=Yf0ldoA`9fYf0p?}u3r6nu%(su&saZaU}~ndzq;Y%{G+ERC6lt>F({HUSN0UO zGg<~$>t!6yiDKBtG8Tt7;WH-eVB87J=`MjLeDzPZ1=~IYbjM64@$ucsG$AlCVJT^v zdzltAO`vIh@~%O~w~D$Ok15b=>Tw>Xbj&SHbpw?5;qLtSn}PXBY-_cF1sJ$S%1r(@z zE0#h73No7mOwvY5&Mz|_`q!yv&zzU!mV|mltQ2LA$StNoM7eeE z=McFS{2b9HxMMG`*CyaN0qLAX%w+5(Q4$<6llCDT!D;kjJX2Bx!O13Y1O%4{J%>eb z(X#>e5^oJeO>kx}na6((2u`J#A-K#tVts&@CG+@+FXJ4Fz5j-aF7mMPb<6+>#gcRa z9EyDtLNVln69pm<|6_n8L8fO|1WF8?I*0$UU4W#7u4}ak9yNja_{=6?KGdx*gVhda zK!`S>o`hm+N~A#Sc!siZ3g#qKN?2?fD$TShGJQ0Ry!mu_$@NBN%tLLFoo-Ra)c0#1kP^mMK=OHERI)giIH9_X%6Ptij z!sO^1#P+wMkB?!SB&vDX--=wOsGq5XgA{|Mm{7#53JI5DN@*4FlsI6@s*#W><{(#8 z3*0ns!e?xFfuTe`&TJGzvG@ZC#mZC8aNy^sBwyl`Gfy^$CSQ(hb3`r^G|koKus-BA zhiDqMIfTfEd;^ij7ecK(vvM5G03q5jF?i2E4uv1-B~mPG199L-B1FXCk!v{0d2`BK za$B$yU3SouI`cyB zF?xngY}fbRZ;AcY(O&G*QBHFGHr9Ka~sxCkFbtp$*!Kt=x1g3VI4smc5~yp#;PsL8>qwUD>ZvR+elFdIbp&n1i?KTM@?xFYgvRQ*IhiWxcaaOWHw*aStkx1fbOtuG z9cg-{@O^Oxe&c87Bt5o(9W`5K1vp1`TiY+AJ6Y|^1I zdMf@&wf2K^&-|Fo@ZnYwA6knFB+MQGYOMm)wz#xmP|McQ{ZzIvoc9DyfmMe6b0!!X zA04ab{7|a3|JMHg-E09L@+EvIxxjRtfCe#{9-y|AL2agU8xd-U$N4M)=RJW_ZntTQ z&xW=u)mx}{wx)6RH|LovCP&B`2Ad;6?I45N&KI28$nbYKobO^dkMBd<$PLCo zW{#n8cdwzb3XRqCVg>aCzDj!}G>f~`|3i13yVRrQqH~ve)LeA#QjeC4&Ry!!a?!a< zJ!&pGcd19qMdvQ{sJZCer5-KTo4eH9rMAS%IhetHoTU~c2b`rIoHFv3-1D!)? zoTZkD;B}E;Y^|k%cv_Jn=&c?6QC$PyBG3oWfaZ&QiN(rSZfMSzuSl zvEzv!Zj)0uOU+qoND6eyO5=$ivUEiu$Brj{xKBH~RKCV?shg_{^k~JL2chnw=02zu51mQ9P=I sKZv14H|%fq_ahDdgC7g2Sqf>C;$Ke literal 0 HcmV?d00001 diff --git a/test/e2e/specs/editor/various/client-side-media-processing.spec.js b/test/e2e/specs/editor/various/client-side-media-processing.spec.js index 228174adc9396c..7c96562260a5fa 100644 --- a/test/e2e/specs/editor/various/client-side-media-processing.spec.js +++ b/test/e2e/specs/editor/various/client-side-media-processing.spec.js @@ -11,6 +11,31 @@ const { v4: uuid } = require( 'uuid' ); */ const { test, expect } = require( '@wordpress/e2e-test-utils-playwright' ); +/** + * Probes a remote JPEG for an embedded UltraHDR gain map. + * + * Loaded lazily so the wasm-vips runtime (~10MB) only instantiates when an + * UltraHDR test actually runs. + * + * @param {string} url Image URL to fetch. + * @return {Promise<{ width: number, height: number, hasGainmap: boolean }>} Probe result. + */ +async function probeUltraHdrUrl( url ) { + const { default: Vips } = await import( 'wasm-vips' ); + const vips = await Vips( {} ); + const response = await fetch( url ); + if ( ! response.ok ) { + throw new Error( `Failed to fetch ${ url }: ${ response.status }` ); + } + const bytes = new Uint8Array( await response.arrayBuffer() ); + const image = vips.Image.uhdrloadBuffer( bytes ); + return { + width: image.width, + height: image.pageHeight, + hasGainmap: !! image.gainmap, + }; +} + /** * @typedef {import('@playwright/test').Page} Page */ @@ -270,6 +295,34 @@ test.describe( 'Client-side media processing', () => { expect( media.media_details.height ).toBe( 150 ); } ); + test( 'preserves UltraHDR gain map through sub-size resize', async ( { + editor, + mediaProcessingUtils, + requestUtils, + } ) => { + const media = await mediaProcessingUtils.uploadImageAndGetMedia( + editor, + requestUtils, + '1024x768_e2e_test_image_ultrahdr.jpeg' + ); + + expect( media.mime_type ).toBe( 'image/jpeg' ); + expect( media.media_details.width ).toBe( 1024 ); + expect( media.media_details.height ).toBe( 768 ); + + // Default sub-sizes must be generated. + const sizes = media.media_details.sizes; + expect( sizes.thumbnail ).toBeDefined(); + expect( sizes.medium ).toBeDefined(); + + // The medium sub-size must still carry the embedded UltraHDR gain map. + // This proves the resize step routed through libvips's + // uhdrload/uhdrsave pipeline rather than the regular JPEG path + // (which would have stripped the gain map). + const probed = await probeUltraHdrUrl( sizes.medium.source_url ); + expect( probed.hasGainmap ).toBe( true ); + } ); + test( 'scales oversized images and generates the standard sub-sizes', async ( { editor, mediaProcessingUtils, From fb0341651191293cb9d6c47c2f133e9f8ac94a22 Mon Sep 17 00:00:00 2001 From: Adam Silverstein Date: Sat, 9 May 2026 16:57:20 -0700 Subject: [PATCH 22/33] Update packages/vips/src/index.ts Co-authored-by: Kleis Auke Wolthuizen --- packages/vips/src/index.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/packages/vips/src/index.ts b/packages/vips/src/index.ts index 190299af619172..2784703b3a03f2 100644 --- a/packages/vips/src/index.ts +++ b/packages/vips/src/index.ts @@ -298,7 +298,9 @@ function buildSaveOptions( const saveOptions: SaveOptions< typeof type > = { // Strip metadata except ICC color profiles, // matching WordPress core's behavior. - keep: 'icc', +// Strip metadata except ICC color profiles or gainmaps, +// matching WordPress core's behavior. +keep: 'icc|gainmap', }; if ( supportsQuality( type ) ) { From f17ac14fc739c1d97902c3206028d138956f3af8 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Sat, 9 May 2026 17:13:22 -0700 Subject: [PATCH 23/33] Vips: Simplify UltraHDR resize via libvips auto-detection Address kleisauke's review on PR #74873: - Drop the explicit isUltraHdr branching in resizeImage. uhdrload* has higher priority than jpegload* in libvips, so newFromBuffer and thumbnailBuffer auto-detect UltraHDR JPEGs and decode the gain map alongside the base image. jpegsave* delegates to uhdrsave* on output when a gain map is attached, so writeToBuffer handles the save side too. Removes the parameter from vipsResizeImage at every layer. - Crop the gain map alongside the main image on positional crop. Scale crop coordinates to the gain map's resolution, since the gain map can be smaller than the main image. Follows libvips's a-la-carte processing example: https://www.libvips.org/API/current/uhdr.html#a-la-carte-processing - Clean up the keep:'icc|gainmap' save option formatting that was applied as a raw suggestion in the previous commit. Extend the ForeignKeep type to include 'gainmap' and pipe-combined values. Update tests to cover the simplified path, the new gain-map crop branch, and the keep:'icc|gainmap' save option. --- .../upload-media/src/store/private-actions.ts | 8 +- .../upload-media/src/store/utils/index.ts | 11 +- packages/vips/CHANGELOG.md | 3 +- packages/vips/README.md | 6 +- packages/vips/src/index.ts | 94 +++++++------- packages/vips/src/test/ultrahdr.ts | 120 +++++++++++------- packages/vips/src/types.ts | 14 +- packages/vips/src/vips-worker.ts | 31 ++--- 8 files changed, 155 insertions(+), 132 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 4d97b86ebfde7c..304c6a19f3f8c3 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -944,10 +944,6 @@ export function resizeCropItem( id: QueueItemId, args?: ResizeCropItemArgs ) { const addSuffix = Boolean( item.parentId ); // Add '-scaled' suffix for big image threshold resizing. const scaledSuffix = Boolean( args.isThresholdResize ); - // UltraHDR status is tracked on the parent item ID. For sub-sizes, - // look up the parentId; for threshold-resize on the parent itself, - // look up its own id. - const isUltraHdr = ultraHdrItems.has( item.parentId ?? item.id ); try { const file = await vipsResizeImage( @@ -957,9 +953,7 @@ export function resizeCropItem( id: QueueItemId, args?: ResizeCropItemArgs ) { false, // smartCrop addSuffix, item.abortController?.signal, - scaledSuffix, - undefined, // quality (defaults inside vipsResizeImage) - isUltraHdr + scaledSuffix ); const blobUrl = createBlobURL( file ); diff --git a/packages/upload-media/src/store/utils/index.ts b/packages/upload-media/src/store/utils/index.ts index 83ff7384546426..664e0d1467c8a0 100644 --- a/packages/upload-media/src/store/utils/index.ts +++ b/packages/upload-media/src/store/utils/index.ts @@ -140,6 +140,9 @@ export async function vipsGetUltraHdrInfo( buffer: ArrayBuffer ) { /** * Resizes an image using vips in a web worker. * + * UltraHDR JPEGs are auto-detected by libvips and their gain map is + * preserved through the resize. + * * @param id Queue item ID. * @param file File object. * @param resize Resize options (width, height, crop). @@ -148,8 +151,6 @@ export async function vipsGetUltraHdrInfo( buffer: ArrayBuffer ) { * @param signal Optional abort signal to cancel the operation. * @param scaledSuffix Whether to add '-scaled' suffix instead of dimensions (for big image threshold). * @param quality Desired quality (0-1). Defaults to 0.82. - * @param isUltraHdr Whether the source is an UltraHDR JPEG; routes through - * uhdrload/uhdrsave so the gain map is preserved. * @return Resized ImageFile with dimension metadata. */ export async function vipsResizeImage( @@ -160,8 +161,7 @@ export async function vipsResizeImage( addSuffix: boolean, signal?: AbortSignal, scaledSuffix?: boolean, - quality?: number, - isUltraHdr?: boolean + quality?: number ) { if ( signal?.aborted ) { throw new Error( 'Operation aborted' ); @@ -175,8 +175,7 @@ export async function vipsResizeImage( file.type, resize, smartCrop, - quality, - isUltraHdr + quality ); let fileName = file.name; diff --git a/packages/vips/CHANGELOG.md b/packages/vips/CHANGELOG.md index 570e38f8c47b93..7db64bf5f2b7eb 100644 --- a/packages/vips/CHANGELOG.md +++ b/packages/vips/CHANGELOG.md @@ -4,7 +4,8 @@ ### New Features -- Add `getUltraHdrInfo` for probing UltraHDR (ISO 21496-1 gain map) JPEGs and an `isUltraHdr` flag on `resizeImage` that routes through `uhdrloadBuffer`/`uhdrsaveBuffer` so the gain map is preserved through resize ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). +- Add `getUltraHdrInfo` for probing UltraHDR (ISO 21496-1 gain map) JPEGs ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). +- Preserve UltraHDR gain maps through `resizeImage`: libvips's `uhdrload`/`uhdrsave` priority is leveraged automatically, the save path keeps `icc|gainmap` metadata, and positional crop now also crops the attached gain map ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). - Bump `wasm-vips` to `^0.0.17` for native UltraHDR support ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). ## 1.5.0 (2026-04-29) diff --git a/packages/vips/README.md b/packages/vips/README.md index 5b74f472bfbfb6..3f737721233f7c 100644 --- a/packages/vips/README.md +++ b/packages/vips/README.md @@ -106,6 +106,8 @@ _Returns_ Resizes an image using vips. +UltraHDR JPEGs are auto-detected and preserved: libvips's `uhdrload*` has higher priority than `jpegload*`, so `newFromBuffer`/`thumbnailBuffer` decode the gain map alongside the base image, and `jpegsave*` delegates to `uhdrsave*` on output when a gain map is attached. + _Parameters_ - _id_ `ItemId`: Item ID. @@ -114,7 +116,6 @@ _Parameters_ - _resize_ `ImageSizeCrop`: Resize options. - _smartCrop_ Whether to use smart cropping (i.e. saliency-aware). - _quality_ Desired quality (0-1). -- _isUltraHdr_ Whether the input is an UltraHDR JPEG with a gain map. When true, the image is loaded via uhdrload so libvips resizes the gain map alongside the base image, and the output is saved via uhdrsave so the gain map is re-embedded in the resulting JPEG. _Returns_ @@ -229,6 +230,8 @@ _Returns_ Resizes an image using vips. +UltraHDR JPEGs are auto-detected and preserved: libvips's `uhdrload*` has higher priority than `jpegload*`, so `newFromBuffer`/`thumbnailBuffer` decode the gain map alongside the base image, and `jpegsave*` delegates to `uhdrsave*` on output when a gain map is attached. + _Parameters_ - _id_ `ItemId`: Item ID. @@ -237,7 +240,6 @@ _Parameters_ - _resize_ `ImageSizeCrop`: Resize options. - _smartCrop_ Whether to use smart cropping (i.e. saliency-aware). - _quality_ Desired quality (0-1). -- _isUltraHdr_ Whether the input is an UltraHDR JPEG with a gain map. When true, the image is loaded via uhdrload so libvips resizes the gain map alongside the base image, and the output is saved via uhdrsave so the gain map is re-embedded in the resulting JPEG. _Returns_ diff --git a/packages/vips/src/index.ts b/packages/vips/src/index.ts index 2784703b3a03f2..941a97c95b1cc2 100644 --- a/packages/vips/src/index.ts +++ b/packages/vips/src/index.ts @@ -204,6 +204,11 @@ function applyResizeAndCrop< width: number; height: number; crop: ( ...args: number[] ) => T; + // Optional UltraHDR support: present on Vips.Image instances when the + // source has an embedded gain map. + gainmap?: T; + copy?: () => T; + setImage?: ( name: string, value: T ) => void; }, >( resize: ImageSizeCrop, @@ -281,7 +286,32 @@ function applyResizeAndCrop< const cropWidth = Math.min( image.width, target.width ); const cropHeight = Math.min( image.height, target.height ); - return image.crop( left, top, cropWidth, cropHeight ); + const cropped = image.crop( left, top, cropWidth, cropHeight ); + + // For UltraHDR sources, also crop the attached gain map. The gain map + // can be smaller than the main image, so we scale the crop coordinates + // to its resolution. See: + // https://www.libvips.org/API/current/uhdr.html#a-la-carte-processing + const gainmap = image.gainmap; + const copy = cropped.copy; + const setImage = cropped.setImage; + if ( ! gainmap || ! copy || ! setImage ) { + return cropped; + } + + const hscale = gainmap.width / image.width; + const vscale = gainmap.height / image.height; + const newGainmap = gainmap.crop( + left * hscale, + top * vscale, + cropWidth * hscale, + cropHeight * vscale + ); + + // setImage mutates, so produce a unique copy first. + const result = copy.call( cropped ); + setImage.call( result, 'gainmap', newGainmap ); + return result; } /** @@ -296,11 +326,9 @@ function buildSaveOptions( quality: number ): SaveOptions< typeof type > { const saveOptions: SaveOptions< typeof type > = { - // Strip metadata except ICC color profiles, + // Strip metadata except ICC color profiles or gainmaps, // matching WordPress core's behavior. -// Strip metadata except ICC color profiles or gainmaps, -// matching WordPress core's behavior. -keep: 'icc|gainmap', + keep: 'icc|gainmap', }; if ( supportsQuality( type ) ) { @@ -318,17 +346,17 @@ keep: 'icc|gainmap', /** * Resizes an image using vips. * - * @param id Item ID. - * @param buffer Original file buffer. - * @param type Mime type. - * @param resize Resize options. - * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). - * @param quality Desired quality (0-1). - * @param isUltraHdr Whether the input is an UltraHDR JPEG with a gain map. - * When true, the image is loaded via uhdrload so libvips - * resizes the gain map alongside the base image, and the - * output is saved via uhdrsave so the gain map is - * re-embedded in the resulting JPEG. + * UltraHDR JPEGs are auto-detected and preserved: libvips's `uhdrload*` + * has higher priority than `jpegload*`, so `newFromBuffer`/`thumbnailBuffer` + * decode the gain map alongside the base image, and `jpegsave*` delegates + * to `uhdrsave*` on output when a gain map is attached. + * + * @param id Item ID. + * @param buffer Original file buffer. + * @param type Mime type. + * @param resize Resize options. + * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). + * @param quality Desired quality (0-1). * @return Processed file data plus the old and new dimensions. */ export async function resizeImage( @@ -337,8 +365,7 @@ export async function resizeImage( type: string, resize: ImageSizeCrop, smartCrop = false, - quality = 0.82, - isUltraHdr = false + quality = 0.82 ): Promise< { buffer: ArrayBuffer | ArrayBufferLike; width: number; @@ -370,11 +397,7 @@ export async function resizeImage( } }; - // For UltraHDR JPEGs, load via uhdrload so the gain map is decoded - // alongside the base image and tracked through the thumbnail pipeline. - let image = isUltraHdr - ? vips.Image.uhdrloadBuffer( buffer ) - : vips.Image.newFromBuffer( buffer, strOptions, loadOptions ); + let image = vips.Image.newFromBuffer( buffer, strOptions, loadOptions ); image.onProgress = onProgress; @@ -386,18 +409,6 @@ export async function resizeImage( pageHeight, smartCrop, ( resizeWidth, thumbnailOptions ) => { - // thumbnailImage downsizes the already-loaded image (including - // the attached gain map for UltraHDR inputs), avoiding a - // reload via thumbnailBuffer which would not preserve the - // gain map link for UltraHDR sources. - if ( isUltraHdr ) { - const thumb = image.thumbnailImage( - resizeWidth, - thumbnailOptions - ); - thumb.onProgress = onProgress; - return thumb; - } if ( strOptions ) { thumbnailOptions.option_string = strOptions; } @@ -411,17 +422,8 @@ export async function resizeImage( } ); - let outBuffer: Uint8Array; - if ( isUltraHdr ) { - // Default metadata retention — UltraHDR's gain map structure is - // stored in XMP, so stripping metadata would invalidate the file. - outBuffer = image.uhdrsaveBuffer( { - Q: quality * 100, - } ); - } else { - const saveOptions = buildSaveOptions( type, quality ); - outBuffer = image.writeToBuffer( `.${ ext }`, saveOptions ); - } + const saveOptions = buildSaveOptions( type, quality ); + const outBuffer = image.writeToBuffer( `.${ ext }`, saveOptions ); const result = { buffer: outBuffer.buffer, diff --git a/packages/vips/src/test/ultrahdr.ts b/packages/vips/src/test/ultrahdr.ts index 072bac87919f76..1306687725b094 100644 --- a/packages/vips/src/test/ultrahdr.ts +++ b/packages/vips/src/test/ultrahdr.ts @@ -7,11 +7,10 @@ const mockThumbnailImage = jest.fn(); const mockThumbnailBuffer = jest.fn(); const mockNewFromBuffer = jest.fn(); const mockUhdrLoadBuffer = jest.fn(); -const mockUhdrSaveBuffer = jest.fn( - () => new Uint8Array( [ 0xff, 0xd8, 0xff ] ) -); const mockWriteToBuffer = jest.fn( () => ( { buffer: new ArrayBuffer( 0 ) } ) ); const mockGetDouble = jest.fn(); +const mockSetImage = jest.fn(); +const mockCrop = jest.fn(); class MockImage { width = 100; @@ -19,10 +18,11 @@ class MockImage { pageHeight = 100; gainmap: MockImage | undefined; thumbnailImage = mockThumbnailImage.mockImplementation( () => this ); - uhdrsaveBuffer = mockUhdrSaveBuffer; writeToBuffer = mockWriteToBuffer; getDouble = mockGetDouble; - crop = jest.fn( () => this ); + crop = mockCrop.mockImplementation( () => this ); + copy = jest.fn( () => this ); + setImage = mockSetImage; } class MockVipsImage { @@ -111,57 +111,79 @@ describe( 'UltraHDR helpers', () => { } ); } ); - describe( 'resizeImage with isUltraHdr', () => { - it( 'loads via uhdrloadBuffer and saves via uhdrsaveBuffer when isUltraHdr=true', async () => { - const image = new MockImage(); - image.width = 1024; - image.pageHeight = 768; - image.gainmap = new MockImage(); - mockUhdrLoadBuffer.mockReturnValueOnce( image ); - - const buffer = new ArrayBuffer( 16 ); - await resizeImage( - 'itemId', - buffer, - 'image/jpeg', - { width: 200, height: 0 }, - false, - 0.7, - true - ); + describe( 'resizeImage uses libvips auto-detection for UltraHDR', () => { + it( 'uses newFromBuffer/thumbnailBuffer/writeToBuffer regardless of UltraHDR status', async () => { + // libvips auto-detects UltraHDR via uhdrload's higher priority, + // and writeToBuffer auto-delegates to uhdrsave when a gain map + // is attached. No separate uhdr code path is needed here. + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 200, + height: 200, + } ); - // Should NOT use the regular load path. - expect( mockNewFromBuffer ).not.toHaveBeenCalled(); - expect( mockThumbnailBuffer ).not.toHaveBeenCalled(); + expect( mockUhdrLoadBuffer ).not.toHaveBeenCalled(); + expect( mockNewFromBuffer ).toHaveBeenCalled(); + expect( mockThumbnailBuffer ).toHaveBeenCalled(); + expect( mockWriteToBuffer ).toHaveBeenCalled(); + } ); - // UltraHDR path: uhdrload, then thumbnailImage on the loaded image. - expect( mockUhdrLoadBuffer ).toHaveBeenCalledWith( buffer ); - expect( mockThumbnailImage ).toHaveBeenCalledWith( 200, { - size: 'down', - height: 150, - } ); - // Saves with quality scaled to 0..100; no `keep` so XMP gain map metadata is preserved. - expect( mockUhdrSaveBuffer ).toHaveBeenCalledWith( { - Q: 70, + it( 'passes keep:icc|gainmap to writeToBuffer to preserve gain maps', async () => { + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 200, + height: 200, } ); + + expect( mockWriteToBuffer ).toHaveBeenCalledWith( + '.jpeg', + expect.objectContaining( { keep: 'icc|gainmap' } ) + ); } ); - it( 'uses the regular path when isUltraHdr=false', async () => { - await resizeImage( - 'itemId', - new ArrayBuffer( 16 ), - 'image/jpeg', - { width: 200, height: 200 }, - false, - 0.82, - false + it( 'crops the gain map alongside the main image on positional crop', async () => { + // Build a thumbnail with a gain map at half resolution. + const thumb = new MockImage(); + thumb.width = 200; + thumb.height = 200; + thumb.pageHeight = 200; + const thumbGainmap = new MockImage(); + thumbGainmap.width = 100; + thumbGainmap.height = 100; + thumb.gainmap = thumbGainmap; + mockThumbnailBuffer.mockImplementationOnce( () => thumb ); + + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 100, + height: 100, + crop: [ 'center', 'top' ], + } ); + + // Main image is cropped at full resolution. + expect( thumb.crop ).toHaveBeenCalledWith( 50, 0, 100, 100 ); + // Gain map is cropped at its (halved) scale. + expect( thumbGainmap.crop ).toHaveBeenCalledWith( 25, 0, 50, 50 ); + // Result is set as the gain map on a copy of the cropped image. + expect( mockSetImage ).toHaveBeenCalledWith( + 'gainmap', + expect.anything() ); + } ); - expect( mockUhdrLoadBuffer ).not.toHaveBeenCalled(); - expect( mockUhdrSaveBuffer ).not.toHaveBeenCalled(); - expect( mockNewFromBuffer ).toHaveBeenCalled(); - expect( mockThumbnailBuffer ).toHaveBeenCalled(); - expect( mockWriteToBuffer ).toHaveBeenCalled(); + it( 'skips gain-map crop when no gain map is present', async () => { + const thumb = new MockImage(); + thumb.width = 200; + thumb.height = 200; + thumb.pageHeight = 200; + // gainmap stays undefined. + mockThumbnailBuffer.mockImplementationOnce( () => thumb ); + + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 100, + height: 100, + crop: [ 'center', 'top' ], + } ); + + expect( thumb.crop ).toHaveBeenCalledWith( 50, 0, 100, 100 ); + expect( mockSetImage ).not.toHaveBeenCalled(); } ); } ); } ); diff --git a/packages/vips/src/types.ts b/packages/vips/src/types.ts index d0978ff7979634..685586ee3cf6ca 100644 --- a/packages/vips/src/types.ts +++ b/packages/vips/src/types.ts @@ -33,9 +33,21 @@ type Interesting = * iptc: Keep IPTC metadata. * icc: Keep ICC metadata. * other: Keep other metadata (e.g. PNG comments and some TIFF tags). + * gainmap: Keep gainmap metadata (UltraHDR JPEG). * all: Keep all metadata. + * + * Multiple values can be combined with `|`, e.g. `'icc|gainmap'`. */ -type ForeignKeep = 'none' | 'exif' | 'xmp' | 'iptc' | 'icc' | 'other' | 'all'; +type ForeignKeepValue = + | 'none' + | 'exif' + | 'xmp' + | 'iptc' + | 'icc' + | 'other' + | 'gainmap' + | 'all'; +type ForeignKeep = ForeignKeepValue | `${ ForeignKeepValue }|${ string }`; /** * The rendering intent.'absolute' is best for diff --git a/packages/vips/src/vips-worker.ts b/packages/vips/src/vips-worker.ts index 553a376ad0a35f..6bfacaef8b14c2 100644 --- a/packages/vips/src/vips-worker.ts +++ b/packages/vips/src/vips-worker.ts @@ -103,15 +103,15 @@ export async function vipsCompressImage( /** * Resizes an image using vips in a worker. * - * @param id Item ID. - * @param buffer Original file buffer. - * @param type Mime type. - * @param resize Resize options. - * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). - * @param quality Desired quality (0-1). Defaults to 0.82. - * @param isUltraHdr Whether the input is an UltraHDR JPEG with a gain map. - * When true, libvips loads via uhdrload and saves via - * uhdrsave so the gain map is preserved through resize. + * UltraHDR JPEGs are auto-detected by libvips and their gain map is + * preserved through the resize. + * + * @param id Item ID. + * @param buffer Original file buffer. + * @param type Mime type. + * @param resize Resize options. + * @param smartCrop Whether to use smart cropping (i.e. saliency-aware). + * @param quality Desired quality (0-1). Defaults to 0.82. * @return Processed file data plus the old and new dimensions. */ export async function vipsResizeImage( @@ -120,8 +120,7 @@ export async function vipsResizeImage( type: string, resize: ImageSizeCrop, smartCrop = false, - quality = 0.82, - isUltraHdr = false + quality = 0.82 ): Promise< { buffer: ArrayBuffer | ArrayBufferLike; width: number; @@ -130,15 +129,7 @@ export async function vipsResizeImage( originalHeight: number; } > { const api = getWorkerAPI(); - return api.resizeImage( - id, - buffer, - type, - resize, - smartCrop, - quality, - isUltraHdr - ); + return api.resizeImage( id, buffer, type, resize, smartCrop, quality ); } /** From 0ccd44cb4e8e13d1e207938943ec88cfa0d2e233 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Sat, 9 May 2026 23:31:38 -0700 Subject: [PATCH 24/33] Vips: Fix lint errors in UltraHDR fixture generator Apply prettier formatting and add eslint-disable directives for the legitimate console output and wasm-vips import (the script is a manually-run fixture generator, not part of CI). --- test/e2e/assets/.gen-ultrahdr-fixture.mjs | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/test/e2e/assets/.gen-ultrahdr-fixture.mjs b/test/e2e/assets/.gen-ultrahdr-fixture.mjs index cae2b1c031d71f..9c5d0071e9a42b 100644 --- a/test/e2e/assets/.gen-ultrahdr-fixture.mjs +++ b/test/e2e/assets/.gen-ultrahdr-fixture.mjs @@ -7,7 +7,11 @@ * * Synthesizes a small UltraHDR JPEG (ISO 21496-1 gain map) using wasm-vips's * encoder so we don't need to vendor a binary asset from a third-party source. + * + * Run manually (not part of CI). `wasm-vips` resolves through the workspace + * via `@wordpress/vips`; console output is the script's user interface. */ +/* eslint-disable import/no-extraneous-dependencies, no-console */ import Vips from 'wasm-vips'; import fs from 'node:fs'; @@ -55,12 +59,8 @@ base.setArrayDouble( 'gainmap-max-content-boost', [ 8.0, 8.0, 8.0 ] ); base.setDouble( 'gainmap-hdr-capacity-min', 1.0 ); base.setDouble( 'gainmap-hdr-capacity-max', 8.0 ); base.setArrayDouble( 'gainmap-gamma', [ 1.0, 1.0, 1.0 ] ); -base.setArrayDouble( 'gainmap-offset-sdr', [ - 0.015625, 0.015625, 0.015625, -] ); -base.setArrayDouble( 'gainmap-offset-hdr', [ - 0.015625, 0.015625, 0.015625, -] ); +base.setArrayDouble( 'gainmap-offset-sdr', [ 0.015625, 0.015625, 0.015625 ] ); +base.setArrayDouble( 'gainmap-offset-hdr', [ 0.015625, 0.015625, 0.015625 ] ); base.setInt( 'gainmap-base-rendition-is-hdr', 0 ); base.setInt( 'gainmap-use-base-cg', 1 ); @@ -73,3 +73,4 @@ try { console.error( vips.error || vips.Error?.message || '(no extra detail)' ); process.exit( 1 ); } +/* eslint-enable import/no-extraneous-dependencies, no-console */ From acdb6fa07e0a3098d84c0541ac683a02de46868e Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Sun, 10 May 2026 08:48:58 -0700 Subject: [PATCH 25/33] Performance: Disable libvips operation cache in media-processing spec The cache pins decoded image references, which prevents libheif from releasing its AVIF decoder state across iterations. On a 3000x2000 AVIF input, the WASM heap exhausts after a few runs and the AVIF encode fails with 'heif: Memory allocation error'. Calling Cache.max(0) once after init resolves it; the cache offered no value here since each iteration uses a fresh thumbnail call. --- test/performance/specs/media-processing.spec.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/performance/specs/media-processing.spec.js b/test/performance/specs/media-processing.spec.js index adaf689cf82996..494c5b5c19c0d6 100644 --- a/test/performance/specs/media-processing.spec.js +++ b/test/performance/specs/media-processing.spec.js @@ -48,6 +48,12 @@ async function getVips() { } ); }, } ); + // Disable libvips's operation cache. The cache pins decoded image + // references, which in turn prevents libheif from releasing its + // internal AVIF decoder state. Across the 8 perf-test iterations on + // a 3000x2000 AVIF, this manifests as a `heif: Memory allocation + // error` once the WASM heap is exhausted. + vips.Cache.max( 0 ); return vips; } From fd3060938ab1b636d64bf6bca4bdff9fade5291d Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 27 May 2026 15:17:08 -0400 Subject: [PATCH 26/33] Tests: Add missing Cache.max to wasm-vips mock in ultrahdr tests getVips() calls vipsInstance.Cache.max(0) to disable libvips's operation cache. Without it in the wasm-vips mock, the first getUltraHdrInfo test threw inside getVips, never invoking uhdrloadBuffer. Because the queued mockReturnValueOnce values were not consumed and jest.clearAllMocks() does not drain them, the next tests then read stale mock returns and produced unexpected results. --- packages/vips/src/test/ultrahdr.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/packages/vips/src/test/ultrahdr.ts b/packages/vips/src/test/ultrahdr.ts index 1306687725b094..0f122f474e75b9 100644 --- a/packages/vips/src/test/ultrahdr.ts +++ b/packages/vips/src/test/ultrahdr.ts @@ -38,6 +38,8 @@ class MockVipsImage { jest.mock( 'wasm-vips', () => jest.fn( () => ( { Image: MockVipsImage, + // getVips() calls Cache.max(0) to disable libvips's operation cache. + Cache: { max: jest.fn() }, } ) ) ); From 65689448294285dec7c698a707c5ba6c17ecb60f Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 3 Jun 2026 10:17:10 +0200 Subject: [PATCH 27/33] Upload Media: clear UltraHDR tracking when an item is removed Move the ultraHdrItems set cleanup from finalizeItem to removeItem so the entry is cleared on both successful completion and cancellation, preventing the set from growing over a long editing session. --- packages/upload-media/src/store/private-actions.ts | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index aad48d6a68caa4..2e7ac75ac76605 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -66,7 +66,9 @@ const DEFAULT_OUTPUT_QUALITY = 0.82; /** * Tracks parent item IDs whose source file is an UltraHDR JPEG so that * sub-size resize operations can route through libvips's uhdrload/uhdrsave - * to preserve the gain map. Entries are cleared when the parent finalizes. + * to preserve the gain map. Entries are cleared in `removeItem` when the + * parent item leaves the queue, covering both successful completion and + * cancellation. */ const ultraHdrItems = new Set< QueueItemId >(); @@ -515,6 +517,11 @@ export function removeItem( id: QueueItemId ) { return; } + // Clear any UltraHDR tracking for this item. removeItem runs on both + // successful completion and cancellation, so this prevents the set + // from growing unbounded over a long editing session. + ultraHdrItems.delete( id ); + dispatch( { type: Type.Remove, id, @@ -1433,9 +1440,6 @@ export function finalizeItem( id: QueueItemId ) { } } - // Clean up UltraHDR tracking — all sub-sizes are done by now. - ultraHdrItems.delete( id ); - dispatch.finishOperation( id, updates ); }; } From 215ed5da4fb42703f86f544a119706b39cde957d Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 3 Jun 2026 10:17:20 +0200 Subject: [PATCH 28/33] Upload Media: drop changelog note about unlanded open-ultrahdr deps The standalone open-ultrahdr/open-ultrahdr-wasm dependencies were never landed, so the changelog should not mention removing them. --- packages/upload-media/CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/upload-media/CHANGELOG.md b/packages/upload-media/CHANGELOG.md index 0090e2139e41b7..b8336c9ba5f783 100644 --- a/packages/upload-media/CHANGELOG.md +++ b/packages/upload-media/CHANGELOG.md @@ -4,7 +4,7 @@ ### Enhancement -- UltraHDR (ISO 21496-1 gain map) JPEGs are now detected and resized via libvips's native `uhdrload`/`uhdrsave` pipeline. The standalone `open-ultrahdr` and `open-ultrahdr-wasm` dependencies have been removed; gain maps are preserved automatically through the existing resize step ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). +- UltraHDR (ISO 21496-1 gain map) JPEGs are now detected and resized via libvips's native `uhdrload`/`uhdrsave` pipeline, so gain maps are preserved automatically through the existing resize step ([#74873](https://github.com/WordPress/gutenberg/pull/74873)). ## 0.32.0 (2026-05-27) From cd0acc47d296799780518d4e6de2c51d91891ecf Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 3 Jun 2026 10:17:29 +0200 Subject: [PATCH 29/33] Upload Media: add tests confirming sub-size gain map preservation Add coverage proving UltraHDR gain maps survive into generated sub-sizes: - upload-media: generateThumbnails routes every sub-size and the -scaled copy through resize without transcoding for UltraHDR sources (transcoding would strip the gain map), and transcodes normally once the item is no longer tracked. - vips: resizeImage preserves the gain map on simple downscales and boolean crops (relying on libvips thumbnail) without cropping it manually, in addition to the existing positional-crop coverage. - e2e: assert both the cropped thumbnail and the proportional medium sub-size carry the gain map and match their registered dimensions. --- .../src/store/test/private-actions.js | 187 ++++++++++++++++++ packages/vips/src/test/ultrahdr.ts | 54 +++++ .../client-side-media-processing.spec.js | 21 +- 3 files changed, 258 insertions(+), 4 deletions(-) diff --git a/packages/upload-media/src/store/test/private-actions.js b/packages/upload-media/src/store/test/private-actions.js index 3681ad94b92cd0..9ed3b33f6603b8 100644 --- a/packages/upload-media/src/store/test/private-actions.js +++ b/packages/upload-media/src/store/test/private-actions.js @@ -10,6 +10,8 @@ import { getTranscodeImageOperation, finalizeItem, detectUltraHdr, + generateThumbnails, + removeItem, } from '../private-actions'; import { OperationType } from '../types'; import { vipsHasTransparency, vipsGetUltraHdrInfo } from '../utils'; @@ -24,6 +26,8 @@ jest.mock( '@wordpress/blob', () => ( { jest.mock( '../utils', () => ( { vipsHasTransparency: jest.fn(), vipsGetUltraHdrInfo: jest.fn(), + terminateVipsWorker: jest.fn(), + maybeRecycleVipsWorker: jest.fn(), } ) ); describe( 'private actions', () => { @@ -527,4 +531,187 @@ describe( 'private actions', () => { expect( finishOperation ).not.toHaveBeenCalled(); } ); } ); + + describe( 'generateThumbnails UltraHDR gain-map routing', () => { + const ULTRAHDR_INFO = { width: 1024, height: 768, hdrCapacity: 3 }; + + // Two sizes with distinct dimensions/crop so they form two separate + // groups: a hard-cropped square thumbnail and a proportional medium + // downscale. Together they exercise both resize paths. + const ALL_IMAGE_SIZES = { + thumbnail: { width: 150, height: 150, crop: true }, + medium: { width: 300, height: 0, crop: false }, + }; + + const makeThumbnailItem = ( attachmentOverrides = {} ) => ( { + id: 'uhdr-parent', + file: new File( [ 'fake' ], 'photo.jpg', { type: 'image/jpeg' } ), + sourceFile: new File( [ 'fake' ], 'photo.jpg', { + type: 'image/jpeg', + } ), + attachment: { + id: 42, + filename: 'photo.jpg', + missing_image_sizes: [ 'thumbnail', 'medium' ], + exif_orientation: 1, + ...attachmentOverrides, + }, + } ); + + const makeHarness = ( item, settings = {} ) => { + const addSideloadItem = jest.fn(); + const finishOperation = jest.fn(); + const dispatch = { + addSideloadItem, + finishOperation, + addItem: jest.fn(), + }; + const select = { + getItem: () => item, + getSettings: () => ( { + allImageSizes: ALL_IMAGE_SIZES, + ...settings, + } ), + }; + return { select, dispatch, addSideloadItem }; + }; + + // Normalizes an operations list to the bare operation types, whether + // an entry is a plain type or a [ type, args ] tuple. + const operationTypes = ( sideloadArgs ) => + sideloadArgs.operations.map( ( op ) => + Array.isArray( op ) ? op[ 0 ] : op + ); + + // Marks an item as UltraHDR by running the real detectUltraHdr thunk, + // which is what populates the module-level tracking set that + // generateThumbnails reads. + const markUltraHdr = async ( item ) => { + vipsGetUltraHdrInfo.mockResolvedValue( ULTRAHDR_INFO ); + await detectUltraHdr( item.id )( { + select: { getItem: () => item }, + dispatch: { finishOperation: jest.fn() }, + } ); + }; + + // removeItem owns teardown of the tracking set, so use it to reset + // state between tests (and to exercise the cleanup path itself). + const clearTracking = async ( id ) => { + await removeItem( id )( { + select: { getItem: () => ( {} ), getAllItems: () => [] }, + dispatch: jest.fn(), + } ); + }; + + beforeEach( () => { + jest.clearAllMocks(); + } ); + + afterEach( async () => { + await clearTracking( 'uhdr-parent' ); + } ); + + it( 'routes every sub-size through resize without transcoding, preserving the gain map', async () => { + const item = makeThumbnailItem( { + image_output_format: 'image/webp', + } ); + await markUltraHdr( item ); + + const { select, dispatch, addSideloadItem } = makeHarness( item ); + await generateThumbnails( item.id )( { select, dispatch } ); + + // Both the cropped thumbnail and the proportional medium size + // were dispatched as sideloads. + const sizes = addSideloadItem.mock.calls.map( + ( [ args ] ) => args.additionalData.image_size + ); + expect( sizes ).toEqual( + expect.arrayContaining( [ 'thumbnail', 'medium' ] ) + ); + + // Crucially, none of the sub-size operations transcode the image, + // which would strip the ISO 21496-1 gain map. Each one resizes + // (gain-map-aware) and uploads. + for ( const [ args ] of addSideloadItem.mock.calls ) { + const types = operationTypes( args ); + expect( types ).toContain( OperationType.ResizeCrop ); + expect( types ).toContain( OperationType.Upload ); + expect( types ).not.toContain( OperationType.TranscodeImage ); + } + } ); + + it( 'keeps the over-threshold -scaled full-size copy as UltraHDR (no transcode)', async () => { + const originalCreateImageBitmap = global.createImageBitmap; + global.createImageBitmap = jest.fn( async () => ( { + width: 5000, + height: 4000, + close: jest.fn(), + } ) ); + + try { + const item = makeThumbnailItem( { + image_output_format: 'image/webp', + } ); + await markUltraHdr( item ); + + const { select, dispatch, addSideloadItem } = makeHarness( + item, + { bigImageSizeThreshold: 2560 } + ); + await generateThumbnails( item.id )( { select, dispatch } ); + + const scaledCall = addSideloadItem.mock.calls.find( + ( [ args ] ) => args.additionalData.image_size === 'scaled' + ); + expect( scaledCall ).toBeDefined(); + + const types = operationTypes( scaledCall[ 0 ] ); + expect( types ).toContain( OperationType.ResizeCrop ); + expect( types ).not.toContain( OperationType.TranscodeImage ); + } finally { + global.createImageBitmap = originalCreateImageBitmap; + } + } ); + + it( 'transcodes sub-sizes for non-UltraHDR sources', async () => { + // This item is never marked UltraHDR, so the gain-map guard does + // not apply and the configured format conversion runs as usual. + const item = makeThumbnailItem( { + image_output_format: 'image/webp', + } ); + + const { select, dispatch, addSideloadItem } = makeHarness( item ); + await generateThumbnails( item.id )( { select, dispatch } ); + + const anyTranscode = addSideloadItem.mock.calls.some( + ( [ args ] ) => + operationTypes( args ).includes( + OperationType.TranscodeImage + ) + ); + expect( anyTranscode ).toBe( true ); + } ); + + it( 'clears UltraHDR tracking on removeItem so later processing transcodes normally', async () => { + const item = makeThumbnailItem( { + image_output_format: 'image/webp', + } ); + await markUltraHdr( item ); + // Both success and cancellation route through removeItem. + await clearTracking( item.id ); + + const { select, dispatch, addSideloadItem } = makeHarness( item ); + await generateThumbnails( item.id )( { select, dispatch } ); + + // With tracking cleared the source is treated as a normal JPEG, + // re-enabling transcoding — proving the set was emptied. + const anyTranscode = addSideloadItem.mock.calls.some( + ( [ args ] ) => + operationTypes( args ).includes( + OperationType.TranscodeImage + ) + ); + expect( anyTranscode ).toBe( true ); + } ); + } ); } ); diff --git a/packages/vips/src/test/ultrahdr.ts b/packages/vips/src/test/ultrahdr.ts index 0f122f474e75b9..d8f5da2bbee543 100644 --- a/packages/vips/src/test/ultrahdr.ts +++ b/packages/vips/src/test/ultrahdr.ts @@ -170,6 +170,60 @@ describe( 'UltraHDR helpers', () => { ); } ); + it( 'preserves the gain map on a simple downscale without manually cropping it', async () => { + // A proportional downscale (no crop) relies on libvips's + // `thumbnail` to resize the attached gain map in lockstep, so the + // resize step must not crop it manually, and `writeToBuffer` must + // keep the gain map metadata. + const thumb = new MockImage(); + thumb.width = 300; + thumb.height = 225; + thumb.pageHeight = 225; + thumb.gainmap = new MockImage(); + mockThumbnailBuffer.mockImplementationOnce( () => thumb ); + + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 300, + height: 0, + } ); + + // No positional crop, so neither the image nor its gain map is + // cropped, and no gain map is re-attached manually. + expect( thumb.crop ).not.toHaveBeenCalled(); + expect( mockSetImage ).not.toHaveBeenCalled(); + // The gain map still survives via the keep flag on save. + expect( mockWriteToBuffer ).toHaveBeenCalledWith( + '.jpeg', + expect.objectContaining( { keep: 'icc|gainmap' } ) + ); + } ); + + it( 'preserves the gain map on a boolean (centre) crop without manually cropping it', async () => { + // A boolean crop is handled entirely by `thumbnail` (with its + // crop option), which updates the gain map automatically, so the + // resize step must not crop the gain map itself. + const thumb = new MockImage(); + thumb.width = 150; + thumb.height = 150; + thumb.pageHeight = 150; + thumb.gainmap = new MockImage(); + mockThumbnailBuffer.mockImplementationOnce( () => thumb ); + + await resizeImage( 'itemId', new ArrayBuffer( 16 ), 'image/jpeg', { + width: 150, + height: 150, + crop: true, + } ); + + expect( mockThumbnailBuffer ).toHaveBeenCalled(); + expect( thumb.crop ).not.toHaveBeenCalled(); + expect( mockSetImage ).not.toHaveBeenCalled(); + expect( mockWriteToBuffer ).toHaveBeenCalledWith( + '.jpeg', + expect.objectContaining( { keep: 'icc|gainmap' } ) + ); + } ); + it( 'skips gain-map crop when no gain map is present', async () => { const thumb = new MockImage(); thumb.width = 200; diff --git a/test/e2e/specs/editor/various/client-side-media-processing.spec.js b/test/e2e/specs/editor/various/client-side-media-processing.spec.js index 0722ebb07c0b2a..32e04c8e4dd503 100644 --- a/test/e2e/specs/editor/various/client-side-media-processing.spec.js +++ b/test/e2e/specs/editor/various/client-side-media-processing.spec.js @@ -315,12 +315,25 @@ test.describe( 'Client-side media processing', () => { expect( sizes.thumbnail ).toBeDefined(); expect( sizes.medium ).toBeDefined(); - // The medium sub-size must still carry the embedded UltraHDR gain map. - // This proves the resize step routed through libvips's + // Every generated sub-size must still carry the embedded UltraHDR + // gain map. This proves the resize step routed through libvips's // uhdrload/uhdrsave pipeline rather than the regular JPEG path // (which would have stripped the gain map). - const probed = await probeUltraHdrUrl( sizes.medium.source_url ); - expect( probed.hasGainmap ).toBe( true ); + // + // `thumbnail` is a hard-cropped square (exercising the manual + // gain-map crop path) while `medium` is a proportional downscale + // (exercising libvips's automatic gain-map resize), so checking both + // covers both code paths end to end. + for ( const sizeName of [ 'thumbnail', 'medium' ] ) { + const size = sizes[ sizeName ]; + const probed = await probeUltraHdrUrl( size.source_url ); + expect( probed.hasGainmap ).toBe( true ); + // The decoded base image must match the registered sub-size + // dimensions, confirming the gain map travels with a correctly + // resized/cropped image rather than a stale full-size one. + expect( probed.width ).toBe( size.width ); + expect( probed.height ).toBe( size.height ); + } } ); test( 'scales oversized images and generates the standard sub-sizes', async ( { From 9a1a40b823dd8e2cb8ef914b6ac85d7f0b39cc9c Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Wed, 3 Jun 2026 10:19:36 +0200 Subject: [PATCH 30/33] create-block: revert stray import reordering in check-system-requirements Restore the file to match trunk; the reordering was an unrelated leftover and is not needed for UltraHDR support. --- packages/create-block/lib/check-system-requirements.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/create-block/lib/check-system-requirements.js b/packages/create-block/lib/check-system-requirements.js index f95a2dabb4c755..152931bc191410 100644 --- a/packages/create-block/lib/check-system-requirements.js +++ b/packages/create-block/lib/check-system-requirements.js @@ -1,10 +1,10 @@ /** * External dependencies */ -const { promisify } = require( 'util' ); const { confirm } = require( '@inquirer/prompts' ); const checkSync = require( 'check-node-version' ); const tools = require( 'check-node-version/tools' ); +const { promisify } = require( 'util' ); /** * Internal dependencies From 5500ed3a0be3db03dd40e7e058fed8756615ffc8 Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 5 Jun 2026 14:48:26 +0200 Subject: [PATCH 31/33] Upload Media: drop unused UltraHDR attachment meta detectUltraHdr wrote `ultrahdr`/`hdr_capacity` onto the item's local attachment meta, but uploadItem only sends `additionalData` to the server and the upload response overwrites the local attachment anyway, so the meta was never persisted or read. All gain-map routing is driven by the `ultraHdrItems` set, so the thunk now just probes and tracks the item. --- .../upload-media/src/store/private-actions.ts | 22 ++-------- .../src/store/test/private-actions.js | 44 +++---------------- 2 files changed, 10 insertions(+), 56 deletions(-) diff --git a/packages/upload-media/src/store/private-actions.ts b/packages/upload-media/src/store/private-actions.ts index 2e7ac75ac76605..fdff313162a6af 100644 --- a/packages/upload-media/src/store/private-actions.ts +++ b/packages/upload-media/src/store/private-actions.ts @@ -832,26 +832,12 @@ export function detectUltraHdr( id: QueueItemId ) { // If UltraHDR detection fails, continue with regular upload. } + // Track the item so downstream resize operations preserve the gain + // map and skip format transcoding. The original file is uploaded + // unmodified — UltraHDR JPEGs are already backwards compatible (SDR + // displays use the embedded base image). if ( info ) { ultraHdrItems.add( id ); - - // Mark attachment metadata with UltraHDR info. The original file - // is uploaded unmodified — UltraHDR JPEGs are already backwards - // compatible (SDR displays use the embedded base image). - const existingMeta = Array.isArray( item.attachment?.meta ) - ? {} - : item.attachment?.meta || {}; - dispatch.finishOperation( id, { - attachment: { - ...item.attachment, - meta: { - ...existingMeta, - ultrahdr: true, - hdr_capacity: info.hdrCapacity, - }, - }, - } ); - return; } dispatch.finishOperation( id, {} ); diff --git a/packages/upload-media/src/store/test/private-actions.js b/packages/upload-media/src/store/test/private-actions.js index 9ed3b33f6603b8..22b5ff1cfdf454 100644 --- a/packages/upload-media/src/store/test/private-actions.js +++ b/packages/upload-media/src/store/test/private-actions.js @@ -439,7 +439,7 @@ describe( 'private actions', () => { jest.clearAllMocks(); } ); - it( 'tags the attachment when the buffer is UltraHDR', async () => { + it( 'probes the file and finishes the operation when UltraHDR', async () => { vipsGetUltraHdrInfo.mockResolvedValue( { width: 1024, height: 768, @@ -453,18 +453,14 @@ describe( 'private actions', () => { const thunk = detectUltraHdr( 'test-id' ); await thunk( { select, dispatch } ); + // The thunk only probes and tracks the item (tracking is verified + // via the generateThumbnails routing tests); the upload itself is + // untouched, so it finishes with no attachment updates. expect( vipsGetUltraHdrInfo ).toHaveBeenCalledTimes( 1 ); - expect( finishOperation ).toHaveBeenCalledWith( 'test-id', { - attachment: { - meta: { - ultrahdr: true, - hdr_capacity: 3, - }, - }, - } ); + expect( finishOperation ).toHaveBeenCalledWith( 'test-id', {} ); } ); - it( 'finishes with no metadata when buffer is not UltraHDR', async () => { + it( 'finishes cleanly when buffer is not UltraHDR', async () => { vipsGetUltraHdrInfo.mockResolvedValue( null ); const finishOperation = jest.fn(); const select = { getItem: () => makeItem() }; @@ -491,34 +487,6 @@ describe( 'private actions', () => { expect( finishOperation ).toHaveBeenCalledWith( 'test-id', {} ); } ); - it( 'normalizes meta when attachment.meta is an array', async () => { - vipsGetUltraHdrInfo.mockResolvedValue( { - width: 800, - height: 600, - hdrCapacity: 2, - } ); - const finishOperation = jest.fn(); - // WP REST sometimes returns `meta: []` for empty meta; - // the thunk must spread an object, not the array. - const item = { - file: new File( [ 'fake' ], 'photo.jpg', { - type: 'image/jpeg', - } ), - attachment: { meta: [] }, - }; - const select = { getItem: () => item }; - const dispatch = { finishOperation }; - - const thunk = detectUltraHdr( 'test-id' ); - await thunk( { select, dispatch } ); - - const call = finishOperation.mock.calls[ 0 ]; - expect( call[ 1 ].attachment.meta ).toEqual( { - ultrahdr: true, - hdr_capacity: 2, - } ); - } ); - it( 'returns early when item is not found', async () => { const finishOperation = jest.fn(); const select = { getItem: () => undefined }; From 73f662c37eeaecd98c7afbbd1b696450cce2a66c Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 5 Jun 2026 14:48:34 +0200 Subject: [PATCH 32/33] vips: round gain map crop coordinates to integers Scaling the crop rect to the gain map resolution produced floats, which were passed straight to `crop`. Round to integer pixel coordinates and clamp the width/height to the gain map bounds so the rect never extends past its edges, avoiding sub-pixel alignment ambiguity. --- packages/vips/src/index.ts | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/packages/vips/src/index.ts b/packages/vips/src/index.ts index 470a4e28f3c2c0..799ffbf7051fe4 100644 --- a/packages/vips/src/index.ts +++ b/packages/vips/src/index.ts @@ -316,13 +316,27 @@ function applyResizeAndCrop< return cropped; } + // Scale the crop rect to the gain map's resolution. `crop` expects integer + // pixel coordinates, so round here rather than relying on an implicit + // float-to-int conversion, and clamp to the gain map bounds so the rect + // never extends past its edges. const hscale = gainmap.width / image.width; const vscale = gainmap.height / image.height; + const gainmapLeft = Math.round( left * hscale ); + const gainmapTop = Math.round( top * vscale ); + const gainmapWidth = Math.min( + Math.round( cropWidth * hscale ), + gainmap.width - gainmapLeft + ); + const gainmapHeight = Math.min( + Math.round( cropHeight * vscale ), + gainmap.height - gainmapTop + ); const newGainmap = gainmap.crop( - left * hscale, - top * vscale, - cropWidth * hscale, - cropHeight * vscale + gainmapLeft, + gainmapTop, + gainmapWidth, + gainmapHeight ); // setImage mutates, so produce a unique copy first. From 17179a6fc5da0b2b7f55e2a7f7aa12d217b8525d Mon Sep 17 00:00:00 2001 From: adamsilverstein Date: Fri, 5 Jun 2026 14:48:42 +0200 Subject: [PATCH 33/33] Tests: move UltraHDR e2e fixture generator to bin Relocate the one-shot UltraHDR fixture generator from the e2e assets directory into the e2e bin directory alongside the other utility scripts, dropping the leading dot from the filename and the now-unused no-console eslint exception. --- .../gen-ultrahdr-fixture.mjs} | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) rename test/e2e/{assets/.gen-ultrahdr-fixture.mjs => bin/gen-ultrahdr-fixture.mjs} (89%) diff --git a/test/e2e/assets/.gen-ultrahdr-fixture.mjs b/test/e2e/bin/gen-ultrahdr-fixture.mjs similarity index 89% rename from test/e2e/assets/.gen-ultrahdr-fixture.mjs rename to test/e2e/bin/gen-ultrahdr-fixture.mjs index 9c5d0071e9a42b..9ea019bca16b95 100644 --- a/test/e2e/assets/.gen-ultrahdr-fixture.mjs +++ b/test/e2e/bin/gen-ultrahdr-fixture.mjs @@ -2,8 +2,8 @@ * One-shot generator for the UltraHDR e2e fixture. * * Regenerate with: - * cd test/e2e/assets - * node .gen-ultrahdr-fixture.mjs 1024x768_e2e_test_image_ultrahdr.jpeg + * cd test/e2e/bin + * node gen-ultrahdr-fixture.mjs ../assets/1024x768_e2e_test_image_ultrahdr.jpeg * * Synthesizes a small UltraHDR JPEG (ISO 21496-1 gain map) using wasm-vips's * encoder so we don't need to vendor a binary asset from a third-party source. @@ -11,13 +11,13 @@ * Run manually (not part of CI). `wasm-vips` resolves through the workspace * via `@wordpress/vips`; console output is the script's user interface. */ -/* eslint-disable import/no-extraneous-dependencies, no-console */ +/* eslint-disable import/no-extraneous-dependencies */ import Vips from 'wasm-vips'; import fs from 'node:fs'; const out = process.argv[ 2 ]; if ( ! out ) { - console.error( 'Usage: node .gen-ultrahdr-fixture.mjs ' ); + console.error( 'Usage: node gen-ultrahdr-fixture.mjs ' ); process.exit( 1 ); } @@ -73,4 +73,4 @@ try { console.error( vips.error || vips.Error?.message || '(no extra detail)' ); process.exit( 1 ); } -/* eslint-enable import/no-extraneous-dependencies, no-console */ +/* eslint-enable import/no-extraneous-dependencies */