📝 添加 .gitignore 排除 node_modules 和生成文件

.gitignore

@@ -0,0 +1,33 @@
+# Dependencies
+node_modules/
+package-lock.json
+
+# Build outputs
+dist/
+build/
+*.pyc
+__pycache__/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+
+# Environment
+.env
+.env.local
+
+# Staging area (generated content)
+staging/
+courseware/
+exercises/
+tests/

node_modules/.bin/mustache

@@ -1 +0,0 @@
-../mustache/bin/mustache

node_modules/.bin/tldts

@@ -1 +0,0 @@
-../tldts/bin/cli.js

node_modules/.package-lock.json

@@ -1,686 +0,0 @@
-{
-  "name": "clawd",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "node_modules/@acemir/cssom": {
-      "version": "0.9.31",
-      "resolved": "https://registry.npmjs.org/@acemir/cssom/-/cssom-0.9.31.tgz",
-      "integrity": "sha512-ZnR3GSaH+/vJ0YlHau21FjfLYjMpYVIzTD8M8vIEQvIGxeOXyXdzCI140rrCY862p/C/BbzWsjc1dgnM9mkoTA==",
-      "license": "MIT"
-    },
-    "node_modules/@asamuzakjp/css-color": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-4.1.2.tgz",
-      "integrity": "sha512-NfBUvBaYgKIuq6E/RBLY1m0IohzNHAYyaJGuTK79Z23uNwmz2jl1mPsC5ZxCCxylinKhT1Amn5oNTlx1wN8cQg==",
-      "license": "MIT",
-      "dependencies": {
-        "@csstools/css-calc": "^3.0.0",
-        "@csstools/css-color-parser": "^4.0.1",
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0",
-        "lru-cache": "^11.2.5"
-      }
-    },
-    "node_modules/@asamuzakjp/dom-selector": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-6.8.1.tgz",
-      "integrity": "sha512-MvRz1nCqW0fsy8Qz4dnLIvhOlMzqDVBabZx6lH+YywFDdjXhMY37SmpV1XFX3JzG5GWHn63j6HX6QPr3lZXHvQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@asamuzakjp/nwsapi": "^2.3.9",
-        "bidi-js": "^1.0.3",
-        "css-tree": "^3.1.0",
-        "is-potential-custom-element-name": "^1.0.1",
-        "lru-cache": "^11.2.6"
-      }
-    },
-    "node_modules/@asamuzakjp/nwsapi": {
-      "version": "2.3.9",
-      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
-      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
-      "license": "MIT"
-    },
-    "node_modules/@csstools/color-helpers": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-6.0.1.tgz",
-      "integrity": "sha512-NmXRccUJMk2AWA5A7e5a//3bCIMyOu2hAtdRYrhPPHjDxINuCwX1w6rnIZ4xjLcp0ayv6h8Pc3X0eJUGiAAXHQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0",
-      "engines": {
-        "node": ">=20.19.0"
-      }
-    },
-    "node_modules/@csstools/css-calc": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-3.1.1.tgz",
-      "integrity": "sha512-HJ26Z/vmsZQqs/o3a6bgKslXGFAungXGbinULZO3eMsOyNJHeBBZfup5FiZInOghgoM4Hwnmw+OgbJCNg1wwUQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-color-parser": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-4.0.1.tgz",
-      "integrity": "sha512-vYwO15eRBEkeF6xjAno/KQ61HacNhfQuuU/eGwH67DplL0zD5ZixUa563phQvUelA07yDczIXdtmYojCphKJcw==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "dependencies": {
-        "@csstools/color-helpers": "^6.0.1",
-        "@csstools/css-calc": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-parser-algorithms": "^4.0.0",
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-parser-algorithms": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-4.0.0.tgz",
-      "integrity": "sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      },
-      "peerDependencies": {
-        "@csstools/css-tokenizer": "^4.0.0"
-      }
-    },
-    "node_modules/@csstools/css-syntax-patches-for-csstree": {
-      "version": "1.0.27",
-      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.0.27.tgz",
-      "integrity": "sha512-sxP33Jwg1bviSUXAV43cVYdmjt2TLnLXNqCWl9xmxHawWVjGz/kEbdkr7F9pxJNBN2Mh+dq0crgItbW6tQvyow==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT-0"
-    },
-    "node_modules/@csstools/css-tokenizer": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-4.0.0.tgz",
-      "integrity": "sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/csstools"
-        },
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/csstools"
-        }
-      ],
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.19.0"
-      }
-    },
-    "node_modules/@exodus/bytes": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/@exodus/bytes/-/bytes-1.14.1.tgz",
-      "integrity": "sha512-OhkBFWI6GcRMUroChZiopRiSp2iAMvEBK47NhJooDqz1RERO4QuZIZnjP63TXX8GAiLABkYmX+fuQsdJ1dd2QQ==",
-      "license": "MIT",
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "@noble/hashes": "^1.8.0 || ^2.0.0"
-      },
-      "peerDependenciesMeta": {
-        "@noble/hashes": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/agent-base": {
-      "version": "7.1.4",
-      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
-      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/arxiv-api": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/arxiv-api/-/arxiv-api-1.1.1.tgz",
-      "integrity": "sha512-34Kp1sCS3/n/6vNU9nNs8lPWPxbI+POYPrXGinUKYCqDJeCvnreA8D53In9wCgO97XcsTuKnWxYMhfB6ZsMFxQ==",
-      "license": "ISC",
-      "dependencies": {
-        "axios": "0.19.2",
-        "lodash": "4.17.15",
-        "xml2js": "0.4.23"
-      },
-      "engines": {
-        "node": ">=8.10.0"
-      }
-    },
-    "node_modules/arxiv-api/node_modules/xml2js": {
-      "version": "0.4.23",
-      "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.23.tgz",
-      "integrity": "sha512-ySPiMjM0+pLDftHgXY4By0uswI3SPKLDw/i3UXbnO8M/p28zqexCUoPmQFrYD+/1BzhGJSs2i1ERWKJAtiLrug==",
-      "license": "MIT",
-      "dependencies": {
-        "sax": ">=0.6.0",
-        "xmlbuilder": "~11.0.0"
-      },
-      "engines": {
-        "node": ">=4.0.0"
-      }
-    },
-    "node_modules/axios": {
-      "version": "0.19.2",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-0.19.2.tgz",
-      "integrity": "sha512-fjgm5MvRHLhx+osE2xoekY70AhARk3a6hkN+3Io1jc00jtquGvxYlKlsFUhmUET0V5te6CcZI7lcv2Ym61mjHA==",
-      "deprecated": "Critical security vulnerability fixed in v0.21.1. For more information, see https://github.com/axios/axios/pull/3410",
-      "license": "MIT",
-      "dependencies": {
-        "follow-redirects": "1.5.10"
-      }
-    },
-    "node_modules/bidi-js": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
-      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
-      "license": "MIT",
-      "dependencies": {
-        "require-from-string": "^2.0.2"
-      }
-    },
-    "node_modules/css-tree": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.1.0.tgz",
-      "integrity": "sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==",
-      "license": "MIT",
-      "dependencies": {
-        "mdn-data": "2.12.2",
-        "source-map-js": "^1.0.1"
-      },
-      "engines": {
-        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
-      }
-    },
-    "node_modules/cssstyle": {
-      "version": "5.3.7",
-      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-5.3.7.tgz",
-      "integrity": "sha512-7D2EPVltRrsTkhpQmksIu+LxeWAIEk6wRDMJ1qljlv+CKHJM+cJLlfhWIzNA44eAsHXSNe3+vO6DW1yCYx8SuQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@asamuzakjp/css-color": "^4.1.1",
-        "@csstools/css-syntax-patches-for-csstree": "^1.0.21",
-        "css-tree": "^3.1.0",
-        "lru-cache": "^11.2.4"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/data-urls": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-7.0.0.tgz",
-      "integrity": "sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==",
-      "license": "MIT",
-      "dependencies": {
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^16.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/debug": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz",
-      "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "2.0.0"
-      }
-    },
-    "node_modules/decimal.js": {
-      "version": "10.6.0",
-      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
-      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
-      "license": "MIT"
-    },
-    "node_modules/entities": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
-      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=0.12"
-      },
-      "funding": {
-        "url": "https://github.com/fb55/entities?sponsor=1"
-      }
-    },
-    "node_modules/follow-redirects": {
-      "version": "1.5.10",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.5.10.tgz",
-      "integrity": "sha512-0V5l4Cizzvqt5D44aTXbFZz+FtyXV1vrDN6qrelxtfYQKW0KO0W2T/hkE8xvGa/540LkZlkaUjO4ailYTFtHVQ==",
-      "license": "MIT",
-      "dependencies": {
-        "debug": "=3.1.0"
-      },
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/html-encoding-sniffer": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
-      "integrity": "sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==",
-      "license": "MIT",
-      "dependencies": {
-        "@exodus/bytes": "^1.6.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/http-proxy-agent": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
-      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.0",
-        "debug": "^4.3.4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/http-proxy-agent/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/http-proxy-agent/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/https-proxy-agent": {
-      "version": "7.0.6",
-      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
-      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
-      "license": "MIT",
-      "dependencies": {
-        "agent-base": "^7.1.2",
-        "debug": "4"
-      },
-      "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/https-proxy-agent/node_modules/debug": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-      "license": "MIT",
-      "dependencies": {
-        "ms": "^2.1.3"
-      },
-      "engines": {
-        "node": ">=6.0"
-      },
-      "peerDependenciesMeta": {
-        "supports-color": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/https-proxy-agent/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/is-potential-custom-element-name": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
-      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
-      "license": "MIT"
-    },
-    "node_modules/jsdom": {
-      "version": "28.0.0",
-      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-28.0.0.tgz",
-      "integrity": "sha512-KDYJgZ6T2TKdU8yBfYueq5EPG/EylMsBvCaenWMJb2OXmjgczzwveRCoJ+Hgj1lXPDyasvrgneSn4GBuR1hYyA==",
-      "license": "MIT",
-      "dependencies": {
-        "@acemir/cssom": "^0.9.31",
-        "@asamuzakjp/dom-selector": "^6.7.6",
-        "@exodus/bytes": "^1.11.0",
-        "cssstyle": "^5.3.7",
-        "data-urls": "^7.0.0",
-        "decimal.js": "^10.6.0",
-        "html-encoding-sniffer": "^6.0.0",
-        "http-proxy-agent": "^7.0.2",
-        "https-proxy-agent": "^7.0.6",
-        "is-potential-custom-element-name": "^1.0.1",
-        "parse5": "^8.0.0",
-        "saxes": "^6.0.0",
-        "symbol-tree": "^3.2.4",
-        "tough-cookie": "^6.0.0",
-        "undici": "^7.20.0",
-        "w3c-xmlserializer": "^5.0.0",
-        "webidl-conversions": "^8.0.1",
-        "whatwg-mimetype": "^5.0.0",
-        "whatwg-url": "^16.0.0",
-        "xml-name-validator": "^5.0.0"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      },
-      "peerDependencies": {
-        "canvas": "^3.0.0"
-      },
-      "peerDependenciesMeta": {
-        "canvas": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/lodash": {
-      "version": "4.17.15",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.15.tgz",
-      "integrity": "sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==",
-      "license": "MIT"
-    },
-    "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==",
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": "20 || >=22"
-      }
-    },
-    "node_modules/mdn-data": {
-      "version": "2.12.2",
-      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
-      "integrity": "sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==",
-      "license": "CC0-1.0"
-    },
-    "node_modules/ms": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
-      "license": "MIT"
-    },
-    "node_modules/mustache": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
-      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
-      "license": "MIT",
-      "bin": {
-        "mustache": "bin/mustache"
-      }
-    },
-    "node_modules/parse5": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/parse5/-/parse5-8.0.0.tgz",
-      "integrity": "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA==",
-      "license": "MIT",
-      "dependencies": {
-        "entities": "^6.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/inikulin/parse5?sponsor=1"
-      }
-    },
-    "node_modules/punycode": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
-      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/require-from-string": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
-      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/sax": {
-      "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"
-      }
-    },
-    "node_modules/saxes": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
-      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
-      "license": "ISC",
-      "dependencies": {
-        "xmlchars": "^2.2.0"
-      },
-      "engines": {
-        "node": ">=v12.22.7"
-      }
-    },
-    "node_modules/source-map-js": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
-      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
-      "license": "BSD-3-Clause",
-      "engines": {
-        "node": ">=0.10.0"
-      }
-    },
-    "node_modules/symbol-tree": {
-      "version": "3.2.4",
-      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
-      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
-      "license": "MIT"
-    },
-    "node_modules/tldts": {
-      "version": "7.0.23",
-      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.23.tgz",
-      "integrity": "sha512-ASdhgQIBSay0R/eXggAkQ53G4nTJqTXqC2kbaBbdDwM7SkjyZyO0OaaN1/FH7U/yCeqOHDwFO5j8+Os/IS1dXw==",
-      "license": "MIT",
-      "dependencies": {
-        "tldts-core": "^7.0.23"
-      },
-      "bin": {
-        "tldts": "bin/cli.js"
-      }
-    },
-    "node_modules/tldts-core": {
-      "version": "7.0.23",
-      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.23.tgz",
-      "integrity": "sha512-0g9vrtDQLrNIiCj22HSe9d4mLVG3g5ph5DZ8zCKBr4OtrspmNB6ss7hVyzArAeE88ceZocIEGkyW1Ime7fxPtQ==",
-      "license": "MIT"
-    },
-    "node_modules/tough-cookie": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.0.tgz",
-      "integrity": "sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==",
-      "license": "BSD-3-Clause",
-      "dependencies": {
-        "tldts": "^7.0.5"
-      },
-      "engines": {
-        "node": ">=16"
-      }
-    },
-    "node_modules/tr46": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
-      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
-      "license": "MIT",
-      "dependencies": {
-        "punycode": "^2.3.1"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/undici": {
-      "version": "7.22.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-7.22.0.tgz",
-      "integrity": "sha512-RqslV2Us5BrllB+JeiZnK4peryVTndy9Dnqq62S3yYRRTj0tFQCwEniUy2167skdGOy3vqRzEvl1Dm4sV2ReDg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=20.18.1"
-      }
-    },
-    "node_modules/w3c-xmlserializer": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
-      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
-      "license": "MIT",
-      "dependencies": {
-        "xml-name-validator": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/webidl-conversions": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.1.tgz",
-      "integrity": "sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==",
-      "license": "BSD-2-Clause",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/whatwg-mimetype": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-5.0.0.tgz",
-      "integrity": "sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/whatwg-url": {
-      "version": "16.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-16.0.0.tgz",
-      "integrity": "sha512-9CcxtEKsf53UFwkSUZjG+9vydAsFO4lFHBpJUtjBcoJOCJpKnSJNwCw813zrYJHpCJ7sgfbtOe0V5Ku7Pa1XMQ==",
-      "license": "MIT",
-      "dependencies": {
-        "@exodus/bytes": "^1.11.0",
-        "tr46": "^6.0.0",
-        "webidl-conversions": "^8.0.1"
-      },
-      "engines": {
-        "node": "^20.19.0 || ^22.12.0 || >=24.0.0"
-      }
-    },
-    "node_modules/xml-name-validator": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
-      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=18"
-      }
-    },
-    "node_modules/xml2js": {
-      "version": "0.6.2",
-      "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.6.2.tgz",
-      "integrity": "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==",
-      "license": "MIT",
-      "dependencies": {
-        "sax": ">=0.6.0",
-        "xmlbuilder": "~11.0.0"
-      },
-      "engines": {
-        "node": ">=4.0.0"
-      }
-    },
-    "node_modules/xmlbuilder": {
-      "version": "11.0.1",
-      "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz",
-      "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=4.0"
-      }
-    },
-    "node_modules/xmlchars": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
-      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
-      "license": "MIT"
-    }
-  }
-}

node_modules/@acemir/cssom/LICENSE.txt

@@ -1,20 +0,0 @@
-Copyright (c) Nikita Vasilyev
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@acemir/cssom/README.mdown

@@ -1,64 +0,0 @@
-# CSSOM
-
-CSSOM.js is a CSS parser written in pure JavaScript. It is also a partial implementation of [CSS Object Model](http://dev.w3.org/csswg/cssom/). 
-
-    CSSOM.parse("body {color: black}")
-    -> {
-      cssRules: [
-        {
-          selectorText: "body",
-          style: {
-            0: "color",
-            color: "black",
-            length: 1
-          }
-        }
-      ]
-    }
-
-
-## [Parser demo](https://acemir.github.io/CSSOM/docs/parse.html)
-
-Works well in Google Chrome 6+, Safari 5+, Firefox 3.6+, Opera 10.63+.
-Doesn't work in IE < 9 because of unsupported getters/setters.
-
-To use CSSOM.js in the browser you might want to build a one-file version that exposes a single `CSSOM` global variable:
-
-    ➤ git clone https://github.com/acemir/CSSOM.git
-    ➤ cd CSSOM
-    ➤ node build.js
-    build/CSSOM.js is done
-
-To use it with Node.js or any other CommonJS loader:
-
-    ➤ npm install @acemir/cssom
-
-## Don’t use it if...
-
-You parse CSS to mungle, minify or reformat code like this:
-
-```css
-div {
-  background: gray;
-  background: linear-gradient(to bottom, white 0%, black 100%);
-}
-```
-
-This pattern is often used to give browsers that don’t understand linear gradients a fallback solution (e.g. gray color in the example).
-In CSSOM, `background: gray` [gets overwritten](http://nv.github.io/CSSOM/docs/parse.html#css=div%20%7B%0A%20%20%20%20%20%20background%3A%20gray%3B%0A%20%20%20%20background%3A%20linear-gradient(to%20bottom%2C%20white%200%25%2C%20black%20100%25)%3B%0A%7D).
-It does **NOT** get preserved.
-
-If you do CSS mungling, minification, or image inlining, considere using one of the following:
-
-  * [postcss](https://github.com/postcss/postcss)
-  * [reworkcss/css](https://github.com/reworkcss/css)
-  * [csso](https://github.com/css/csso)
-  * [mensch](https://github.com/brettstimmerman/mensch)
-
-
-## [Tests](https://acemir.github.io/CSSOM/spec/)
-
-To run tests locally:
-
-    ➤ git submodule init
-    ➤ git submodule update

node_modules/@acemir/cssom/build/CSSOM.js

@@ -1,6611 +0,0 @@
-var CSSOM = {
-  /**
-   * Creates and configures a new CSSOM instance with the specified options.
-   * 
-   * @param {Object} opts - Configuration options for the CSSOM instance
-   * @param {Object} [opts.globalObject] - Optional global object to be assigned to CSSOM objects prototype
-   * @returns {Object} A new CSSOM instance with the applied configuration
-   * @description
-   * This method creates a new instance of CSSOM and optionally
-   * configures CSSStyleSheet with a global object reference. When a globalObject is provided
-   * and CSSStyleSheet exists on the instance, it creates a new CSSStyleSheet constructor
-   * using a factory function and assigns the globalObject to its prototype's __globalObject property.
-   */
-  setup: function (opts) {
-    var instance = Object.create(this);
-    if (opts.globalObject) {
-      if (instance.CSSStyleSheet) {
-        var factoryCSSStyleSheet = createFunctionFactory(instance.CSSStyleSheet);
-        var CSSStyleSheet = factoryCSSStyleSheet();
-        CSSStyleSheet.prototype.__globalObject = opts.globalObject;
-
-        instance.CSSStyleSheet = CSSStyleSheet;
-      }
-    }
-    return instance;
-  }
-};
-
-function createFunctionFactory(fn) {
-  return function() {
-    // Create a new function that delegates to the original
-    var newFn = function() {
-      return fn.apply(this, arguments);
-    };
-
-    // Copy prototype chain
-    Object.setPrototypeOf(newFn, Object.getPrototypeOf(fn));
-
-    // Copy own properties
-    for (var key in fn) {
-      if (Object.prototype.hasOwnProperty.call(fn, key)) {
-        newFn[key] = fn[key];
-      }
-    }
-
-    // Clone the .prototype object for constructor-like behavior
-    if (fn.prototype) {
-      newFn.prototype = Object.create(fn.prototype);
-    }
-
-    return newFn;
-  };
-}
-
-
-
-// Utility functions for CSSOM error handling
-
-/**
- * Gets the appropriate error constructor from the global object context.
- * Tries to find the error constructor from parentStyleSheet.__globalObject,
- * then from __globalObject, then falls back to the native constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @return {Function} The error constructor
- */
-function getErrorConstructor(context, errorType) {
-	// Try parentStyleSheet.__globalObject first
-	if (context.parentStyleSheet && context.parentStyleSheet.__globalObject && context.parentStyleSheet.__globalObject[errorType]) {
-		return context.parentStyleSheet.__globalObject[errorType];
-	}
-	
-	// Try __parentStyleSheet (alternative naming)
-	if (context.__parentStyleSheet && context.__parentStyleSheet.__globalObject && context.__parentStyleSheet.__globalObject[errorType]) {
-		return context.__parentStyleSheet.__globalObject[errorType];
-	}
-	
-	// Try __globalObject on the context itself
-	if (context.__globalObject && context.__globalObject[errorType]) {
-		return context.__globalObject[errorType];
-	}
-	
-	// Fall back to native constructor
-	return (typeof global !== 'undefined' && global[errorType]) || 
-	       (typeof window !== 'undefined' && window[errorType]) || 
-	       eval(errorType);
-}
-
-/**
- * Creates an appropriate error with context-aware constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @param {string} message - The error message
- * @param {string} [name] - Optional name for DOMException
- */
-function createError(context, errorType, message, name) {
-	var ErrorConstructor = getErrorConstructor(context, errorType);
-	return new ErrorConstructor(message, name);
-}
-
-/**
- * Creates and throws an appropriate error with context-aware constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @param {string} message - The error message
- * @param {string} [name] - Optional name for DOMException
- */
-function throwError(context, errorType, message, name) {
-	throw createError(context, errorType, message, name);
-}
-
-/**
- * Throws a TypeError for missing required arguments.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name (e.g., 'appendRule')
- * @param {string} objectName - The object name (e.g., 'CSSKeyframesRule')
- * @param {number} [required=1] - Number of required arguments
- * @param {number} [provided=0] - Number of provided arguments
- */
-function throwMissingArguments(context, methodName, objectName, required, provided) {
-	required = required || 1;
-	provided = provided || 0;
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " + 
-	              required + " argument" + (required > 1 ? "s" : "") + " required, but only " + 
-	              provided + " present.";
-	throwError(context, 'TypeError', message);
-}
-
-/**
- * Throws a DOMException for parse errors.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name
- * @param {string} objectName - The object name
- * @param {string} rule - The rule that failed to parse
- * @param {string} [name='SyntaxError'] - The DOMException name
- */
-function throwParseError(context, methodName, objectName, rule, name) {
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
-	              "Failed to parse the rule '" + rule + "'.";
-	throwError(context, 'DOMException', message, name || 'SyntaxError');
-}
-
-/**
- * Throws a DOMException for index errors.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name
- * @param {string} objectName - The object name
- * @param {number} index - The invalid index
- * @param {number} maxIndex - The maximum valid index
- * @param {string} [name='IndexSizeError'] - The DOMException name
- */
-function throwIndexError(context, methodName, objectName, index, maxIndex, name) {
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
-	              "The index provided (" + index + ") is larger than the maximum index (" + maxIndex + ").";
-	throwError(context, 'DOMException', message, name || 'IndexSizeError');
-}
-
-var errorUtils = {
-	createError: createError,
-	getErrorConstructor: getErrorConstructor,
-	throwError: throwError,
-	throwMissingArguments: throwMissingArguments,
-	throwParseError: throwParseError,
-	throwIndexError: throwIndexError
-};
-
-// Shared regex patterns for CSS parsing and validation
-// These patterns are compiled once and reused across multiple files for better performance
-
-// Regex patterns for CSS parsing
-var atKeyframesRegExp = /@(-(?:\w+-)+)?keyframes/g; // Match @keyframes and vendor-prefixed @keyframes
-var beforeRulePortionRegExp = /{(?!.*{)|}(?!.*})|;(?!.*;)|\*\/(?!.*\*\/)/g; // Match the closest allowed character (a opening or closing brace, a semicolon or a comment ending) before the rule
-var beforeRuleValidationRegExp = /^[\s{};]*(\*\/\s*)?$/; // Match that the portion before the rule is empty or contains only whitespace, semicolons, opening/closing braces, and optionally a comment ending (*/) followed by whitespace
-var forwardRuleValidationRegExp = /(?:\s|\/\*|\{|\()/; // Match that the rule is followed by any whitespace, a opening comment, a condition opening parenthesis or a opening brace
-var forwardImportRuleValidationRegExp = /(?:\s|\/\*|'|")/; // Match that the rule is followed by any whitespace, an opening comment, a single quote or double quote
-var forwardRuleClosingBraceRegExp = /{[^{}]*}|}/; // Finds the next closing brace of a rule block
-var forwardRuleSemicolonAndOpeningBraceRegExp = /^.*?({|;)/; // Finds the next semicolon or opening brace after the at-rule
-
-// Regex patterns for CSS selector validation and parsing
-var cssCustomIdentifierRegExp = /^(-?[_a-zA-Z]+(\.[_a-zA-Z]+)*[_a-zA-Z0-9-]*)$/; // Validates a css custom identifier
-var startsWithCombinatorRegExp = /^\s*[>+~]/; // Checks if a selector starts with a CSS combinator (>, +, ~)
-
-/**
- * Parse `@page` selectorText for page name and pseudo-pages
- * Valid formats:
- * - (empty - no name, no pseudo-page)
- * - `:left`, `:right`, `:first`, `:blank` (pseudo-page only)
- * - `named` (named page only)
- * - `named:first` (named page with single pseudo-page)
- * - `named:first:left` (named page with multiple pseudo-pages)
- */
-var atPageRuleSelectorRegExp = /^([^\s:]+)?((?::\w+)*)$/; // Validates @page rule selectors
-
-// Regex patterns for CSSImportRule parsing
-var layerRegExp = /layer\(([^)]*)\)/; // Matches layer() function in @import
-var layerRuleNameRegExp = /^(-?[_a-zA-Z]+(\.[_a-zA-Z]+)*[_a-zA-Z0-9-]*)$/; // Validates layer name (same as custom identifier)
-var doubleOrMoreSpacesRegExp = /\s{2,}/g; // Matches two or more consecutive whitespace characters
-
-
-// Regex patterns for CSS escape sequences and identifiers
-var startsWithHexEscapeRegExp = /^\\[0-9a-fA-F]/; // Checks if escape sequence starts with hex escape
-var identStartCharRegExp = /[a-zA-Z_\u00A0-\uFFFF]/; // Valid identifier start character
-var identCharRegExp = /^[a-zA-Z0-9_\-\u00A0-\uFFFF\\]/; // Valid identifier character
-var specialCharsNeedEscapeRegExp = /[!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~\s]/; // Characters that need escaping
-var combinatorOrSeparatorRegExp = /[\s>+~,()]/; // Selector boundaries and combinators
-var afterHexEscapeSeparatorRegExp = /[\s>+~,(){}\[\]]/; // Characters that separate after hex escape
-var trailingSpaceSeparatorRegExp = /[\s>+~,(){}]/; // Characters that allow trailing space
-var endsWithHexEscapeRegExp = /\\[0-9a-fA-F]{1,6}\s+$/; // Matches selector ending with hex escape + space(s)
-
-/**
- * Regular expression to detect invalid characters in the value portion of a CSS style declaration.
- *
- * This regex matches a colon (:) that is not inside parentheses and not inside single or double quotes.
- * It is used to ensure that the value part of a CSS property does not contain unexpected colons,
- * which would indicate a malformed declaration (e.g., "color: foo:bar;" is invalid).
- *
- * The negative lookahead `(?![^(]*\))` ensures that the colon is not followed by a closing
- * parenthesis without encountering an opening parenthesis, effectively ignoring colons inside
- * function-like values (e.g., `url(data:image/png;base64,...)`).
- *
- * The lookahead `(?=(?:[^'"]|'[^']*'|"[^"]*")*$)` ensures that the colon is not inside single or double quotes,
- * allowing colons within quoted strings (e.g., `content: ":";` or `background: url("foo:bar.png");`).
- *
- * Example:
- * - `color: red;`         // valid, does not match
- * - `background: url(data:image/png;base64,...);` // valid, does not match
- * - `content: ':';`       // valid, does not match
- * - `color: foo:bar;`     // invalid, matches
- */
-var basicStylePropertyValueValidationRegExp = /:(?![^(]*\))(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/;
-
-// Attribute selector pattern: matches attribute-name operator value
-// Operators: =, ~=, |=, ^=, $=, *=
-// Rewritten to avoid ReDoS by using greedy match and trimming in JavaScript
-var attributeSelectorContentRegExp = /^([^\s=~|^$*]+)\s*(~=|\|=|\^=|\$=|\*=|=)\s*(.+)$/;
-
-// Selector validation patterns
-var pseudoElementRegExp = /::[a-zA-Z][\w-]*|:(before|after|first-line|first-letter)(?![a-zA-Z0-9_-])/; // Matches pseudo-elements
-var invalidCombinatorLtGtRegExp = /<>/; // Invalid <> combinator
-var invalidCombinatorDoubleGtRegExp = />>/; // Invalid >> combinator
-var consecutiveCombinatorsRegExp = /[>+~]\s*[>+~]/; // Invalid consecutive combinators
-var invalidSlottedRegExp = /(?:^|[\s>+~,\[])slotted\s*\(/i; // Invalid slotted() without ::
-var invalidPartRegExp = /(?:^|[\s>+~,\[])part\s*\(/i; // Invalid part() without ::
-var invalidCueRegExp = /(?:^|[\s>+~,\[])cue\s*\(/i; // Invalid cue() without ::
-var invalidCueRegionRegExp = /(?:^|[\s>+~,\[])cue-region\s*\(/i; // Invalid cue-region() without ::
-var invalidNestingPattern = /&(?![.\#\[:>\+~\s])[a-zA-Z]/; // Invalid & followed by type selector
-var emptyPseudoClassRegExp = /:(?:is|not|where|has)\(\s*\)/; // Empty pseudo-class like :is()
-var whitespaceNormalizationRegExp = /(['"])(?:\\.|[^\\])*?\1|(\r\n|\r|\n)/g; // Normalize newlines outside quotes
-var newlineRemovalRegExp = /\n/g; // Remove all newlines
-var whitespaceAndDotRegExp = /[\s.]/; // Matches whitespace or dot
-var declarationOrOpenBraceRegExp = /[{;}]/; // Matches declaration separator or open brace
-var ampersandRegExp = /&/; // Matches nesting selector
-var hexEscapeSequenceRegExp = /^([0-9a-fA-F]{1,6})[ \t\r\n\f]?/; // Matches hex escape sequence (1-6 hex digits optionally followed by whitespace)
-var attributeCaseFlagRegExp = /^(.+?)\s+([is])$/i; // Matches case-sensitivity flag at end of attribute value
-var prependedAmpersandRegExp = /^&\s+[:\\.]/; // Matches prepended ampersand pattern (& followed by space and : or .)
-var openBraceGlobalRegExp = /{/g; // Matches opening braces (global)
-var closeBraceGlobalRegExp = /}/g; // Matches closing braces (global)
-var scopePreludeSplitRegExp = /\s*\)\s*to\s+\(/; // Splits scope prelude by ") to ("
-var leadingWhitespaceRegExp = /^\s+/; // Matches leading whitespace (used to implement a ES5-compliant alternative to trimStart())
-var doubleQuoteRegExp = /"/g; // Match all double quotes (for escaping in attribute values)
-var backslashRegExp = /\\/g; // Match all backslashes (for escaping in attribute values)
-
-var regexPatterns = {
-	// Parsing patterns
-	atKeyframesRegExp: atKeyframesRegExp,
-	beforeRulePortionRegExp: beforeRulePortionRegExp,
-	beforeRuleValidationRegExp: beforeRuleValidationRegExp,
-	forwardRuleValidationRegExp: forwardRuleValidationRegExp,
-	forwardImportRuleValidationRegExp: forwardImportRuleValidationRegExp,
-	forwardRuleClosingBraceRegExp: forwardRuleClosingBraceRegExp,
-	forwardRuleSemicolonAndOpeningBraceRegExp: forwardRuleSemicolonAndOpeningBraceRegExp,
-	
-	// Selector validation patterns
-	cssCustomIdentifierRegExp: cssCustomIdentifierRegExp,
-	startsWithCombinatorRegExp: startsWithCombinatorRegExp,
-	atPageRuleSelectorRegExp: atPageRuleSelectorRegExp,
-	
-	// Parsing patterns used in CSSImportRule
-	layerRegExp: layerRegExp,
-	layerRuleNameRegExp: layerRuleNameRegExp,
-	doubleOrMoreSpacesRegExp: doubleOrMoreSpacesRegExp,
-	
-	// Escape sequence and identifier patterns
-	startsWithHexEscapeRegExp: startsWithHexEscapeRegExp,
-	identStartCharRegExp: identStartCharRegExp,
-	identCharRegExp: identCharRegExp,
-	specialCharsNeedEscapeRegExp: specialCharsNeedEscapeRegExp,
-	combinatorOrSeparatorRegExp: combinatorOrSeparatorRegExp,
-	afterHexEscapeSeparatorRegExp: afterHexEscapeSeparatorRegExp,
-	trailingSpaceSeparatorRegExp: trailingSpaceSeparatorRegExp,
-	endsWithHexEscapeRegExp: endsWithHexEscapeRegExp,
-
-	// Basic style property value validation
-	basicStylePropertyValueValidationRegExp: basicStylePropertyValueValidationRegExp,
-
-	// Attribute selector patterns
-	attributeSelectorContentRegExp: attributeSelectorContentRegExp,
-
-	// Selector validation patterns
-	pseudoElementRegExp: pseudoElementRegExp,
-	invalidCombinatorLtGtRegExp: invalidCombinatorLtGtRegExp,
-	invalidCombinatorDoubleGtRegExp: invalidCombinatorDoubleGtRegExp,
-	consecutiveCombinatorsRegExp: consecutiveCombinatorsRegExp,
-	invalidSlottedRegExp: invalidSlottedRegExp,
-	invalidPartRegExp: invalidPartRegExp,
-	invalidCueRegExp: invalidCueRegExp,
-	invalidCueRegionRegExp: invalidCueRegionRegExp,
-	invalidNestingPattern: invalidNestingPattern,
-	emptyPseudoClassRegExp: emptyPseudoClassRegExp,
-	whitespaceNormalizationRegExp: whitespaceNormalizationRegExp,
-	newlineRemovalRegExp: newlineRemovalRegExp,
-	whitespaceAndDotRegExp: whitespaceAndDotRegExp,
-	declarationOrOpenBraceRegExp: declarationOrOpenBraceRegExp,
-	ampersandRegExp: ampersandRegExp,
-	hexEscapeSequenceRegExp: hexEscapeSequenceRegExp,
-	attributeCaseFlagRegExp: attributeCaseFlagRegExp,
-	prependedAmpersandRegExp: prependedAmpersandRegExp,
-	openBraceGlobalRegExp: openBraceGlobalRegExp,
-	closeBraceGlobalRegExp: closeBraceGlobalRegExp,
-	scopePreludeSplitRegExp: scopePreludeSplitRegExp,
-	leadingWhitespaceRegExp: leadingWhitespaceRegExp,
-	doubleQuoteRegExp: doubleQuoteRegExp,
-	backslashRegExp: backslashRegExp
-};
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration
- */
-CSSOM.CSSStyleDeclaration = function CSSStyleDeclaration(){
-	this.length = 0;
-	this.parentRule = null;
-
-	// NON-STANDARD
-	this._importants = {};
-};
-
-
-CSSOM.CSSStyleDeclaration.prototype = {
-
-	constructor: CSSOM.CSSStyleDeclaration,
-
-	/**
-	 *
-	 * @param {string} name
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-getPropertyValue
-	 * @return {string} the value of the property if it has been explicitly set for this declaration block.
-	 * Returns the empty string if the property has not been set.
-	 */
-	getPropertyValue: function(name) {
-		return this[name] || "";
-	},
-
-	/**
-	 *
-	 * @param {string} name
-	 * @param {string} value
-	 * @param {string} [priority=null] "important" or null
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-setProperty
-	 */
-	setProperty: function(name, value, priority, parseErrorHandler) 
-	{
-		// NOTE: Check viability to add a validation for css values or use a dependency like csstree-validator
-		var basicStylePropertyValueValidationRegExp = regexPatterns.basicStylePropertyValueValidationRegExp
-		if (basicStylePropertyValueValidationRegExp.test(value)) {
-			parseErrorHandler && parseErrorHandler('Invalid CSSStyleDeclaration property (name = "' + name + '", value = "' + value + '")');
-		} else if (this[name]) {
-			// Property already exist. Overwrite it.
-			var index = Array.prototype.indexOf.call(this, name);
-			if (index < 0) {
-				this[this.length] = name;
-				this.length++;
-			}
-	
-			// If the priority value of the incoming property is "important",
-			// or the value of the existing property is not "important", 
-			// then remove the existing property and rewrite it.
-			if (priority || !this._importants[name]) {
-				this.removeProperty(name);
-				this[this.length] = name;
-				this.length++;
-				this[name] = value + '';
-				this._importants[name] = priority;
-			}
-		} else {
-			// New property.
-			this[this.length] = name;
-			this.length++;
-			this[name] = value + '';
-			this._importants[name] = priority;
-		}
-	},
-
-	/**
-	 *
-	 * @param {string} name
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-removeProperty
-	 * @return {string} the value of the property if it has been explicitly set for this declaration block.
-	 * Returns the empty string if the property has not been set or the property name does not correspond to a known CSS property.
-	 */
-	removeProperty: function(name) {
-		if (!(name in this)) {
-			return "";
-		}
-		var index = Array.prototype.indexOf.call(this, name);
-		if (index < 0) {
-			return "";
-		}
-		var prevValue = this[name];
-		this[name] = "";
-
-		// That's what WebKit and Opera do
-		Array.prototype.splice.call(this, index, 1);
-
-		// That's what Firefox does
-		//this[index] = ""
-
-		return prevValue;
-	},
-
-	getPropertyCSSValue: function() {
-		//FIXME
-	},
-
-	/**
-	 *
-	 * @param {String} name
-	 */
-	getPropertyPriority: function(name) {
-		return this._importants[name] || "";
-	},
-
-
-	/**
-	 *   element.style.overflow = "auto"
-	 *   element.style.getPropertyShorthand("overflow-x")
-	 *   -> "overflow"
-	 */
-	getPropertyShorthand: function() {
-		//FIXME
-	},
-
-	isPropertyImplicit: function() {
-		//FIXME
-	},
-
-	// Doesn't work in IE < 9
-	get cssText(){
-		var properties = [];
-		for (var i=0, length=this.length; i < length; ++i) {
-			var name = this[i];
-			var value = this.getPropertyValue(name);
-			var priority = this.getPropertyPriority(name);
-			if (priority) {
-				priority = " !" + priority;
-			}
-			properties[i] = name + ": " + value + priority + ";";
-		}
-		return properties.join(" ");
-	},
-
-	set cssText(text){
-		var i, name;
-		for (i = this.length; i--;) {
-			name = this[i];
-			this[name] = "";
-		}
-		Array.prototype.splice.call(this, 0, this.length);
-		this._importants = {};
-
-		var dummyRule = CSSOM.parse('#bogus{' + text + '}').cssRules[0].style;
-		var length = dummyRule.length;
-		for (i = 0; i < length; ++i) {
-			name = dummyRule[i];
-			this.setProperty(dummyRule[i], dummyRule.getPropertyValue(name), dummyRule.getPropertyPriority(name));
-		}
-	}
-};
-
-
-
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#the-cssrule-interface
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSRule
- */
-CSSOM.CSSRule = function CSSRule() {
-  this.__parentRule = null;
-  this.__parentStyleSheet = null;
-};
-
-CSSOM.CSSRule.UNKNOWN_RULE = 0; // obsolete
-CSSOM.CSSRule.STYLE_RULE = 1;
-CSSOM.CSSRule.CHARSET_RULE = 2; // obsolete
-CSSOM.CSSRule.IMPORT_RULE = 3;
-CSSOM.CSSRule.MEDIA_RULE = 4;
-CSSOM.CSSRule.FONT_FACE_RULE = 5;
-CSSOM.CSSRule.PAGE_RULE = 6;
-CSSOM.CSSRule.KEYFRAMES_RULE = 7;
-CSSOM.CSSRule.KEYFRAME_RULE = 8;
-CSSOM.CSSRule.MARGIN_RULE = 9;
-CSSOM.CSSRule.NAMESPACE_RULE = 10;
-CSSOM.CSSRule.COUNTER_STYLE_RULE = 11;
-CSSOM.CSSRule.SUPPORTS_RULE = 12;
-CSSOM.CSSRule.DOCUMENT_RULE = 13;
-CSSOM.CSSRule.FONT_FEATURE_VALUES_RULE = 14;
-CSSOM.CSSRule.VIEWPORT_RULE = 15;
-CSSOM.CSSRule.REGION_STYLE_RULE = 16;
-CSSOM.CSSRule.CONTAINER_RULE = 17;
-CSSOM.CSSRule.LAYER_BLOCK_RULE = 18;
-CSSOM.CSSRule.STARTING_STYLE_RULE = 1002;
-
-Object.defineProperties(CSSOM.CSSRule.prototype, {
-
-  constructor: { value: CSSOM.CSSRule },
-
-  cssRule: {
-    value: "",
-    configurable: true,
-    enumerable: true
-  },
-
-  cssText: {
-    get: function() {
-      // Default getter: subclasses should override this
-      return "";
-    },
-    set: function(cssText) {
-      return cssText;
-    }
-  },
-
-  parentRule: {
-    get: function() {
-      return this.__parentRule
-    }
-  },
-
-  parentStyleSheet: {
-    get: function() {
-      return this.__parentStyleSheet
-    }
-  },
-  
-  UNKNOWN_RULE: { value: 0, enumerable: true }, // obsolet
-  STYLE_RULE: { value: 1, enumerable: true },
-  CHARSET_RULE: { value: 2, enumerable: true }, // obsolet
-  IMPORT_RULE: { value: 3, enumerable: true },
-  MEDIA_RULE: { value: 4, enumerable: true },
-  FONT_FACE_RULE: { value: 5, enumerable: true },
-  PAGE_RULE: { value: 6, enumerable: true },
-  KEYFRAMES_RULE: { value: 7, enumerable: true },
-  KEYFRAME_RULE: { value: 8, enumerable: true },
-  MARGIN_RULE: { value: 9, enumerable: true },
-  NAMESPACE_RULE: { value: 10, enumerable: true },
-  COUNTER_STYLE_RULE: { value: 11, enumerable: true },
-  SUPPORTS_RULE: { value: 12, enumerable: true },
-  DOCUMENT_RULE: { value: 13, enumerable: true },
-  FONT_FEATURE_VALUES_RULE: { value: 14, enumerable: true },
-  VIEWPORT_RULE: { value: 15, enumerable: true },
-  REGION_STYLE_RULE: { value: 16, enumerable: true },
-  CONTAINER_RULE: { value: 17, enumerable: true },
-  LAYER_BLOCK_RULE: { value: 18, enumerable: true },
-  STARTING_STYLE_RULE: { value: 1002, enumerable: true },
-});
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssrulelist-interface
- */
-CSSOM.CSSRuleList = function CSSRuleList(){
-  var arr = new Array();
-  Object.setPrototypeOf(arr, CSSOM.CSSRuleList.prototype);
-  return arr;
-};
-
-CSSOM.CSSRuleList.prototype = Object.create(Array.prototype);
-CSSOM.CSSRuleList.prototype.constructor = CSSOM.CSSRuleList;
-
-CSSOM.CSSRuleList.prototype.item = function(index) {
-    return this[index] || null;
-};
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-nesting-1/
- */
-CSSOM.CSSNestedDeclarations = function CSSNestedDeclarations() {
-  CSSOM.CSSRule.call(this);
-  this.__style = new CSSOM.CSSStyleDeclaration();
-  this.__style.parentRule = this;
-};
-
-CSSOM.CSSNestedDeclarations.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSNestedDeclarations.prototype.constructor = CSSOM.CSSNestedDeclarations;
-
-Object.setPrototypeOf(CSSOM.CSSNestedDeclarations, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "type", {
-  value: 0,
-  writable: false
-});
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "cssText", {
-  get: function () {
-    return this.style.cssText;
-  }
-});
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssgroupingrule-interface
- */
-CSSOM.CSSGroupingRule = function CSSGroupingRule() {
-	CSSOM.CSSRule.call(this);
-	this.__cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSGroupingRule.prototype  = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
-
-Object.setPrototypeOf(CSSOM.CSSGroupingRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSGroupingRule.prototype, "cssRules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-/**
- * Used to insert a new CSS rule to a list of CSS rules.
- *
- * @example
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}"
- *   cssGroupingRule.insertRule("img{border:none;}", 1)
- *   -> 1
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}img{border:none;}"
- *
- * @param {string} rule
- * @param {number} [index]
- * @see https://www.w3.org/TR/cssom-1/#dom-cssgroupingrule-insertrule
- * @return {number} The index within the grouping rule's collection of the newly inserted rule.
- */
- CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule, index) {
-	if (rule === undefined && index === undefined) {
-		errorUtils.throwMissingArguments(this, 'insertRule', this.constructor.name);
-	}
-	if (index === void 0) {
-		index = 0;
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index > this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'insertRule', this.constructor.name, index, this.cssRules.length);
-	}
-	var ruleToParse = processedRuleToParse = String(rule);
-	ruleToParse = ruleToParse.trim().replace(/^\/\*[\s\S]*?\*\/\s*/, "");
-	var isNestedSelector = this.constructor.name === "CSSStyleRule";
-	if (isNestedSelector === false) {
-		var currentRule = this;
-		while (currentRule.parentRule) {
-			currentRule = currentRule.parentRule;
-			if (currentRule.constructor.name === "CSSStyleRule") {
-				isNestedSelector = true;
-				break;
-			}
-		}
-	}
-	if (isNestedSelector) {
-		processedRuleToParse = 's { n { } ' + ruleToParse + '}';
-	}
-	var isScopeRule = this.constructor.name === "CSSScopeRule";
-	if (isScopeRule) {
-		if (isNestedSelector) {
-			processedRuleToParse = 's { ' + '@scope {' + ruleToParse + '}}';
-		} else {
-			processedRuleToParse = '@scope {' + ruleToParse + '}';
-		}
-	}
-	var parsedRules = new CSSOM.CSSRuleList();
-	CSSOM.parse(processedRuleToParse, {
-		styleSheet: this.parentStyleSheet,
-		cssRules: parsedRules
-	});
-	if (isScopeRule) {
-		if (isNestedSelector) {
-			parsedRules = parsedRules[0].cssRules[0].cssRules;
-		} else {
-			parsedRules = parsedRules[0].cssRules
-		}
-	}
-	if (isNestedSelector) {
-		parsedRules = parsedRules[0].cssRules.slice(1);
-	}
-	if (parsedRules.length !== 1) {
-		if (isNestedSelector && parsedRules.length === 0 && ruleToParse.indexOf('@font-face') === 0) {
-			errorUtils.throwError(this, 'DOMException', 
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': " +
-				"Only conditional nested group rules, style rules, @scope rules, @apply rules, and nested declaration rules may be nested.",
-				'HierarchyRequestError');
-		} else {
-			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-		}
-	}
-	var cssRule = parsedRules[0];
-
-	if (cssRule.constructor.name === 'CSSNestedDeclarations' && cssRule.style.length === 0) {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');	
-	}
-	
-	// Check for rules that cannot be inserted inside a CSSGroupingRule
-	if (cssRule.constructor.name === 'CSSImportRule' || cssRule.constructor.name === 'CSSNamespaceRule') {
-		var ruleKeyword = cssRule.constructor.name === 'CSSImportRule' ? '@import' : '@namespace';
-		errorUtils.throwError(this, 'DOMException', 
-			"Failed to execute 'insertRule' on '" + this.constructor.name + "': " +
-			"'" + ruleKeyword + "' rules cannot be inserted inside a group rule.",
-			'HierarchyRequestError');
-	}
-	
-	// Check for CSSLayerStatementRule (@layer statement rules)
-	if (cssRule.constructor.name === 'CSSLayerStatementRule') {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-	}
-	
-	cssRule.__parentRule = this;
-	this.cssRules.splice(index, 0, cssRule);
-	return index;
-};
-
-/**
- * Used to delete a rule from the grouping rule.
- *
- *   cssGroupingRule.cssText
- *   -> "img{border:none;}body{margin:0;}"
- *   cssGroupingRule.deleteRule(0)
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}"
- *
- * @param {number} index within the grouping rule's rule list of the rule to remove.
- * @see https://www.w3.org/TR/cssom-1/#dom-cssgroupingrule-deleterule
- */
- CSSOM.CSSGroupingRule.prototype.deleteRule = function deleteRule(index) {
-	if (index === undefined) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', this.constructor.name);
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index >= this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
-	}
-	this.cssRules[index].__parentRule = null;
-	this.cssRules[index].__parentStyleSheet = null;
-	this.cssRules.splice(index, 1);
-};
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-counter-styles/#the-csscounterstylerule-interface
- */
-CSSOM.CSSCounterStyleRule = function CSSCounterStyleRule() {
-	CSSOM.CSSRule.call(this);
-    this.name = "";
-	this.__props = "";
-};
-
-CSSOM.CSSCounterStyleRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSCounterStyleRule.prototype.constructor = CSSOM.CSSCounterStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSCounterStyleRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "type", {
-	value: 11,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "cssText", {
-	get: function() {
-		// FIXME : Implement real cssText generation based on properties
-		return "@counter-style " + this.name + " { " + this.__props + " }";
-	}
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "parse", {
-	value: function(cssText) {
-		// Extract the name from "@counter-style <name> { ... }"
-		var match = cssText.match(/@counter-style\s+([^\s{]+)\s*\{([^]*)\}/);
-		if (match) {
-			this.name = match[1];
-			// Get the text inside the brackets and clean it up
-			var propsText = match[2];
-			this.__props = propsText.trim().replace(/\n/g, " ").replace(/(['"])(?:\\.|[^\\])*?\1|(\s{2,})/g, function (match, quote) {
-				return quote ? match : ' ';
-			});
-		}
-	}
-});
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.css-houdini.org/css-properties-values-api/#the-css-property-rule-interface
- */
-CSSOM.CSSPropertyRule = function CSSPropertyRule() {
-	CSSOM.CSSRule.call(this);
-	this.__name = "";
-	this.__syntax = "";
-	this.__inherits = false;
-	this.__initialValue = null;
-};
-
-CSSOM.CSSPropertyRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSPropertyRule.prototype.constructor = CSSOM.CSSPropertyRule;
-
-Object.setPrototypeOf(CSSOM.CSSPropertyRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "type", {
-	value: 0,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "cssText", {
-	get: function() {
-		var text = "@property " + this.name + " {";
-		if (this.syntax !== "") {
-			text += " syntax: \"" + this.syntax.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + "\";";
-		}
-		text += " inherits: " + (this.inherits ? "true" : "false") + ";";
-		if (this.initialValue !== null) {
-			text += " initial-value: " + this.initialValue + ";";
-		}
-		text += " }";
-		return text;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "name", {
-	get: function() {
-		return this.__name;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "syntax", {
-	get: function() {
-		return this.__syntax;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "inherits", {
-	get: function() {
-		return this.__inherits;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "initialValue", {
-	get: function() {
-		return this.__initialValue;
-	}
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- * @returns {boolean} True if the rule is valid and was parsed successfully
- */
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "parse", {
-	value: function(cssText) {
-		// Extract the name from "@property <name> { ... }"
-		var match = cssText.match(/@property\s+(--[^\s{]+)\s*\{([^]*)\}/);
-		if (!match) {
-			return false;
-		}
-		
-		this.__name = match[1];
-		var bodyText = match[2];
-		
-		// Parse syntax descriptor (REQUIRED)
-		var syntaxMatch = bodyText.match(/syntax\s*:\s*(['"])([^]*?)\1\s*;/);
-		if (!syntaxMatch) {
-			return false; // syntax is required
-		}
-		this.__syntax = syntaxMatch[2];
-		
-		// Syntax cannot be empty
-		if (this.__syntax === "") {
-			return false;
-		}
-		
-		// Parse inherits descriptor (REQUIRED)
-		var inheritsMatch = bodyText.match(/inherits\s*:\s*(true|false)\s*;/);
-		if (!inheritsMatch) {
-			return false; // inherits is required
-		}
-		this.__inherits = inheritsMatch[1] === "true";
-		
-		// Parse initial-value descriptor (OPTIONAL, but required if syntax is not "*")
-		var initialValueMatch = bodyText.match(/initial-value\s*:\s*([^;]+);/);
-		if (initialValueMatch) {
-			this.__initialValue = initialValueMatch[1].trim();
-		} else {
-			// If syntax is not "*", initial-value is required
-			if (this.__syntax !== "*") {
-				return false;
-			}
-		}
-		
-		return true; // Successfully parsed
-	}
-});
-
-
-
-
-
-/**
- * @constructor
- * @see https://www.w3.org/TR/css-conditional-3/#the-cssconditionrule-interface
- */
-CSSOM.CSSConditionRule = function CSSConditionRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.__conditionText = '';
-};
-
-CSSOM.CSSConditionRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSConditionRule.prototype.constructor = CSSOM.CSSConditionRule;
-
-Object.setPrototypeOf(CSSOM.CSSConditionRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSConditionRule.prototype, "conditionText", {
-  get: function () {
-    return this.__conditionText;
-  }
-});
-
-
-
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssstylerule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleRule
- */
-CSSOM.CSSStyleRule = function CSSStyleRule() {
-	CSSOM.CSSGroupingRule.call(this);
-	this.__selectorText = "";
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSStyleRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSStyleRule.prototype.constructor = CSSOM.CSSStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSStyleRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "type", {
-	value: 1,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "selectorText", {
-	get: function() {
-		return this.__selectorText;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			// Don't trim if the value ends with a hex escape sequence followed by space
-			// (e.g., ".\31 " where the space is part of the escape terminator)
-			var endsWithHexEscapeRegExp = regexPatterns.endsWithHexEscapeRegExp;
-			var endsWithEscape = endsWithHexEscapeRegExp.test(value);
-			var trimmedValue = endsWithEscape ? value.replace(/\s+$/, ' ').trimStart() : value.trim();
-
-			if (trimmedValue === '') {
-				return;
-			}
-
-			// TODO: Setting invalid selectorText should be ignored
-			// There are some validations already on lib/parse.js
-			// but the same validations should be applied here.
-			// Check if we can move these validation logic to a shared function.
-
-			this.__selectorText = trimmedValue;
-		}
-	},
-	configurable: true
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	},
-	configurable: true
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "cssText", {
-	get: function() {
-		var text;
-		if (this.selectorText) {
-			var values = "";
-			if (this.cssRules.length) {
-				var valuesArr = [" {"];
-				this.style.cssText && valuesArr.push(this.style.cssText);
-				valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-					if (rule.cssText !== "") {
-						acc.push(rule.cssText);
-					}
-					return acc;
-				}, []).join("\n  "));
-				values = valuesArr.join("\n  ") + "\n}";
-			} else {
-				values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-			}
-			text = this.selectorText + values;
-		} else {
-			text = "";
-		}
-		return text;
-	}
-});
-
-
-
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#the-medialist-interface
- */
-CSSOM.MediaList = function MediaList(){
-	this.length = 0;
-};
-
-CSSOM.MediaList.prototype = {
-
-	constructor: CSSOM.MediaList,
-
-	/**
-	 * @return {string}
-	 */
-	get mediaText() {
-		return Array.prototype.join.call(this, ", ");
-	},
-
-	/**
-	 * @param {string} value
-	 */
-	set mediaText(value) {
-		if (typeof value === "string") {
-			var values = value.split(",").filter(function(text){
-				return !!text;
-			});
-			var length = this.length = values.length;
-			for (var i=0; i<length; i++) {
-				this[i] = values[i].trim();
-			}
-		} else if (value === null) {
-			var length = this.length;
-			for (var i = 0; i < length; i++) {
-				delete this[i];
-			}
-			this.length = 0;
-		}
-	},
-
-	/**
-	 * @param {string} medium
-	 */
-	appendMedium: function(medium) {
-		if (Array.prototype.indexOf.call(this, medium) === -1) {
-			this[this.length] = medium;
-			this.length++;
-		}
-	},
-
-	/**
-	 * @param {string} medium
-	 */
-	deleteMedium: function(medium) {
-		var index = Array.prototype.indexOf.call(this, medium);
-		if (index !== -1) {
-			Array.prototype.splice.call(this, index, 1);
-		}
-	},
-
-	item: function(index) {
-		return this[index] || null;
-	},
-
-	toString: function() {
-		return this.mediaText;
-	}
-};
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssmediarule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSMediaRule
- */
-CSSOM.CSSMediaRule = function CSSMediaRule() {
-	CSSOM.CSSConditionRule.call(this);
-	this.__media = new CSSOM.MediaList();
-};
-
-CSSOM.CSSMediaRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSMediaRule.prototype.constructor = CSSOM.CSSMediaRule;
-
-Object.setPrototypeOf(CSSOM.CSSMediaRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSMediaRule.prototype, "type", {
-	value: 4,
-	writable: false
-});
-
-// https://opensource.apple.com/source/WebCore/WebCore-7611.1.21.161.3/css/CSSMediaRule.cpp
-Object.defineProperties(CSSOM.CSSMediaRule.prototype, {
-  "media": {
-    get: function() {
-      return this.__media;
-    },
-    set: function(value) {
-      if (typeof value === "string") {
-        this.__media.mediaText = value;
-      } else {
-        this.__media = value;
-      }
-    },
-    configurable: true,
-    enumerable: true
-  },
-  "conditionText": {
-    get: function() {
-      return this.media.mediaText;
-    }
-  },
-  "cssText": {
-    get: function() {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@media " + this.media.mediaText + values;
-    }
-  }
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-contain-3/
- * @see https://www.w3.org/TR/css-contain-3/
- */
-CSSOM.CSSContainerRule = function CSSContainerRule() {
-	CSSOM.CSSConditionRule.call(this);
-};
-
-CSSOM.CSSContainerRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSContainerRule.prototype.constructor = CSSOM.CSSContainerRule;
-
-Object.setPrototypeOf(CSSOM.CSSContainerRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSContainerRule.prototype, "type", {
-	value: 17,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSContainerRule.prototype, {
-  "cssText": {
-    get: function() {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@container " + this.conditionText + values;
-    }
-  },
-  "containerName": {
-      get: function() {
-        var parts = this.conditionText.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] !== '(' && !parts[0].startsWith('(')) {
-          return parts[0];
-        }
-        return "";
-      }
-    },
-  "containerQuery": {
-      get: function() {
-        var parts = this.conditionText.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] !== '(' && !parts[0].startsWith('(')) {
-          return parts.slice(1).join(' ');
-        }
-        return this.conditionText;
-      }
-    },
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-conditional-3/#the-csssupportsrule-interface
- */
-CSSOM.CSSSupportsRule = function CSSSupportsRule() {
-  CSSOM.CSSConditionRule.call(this);
-};
-
-CSSOM.CSSSupportsRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSSupportsRule.prototype.constructor = CSSOM.CSSSupportsRule;
-  
-Object.setPrototypeOf(CSSOM.CSSSupportsRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSSupportsRule.prototype, "type", {
-	value: 12,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSSupportsRule.prototype, "cssText", {
-  get: function() {
-    var values = "";
-    var valuesArr = [" {"];
-    if (this.cssRules.length) {
-      valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-        if (rule.cssText !== "") {
-          acc.push(rule.cssText);
-        }
-        return acc;
-      }, []).join("\n  "));
-    }
-    values = valuesArr.join("\n  ") + "\n}";
-    return "@supports " + this.conditionText + values;
-  }
-});
-
-
-
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssimportrule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSImportRule
- */
-CSSOM.CSSImportRule = function CSSImportRule() {
-	CSSOM.CSSRule.call(this);
-	this.__href = "";
-	this.__media = new CSSOM.MediaList();
-  this.__layerName = null;
-  this.__supportsText = null;
-	this.__styleSheet = new CSSOM.CSSStyleSheet();
-};
-
-CSSOM.CSSImportRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSImportRule.prototype.constructor = CSSOM.CSSImportRule;
-
-Object.setPrototypeOf(CSSOM.CSSImportRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "type", {
-	value: 3,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "cssText", {
-  get: function() {
-    var mediaText = this.media.mediaText;
-    return "@import url(\"" + this.href.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + "\")" + (this.layerName !== null ? " layer" + (this.layerName && "(" + this.layerName + ")") : "" ) + (this.supportsText ? " supports(" + this.supportsText + ")" : "" ) + (mediaText ? " " + mediaText : "") + ";";
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "href", {
-  get: function() {
-    return this.__href;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "media", {
-  get: function() {
-    return this.__media;
-  },
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__media.mediaText = value;
-		} else {
-			this.__media = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "layerName", {
-  get: function() {
-    return this.__layerName;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "supportsText", {
-  get: function() {
-    return this.__supportsText;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "styleSheet", {
-  get: function() {
-    return this.__styleSheet;
-  }
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "parse", {
-  value: function(cssText) {
-    var i = 0;
-
-    /**
-     * @import url(partial.css) screen, handheld;
-     *        ||               |
-     *        after-import     media
-     *         |
-     *         url
-     */
-    var state = '';
-
-    var buffer = '';
-    var index;
-
-    var layerRegExp = regexPatterns.layerRegExp;
-    var layerRuleNameRegExp = regexPatterns.layerRuleNameRegExp;
-    var doubleOrMoreSpacesRegExp = regexPatterns.doubleOrMoreSpacesRegExp;
-    
-    /**
-     * Extracts the content inside supports() handling nested parentheses.
-     * @param {string} text - The text to parse
-     * @returns {object|null} - {content: string, endIndex: number} or null if not found
-     */
-    function extractSupportsContent(text) {
-      var supportsIndex = text.indexOf('supports(');
-      if (supportsIndex !== 0) {
-        return null;
-      }
-      
-      var depth = 0;
-      var start = supportsIndex + 'supports('.length;
-      var i = start;
-      
-      for (; i < text.length; i++) {
-        if (text[i] === '(') {
-          depth++;
-        } else if (text[i] === ')') {
-          if (depth === 0) {
-            // Found the closing parenthesis for supports()
-            return {
-              content: text.slice(start, i),
-              endIndex: i
-            };
-          }
-          depth--;
-        }
-      }
-      
-      return null; // Unbalanced parentheses
-    }
-
-    for (var character; (character = cssText.charAt(i)); i++) {
-
-      switch (character) {
-        case ' ':
-        case '\t':
-        case '\r':
-        case '\n':
-        case '\f':
-          if (state === 'after-import') {
-            state = 'url';
-          } else {
-            buffer += character;
-          }
-          break;
-
-        case '@':
-          if (!state && cssText.indexOf('@import', i) === i) {
-            state = 'after-import';
-            i += 'import'.length;
-            buffer = '';
-          }
-          break;
-
-        case 'u':
-          if (state === 'media') {
-            buffer += character;
-          }
-          if (state === 'url' && cssText.indexOf('url(', i) === i) {
-            index = cssText.indexOf(')', i + 1);
-            if (index === -1) {
-              throw i + ': ")" not found';
-            }
-            i += 'url('.length;
-            var url = cssText.slice(i, index);
-            if (url[0] === url[url.length - 1]) {
-              if (url[0] === '"' || url[0] === "'") {
-                url = url.slice(1, -1);
-              }
-            }
-            this.__href = url;
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case '"':
-          if (state === 'after-import' || state === 'url') {
-            index = cssText.indexOf('"', i + 1);
-            if (!index) {
-              throw i + ": '\"' not found";
-            }
-            this.__href = cssText.slice(i + 1, index);
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case "'":
-          if (state === 'after-import' || state === 'url') {
-            index = cssText.indexOf("'", i + 1);
-            if (!index) {
-              throw i + ': "\'" not found';
-            }
-            this.__href = cssText.slice(i + 1, index);
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case ';':
-          if (state === 'media') {
-            if (buffer) {
-              var bufferTrimmed = buffer.trim();
-              
-              if (bufferTrimmed.indexOf('layer') === 0) {
-                var layerMatch =  bufferTrimmed.match(layerRegExp);
-
-                if (layerMatch) {
-                  var layerName = layerMatch[1].trim();
-
-                  if (layerName.match(layerRuleNameRegExp) !== null) {
-                    this.__layerName = layerMatch[1].trim();
-                    bufferTrimmed = bufferTrimmed.replace(layerRegExp, '')
-                      .replace(doubleOrMoreSpacesRegExp, ' ') // Replace double or more spaces with single space
-                      .trim();
-                  } else {
-                    // REVIEW: In the browser, an empty layer() is not processed as a unamed layer
-                    // and treats the rest of the string as mediaText, ignoring the parse of supports()
-                    if (bufferTrimmed) {
-                      this.media.mediaText = bufferTrimmed;
-                      return;
-                    }
-                  }
-                } else {
-                  this.__layerName = "";
-                  bufferTrimmed = bufferTrimmed.substring('layer'.length).trim()
-                }
-              }
-
-              var supportsResult = extractSupportsContent(bufferTrimmed);
-
-              if (supportsResult) {
-                // REVIEW: In the browser, an empty supports() invalidates and ignores the entire @import rule
-                this.__supportsText = supportsResult.content.trim();
-                // Remove the entire supports(...) from the buffer
-                bufferTrimmed = bufferTrimmed.slice(0, 0) + bufferTrimmed.slice(supportsResult.endIndex + 1);
-                bufferTrimmed = bufferTrimmed.replace(doubleOrMoreSpacesRegExp, ' ').trim();
-              }
-
-              // REVIEW: In the browser, any invalid media is replaced with 'not all'
-              if (bufferTrimmed) {
-                this.media.mediaText = bufferTrimmed;
-              }
-            }
-          }
-          break;
-
-        default:
-          if (state === 'media') {
-            buffer += character;
-          }
-          break;
-      }
-    }
-  }
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssnamespacerule-interface
- */
-CSSOM.CSSNamespaceRule = function CSSNamespaceRule() {
-	CSSOM.CSSRule.call(this);
-	this.__prefix = "";
-	this.__namespaceURI = "";
-};
-
-CSSOM.CSSNamespaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSNamespaceRule.prototype.constructor = CSSOM.CSSNamespaceRule;
-
-Object.setPrototypeOf(CSSOM.CSSNamespaceRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "type", {
-  value: 10,
-  writable: false
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "cssText", {
-  get: function() {
-    return "@namespace" + (this.prefix && " " + this.prefix) + " url(\"" + this.namespaceURI + "\");";
-  }
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "prefix", {
-  get: function() {
-    return this.__prefix;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "namespaceURI", {
-  get: function() {
-    return this.__namespaceURI;
-  }
-});
-
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "parse", {
-  value: function(cssText) {
-    var newPrefix = "";
-    var newNamespaceURI = "";
-
-    // Remove @namespace and trim
-    var text = cssText.trim();
-    if (text.indexOf('@namespace') === 0) {
-      text = text.slice('@namespace'.length).trim();
-    }
-
-    // Remove trailing semicolon if present
-    if (text.charAt(text.length - 1) === ';') {
-      text = text.slice(0, -1).trim();
-    }
-
-    // Regex to match valid namespace syntax:
-    // 1. [optional prefix] url("...") or [optional prefix] url('...') or [optional prefix] url() or [optional prefix] url(unquoted)
-    // 2. [optional prefix] "..." or [optional prefix] '...'
-    // The prefix must be a valid CSS identifier (letters, digits, hyphens, underscores, starting with letter or underscore)
-    var re = /^(?:([a-zA-Z_][a-zA-Z0-9_-]*)\s+)?(?:url\(\s*(?:(['"])(.*?)\2\s*|([^)]*?))\s*\)|(['"])(.*?)\5)$/;
-    var match = text.match(re);
-
-    if (match) {
-      // If prefix is present
-      if (match[1]) {
-        newPrefix = match[1];
-      }
-      // If url(...) form with quotes
-      if (typeof match[3] !== "undefined") {
-        newNamespaceURI = match[3];
-      }
-      // If url(...) form without quotes
-      else if (typeof match[4] !== "undefined") {
-        newNamespaceURI = match[4].trim();
-      }
-      // If quoted string form
-      else if (typeof match[6] !== "undefined") {
-        newNamespaceURI = match[6];
-      }
-
-      this.__prefix = newPrefix;
-      this.__namespaceURI = newNamespaceURI;
-    } else {
-      throw new DOMException("Invalid @namespace rule", "InvalidStateError");
-    }
-  }
-});
-
-
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#css-font-face-rule
- */
-CSSOM.CSSFontFaceRule = function CSSFontFaceRule() {
-	CSSOM.CSSRule.call(this);
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSFontFaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSFontFaceRule.prototype.constructor = CSSOM.CSSFontFaceRule;
-
-Object.setPrototypeOf(CSSOM.CSSFontFaceRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "type", {
-	value: 5,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSFontFaceRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSFontFaceRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSFontFaceRule.cpp
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "cssText", {
-  get: function() {
-    return "@font-face {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-  }
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
- * @see http://html5index.org/Shadow%20DOM%20-%20CSSHostRule.html
- * @deprecated This rule was part of early Shadow DOM drafts but was removed in favor of the more flexible :host and :host-context() pseudo-classes in modern CSS for Web Components.
- */
-CSSOM.CSSHostRule = function CSSHostRule() {
-	CSSOM.CSSRule.call(this);
-	this.cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSHostRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSHostRule.prototype.constructor = CSSOM.CSSHostRule;
-
-Object.setPrototypeOf(CSSOM.CSSHostRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSHostRule.prototype, "type", {
-	value: 1001,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSHostRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSHostRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSHostRule.prototype, "cssText", {
-	get: function() {
-		var values = "";
-		var valuesArr = [" {"];
-		if (this.cssRules.length) {
-			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-			if (rule.cssText !== "") {
-				acc.push(rule.cssText);
-			}
-			return acc;
-			}, []).join("\n  "));
-		}
-		values = valuesArr.join("\n  ") + "\n}";
-		return "@host" + values;
-	}
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
- */
-CSSOM.CSSStartingStyleRule = function CSSStartingStyleRule() {
-	CSSOM.CSSGroupingRule.call(this);
-};
-
-CSSOM.CSSStartingStyleRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSStartingStyleRule.prototype.constructor = CSSOM.CSSStartingStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSStartingStyleRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSStartingStyleRule.prototype, "type", {
-	value: 1002,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSStartingStyleRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSStartingStyleRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSStartingStyleRule.prototype, "cssText", {
-	get: function() {
-		var values = "";
-		var valuesArr = [" {"];
-		if (this.cssRules.length) {
-			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-			if (rule.cssText !== "") {
-				acc.push(rule.cssText);
-			}
-			return acc;
-			}, []).join("\n  "));
-		}
-		values = valuesArr.join("\n  ") + "\n}";
-		return "@starting-style" + values;
-	}
-});
-
-
-
-
-
-
-/**
- * @see http://dev.w3.org/csswg/cssom/#the-stylesheet-interface
- */
-CSSOM.StyleSheet = function StyleSheet() {
-	this.__href = null;
-	this.__ownerNode = null;
-	this.__title = null;
-	this.__media = new CSSOM.MediaList();
-	this.__parentStyleSheet = null;
-	this.disabled = false;
-};
-
-Object.defineProperties(CSSOM.StyleSheet.prototype, {
-	type: {
-		get: function() {
-			return "text/css";
-		}
-	},
-	href: {
-		get: function() {
-			return this.__href;
-		}
-	},
-	ownerNode: {
-		get: function() {
-			return this.__ownerNode;
-		}
-	},
-	title: {
-		get: function() {
-			return this.__title;
-		}
-	},
-	media: {
-		get: function() {
-			return this.__media;
-		},
-		set: function(value) {
-			if (typeof value === "string") {
-				this.__media.mediaText = value;
-			} else {
-				this.__media = value;
-			}
-		}
-	},
-	parentStyleSheet: {
-		get: function() {
-			return this.__parentStyleSheet;
-		}
-	}
-});
-
-
-
-
-
-/**
- * @constructor
- * @param {CSSStyleSheetInit} [opts] - CSSStyleSheetInit options.
- * @param {string} [opts.baseURL] - The base URL of the stylesheet.
- * @param {boolean} [opts.disabled] - The disabled attribute of the stylesheet.
- * @param {MediaList | string} [opts.media] - The media attribute of the stylesheet.
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet
- */
-CSSOM.CSSStyleSheet = function CSSStyleSheet(opts) {
-	CSSOM.StyleSheet.call(this);
-	this.__constructed = true;
-	this.__cssRules = new CSSOM.CSSRuleList();
-	this.__ownerRule = null; 
-
-	if (opts && typeof opts === "object") {
-		if (opts.baseURL && typeof opts.baseURL === "string") {
-			this.__baseURL = opts.baseURL;
-		}
-		if (opts.media && typeof opts.media === "string") {
-			this.media.mediaText = opts.media;
-		}
-		if (typeof opts.disabled === "boolean") {
-			this.disabled = opts.disabled;
-		}
-	}
-};
-
-
-CSSOM.CSSStyleSheet.prototype = Object.create(CSSOM.StyleSheet.prototype);
-CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet;
-
-Object.setPrototypeOf(CSSOM.CSSStyleSheet, CSSOM.StyleSheet);
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "cssRules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "rules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "ownerRule", {
-	get: function() {
-		return this.__ownerRule;
-	}
-});
-
-/**
- * Used to insert a new rule into the style sheet. The new rule now becomes part of the cascade.
- *
- *   sheet = new Sheet("body {margin: 0}")
- *   sheet.toString()
- *   -> "body{margin:0;}"
- *   sheet.insertRule("img {border: none}", 0)
- *   -> 0
- *   sheet.toString()
- *   -> "img{border:none;}body{margin:0;}"
- *
- * @param {string} rule
- * @param {number} [index=0]
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-insertRule
- * @return {number} The index within the style sheet's rule collection of the newly inserted rule.
- */
-CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
-	if (rule === undefined && index === undefined) {
-		errorUtils.throwMissingArguments(this, 'insertRule', this.constructor.name);
-	}
-	if (index === void 0) {
-		index = 0;
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index > this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'insertRule', this.constructor.name, index, this.cssRules.length);
-	}
-	
-	var ruleToParse = String(rule);
-	var parseErrors = [];
-	var parsedSheet = CSSOM.parse(ruleToParse, undefined, function(err) {
-		parseErrors.push(err);
-	} );
-	if (parsedSheet.cssRules.length !== 1) {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-	}
-	var cssRule = parsedSheet.cssRules[0];
-	
-	// Helper function to find the last index of a specific rule constructor
-	function findLastIndexOfConstructor(rules, constructorName) {
-		for (var i = rules.length - 1; i >= 0; i--) {
-			if (rules[i].constructor.name === constructorName) {
-				return i;
-			}
-		}
-		return -1;
-	}
-	
-	// Helper function to find the first index of a rule that's NOT of specified constructors
-	function findFirstNonConstructorIndex(rules, constructorNames) {
-		for (var i = 0; i < rules.length; i++) {
-			if (constructorNames.indexOf(rules[i].constructor.name) === -1) {
-				return i;
-			}
-		}
-		return rules.length;
-	}
-	
-	// Validate rule ordering based on CSS specification
-	if (cssRule.constructor.name === 'CSSImportRule') {
-		if (this.__constructed === true) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Can't insert @import rules into a constructed stylesheet.",
-				'SyntaxError');
-		}
-		// @import rules cannot be inserted after @layer rules that already exist
-		// They can only be inserted at the beginning or after other @import rules
-		var firstLayerIndex = findFirstNonConstructorIndex(this.cssRules, ['CSSImportRule']);
-		if (firstLayerIndex < this.cssRules.length && this.cssRules[firstLayerIndex].constructor.name === 'CSSLayerStatementRule' && index > firstLayerIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-		
-		// Also cannot insert after @namespace or other rules
-		var firstNonImportIndex = findFirstNonConstructorIndex(this.cssRules, ['CSSImportRule']);
-		if (index > firstNonImportIndex && firstNonImportIndex < this.cssRules.length && 
-		    this.cssRules[firstNonImportIndex].constructor.name !== 'CSSLayerStatementRule') {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-	} else if (cssRule.constructor.name === 'CSSNamespaceRule') {
-		// @namespace rules can come after @layer and @import, but before any other rules
-		// They cannot come before @import rules
-		var firstImportIndex = -1;
-		for (var i = 0; i < this.cssRules.length; i++) {
-			if (this.cssRules[i].constructor.name === 'CSSImportRule') {
-				firstImportIndex = i;
-				break;
-			}
-		}
-		var firstNonImportNamespaceIndex = findFirstNonConstructorIndex(this.cssRules, [
-			'CSSLayerStatementRule', 
-			'CSSImportRule', 
-			'CSSNamespaceRule'
-		]);
-		
-		// Cannot insert before @import rules
-		if (firstImportIndex !== -1 && index <= firstImportIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-		
-		// Cannot insert if there are already non-special rules
-		if (firstNonImportNamespaceIndex < this.cssRules.length) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'InvalidStateError');
-		}
-		
-		// Cannot insert after other types of rules
-		if (index > firstNonImportNamespaceIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-
-		
-	} else if (cssRule.constructor.name === 'CSSLayerStatementRule') {
-		// @layer statement rules can be inserted anywhere before @import and @namespace
-		// No additional restrictions beyond what's already handled
-	} else {
-		// Any other rule cannot be inserted before @import and @namespace
-		var firstNonSpecialRuleIndex = findFirstNonConstructorIndex(this.cssRules, [
-			'CSSLayerStatementRule',
-			'CSSImportRule',
-			'CSSNamespaceRule'
-		]);
-		
-		if (index < firstNonSpecialRuleIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-
-		if (parseErrors.filter(function(error) { return !error.isNested; }).length !== 0) {
-			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-		}
-	}
-	
-	cssRule.__parentStyleSheet = this;
-	this.cssRules.splice(index, 0, cssRule);
-	return index;
-};
-
-CSSOM.CSSStyleSheet.prototype.addRule = function(selector, styleBlock, index) {
-	if (index === void 0) {
-		index = this.cssRules.length;
-	}
-	this.insertRule(selector + "{" + styleBlock + "}", index);
-	return -1;
-};
-
-/**
- * Used to delete a rule from the style sheet.
- *
- *   sheet = new Sheet("img{border:none} body{margin:0}")
- *   sheet.toString()
- *   -> "img{border:none;}body{margin:0;}"
- *   sheet.deleteRule(0)
- *   sheet.toString()
- *   -> "body{margin:0;}"
- *
- * @param {number} index within the style sheet's rule list of the rule to remove.
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-deleteRule
- */
-CSSOM.CSSStyleSheet.prototype.deleteRule = function(index) {
-	if (index === undefined) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', this.constructor.name);
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index >= this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
-	}
-	if (this.cssRules[index]) {		
-		if (this.cssRules[index].constructor.name == "CSSNamespaceRule") {
-			var shouldContinue = this.cssRules.every(function (rule) {
-				return ['CSSImportRule','CSSLayerStatementRule','CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
-			});
-			if (!shouldContinue) {
-				errorUtils.throwError(this, 'DOMException', "Failed to execute 'deleteRule' on '" + this.constructor.name + "': Failed to delete rule.", "InvalidStateError");
-			}
-		}
-		if (this.cssRules[index].constructor.name == "CSSImportRule") {
-			this.cssRules[index].styleSheet.__parentStyleSheet = null;
-		}
-
-		this.cssRules[index].__parentStyleSheet = null;
-	}
-	this.cssRules.splice(index, 1);
-};
-
-CSSOM.CSSStyleSheet.prototype.removeRule = function(index) {
-	if (index === void 0) {
-		index = 0;
-	}
-	this.deleteRule(index);
-};
-
-
-/**
- * Replaces the rules of a {@link CSSStyleSheet}
- * 
- * @returns a promise
- * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replace
- */
-CSSOM.CSSStyleSheet.prototype.replace = function(text) {
-	var _Promise;
-	if (this.__globalObject && this.__globalObject['Promise']) {
-		_Promise = this.__globalObject['Promise'];
-	} else {
-		_Promise = Promise;
-	}
-	var _setTimeout;
-	if (this.__globalObject && this.__globalObject['setTimeout']) {
-		_setTimeout = this.__globalObject['setTimeout'];
-	} else {
-		_setTimeout = setTimeout;
-	}
-	var sheet = this;
-	return new _Promise(function (resolve, reject) {
-		// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
-		if (!sheet.__constructed || sheet.__disallowModification) {
-			reject(errorUtils.createError(sheet, 'DOMException',
-				"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
-				'NotAllowedError'));
-		}
-		// Set the disallow modification flag.
-		sheet.__disallowModification = true;
-
-		// In parallel, do these steps:
-		_setTimeout(function() {
-			// Let rules be the result of running parse a stylesheet's contents from text.
-			var rules = new CSSOM.CSSRuleList();
-			CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
-			// If rules contains one or more @import rules, remove those rules from rules.
-			var i = 0;
-			while (i < rules.length) {
-				if (rules[i].constructor.name === 'CSSImportRule') {
-					rules.splice(i, 1);
-				} else {
-					i++;
-				}
-			}
-			// Set sheet's CSS rules to rules.
-			sheet.__cssRules.splice.apply(sheet.__cssRules, [0, sheet.__cssRules.length].concat(rules));
-			// Unset sheet’s disallow modification flag.
-			delete sheet.__disallowModification;
-			// Resolve promise with sheet.
-			resolve(sheet);
-		})
-	});
-}
-
-/**
- * Synchronously replaces the rules of a {@link CSSStyleSheet}
- * 
- * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replacesync
- */
-CSSOM.CSSStyleSheet.prototype.replaceSync = function(text) {
-	var sheet = this;
-	// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
-	if (!sheet.__constructed || sheet.__disallowModification) {
-		errorUtils.throwError(sheet, 'DOMException',
-			"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
-			'NotAllowedError');
-	}
-	// Let rules be the result of running parse a stylesheet's contents from text.
-	var rules = new CSSOM.CSSRuleList();
-	CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
-	// If rules contains one or more @import rules, remove those rules from rules.
-	var i = 0;
-	while (i < rules.length) {
-		if (rules[i].constructor.name === 'CSSImportRule') {
-			rules.splice(i, 1);
-		} else {
-			i++;
-		}
-	}
-	// Set sheet's CSS rules to rules.
-	sheet.__cssRules.splice.apply(sheet.__cssRules, [0, sheet.__cssRules.length].concat(rules));
-}
-
-/**
- * NON-STANDARD
- * @return {string} serialize stylesheet
- */
-CSSOM.CSSStyleSheet.prototype.toString = function() {
-	var result = "";
-	var rules = this.cssRules;
-	for (var i=0; i<rules.length; i++) {
-		result += rules[i].cssText + "\n";
-	}
-	return result;
-};
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframesRule
- */
-CSSOM.CSSKeyframesRule = function CSSKeyframesRule() {
-	CSSOM.CSSRule.call(this);
-	this.name = '';
-	this.cssRules = new CSSOM.CSSRuleList();
-	
-	// Set up initial indexed access
-	this._setupIndexedAccess();
-	
-	// Override cssRules methods after initial setup, store references as non-enumerable properties
-	var self = this;
-	var originalPush = this.cssRules.push;
-	var originalSplice = this.cssRules.splice;
-	
-	// Create non-enumerable method overrides
-	Object.defineProperty(this.cssRules, 'push', {
-		value: function() {
-			var result = originalPush.apply(this, arguments);
-			self._setupIndexedAccess();
-			return result;
-		},
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-	
-	Object.defineProperty(this.cssRules, 'splice', {
-		value: function() {
-			var result = originalSplice.apply(this, arguments);
-			self._setupIndexedAccess();
-			return result;
-		},
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-};
-
-CSSOM.CSSKeyframesRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSKeyframesRule.prototype.constructor = CSSOM.CSSKeyframesRule;
-
-Object.setPrototypeOf(CSSOM.CSSKeyframesRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "type", {
-	value: 7,
-	writable: false
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframesRule.cpp
-Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "cssText", {
-  get: function() {
-    var values = "";
-	var valuesArr = [" {"];
-	if (this.cssRules.length) {
-	valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-		if (rule.cssText !== "") {
-		acc.push(rule.cssText);
-		}
-		return acc;
-	}, []).join("\n  "));
-	}
-	values = valuesArr.join("\n  ") + "\n}";
-    var cssWideKeywords = ['initial', 'inherit', 'revert', 'revert-layer', 'unset', 'none'];
-    var processedName = cssWideKeywords.includes(this.name) ? '"' + this.name + '"' : this.name;
-    return "@" + (this._vendorPrefix || '') + "keyframes " + processedName + values;
-  }
-});
-
-/**
- * Appends a new keyframe rule to the list of keyframes.
- * 
- * @param {string} rule - The keyframe rule string to append (e.g., "50% { opacity: 0.5; }")
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-appendrule
- */
-CSSOM.CSSKeyframesRule.prototype.appendRule = function appendRule(rule) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'appendRule', 'CSSKeyframesRule');
-	}
-	
-	var parsedRule;
-	try {
-		// Parse the rule string as a keyframe rule
-		var tempStyleSheet = CSSOM.parse("@keyframes temp { " + rule + " }");
-		if (tempStyleSheet.cssRules.length > 0 && tempStyleSheet.cssRules[0].cssRules.length > 0) {
-			parsedRule = tempStyleSheet.cssRules[0].cssRules[0];
-		} else {
-			throw new Error("Failed to parse keyframe rule");
-		}
-	} catch (e) {
-		errorUtils.throwParseError(this, 'appendRule', 'CSSKeyframesRule', rule);
-	}
-	
-	parsedRule.__parentRule = this;
-	this.cssRules.push(parsedRule);
-};
-
-/**
- * Deletes a keyframe rule that matches the specified key.
- * 
- * @param {string} select - The keyframe selector to delete (e.g., "50%", "from", "to")
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-deleterule
- */
-CSSOM.CSSKeyframesRule.prototype.deleteRule = function deleteRule(select) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', 'CSSKeyframesRule');
-	}
-	
-	var normalizedSelect = this._normalizeKeyText(select);
-	
-	for (var i = 0; i < this.cssRules.length; i++) {
-		var rule = this.cssRules[i];
-		if (this._normalizeKeyText(rule.keyText) === normalizedSelect) {
-			rule.__parentRule = null;
-			this.cssRules.splice(i, 1);
-			return;
-		}
-	}
-};
-
-/**
- * Finds and returns the keyframe rule that matches the specified key.
- * When multiple rules have the same key, returns the last one.
- * 
- * @param {string} select - The keyframe selector to find (e.g., "50%", "from", "to")
- * @return {CSSKeyframeRule|null} The matching keyframe rule, or null if not found
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-findrule
- */
-CSSOM.CSSKeyframesRule.prototype.findRule = function findRule(select) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'findRule', 'CSSKeyframesRule');
-	}
-	
-	var normalizedSelect = this._normalizeKeyText(select);
-	
-	// Iterate backwards to find the last matching rule
-	for (var i = this.cssRules.length - 1; i >= 0; i--) {
-		var rule = this.cssRules[i];
-		if (this._normalizeKeyText(rule.keyText) === normalizedSelect) {
-			return rule;
-		}
-	}
-	
-	return null;
-};
-
-/**
- * Normalizes keyframe selector text for comparison.
- * Handles "from" -> "0%" and "to" -> "100%" conversions and trims whitespace.
- * 
- * @private
- * @param {string} keyText - The keyframe selector text to normalize
- * @return {string} The normalized keyframe selector text
- */
-CSSOM.CSSKeyframesRule.prototype._normalizeKeyText = function _normalizeKeyText(keyText) {
-	if (!keyText) return '';
-	
-	var normalized = keyText.toString().trim().toLowerCase();
-	
-	// Convert keywords to percentages for comparison
-	if (normalized === 'from') {
-		return '0%';
-	} else if (normalized === 'to') {
-		return '100%';
-	}
-	
-	return normalized;
-};
-
-/**
- * Makes CSSKeyframesRule iterable over its cssRules.
- * Allows for...of loops and other iterable methods.
- */
-if (typeof Symbol !== 'undefined' && Symbol.iterator) {
-	CSSOM.CSSKeyframesRule.prototype[Symbol.iterator] = function() {
-		var index = 0;
-		var cssRules = this.cssRules;
-		
-		return {
-			next: function() {
-				if (index < cssRules.length) {
-					return { value: cssRules[index++], done: false };
-				} else {
-					return { done: true };
-				}
-			}
-		};
-	};
-}
-
-/**
- * Adds indexed getters for direct access to cssRules by index.
- * This enables rule[0], rule[1], etc. access patterns.
- * Works in environments where Proxy is not available (like jsdom).
- */
-CSSOM.CSSKeyframesRule.prototype._setupIndexedAccess = function() {
-	// Remove any existing indexed properties
-	for (var i = 0; i < 1000; i++) { // reasonable upper limit
-		if (this.hasOwnProperty(i)) {
-			delete this[i];
-		} else {
-			break;
-		}
-	}
-	
-	// Add indexed getters for current cssRules
-	for (var i = 0; i < this.cssRules.length; i++) {
-		(function(index) {
-			Object.defineProperty(this, index, {
-				get: function() {
-					return this.cssRules[index];
-				},
-				enumerable: false,
-				configurable: true
-			});
-		}.call(this, i));
-	}
-	
-	// Update length property
-	Object.defineProperty(this, 'length', {
-		get: function() {
-			return this.cssRules.length;
-		},
-		enumerable: false,
-		configurable: true
-	});
-};
-
-
-
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframeRule
- */
-CSSOM.CSSKeyframeRule = function CSSKeyframeRule() {
-	CSSOM.CSSRule.call(this);
-	this.keyText = '';
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSKeyframeRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSKeyframeRule.prototype.constructor = CSSOM.CSSKeyframeRule;
-
-Object.setPrototypeOf(CSSOM.CSSKeyframeRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "type", {
-	value: 8,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSKeyframeRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSKeyframeRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframeRule.cpp
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "cssText", {
-  get: function() {
-    return this.keyText + " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-  }
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://developer.mozilla.org/en/CSS/@-moz-document
- */
-CSSOM.MatcherList = function MatcherList(){
-    this.length = 0;
-};
-
-CSSOM.MatcherList.prototype = {
-
-    constructor: CSSOM.MatcherList,
-
-    /**
-     * @return {string}
-     */
-    get matcherText() {
-        return Array.prototype.join.call(this, ", ");
-    },
-
-    /**
-     * @param {string} value
-     */
-    set matcherText(value) {
-        // just a temporary solution, actually it may be wrong by just split the value with ',', because a url can include ','.
-        var values = value.split(",");
-        var length = this.length = values.length;
-        for (var i=0; i<length; i++) {
-            this[i] = values[i].trim();
-        }
-    },
-
-    /**
-     * @param {string} matcher
-     */
-    appendMatcher: function(matcher) {
-        if (Array.prototype.indexOf.call(this, matcher) === -1) {
-            this[this.length] = matcher;
-            this.length++;
-        }
-    },
-
-    /**
-     * @param {string} matcher
-     */
-    deleteMatcher: function(matcher) {
-        var index = Array.prototype.indexOf.call(this, matcher);
-        if (index !== -1) {
-            Array.prototype.splice.call(this, index, 1);
-        }
-    }
-
-};
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://developer.mozilla.org/en/CSS/@-moz-document
- * @deprecated This rule is a non-standard Mozilla-specific extension and is not part of any official CSS specification.
- */
-CSSOM.CSSDocumentRule = function CSSDocumentRule() {
-    CSSOM.CSSRule.call(this);
-    this.matcher = new CSSOM.MatcherList();
-    this.cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSDocumentRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSDocumentRule.prototype.constructor = CSSOM.CSSDocumentRule;
-
-Object.setPrototypeOf(CSSOM.CSSDocumentRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSDocumentRule.prototype, "type", {
-	value: 10,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSDocumentRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSDocumentRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSDocumentRule.prototype, "cssText", {
-  get: function() {
-    var cssTexts = [];
-    for (var i=0, length=this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
-    }
-    return "@-moz-document " + this.matcher.matcherText + " {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
-  }
-});
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSValue
- *
- * TODO: add if needed
- */
-CSSOM.CSSValue = function CSSValue() {
-};
-
-CSSOM.CSSValue.prototype = {
-	constructor: CSSOM.CSSValue,
-
-	// @see: http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSValue
-	set cssText(text) {
-		var name = this._getConstructorName();
-
-		throw new Error('DOMException: property "cssText" of "' + name + '" is readonly and can not be replaced with "' + text + '"!');
-	},
-
-	get cssText() {
-		var name = this._getConstructorName();
-
-		throw new Error('getter "cssText" of "' + name + '" is not implemented!');
-	},
-
-	_getConstructorName: function() {
-		var s = this.constructor.toString(),
-				c = s.match(/function\s([^\(]+)/),
-				name = c[1];
-
-		return name;
-	}
-};
-
-
-
-
-
-
-/**
- * @constructor
- * @see http://msdn.microsoft.com/en-us/library/ms537634(v=vs.85).aspx
- *
- */
-CSSOM.CSSValueExpression = function CSSValueExpression(token, idx) {
-	this._token = token;
-	this._idx = idx;
-};
-
-CSSOM.CSSValueExpression.prototype = Object.create(CSSOM.CSSValue.prototype);
-CSSOM.CSSValueExpression.prototype.constructor = CSSOM.CSSValueExpression;
-
-Object.setPrototypeOf(CSSOM.CSSValueExpression, CSSOM.CSSValue);
-
-/**
- * parse css expression() value
- *
- * @return {Object}
- *         - error:
- *         or
- *         - idx:
- *         - expression:
- *
- * Example:
- *
- * .selector {
- *		zoom: expression(documentElement.clientWidth > 1000 ? '1000px' : 'auto');
- * }
- */
-CSSOM.CSSValueExpression.prototype.parse = function() {
-	var token = this._token,
-			idx = this._idx;
-
-	var character = '',
-			expression = '',
-			error = '',
-			info,
-			paren = [];
-
-
-	for (; ; ++idx) {
-		character = token.charAt(idx);
-
-		// end of token
-		if (character === '') {
-			error = 'css expression error: unfinished expression!';
-			break;
-		}
-
-		switch(character) {
-			case '(':
-				paren.push(character);
-				expression += character;
-				break;
-
-			case ')':
-				paren.pop(character);
-				expression += character;
-				break;
-
-			case '/':
-				if ((info = this._parseJSComment(token, idx))) { // comment?
-					if (info.error) {
-						error = 'css expression error: unfinished comment in expression!';
-					} else {
-						idx = info.idx;
-						// ignore the comment
-					}
-				} else if ((info = this._parseJSRexExp(token, idx))) { // regexp
-					idx = info.idx;
-					expression += info.text;
-				} else { // other
-					expression += character;
-				}
-				break;
-
-			case "'":
-			case '"':
-				info = this._parseJSString(token, idx, character);
-				if (info) { // string
-					idx = info.idx;
-					expression += info.text;
-				} else {
-					expression += character;
-				}
-				break;
-
-			default:
-				expression += character;
-				break;
-		}
-
-		if (error) {
-			break;
-		}
-
-		// end of expression
-		if (paren.length === 0) {
-			break;
-		}
-	}
-
-	var ret;
-	if (error) {
-		ret = {
-			error: error
-		};
-	} else {
-		ret = {
-			idx: idx,
-			expression: expression
-		};
-	}
-
-	return ret;
-};
-
-
-/**
- *
- * @return {Object|false}
- *          - idx:
- *          - text:
- *          or
- *          - error:
- *          or
- *          false
- *
- */
-CSSOM.CSSValueExpression.prototype._parseJSComment = function(token, idx) {
-	var nextChar = token.charAt(idx + 1),
-			text;
-
-	if (nextChar === '/' || nextChar === '*') {
-		var startIdx = idx,
-				endIdx,
-				commentEndChar;
-
-		if (nextChar === '/') { // line comment
-			commentEndChar = '\n';
-		} else if (nextChar === '*') { // block comment
-			commentEndChar = '*/';
-		}
-
-		endIdx = token.indexOf(commentEndChar, startIdx + 1 + 1);
-		if (endIdx !== -1) {
-			endIdx = endIdx + commentEndChar.length - 1;
-			text = token.substring(idx, endIdx + 1);
-			return {
-				idx: endIdx,
-				text: text
-			};
-		} else {
-			var error = 'css expression error: unfinished comment in expression!';
-			return {
-				error: error
-			};
-		}
-	} else {
-		return false;
-	}
-};
-
-
-/**
- *
- * @return {Object|false}
- *					- idx:
- *					- text:
- *					or 
- *					false
- *
- */
-CSSOM.CSSValueExpression.prototype._parseJSString = function(token, idx, sep) {
-	var endIdx = this._findMatchedIdx(token, idx, sep),
-			text;
-
-	if (endIdx === -1) {
-		return false;
-	} else {
-		text = token.substring(idx, endIdx + sep.length);
-
-		return {
-			idx: endIdx,
-			text: text
-		};
-	}
-};
-
-
-/**
- * parse regexp in css expression
- *
- * @return {Object|false}
- *				- idx:
- *				- regExp:
- *				or 
- *				false
- */
-
-/*
-
-all legal RegExp
- 
-/a/
-(/a/)
-[/a/]
-[12, /a/]
-
-!/a/
-
-+/a/
--/a/
-* /a/
-/ /a/
-%/a/
-
-===/a/
-!==/a/
-==/a/
-!=/a/
->/a/
->=/a/
-</a/
-<=/a/
-
-&/a/
-|/a/
-^/a/
-~/a/
-<</a/
->>/a/
->>>/a/
-
-&&/a/
-||/a/
-?/a/
-=/a/
-,/a/
-
-		delete /a/
-				in /a/
-instanceof /a/
-				new /a/
-		typeof /a/
-			void /a/
-
-*/
-CSSOM.CSSValueExpression.prototype._parseJSRexExp = function(token, idx) {
-	var before = token.substring(0, idx).replace(/\s+$/, ""),
-			legalRegx = [
-				/^$/,
-				/\($/,
-				/\[$/,
-				/\!$/,
-				/\+$/,
-				/\-$/,
-				/\*$/,
-				/\/\s+/,
-				/\%$/,
-				/\=$/,
-				/\>$/,
-				/<$/,
-				/\&$/,
-				/\|$/,
-				/\^$/,
-				/\~$/,
-				/\?$/,
-				/\,$/,
-				/delete$/,
-				/in$/,
-				/instanceof$/,
-				/new$/,
-				/typeof$/,
-				/void$/
-			];
-
-	var isLegal = legalRegx.some(function(reg) {
-		return reg.test(before);
-	});
-
-	if (!isLegal) {
-		return false;
-	} else {
-		var sep = '/';
-
-		// same logic as string
-		return this._parseJSString(token, idx, sep);
-	}
-};
-
-
-/**
- *
- * find next sep(same line) index in `token`
- *
- * @return {Number}
- *
- */
-CSSOM.CSSValueExpression.prototype._findMatchedIdx = function(token, idx, sep) {
-	var startIdx = idx,
-			endIdx;
-
-	var NOT_FOUND = -1;
-
-	while(true) {
-		endIdx = token.indexOf(sep, startIdx + 1);
-
-		if (endIdx === -1) { // not found
-			endIdx = NOT_FOUND;
-			break;
-		} else {
-			var text = token.substring(idx + 1, endIdx),
-					matched = text.match(/\\+$/);
-			if (!matched || matched[0] % 2 === 0) { // not escaped
-				break;
-			} else {
-				startIdx = endIdx;
-			}
-		}
-	}
-
-	// boundary must be in the same line(js sting or regexp)
-	var nextNewLineIdx = token.indexOf('\n', idx + 1);
-	if (nextNewLineIdx < endIdx) {
-		endIdx = NOT_FOUND;
-	}
-
-
-	return endIdx;
-};
-
-
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-6/#cssscoperule
- */
-CSSOM.CSSScopeRule = function CSSScopeRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.__start = null;
-  this.__end = null;
-};
-
-CSSOM.CSSScopeRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSScopeRule.prototype.constructor = CSSOM.CSSScopeRule;
-
-Object.setPrototypeOf(CSSOM.CSSScopeRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperties(CSSOM.CSSScopeRule.prototype, {
-  type: {
-    value: 0,
-    writable: false,
-  },
-  cssText: {
-    get: function () {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@scope" + (this.start ? " (" + this.start + ")" : "") + (this.end ? " to (" + this.end + ")" : "") + values;
-    },
-    configurable: true,
-    enumerable: true,
-  },
-  start: {
-    get: function () {
-      return this.__start;
-    }
-  },
-  end: {
-    get: function () {
-      return this.__end;
-    }
-  }
-});
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-5/#csslayerblockrule
- */
-CSSOM.CSSLayerBlockRule = function CSSLayerBlockRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.name = "";
-};
-
-CSSOM.CSSLayerBlockRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSLayerBlockRule.prototype.constructor = CSSOM.CSSLayerBlockRule;
-
-Object.setPrototypeOf(CSSOM.CSSLayerBlockRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSLayerBlockRule.prototype, "type", {
-	value: 18,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSLayerBlockRule.prototype, {
-  cssText: {
-    get: function () {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@layer" + (this.name ? " " + this.name : "") + values;
-    }
-  },
-});
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-5/#csslayerstatementrule
- */
-CSSOM.CSSLayerStatementRule = function CSSLayerStatementRule() {
-  CSSOM.CSSRule.call(this);
-  this.nameList = [];
-};
-
-CSSOM.CSSLayerStatementRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSLayerStatementRule.prototype.constructor = CSSOM.CSSLayerStatementRule;
-
-Object.setPrototypeOf(CSSOM.CSSLayerStatementRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSLayerStatementRule.prototype, "type", {
-	value: 0,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSLayerStatementRule.prototype, {
-  cssText: {
-    get: function () {
-      return "@layer " + this.nameList.join(", ") + ";";
-    }
-  },
-});
-
-
-
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-csspagerule-interface
- */
-CSSOM.CSSPageRule = function CSSPageRule() {
-	CSSOM.CSSGroupingRule.call(this);
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSPageRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSPageRule.prototype.constructor = CSSOM.CSSPageRule;
-
-Object.setPrototypeOf(CSSOM.CSSPageRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "type", {
-	value: 6,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "selectorText", {
-    get: function() {
-        return this.__selectorText;	
-    },
-    set: function(value) {
-        if (typeof value === "string") {
-            var trimmedValue = value.trim();
-            
-            // Empty selector is valid for @page
-            if (trimmedValue === '') {
-                this.__selectorText = '';
-                return;
-            }
-            
-			var atPageRuleSelectorRegExp = regexPatterns.atPageRuleSelectorRegExp;
-			var cssCustomIdentifierRegExp = regexPatterns.cssCustomIdentifierRegExp;
-            var match = trimmedValue.match(atPageRuleSelectorRegExp);
-            if (match) {
-				var pageName = match[1] || '';
-                var pseudoPages = match[2] || '';
-
-				// Validate page name if present
-				if (pageName) {
-					// Page name can be an identifier or a string
-					if (!cssCustomIdentifierRegExp.test(pageName)) {
-						return;
-					}
-				}
-                
-                // Validate pseudo-pages if present
-                if (pseudoPages) {
-                    var pseudos = pseudoPages.split(':').filter(function(p) { return p; });
-                    var validPseudos = ['left', 'right', 'first', 'blank'];
-                    var allValid = true;
-                    for (var j = 0; j < pseudos.length; j++) {
-                        if (validPseudos.indexOf(pseudos[j].toLowerCase()) === -1) {
-                            allValid = false;
-                            break;
-                        }
-                    }
-                    
-                    if (!allValid) {
-                        return; // Invalid pseudo-page, do nothing
-                    }
-                }
-                
-				this.__selectorText = pageName + pseudoPages.toLowerCase();
-            }
-        }
-    }
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "cssText", {
-	get: function() {
-        var values = "";
-        if (this.cssRules.length) {
-            var valuesArr = [" {"];
-            this.style.cssText && valuesArr.push(this.style.cssText);
-            valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-				if (rule.cssText !== "") {
-					acc.push(rule.cssText);
-				}
-				return acc;
-			}, []).join("\n  "));
-            values = valuesArr.join("\n  ") + "\n}";
-        } else {
-            values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-        }
-		return "@page" + (this.selectorText ? " " + this.selectorText : "") + values;
-	}
-});
-
-
-
-
-/**
- * Parses a CSS string and returns a `CSSStyleSheet` object representing the parsed stylesheet.
- *
- * @param {string} token - The CSS string to parse.
- * @param {object} [opts] - Optional parsing options.
- * @param {object} [opts.globalObject] - An optional global object to prioritize over the window object. Useful on jsdom webplatform tests.
- * @param {Element | ProcessingInstruction} [opts.ownerNode] - The owner node of the stylesheet.
- * @param {CSSRule} [opts.ownerRule] - The owner rule of the stylesheet.
- * @param {CSSOM.CSSStyleSheet} [opts.styleSheet] - Reuse a style sheet instead of creating a new one (e.g. as `parentStyleSheet`)
- * @param {CSSOM.CSSRuleList} [opts.cssRules] - Prepare all rules in this list instead of mutating the style sheet continually
- * @param {function|boolean} [errorHandler] - Optional error handler function or `true` to use `console.error`.
- * @returns {CSSOM.CSSStyleSheet} The parsed `CSSStyleSheet` object.
- */
-CSSOM.parse = function parse(token, opts, errorHandler) {
-	errorHandler = errorHandler === true ? (console && console.error) : errorHandler;
-
-	var i = 0;
-
-	/**
-		"before-selector" or
-		"selector" or
-		"atRule" or
-		"atBlock" or
-		"conditionBlock" or
-		"before-name" or
-		"name" or
-		"before-value" or
-		"value"
-	*/
-	var state = "before-selector";
-
-	var index;
-	var buffer = "";
-	var valueParenthesisDepth = 0;
-	var hasUnmatchedQuoteInSelector = false; // Track if current selector has unmatched quote
-
-	var SIGNIFICANT_WHITESPACE = {
-		"name": true,
-		"before-name": true,
-		"selector": true,
-		"value": true,
-		"value-parenthesis": true,
-		"atRule": true,
-		"importRule-begin": true,
-		"importRule": true,
-		"namespaceRule-begin": true,
-		"namespaceRule": true,
-		"atBlock": true,
-		"containerBlock": true,
-		"conditionBlock": true,
-		"counterStyleBlock": true,
-		"propertyBlock": true,
-		'documentRule-begin': true,
-		"scopeBlock": true,
-		"layerBlock": true,
-		"pageBlock": true
-	};
-
-	var styleSheet;
-	if (opts && opts.styleSheet) {
-		styleSheet = opts.styleSheet;
-	} else {
-		if (opts && opts.globalObject && opts.globalObject.CSSStyleSheet) {
-			styleSheet = new opts.globalObject.CSSStyleSheet();
-		} else {
-			styleSheet = new CSSOM.CSSStyleSheet();
-		}
-		styleSheet.__constructed = false;
-	}
-
-	var topScope;
-	if (opts && opts.cssRules) {
-		topScope = { cssRules: opts.cssRules };
-	} else {
-		topScope = styleSheet;
-	}
-
-	if (opts && opts.ownerNode) {
-		styleSheet.__ownerNode = opts.ownerNode;
-		var ownerNodeMedia = opts.ownerNode.media || (opts.ownerNode.getAttribute && opts.ownerNode.getAttribute("media"));
-		if (ownerNodeMedia) {
-			styleSheet.media.mediaText = ownerNodeMedia;
-		}
-		var ownerNodeTitle = opts.ownerNode.title || (opts.ownerNode.getAttribute && opts.ownerNode.getAttribute("title"));
-		if (ownerNodeTitle) {
-			styleSheet.__title = ownerNodeTitle;
-		}
-	}
-
-	if (opts && opts.ownerRule) {
-		styleSheet.__ownerRule = opts.ownerRule;
-	}
-
-	// @type CSSStyleSheet|CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSFontFaceRule|CSSKeyframesRule|CSSDocumentRule
-	var currentScope = topScope;
-
-	// @type CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSKeyframesRule|CSSDocumentRule
-	var parentRule;
-
-	var ancestorRules = [];
-	var prevScope;
-
-	var name, priority = "", styleRule, mediaRule, containerRule, counterStyleRule, propertyRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, scopeRule, pageRule, layerBlockRule, layerStatementRule, nestedSelectorRule, namespaceRule;
-
-	// Track defined namespace prefixes for validation
-	var definedNamespacePrefixes = {};
-
-	// Track which rules have been added
-	var ruleIdCounter = 0;
-	var addedToParent = {};
-	var addedToTopScope = {};
-	var addedToCurrentScope = {};
-
-	// Helper to get unique ID for tracking rules
-	function getRuleId(rule) {
-		if (!rule.__parseId) {
-			rule.__parseId = ++ruleIdCounter;
-		}
-		return rule.__parseId;
-	}
-
-	// Cache last validation boundary position
-	// to avoid rescanning the entire token string for each at-rule
-	var lastValidationBoundary = 0;
-
-	// Pre-compile validation regexes for common at-rules
-	var validationRegexCache = {};
-	function getValidationRegex(atRuleKey) {
-		if (!validationRegexCache[atRuleKey]) {
-			var sourceRuleRegExp = atRuleKey === "@import" ? forwardImportRuleValidationRegExp : forwardRuleValidationRegExp;
-			validationRegexCache[atRuleKey] = new RegExp(atRuleKey + sourceRuleRegExp.source, sourceRuleRegExp.flags);
-		}
-		return validationRegexCache[atRuleKey];
-	}
-
-	// Import regex patterns from shared module
-	var atKeyframesRegExp = regexPatterns.atKeyframesRegExp;
-	var beforeRulePortionRegExp = regexPatterns.beforeRulePortionRegExp;
-	var beforeRuleValidationRegExp = regexPatterns.beforeRuleValidationRegExp;
-	var forwardRuleValidationRegExp = regexPatterns.forwardRuleValidationRegExp;
-	var forwardImportRuleValidationRegExp = regexPatterns.forwardImportRuleValidationRegExp;
-
-	// Pre-compile regexBefore to avoid creating it on every validateAtRule call
-	var regexBefore = new RegExp(beforeRulePortionRegExp.source, beforeRulePortionRegExp.flags);
-	var forwardRuleClosingBraceRegExp = regexPatterns.forwardRuleClosingBraceRegExp;
-	var forwardRuleSemicolonAndOpeningBraceRegExp = regexPatterns.forwardRuleSemicolonAndOpeningBraceRegExp;
-	var cssCustomIdentifierRegExp = regexPatterns.cssCustomIdentifierRegExp;
-	var startsWithCombinatorRegExp = regexPatterns.startsWithCombinatorRegExp;
-	var atPageRuleSelectorRegExp = regexPatterns.atPageRuleSelectorRegExp;
-	var startsWithHexEscapeRegExp = regexPatterns.startsWithHexEscapeRegExp;
-	var identStartCharRegExp = regexPatterns.identStartCharRegExp;
-	var identCharRegExp = regexPatterns.identCharRegExp;
-	var specialCharsNeedEscapeRegExp = regexPatterns.specialCharsNeedEscapeRegExp;
-	var combinatorOrSeparatorRegExp = regexPatterns.combinatorOrSeparatorRegExp;
-	var afterHexEscapeSeparatorRegExp = regexPatterns.afterHexEscapeSeparatorRegExp;
-	var trailingSpaceSeparatorRegExp = regexPatterns.trailingSpaceSeparatorRegExp;
-	var endsWithHexEscapeRegExp = regexPatterns.endsWithHexEscapeRegExp;
-	var attributeSelectorContentRegExp = regexPatterns.attributeSelectorContentRegExp;
-	var pseudoElementRegExp = regexPatterns.pseudoElementRegExp;
-	var invalidCombinatorLtGtRegExp = regexPatterns.invalidCombinatorLtGtRegExp;
-	var invalidCombinatorDoubleGtRegExp = regexPatterns.invalidCombinatorDoubleGtRegExp;
-	var consecutiveCombinatorsRegExp = regexPatterns.consecutiveCombinatorsRegExp;
-	var invalidSlottedRegExp = regexPatterns.invalidSlottedRegExp;
-	var invalidPartRegExp = regexPatterns.invalidPartRegExp;
-	var invalidCueRegExp = regexPatterns.invalidCueRegExp;
-	var invalidCueRegionRegExp = regexPatterns.invalidCueRegionRegExp;
-	var invalidNestingPattern = regexPatterns.invalidNestingPattern;
-	var emptyPseudoClassRegExp = regexPatterns.emptyPseudoClassRegExp;
-	var whitespaceNormalizationRegExp = regexPatterns.whitespaceNormalizationRegExp;
-	var newlineRemovalRegExp = regexPatterns.newlineRemovalRegExp;
-	var whitespaceAndDotRegExp = regexPatterns.whitespaceAndDotRegExp;
-	var declarationOrOpenBraceRegExp = regexPatterns.declarationOrOpenBraceRegExp;
-	var ampersandRegExp = regexPatterns.ampersandRegExp;
-	var hexEscapeSequenceRegExp = regexPatterns.hexEscapeSequenceRegExp;
-	var attributeCaseFlagRegExp = regexPatterns.attributeCaseFlagRegExp;
-	var prependedAmpersandRegExp = regexPatterns.prependedAmpersandRegExp;
-	var openBraceGlobalRegExp = regexPatterns.openBraceGlobalRegExp;
-	var closeBraceGlobalRegExp = regexPatterns.closeBraceGlobalRegExp;
-	var scopePreludeSplitRegExp = regexPatterns.scopePreludeSplitRegExp;
-	var leadingWhitespaceRegExp = regexPatterns.leadingWhitespaceRegExp;
-	var doubleQuoteRegExp = regexPatterns.doubleQuoteRegExp;
-	var backslashRegExp = regexPatterns.backslashRegExp;
-
-	/**
-	 * Searches for the first occurrence of a CSS at-rule statement terminator (`;` or `}`) 
-	 * that is not inside a brace block within the given string. Mimics the behavior of a 
-	 * regular expression match for such terminators, including any trailing whitespace.
-	 * @param {string} str - The string to search for at-rule statement terminators.
-	 * @returns {object | null} {0: string, index: number} or null if no match is found.
-	 */
-	function atRulesStatemenRegExpES5Alternative(ruleSlice) {
-		for (var i = 0; i < ruleSlice.length; i++) {
-			var char = ruleSlice[i];
-
-			if (char === ';' || char === '}') {
-				// Simulate negative lookbehind: check if there is a { before this position
-				var sliceBefore = ruleSlice.substring(0, i);
-				var openBraceIndex = sliceBefore.indexOf('{');
-
-				if (openBraceIndex === -1) {
-					// No { found before, so we treat it as a valid match
-					var match = char;
-					var j = i + 1;
-
-					while (j < ruleSlice.length && /\s/.test(ruleSlice[j])) {
-						match += ruleSlice[j];
-						j++;
-					}
-
-					var matchObj = [match];
-					matchObj.index = i;
-					matchObj.input = ruleSlice;
-					return matchObj;
-				}
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Finds the first balanced block (including nested braces) in the string, starting from fromIndex.
-	 * Returns an object similar to RegExp.prototype.match output.
-	 * @param {string} str - The string to search.
-	 * @param {number} [fromIndex=0] - The index to start searching from.
-	 * @returns {object|null} - { 0: matchedString, index: startIndex, input: str } or null if not found.
-	 */
-	function matchBalancedBlock(str, fromIndex) {
-		fromIndex = fromIndex || 0;
-		var openIndex = str.indexOf('{', fromIndex);
-		if (openIndex === -1) return null;
-		var depth = 0;
-		for (var i = openIndex; i < str.length; i++) {
-			if (str[i] === '{') {
-				depth++;
-			} else if (str[i] === '}') {
-				depth--;
-				if (depth === 0) {
-					var matchedString = str.slice(openIndex, i + 1);
-					return {
-						0: matchedString,
-						index: openIndex,
-						input: str
-					};
-				}
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Advances the index `i` to skip over a balanced block of curly braces in the given string.
-	 * This is typically used to ignore the contents of a CSS rule block.
-	 *
-	 * @param {number} i - The current index in the string to start searching from.
-	 * @param {string} str - The string containing the CSS code.
-	 * @param {number} fromIndex - The index in the string where the balanced block search should begin.
-	 * @returns {number} The updated index after skipping the balanced block.
-	 */
-	function ignoreBalancedBlock(i, str, fromIndex) {
-		var ruleClosingMatch = matchBalancedBlock(str, fromIndex);
-		if (ruleClosingMatch) {
-			var ignoreRange = ruleClosingMatch.index + ruleClosingMatch[0].length;
-			i += ignoreRange;
-			if (token.charAt(i) === '}') {
-				i -= 1;
-			}
-		} else {
-			i += str.length;
-		}
-		return i;
-	}
-
-	/**
-	 * Parses the scope prelude and extracts start and end selectors.
-	 * @param {string} preludeContent - The scope prelude content (without @scope keyword)
-	 * @returns {object} Object with startSelector and endSelector properties
-	 */
-	function parseScopePrelude(preludeContent) {
-		var parts = preludeContent.split(scopePreludeSplitRegExp);
-
-		// Restore the parentheses that were consumed by the split
-		if (parts.length === 2) {
-			parts[0] = parts[0] + ')';
-			parts[1] = '(' + parts[1];
-		}
-
-		var hasStart = parts[0] &&
-			parts[0].charAt(0) === '(' &&
-			parts[0].charAt(parts[0].length - 1) === ')';
-		var hasEnd = parts[1] &&
-			parts[1].charAt(0) === '(' &&
-			parts[1].charAt(parts[1].length - 1) === ')';
-
-		// Handle case: @scope to (<end>)
-		var hasOnlyEnd = !hasStart &&
-			!hasEnd &&
-			parts[0].indexOf('to (') === 0 &&
-			parts[0].charAt(parts[0].length - 1) === ')';
-
-		var startSelector = '';
-		var endSelector = '';
-
-		if (hasStart) {
-			startSelector = parts[0].slice(1, -1).trim();
-		}
-		if (hasEnd) {
-			endSelector = parts[1].slice(1, -1).trim();
-		}
-		if (hasOnlyEnd) {
-			endSelector = parts[0].slice(4, -1).trim();
-		}
-
-		return {
-			startSelector: startSelector,
-			endSelector: endSelector,
-			hasStart: hasStart,
-			hasEnd: hasEnd,
-			hasOnlyEnd: hasOnlyEnd
-		};
-	};
-
-	/**
-	 * Checks if a selector contains pseudo-elements.
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains pseudo-elements
-	 */
-	function hasPseudoElement(selector) {
-		// Match only double-colon (::) pseudo-elements
-		// Also match legacy single-colon pseudo-elements: :before, :after, :first-line, :first-letter
-		// These must NOT be followed by alphanumeric characters (to avoid matching :before-x or similar)
-		return pseudoElementRegExp.test(selector);
-	};
-
-	/**
-	 * Validates balanced parentheses, brackets, and quotes in a selector.
-	 * 
-	 * @param {string} selector - The CSS selector to validate
-	 * @param {boolean} trackAttributes - Whether to track attribute selector context
-	 * @param {boolean} useStack - Whether to use a stack for parentheses (needed for nested validation)
-	 * @returns {boolean} True if the syntax is valid (all brackets, parentheses, and quotes are balanced)
-	 */
-	function validateBalancedSyntax(selector, trackAttributes, useStack) {
-		var parenDepth = 0;
-		var bracketDepth = 0;
-		var inSingleQuote = false;
-		var inDoubleQuote = false;
-		var inAttr = false;
-		var stack = useStack ? [] : null;
-
-		for (var i = 0; i < selector.length; i++) {
-			var char = selector[i];
-
-			// Handle escape sequences - skip hex escapes or simple escapes
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-
-			if (inSingleQuote) {
-				if (char === "'") {
-					inSingleQuote = false;
-				}
-			} else if (inDoubleQuote) {
-				if (char === '"') {
-					inDoubleQuote = false;
-				}
-			} else if (trackAttributes && inAttr) {
-				if (char === "]") {
-					inAttr = false;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				}
-			} else {
-				if (trackAttributes && char === "[") {
-					inAttr = true;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				} else if (char === '(') {
-					if (useStack) {
-						stack.push("(");
-					} else {
-						parenDepth++;
-					}
-				} else if (char === ')') {
-					if (useStack) {
-						if (!stack.length || stack.pop() !== "(") {
-							return false;
-						}
-					} else {
-						parenDepth--;
-						if (parenDepth < 0) {
-							return false;
-						}
-					}
-				} else if (char === '[') {
-					bracketDepth++;
-				} else if (char === ']') {
-					bracketDepth--;
-					if (bracketDepth < 0) {
-						return false;
-					}
-				}
-			}
-		}
-
-		// Check if everything is balanced
-		if (useStack) {
-			return stack.length === 0 && bracketDepth === 0 && !inSingleQuote && !inDoubleQuote && !inAttr;
-		} else {
-			return parenDepth === 0 && bracketDepth === 0 && !inSingleQuote && !inDoubleQuote;
-		}
-	};
-
-	/**
-	 * Checks for basic syntax errors in selectors (mismatched parentheses, brackets, quotes).
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if there are syntax errors
-	 */
-	function hasBasicSyntaxError(selector) {
-		return !validateBalancedSyntax(selector, false, false);
-	};
-
-	/**
-	 * Checks for invalid combinator patterns in selectors.
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid combinators
-	 */
-	function hasInvalidCombinators(selector) {
-		// Check for invalid combinator patterns:
-		// - <> (not a valid combinator)
-		// - >> (deep descendant combinator, deprecated and invalid)
-		// - Multiple consecutive combinators like >>, >~, etc.
-		if (invalidCombinatorLtGtRegExp.test(selector)) return true;
-		if (invalidCombinatorDoubleGtRegExp.test(selector)) return true;
-		// Check for other invalid consecutive combinator patterns
-		if (consecutiveCombinatorsRegExp.test(selector)) return true;
-		return false;
-	};
-
-	/**
-	 * Checks for invalid pseudo-like syntax (function calls without proper pseudo prefix).
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid pseudo-like syntax
-	 */
-	function hasInvalidPseudoSyntax(selector) {
-		// Check for specific known pseudo-elements used without : or :: prefix
-		// Examples: slotted(div), part(name), cue(selector)
-		// These are ONLY valid as ::slotted(), ::part(), ::cue()
-		var invalidPatterns = [
-			invalidSlottedRegExp,
-			invalidPartRegExp,
-			invalidCueRegExp,
-			invalidCueRegionRegExp
-		];
-
-		for (var i = 0; i < invalidPatterns.length; i++) {
-			if (invalidPatterns[i].test(selector)) {
-				return true;
-			}
-		}
-		return false;
-	};
-
-	/**
-	 * Checks for invalid nesting selector (&) usage.
-	 * The & selector cannot be directly followed by a type selector without a delimiter.
-	 * Valid: &.class, &#id, &[attr], &:hover, &::before, & div, &>div
-	 * Invalid: &div, &span
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid & usage
-	 */
-	function hasInvalidNestingSelector(selector) {
-		// Check for & followed directly by a letter (type selector) without any delimiter
-		// This regex matches & followed by a letter (start of type selector) that's not preceded by an escape
-		// We need to exclude valid cases like &.class, &#id, &[attr], &:pseudo, &::pseudo, & (with space), &>
-		return invalidNestingPattern.test(selector);
-	};
-
-	/**
-	 * Checks if an at-rule can be nested based on parent chain validation.
-	 * Used for at-rules like `@counter-style`, `@property` and `@font-face` rules that can only be nested inside
-	 * `CSSScopeRule` or `CSSConditionRule` without `CSSStyleRule` in parent chain.
-	 * @returns {boolean} `true` if nesting is allowed, `false` otherwise
-	 */
-	function canAtRuleBeNested() {
-		if (currentScope === topScope) {
-			return true; // Top-level is always allowed
-		}
-
-		var hasStyleRuleInChain = false;
-		var hasValidParent = false;
-
-		// Check currentScope
-		if (currentScope.constructor.name === 'CSSStyleRule') {
-			hasStyleRuleInChain = true;
-		} else if (currentScope instanceof CSSOM.CSSScopeRule || currentScope instanceof CSSOM.CSSConditionRule) {
-			hasValidParent = true;
-		}
-
-		// Check ancestorRules for CSSStyleRule
-		if (!hasStyleRuleInChain) {
-			for (var j = 0; j < ancestorRules.length; j++) {
-				if (ancestorRules[j].constructor.name === 'CSSStyleRule') {
-					hasStyleRuleInChain = true;
-					break;
-				}
-				if (ancestorRules[j] instanceof CSSOM.CSSScopeRule || ancestorRules[j] instanceof CSSOM.CSSConditionRule) {
-					hasValidParent = true;
-				}
-			}
-		}
-
-		// Allow nesting if we have a valid parent and no style rule in the chain
-		return hasValidParent && !hasStyleRuleInChain;
-	}
-
-	function validateAtRule(atRuleKey, validCallback, cannotBeNested) {
-		var isValid = false;
-		// Use cached regex instead of creating new one each time
-		var ruleRegExp = getValidationRegex(atRuleKey);
-		//  Only slice what we need for validation (max 100 chars)
-		// since we only check match at position 0
-		var lookAheadLength = Math.min(100, token.length - i);
-		var ruleSlice = token.slice(i, i + lookAheadLength);
-		// Not all rules can be nested, if the rule cannot be nested and is in the root scope, do not perform the check
-		var shouldPerformCheck = cannotBeNested && currentScope !== topScope ? false : true;
-		// First, check if there is no invalid characters just after the at-rule
-		if (shouldPerformCheck && ruleSlice.search(ruleRegExp) === 0) {
-			// Only scan from the last known validation boundary
-			var searchStart = Math.max(0, lastValidationBoundary);
-			var beforeSlice = token.slice(searchStart, i);
-			
-			// Use pre-compiled regex instead of creating new one each time
-			var matches = beforeSlice.match(regexBefore);
-			var lastI = matches ? searchStart + beforeSlice.lastIndexOf(matches[matches.length - 1]) : searchStart;
-			var toCheckSlice = token.slice(lastI, i);
-			// Check if we don't have any invalid in the portion before the `at-rule` and the closest allowed character
-			var checkedSlice = toCheckSlice.search(beforeRuleValidationRegExp);
-			if (checkedSlice === 0) {
-				isValid = true;
-				// Update the validation boundary cache to this position
-				lastValidationBoundary = lastI;
-			}
-		}
-
-		// Additional validation for @scope rule
-		if (isValid && atRuleKey === "@scope") {
-			var openBraceIndex = ruleSlice.indexOf('{');
-			if (openBraceIndex !== -1) {
-				// Extract the rule prelude (everything between the at-rule and {)
-				var rulePrelude = ruleSlice.slice(0, openBraceIndex).trim();
-
-				// Skip past at-rule keyword and whitespace
-				var preludeContent = rulePrelude.slice("@scope".length).trim();
-
-				if (preludeContent.length > 0) {
-					// Parse the scope prelude
-					var parsedScopePrelude = parseScopePrelude(preludeContent);
-					var startSelector = parsedScopePrelude.startSelector;
-					var endSelector = parsedScopePrelude.endSelector;
-					var hasStart = parsedScopePrelude.hasStart;
-					var hasEnd = parsedScopePrelude.hasEnd;
-					var hasOnlyEnd = parsedScopePrelude.hasOnlyEnd;
-
-					// Validation rules for @scope:
-					// 1. Empty selectors in parentheses are invalid: @scope () {} or @scope (.a) to () {}
-					if ((hasStart && startSelector === '') || (hasEnd && endSelector === '') || (hasOnlyEnd && endSelector === '')) {
-						isValid = false;
-					}
-					// 2. Pseudo-elements are invalid in scope selectors
-					else if ((startSelector && hasPseudoElement(startSelector)) || (endSelector && hasPseudoElement(endSelector))) {
-						isValid = false;
-					}
-					// 3. Basic syntax errors (mismatched parens, brackets, quotes)
-					else if ((startSelector && hasBasicSyntaxError(startSelector)) || (endSelector && hasBasicSyntaxError(endSelector))) {
-						isValid = false;
-					}
-					// 4. Invalid combinator patterns
-					else if ((startSelector && hasInvalidCombinators(startSelector)) || (endSelector && hasInvalidCombinators(endSelector))) {
-						isValid = false;
-					}
-					// 5. Invalid pseudo-like syntax (function without : or :: prefix)
-					else if ((startSelector && hasInvalidPseudoSyntax(startSelector)) || (endSelector && hasInvalidPseudoSyntax(endSelector))) {
-						isValid = false;
-					}
-					// 6. Invalid structure (no proper parentheses found when prelude is not empty)
-					else if (!hasStart && !hasOnlyEnd) {
-						isValid = false;
-					}
-				}
-				// Empty prelude (@scope {}) is valid
-			}
-		}
-
-		if (isValid && atRuleKey === "@page") {
-			var openBraceIndex = ruleSlice.indexOf('{');
-			if (openBraceIndex !== -1) {
-				// Extract the rule prelude (everything between the at-rule and {)
-				var rulePrelude = ruleSlice.slice(0, openBraceIndex).trim();
-
-				// Skip past at-rule keyword and whitespace
-				var preludeContent = rulePrelude.slice("@page".length).trim();
-
-				if (preludeContent.length > 0) {
-					var trimmedValue = preludeContent.trim();
-
-					// Empty selector is valid for @page
-					if (trimmedValue !== '') {
-						// Parse @page selectorText for page name and pseudo-pages
-						// Valid formats:
-						// - (empty - no name, no pseudo-page)
-						// - :left, :right, :first, :blank (pseudo-page only)
-						// - named (named page only)
-						// - named:first (named page with single pseudo-page)
-						// - named:first:left (named page with multiple pseudo-pages)
-						var match = trimmedValue.match(atPageRuleSelectorRegExp);
-						if (match) {
-							var pageName = match[1] || '';
-							var pseudoPages = match[2] || '';
-
-							// Validate page name if present
-							if (pageName) {
-								if (!cssCustomIdentifierRegExp.test(pageName)) {
-									isValid = false;
-								}
-							}
-
-							// Validate pseudo-pages if present
-							if (pseudoPages) {
-								var pseudos = pseudoPages.split(':').filter(function (p) { return p; });
-								var validPseudos = ['left', 'right', 'first', 'blank'];
-								var allValid = true;
-								for (var j = 0; j < pseudos.length; j++) {
-									if (validPseudos.indexOf(pseudos[j].toLowerCase()) === -1) {
-										allValid = false;
-										break;
-									}
-								}
-
-								if (!allValid) {
-									isValid = false;
-								}
-							}
-						} else {
-							isValid = false;
-						}
-					}
-
-				}
-			}
-		}
-
-		if (!isValid) {
-			// If it's invalid the browser will simply ignore the entire invalid block
-			// Use regex to find the closing brace of the invalid rule
-
-			// Regex used above is not ES5 compliant. Using alternative.
-			// var ruleStatementMatch = ruleSlice.match(atRulesStatemenRegExp); //
-			var ruleStatementMatch = atRulesStatemenRegExpES5Alternative(ruleSlice);
-
-			// If it's a statement inside a nested rule, ignore only the statement
-			if (ruleStatementMatch && currentScope !== topScope) {
-				var ignoreEnd = ruleStatementMatch[0].indexOf(";");
-				i += ruleStatementMatch.index + ignoreEnd;
-				return;
-			}
-
-			// Check if there's a semicolon before the invalid at-rule and the first opening brace
-			if (atRuleKey === "@layer") {
-				var ruleSemicolonAndOpeningBraceMatch = ruleSlice.match(forwardRuleSemicolonAndOpeningBraceRegExp);
-				if (ruleSemicolonAndOpeningBraceMatch && ruleSemicolonAndOpeningBraceMatch[1] === ";") {
-					// Ignore the rule block until the semicolon
-					i += ruleSemicolonAndOpeningBraceMatch.index + ruleSemicolonAndOpeningBraceMatch[0].length;
-					state = "before-selector";
-					return;
-				}
-			}
-
-			// Ignore the entire rule block (if it's a statement it should ignore the statement plus the next block)
-			i = ignoreBalancedBlock(i, ruleSlice);
-			state = "before-selector";
-		} else {
-			validCallback.call(this);
-		}
-	}
-
-	// Helper functions for looseSelectorValidator
-	// Defined outside to avoid recreation on every validation call
-
-	/**
-	 * Check if character is a valid identifier start
-	 * @param {string} c - Character to check
-	 * @returns {boolean}
-	 */
-	function isIdentStart(c) {
-		return /[a-zA-Z_\u00A0-\uFFFF]/.test(c);
-	}
-
-	/**
-	 * Check if character is a valid identifier character
-	 * @param {string} c - Character to check
-	 * @returns {boolean}
-	 */
-	function isIdentChar(c) {
-		return /[a-zA-Z0-9_\u00A0-\uFFFF\-]/.test(c);
-	}
-
-	/**
-	 * Helper function to validate CSS selector syntax without regex backtracking.
-	 * Iteratively parses the selector string to identify valid components.
-	 * 
-	 * Supports:
-	 * - Escaped characters (e.g., .class\!, #id\@name)
-	 * - Namespace selectors (ns|element, *|element, |element)
-	 * - All standard CSS selectors (class, ID, type, attribute, pseudo, etc.)
-	 * - Combinators (>, +, ~, whitespace)
-	 * - Nesting selector (&)
-	 * 
-	 * This approach eliminates exponential backtracking by using explicit character-by-character
-	 * parsing instead of nested quantifiers in regex.
-	 * 
-	 * @param {string} selector - The selector to validate
-	 * @returns {boolean} - True if valid selector syntax
-	 */
-	function looseSelectorValidator(selector) {
-		if (!selector || selector.length === 0) {
-			return false;
-		}
-
-		var i = 0;
-		var len = selector.length;
-		var hasMatchedComponent = false;
-
-		// Helper: Skip escaped character (backslash + hex escape or any char)
-		function skipEscape() {
-			if (i < len && selector[i] === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen; // Skip entire escape sequence
-					return true;
-				}
-			}
-			return false;
-		}
-
-		// Helper: Parse identifier (with possible escapes)
-		function parseIdentifier() {
-			var start = i;
-			while (i < len) {
-				if (skipEscape()) {
-					continue;
-				} else if (isIdentChar(selector[i])) {
-					i++;
-				} else {
-					break;
-				}
-			}
-			return i > start;
-		}
-
-		// Helper: Parse namespace prefix (optional)
-		function parseNamespace() {
-			var start = i;
-
-			// Match: *| or identifier| or |
-			if (i < len && selector[i] === '*') {
-				i++;
-			} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
-				parseIdentifier();
-			}
-
-			if (i < len && selector[i] === '|') {
-				i++;
-				return true;
-			}
-
-			// Rollback if no pipe found
-			i = start;
-			return false;
-		}
-
-		// Helper: Parse pseudo-class/element arguments (with balanced parens)
-		function parsePseudoArgs() {
-			if (i >= len || selector[i] !== '(') {
-				return false;
-			}
-
-			i++; // Skip opening paren
-			var depth = 1;
-			var inString = false;
-			var stringChar = '';
-
-			while (i < len && depth > 0) {
-				var c = selector[i];
-
-				if (c === '\\' && i + 1 < len) {
-					i += 2; // Skip escaped character
-				} else if (!inString && (c === '"' || c === '\'')) {
-					inString = true;
-					stringChar = c;
-					i++;
-				} else if (inString && c === stringChar) {
-					inString = false;
-					i++;
-				} else if (!inString && c === '(') {
-					depth++;
-					i++;
-				} else if (!inString && c === ')') {
-					depth--;
-					i++;
-				} else {
-					i++;
-				}
-			}
-
-			return depth === 0;
-		}
-
-		// Main parsing loop
-		while (i < len) {
-			var matched = false;
-			var start = i;
-
-			// Skip whitespace
-			while (i < len && /\s/.test(selector[i])) {
-				i++;
-			}
-			if (i > start) {
-				hasMatchedComponent = true;
-				continue;
-			}
-
-			// Match combinators: >, +, ~
-			if (i < len && /[>+~]/.test(selector[i])) {
-				i++;
-				hasMatchedComponent = true;
-				// Skip trailing whitespace
-				while (i < len && /\s/.test(selector[i])) {
-					i++;
-				}
-				continue;
-			}
-
-			// Match nesting selector: &
-			if (i < len && selector[i] === '&') {
-				i++;
-				hasMatchedComponent = true;
-				matched = true;
-			}
-			// Match class selector: .identifier
-			else if (i < len && selector[i] === '.') {
-				i++;
-				if (parseIdentifier()) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match ID selector: #identifier
-			else if (i < len && selector[i] === '#') {
-				i++;
-				if (parseIdentifier()) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match pseudo-class/element: :identifier or ::identifier
-			else if (i < len && selector[i] === ':') {
-				i++;
-				if (i < len && selector[i] === ':') {
-					i++; // Pseudo-element
-				}
-				if (parseIdentifier()) {
-					parsePseudoArgs(); // Optional arguments
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match attribute selector: [...]
-			else if (i < len && selector[i] === '[') {
-				i++;
-				var depth = 1;
-				while (i < len && depth > 0) {
-					if (selector[i] === '\\') {
-						i += 2;
-					} else if (selector[i] === '\'') {
-						i++;
-						while (i < len && selector[i] !== '\'') {
-							if (selector[i] === '\\') i += 2;
-							else i++;
-						}
-						if (i < len) i++; // Skip closing quote
-					} else if (selector[i] === '"') {
-						i++;
-						while (i < len && selector[i] !== '"') {
-							if (selector[i] === '\\') i += 2;
-							else i++;
-						}
-						if (i < len) i++; // Skip closing quote
-					} else if (selector[i] === '[') {
-						depth++;
-						i++;
-					} else if (selector[i] === ']') {
-						depth--;
-						i++;
-					} else {
-						i++;
-					}
-				}
-				if (depth === 0) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match type selector with optional namespace: [namespace|]identifier
-			else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\' || selector[i] === '*' || selector[i] === '|')) {
-				parseNamespace(); // Optional namespace prefix
-
-				if (i < len && selector[i] === '*') {
-					i++; // Universal selector
-					hasMatchedComponent = true;
-					matched = true;
-				} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
-					if (parseIdentifier()) {
-						hasMatchedComponent = true;
-						matched = true;
-					}
-				}
-			}
-
-			// If no match found, invalid selector
-			if (!matched && i === start) {
-				return false;
-			}
-		}
-
-		return hasMatchedComponent;
-	}
-
-	/**
-	 * Validates a basic CSS selector, allowing for deeply nested balanced parentheses in pseudo-classes.
-	 * This function replaces the previous basicSelectorRegExp.
-	 * 
-	 * This function matches:
-	 * - Type selectors (e.g., `div`, `span`)
-	 * - Universal selector (`*`)
-	 * - Namespace selectors (e.g., `*|div`, `custom|div`, `|div`)
-	 * - ID selectors (e.g., `#header`, `#a\ b`, `#åèiöú`)
-	 * - Class selectors (e.g., `.container`, `.a\ b`, `.åèiöú`)
-	 * - Attribute selectors (e.g., `[type="text"]`)
-	 * - Pseudo-classes and pseudo-elements (e.g., `:hover`, `::before`, `:nth-child(2)`)
-	 * - Pseudo-classes with nested parentheses, including cases where parentheses are nested inside arguments,
-	 *   such as `:has(.sel:nth-child(3n))`
-	 * - The parent selector (`&`)
-	 * - Combinators (`>`, `+`, `~`) with optional whitespace
-	 * - Whitespace (descendant combinator)
-	 *
-	 * Unicode and escape sequences are allowed in identifiers.
-	 *
-	 * @param {string} selector
-	 * @returns {boolean}
-	 */
-	function basicSelectorValidator(selector) {
-		// Guard against extremely long selectors to prevent potential regex performance issues
-		// Reasonable selectors are typically under 1000 characters
-		if (selector.length > 10000) {
-			return false;
-		}
-
-		// Validate balanced syntax with attribute tracking and stack-based parentheses matching
-		if (!validateBalancedSyntax(selector, true, true)) {
-			return false;
-		}
-
-		// Check for invalid combinator patterns
-		if (hasInvalidCombinators(selector)) {
-			return false;
-		}
-
-		// Check for invalid pseudo-like syntax
-		if (hasInvalidPseudoSyntax(selector)) {
-			return false;
-		}
-
-		// Check for invalid nesting selector (&) usage
-		if (hasInvalidNestingSelector(selector)) {
-			return false;
-		}
-
-		// Check for invalid pseudo-class usage with quoted strings
-		// Pseudo-classes like :lang(), :dir(), :nth-*() should not accept quoted strings
-		// Using iterative parsing instead of regex to avoid exponential backtracking
-		var noQuotesPseudos = ['lang', 'dir', 'nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type'];
-
-		for (var idx = 0; idx < selector.length; idx++) {
-			// Look for pseudo-class/element start
-			if (selector[idx] === ':') {
-				var pseudoStart = idx;
-				idx++;
-
-				// Skip second colon for pseudo-elements
-				if (idx < selector.length && selector[idx] === ':') {
-					idx++;
-				}
-
-				// Extract pseudo name
-				var nameStart = idx;
-				while (idx < selector.length && /[a-zA-Z0-9\-]/.test(selector[idx])) {
-					idx++;
-				}
-
-				if (idx === nameStart) {
-					continue; // No name found
-				}
-
-				var pseudoName = selector.substring(nameStart, idx).toLowerCase();
-
-				// Check if this pseudo has arguments
-				if (idx < selector.length && selector[idx] === '(') {
-					idx++;
-					var contentStart = idx;
-					var depth = 1;
-
-					// Find matching closing paren (handle nesting)
-					while (idx < selector.length && depth > 0) {
-						if (selector[idx] === '\\') {
-							idx += 2; // Skip escaped character
-						} else if (selector[idx] === '(') {
-							depth++;
-							idx++;
-						} else if (selector[idx] === ')') {
-							depth--;
-							idx++;
-						} else {
-							idx++;
-						}
-					}
-
-					if (depth === 0) {
-						var pseudoContent = selector.substring(contentStart, idx - 1);
-
-						// Check if this pseudo should not have quoted strings
-						for (var j = 0; j < noQuotesPseudos.length; j++) {
-							if (pseudoName === noQuotesPseudos[j] && /['"]/.test(pseudoContent)) {
-								return false;
-							}
-						}
-					}
-				}
-			}
-		}
-
-		// Use the iterative validator to avoid regex backtracking issues
-		return looseSelectorValidator(selector);
-	}
-
-	/**
-	 * Regular expression to match CSS pseudo-classes with arguments.
-	 *
-	 * Matches patterns like `:pseudo-class(argument)`, capturing the pseudo-class name and its argument.
-	 *
-	 * Capture groups:
-	 *   1. The pseudo-class name (letters and hyphens).
-	 *   2. The argument inside the parentheses (can contain nested parentheses, quoted strings, and other characters.).
-	 *
-	 * Global flag (`g`) is used to find all matches in the input string.
-	 *
-	 * Example matches:
-	 *   - :nth-child(2n+1)
-	 *   - :has(.sel:nth-child(3n))
-	 *   - :not(".foo, .bar")
-	 *
-	 * REPLACED WITH FUNCTION to avoid exponential backtracking.
-	 */
-
-	/**
-	 * Extract pseudo-classes with arguments from a selector using iterative parsing.
-	 * Replaces the previous globalPseudoClassRegExp to avoid exponential backtracking.
-	 * 
-	 * Handles:
-	 * - Regular content without parentheses or quotes
-	 * - Single-quoted strings
-	 * - Double-quoted strings  
-	 * - Nested parentheses (arbitrary depth)
-	 * 
-	 * @param {string} selector - The CSS selector to parse
-	 * @returns {Array} Array of matches, each with: [fullMatch, pseudoName, pseudoArgs, startIndex]
-	 */
-	function extractPseudoClasses(selector) {
-		var matches = [];
-
-		for (var i = 0; i < selector.length; i++) {
-			// Look for pseudo-class start (single or double colon)
-			if (selector[i] === ':') {
-				var pseudoStart = i;
-				i++;
-
-				// Skip second colon for pseudo-elements (::)
-				if (i < selector.length && selector[i] === ':') {
-					i++;
-				}
-
-				// Extract pseudo name
-				var nameStart = i;
-				while (i < selector.length && /[a-zA-Z\-]/.test(selector[i])) {
-					i++;
-				}
-
-				if (i === nameStart) {
-					continue; // No name found
-				}
-
-				var pseudoName = selector.substring(nameStart, i);
-
-				// Check if this pseudo has arguments
-				if (i < selector.length && selector[i] === '(') {
-					i++;
-					var argsStart = i;
-					var depth = 1;
-					var inSingleQuote = false;
-					var inDoubleQuote = false;
-
-					// Find matching closing paren (handle nesting and strings)
-					while (i < selector.length && depth > 0) {
-						var ch = selector[i];
-
-						if (ch === '\\') {
-							i += 2; // Skip escaped character
-						} else if (ch === "'" && !inDoubleQuote) {
-							inSingleQuote = !inSingleQuote;
-							i++;
-						} else if (ch === '"' && !inSingleQuote) {
-							inDoubleQuote = !inDoubleQuote;
-							i++;
-						} else if (ch === '(' && !inSingleQuote && !inDoubleQuote) {
-							depth++;
-							i++;
-						} else if (ch === ')' && !inSingleQuote && !inDoubleQuote) {
-							depth--;
-							i++;
-						} else {
-							i++;
-						}
-					}
-
-					if (depth === 0) {
-						var pseudoArgs = selector.substring(argsStart, i - 1);
-						var fullMatch = selector.substring(pseudoStart, i);
-
-						// Store match in same format as regex: [fullMatch, pseudoName, pseudoArgs, startIndex]
-						matches.push([fullMatch, pseudoName, pseudoArgs, pseudoStart]);
-					}
-
-					// Move back one since loop will increment
-					i--;
-				}
-			}
-		}
-
-		return matches;
-	}
-
-	/**
-	 * Parses a CSS selector string and splits it into parts, handling nested parentheses.
-	 *
-	 * This function is useful for splitting selectors that may contain nested function-like
-	 * syntax (e.g., :not(.foo, .bar)), ensuring that commas inside parentheses do not split
-	 * the selector.
-	 *
-	 * @param {string} selector - The CSS selector string to parse.
-	 * @returns {string[]} An array of selector parts, split by top-level commas, with whitespace trimmed.
-	 */
-	function parseAndSplitNestedSelectors(selector) {
-		var depth = 0;           // Track parenthesis nesting depth
-		var buffer = "";         // Accumulate characters for current selector part
-		var parts = [];          // Array of split selector parts
-		var inSingleQuote = false; // Track if we're inside single quotes
-		var inDoubleQuote = false; // Track if we're inside double quotes
-		var i, char;
-
-		for (i = 0; i < selector.length; i++) {
-			char = selector.charAt(i);
-
-			// Handle escape sequences - skip them entirely
-			if (char === '\\' && i + 1 < selector.length) {
-				buffer += char;
-				i++;
-				buffer += selector.charAt(i);
-				continue;
-			}
-
-			// Handle single quote strings
-			if (char === "'" && !inDoubleQuote) {
-				inSingleQuote = !inSingleQuote;
-				buffer += char;
-			}
-			// Handle double quote strings
-			else if (char === '"' && !inSingleQuote) {
-				inDoubleQuote = !inDoubleQuote;
-				buffer += char;
-			}
-			// Process characters outside of quoted strings
-			else if (!inSingleQuote && !inDoubleQuote) {
-				if (char === '(') {
-					// Entering a nested level (e.g., :is(...))
-					depth++;
-					buffer += char;
-				} else if (char === ')') {
-					// Exiting a nested level
-					depth--;
-					buffer += char;
-				} else if (char === ',' && depth === 0) {
-					// Found a top-level comma separator - split here
-					// Note: escaped commas (\,) are already handled above
-					if (buffer.trim()) {
-						parts.push(buffer.trim());
-					}
-					buffer = "";
-				} else {
-					// Regular character - add to buffer
-					buffer += char;
-				}
-			}
-			// Characters inside quoted strings - add to buffer
-			else {
-				buffer += char;
-			}
-		}
-
-		// Add any remaining content in buffer as the last part
-		var trimmed = buffer.trim();
-		if (trimmed) {
-			// Preserve trailing space if selector ends with hex escape
-			var endsWithHexEscape = endsWithHexEscapeRegExp.test(buffer);
-			parts.push(endsWithHexEscape ? buffer.replace(leadingWhitespaceRegExp, '') : trimmed);
-		}
-
-		return parts;
-	}
-
-	/**
-	 * Validates a CSS selector string, including handling of nested selectors within certain pseudo-classes.
-	 *
-	 * This function checks if the provided selector is valid according to the rules defined by
-	 * `basicSelectorValidator`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
-	 * it recursively validates each nested selector using the same validation logic.
-	 *
-	 * @param {string} selector - The CSS selector string to validate.
-	 * @returns {boolean} Returns `true` if the selector is valid, otherwise `false`.
-	 */
-
-	// Cache to store validated selectors (previously a ES6 Map, now an ES5-compliant object)
-	var validatedSelectorsCache = {};
-
-	// Only pseudo-classes that accept selector lists should recurse
-	var selectorListPseudoClasses = {
-		'not': true,
-		'is': true,
-		'has': true,
-		'where': true
-	};
-
-	function validateSelector(selector) {
-		if (validatedSelectorsCache.hasOwnProperty(selector)) {
-			return validatedSelectorsCache[selector];
-		}
-
-		// Use function-based parsing to extract pseudo-classes (avoids backtracking)
-		var pseudoClassMatches = extractPseudoClasses(selector);
-
-		for (var j = 0; j < pseudoClassMatches.length; j++) {
-			var pseudoClass = pseudoClassMatches[j][1];
-			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				var nestedSelectors = parseAndSplitNestedSelectors(pseudoClassMatches[j][2]);
-
-				// Check if ANY selector in the list contains & (nesting selector)
-				// If so, skip validation for the entire selector list since & will be replaced at runtime
-				var hasAmpersand = false;
-				for (var k = 0; k < nestedSelectors.length; k++) {
-					if (ampersandRegExp.test(nestedSelectors[k])) {
-						hasAmpersand = true;
-						break;
-					}
-				}
-
-				// If any selector has &, skip validation for this entire pseudo-class
-				if (hasAmpersand) {
-					continue;
-				}
-
-				// Otherwise, validate each selector normally
-				for (var i = 0; i < nestedSelectors.length; i++) {
-					var nestedSelector = nestedSelectors[i];
-					if (!validatedSelectorsCache.hasOwnProperty(nestedSelector)) {
-						var nestedSelectorValidation = validateSelector(nestedSelector);
-						validatedSelectorsCache[nestedSelector] = nestedSelectorValidation;
-						if (!nestedSelectorValidation) {
-							validatedSelectorsCache[selector] = false;
-							return false;
-						}
-					} else if (!validatedSelectorsCache[nestedSelector]) {
-						validatedSelectorsCache[selector] = false;
-						return false;
-					}
-				}
-			}
-		}
-
-		var basicSelectorValidation = basicSelectorValidator(selector);
-		validatedSelectorsCache[selector] = basicSelectorValidation;
-
-		return basicSelectorValidation;
-	}
-
-	/**
-	 * Validates namespace selectors by checking if the namespace prefix is defined.
-	 * 
-	 * @param {string} selector - The CSS selector to validate
-	 * @returns {boolean} Returns true if the namespace is valid, false otherwise
-	 */
-	function validateNamespaceSelector(selector) {
-		// Check if selector contains a namespace prefix
-		// We need to ignore pipes inside attribute selectors
-		var pipeIndex = -1;
-		var inAttr = false;
-		var inSingleQuote = false;
-		var inDoubleQuote = false;
-
-		for (var i = 0; i < selector.length; i++) {
-			var char = selector[i];
-
-			// Handle escape sequences - skip hex escapes or simple escapes
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-
-			if (inSingleQuote) {
-				if (char === "'") {
-					inSingleQuote = false;
-				}
-			} else if (inDoubleQuote) {
-				if (char === '"') {
-					inDoubleQuote = false;
-				}
-			} else if (inAttr) {
-				if (char === "]") {
-					inAttr = false;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				}
-			} else {
-				if (char === "[") {
-					inAttr = true;
-				} else if (char === "|" && !inAttr) {
-					// This is a namespace separator, not an attribute operator
-					pipeIndex = i;
-					break;
-				}
-			}
-		}
-
-		if (pipeIndex === -1) {
-			return true; // No namespace, always valid
-		}
-
-		var namespacePrefix = selector.substring(0, pipeIndex);
-
-		// Universal namespace (*|) and default namespace (|) are always valid
-		if (namespacePrefix === '*' || namespacePrefix === '') {
-			return true;
-		}
-
-		// Check if the custom namespace prefix is defined
-		return definedNamespacePrefixes.hasOwnProperty(namespacePrefix);
-	}
-
-	/**
-	 * Normalizes escape sequences in a selector to match browser behavior.
-	 * Decodes escape sequences and re-encodes them in canonical form.
-	 * 
-	 * @param {string} selector - The selector to normalize
-	 * @returns {string} Normalized selector
-	 */
-	function normalizeSelectorEscapes(selector) {
-		var result = '';
-		var i = 0;
-		var nextChar = '';
-		
-		// Track context for identifier boundaries
-		var inIdentifier = false;
-		var inAttribute = false;
-		var attributeDepth = 0;
-		var needsEscapeForIdent = false;
-		var lastWasHexEscape = false;
-		
-		while (i < selector.length) {
-			var char = selector[i];
-			
-			// Track attribute selector context
-			if (char === '[' && !inAttribute) {
-				inAttribute = true;
-				attributeDepth = 1;
-				result += char;
-				i++;
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				continue;
-			}
-			
-			if (inAttribute) {
-				if (char === '[') attributeDepth++;
-				if (char === ']') {
-					attributeDepth--;
-					if (attributeDepth === 0) inAttribute = false;
-				}
-				// Don't normalize escapes inside attribute selectors
-				if (char === '\\' && i + 1 < selector.length) {
-					var escapeLen = getEscapeSequenceLength(selector, i);
-					result += selector.substr(i, escapeLen);
-					i += escapeLen;
-				} else {
-					result += char;
-					i++;
-				}
-				lastWasHexEscape = false;
-				continue;
-			}
-			
-			// Handle escape sequences
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					var escapeSeq = selector.substr(i, escapeLen);
-					var decoded = decodeEscapeSequence(escapeSeq);
-					var wasHexEscape = startsWithHexEscapeRegExp.test(escapeSeq);
-					var hadTerminatingSpace = wasHexEscape && escapeSeq[escapeLen - 1] === ' ';
-					nextChar = selector[i + escapeLen] || '';
-					
-					// Check if this character needs escaping
-					var needsEscape = false;
-					var useHexEscape = false;
-					
-					if (needsEscapeForIdent) {
-						// At start of identifier (after . # or -)
-						// Digits must be escaped, letters/underscore/_/- don't need escaping
-						if (isDigit(decoded)) {
-							needsEscape = true;
-							useHexEscape = true;
-						} else if (decoded === '-') {
-							// Dash at identifier start: keep escaped if it's the only character,
-							// otherwise it can be decoded
-							var remainingSelector = selector.substring(i + escapeLen);
-							var hasMoreIdentChars = remainingSelector && identCharRegExp.test(remainingSelector[0]);
-							needsEscape = !hasMoreIdentChars;
-						} else if (!identStartCharRegExp.test(decoded)) {
-							needsEscape = true;
-						}
-					} else {
-						if (specialCharsNeedEscapeRegExp.test(decoded)) {
-							needsEscape = true;
-						}
-					}
-					
-					if (needsEscape) {
-						if (useHexEscape) {
-							// Use normalized hex escape
-							var codePoint = decoded.charCodeAt(0);
-							var hex = codePoint.toString(16);
-							result += '\\' + hex;
-							// Add space if next char could continue the hex sequence, 
-							// or if at end of selector (to disambiguate the escape)
-							if (isHexDigit(nextChar) || !nextChar || afterHexEscapeSeparatorRegExp.test(nextChar)) {
-								result += ' ';
-								lastWasHexEscape = false;
-							} else {
-								lastWasHexEscape = true;
-							}
-						} else {
-							// Use simple character escape
-							result += '\\' + decoded;
-							lastWasHexEscape = false;
-						}
-					} else {
-						// No escape needed, use the character directly
-						// But if previous was hex escape (without terminating space) and this is alphanumeric, add space
-						if (lastWasHexEscape && !hadTerminatingSpace && isAlphanumeric(decoded)) {
-							result += ' ';
-						}
-						result += decoded;
-						// Preserve terminating space at end of selector (when followed by non-ident char)
-						if (hadTerminatingSpace && (!nextChar || afterHexEscapeSeparatorRegExp.test(nextChar))) {
-							result += ' ';
-						}
-						lastWasHexEscape = false;
-					}
-					
-					i += escapeLen;
-					// After processing escape, check if we're still needing ident validation
-					// Only stay in needsEscapeForIdent state if decoded was '-'
-					needsEscapeForIdent = needsEscapeForIdent && decoded === '-';
-					inIdentifier = true;
-					continue;
-				}
-			}
-			
-			// Handle regular characters
-			if (char === '.' || char === '#') {
-				result += char;
-				needsEscapeForIdent = true;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else if (char === '-' && needsEscapeForIdent) {
-				// Dash after . or # - next char must be valid ident start or digit (which needs escaping)
-				result += char;
-				needsEscapeForIdent = true;
-				lastWasHexEscape = false;
-				i++;
-			} else if (isDigit(char) && needsEscapeForIdent) {
-				// Digit at identifier start must be hex escaped
-				var codePoint = char.charCodeAt(0);
-				var hex = codePoint.toString(16);
-				result += '\\' + hex;
-				nextChar = selector[i + 1] || '';
-				// Add space if next char could continue the hex sequence,
-				// or if at end of selector (to disambiguate the escape)
-				if (isHexDigit(nextChar) || !nextChar || afterHexEscapeSeparatorRegExp.test(nextChar)) {
-					result += ' ';
-					lastWasHexEscape = false;
-				} else {
-					lastWasHexEscape = true;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				i++;
-			} else if (char === ':' || combinatorOrSeparatorRegExp.test(char)) {
-				// Combinators, separators, and pseudo-class markers reset identifier state
-				// Preserve trailing space from hex escape
-				if (!(char === ' ' && lastWasHexEscape && result[result.length - 1] === ' ')) {
-					result += char;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else if (isLetter(char) && lastWasHexEscape) {
-				// Letter after hex escape needs a space separator
-				result += ' ' + char;
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				lastWasHexEscape = false;
-				i++;
-			} else if (char === ' ' && lastWasHexEscape) {
-				// Trailing space - keep it if at end or before non-ident char
-				nextChar = selector[i + 1] || '';
-				if (!nextChar || trailingSpaceSeparatorRegExp.test(nextChar)) {
-					result += char;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else {
-				result += char;
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				lastWasHexEscape = false;
-				i++;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Helper function to decode all escape sequences in a string.
-	 * 
-	 * @param {string} str - The string to decode
-	 * @returns {string} The decoded string
-	 */
-	function decodeEscapeSequencesInString(str) {
-		var result = '';
-		for (var i = 0; i < str.length; i++) {
-			if (str[i] === '\\' && i + 1 < str.length) {
-				// Get the escape sequence length
-				var escapeLen = getEscapeSequenceLength(str, i);
-				if (escapeLen > 0) {
-					var escapeSeq = str.substr(i, escapeLen);
-					var decoded = decodeEscapeSequence(escapeSeq);
-					result += decoded;
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			result += str[i];
-		}
-		return result;
-	}
-
-	/**
-	 * Decodes a CSS escape sequence to its character value.
-	 * 
-	 * @param {string} escapeSeq - The escape sequence (including backslash)
-	 * @returns {string} The decoded character
-	 */
-	function decodeEscapeSequence(escapeSeq) {
-		if (escapeSeq.length < 2 || escapeSeq[0] !== '\\') {
-			return escapeSeq;
-		}
-		
-		var content = escapeSeq.substring(1);
-		
-		// Check if it's a hex escape
-		var hexMatch = content.match(hexEscapeSequenceRegExp);
-		if (hexMatch) {
-			var codePoint = parseInt(hexMatch[1], 16);
-			// Handle surrogate pairs for code points > 0xFFFF
-			if (codePoint > 0xFFFF) {
-				// Convert to surrogate pair
-				codePoint -= 0x10000;
-				var high = 0xD800 + (codePoint >> 10);
-				var low = 0xDC00 + (codePoint & 0x3FF);
-				return String.fromCharCode(high, low);
-			}
-			return String.fromCharCode(codePoint);
-		}
-		
-		// Simple escape - return the character after backslash
-		return content[0] || '';
-	}
-
-	/**
-	 * Normalizes attribute selectors by ensuring values are properly quoted with double quotes.
-	 * Examples:
-	 *   [attr=value] -> [attr="value"]
-	 *   [attr="value"] -> [attr="value"] (unchanged)
-	 *   [attr='value'] -> [attr="value"] (converted to double quotes)
-	 * 
-	 * @param {string} selector - The selector to normalize
-	 * @returns {string|null} Normalized selector, or null if invalid
-	 */
-	function normalizeAttributeSelectors(selector) {
-		var result = '';
-		var i = 0;
-		
-		while (i < selector.length) {
-			// Look for attribute selector start
-			if (selector[i] === '[') {
-				result += '[';
-				i++;
-				
-				var attrContent = '';
-				var depth = 1;
-				
-				// Find the closing bracket, handling nested brackets and escapes
-				while (i < selector.length && depth > 0) {
-					if (selector[i] === '\\' && i + 1 < selector.length) {
-						attrContent += selector.substring(i, i + 2);
-						i += 2;
-						continue;
-					}
-					if (selector[i] === '[') depth++;
-					if (selector[i] === ']') {
-						depth--;
-						if (depth === 0) break;
-					}
-					attrContent += selector[i];
-					i++;
-				}
-				
-				// Normalize the attribute content
-				var normalized = normalizeAttributeContent(attrContent);
-				if (normalized === null) {
-					// Invalid attribute selector (e.g., unclosed quote)
-					return null;
-				}
-				result += normalized;
-				if (i < selector.length && selector[i] === ']') {
-					result += ']';
-					i++;
-				}
-			} else {
-				result += selector[i];
-				i++;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Processes a quoted attribute value by checking for proper closure and decoding escape sequences.
-	 * @param {string} trimmedValue - The quoted value (with quotes)
-	 * @param {string} quoteChar - The quote character ('"' or "'")
-	 * @param {string} attrName - The attribute name
-	 * @param {string} operator - The attribute operator
-	 * @param {string} flag - Optional case-sensitivity flag
-	 * @returns {string|null} Normalized attribute content, or null if invalid
-	 */
-	function processQuotedAttributeValue(trimmedValue, quoteChar, attrName, operator, flag) {
-		// Check if the closing quote is properly closed (not escaped)
-		if (trimmedValue.length < 2) {
-			return null; // Too short
-		}
-		// Find the actual closing quote (not escaped)
-		var i = 1;
-		var foundClose = false;
-		while (i < trimmedValue.length) {
-			if (trimmedValue[i] === '\\' && i + 1 < trimmedValue.length) {
-				// Skip escape sequence
-				var escapeLen = getEscapeSequenceLength(trimmedValue, i);
-				i += escapeLen;
-				continue;
-			}
-			if (trimmedValue[i] === quoteChar) {
-				// Found closing quote
-				foundClose = (i === trimmedValue.length - 1);
-				break;
-			}
-			i++;
-		}
-		if (!foundClose) {
-			return null; // Unclosed quote - invalid
-		}
-		// Extract inner value and decode escape sequences
-		var innerValue = trimmedValue.slice(1, -1);
-		var decodedValue = decodeEscapeSequencesInString(innerValue);
-		// If decoded value contains quotes, we need to escape them
-		var escapedValue = decodedValue.replace(doubleQuoteRegExp, '\\"');
-		return attrName + operator + '"' + escapedValue + '"' + (flag ? ' ' + flag : '');
-	}
-
-	/**
-	 * Normalizes the content inside an attribute selector.
-	 * @param {string} content - The content between [ and ]
-	 * @returns {string} Normalized content, or null if invalid
-	 */
-	function normalizeAttributeContent(content) {
-		// Match: attribute-name [operator] [value] [flag]
-		var match = content.match(attributeSelectorContentRegExp);
-		
-		if (!match) {
-			// No operator (e.g., [disabled]) or malformed - return as is
-			return content;
-		}
-		
-		var attrName = match[1];
-		var operator = match[2];
-		var valueAndFlag = match[3].trim(); // Trim here instead of in regex
-		
-		// Check if there's a case-sensitivity flag (i or s) at the end
-		var flagMatch = valueAndFlag.match(attributeCaseFlagRegExp);
-		var value = flagMatch ? flagMatch[1] : valueAndFlag;
-		var flag = flagMatch ? flagMatch[2] : '';
-		
-		// Check for unclosed quotes - this makes the selector invalid
-		var trimmedValue = value.trim();
-		var firstChar = trimmedValue[0];
-		
-		if (firstChar === '"') {
-			return processQuotedAttributeValue(trimmedValue, '"', attrName, operator, flag);
-		}
-		
-		if (firstChar === "'") {
-			return processQuotedAttributeValue(trimmedValue, "'", attrName, operator, flag);
-		}
-		
-		// Check for unescaped special characters in unquoted values
-		// Escaped special characters are valid (e.g., \` is valid, but ` is not)
-		var hasUnescapedSpecialChar = false;
-		for (var i = 0; i < trimmedValue.length; i++) {
-			var char = trimmedValue[i];
-			if (char === '\\' && i + 1 < trimmedValue.length) {
-				// Skip the entire escape sequence
-				var escapeLen = getEscapeSequenceLength(trimmedValue, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			// Check if this is an unescaped special character
-			if (specialCharsNeedEscapeRegExp.test(char)) {
-				hasUnescapedSpecialChar = true;
-				break;
-			}
-		}
-		
-		if (hasUnescapedSpecialChar) {
-			return null; // Unescaped special characters not allowed in unquoted attribute values
-		}
-		
-		// Decode escape sequences in the value before quoting
-		// Inside quotes, special characters don't need escaping
-		var decodedValue = decodeEscapeSequencesInString(trimmedValue);
-		
-		// If the decoded value contains double quotes, escape them for the output
-		// (since we're using double quotes as delimiters)
-		var escapedValue = decodedValue.replace(backslashRegExp, '\\\\').replace(doubleQuoteRegExp, '\\"');
-		
-		// Unquoted value - add double quotes with decoded and re-escaped content
-		return attrName + operator + '"' + escapedValue + '"' + (flag ? ' ' + flag : '');
-	}
-
-	/**
-	 * Processes a CSS selector text 
-	 * 
-	 * @param {string} selectorText - The CSS selector text to process
-	 * @returns {string} The processed selector text with normalized whitespace and invalid selectors removed
-	 */
-	function processSelectorText(selectorText) {
-		// Normalize whitespace first
-		var normalized = selectorText.replace(whitespaceNormalizationRegExp, function (match, _, newline) {
-			if (newline) return " ";
-			return match;
-		});
-
-		// Normalize escape sequences to match browser behavior
-		normalized = normalizeSelectorEscapes(normalized);
-
-		// Normalize attribute selectors (add quotes to unquoted values)
-		// Returns null if invalid (e.g., unclosed quotes)
-		normalized = normalizeAttributeSelectors(normalized);
-		if (normalized === null) {
-			return ''; // Invalid selector - return empty to trigger validation failure
-		}
-
-		// Recursively process pseudo-classes to handle nesting
-		return processNestedPseudoClasses(normalized);
-	}
-
-	/**
-	 * Recursively processes pseudo-classes to filter invalid selectors
-	 * 
-	 * @param {string} selectorText - The CSS selector text to process
-	 * @param {number} depth - Current recursion depth (to prevent infinite loops)
-	 * @returns {string} The processed selector text with invalid selectors removed
-	 */
-	function processNestedPseudoClasses(selectorText, depth) {
-		// Prevent infinite recursion
-		if (typeof depth === 'undefined') {
-			depth = 0;
-		}
-		if (depth > 10) {
-			return selectorText;
-		}
-
-		var pseudoClassMatches = extractPseudoClasses(selectorText);
-
-		// If no pseudo-classes found, return as-is
-		if (pseudoClassMatches.length === 0) {
-			return selectorText;
-		}
-
-		// Build result by processing matches from right to left (to preserve positions)
-		var result = selectorText;
-
-		for (var j = pseudoClassMatches.length - 1; j >= 0; j--) {
-			var pseudoClass = pseudoClassMatches[j][1];
-			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				var fullMatch = pseudoClassMatches[j][0];
-				var pseudoArgs = pseudoClassMatches[j][2];
-				var matchStart = pseudoClassMatches[j][3];
-
-				// Check if ANY selector contains & BEFORE processing
-				var nestedSelectorsRaw = parseAndSplitNestedSelectors(pseudoArgs);
-				var hasAmpersand = false;
-				for (var k = 0; k < nestedSelectorsRaw.length; k++) {
-					if (ampersandRegExp.test(nestedSelectorsRaw[k])) {
-						hasAmpersand = true;
-						break;
-					}
-				}
-
-				// If & is present, skip all processing (keep everything unchanged)
-				if (hasAmpersand) {
-					continue;
-				}
-
-				// Recursively process the arguments
-				var processedArgs = processNestedPseudoClasses(pseudoArgs, depth + 1);
-				var nestedSelectors = parseAndSplitNestedSelectors(processedArgs);
-
-				// Filter out invalid selectors
-				var validSelectors = [];
-				for (var i = 0; i < nestedSelectors.length; i++) {
-					var nestedSelector = nestedSelectors[i];
-					if (basicSelectorValidator(nestedSelector)) {
-						validSelectors.push(nestedSelector);
-					}
-				}
-
-				// Reconstruct the pseudo-class with only valid selectors
-				var newArgs = validSelectors.join(', ');
-				var newPseudoClass = ':' + pseudoClass + '(' + newArgs + ')';
-
-				// Replace in the result string using position (processing right to left preserves positions)
-				result = result.substring(0, matchStart) + newPseudoClass + result.substring(matchStart + fullMatch.length);
-			}
-		}
-
-		return result;
-
-		return normalized;
-	}
-
-	/**
-	 * Checks if a selector contains newlines inside quoted strings.
-	 * Uses iterative parsing to avoid regex backtracking issues.
-	 * @param {string} selectorText - The selector to check
-	 * @returns {boolean} True if newlines found inside quotes
-	 */
-	function hasNewlineInQuotedString(selectorText) {
-		for (var i = 0; i < selectorText.length; i++) {
-			var char = selectorText[i];
-			
-			// Start of single-quoted string
-			if (char === "'") {
-				i++;
-				while (i < selectorText.length) {
-					if (selectorText[i] === '\\' && i + 1 < selectorText.length) {
-						// Skip escape sequence
-						i += 2;
-						continue;
-					}
-					if (selectorText[i] === "'") {
-						// End of string
-						break;
-					}
-					if (selectorText[i] === '\r' || selectorText[i] === '\n') {
-						return true;
-					}
-					i++;
-				}
-			}
-			// Start of double-quoted string
-			else if (char === '"') {
-				i++;
-				while (i < selectorText.length) {
-					if (selectorText[i] === '\\' && i + 1 < selectorText.length) {
-						// Skip escape sequence
-						i += 2;
-						continue;
-					}
-					if (selectorText[i] === '"') {
-						// End of string
-						break;
-					}
-					if (selectorText[i] === '\r' || selectorText[i] === '\n') {
-						return true;
-					}
-					i++;
-				}
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Checks if a given CSS selector text is valid by splitting it by commas
-	 * and validating each individual selector using the `validateSelector` function.
-	 *
-	 * @param {string} selectorText - The CSS selector text to validate. Can contain multiple selectors separated by commas.
-	 * @returns {boolean} Returns true if all selectors are valid, otherwise false.
-	 */
-	function isValidSelectorText(selectorText) {
-		// TODO: The same validations here needs to be reused in CSSStyleRule.selectorText setter
-		// TODO: Move these validation logic to a shared function to be reused in CSSStyleRule.selectorText setter
-
-		// Check for empty or whitespace-only selector
-		if (!selectorText || selectorText.trim() === '') {
-			return false;
-		}
-
-		// Check for empty selector lists in pseudo-classes (e.g., :is(), :not(), :where(), :has())
-		// These are invalid after filtering out invalid selectors
-		if (emptyPseudoClassRegExp.test(selectorText)) {
-			return false;
-		}
-
-		// Check for newlines inside single or double quotes
-		// Uses helper function to avoid regex security issues
-		if (hasNewlineInQuotedString(selectorText)) {
-			return false;
-		}
-
-		// Split selectorText by commas and validate each part
-		var selectors = parseAndSplitNestedSelectors(selectorText);
-		for (var i = 0; i < selectors.length; i++) {
-			var selector = selectors[i].trim();
-			if (!validateSelector(selector) || !validateNamespaceSelector(selector)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	function pushToAncestorRules(rule) {
-		ancestorRules.push(rule);
-	}
-
-	function parseError(message, isNested) {
-		var lines = token.substring(0, i).split('\n');
-		var lineCount = lines.length;
-		var charCount = lines.pop().length + 1;
-		var error = new Error(message + ' (line ' + lineCount + ', char ' + charCount + ')');
-		error.line = lineCount;
-		/* jshint sub : true */
-		error['char'] = charCount;
-		error.styleSheet = styleSheet;
-		error.isNested = !!isNested;
-		// Print the error but continue parsing the sheet
-		try {
-			throw error;
-		} catch (e) {
-			errorHandler && errorHandler(e);
-		}
-	};
-
-	/**
-	 * Handles invalid selectors with unmatched quotes by skipping the entire rule block.
-	 * @param {string} nextState - The parser state to transition to after skipping
-	 */
-	function handleUnmatchedQuoteInSelector(nextState) {
-		// parseError('Invalid selector with unmatched quote: ' + buffer.trim());
-		// Skip this entire invalid rule including its block
-		var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-		if (ruleClosingMatch) {
-			i += ruleClosingMatch.index + ruleClosingMatch[0].length - 1;
-		}
-		styleRule = null;
-		buffer = "";
-		hasUnmatchedQuoteInSelector = false; // Reset flag
-		state = nextState;
-	}
-
-	// Helper functions to check character types
-	function isSelectorStartChar(char) {
-		return '.:#&*['.indexOf(char) !== -1;
-	}
-
-	function isWhitespaceChar(char) {
-		return ' \t\n\r'.indexOf(char) !== -1;
-	}
-
-	// Helper functions for character type checking (faster than regex for single chars)
-	function isDigit(char) {
-		var code = char.charCodeAt(0);
-		return code >= 0x0030 && code <= 0x0039; // 0-9
-	}
-
-	function isHexDigit(char) {
-		if (!char) return false;
-		var code = char.charCodeAt(0);
-		return (code >= 0x0030 && code <= 0x0039) || // 0-9
-		       (code >= 0x0041 && code <= 0x0046) || // A-F
-		       (code >= 0x0061 && code <= 0x0066);   // a-f
-	}
-
-	function isLetter(char) {
-		if (!char) return false;
-		var code = char.charCodeAt(0);
-		return (code >= 0x0041 && code <= 0x005A) || // A-Z
-		       (code >= 0x0061 && code <= 0x007A);   // a-z
-	}
-
-	function isAlphanumeric(char) {
-		var code = char.charCodeAt(0);
-		return (code >= 0x0030 && code <= 0x0039) || // 0-9
-		       (code >= 0x0041 && code <= 0x005A) || // A-Z
-		       (code >= 0x0061 && code <= 0x007A);   // a-z
-	}
-
-	/**
-	 * Get the length of an escape sequence starting at the given position.
-	 * CSS escape sequences are:
-	 * - Backslash followed by 1-6 hex digits, optionally followed by a whitespace (consumed)
-	 * - Backslash followed by any non-hex character
-	 * @param {string} str - The string to check
-	 * @param {number} pos - Position of the backslash
-	 * @returns {number} Number of characters in the escape sequence (including backslash)
-	 */
-	function getEscapeSequenceLength(str, pos) {
-		if (str[pos] !== '\\' || pos + 1 >= str.length) {
-			return 0;
-		}
-		
-		var nextChar = str[pos + 1];
-		
-		// Check if it's a hex escape
-		if (isHexDigit(nextChar)) {
-			var hexLength = 1;
-			// Count up to 6 hex digits
-			while (hexLength < 6 && pos + 1 + hexLength < str.length && isHexDigit(str[pos + 1 + hexLength])) {
-				hexLength++;
-			}
-			// Check if followed by optional whitespace (which gets consumed)
-			if (pos + 1 + hexLength < str.length && isWhitespaceChar(str[pos + 1 + hexLength])) {
-				return 1 + hexLength + 1; // backslash + hex digits + whitespace
-			}
-			return 1 + hexLength; // backslash + hex digits
-		}
-		
-		// Simple escape: backslash + any character
-		return 2;
-	}
-
-	/**
-	 * Check if a string contains an unescaped occurrence of a specific character
-	 * @param {string} str - The string to search
-	 * @param {string} char - The character to look for
-	 * @returns {boolean} True if the character appears unescaped
-	 */
-	function containsUnescaped(str, char) {
-		for (var i = 0; i < str.length; i++) {
-			if (str[i] === '\\') {
-				var escapeLen = getEscapeSequenceLength(str, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			if (str[i] === char) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	var endingIndex = token.length - 1;
-	var initialEndingIndex = endingIndex;
-
-	for (var character; (character = token.charAt(i)); i++) {
-		if (i === endingIndex) {
-			switch (state) {
-				case "importRule":
-				case "namespaceRule":
-				case "layerBlock":
-					if (character !== ";") {
-						token += ";";
-						endingIndex += 1;
-					}
-					break;
-				case "value":
-					if (character !== "}") {
-						if (character === ";") {
-							token += "}"
-						} else {
-							token += ";";
-						}
-						endingIndex += 1;
-						break;
-					}
-				case "name":
-				case "before-name":
-					if (character === "}") {
-						token += " "
-					} else {
-						token += "}"
-					}
-					endingIndex += 1
-					break;
-				case "before-selector":
-					if (character !== "}" && currentScope !== styleSheet) {
-						token += "}"
-						endingIndex += 1
-						break;
-					}
-			}
-		}
-
-		// Handle escape sequences before processing special characters
-		// CSS escape sequences: \HHHHHH (1-6 hex digits) optionally followed by whitespace, or \ + any char
-		if (character === '\\' && i + 1 < token.length) {
-			var escapeLen = getEscapeSequenceLength(token, i);
-			if (escapeLen > 0) {
-				buffer += token.substr(i, escapeLen);
-				i += escapeLen - 1; // -1 because loop will increment
-				continue;
-			}
-		}
-
-		switch (character) {
-
-			case " ":
-			case "\t":
-			case "\r":
-			case "\n":
-			case "\f":
-				if (SIGNIFICANT_WHITESPACE[state]) {
-					buffer += character;
-				}
-				break;
-
-			// String
-			case '"':
-				index = i + 1;
-				do {
-					index = token.indexOf('"', index) + 1;
-					if (!index) {
-						parseError('Unmatched "');
-						// If we're parsing a selector, flag it as invalid
-						if (state === "selector" || state === "atRule") {
-							hasUnmatchedQuoteInSelector = true;
-						}
-					}
-				} while (token[index - 2] === '\\');
-				if (index === 0) {
-					break;
-				}
-				buffer += token.slice(i, index);
-				i = index - 1;
-				switch (state) {
-					case 'before-value':
-						state = 'value';
-						break;
-					case 'importRule-begin':
-						state = 'importRule';
-						if (i === endingIndex) {
-							token += ';'
-						}
-						break;
-					case 'namespaceRule-begin':
-						state = 'namespaceRule';
-						if (i === endingIndex) {
-							token += ';'
-						}
-						break;
-				}
-				break;
-
-			case "'":
-				index = i + 1;
-				do {
-					index = token.indexOf("'", index) + 1;
-					if (!index) {
-						parseError("Unmatched '");
-						// If we're parsing a selector, flag it as invalid
-						if (state === "selector" || state === "atRule") {
-							hasUnmatchedQuoteInSelector = true;
-						}
-					}
-				} while (token[index - 2] === '\\');
-				if (index === 0) {
-					break;
-				}
-				buffer += token.slice(i, index);
-				i = index - 1;
-				switch (state) {
-					case 'before-value':
-						state = 'value';
-						break;
-					case 'importRule-begin':
-						state = 'importRule';
-						break;
-					case 'namespaceRule-begin':
-						state = 'namespaceRule';
-						break;
-				}
-				break;
-
-			// Comment
-			case "/":
-				if (token.charAt(i + 1) === "*") {
-					i += 2;
-					index = token.indexOf("*/", i);
-					if (index === -1) {
-						i = token.length - 1;
-						buffer = "";
-					} else {
-						i = index + 1;
-					}
-				} else {
-					buffer += character;
-				}
-				if (state === "importRule-begin") {
-					buffer += " ";
-					state = "importRule";
-				}
-				if (state === "namespaceRule-begin") {
-					buffer += " ";
-					state = "namespaceRule";
-				}
-				break;
-
-			// At-rule
-			case "@":
-				if (nestedSelectorRule) {
-					if (styleRule && styleRule.constructor.name === "CSSNestedDeclarations") {
-						currentScope.cssRules.push(styleRule);
-					}
-					// Only reset styleRule to parent if styleRule is not the nestedSelectorRule itself
-					// This preserves nested selectors when followed immediately by @-rules
-					if (styleRule !== nestedSelectorRule && nestedSelectorRule.parentRule && nestedSelectorRule.parentRule.constructor.name === "CSSStyleRule") {
-						styleRule = nestedSelectorRule.parentRule;
-					}
-					// Don't reset nestedSelectorRule here - preserve it through @-rules
-				}
-				if (token.indexOf("@-moz-document", i) === i) {
-					validateAtRule("@-moz-document", function () {
-						state = "documentRule-begin";
-						documentRule = new CSSOM.CSSDocumentRule();
-						documentRule.__starts = i;
-						i += "-moz-document".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@media", i) === i) {
-					validateAtRule("@media", function () {
-						state = "atBlock";
-						mediaRule = new CSSOM.CSSMediaRule();
-						mediaRule.__starts = i;
-						i += "media".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@container", i) === i) {
-					validateAtRule("@container", function () {
-						state = "containerBlock";
-						containerRule = new CSSOM.CSSContainerRule();
-						containerRule.__starts = i;
-						i += "container".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@counter-style", i) === i) {
-					buffer = "";
-					// @counter-style can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@counter-style", function () {
-						state = "counterStyleBlock"
-						counterStyleRule = new CSSOM.CSSCounterStyleRule();
-						counterStyleRule.__starts = i;
-						i += "counter-style".length;
-					}, cannotBeNested);
-					break;
-				} else if (token.indexOf("@property", i) === i) {
-					buffer = "";
-					// @property can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@property", function () {
-						state = "propertyBlock"
-						propertyRule = new CSSOM.CSSPropertyRule();
-						propertyRule.__starts = i;
-						i += "property".length;
-					}, cannotBeNested);
-					break;
-				} else if (token.indexOf("@scope", i) === i) {
-					validateAtRule("@scope", function () {
-						state = "scopeBlock";
-						scopeRule = new CSSOM.CSSScopeRule();
-						scopeRule.__starts = i;
-						i += "scope".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@layer", i) === i) {
-					validateAtRule("@layer", function () {
-						state = "layerBlock"
-						layerBlockRule = new CSSOM.CSSLayerBlockRule();
-						layerBlockRule.__starts = i;
-						i += "layer".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@page", i) === i) {
-					validateAtRule("@page", function () {
-						state = "pageBlock"
-						pageRule = new CSSOM.CSSPageRule();
-						pageRule.__starts = i;
-						i += "page".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@supports", i) === i) {
-					validateAtRule("@supports", function () {
-						state = "conditionBlock";
-						supportsRule = new CSSOM.CSSSupportsRule();
-						supportsRule.__starts = i;
-						i += "supports".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@host", i) === i) {
-					validateAtRule("@host", function () {
-						state = "hostRule-begin";
-						i += "host".length;
-						hostRule = new CSSOM.CSSHostRule();
-						hostRule.__starts = i;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@starting-style", i) === i) {
-					validateAtRule("@starting-style", function () {
-						state = "startingStyleRule-begin";
-						i += "starting-style".length;
-						startingStyleRule = new CSSOM.CSSStartingStyleRule();
-						startingStyleRule.__starts = i;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@import", i) === i) {
-					buffer = "";
-					validateAtRule("@import", function () {
-						state = "importRule-begin";
-						i += "import".length;
-						buffer += "@import";
-					}, true);
-					break;
-				} else if (token.indexOf("@namespace", i) === i) {
-					buffer = "";
-					validateAtRule("@namespace", function () {
-						state = "namespaceRule-begin";
-						i += "namespace".length;
-						buffer += "@namespace";
-					}, true);
-					break;
-				} else if (token.indexOf("@font-face", i) === i) {
-					buffer = "";
-					// @font-face can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@font-face", function () {
-						state = "fontFaceRule-begin";
-						i += "font-face".length;
-						fontFaceRule = new CSSOM.CSSFontFaceRule();
-						fontFaceRule.__starts = i;
-					}, cannotBeNested);
-					break;
-				} else {
-					// Reset lastIndex before using global regex (shared instance)
-					atKeyframesRegExp.lastIndex = i;
-					var matchKeyframes = atKeyframesRegExp.exec(token);
-					if (matchKeyframes && matchKeyframes.index === i) {
-						state = "keyframesRule-begin";
-						keyframesRule = new CSSOM.CSSKeyframesRule();
-						keyframesRule.__starts = i;
-						keyframesRule._vendorPrefix = matchKeyframes[1]; // Will come out as undefined if no prefix was found
-						i += matchKeyframes[0].length - 1;
-						buffer = "";
-						break;
-					} else if (state === "selector") {
-						state = "atRule";
-					}
-				}
-				buffer += character;
-				break;
-
-			case "{":
-				if (currentScope === topScope) {
-					nestedSelectorRule = null;
-				}
-				if (state === 'before-selector') {
-					parseError("Unexpected {");
-					i = ignoreBalancedBlock(i, token.slice(i));
-					break;
-				}
-				if (state === "selector" || state === "atRule") {
-					if (!nestedSelectorRule && containsUnescaped(buffer, ";")) {
-						var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-						if (ruleClosingMatch) {
-							styleRule = null;
-							buffer = "";
-							state = "before-selector";
-							i += ruleClosingMatch.index + ruleClosingMatch[0].length;
-							break;
-						}
-					}
-
-					// Ensure styleRule exists before trying to set properties on it
-					if (!styleRule) {
-						styleRule = new CSSOM.CSSStyleRule();
-						styleRule.__starts = i;
-					}
-
-					// Check if tokenizer detected an unmatched quote BEFORE setting up the rule
-					if (hasUnmatchedQuoteInSelector) {
-						handleUnmatchedQuoteInSelector("before-selector");
-						break;
-					}
-
-					var originalParentRule = parentRule;
-
-					if (parentRule) {
-						styleRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = styleRule;
-					
-					var processedSelectorText = processSelectorText(buffer.trim());
-					// In a nested selector, ensure each selector contains '&' at the beginning, except for selectors that already have '&' somewhere
-					if (originalParentRule && originalParentRule.constructor.name === "CSSStyleRule") {
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).map(function (sel) {
-							// Add & at the beginning if there's no & in the selector, or if it starts with a combinator
-							return (sel.indexOf('&') === -1 || startsWithCombinatorRegExp.test(sel)) ? '& ' + sel : sel;
-						}).join(', ');
-					} else {
-						// Normalize comma spacing: split by commas and rejoin with ", "
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).join(', ');
-					}
-					styleRule.style.__starts = i;
-					styleRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "atBlock") {
-					mediaRule.media.mediaText = buffer.trim();
-
-					if (parentRule) {
-						mediaRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						// If entering @media from within a CSSStyleRule, set nestedSelectorRule
-						// so that & selectors and declarations work correctly inside
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = mediaRule;
-					pushToAncestorRules(mediaRule);
-					mediaRule.__parentStyleSheet = styleSheet;
-					
-					// Don't reset styleRule to null if it's a nested CSSStyleRule that will contain this @-rule
-					if (!styleRule || styleRule.constructor.name !== "CSSStyleRule" || !styleRule.__parentRule) {
-						styleRule = null; // Reset styleRule when entering @-rule
-					}
-					
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "containerBlock") {
-					containerRule.__conditionText = buffer.trim();
-
-					if (parentRule) {
-						containerRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-					currentScope = parentRule = containerRule;
-					pushToAncestorRules(containerRule);
-					containerRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "counterStyleBlock") {
-					var counterStyleName = buffer.trim().replace(newlineRemovalRegExp, "");
-					// Validate: name cannot be empty, contain whitespace, or contain dots
-					var isValidCounterStyleName = counterStyleName.length > 0 && !whitespaceAndDotRegExp.test(counterStyleName);
-
-					if (isValidCounterStyleName) {
-						counterStyleRule.name = counterStyleName;
-						if (parentRule) {
-							counterStyleRule.__parentRule = parentRule;
-						}
-						counterStyleRule.__parentStyleSheet = styleSheet;
-						styleRule = counterStyleRule;
-					}
-					buffer = "";
-				} else if (state === "propertyBlock") {
-					var propertyName = buffer.trim().replace(newlineRemovalRegExp, "");
-					// Validate: name must start with -- (custom property)
-					var isValidPropertyName = propertyName.indexOf("--") === 0;
-
-					if (isValidPropertyName) {
-						propertyRule.__name = propertyName;
-						if (parentRule) {
-							propertyRule.__parentRule = parentRule;
-						}
-						propertyRule.__parentStyleSheet = styleSheet;
-						styleRule = propertyRule;
-					}
-					buffer = "";
-				} else if (state === "conditionBlock") {
-					supportsRule.__conditionText = buffer.trim();
-
-					if (parentRule) {
-						supportsRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = supportsRule;
-					pushToAncestorRules(supportsRule);
-					supportsRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "scopeBlock") {
-					var parsedScopePrelude = parseScopePrelude(buffer.trim());
-
-					if (parsedScopePrelude.hasStart) {
-						scopeRule.__start = parsedScopePrelude.startSelector;
-					}
-					if (parsedScopePrelude.hasEnd) {
-						scopeRule.__end = parsedScopePrelude.endSelector;
-					}
-					if (parsedScopePrelude.hasOnlyEnd) {
-						scopeRule.__end = parsedScopePrelude.endSelector;
-					}
-
-					if (parentRule) {
-						scopeRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-					currentScope = parentRule = scopeRule;
-					pushToAncestorRules(scopeRule);
-					scopeRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "layerBlock") {
-					layerBlockRule.name = buffer.trim();
-
-					var isValidName = layerBlockRule.name.length === 0 || layerBlockRule.name.match(cssCustomIdentifierRegExp) !== null;
-
-					if (isValidName) {
-						if (parentRule) {
-							layerBlockRule.__parentRule = parentRule;
-							pushToAncestorRules(parentRule);
-							if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-								nestedSelectorRule = parentRule;
-							}
-						}
-
-						currentScope = parentRule = layerBlockRule;
-						pushToAncestorRules(layerBlockRule);
-						layerBlockRule.__parentStyleSheet = styleSheet;
-					}
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "pageBlock") {
-					pageRule.selectorText = buffer.trim();
-
-					if (parentRule) {
-						pageRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = pageRule;
-					pageRule.__parentStyleSheet = styleSheet;
-					styleRule = pageRule;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "hostRule-begin") {
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = hostRule;
-					pushToAncestorRules(hostRule);
-					hostRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "startingStyleRule-begin") {
-					if (parentRule) {
-						startingStyleRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = startingStyleRule;
-					pushToAncestorRules(startingStyleRule);
-					startingStyleRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-
-				} else if (state === "fontFaceRule-begin") {
-					if (parentRule) {
-						fontFaceRule.__parentRule = parentRule;
-					}
-					fontFaceRule.__parentStyleSheet = styleSheet;
-					styleRule = fontFaceRule;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "keyframesRule-begin") {
-					keyframesRule.name = buffer.trim();
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-						keyframesRule.__parentRule = parentRule;
-					}
-					keyframesRule.__parentStyleSheet = styleSheet;
-					currentScope = parentRule = keyframesRule;
-					buffer = "";
-					state = "keyframeRule-begin";
-				} else if (state === "keyframeRule-begin") {
-					styleRule = new CSSOM.CSSKeyframeRule();
-					styleRule.keyText = buffer.trim();
-					styleRule.__starts = i;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "documentRule-begin") {
-					// FIXME: what if this '{' is in the url text of the match function?
-					documentRule.matcher.matcherText = buffer.trim();
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-						documentRule.__parentRule = parentRule;
-					}
-					currentScope = parentRule = documentRule;
-					pushToAncestorRules(documentRule);
-					documentRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "before-name" || state === "name") {
-					// @font-face and similar rules don't support nested selectors
-					// If we encounter a nested selector block inside them, skip it
-					if (styleRule.constructor.name === "CSSFontFaceRule" ||
-						styleRule.constructor.name === "CSSKeyframeRule" ||
-						(styleRule.constructor.name === "CSSPageRule" && parentRule === styleRule)) {
-						// Skip the nested block
-						var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-						if (ruleClosingMatch) {
-							i += ruleClosingMatch.index + ruleClosingMatch[0].length - 1;
-							buffer = "";
-							state = "before-name";
-							break;
-						}
-					}
-
-					if (styleRule.constructor.name === "CSSNestedDeclarations") {
-						if (styleRule.style.length) {
-							parentRule.cssRules.push(styleRule);
-							styleRule.__parentRule = parentRule;
-							styleRule.__parentStyleSheet = styleSheet;
-							pushToAncestorRules(parentRule);
-						} else {
-							// If the styleRule is empty, we can assume that it's a nested selector
-							pushToAncestorRules(parentRule);
-						}
-					} else {
-						currentScope = parentRule = styleRule;
-						pushToAncestorRules(parentRule);
-						styleRule.__parentStyleSheet = styleSheet;
-					}
-
-					styleRule = new CSSOM.CSSStyleRule();
-					
-					// Check if tokenizer detected an unmatched quote BEFORE setting up the rule
-					if (hasUnmatchedQuoteInSelector) {
-						handleUnmatchedQuoteInSelector("before-name");
-						break;
-					}
-					
-					var processedSelectorText = processSelectorText(buffer.trim());
-					// In a nested selector, ensure each selector contains '&' at the beginning, except for selectors that already have '&' somewhere
-					if (parentRule.constructor.name === "CSSScopeRule" || (parentRule.constructor.name !== "CSSStyleRule" && parentRule.parentRule === null)) {
-						// Normalize comma spacing: split by commas and rejoin with ", "
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).join(', ');
-					} else {
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).map(function (sel) {
-							// Add & at the beginning if there's no & in the selector, or if it starts with a combinator
-							return (sel.indexOf('&') === -1 || startsWithCombinatorRegExp.test(sel)) ? '& ' + sel : sel;
-						}).join(', ');
-					}
-					styleRule.style.__starts = i - buffer.length;
-					styleRule.__parentRule = parentRule;
-					// Only set nestedSelectorRule if we're directly inside a CSSStyleRule or CSSScopeRule,
-					// not inside other grouping rules like @media/@supports
-					if (parentRule.constructor.name === "CSSStyleRule" || parentRule.constructor.name === "CSSScopeRule") {
-						nestedSelectorRule = styleRule;
-					}
-					
-					// Set __parentStyleSheet for the new nested styleRule
-					styleRule.__parentStyleSheet = styleSheet;
-					
-					// Update currentScope and parentRule to the new nested styleRule
-					// so that subsequent content (like @-rules) will be children of this rule
-					currentScope = parentRule = styleRule;
-
-					buffer = "";
-					state = "before-name";
-				}
-				break;
-
-			case ":":
-				if (state === "name") {
-					// It can be a nested selector, let's check
-					var openBraceBeforeMatch = token.slice(i).match(declarationOrOpenBraceRegExp);
-					var hasOpenBraceBefore = openBraceBeforeMatch && openBraceBeforeMatch[0] === '{';
-					if (hasOpenBraceBefore) {
-						// Is a selector
-						buffer += character;
-					} else {
-						// Is a declaration
-						name = buffer.trim();
-						buffer = "";
-						state = "before-value";
-					}
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case "(":
-				if (state === 'value') {
-					// ie css expression mode
-					if (buffer.trim() === 'expression') {
-						var info = (new CSSOM.CSSValueExpression(token, i)).parse();
-
-						if (info.error) {
-							parseError(info.error);
-						} else {
-							buffer += info.expression;
-							i = info.idx;
-						}
-					} else {
-						state = 'value-parenthesis';
-						//always ensure this is reset to 1 on transition
-						//from value to value-parenthesis
-						valueParenthesisDepth = 1;
-						buffer += character;
-					}
-				} else if (state === 'value-parenthesis') {
-					valueParenthesisDepth++;
-					buffer += character;
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case ")":
-				if (state === 'value-parenthesis') {
-					valueParenthesisDepth--;
-					if (valueParenthesisDepth === 0) state = 'value';
-				}
-				buffer += character;
-				break;
-
-			case "!":
-				if (state === "value" && token.indexOf("!important", i) === i) {
-					priority = "important";
-					i += "important".length;
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case ";":
-				switch (state) {
-					case "before-value":
-					case "before-name":
-						parseError("Unexpected ;");
-						buffer = "";
-						state = "before-name";
-						break;
-					case "value":
-						styleRule.style.setProperty(name, buffer.trim(), priority, parseError);
-						priority = "";
-						buffer = "";
-						state = "before-name";
-						break;
-					case "atRule":
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "importRule":
-						var isValid = topScope.cssRules.length === 0 || topScope.cssRules.some(function (rule) {
-							return ['CSSImportRule', 'CSSLayerStatementRule'].indexOf(rule.constructor.name) !== -1
-						});
-						if (isValid) {
-							importRule = new CSSOM.CSSImportRule();
-							if (opts && opts.globalObject && opts.globalObject.CSSStyleSheet) {
-								importRule.__styleSheet = new opts.globalObject.CSSStyleSheet();
-							}
-							importRule.styleSheet.__constructed = false;
-							importRule.__parentStyleSheet = importRule.styleSheet.__parentStyleSheet = styleSheet;
-							importRule.parse(buffer + character);
-							topScope.cssRules.push(importRule);
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "namespaceRule":
-						var isValid = topScope.cssRules.length === 0 || topScope.cssRules.every(function (rule) {
-							return ['CSSImportRule', 'CSSLayerStatementRule', 'CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
-						});
-						if (isValid) {
-							try {
-								// Validate namespace syntax before creating the rule
-								var testNamespaceRule = new CSSOM.CSSNamespaceRule();
-								testNamespaceRule.parse(buffer + character);
-
-								namespaceRule = testNamespaceRule;
-								namespaceRule.__parentStyleSheet = styleSheet;
-								topScope.cssRules.push(namespaceRule);
-
-								// Track the namespace prefix for validation
-								if (namespaceRule.prefix) {
-									definedNamespacePrefixes[namespaceRule.prefix] = namespaceRule.namespaceURI;
-								}
-							} catch (e) {
-								parseError(e.message);
-							}
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "layerBlock":
-						var nameListStr = buffer.trim().split(",").map(function (name) {
-							return name.trim();
-						});
-						var isInvalid = nameListStr.some(function (name) {
-							return name.trim().match(cssCustomIdentifierRegExp) === null;
-						});
-
-						// Check if there's a CSSStyleRule in the parent chain
-						var hasStyleRuleParent = false;
-						if (parentRule) {
-							var checkParent = parentRule;
-							while (checkParent) {
-								if (checkParent.constructor.name === "CSSStyleRule") {
-									hasStyleRuleParent = true;
-									break;
-								}
-								checkParent = checkParent.__parentRule;
-							}
-						}
-
-						if (!isInvalid && !hasStyleRuleParent) {
-							layerStatementRule = new CSSOM.CSSLayerStatementRule();
-							layerStatementRule.__parentStyleSheet = styleSheet;
-							layerStatementRule.__starts = layerBlockRule.__starts;
-							layerStatementRule.__ends = i;
-							layerStatementRule.nameList = nameListStr;
-
-							// Add to parent rule if nested, otherwise to top scope
-							if (parentRule) {
-								layerStatementRule.__parentRule = parentRule;
-								parentRule.cssRules.push(layerStatementRule);
-							} else {
-								topScope.cssRules.push(layerStatementRule);
-							}
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					default:
-						buffer += character;
-						break;
-				}
-				break;
-
-			case "}":
-				if (state === "counterStyleBlock") {
-					// FIXME : Implement missing properties on CSSCounterStyleRule interface and update parse method
-					// For now it's just assigning entire rule text
-					if (counterStyleRule.name) {
-						// Only process if name was set (valid)
-						counterStyleRule.parse("@counter-style " + counterStyleRule.name + " { " + buffer + " }");
-						counterStyleRule.__ends = i + 1;
-						// Add to parent's cssRules
-						if (counterStyleRule.__parentRule) {
-							counterStyleRule.__parentRule.cssRules.push(counterStyleRule);
-						} else {
-							topScope.cssRules.push(counterStyleRule);
-						}
-					}
-					// Restore currentScope to parent after closing this rule
-					if (counterStyleRule.__parentRule) {
-						currentScope = counterStyleRule.__parentRule;
-					}
-					styleRule = null;
-					buffer = "";
-					state = "before-selector";
-					break;
-				}
-				if (state === "propertyBlock") {
-					// Only process if name was set (valid)
-					if (propertyRule.__name) {
-						var parseSuccess = propertyRule.parse("@property " + propertyRule.__name + " { " + buffer + " }");
-						// Only add the rule if parse was successful (syntax, inherits, and initial-value validation passed)
-						if (parseSuccess) {
-							propertyRule.__ends = i + 1;
-							// Add to parent's cssRules
-							if (propertyRule.__parentRule) {
-								propertyRule.__parentRule.cssRules.push(propertyRule);
-							} else {
-								topScope.cssRules.push(propertyRule);
-							}
-						}
-					}
-					// Restore currentScope to parent after closing this rule
-					if (propertyRule.__parentRule) {
-						currentScope = propertyRule.__parentRule;
-					}
-					styleRule = null;
-					buffer = "";
-					state = "before-selector";
-					break;
-				}
-				switch (state) {
-					case "value":
-						styleRule.style.setProperty(name, buffer.trim(), priority, parseError);
-						priority = "";
-					/* falls through */
-					case "before-value":
-					case "before-name":
-					case "name":
-						styleRule.__ends = i + 1;
-
-						if (parentRule === styleRule) {
-							parentRule = ancestorRules.pop()
-						}
-
-						if (parentRule) {
-							styleRule.__parentRule = parentRule;
-						}
-						styleRule.__parentStyleSheet = styleSheet;
-
-						if (currentScope === styleRule) {
-							currentScope = parentRule || topScope;
-						}
-
-						if (styleRule.constructor.name === "CSSStyleRule" && !isValidSelectorText(styleRule.selectorText)) {
-							if (styleRule === nestedSelectorRule) {
-								nestedSelectorRule = null;
-							}
-							parseError('Invalid CSSStyleRule (selectorText = "' + styleRule.selectorText + '")', styleRule.parentRule !== null);
-						} else {
-							if (styleRule.parentRule) {
-								styleRule.parentRule.cssRules.push(styleRule);
-							} else {
-								currentScope.cssRules.push(styleRule);
-							}
-						}
-						buffer = "";
-						if (currentScope.constructor === CSSOM.CSSKeyframesRule) {
-							state = "keyframeRule-begin";
-						} else {
-							state = "before-selector";
-						}
-
-						if (styleRule.constructor.name === "CSSNestedDeclarations") {
-							if (currentScope !== topScope) {
-								// Only set nestedSelectorRule if currentScope is CSSStyleRule or CSSScopeRule
-								// Not for other grouping rules like @media/@supports
-								if (currentScope.constructor.name === "CSSStyleRule" || currentScope.constructor.name === "CSSScopeRule") {
-									nestedSelectorRule = currentScope;
-								}
-							}
-							styleRule = null;
-						} else {
-							// Update nestedSelectorRule when closing a CSSStyleRule
-							if (styleRule === nestedSelectorRule) {
-								var selector = styleRule.selectorText && styleRule.selectorText.trim();
-								// Check if this is proper nesting (&.class, &:pseudo) vs prepended & (& :is, & .class with space)
-								// Prepended & has pattern "& X" where X starts with : or .
-								var isPrependedAmpersand = selector && selector.match(prependedAmpersandRegExp);
-
-								// Check if parent is a grouping rule that can contain nested selectors
-								var isGroupingRule = currentScope && currentScope instanceof CSSOM.CSSGroupingRule;
-
-								if (!isPrependedAmpersand && isGroupingRule) {
-									// Proper nesting - set nestedSelectorRule to parent for more nested selectors
-									// But only if it's a CSSStyleRule or CSSScopeRule, not other grouping rules like @media
-									if (currentScope.constructor.name === "CSSStyleRule" || currentScope.constructor.name === "CSSScopeRule") {
-										nestedSelectorRule = currentScope;
-									}
-									// If currentScope is another type of grouping rule (like @media), keep nestedSelectorRule unchanged
-								} else {
-									// Prepended & or not nested in grouping rule - reset to prevent CSSNestedDeclarations
-									nestedSelectorRule = null;
-								}
-							} else if (nestedSelectorRule && currentScope instanceof CSSOM.CSSGroupingRule) {
-								// When closing a nested rule that's not the nestedSelectorRule itself,
-								// maintain nestedSelectorRule if we're still inside a grouping rule
-								// This ensures declarations after nested selectors inside @media/@supports etc. work correctly
-							}
-							styleRule = null;
-							break;
-						}
-					case "keyframeRule-begin":
-					case "before-selector":
-					case "selector":
-						// End of media/supports/document rule.
-						if (!parentRule) {
-							parseError("Unexpected }");
-
-							var hasPreviousStyleRule = currentScope.cssRules.length && currentScope.cssRules[currentScope.cssRules.length - 1].constructor.name === "CSSStyleRule";
-							if (hasPreviousStyleRule) {
-								i = ignoreBalancedBlock(i, token.slice(i), 1);
-							}
-
-							break;
-						}
-
-						// Find the actual parent rule by popping from ancestor stack
-						while (ancestorRules.length > 0) {
-							parentRule = ancestorRules.pop();
-
-							// Skip if we popped the current scope itself (happens because we push both rule and parent)
-							if (parentRule === currentScope) {
-								continue;
-							}
-
-							// Only process valid grouping rules
-							if (!(parentRule instanceof CSSOM.CSSGroupingRule && (parentRule.constructor.name !== 'CSSStyleRule' || parentRule.__parentRule))) {
-								continue;
-							}
-
-							// Determine if we're closing a special nested selector context
-							var isClosingNestedSelectorContext = nestedSelectorRule && 
-								(currentScope === nestedSelectorRule || nestedSelectorRule.__parentRule === currentScope);
-
-							if (isClosingNestedSelectorContext) {
-								// Closing the nestedSelectorRule or its direct container
-								if (nestedSelectorRule.parentRule) {
-									// Add nestedSelectorRule to its parent and update scope
-									prevScope = nestedSelectorRule;
-									currentScope = nestedSelectorRule.parentRule;
-									// Use object lookup instead of O(n) indexOf
-									var scopeId = getRuleId(prevScope);
-									if (!addedToCurrentScope[scopeId]) {
-										currentScope.cssRules.push(prevScope);
-										addedToCurrentScope[scopeId] = true;
-									}
-									nestedSelectorRule = currentScope;
-									// Stop here to preserve context for sibling selectors
-									break;
-								} else {
-									// Top-level CSSStyleRule with nested grouping rule
-									prevScope = currentScope;
-									var actualParent = ancestorRules.length > 0 ? ancestorRules[ancestorRules.length - 1] : nestedSelectorRule;
-									if (actualParent !== prevScope) {
-										actualParent.cssRules.push(prevScope);
-									}
-									currentScope = actualParent;
-									parentRule = actualParent;
-									break;
-								}
-							} else {
-								// Regular case: add currentScope to parentRule
-								prevScope = currentScope;
-								if (parentRule !== prevScope) {
-									parentRule.cssRules.push(prevScope);
-								}
-								break;
-							}
-						}
-
-						// If currentScope has a __parentRule and wasn't added yet, add it
-						if (ancestorRules.length === 0 && currentScope.__parentRule && currentScope.__parentRule.cssRules) {
-							// Use object lookup instead of O(n) findIndex
-							var parentId = getRuleId(currentScope);
-							if (!addedToParent[parentId]) {
-								currentScope.__parentRule.cssRules.push(currentScope);
-								addedToParent[parentId] = true;
-							}
-						}
-
-						// Only handle top-level rule closing if we processed all ancestors
-						if (ancestorRules.length === 0 && currentScope.parentRule == null) {
-							currentScope.__ends = i + 1;
-							// Use object lookup instead of O(n) findIndex
-							var topId = getRuleId(currentScope);
-							if (currentScope !== topScope && !addedToTopScope[topId]) {
-								topScope.cssRules.push(currentScope);
-								addedToTopScope[topId] = true;
-							}
-							currentScope = topScope;
-							if (nestedSelectorRule === parentRule) {
-								// Check if this selector is really starting inside another selector
-								var nestedSelectorTokenToCurrentSelectorToken = token.slice(nestedSelectorRule.__starts, i + 1);
-								var openingBraceMatch = nestedSelectorTokenToCurrentSelectorToken.match(openBraceGlobalRegExp);
-								var closingBraceMatch = nestedSelectorTokenToCurrentSelectorToken.match(closeBraceGlobalRegExp);
-								var openingBraceLen = openingBraceMatch && openingBraceMatch.length;
-								var closingBraceLen = closingBraceMatch && closingBraceMatch.length;
-
-								if (openingBraceLen === closingBraceLen) {
-									// If the number of opening and closing braces are equal, we can assume that the new selector is starting outside the nestedSelectorRule
-									nestedSelectorRule.__ends = i + 1;
-									nestedSelectorRule = null;
-									parentRule = null;
-								}
-							} else {
-								parentRule = null;
-							}
-						} else {
-							currentScope = parentRule;
-						}
-
-						buffer = "";
-						state = "before-selector";
-						break;
-				}
-				break;
-
-			default:
-				switch (state) {
-					case "before-selector":
-						state = "selector";
-						if ((styleRule || scopeRule) && parentRule) {
-							// Assuming it's a declaration inside Nested Selector OR a Nested Declaration
-							// If Declaration inside Nested Selector let's keep the same styleRule
-							if (!isSelectorStartChar(character) && !isWhitespaceChar(character) && parentRule instanceof CSSOM.CSSGroupingRule) {
-								// parentRule.__parentRule = styleRule;
-								state = "before-name";
-								if (styleRule !== parentRule) {
-									styleRule = new CSSOM.CSSNestedDeclarations();
-									styleRule.__starts = i;
-								}
-							}
-
-						} else if (nestedSelectorRule && parentRule && parentRule instanceof CSSOM.CSSGroupingRule) {
-							if (isSelectorStartChar(character)) {
-								// If starting with a selector character, create CSSStyleRule instead of CSSNestedDeclarations
-								styleRule = new CSSOM.CSSStyleRule();
-								styleRule.__starts = i;
-							} else if (!isWhitespaceChar(character)) {
-								// Starting a declaration (not whitespace, not a selector)
-								state = "before-name";
-								// Check if we should create CSSNestedDeclarations
-								// This happens if: parent has cssRules OR nestedSelectorRule exists (indicating CSSStyleRule in hierarchy)
-								if (parentRule.cssRules.length || nestedSelectorRule) {
-									currentScope = parentRule;
-									// Only set nestedSelectorRule if parentRule is CSSStyleRule or CSSScopeRule
-									if (parentRule.constructor.name === "CSSStyleRule" || parentRule.constructor.name === "CSSScopeRule") {
-										nestedSelectorRule = parentRule;
-									}
-									styleRule = new CSSOM.CSSNestedDeclarations();
-									styleRule.__starts = i;
-								} else {
-									if (parentRule.constructor.name === "CSSStyleRule") {
-										styleRule = parentRule;
-									} else {
-										styleRule = new CSSOM.CSSStyleRule();
-										styleRule.__starts = i;
-									}
-								}
-							}
-						}
-						break;
-					case "before-name":
-						state = "name";
-						break;
-					case "before-value":
-						state = "value";
-						break;
-					case "importRule-begin":
-						state = "importRule";
-						break;
-					case "namespaceRule-begin":
-						state = "namespaceRule";
-						break;
-				}
-				buffer += character;
-				break;
-		}
-
-		// Auto-close all unclosed nested structures
-		// Check AFTER processing the character, at the ORIGINAL ending index
-		// Only add closing braces if CSS is incomplete (not at top scope)
-		if (i === initialEndingIndex && (currentScope !== topScope || ancestorRules.length > 0)) {
-			var needsClosing = ancestorRules.length;
-			if (currentScope !== topScope && ancestorRules.indexOf(currentScope) === -1) {
-				needsClosing += 1;
-			}
-			// Add closing braces for all unclosed structures
-			for (var closeIdx = 0; closeIdx < needsClosing; closeIdx++) {
-				token += "}";
-				endingIndex += 1;
-			}
-		}
-	}
-
-	if (buffer.trim() !== "") {
-		parseError("Unexpected end of input");
-	}
-
-	return styleSheet;
-};
-
-
-
-
-
-
-/**
- * Produces a deep copy of stylesheet — the instance variables of stylesheet are copied recursively.
- * @param {CSSStyleSheet|CSSOM.CSSStyleSheet} stylesheet
- * @nosideeffects
- * @return {CSSOM.CSSStyleSheet}
- */
-CSSOM.clone = function clone(stylesheet) {
-
-	var cloned = new CSSOM.CSSStyleSheet();
-
-	var rules = stylesheet.cssRules;
-	if (!rules) {
-		return cloned;
-	}
-
-	for (var i = 0, rulesLength = rules.length; i < rulesLength; i++) {
-		var rule = rules[i];
-		var ruleClone = cloned.cssRules[i] = new rule.constructor();
-
-		var style = rule.style;
-		if (style) {
-			var styleClone = ruleClone.style = new CSSOM.CSSStyleDeclaration();
-			for (var j = 0, styleLength = style.length; j < styleLength; j++) {
-				var name = styleClone[j] = style[j];
-				styleClone[name] = style[name];
-				styleClone._importants[name] = style.getPropertyPriority(name);
-			}
-			styleClone.length = style.length;
-		}
-
-		if (rule.hasOwnProperty('keyText')) {
-			ruleClone.keyText = rule.keyText;
-		}
-
-		if (rule.hasOwnProperty('selectorText')) {
-			ruleClone.selectorText = rule.selectorText;
-		}
-
-		if (rule.hasOwnProperty('mediaText')) {
-			ruleClone.mediaText = rule.mediaText;
-		}
-
-		if (rule.hasOwnProperty('supportsText')) {
-			ruleClone.supports = rule.supports;
-		}
-
-		if (rule.hasOwnProperty('conditionText')) {
-			ruleClone.conditionText = rule.conditionText;
-		}
-
-		if (rule.hasOwnProperty('layerName')) {
-			ruleClone.layerName = rule.layerName;
-		}
-
-		if (rule.hasOwnProperty('href')) {
-			ruleClone.href = rule.href;
-		}
-
-		if (rule.hasOwnProperty('name')) {
-			ruleClone.name = rule.name;
-		}
-
-		if (rule.hasOwnProperty('nameList')) {
-			ruleClone.nameList = rule.nameList;
-		}
-
-		if (rule.hasOwnProperty('cssRules')) {
-			ruleClone.cssRules = clone(rule).cssRules;
-		}
-	}
-
-	return cloned;
-
-};
-
-

node_modules/@acemir/cssom/lib/CSSConditionRule.js

@@ -1,32 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-  CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://www.w3.org/TR/css-conditional-3/#the-cssconditionrule-interface
- */
-CSSOM.CSSConditionRule = function CSSConditionRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.__conditionText = '';
-};
-
-CSSOM.CSSConditionRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSConditionRule.prototype.constructor = CSSOM.CSSConditionRule;
-
-Object.setPrototypeOf(CSSOM.CSSConditionRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSConditionRule.prototype, "conditionText", {
-  get: function () {
-    return this.__conditionText;
-  }
-});
-
-//.CommonJS
-exports.CSSConditionRule = CSSOM.CSSConditionRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSContainerRule.js

@@ -1,70 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-	CSSConditionRule: require("./CSSConditionRule").CSSConditionRule,
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-contain-3/
- * @see https://www.w3.org/TR/css-contain-3/
- */
-CSSOM.CSSContainerRule = function CSSContainerRule() {
-	CSSOM.CSSConditionRule.call(this);
-};
-
-CSSOM.CSSContainerRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSContainerRule.prototype.constructor = CSSOM.CSSContainerRule;
-
-Object.setPrototypeOf(CSSOM.CSSContainerRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSContainerRule.prototype, "type", {
-	value: 17,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSContainerRule.prototype, {
-  "cssText": {
-    get: function() {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@container " + this.conditionText + values;
-    }
-  },
-  "containerName": {
-      get: function() {
-        var parts = this.conditionText.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] !== '(' && !parts[0].startsWith('(')) {
-          return parts[0];
-        }
-        return "";
-      }
-    },
-  "containerQuery": {
-      get: function() {
-        var parts = this.conditionText.trim().split(/\s+/);
-        if (parts.length > 1 && parts[0] !== '(' && !parts[0].startsWith('(')) {
-          return parts.slice(1).join(' ');
-        }
-        return this.conditionText;
-      }
-    },
-});
-
-
-//.CommonJS
-exports.CSSContainerRule = CSSOM.CSSContainerRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSCounterStyleRule.js

@@ -1,57 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-counter-styles/#the-csscounterstylerule-interface
- */
-CSSOM.CSSCounterStyleRule = function CSSCounterStyleRule() {
-	CSSOM.CSSRule.call(this);
-    this.name = "";
-	this.__props = "";
-};
-
-CSSOM.CSSCounterStyleRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSCounterStyleRule.prototype.constructor = CSSOM.CSSCounterStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSCounterStyleRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "type", {
-	value: 11,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "cssText", {
-	get: function() {
-		// FIXME : Implement real cssText generation based on properties
-		return "@counter-style " + this.name + " { " + this.__props + " }";
-	}
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSCounterStyleRule.prototype, "parse", {
-	value: function(cssText) {
-		// Extract the name from "@counter-style <name> { ... }"
-		var match = cssText.match(/@counter-style\s+([^\s{]+)\s*\{([^]*)\}/);
-		if (match) {
-			this.name = match[1];
-			// Get the text inside the brackets and clean it up
-			var propsText = match[2];
-			this.__props = propsText.trim().replace(/\n/g, " ").replace(/(['"])(?:\\.|[^\\])*?\1|(\s{2,})/g, function (match, quote) {
-				return quote ? match : ' ';
-			});
-		}
-	}
-});
-
-//.CommonJS
-exports.CSSCounterStyleRule = CSSOM.CSSCounterStyleRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSDocumentRule.js

@@ -1,48 +0,0 @@
-//.CommonJS
-var CSSOM = {
-    CSSRule: require("./CSSRule").CSSRule,
-    CSSRuleList: require("./CSSRuleList").CSSRuleList,
-    MatcherList: require("./MatcherList").MatcherList
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://developer.mozilla.org/en/CSS/@-moz-document
- * @deprecated This rule is a non-standard Mozilla-specific extension and is not part of any official CSS specification.
- */
-CSSOM.CSSDocumentRule = function CSSDocumentRule() {
-    CSSOM.CSSRule.call(this);
-    this.matcher = new CSSOM.MatcherList();
-    this.cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSDocumentRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSDocumentRule.prototype.constructor = CSSOM.CSSDocumentRule;
-
-Object.setPrototypeOf(CSSOM.CSSDocumentRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSDocumentRule.prototype, "type", {
-	value: 10,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSDocumentRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSDocumentRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSDocumentRule.prototype, "cssText", {
-  get: function() {
-    var cssTexts = [];
-    for (var i=0, length=this.cssRules.length; i < length; i++) {
-        cssTexts.push(this.cssRules[i].cssText);
-    }
-    return "@-moz-document " + this.matcher.matcherText + " {" + (cssTexts.length ? "\n  " + cssTexts.join("\n  ") : "") + "\n}";
-  }
-});
-
-
-//.CommonJS
-exports.CSSDocumentRule = CSSOM.CSSDocumentRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSFontFaceRule.js

@@ -1,62 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
-	CSSRule: require("./CSSRule").CSSRule
-};
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#css-font-face-rule
- */
-CSSOM.CSSFontFaceRule = function CSSFontFaceRule() {
-	CSSOM.CSSRule.call(this);
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSFontFaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSFontFaceRule.prototype.constructor = CSSOM.CSSFontFaceRule;
-
-Object.setPrototypeOf(CSSOM.CSSFontFaceRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "type", {
-	value: 5,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSFontFaceRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSFontFaceRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSFontFaceRule.cpp
-Object.defineProperty(CSSOM.CSSFontFaceRule.prototype, "cssText", {
-  get: function() {
-    return "@font-face {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-  }
-});
-
-
-//.CommonJS
-exports.CSSFontFaceRule = CSSOM.CSSFontFaceRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSGroupingRule.js

@@ -1,165 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	parse: require('./parse').parse
-};
-var errorUtils = require("./errorUtils").errorUtils;
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssgroupingrule-interface
- */
-CSSOM.CSSGroupingRule = function CSSGroupingRule() {
-	CSSOM.CSSRule.call(this);
-	this.__cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSGroupingRule.prototype  = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSGroupingRule.prototype.constructor = CSSOM.CSSGroupingRule;
-
-Object.setPrototypeOf(CSSOM.CSSGroupingRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSGroupingRule.prototype, "cssRules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-/**
- * Used to insert a new CSS rule to a list of CSS rules.
- *
- * @example
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}"
- *   cssGroupingRule.insertRule("img{border:none;}", 1)
- *   -> 1
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}img{border:none;}"
- *
- * @param {string} rule
- * @param {number} [index]
- * @see https://www.w3.org/TR/cssom-1/#dom-cssgroupingrule-insertrule
- * @return {number} The index within the grouping rule's collection of the newly inserted rule.
- */
- CSSOM.CSSGroupingRule.prototype.insertRule = function insertRule(rule, index) {
-	if (rule === undefined && index === undefined) {
-		errorUtils.throwMissingArguments(this, 'insertRule', this.constructor.name);
-	}
-	if (index === void 0) {
-		index = 0;
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index > this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'insertRule', this.constructor.name, index, this.cssRules.length);
-	}
-	var ruleToParse = processedRuleToParse = String(rule);
-	ruleToParse = ruleToParse.trim().replace(/^\/\*[\s\S]*?\*\/\s*/, "");
-	var isNestedSelector = this.constructor.name === "CSSStyleRule";
-	if (isNestedSelector === false) {
-		var currentRule = this;
-		while (currentRule.parentRule) {
-			currentRule = currentRule.parentRule;
-			if (currentRule.constructor.name === "CSSStyleRule") {
-				isNestedSelector = true;
-				break;
-			}
-		}
-	}
-	if (isNestedSelector) {
-		processedRuleToParse = 's { n { } ' + ruleToParse + '}';
-	}
-	var isScopeRule = this.constructor.name === "CSSScopeRule";
-	if (isScopeRule) {
-		if (isNestedSelector) {
-			processedRuleToParse = 's { ' + '@scope {' + ruleToParse + '}}';
-		} else {
-			processedRuleToParse = '@scope {' + ruleToParse + '}';
-		}
-	}
-	var parsedRules = new CSSOM.CSSRuleList();
-	CSSOM.parse(processedRuleToParse, {
-		styleSheet: this.parentStyleSheet,
-		cssRules: parsedRules
-	});
-	if (isScopeRule) {
-		if (isNestedSelector) {
-			parsedRules = parsedRules[0].cssRules[0].cssRules;
-		} else {
-			parsedRules = parsedRules[0].cssRules
-		}
-	}
-	if (isNestedSelector) {
-		parsedRules = parsedRules[0].cssRules.slice(1);
-	}
-	if (parsedRules.length !== 1) {
-		if (isNestedSelector && parsedRules.length === 0 && ruleToParse.indexOf('@font-face') === 0) {
-			errorUtils.throwError(this, 'DOMException', 
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': " +
-				"Only conditional nested group rules, style rules, @scope rules, @apply rules, and nested declaration rules may be nested.",
-				'HierarchyRequestError');
-		} else {
-			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-		}
-	}
-	var cssRule = parsedRules[0];
-
-	if (cssRule.constructor.name === 'CSSNestedDeclarations' && cssRule.style.length === 0) {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');	
-	}
-	
-	// Check for rules that cannot be inserted inside a CSSGroupingRule
-	if (cssRule.constructor.name === 'CSSImportRule' || cssRule.constructor.name === 'CSSNamespaceRule') {
-		var ruleKeyword = cssRule.constructor.name === 'CSSImportRule' ? '@import' : '@namespace';
-		errorUtils.throwError(this, 'DOMException', 
-			"Failed to execute 'insertRule' on '" + this.constructor.name + "': " +
-			"'" + ruleKeyword + "' rules cannot be inserted inside a group rule.",
-			'HierarchyRequestError');
-	}
-	
-	// Check for CSSLayerStatementRule (@layer statement rules)
-	if (cssRule.constructor.name === 'CSSLayerStatementRule') {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-	}
-	
-	cssRule.__parentRule = this;
-	this.cssRules.splice(index, 0, cssRule);
-	return index;
-};
-
-/**
- * Used to delete a rule from the grouping rule.
- *
- *   cssGroupingRule.cssText
- *   -> "img{border:none;}body{margin:0;}"
- *   cssGroupingRule.deleteRule(0)
- *   cssGroupingRule.cssText
- *   -> "body{margin:0;}"
- *
- * @param {number} index within the grouping rule's rule list of the rule to remove.
- * @see https://www.w3.org/TR/cssom-1/#dom-cssgroupingrule-deleterule
- */
- CSSOM.CSSGroupingRule.prototype.deleteRule = function deleteRule(index) {
-	if (index === undefined) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', this.constructor.name);
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index >= this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
-	}
-	this.cssRules[index].__parentRule = null;
-	this.cssRules[index].__parentStyleSheet = null;
-	this.cssRules.splice(index, 1);
-};
-
-//.CommonJS
-exports.CSSGroupingRule = CSSOM.CSSGroupingRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSHostRule.js

@@ -1,54 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
- * @see http://html5index.org/Shadow%20DOM%20-%20CSSHostRule.html
- * @deprecated This rule was part of early Shadow DOM drafts but was removed in favor of the more flexible :host and :host-context() pseudo-classes in modern CSS for Web Components.
- */
-CSSOM.CSSHostRule = function CSSHostRule() {
-	CSSOM.CSSRule.call(this);
-	this.cssRules = new CSSOM.CSSRuleList();
-};
-
-CSSOM.CSSHostRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSHostRule.prototype.constructor = CSSOM.CSSHostRule;
-
-Object.setPrototypeOf(CSSOM.CSSHostRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSHostRule.prototype, "type", {
-	value: 1001,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSHostRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSHostRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSHostRule.prototype, "cssText", {
-	get: function() {
-		var values = "";
-		var valuesArr = [" {"];
-		if (this.cssRules.length) {
-			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-			if (rule.cssText !== "") {
-				acc.push(rule.cssText);
-			}
-			return acc;
-			}, []).join("\n  "));
-		}
-		values = valuesArr.join("\n  ") + "\n}";
-		return "@host" + values;
-	}
-});
-
-
-//.CommonJS
-exports.CSSHostRule = CSSOM.CSSHostRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSImportRule.js

@@ -1,267 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSStyleSheet: require("./CSSStyleSheet").CSSStyleSheet,
-	MediaList: require("./MediaList").MediaList
-};
-var regexPatterns = require("./regexPatterns").regexPatterns;
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssimportrule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSImportRule
- */
-CSSOM.CSSImportRule = function CSSImportRule() {
-	CSSOM.CSSRule.call(this);
-	this.__href = "";
-	this.__media = new CSSOM.MediaList();
-  this.__layerName = null;
-  this.__supportsText = null;
-	this.__styleSheet = new CSSOM.CSSStyleSheet();
-};
-
-CSSOM.CSSImportRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSImportRule.prototype.constructor = CSSOM.CSSImportRule;
-
-Object.setPrototypeOf(CSSOM.CSSImportRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "type", {
-	value: 3,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "cssText", {
-  get: function() {
-    var mediaText = this.media.mediaText;
-    return "@import url(\"" + this.href.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + "\")" + (this.layerName !== null ? " layer" + (this.layerName && "(" + this.layerName + ")") : "" ) + (this.supportsText ? " supports(" + this.supportsText + ")" : "" ) + (mediaText ? " " + mediaText : "") + ";";
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "href", {
-  get: function() {
-    return this.__href;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "media", {
-  get: function() {
-    return this.__media;
-  },
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__media.mediaText = value;
-		} else {
-			this.__media = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "layerName", {
-  get: function() {
-    return this.__layerName;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "supportsText", {
-  get: function() {
-    return this.__supportsText;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "styleSheet", {
-  get: function() {
-    return this.__styleSheet;
-  }
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSImportRule.prototype, "parse", {
-  value: function(cssText) {
-    var i = 0;
-
-    /**
-     * @import url(partial.css) screen, handheld;
-     *        ||               |
-     *        after-import     media
-     *         |
-     *         url
-     */
-    var state = '';
-
-    var buffer = '';
-    var index;
-
-    var layerRegExp = regexPatterns.layerRegExp;
-    var layerRuleNameRegExp = regexPatterns.layerRuleNameRegExp;
-    var doubleOrMoreSpacesRegExp = regexPatterns.doubleOrMoreSpacesRegExp;
-    
-    /**
-     * Extracts the content inside supports() handling nested parentheses.
-     * @param {string} text - The text to parse
-     * @returns {object|null} - {content: string, endIndex: number} or null if not found
-     */
-    function extractSupportsContent(text) {
-      var supportsIndex = text.indexOf('supports(');
-      if (supportsIndex !== 0) {
-        return null;
-      }
-      
-      var depth = 0;
-      var start = supportsIndex + 'supports('.length;
-      var i = start;
-      
-      for (; i < text.length; i++) {
-        if (text[i] === '(') {
-          depth++;
-        } else if (text[i] === ')') {
-          if (depth === 0) {
-            // Found the closing parenthesis for supports()
-            return {
-              content: text.slice(start, i),
-              endIndex: i
-            };
-          }
-          depth--;
-        }
-      }
-      
-      return null; // Unbalanced parentheses
-    }
-
-    for (var character; (character = cssText.charAt(i)); i++) {
-
-      switch (character) {
-        case ' ':
-        case '\t':
-        case '\r':
-        case '\n':
-        case '\f':
-          if (state === 'after-import') {
-            state = 'url';
-          } else {
-            buffer += character;
-          }
-          break;
-
-        case '@':
-          if (!state && cssText.indexOf('@import', i) === i) {
-            state = 'after-import';
-            i += 'import'.length;
-            buffer = '';
-          }
-          break;
-
-        case 'u':
-          if (state === 'media') {
-            buffer += character;
-          }
-          if (state === 'url' && cssText.indexOf('url(', i) === i) {
-            index = cssText.indexOf(')', i + 1);
-            if (index === -1) {
-              throw i + ': ")" not found';
-            }
-            i += 'url('.length;
-            var url = cssText.slice(i, index);
-            if (url[0] === url[url.length - 1]) {
-              if (url[0] === '"' || url[0] === "'") {
-                url = url.slice(1, -1);
-              }
-            }
-            this.__href = url;
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case '"':
-          if (state === 'after-import' || state === 'url') {
-            index = cssText.indexOf('"', i + 1);
-            if (!index) {
-              throw i + ": '\"' not found";
-            }
-            this.__href = cssText.slice(i + 1, index);
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case "'":
-          if (state === 'after-import' || state === 'url') {
-            index = cssText.indexOf("'", i + 1);
-            if (!index) {
-              throw i + ': "\'" not found';
-            }
-            this.__href = cssText.slice(i + 1, index);
-            i = index;
-            state = 'media';
-          }
-          break;
-
-        case ';':
-          if (state === 'media') {
-            if (buffer) {
-              var bufferTrimmed = buffer.trim();
-              
-              if (bufferTrimmed.indexOf('layer') === 0) {
-                var layerMatch =  bufferTrimmed.match(layerRegExp);
-
-                if (layerMatch) {
-                  var layerName = layerMatch[1].trim();
-
-                  if (layerName.match(layerRuleNameRegExp) !== null) {
-                    this.__layerName = layerMatch[1].trim();
-                    bufferTrimmed = bufferTrimmed.replace(layerRegExp, '')
-                      .replace(doubleOrMoreSpacesRegExp, ' ') // Replace double or more spaces with single space
-                      .trim();
-                  } else {
-                    // REVIEW: In the browser, an empty layer() is not processed as a unamed layer
-                    // and treats the rest of the string as mediaText, ignoring the parse of supports()
-                    if (bufferTrimmed) {
-                      this.media.mediaText = bufferTrimmed;
-                      return;
-                    }
-                  }
-                } else {
-                  this.__layerName = "";
-                  bufferTrimmed = bufferTrimmed.substring('layer'.length).trim()
-                }
-              }
-
-              var supportsResult = extractSupportsContent(bufferTrimmed);
-
-              if (supportsResult) {
-                // REVIEW: In the browser, an empty supports() invalidates and ignores the entire @import rule
-                this.__supportsText = supportsResult.content.trim();
-                // Remove the entire supports(...) from the buffer
-                bufferTrimmed = bufferTrimmed.slice(0, 0) + bufferTrimmed.slice(supportsResult.endIndex + 1);
-                bufferTrimmed = bufferTrimmed.replace(doubleOrMoreSpacesRegExp, ' ').trim();
-              }
-
-              // REVIEW: In the browser, any invalid media is replaced with 'not all'
-              if (bufferTrimmed) {
-                this.media.mediaText = bufferTrimmed;
-              }
-            }
-          }
-          break;
-
-        default:
-          if (state === 'media') {
-            buffer += character;
-          }
-          break;
-      }
-    }
-  }
-});
-
-
-//.CommonJS
-exports.CSSImportRule = CSSOM.CSSImportRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSKeyframeRule.js

@@ -1,63 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSStyleDeclaration: require('./CSSStyleDeclaration').CSSStyleDeclaration
-};
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframeRule
- */
-CSSOM.CSSKeyframeRule = function CSSKeyframeRule() {
-	CSSOM.CSSRule.call(this);
-	this.keyText = '';
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSKeyframeRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSKeyframeRule.prototype.constructor = CSSOM.CSSKeyframeRule;
-
-Object.setPrototypeOf(CSSOM.CSSKeyframeRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "type", {
-	value: 8,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSKeyframeRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSKeyframeRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframeRule.cpp
-Object.defineProperty(CSSOM.CSSKeyframeRule.prototype, "cssText", {
-  get: function() {
-    return this.keyText + " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-  }
-});
-
-
-//.CommonJS
-exports.CSSKeyframeRule = CSSOM.CSSKeyframeRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSKeyframesRule.js

@@ -1,247 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	parse: require("./parse").parse
-};
-var errorUtils = require("./errorUtils").errorUtils;
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/css3-animations/#DOM-CSSKeyframesRule
- */
-CSSOM.CSSKeyframesRule = function CSSKeyframesRule() {
-	CSSOM.CSSRule.call(this);
-	this.name = '';
-	this.cssRules = new CSSOM.CSSRuleList();
-	
-	// Set up initial indexed access
-	this._setupIndexedAccess();
-	
-	// Override cssRules methods after initial setup, store references as non-enumerable properties
-	var self = this;
-	var originalPush = this.cssRules.push;
-	var originalSplice = this.cssRules.splice;
-	
-	// Create non-enumerable method overrides
-	Object.defineProperty(this.cssRules, 'push', {
-		value: function() {
-			var result = originalPush.apply(this, arguments);
-			self._setupIndexedAccess();
-			return result;
-		},
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-	
-	Object.defineProperty(this.cssRules, 'splice', {
-		value: function() {
-			var result = originalSplice.apply(this, arguments);
-			self._setupIndexedAccess();
-			return result;
-		},
-		writable: true,
-		enumerable: false,
-		configurable: true
-	});
-};
-
-CSSOM.CSSKeyframesRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSKeyframesRule.prototype.constructor = CSSOM.CSSKeyframesRule;
-
-Object.setPrototypeOf(CSSOM.CSSKeyframesRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "type", {
-	value: 7,
-	writable: false
-});
-
-// http://www.opensource.apple.com/source/WebCore/WebCore-955.66.1/css/WebKitCSSKeyframesRule.cpp
-Object.defineProperty(CSSOM.CSSKeyframesRule.prototype, "cssText", {
-  get: function() {
-    var values = "";
-	var valuesArr = [" {"];
-	if (this.cssRules.length) {
-	valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-		if (rule.cssText !== "") {
-		acc.push(rule.cssText);
-		}
-		return acc;
-	}, []).join("\n  "));
-	}
-	values = valuesArr.join("\n  ") + "\n}";
-    var cssWideKeywords = ['initial', 'inherit', 'revert', 'revert-layer', 'unset', 'none'];
-    var processedName = cssWideKeywords.includes(this.name) ? '"' + this.name + '"' : this.name;
-    return "@" + (this._vendorPrefix || '') + "keyframes " + processedName + values;
-  }
-});
-
-/**
- * Appends a new keyframe rule to the list of keyframes.
- * 
- * @param {string} rule - The keyframe rule string to append (e.g., "50% { opacity: 0.5; }")
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-appendrule
- */
-CSSOM.CSSKeyframesRule.prototype.appendRule = function appendRule(rule) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'appendRule', 'CSSKeyframesRule');
-	}
-	
-	var parsedRule;
-	try {
-		// Parse the rule string as a keyframe rule
-		var tempStyleSheet = CSSOM.parse("@keyframes temp { " + rule + " }");
-		if (tempStyleSheet.cssRules.length > 0 && tempStyleSheet.cssRules[0].cssRules.length > 0) {
-			parsedRule = tempStyleSheet.cssRules[0].cssRules[0];
-		} else {
-			throw new Error("Failed to parse keyframe rule");
-		}
-	} catch (e) {
-		errorUtils.throwParseError(this, 'appendRule', 'CSSKeyframesRule', rule);
-	}
-	
-	parsedRule.__parentRule = this;
-	this.cssRules.push(parsedRule);
-};
-
-/**
- * Deletes a keyframe rule that matches the specified key.
- * 
- * @param {string} select - The keyframe selector to delete (e.g., "50%", "from", "to")
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-deleterule
- */
-CSSOM.CSSKeyframesRule.prototype.deleteRule = function deleteRule(select) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', 'CSSKeyframesRule');
-	}
-	
-	var normalizedSelect = this._normalizeKeyText(select);
-	
-	for (var i = 0; i < this.cssRules.length; i++) {
-		var rule = this.cssRules[i];
-		if (this._normalizeKeyText(rule.keyText) === normalizedSelect) {
-			rule.__parentRule = null;
-			this.cssRules.splice(i, 1);
-			return;
-		}
-	}
-};
-
-/**
- * Finds and returns the keyframe rule that matches the specified key.
- * When multiple rules have the same key, returns the last one.
- * 
- * @param {string} select - The keyframe selector to find (e.g., "50%", "from", "to")
- * @return {CSSKeyframeRule|null} The matching keyframe rule, or null if not found
- * @see https://www.w3.org/TR/css-animations-1/#dom-csskeyframesrule-findrule
- */
-CSSOM.CSSKeyframesRule.prototype.findRule = function findRule(select) {
-	if (arguments.length === 0) {
-		errorUtils.throwMissingArguments(this, 'findRule', 'CSSKeyframesRule');
-	}
-	
-	var normalizedSelect = this._normalizeKeyText(select);
-	
-	// Iterate backwards to find the last matching rule
-	for (var i = this.cssRules.length - 1; i >= 0; i--) {
-		var rule = this.cssRules[i];
-		if (this._normalizeKeyText(rule.keyText) === normalizedSelect) {
-			return rule;
-		}
-	}
-	
-	return null;
-};
-
-/**
- * Normalizes keyframe selector text for comparison.
- * Handles "from" -> "0%" and "to" -> "100%" conversions and trims whitespace.
- * 
- * @private
- * @param {string} keyText - The keyframe selector text to normalize
- * @return {string} The normalized keyframe selector text
- */
-CSSOM.CSSKeyframesRule.prototype._normalizeKeyText = function _normalizeKeyText(keyText) {
-	if (!keyText) return '';
-	
-	var normalized = keyText.toString().trim().toLowerCase();
-	
-	// Convert keywords to percentages for comparison
-	if (normalized === 'from') {
-		return '0%';
-	} else if (normalized === 'to') {
-		return '100%';
-	}
-	
-	return normalized;
-};
-
-/**
- * Makes CSSKeyframesRule iterable over its cssRules.
- * Allows for...of loops and other iterable methods.
- */
-if (typeof Symbol !== 'undefined' && Symbol.iterator) {
-	CSSOM.CSSKeyframesRule.prototype[Symbol.iterator] = function() {
-		var index = 0;
-		var cssRules = this.cssRules;
-		
-		return {
-			next: function() {
-				if (index < cssRules.length) {
-					return { value: cssRules[index++], done: false };
-				} else {
-					return { done: true };
-				}
-			}
-		};
-	};
-}
-
-/**
- * Adds indexed getters for direct access to cssRules by index.
- * This enables rule[0], rule[1], etc. access patterns.
- * Works in environments where Proxy is not available (like jsdom).
- */
-CSSOM.CSSKeyframesRule.prototype._setupIndexedAccess = function() {
-	// Remove any existing indexed properties
-	for (var i = 0; i < 1000; i++) { // reasonable upper limit
-		if (this.hasOwnProperty(i)) {
-			delete this[i];
-		} else {
-			break;
-		}
-	}
-	
-	// Add indexed getters for current cssRules
-	for (var i = 0; i < this.cssRules.length; i++) {
-		(function(index) {
-			Object.defineProperty(this, index, {
-				get: function() {
-					return this.cssRules[index];
-				},
-				enumerable: false,
-				configurable: true
-			});
-		}.call(this, i));
-	}
-	
-	// Update length property
-	Object.defineProperty(this, 'length', {
-		get: function() {
-			return this.cssRules.length;
-		},
-		enumerable: false,
-		configurable: true
-	});
-};
-
-
-
-
-
-//.CommonJS
-exports.CSSKeyframesRule = CSSOM.CSSKeyframesRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSLayerBlockRule.js

@@ -1,49 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-  CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-};
-///CommonJS
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-5/#csslayerblockrule
- */
-CSSOM.CSSLayerBlockRule = function CSSLayerBlockRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.name = "";
-};
-
-CSSOM.CSSLayerBlockRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSLayerBlockRule.prototype.constructor = CSSOM.CSSLayerBlockRule;
-
-Object.setPrototypeOf(CSSOM.CSSLayerBlockRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSLayerBlockRule.prototype, "type", {
-	value: 18,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSLayerBlockRule.prototype, {
-  cssText: {
-    get: function () {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@layer" + (this.name ? " " + this.name : "") + values;
-    }
-  },
-});
-
-//.CommonJS
-exports.CSSLayerBlockRule = CSSOM.CSSLayerBlockRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSLayerStatementRule.js

@@ -1,36 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-};
-///CommonJS
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-5/#csslayerstatementrule
- */
-CSSOM.CSSLayerStatementRule = function CSSLayerStatementRule() {
-  CSSOM.CSSRule.call(this);
-  this.nameList = [];
-};
-
-CSSOM.CSSLayerStatementRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSLayerStatementRule.prototype.constructor = CSSOM.CSSLayerStatementRule;
-
-Object.setPrototypeOf(CSSOM.CSSLayerStatementRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSLayerStatementRule.prototype, "type", {
-	value: 0,
-	writable: false
-});
-
-Object.defineProperties(CSSOM.CSSLayerStatementRule.prototype, {
-  cssText: {
-    get: function () {
-      return "@layer " + this.nameList.join(", ") + ";";
-    }
-  },
-});
-
-//.CommonJS
-exports.CSSLayerStatementRule = CSSOM.CSSLayerStatementRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSMediaRule.js

@@ -1,74 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-	CSSConditionRule: require("./CSSConditionRule").CSSConditionRule,
-	MediaList: require("./MediaList").MediaList
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssmediarule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSMediaRule
- */
-CSSOM.CSSMediaRule = function CSSMediaRule() {
-	CSSOM.CSSConditionRule.call(this);
-	this.__media = new CSSOM.MediaList();
-};
-
-CSSOM.CSSMediaRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSMediaRule.prototype.constructor = CSSOM.CSSMediaRule;
-
-Object.setPrototypeOf(CSSOM.CSSMediaRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSMediaRule.prototype, "type", {
-	value: 4,
-	writable: false
-});
-
-// https://opensource.apple.com/source/WebCore/WebCore-7611.1.21.161.3/css/CSSMediaRule.cpp
-Object.defineProperties(CSSOM.CSSMediaRule.prototype, {
-  "media": {
-    get: function() {
-      return this.__media;
-    },
-    set: function(value) {
-      if (typeof value === "string") {
-        this.__media.mediaText = value;
-      } else {
-        this.__media = value;
-      }
-    },
-    configurable: true,
-    enumerable: true
-  },
-  "conditionText": {
-    get: function() {
-      return this.media.mediaText;
-    }
-  },
-  "cssText": {
-    get: function() {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@media " + this.media.mediaText + values;
-    }
-  }
-});
-
-
-//.CommonJS
-exports.CSSMediaRule = CSSOM.CSSMediaRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSNamespaceRule.js

@@ -1,103 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSStyleSheet: require("./CSSStyleSheet").CSSStyleSheet
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssnamespacerule-interface
- */
-CSSOM.CSSNamespaceRule = function CSSNamespaceRule() {
-	CSSOM.CSSRule.call(this);
-	this.__prefix = "";
-	this.__namespaceURI = "";
-};
-
-CSSOM.CSSNamespaceRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSNamespaceRule.prototype.constructor = CSSOM.CSSNamespaceRule;
-
-Object.setPrototypeOf(CSSOM.CSSNamespaceRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "type", {
-  value: 10,
-  writable: false
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "cssText", {
-  get: function() {
-    return "@namespace" + (this.prefix && " " + this.prefix) + " url(\"" + this.namespaceURI + "\");";
-  }
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "prefix", {
-  get: function() {
-    return this.__prefix;
-  }
-});
-
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "namespaceURI", {
-  get: function() {
-    return this.__namespaceURI;
-  }
-});
-
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- */
-Object.defineProperty(CSSOM.CSSNamespaceRule.prototype, "parse", {
-  value: function(cssText) {
-    var newPrefix = "";
-    var newNamespaceURI = "";
-
-    // Remove @namespace and trim
-    var text = cssText.trim();
-    if (text.indexOf('@namespace') === 0) {
-      text = text.slice('@namespace'.length).trim();
-    }
-
-    // Remove trailing semicolon if present
-    if (text.charAt(text.length - 1) === ';') {
-      text = text.slice(0, -1).trim();
-    }
-
-    // Regex to match valid namespace syntax:
-    // 1. [optional prefix] url("...") or [optional prefix] url('...') or [optional prefix] url() or [optional prefix] url(unquoted)
-    // 2. [optional prefix] "..." or [optional prefix] '...'
-    // The prefix must be a valid CSS identifier (letters, digits, hyphens, underscores, starting with letter or underscore)
-    var re = /^(?:([a-zA-Z_][a-zA-Z0-9_-]*)\s+)?(?:url\(\s*(?:(['"])(.*?)\2\s*|([^)]*?))\s*\)|(['"])(.*?)\5)$/;
-    var match = text.match(re);
-
-    if (match) {
-      // If prefix is present
-      if (match[1]) {
-        newPrefix = match[1];
-      }
-      // If url(...) form with quotes
-      if (typeof match[3] !== "undefined") {
-        newNamespaceURI = match[3];
-      }
-      // If url(...) form without quotes
-      else if (typeof match[4] !== "undefined") {
-        newNamespaceURI = match[4].trim();
-      }
-      // If quoted string form
-      else if (typeof match[6] !== "undefined") {
-        newNamespaceURI = match[6];
-      }
-
-      this.__prefix = newPrefix;
-      this.__namespaceURI = newNamespaceURI;
-    } else {
-      throw new DOMException("Invalid @namespace rule", "InvalidStateError");
-    }
-  }
-});
-//.CommonJS
-exports.CSSNamespaceRule = CSSOM.CSSNamespaceRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSNestedDeclarations.js

@@ -1,56 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-  CSSStyleDeclaration: require('./CSSStyleDeclaration').CSSStyleDeclaration
-};
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-nesting-1/
- */
-CSSOM.CSSNestedDeclarations = function CSSNestedDeclarations() {
-  CSSOM.CSSRule.call(this);
-  this.__style = new CSSOM.CSSStyleDeclaration();
-  this.__style.parentRule = this;
-};
-
-CSSOM.CSSNestedDeclarations.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSNestedDeclarations.prototype.constructor = CSSOM.CSSNestedDeclarations;
-
-Object.setPrototypeOf(CSSOM.CSSNestedDeclarations, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "type", {
-  value: 0,
-  writable: false
-});
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSNestedDeclarations.prototype, "cssText", {
-  get: function () {
-    return this.style.cssText;
-  }
-});
-
-//.CommonJS
-exports.CSSNestedDeclarations = CSSOM.CSSNestedDeclarations;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSOM.js

@@ -1,58 +0,0 @@
-var CSSOM = {
-  /**
-   * Creates and configures a new CSSOM instance with the specified options.
-   * 
-   * @param {Object} opts - Configuration options for the CSSOM instance
-   * @param {Object} [opts.globalObject] - Optional global object to be assigned to CSSOM objects prototype
-   * @returns {Object} A new CSSOM instance with the applied configuration
-   * @description
-   * This method creates a new instance of CSSOM and optionally
-   * configures CSSStyleSheet with a global object reference. When a globalObject is provided
-   * and CSSStyleSheet exists on the instance, it creates a new CSSStyleSheet constructor
-   * using a factory function and assigns the globalObject to its prototype's __globalObject property.
-   */
-  setup: function (opts) {
-    var instance = Object.create(this);
-    if (opts.globalObject) {
-      if (instance.CSSStyleSheet) {
-        var factoryCSSStyleSheet = createFunctionFactory(instance.CSSStyleSheet);
-        var CSSStyleSheet = factoryCSSStyleSheet();
-        CSSStyleSheet.prototype.__globalObject = opts.globalObject;
-
-        instance.CSSStyleSheet = CSSStyleSheet;
-      }
-    }
-    return instance;
-  }
-};
-
-function createFunctionFactory(fn) {
-  return function() {
-    // Create a new function that delegates to the original
-    var newFn = function() {
-      return fn.apply(this, arguments);
-    };
-
-    // Copy prototype chain
-    Object.setPrototypeOf(newFn, Object.getPrototypeOf(fn));
-
-    // Copy own properties
-    for (var key in fn) {
-      if (Object.prototype.hasOwnProperty.call(fn, key)) {
-        newFn[key] = fn[key];
-      }
-    }
-
-    // Clone the .prototype object for constructor-like behavior
-    if (fn.prototype) {
-      newFn.prototype = Object.create(fn.prototype);
-    }
-
-    return newFn;
-  };
-}
-
-//.CommonJS
-module.exports = CSSOM;
-///CommonJS
-

node_modules/@acemir/cssom/lib/CSSPageRule.js

@@ -1,125 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-};
-var regexPatterns = require("./regexPatterns").regexPatterns;
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-csspagerule-interface
- */
-CSSOM.CSSPageRule = function CSSPageRule() {
-	CSSOM.CSSGroupingRule.call(this);
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSPageRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSPageRule.prototype.constructor = CSSOM.CSSPageRule;
-
-Object.setPrototypeOf(CSSOM.CSSPageRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "type", {
-	value: 6,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "selectorText", {
-    get: function() {
-        return this.__selectorText;	
-    },
-    set: function(value) {
-        if (typeof value === "string") {
-            var trimmedValue = value.trim();
-            
-            // Empty selector is valid for @page
-            if (trimmedValue === '') {
-                this.__selectorText = '';
-                return;
-            }
-            
-			var atPageRuleSelectorRegExp = regexPatterns.atPageRuleSelectorRegExp;
-			var cssCustomIdentifierRegExp = regexPatterns.cssCustomIdentifierRegExp;
-            var match = trimmedValue.match(atPageRuleSelectorRegExp);
-            if (match) {
-				var pageName = match[1] || '';
-                var pseudoPages = match[2] || '';
-
-				// Validate page name if present
-				if (pageName) {
-					// Page name can be an identifier or a string
-					if (!cssCustomIdentifierRegExp.test(pageName)) {
-						return;
-					}
-				}
-                
-                // Validate pseudo-pages if present
-                if (pseudoPages) {
-                    var pseudos = pseudoPages.split(':').filter(function(p) { return p; });
-                    var validPseudos = ['left', 'right', 'first', 'blank'];
-                    var allValid = true;
-                    for (var j = 0; j < pseudos.length; j++) {
-                        if (validPseudos.indexOf(pseudos[j].toLowerCase()) === -1) {
-                            allValid = false;
-                            break;
-                        }
-                    }
-                    
-                    if (!allValid) {
-                        return; // Invalid pseudo-page, do nothing
-                    }
-                }
-                
-				this.__selectorText = pageName + pseudoPages.toLowerCase();
-            }
-        }
-    }
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPageRule.prototype, "cssText", {
-	get: function() {
-        var values = "";
-        if (this.cssRules.length) {
-            var valuesArr = [" {"];
-            this.style.cssText && valuesArr.push(this.style.cssText);
-            valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-				if (rule.cssText !== "") {
-					acc.push(rule.cssText);
-				}
-				return acc;
-			}, []).join("\n  "));
-            values = valuesArr.join("\n  ") + "\n}";
-        } else {
-            values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-        }
-		return "@page" + (this.selectorText ? " " + this.selectorText : "") + values;
-	}
-});
-
-//.CommonJS
-exports.CSSPageRule = CSSOM.CSSPageRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSPropertyRule.js

@@ -1,122 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.css-houdini.org/css-properties-values-api/#the-css-property-rule-interface
- */
-CSSOM.CSSPropertyRule = function CSSPropertyRule() {
-	CSSOM.CSSRule.call(this);
-	this.__name = "";
-	this.__syntax = "";
-	this.__inherits = false;
-	this.__initialValue = null;
-};
-
-CSSOM.CSSPropertyRule.prototype = Object.create(CSSOM.CSSRule.prototype);
-CSSOM.CSSPropertyRule.prototype.constructor = CSSOM.CSSPropertyRule;
-
-Object.setPrototypeOf(CSSOM.CSSPropertyRule, CSSOM.CSSRule);
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "type", {
-	value: 0,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "cssText", {
-	get: function() {
-		var text = "@property " + this.name + " {";
-		if (this.syntax !== "") {
-			text += " syntax: \"" + this.syntax.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + "\";";
-		}
-		text += " inherits: " + (this.inherits ? "true" : "false") + ";";
-		if (this.initialValue !== null) {
-			text += " initial-value: " + this.initialValue + ";";
-		}
-		text += " }";
-		return text;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "name", {
-	get: function() {
-		return this.__name;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "syntax", {
-	get: function() {
-		return this.__syntax;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "inherits", {
-	get: function() {
-		return this.__inherits;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "initialValue", {
-	get: function() {
-		return this.__initialValue;
-	}
-});
-
-/**
- * NON-STANDARD
- * Rule text parser.
- * @param {string} cssText
- * @returns {boolean} True if the rule is valid and was parsed successfully
- */
-Object.defineProperty(CSSOM.CSSPropertyRule.prototype, "parse", {
-	value: function(cssText) {
-		// Extract the name from "@property <name> { ... }"
-		var match = cssText.match(/@property\s+(--[^\s{]+)\s*\{([^]*)\}/);
-		if (!match) {
-			return false;
-		}
-		
-		this.__name = match[1];
-		var bodyText = match[2];
-		
-		// Parse syntax descriptor (REQUIRED)
-		var syntaxMatch = bodyText.match(/syntax\s*:\s*(['"])([^]*?)\1\s*;/);
-		if (!syntaxMatch) {
-			return false; // syntax is required
-		}
-		this.__syntax = syntaxMatch[2];
-		
-		// Syntax cannot be empty
-		if (this.__syntax === "") {
-			return false;
-		}
-		
-		// Parse inherits descriptor (REQUIRED)
-		var inheritsMatch = bodyText.match(/inherits\s*:\s*(true|false)\s*;/);
-		if (!inheritsMatch) {
-			return false; // inherits is required
-		}
-		this.__inherits = inheritsMatch[1] === "true";
-		
-		// Parse initial-value descriptor (OPTIONAL, but required if syntax is not "*")
-		var initialValueMatch = bodyText.match(/initial-value\s*:\s*([^;]+);/);
-		if (initialValueMatch) {
-			this.__initialValue = initialValueMatch[1].trim();
-		} else {
-			// If syntax is not "*", initial-value is required
-			if (this.__syntax !== "*") {
-				return false;
-			}
-		}
-		
-		return true; // Successfully parsed
-	}
-});
-
-//.CommonJS
-exports.CSSPropertyRule = CSSOM.CSSPropertyRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSRule.js

@@ -1,92 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-///CommonJS
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#the-cssrule-interface
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSRule
- */
-CSSOM.CSSRule = function CSSRule() {
-  this.__parentRule = null;
-  this.__parentStyleSheet = null;
-};
-
-CSSOM.CSSRule.UNKNOWN_RULE = 0; // obsolete
-CSSOM.CSSRule.STYLE_RULE = 1;
-CSSOM.CSSRule.CHARSET_RULE = 2; // obsolete
-CSSOM.CSSRule.IMPORT_RULE = 3;
-CSSOM.CSSRule.MEDIA_RULE = 4;
-CSSOM.CSSRule.FONT_FACE_RULE = 5;
-CSSOM.CSSRule.PAGE_RULE = 6;
-CSSOM.CSSRule.KEYFRAMES_RULE = 7;
-CSSOM.CSSRule.KEYFRAME_RULE = 8;
-CSSOM.CSSRule.MARGIN_RULE = 9;
-CSSOM.CSSRule.NAMESPACE_RULE = 10;
-CSSOM.CSSRule.COUNTER_STYLE_RULE = 11;
-CSSOM.CSSRule.SUPPORTS_RULE = 12;
-CSSOM.CSSRule.DOCUMENT_RULE = 13;
-CSSOM.CSSRule.FONT_FEATURE_VALUES_RULE = 14;
-CSSOM.CSSRule.VIEWPORT_RULE = 15;
-CSSOM.CSSRule.REGION_STYLE_RULE = 16;
-CSSOM.CSSRule.CONTAINER_RULE = 17;
-CSSOM.CSSRule.LAYER_BLOCK_RULE = 18;
-CSSOM.CSSRule.STARTING_STYLE_RULE = 1002;
-
-Object.defineProperties(CSSOM.CSSRule.prototype, {
-
-  constructor: { value: CSSOM.CSSRule },
-
-  cssRule: {
-    value: "",
-    configurable: true,
-    enumerable: true
-  },
-
-  cssText: {
-    get: function() {
-      // Default getter: subclasses should override this
-      return "";
-    },
-    set: function(cssText) {
-      return cssText;
-    }
-  },
-
-  parentRule: {
-    get: function() {
-      return this.__parentRule
-    }
-  },
-
-  parentStyleSheet: {
-    get: function() {
-      return this.__parentStyleSheet
-    }
-  },
-  
-  UNKNOWN_RULE: { value: 0, enumerable: true }, // obsolet
-  STYLE_RULE: { value: 1, enumerable: true },
-  CHARSET_RULE: { value: 2, enumerable: true }, // obsolet
-  IMPORT_RULE: { value: 3, enumerable: true },
-  MEDIA_RULE: { value: 4, enumerable: true },
-  FONT_FACE_RULE: { value: 5, enumerable: true },
-  PAGE_RULE: { value: 6, enumerable: true },
-  KEYFRAMES_RULE: { value: 7, enumerable: true },
-  KEYFRAME_RULE: { value: 8, enumerable: true },
-  MARGIN_RULE: { value: 9, enumerable: true },
-  NAMESPACE_RULE: { value: 10, enumerable: true },
-  COUNTER_STYLE_RULE: { value: 11, enumerable: true },
-  SUPPORTS_RULE: { value: 12, enumerable: true },
-  DOCUMENT_RULE: { value: 13, enumerable: true },
-  FONT_FEATURE_VALUES_RULE: { value: 14, enumerable: true },
-  VIEWPORT_RULE: { value: 15, enumerable: true },
-  REGION_STYLE_RULE: { value: 16, enumerable: true },
-  CONTAINER_RULE: { value: 17, enumerable: true },
-  LAYER_BLOCK_RULE: { value: 18, enumerable: true },
-  STARTING_STYLE_RULE: { value: 1002, enumerable: true },
-});
-
-//.CommonJS
-exports.CSSRule = CSSOM.CSSRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSRuleList.js

@@ -1,26 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/cssom/#the-cssrulelist-interface
- */
-CSSOM.CSSRuleList = function CSSRuleList(){
-  var arr = new Array();
-  Object.setPrototypeOf(arr, CSSOM.CSSRuleList.prototype);
-  return arr;
-};
-
-CSSOM.CSSRuleList.prototype = Object.create(Array.prototype);
-CSSOM.CSSRuleList.prototype.constructor = CSSOM.CSSRuleList;
-
-CSSOM.CSSRuleList.prototype.item = function(index) {
-    return this[index] || null;
-};
-
-
-//.CommonJS
-exports.CSSRuleList = CSSOM.CSSRuleList;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSScopeRule.js

@@ -1,61 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-  CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-};
-///CommonJS
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-cascade-6/#cssscoperule
- */
-CSSOM.CSSScopeRule = function CSSScopeRule() {
-  CSSOM.CSSGroupingRule.call(this);
-  this.__start = null;
-  this.__end = null;
-};
-
-CSSOM.CSSScopeRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSScopeRule.prototype.constructor = CSSOM.CSSScopeRule;
-
-Object.setPrototypeOf(CSSOM.CSSScopeRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperties(CSSOM.CSSScopeRule.prototype, {
-  type: {
-    value: 0,
-    writable: false,
-  },
-  cssText: {
-    get: function () {
-			var values = "";
-			var valuesArr = [" {"];
-      if (this.cssRules.length) {
-        valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-          if (rule.cssText !== "") {
-            acc.push(rule.cssText);
-          }
-          return acc;
-        }, []).join("\n  "));
-      }
-      values = valuesArr.join("\n  ") + "\n}";
-      return "@scope" + (this.start ? " (" + this.start + ")" : "") + (this.end ? " to (" + this.end + ")" : "") + values;
-    },
-    configurable: true,
-    enumerable: true,
-  },
-  start: {
-    get: function () {
-      return this.__start;
-    }
-  },
-  end: {
-    get: function () {
-      return this.__end;
-    }
-  }
-});
-
-//.CommonJS
-exports.CSSScopeRule = CSSOM.CSSScopeRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSStartingStyleRule.js

@@ -1,52 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/shadow-dom/#host-at-rule
- */
-CSSOM.CSSStartingStyleRule = function CSSStartingStyleRule() {
-	CSSOM.CSSGroupingRule.call(this);
-};
-
-CSSOM.CSSStartingStyleRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSStartingStyleRule.prototype.constructor = CSSOM.CSSStartingStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSStartingStyleRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSStartingStyleRule.prototype, "type", {
-	value: 1002,
-	writable: false
-});
-
-//FIXME
-//CSSOM.CSSStartingStyleRule.prototype.insertRule = CSSStyleSheet.prototype.insertRule;
-//CSSOM.CSSStartingStyleRule.prototype.deleteRule = CSSStyleSheet.prototype.deleteRule;
-
-Object.defineProperty(CSSOM.CSSStartingStyleRule.prototype, "cssText", {
-	get: function() {
-		var values = "";
-		var valuesArr = [" {"];
-		if (this.cssRules.length) {
-			valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-			if (rule.cssText !== "") {
-				acc.push(rule.cssText);
-			}
-			return acc;
-			}, []).join("\n  "));
-		}
-		values = valuesArr.join("\n  ") + "\n}";
-		return "@starting-style" + values;
-	}
-});
-
-
-//.CommonJS
-exports.CSSStartingStyleRule = CSSOM.CSSStartingStyleRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSStyleDeclaration.js

@@ -1,164 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-var regexPatterns = require("./regexPatterns").regexPatterns;
-///CommonJS
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration
- */
-CSSOM.CSSStyleDeclaration = function CSSStyleDeclaration(){
-	this.length = 0;
-	this.parentRule = null;
-
-	// NON-STANDARD
-	this._importants = {};
-};
-
-
-CSSOM.CSSStyleDeclaration.prototype = {
-
-	constructor: CSSOM.CSSStyleDeclaration,
-
-	/**
-	 *
-	 * @param {string} name
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-getPropertyValue
-	 * @return {string} the value of the property if it has been explicitly set for this declaration block.
-	 * Returns the empty string if the property has not been set.
-	 */
-	getPropertyValue: function(name) {
-		return this[name] || "";
-	},
-
-	/**
-	 *
-	 * @param {string} name
-	 * @param {string} value
-	 * @param {string} [priority=null] "important" or null
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-setProperty
-	 */
-	setProperty: function(name, value, priority, parseErrorHandler) 
-	{
-		// NOTE: Check viability to add a validation for css values or use a dependency like csstree-validator
-		var basicStylePropertyValueValidationRegExp = regexPatterns.basicStylePropertyValueValidationRegExp
-		if (basicStylePropertyValueValidationRegExp.test(value)) {
-			parseErrorHandler && parseErrorHandler('Invalid CSSStyleDeclaration property (name = "' + name + '", value = "' + value + '")');
-		} else if (this[name]) {
-			// Property already exist. Overwrite it.
-			var index = Array.prototype.indexOf.call(this, name);
-			if (index < 0) {
-				this[this.length] = name;
-				this.length++;
-			}
-	
-			// If the priority value of the incoming property is "important",
-			// or the value of the existing property is not "important", 
-			// then remove the existing property and rewrite it.
-			if (priority || !this._importants[name]) {
-				this.removeProperty(name);
-				this[this.length] = name;
-				this.length++;
-				this[name] = value + '';
-				this._importants[name] = priority;
-			}
-		} else {
-			// New property.
-			this[this.length] = name;
-			this.length++;
-			this[name] = value + '';
-			this._importants[name] = priority;
-		}
-	},
-
-	/**
-	 *
-	 * @param {string} name
-	 * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-removeProperty
-	 * @return {string} the value of the property if it has been explicitly set for this declaration block.
-	 * Returns the empty string if the property has not been set or the property name does not correspond to a known CSS property.
-	 */
-	removeProperty: function(name) {
-		if (!(name in this)) {
-			return "";
-		}
-		var index = Array.prototype.indexOf.call(this, name);
-		if (index < 0) {
-			return "";
-		}
-		var prevValue = this[name];
-		this[name] = "";
-
-		// That's what WebKit and Opera do
-		Array.prototype.splice.call(this, index, 1);
-
-		// That's what Firefox does
-		//this[index] = ""
-
-		return prevValue;
-	},
-
-	getPropertyCSSValue: function() {
-		//FIXME
-	},
-
-	/**
-	 *
-	 * @param {String} name
-	 */
-	getPropertyPriority: function(name) {
-		return this._importants[name] || "";
-	},
-
-
-	/**
-	 *   element.style.overflow = "auto"
-	 *   element.style.getPropertyShorthand("overflow-x")
-	 *   -> "overflow"
-	 */
-	getPropertyShorthand: function() {
-		//FIXME
-	},
-
-	isPropertyImplicit: function() {
-		//FIXME
-	},
-
-	// Doesn't work in IE < 9
-	get cssText(){
-		var properties = [];
-		for (var i=0, length=this.length; i < length; ++i) {
-			var name = this[i];
-			var value = this.getPropertyValue(name);
-			var priority = this.getPropertyPriority(name);
-			if (priority) {
-				priority = " !" + priority;
-			}
-			properties[i] = name + ": " + value + priority + ";";
-		}
-		return properties.join(" ");
-	},
-
-	set cssText(text){
-		var i, name;
-		for (i = this.length; i--;) {
-			name = this[i];
-			this[name] = "";
-		}
-		Array.prototype.splice.call(this, 0, this.length);
-		this._importants = {};
-
-		var dummyRule = CSSOM.parse('#bogus{' + text + '}').cssRules[0].style;
-		var length = dummyRule.length;
-		for (i = 0; i < length; ++i) {
-			name = dummyRule[i];
-			this.setProperty(dummyRule[i], dummyRule.getPropertyValue(name), dummyRule.getPropertyPriority(name));
-		}
-	}
-};
-
-
-//.CommonJS
-exports.CSSStyleDeclaration = CSSOM.CSSStyleDeclaration;
-CSSOM.parse = require('./parse').parse; // Cannot be included sooner due to the mutual dependency between parse.js and CSSStyleDeclaration.js
-///CommonJS

node_modules/@acemir/cssom/lib/CSSStyleRule.js

@@ -1,109 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-};
-var regexPatterns = require("./regexPatterns").regexPatterns;
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#cssstylerule
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleRule
- */
-CSSOM.CSSStyleRule = function CSSStyleRule() {
-	CSSOM.CSSGroupingRule.call(this);
-	this.__selectorText = "";
-	this.__style = new CSSOM.CSSStyleDeclaration();
-	this.__style.parentRule = this;
-};
-
-CSSOM.CSSStyleRule.prototype = Object.create(CSSOM.CSSGroupingRule.prototype);
-CSSOM.CSSStyleRule.prototype.constructor = CSSOM.CSSStyleRule;
-
-Object.setPrototypeOf(CSSOM.CSSStyleRule, CSSOM.CSSGroupingRule);
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "type", {
-	value: 1,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "selectorText", {
-	get: function() {
-		return this.__selectorText;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			// Don't trim if the value ends with a hex escape sequence followed by space
-			// (e.g., ".\31 " where the space is part of the escape terminator)
-			var endsWithHexEscapeRegExp = regexPatterns.endsWithHexEscapeRegExp;
-			var endsWithEscape = endsWithHexEscapeRegExp.test(value);
-			var trimmedValue = endsWithEscape ? value.replace(/\s+$/, ' ').trimStart() : value.trim();
-
-			if (trimmedValue === '') {
-				return;
-			}
-
-			// TODO: Setting invalid selectorText should be ignored
-			// There are some validations already on lib/parse.js
-			// but the same validations should be applied here.
-			// Check if we can move these validation logic to a shared function.
-
-			this.__selectorText = trimmedValue;
-		}
-	},
-	configurable: true
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "style", {
-	get: function() {
-		return this.__style;	
-	},
-	set: function(value) {
-		if (typeof value === "string") {
-			this.__style.cssText = value;
-		} else {
-			this.__style = value;
-		}
-	},
-	configurable: true
-});
-
-Object.defineProperty(CSSOM.CSSStyleRule.prototype, "cssText", {
-	get: function() {
-		var text;
-		if (this.selectorText) {
-			var values = "";
-			if (this.cssRules.length) {
-				var valuesArr = [" {"];
-				this.style.cssText && valuesArr.push(this.style.cssText);
-				valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-					if (rule.cssText !== "") {
-						acc.push(rule.cssText);
-					}
-					return acc;
-				}, []).join("\n  "));
-				values = valuesArr.join("\n  ") + "\n}";
-			} else {
-				values = " {" + (this.style.cssText ? " " + this.style.cssText : "") + " }";
-			}
-			text = this.selectorText + values;
-		} else {
-			text = "";
-		}
-		return text;
-	}
-});
-
-//.CommonJS
-exports.CSSStyleRule = CSSOM.CSSStyleRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSStyleSheet.js

@@ -1,371 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	MediaList: require("./MediaList").MediaList,
-	StyleSheet: require("./StyleSheet").StyleSheet,
-	CSSRuleList: require("./CSSRuleList").CSSRuleList,
-	CSSStyleRule: require("./CSSStyleRule").CSSStyleRule,
-};
-var errorUtils = require("./errorUtils").errorUtils;
-///CommonJS
-
-
-/**
- * @constructor
- * @param {CSSStyleSheetInit} [opts] - CSSStyleSheetInit options.
- * @param {string} [opts.baseURL] - The base URL of the stylesheet.
- * @param {boolean} [opts.disabled] - The disabled attribute of the stylesheet.
- * @param {MediaList | string} [opts.media] - The media attribute of the stylesheet.
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet
- */
-CSSOM.CSSStyleSheet = function CSSStyleSheet(opts) {
-	CSSOM.StyleSheet.call(this);
-	this.__constructed = true;
-	this.__cssRules = new CSSOM.CSSRuleList();
-	this.__ownerRule = null; 
-
-	if (opts && typeof opts === "object") {
-		if (opts.baseURL && typeof opts.baseURL === "string") {
-			this.__baseURL = opts.baseURL;
-		}
-		if (opts.media && typeof opts.media === "string") {
-			this.media.mediaText = opts.media;
-		}
-		if (typeof opts.disabled === "boolean") {
-			this.disabled = opts.disabled;
-		}
-	}
-};
-
-
-CSSOM.CSSStyleSheet.prototype = Object.create(CSSOM.StyleSheet.prototype);
-CSSOM.CSSStyleSheet.prototype.constructor = CSSOM.CSSStyleSheet;
-
-Object.setPrototypeOf(CSSOM.CSSStyleSheet, CSSOM.StyleSheet);
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "cssRules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "rules", {
-	get: function() {
-		return this.__cssRules;
-	}
-});
-
-Object.defineProperty(CSSOM.CSSStyleSheet.prototype, "ownerRule", {
-	get: function() {
-		return this.__ownerRule;
-	}
-});
-
-/**
- * Used to insert a new rule into the style sheet. The new rule now becomes part of the cascade.
- *
- *   sheet = new Sheet("body {margin: 0}")
- *   sheet.toString()
- *   -> "body{margin:0;}"
- *   sheet.insertRule("img {border: none}", 0)
- *   -> 0
- *   sheet.toString()
- *   -> "img{border:none;}body{margin:0;}"
- *
- * @param {string} rule
- * @param {number} [index=0]
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-insertRule
- * @return {number} The index within the style sheet's rule collection of the newly inserted rule.
- */
-CSSOM.CSSStyleSheet.prototype.insertRule = function(rule, index) {
-	if (rule === undefined && index === undefined) {
-		errorUtils.throwMissingArguments(this, 'insertRule', this.constructor.name);
-	}
-	if (index === void 0) {
-		index = 0;
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index > this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'insertRule', this.constructor.name, index, this.cssRules.length);
-	}
-	
-	var ruleToParse = String(rule);
-	var parseErrors = [];
-	var parsedSheet = CSSOM.parse(ruleToParse, undefined, function(err) {
-		parseErrors.push(err);
-	} );
-	if (parsedSheet.cssRules.length !== 1) {
-		errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-	}
-	var cssRule = parsedSheet.cssRules[0];
-	
-	// Helper function to find the last index of a specific rule constructor
-	function findLastIndexOfConstructor(rules, constructorName) {
-		for (var i = rules.length - 1; i >= 0; i--) {
-			if (rules[i].constructor.name === constructorName) {
-				return i;
-			}
-		}
-		return -1;
-	}
-	
-	// Helper function to find the first index of a rule that's NOT of specified constructors
-	function findFirstNonConstructorIndex(rules, constructorNames) {
-		for (var i = 0; i < rules.length; i++) {
-			if (constructorNames.indexOf(rules[i].constructor.name) === -1) {
-				return i;
-			}
-		}
-		return rules.length;
-	}
-	
-	// Validate rule ordering based on CSS specification
-	if (cssRule.constructor.name === 'CSSImportRule') {
-		if (this.__constructed === true) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Can't insert @import rules into a constructed stylesheet.",
-				'SyntaxError');
-		}
-		// @import rules cannot be inserted after @layer rules that already exist
-		// They can only be inserted at the beginning or after other @import rules
-		var firstLayerIndex = findFirstNonConstructorIndex(this.cssRules, ['CSSImportRule']);
-		if (firstLayerIndex < this.cssRules.length && this.cssRules[firstLayerIndex].constructor.name === 'CSSLayerStatementRule' && index > firstLayerIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-		
-		// Also cannot insert after @namespace or other rules
-		var firstNonImportIndex = findFirstNonConstructorIndex(this.cssRules, ['CSSImportRule']);
-		if (index > firstNonImportIndex && firstNonImportIndex < this.cssRules.length && 
-		    this.cssRules[firstNonImportIndex].constructor.name !== 'CSSLayerStatementRule') {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-	} else if (cssRule.constructor.name === 'CSSNamespaceRule') {
-		// @namespace rules can come after @layer and @import, but before any other rules
-		// They cannot come before @import rules
-		var firstImportIndex = -1;
-		for (var i = 0; i < this.cssRules.length; i++) {
-			if (this.cssRules[i].constructor.name === 'CSSImportRule') {
-				firstImportIndex = i;
-				break;
-			}
-		}
-		var firstNonImportNamespaceIndex = findFirstNonConstructorIndex(this.cssRules, [
-			'CSSLayerStatementRule', 
-			'CSSImportRule', 
-			'CSSNamespaceRule'
-		]);
-		
-		// Cannot insert before @import rules
-		if (firstImportIndex !== -1 && index <= firstImportIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-		
-		// Cannot insert if there are already non-special rules
-		if (firstNonImportNamespaceIndex < this.cssRules.length) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'InvalidStateError');
-		}
-		
-		// Cannot insert after other types of rules
-		if (index > firstNonImportNamespaceIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-
-		
-	} else if (cssRule.constructor.name === 'CSSLayerStatementRule') {
-		// @layer statement rules can be inserted anywhere before @import and @namespace
-		// No additional restrictions beyond what's already handled
-	} else {
-		// Any other rule cannot be inserted before @import and @namespace
-		var firstNonSpecialRuleIndex = findFirstNonConstructorIndex(this.cssRules, [
-			'CSSLayerStatementRule',
-			'CSSImportRule',
-			'CSSNamespaceRule'
-		]);
-		
-		if (index < firstNonSpecialRuleIndex) {
-			errorUtils.throwError(this, 'DOMException',
-				"Failed to execute 'insertRule' on '" + this.constructor.name + "': Failed to insert the rule.",
-				'HierarchyRequestError');
-		}
-
-		if (parseErrors.filter(function(error) { return !error.isNested; }).length !== 0) {
-			errorUtils.throwParseError(this, 'insertRule', this.constructor.name, ruleToParse, 'SyntaxError');
-		}
-	}
-	
-	cssRule.__parentStyleSheet = this;
-	this.cssRules.splice(index, 0, cssRule);
-	return index;
-};
-
-CSSOM.CSSStyleSheet.prototype.addRule = function(selector, styleBlock, index) {
-	if (index === void 0) {
-		index = this.cssRules.length;
-	}
-	this.insertRule(selector + "{" + styleBlock + "}", index);
-	return -1;
-};
-
-/**
- * Used to delete a rule from the style sheet.
- *
- *   sheet = new Sheet("img{border:none} body{margin:0}")
- *   sheet.toString()
- *   -> "img{border:none;}body{margin:0;}"
- *   sheet.deleteRule(0)
- *   sheet.toString()
- *   -> "body{margin:0;}"
- *
- * @param {number} index within the style sheet's rule list of the rule to remove.
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleSheet-deleteRule
- */
-CSSOM.CSSStyleSheet.prototype.deleteRule = function(index) {
-	if (index === undefined) {
-		errorUtils.throwMissingArguments(this, 'deleteRule', this.constructor.name);
-	}
-	index = Number(index);
-	if (index < 0) {
-		index = 4294967296 + index;
-	}
-	if (index >= this.cssRules.length) {
-		errorUtils.throwIndexError(this, 'deleteRule', this.constructor.name, index, this.cssRules.length);
-	}
-	if (this.cssRules[index]) {		
-		if (this.cssRules[index].constructor.name == "CSSNamespaceRule") {
-			var shouldContinue = this.cssRules.every(function (rule) {
-				return ['CSSImportRule','CSSLayerStatementRule','CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
-			});
-			if (!shouldContinue) {
-				errorUtils.throwError(this, 'DOMException', "Failed to execute 'deleteRule' on '" + this.constructor.name + "': Failed to delete rule.", "InvalidStateError");
-			}
-		}
-		if (this.cssRules[index].constructor.name == "CSSImportRule") {
-			this.cssRules[index].styleSheet.__parentStyleSheet = null;
-		}
-
-		this.cssRules[index].__parentStyleSheet = null;
-	}
-	this.cssRules.splice(index, 1);
-};
-
-CSSOM.CSSStyleSheet.prototype.removeRule = function(index) {
-	if (index === void 0) {
-		index = 0;
-	}
-	this.deleteRule(index);
-};
-
-
-/**
- * Replaces the rules of a {@link CSSStyleSheet}
- * 
- * @returns a promise
- * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replace
- */
-CSSOM.CSSStyleSheet.prototype.replace = function(text) {
-	var _Promise;
-	if (this.__globalObject && this.__globalObject['Promise']) {
-		_Promise = this.__globalObject['Promise'];
-	} else {
-		_Promise = Promise;
-	}
-	var _setTimeout;
-	if (this.__globalObject && this.__globalObject['setTimeout']) {
-		_setTimeout = this.__globalObject['setTimeout'];
-	} else {
-		_setTimeout = setTimeout;
-	}
-	var sheet = this;
-	return new _Promise(function (resolve, reject) {
-		// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
-		if (!sheet.__constructed || sheet.__disallowModification) {
-			reject(errorUtils.createError(sheet, 'DOMException',
-				"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
-				'NotAllowedError'));
-		}
-		// Set the disallow modification flag.
-		sheet.__disallowModification = true;
-
-		// In parallel, do these steps:
-		_setTimeout(function() {
-			// Let rules be the result of running parse a stylesheet's contents from text.
-			var rules = new CSSOM.CSSRuleList();
-			CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
-			// If rules contains one or more @import rules, remove those rules from rules.
-			var i = 0;
-			while (i < rules.length) {
-				if (rules[i].constructor.name === 'CSSImportRule') {
-					rules.splice(i, 1);
-				} else {
-					i++;
-				}
-			}
-			// Set sheet's CSS rules to rules.
-			sheet.__cssRules.splice.apply(sheet.__cssRules, [0, sheet.__cssRules.length].concat(rules));
-			// Unset sheet’s disallow modification flag.
-			delete sheet.__disallowModification;
-			// Resolve promise with sheet.
-			resolve(sheet);
-		})
-	});
-}
-
-/**
- * Synchronously replaces the rules of a {@link CSSStyleSheet}
- * 
- * @see https://www.w3.org/TR/cssom-1/#dom-cssstylesheet-replacesync
- */
-CSSOM.CSSStyleSheet.prototype.replaceSync = function(text) {
-	var sheet = this;
-	// If the constructed flag is not set, or the disallow modification flag is set, throw a NotAllowedError DOMException.
-	if (!sheet.__constructed || sheet.__disallowModification) {
-		errorUtils.throwError(sheet, 'DOMException',
-			"Failed to execute 'replaceSync' on '" + sheet.constructor.name + "': Not allowed.",
-			'NotAllowedError');
-	}
-	// Let rules be the result of running parse a stylesheet's contents from text.
-	var rules = new CSSOM.CSSRuleList();
-	CSSOM.parse(text, { styleSheet: sheet, cssRules: rules });
-	// If rules contains one or more @import rules, remove those rules from rules.
-	var i = 0;
-	while (i < rules.length) {
-		if (rules[i].constructor.name === 'CSSImportRule') {
-			rules.splice(i, 1);
-		} else {
-			i++;
-		}
-	}
-	// Set sheet's CSS rules to rules.
-	sheet.__cssRules.splice.apply(sheet.__cssRules, [0, sheet.__cssRules.length].concat(rules));
-}
-
-/**
- * NON-STANDARD
- * @return {string} serialize stylesheet
- */
-CSSOM.CSSStyleSheet.prototype.toString = function() {
-	var result = "";
-	var rules = this.cssRules;
-	for (var i=0; i<rules.length; i++) {
-		result += rules[i].cssText + "\n";
-	}
-	return result;
-};
-
-
-//.CommonJS
-exports.CSSStyleSheet = CSSOM.CSSStyleSheet;
-CSSOM.parse = require('./parse').parse; // Cannot be included sooner due to the mutual dependency between parse.js and CSSStyleSheet.js
-///CommonJS

node_modules/@acemir/cssom/lib/CSSSupportsRule.js

@@ -1,48 +0,0 @@
-//.CommonJS
-var CSSOM = {
-  CSSRule: require("./CSSRule").CSSRule,
-  CSSRuleList: require("./CSSRuleList").CSSRuleList,
-  CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-  CSSConditionRule: require("./CSSConditionRule").CSSConditionRule
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://drafts.csswg.org/css-conditional-3/#the-csssupportsrule-interface
- */
-CSSOM.CSSSupportsRule = function CSSSupportsRule() {
-  CSSOM.CSSConditionRule.call(this);
-};
-
-CSSOM.CSSSupportsRule.prototype = Object.create(CSSOM.CSSConditionRule.prototype);
-CSSOM.CSSSupportsRule.prototype.constructor = CSSOM.CSSSupportsRule;
-  
-Object.setPrototypeOf(CSSOM.CSSSupportsRule, CSSOM.CSSConditionRule);
-
-Object.defineProperty(CSSOM.CSSSupportsRule.prototype, "type", {
-	value: 12,
-	writable: false
-});
-
-Object.defineProperty(CSSOM.CSSSupportsRule.prototype, "cssText", {
-  get: function() {
-    var values = "";
-    var valuesArr = [" {"];
-    if (this.cssRules.length) {
-      valuesArr.push(this.cssRules.reduce(function(acc, rule){ 
-        if (rule.cssText !== "") {
-          acc.push(rule.cssText);
-        }
-        return acc;
-      }, []).join("\n  "));
-    }
-    values = valuesArr.join("\n  ") + "\n}";
-    return "@supports " + this.conditionText + values;
-  }
-});
-
-//.CommonJS
-exports.CSSSupportsRule = CSSOM.CSSSupportsRule;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSValue.js

@@ -1,43 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSValue
- *
- * TODO: add if needed
- */
-CSSOM.CSSValue = function CSSValue() {
-};
-
-CSSOM.CSSValue.prototype = {
-	constructor: CSSOM.CSSValue,
-
-	// @see: http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSValue
-	set cssText(text) {
-		var name = this._getConstructorName();
-
-		throw new Error('DOMException: property "cssText" of "' + name + '" is readonly and can not be replaced with "' + text + '"!');
-	},
-
-	get cssText() {
-		var name = this._getConstructorName();
-
-		throw new Error('getter "cssText" of "' + name + '" is not implemented!');
-	},
-
-	_getConstructorName: function() {
-		var s = this.constructor.toString(),
-				c = s.match(/function\s([^\(]+)/),
-				name = c[1];
-
-		return name;
-	}
-};
-
-
-//.CommonJS
-exports.CSSValue = CSSOM.CSSValue;
-///CommonJS

node_modules/@acemir/cssom/lib/CSSValueExpression.js

@@ -1,346 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSValue: require('./CSSValue').CSSValue
-};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://msdn.microsoft.com/en-us/library/ms537634(v=vs.85).aspx
- *
- */
-CSSOM.CSSValueExpression = function CSSValueExpression(token, idx) {
-	this._token = token;
-	this._idx = idx;
-};
-
-CSSOM.CSSValueExpression.prototype = Object.create(CSSOM.CSSValue.prototype);
-CSSOM.CSSValueExpression.prototype.constructor = CSSOM.CSSValueExpression;
-
-Object.setPrototypeOf(CSSOM.CSSValueExpression, CSSOM.CSSValue);
-
-/**
- * parse css expression() value
- *
- * @return {Object}
- *         - error:
- *         or
- *         - idx:
- *         - expression:
- *
- * Example:
- *
- * .selector {
- *		zoom: expression(documentElement.clientWidth > 1000 ? '1000px' : 'auto');
- * }
- */
-CSSOM.CSSValueExpression.prototype.parse = function() {
-	var token = this._token,
-			idx = this._idx;
-
-	var character = '',
-			expression = '',
-			error = '',
-			info,
-			paren = [];
-
-
-	for (; ; ++idx) {
-		character = token.charAt(idx);
-
-		// end of token
-		if (character === '') {
-			error = 'css expression error: unfinished expression!';
-			break;
-		}
-
-		switch(character) {
-			case '(':
-				paren.push(character);
-				expression += character;
-				break;
-
-			case ')':
-				paren.pop(character);
-				expression += character;
-				break;
-
-			case '/':
-				if ((info = this._parseJSComment(token, idx))) { // comment?
-					if (info.error) {
-						error = 'css expression error: unfinished comment in expression!';
-					} else {
-						idx = info.idx;
-						// ignore the comment
-					}
-				} else if ((info = this._parseJSRexExp(token, idx))) { // regexp
-					idx = info.idx;
-					expression += info.text;
-				} else { // other
-					expression += character;
-				}
-				break;
-
-			case "'":
-			case '"':
-				info = this._parseJSString(token, idx, character);
-				if (info) { // string
-					idx = info.idx;
-					expression += info.text;
-				} else {
-					expression += character;
-				}
-				break;
-
-			default:
-				expression += character;
-				break;
-		}
-
-		if (error) {
-			break;
-		}
-
-		// end of expression
-		if (paren.length === 0) {
-			break;
-		}
-	}
-
-	var ret;
-	if (error) {
-		ret = {
-			error: error
-		};
-	} else {
-		ret = {
-			idx: idx,
-			expression: expression
-		};
-	}
-
-	return ret;
-};
-
-
-/**
- *
- * @return {Object|false}
- *          - idx:
- *          - text:
- *          or
- *          - error:
- *          or
- *          false
- *
- */
-CSSOM.CSSValueExpression.prototype._parseJSComment = function(token, idx) {
-	var nextChar = token.charAt(idx + 1),
-			text;
-
-	if (nextChar === '/' || nextChar === '*') {
-		var startIdx = idx,
-				endIdx,
-				commentEndChar;
-
-		if (nextChar === '/') { // line comment
-			commentEndChar = '\n';
-		} else if (nextChar === '*') { // block comment
-			commentEndChar = '*/';
-		}
-
-		endIdx = token.indexOf(commentEndChar, startIdx + 1 + 1);
-		if (endIdx !== -1) {
-			endIdx = endIdx + commentEndChar.length - 1;
-			text = token.substring(idx, endIdx + 1);
-			return {
-				idx: endIdx,
-				text: text
-			};
-		} else {
-			var error = 'css expression error: unfinished comment in expression!';
-			return {
-				error: error
-			};
-		}
-	} else {
-		return false;
-	}
-};
-
-
-/**
- *
- * @return {Object|false}
- *					- idx:
- *					- text:
- *					or 
- *					false
- *
- */
-CSSOM.CSSValueExpression.prototype._parseJSString = function(token, idx, sep) {
-	var endIdx = this._findMatchedIdx(token, idx, sep),
-			text;
-
-	if (endIdx === -1) {
-		return false;
-	} else {
-		text = token.substring(idx, endIdx + sep.length);
-
-		return {
-			idx: endIdx,
-			text: text
-		};
-	}
-};
-
-
-/**
- * parse regexp in css expression
- *
- * @return {Object|false}
- *				- idx:
- *				- regExp:
- *				or 
- *				false
- */
-
-/*
-
-all legal RegExp
- 
-/a/
-(/a/)
-[/a/]
-[12, /a/]
-
-!/a/
-
-+/a/
--/a/
-* /a/
-/ /a/
-%/a/
-
-===/a/
-!==/a/
-==/a/
-!=/a/
->/a/
->=/a/
-</a/
-<=/a/
-
-&/a/
-|/a/
-^/a/
-~/a/
-<</a/
->>/a/
->>>/a/
-
-&&/a/
-||/a/
-?/a/
-=/a/
-,/a/
-
-		delete /a/
-				in /a/
-instanceof /a/
-				new /a/
-		typeof /a/
-			void /a/
-
-*/
-CSSOM.CSSValueExpression.prototype._parseJSRexExp = function(token, idx) {
-	var before = token.substring(0, idx).replace(/\s+$/, ""),
-			legalRegx = [
-				/^$/,
-				/\($/,
-				/\[$/,
-				/\!$/,
-				/\+$/,
-				/\-$/,
-				/\*$/,
-				/\/\s+/,
-				/\%$/,
-				/\=$/,
-				/\>$/,
-				/<$/,
-				/\&$/,
-				/\|$/,
-				/\^$/,
-				/\~$/,
-				/\?$/,
-				/\,$/,
-				/delete$/,
-				/in$/,
-				/instanceof$/,
-				/new$/,
-				/typeof$/,
-				/void$/
-			];
-
-	var isLegal = legalRegx.some(function(reg) {
-		return reg.test(before);
-	});
-
-	if (!isLegal) {
-		return false;
-	} else {
-		var sep = '/';
-
-		// same logic as string
-		return this._parseJSString(token, idx, sep);
-	}
-};
-
-
-/**
- *
- * find next sep(same line) index in `token`
- *
- * @return {Number}
- *
- */
-CSSOM.CSSValueExpression.prototype._findMatchedIdx = function(token, idx, sep) {
-	var startIdx = idx,
-			endIdx;
-
-	var NOT_FOUND = -1;
-
-	while(true) {
-		endIdx = token.indexOf(sep, startIdx + 1);
-
-		if (endIdx === -1) { // not found
-			endIdx = NOT_FOUND;
-			break;
-		} else {
-			var text = token.substring(idx + 1, endIdx),
-					matched = text.match(/\\+$/);
-			if (!matched || matched[0] % 2 === 0) { // not escaped
-				break;
-			} else {
-				startIdx = endIdx;
-			}
-		}
-	}
-
-	// boundary must be in the same line(js sting or regexp)
-	var nextNewLineIdx = token.indexOf('\n', idx + 1);
-	if (nextNewLineIdx < endIdx) {
-		endIdx = NOT_FOUND;
-	}
-
-
-	return endIdx;
-};
-
-
-
-
-//.CommonJS
-exports.CSSValueExpression = CSSOM.CSSValueExpression;
-///CommonJS

node_modules/@acemir/cssom/lib/MatcherList.js

@@ -1,62 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-///CommonJS
-
-
-/**
- * @constructor
- * @see https://developer.mozilla.org/en/CSS/@-moz-document
- */
-CSSOM.MatcherList = function MatcherList(){
-    this.length = 0;
-};
-
-CSSOM.MatcherList.prototype = {
-
-    constructor: CSSOM.MatcherList,
-
-    /**
-     * @return {string}
-     */
-    get matcherText() {
-        return Array.prototype.join.call(this, ", ");
-    },
-
-    /**
-     * @param {string} value
-     */
-    set matcherText(value) {
-        // just a temporary solution, actually it may be wrong by just split the value with ',', because a url can include ','.
-        var values = value.split(",");
-        var length = this.length = values.length;
-        for (var i=0; i<length; i++) {
-            this[i] = values[i].trim();
-        }
-    },
-
-    /**
-     * @param {string} matcher
-     */
-    appendMatcher: function(matcher) {
-        if (Array.prototype.indexOf.call(this, matcher) === -1) {
-            this[this.length] = matcher;
-            this.length++;
-        }
-    },
-
-    /**
-     * @param {string} matcher
-     */
-    deleteMatcher: function(matcher) {
-        var index = Array.prototype.indexOf.call(this, matcher);
-        if (index !== -1) {
-            Array.prototype.splice.call(this, index, 1);
-        }
-    }
-
-};
-
-
-//.CommonJS
-exports.MatcherList = CSSOM.MatcherList;
-///CommonJS

node_modules/@acemir/cssom/lib/MediaList.js

@@ -1,78 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-///CommonJS
-
-
-/**
- * @constructor
- * @see http://dev.w3.org/csswg/cssom/#the-medialist-interface
- */
-CSSOM.MediaList = function MediaList(){
-	this.length = 0;
-};
-
-CSSOM.MediaList.prototype = {
-
-	constructor: CSSOM.MediaList,
-
-	/**
-	 * @return {string}
-	 */
-	get mediaText() {
-		return Array.prototype.join.call(this, ", ");
-	},
-
-	/**
-	 * @param {string} value
-	 */
-	set mediaText(value) {
-		if (typeof value === "string") {
-			var values = value.split(",").filter(function(text){
-				return !!text;
-			});
-			var length = this.length = values.length;
-			for (var i=0; i<length; i++) {
-				this[i] = values[i].trim();
-			}
-		} else if (value === null) {
-			var length = this.length;
-			for (var i = 0; i < length; i++) {
-				delete this[i];
-			}
-			this.length = 0;
-		}
-	},
-
-	/**
-	 * @param {string} medium
-	 */
-	appendMedium: function(medium) {
-		if (Array.prototype.indexOf.call(this, medium) === -1) {
-			this[this.length] = medium;
-			this.length++;
-		}
-	},
-
-	/**
-	 * @param {string} medium
-	 */
-	deleteMedium: function(medium) {
-		var index = Array.prototype.indexOf.call(this, medium);
-		if (index !== -1) {
-			Array.prototype.splice.call(this, index, 1);
-		}
-	},
-
-	item: function(index) {
-		return this[index] || null;
-	},
-
-	toString: function() {
-		return this.mediaText;
-	}
-};
-
-
-//.CommonJS
-exports.MediaList = CSSOM.MediaList;
-///CommonJS

node_modules/@acemir/cssom/lib/StyleSheet.js

@@ -1,62 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	MediaList: require("./MediaList").MediaList
-};
-///CommonJS
-
-
-/**
- * @see http://dev.w3.org/csswg/cssom/#the-stylesheet-interface
- */
-CSSOM.StyleSheet = function StyleSheet() {
-	this.__href = null;
-	this.__ownerNode = null;
-	this.__title = null;
-	this.__media = new CSSOM.MediaList();
-	this.__parentStyleSheet = null;
-	this.disabled = false;
-};
-
-Object.defineProperties(CSSOM.StyleSheet.prototype, {
-	type: {
-		get: function() {
-			return "text/css";
-		}
-	},
-	href: {
-		get: function() {
-			return this.__href;
-		}
-	},
-	ownerNode: {
-		get: function() {
-			return this.__ownerNode;
-		}
-	},
-	title: {
-		get: function() {
-			return this.__title;
-		}
-	},
-	media: {
-		get: function() {
-			return this.__media;
-		},
-		set: function(value) {
-			if (typeof value === "string") {
-				this.__media.mediaText = value;
-			} else {
-				this.__media = value;
-			}
-		}
-	},
-	parentStyleSheet: {
-		get: function() {
-			return this.__parentStyleSheet;
-		}
-	}
-});
-
-//.CommonJS
-exports.StyleSheet = CSSOM.StyleSheet;
-///CommonJS

node_modules/@acemir/cssom/lib/clone.js

@@ -1,105 +0,0 @@
-//.CommonJS
-var CSSOM = {
-	CSSStyleSheet: require("./CSSStyleSheet").CSSStyleSheet,
-	CSSRule: require("./CSSRule").CSSRule,
-	CSSNestedDeclarations: require("./CSSNestedDeclarations").CSSNestedDeclarations,
-	CSSStyleRule: require("./CSSStyleRule").CSSStyleRule,
-	CSSGroupingRule: require("./CSSGroupingRule").CSSGroupingRule,
-	CSSConditionRule: require("./CSSConditionRule").CSSConditionRule,
-	CSSMediaRule: require("./CSSMediaRule").CSSMediaRule,
-	CSSContainerRule: require("./CSSContainerRule").CSSContainerRule,
-	CSSSupportsRule: require("./CSSSupportsRule").CSSSupportsRule,
-	CSSStyleDeclaration: require("./CSSStyleDeclaration").CSSStyleDeclaration,
-	CSSKeyframeRule: require('./CSSKeyframeRule').CSSKeyframeRule,
-	CSSKeyframesRule: require('./CSSKeyframesRule').CSSKeyframesRule,
-	CSSScopeRule: require('./CSSScopeRule').CSSScopeRule,
-	CSSLayerBlockRule: require('./CSSLayerBlockRule').CSSLayerBlockRule,
-	CSSLayerStatementRule: require('./CSSLayerStatementRule').CSSLayerStatementRule
-};
-// Use cssstyle if available
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}
-///CommonJS
-
-
-/**
- * Produces a deep copy of stylesheet — the instance variables of stylesheet are copied recursively.
- * @param {CSSStyleSheet|CSSOM.CSSStyleSheet} stylesheet
- * @nosideeffects
- * @return {CSSOM.CSSStyleSheet}
- */
-CSSOM.clone = function clone(stylesheet) {
-
-	var cloned = new CSSOM.CSSStyleSheet();
-
-	var rules = stylesheet.cssRules;
-	if (!rules) {
-		return cloned;
-	}
-
-	for (var i = 0, rulesLength = rules.length; i < rulesLength; i++) {
-		var rule = rules[i];
-		var ruleClone = cloned.cssRules[i] = new rule.constructor();
-
-		var style = rule.style;
-		if (style) {
-			var styleClone = ruleClone.style = new CSSOM.CSSStyleDeclaration();
-			for (var j = 0, styleLength = style.length; j < styleLength; j++) {
-				var name = styleClone[j] = style[j];
-				styleClone[name] = style[name];
-				styleClone._importants[name] = style.getPropertyPriority(name);
-			}
-			styleClone.length = style.length;
-		}
-
-		if (rule.hasOwnProperty('keyText')) {
-			ruleClone.keyText = rule.keyText;
-		}
-
-		if (rule.hasOwnProperty('selectorText')) {
-			ruleClone.selectorText = rule.selectorText;
-		}
-
-		if (rule.hasOwnProperty('mediaText')) {
-			ruleClone.mediaText = rule.mediaText;
-		}
-
-		if (rule.hasOwnProperty('supportsText')) {
-			ruleClone.supports = rule.supports;
-		}
-
-		if (rule.hasOwnProperty('conditionText')) {
-			ruleClone.conditionText = rule.conditionText;
-		}
-
-		if (rule.hasOwnProperty('layerName')) {
-			ruleClone.layerName = rule.layerName;
-		}
-
-		if (rule.hasOwnProperty('href')) {
-			ruleClone.href = rule.href;
-		}
-
-		if (rule.hasOwnProperty('name')) {
-			ruleClone.name = rule.name;
-		}
-
-		if (rule.hasOwnProperty('nameList')) {
-			ruleClone.nameList = rule.nameList;
-		}
-
-		if (rule.hasOwnProperty('cssRules')) {
-			ruleClone.cssRules = clone(rule).cssRules;
-		}
-	}
-
-	return cloned;
-
-};
-
-//.CommonJS
-exports.clone = CSSOM.clone;
-///CommonJS

node_modules/@acemir/cssom/lib/cssstyleTryCatchBlock.js

@@ -1,5 +0,0 @@
-try {
-	CSSOM.CSSStyleDeclaration = require("cssstyle").CSSStyleDeclaration;
-} catch (e) {
-	// ignore
-}

node_modules/@acemir/cssom/lib/errorUtils.js

@@ -1,119 +0,0 @@
-// Utility functions for CSSOM error handling
-
-/**
- * Gets the appropriate error constructor from the global object context.
- * Tries to find the error constructor from parentStyleSheet.__globalObject,
- * then from __globalObject, then falls back to the native constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @return {Function} The error constructor
- */
-function getErrorConstructor(context, errorType) {
-	// Try parentStyleSheet.__globalObject first
-	if (context.parentStyleSheet && context.parentStyleSheet.__globalObject && context.parentStyleSheet.__globalObject[errorType]) {
-		return context.parentStyleSheet.__globalObject[errorType];
-	}
-	
-	// Try __parentStyleSheet (alternative naming)
-	if (context.__parentStyleSheet && context.__parentStyleSheet.__globalObject && context.__parentStyleSheet.__globalObject[errorType]) {
-		return context.__parentStyleSheet.__globalObject[errorType];
-	}
-	
-	// Try __globalObject on the context itself
-	if (context.__globalObject && context.__globalObject[errorType]) {
-		return context.__globalObject[errorType];
-	}
-	
-	// Fall back to native constructor
-	return (typeof global !== 'undefined' && global[errorType]) || 
-	       (typeof window !== 'undefined' && window[errorType]) || 
-	       eval(errorType);
-}
-
-/**
- * Creates an appropriate error with context-aware constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @param {string} message - The error message
- * @param {string} [name] - Optional name for DOMException
- */
-function createError(context, errorType, message, name) {
-	var ErrorConstructor = getErrorConstructor(context, errorType);
-	return new ErrorConstructor(message, name);
-}
-
-/**
- * Creates and throws an appropriate error with context-aware constructor.
- * 
- * @param {Object} context - The CSSOM object (rule, stylesheet, etc.)
- * @param {string} errorType - The error type ('TypeError', 'RangeError', 'DOMException', etc.)
- * @param {string} message - The error message
- * @param {string} [name] - Optional name for DOMException
- */
-function throwError(context, errorType, message, name) {
-	throw createError(context, errorType, message, name);
-}
-
-/**
- * Throws a TypeError for missing required arguments.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name (e.g., 'appendRule')
- * @param {string} objectName - The object name (e.g., 'CSSKeyframesRule')
- * @param {number} [required=1] - Number of required arguments
- * @param {number} [provided=0] - Number of provided arguments
- */
-function throwMissingArguments(context, methodName, objectName, required, provided) {
-	required = required || 1;
-	provided = provided || 0;
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " + 
-	              required + " argument" + (required > 1 ? "s" : "") + " required, but only " + 
-	              provided + " present.";
-	throwError(context, 'TypeError', message);
-}
-
-/**
- * Throws a DOMException for parse errors.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name
- * @param {string} objectName - The object name
- * @param {string} rule - The rule that failed to parse
- * @param {string} [name='SyntaxError'] - The DOMException name
- */
-function throwParseError(context, methodName, objectName, rule, name) {
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
-	              "Failed to parse the rule '" + rule + "'.";
-	throwError(context, 'DOMException', message, name || 'SyntaxError');
-}
-
-/**
- * Throws a DOMException for index errors.
- * 
- * @param {Object} context - The CSSOM object
- * @param {string} methodName - The method name
- * @param {string} objectName - The object name
- * @param {number} index - The invalid index
- * @param {number} maxIndex - The maximum valid index
- * @param {string} [name='IndexSizeError'] - The DOMException name
- */
-function throwIndexError(context, methodName, objectName, index, maxIndex, name) {
-	var message = "Failed to execute '" + methodName + "' on '" + objectName + "': " +
-	              "The index provided (" + index + ") is larger than the maximum index (" + maxIndex + ").";
-	throwError(context, 'DOMException', message, name || 'IndexSizeError');
-}
-
-var errorUtils = {
-	createError: createError,
-	getErrorConstructor: getErrorConstructor,
-	throwError: throwError,
-	throwMissingArguments: throwMissingArguments,
-	throwParseError: throwParseError,
-	throwIndexError: throwIndexError
-};
-
-//.CommonJS
-exports.errorUtils = errorUtils;
-///CommonJS

node_modules/@acemir/cssom/lib/index.js

@@ -1,42 +0,0 @@
-'use strict';
-
-exports.setup = require('./CSSOM').setup;
-
-require('./errorUtils');
-require("./regexPatterns")
-
-exports.CSSStyleDeclaration = require('./CSSStyleDeclaration').CSSStyleDeclaration;
-
-require('./cssstyleTryCatchBlock');
-
-exports.CSSRule = require('./CSSRule').CSSRule;
-exports.CSSRuleList = require('./CSSRuleList').CSSRuleList;
-exports.CSSNestedDeclarations = require('./CSSNestedDeclarations').CSSNestedDeclarations;
-exports.CSSGroupingRule = require('./CSSGroupingRule').CSSGroupingRule;
-exports.CSSCounterStyleRule = require('./CSSCounterStyleRule').CSSCounterStyleRule;
-exports.CSSPropertyRule = require('./CSSPropertyRule').CSSPropertyRule;
-exports.CSSConditionRule = require('./CSSConditionRule').CSSConditionRule;
-exports.CSSStyleRule = require('./CSSStyleRule').CSSStyleRule;
-exports.MediaList = require('./MediaList').MediaList;
-exports.CSSMediaRule = require('./CSSMediaRule').CSSMediaRule;
-exports.CSSContainerRule = require('./CSSContainerRule').CSSContainerRule;
-exports.CSSSupportsRule = require('./CSSSupportsRule').CSSSupportsRule;
-exports.CSSImportRule = require('./CSSImportRule').CSSImportRule;
-exports.CSSNamespaceRule = require('./CSSNamespaceRule').CSSNamespaceRule;
-exports.CSSFontFaceRule = require('./CSSFontFaceRule').CSSFontFaceRule;
-exports.CSSHostRule = require('./CSSHostRule').CSSHostRule;
-exports.CSSStartingStyleRule = require('./CSSStartingStyleRule').CSSStartingStyleRule;
-exports.StyleSheet = require('./StyleSheet').StyleSheet;
-exports.CSSStyleSheet = require('./CSSStyleSheet').CSSStyleSheet;
-exports.CSSKeyframesRule = require('./CSSKeyframesRule').CSSKeyframesRule;
-exports.CSSKeyframeRule = require('./CSSKeyframeRule').CSSKeyframeRule;
-exports.MatcherList = require('./MatcherList').MatcherList;
-exports.CSSDocumentRule = require('./CSSDocumentRule').CSSDocumentRule;
-exports.CSSValue = require('./CSSValue').CSSValue;
-exports.CSSValueExpression = require('./CSSValueExpression').CSSValueExpression;
-exports.CSSScopeRule = require('./CSSScopeRule').CSSScopeRule;
-exports.CSSLayerBlockRule = require('./CSSLayerBlockRule').CSSLayerBlockRule;
-exports.CSSLayerStatementRule = require('./CSSLayerStatementRule').CSSLayerStatementRule;
-exports.CSSPageRule = require('./CSSPageRule').CSSPageRule;
-exports.parse = require('./parse').parse;
-exports.clone = require('./clone').clone;

node_modules/@acemir/cssom/lib/parse.js

@@ -1,3332 +0,0 @@
-//.CommonJS
-var CSSOM = {};
-var regexPatterns = require("./regexPatterns").regexPatterns;
-///CommonJS
-
-/**
- * Parses a CSS string and returns a `CSSStyleSheet` object representing the parsed stylesheet.
- *
- * @param {string} token - The CSS string to parse.
- * @param {object} [opts] - Optional parsing options.
- * @param {object} [opts.globalObject] - An optional global object to prioritize over the window object. Useful on jsdom webplatform tests.
- * @param {Element | ProcessingInstruction} [opts.ownerNode] - The owner node of the stylesheet.
- * @param {CSSRule} [opts.ownerRule] - The owner rule of the stylesheet.
- * @param {CSSOM.CSSStyleSheet} [opts.styleSheet] - Reuse a style sheet instead of creating a new one (e.g. as `parentStyleSheet`)
- * @param {CSSOM.CSSRuleList} [opts.cssRules] - Prepare all rules in this list instead of mutating the style sheet continually
- * @param {function|boolean} [errorHandler] - Optional error handler function or `true` to use `console.error`.
- * @returns {CSSOM.CSSStyleSheet} The parsed `CSSStyleSheet` object.
- */
-CSSOM.parse = function parse(token, opts, errorHandler) {
-	errorHandler = errorHandler === true ? (console && console.error) : errorHandler;
-
-	var i = 0;
-
-	/**
-		"before-selector" or
-		"selector" or
-		"atRule" or
-		"atBlock" or
-		"conditionBlock" or
-		"before-name" or
-		"name" or
-		"before-value" or
-		"value"
-	*/
-	var state = "before-selector";
-
-	var index;
-	var buffer = "";
-	var valueParenthesisDepth = 0;
-	var hasUnmatchedQuoteInSelector = false; // Track if current selector has unmatched quote
-
-	var SIGNIFICANT_WHITESPACE = {
-		"name": true,
-		"before-name": true,
-		"selector": true,
-		"value": true,
-		"value-parenthesis": true,
-		"atRule": true,
-		"importRule-begin": true,
-		"importRule": true,
-		"namespaceRule-begin": true,
-		"namespaceRule": true,
-		"atBlock": true,
-		"containerBlock": true,
-		"conditionBlock": true,
-		"counterStyleBlock": true,
-		"propertyBlock": true,
-		'documentRule-begin': true,
-		"scopeBlock": true,
-		"layerBlock": true,
-		"pageBlock": true
-	};
-
-	var styleSheet;
-	if (opts && opts.styleSheet) {
-		styleSheet = opts.styleSheet;
-	} else {
-		if (opts && opts.globalObject && opts.globalObject.CSSStyleSheet) {
-			styleSheet = new opts.globalObject.CSSStyleSheet();
-		} else {
-			styleSheet = new CSSOM.CSSStyleSheet();
-		}
-		styleSheet.__constructed = false;
-	}
-
-	var topScope;
-	if (opts && opts.cssRules) {
-		topScope = { cssRules: opts.cssRules };
-	} else {
-		topScope = styleSheet;
-	}
-
-	if (opts && opts.ownerNode) {
-		styleSheet.__ownerNode = opts.ownerNode;
-		var ownerNodeMedia = opts.ownerNode.media || (opts.ownerNode.getAttribute && opts.ownerNode.getAttribute("media"));
-		if (ownerNodeMedia) {
-			styleSheet.media.mediaText = ownerNodeMedia;
-		}
-		var ownerNodeTitle = opts.ownerNode.title || (opts.ownerNode.getAttribute && opts.ownerNode.getAttribute("title"));
-		if (ownerNodeTitle) {
-			styleSheet.__title = ownerNodeTitle;
-		}
-	}
-
-	if (opts && opts.ownerRule) {
-		styleSheet.__ownerRule = opts.ownerRule;
-	}
-
-	// @type CSSStyleSheet|CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSFontFaceRule|CSSKeyframesRule|CSSDocumentRule
-	var currentScope = topScope;
-
-	// @type CSSMediaRule|CSSContainerRule|CSSSupportsRule|CSSKeyframesRule|CSSDocumentRule
-	var parentRule;
-
-	var ancestorRules = [];
-	var prevScope;
-
-	var name, priority = "", styleRule, mediaRule, containerRule, counterStyleRule, propertyRule, supportsRule, importRule, fontFaceRule, keyframesRule, documentRule, hostRule, startingStyleRule, scopeRule, pageRule, layerBlockRule, layerStatementRule, nestedSelectorRule, namespaceRule;
-
-	// Track defined namespace prefixes for validation
-	var definedNamespacePrefixes = {};
-
-	// Track which rules have been added
-	var ruleIdCounter = 0;
-	var addedToParent = {};
-	var addedToTopScope = {};
-	var addedToCurrentScope = {};
-
-	// Helper to get unique ID for tracking rules
-	function getRuleId(rule) {
-		if (!rule.__parseId) {
-			rule.__parseId = ++ruleIdCounter;
-		}
-		return rule.__parseId;
-	}
-
-	// Cache last validation boundary position
-	// to avoid rescanning the entire token string for each at-rule
-	var lastValidationBoundary = 0;
-
-	// Pre-compile validation regexes for common at-rules
-	var validationRegexCache = {};
-	function getValidationRegex(atRuleKey) {
-		if (!validationRegexCache[atRuleKey]) {
-			var sourceRuleRegExp = atRuleKey === "@import" ? forwardImportRuleValidationRegExp : forwardRuleValidationRegExp;
-			validationRegexCache[atRuleKey] = new RegExp(atRuleKey + sourceRuleRegExp.source, sourceRuleRegExp.flags);
-		}
-		return validationRegexCache[atRuleKey];
-	}
-
-	// Import regex patterns from shared module
-	var atKeyframesRegExp = regexPatterns.atKeyframesRegExp;
-	var beforeRulePortionRegExp = regexPatterns.beforeRulePortionRegExp;
-	var beforeRuleValidationRegExp = regexPatterns.beforeRuleValidationRegExp;
-	var forwardRuleValidationRegExp = regexPatterns.forwardRuleValidationRegExp;
-	var forwardImportRuleValidationRegExp = regexPatterns.forwardImportRuleValidationRegExp;
-
-	// Pre-compile regexBefore to avoid creating it on every validateAtRule call
-	var regexBefore = new RegExp(beforeRulePortionRegExp.source, beforeRulePortionRegExp.flags);
-	var forwardRuleClosingBraceRegExp = regexPatterns.forwardRuleClosingBraceRegExp;
-	var forwardRuleSemicolonAndOpeningBraceRegExp = regexPatterns.forwardRuleSemicolonAndOpeningBraceRegExp;
-	var cssCustomIdentifierRegExp = regexPatterns.cssCustomIdentifierRegExp;
-	var startsWithCombinatorRegExp = regexPatterns.startsWithCombinatorRegExp;
-	var atPageRuleSelectorRegExp = regexPatterns.atPageRuleSelectorRegExp;
-	var startsWithHexEscapeRegExp = regexPatterns.startsWithHexEscapeRegExp;
-	var identStartCharRegExp = regexPatterns.identStartCharRegExp;
-	var identCharRegExp = regexPatterns.identCharRegExp;
-	var specialCharsNeedEscapeRegExp = regexPatterns.specialCharsNeedEscapeRegExp;
-	var combinatorOrSeparatorRegExp = regexPatterns.combinatorOrSeparatorRegExp;
-	var afterHexEscapeSeparatorRegExp = regexPatterns.afterHexEscapeSeparatorRegExp;
-	var trailingSpaceSeparatorRegExp = regexPatterns.trailingSpaceSeparatorRegExp;
-	var endsWithHexEscapeRegExp = regexPatterns.endsWithHexEscapeRegExp;
-	var attributeSelectorContentRegExp = regexPatterns.attributeSelectorContentRegExp;
-	var pseudoElementRegExp = regexPatterns.pseudoElementRegExp;
-	var invalidCombinatorLtGtRegExp = regexPatterns.invalidCombinatorLtGtRegExp;
-	var invalidCombinatorDoubleGtRegExp = regexPatterns.invalidCombinatorDoubleGtRegExp;
-	var consecutiveCombinatorsRegExp = regexPatterns.consecutiveCombinatorsRegExp;
-	var invalidSlottedRegExp = regexPatterns.invalidSlottedRegExp;
-	var invalidPartRegExp = regexPatterns.invalidPartRegExp;
-	var invalidCueRegExp = regexPatterns.invalidCueRegExp;
-	var invalidCueRegionRegExp = regexPatterns.invalidCueRegionRegExp;
-	var invalidNestingPattern = regexPatterns.invalidNestingPattern;
-	var emptyPseudoClassRegExp = regexPatterns.emptyPseudoClassRegExp;
-	var whitespaceNormalizationRegExp = regexPatterns.whitespaceNormalizationRegExp;
-	var newlineRemovalRegExp = regexPatterns.newlineRemovalRegExp;
-	var whitespaceAndDotRegExp = regexPatterns.whitespaceAndDotRegExp;
-	var declarationOrOpenBraceRegExp = regexPatterns.declarationOrOpenBraceRegExp;
-	var ampersandRegExp = regexPatterns.ampersandRegExp;
-	var hexEscapeSequenceRegExp = regexPatterns.hexEscapeSequenceRegExp;
-	var attributeCaseFlagRegExp = regexPatterns.attributeCaseFlagRegExp;
-	var prependedAmpersandRegExp = regexPatterns.prependedAmpersandRegExp;
-	var openBraceGlobalRegExp = regexPatterns.openBraceGlobalRegExp;
-	var closeBraceGlobalRegExp = regexPatterns.closeBraceGlobalRegExp;
-	var scopePreludeSplitRegExp = regexPatterns.scopePreludeSplitRegExp;
-	var leadingWhitespaceRegExp = regexPatterns.leadingWhitespaceRegExp;
-	var doubleQuoteRegExp = regexPatterns.doubleQuoteRegExp;
-	var backslashRegExp = regexPatterns.backslashRegExp;
-
-	/**
-	 * Searches for the first occurrence of a CSS at-rule statement terminator (`;` or `}`) 
-	 * that is not inside a brace block within the given string. Mimics the behavior of a 
-	 * regular expression match for such terminators, including any trailing whitespace.
-	 * @param {string} str - The string to search for at-rule statement terminators.
-	 * @returns {object | null} {0: string, index: number} or null if no match is found.
-	 */
-	function atRulesStatemenRegExpES5Alternative(ruleSlice) {
-		for (var i = 0; i < ruleSlice.length; i++) {
-			var char = ruleSlice[i];
-
-			if (char === ';' || char === '}') {
-				// Simulate negative lookbehind: check if there is a { before this position
-				var sliceBefore = ruleSlice.substring(0, i);
-				var openBraceIndex = sliceBefore.indexOf('{');
-
-				if (openBraceIndex === -1) {
-					// No { found before, so we treat it as a valid match
-					var match = char;
-					var j = i + 1;
-
-					while (j < ruleSlice.length && /\s/.test(ruleSlice[j])) {
-						match += ruleSlice[j];
-						j++;
-					}
-
-					var matchObj = [match];
-					matchObj.index = i;
-					matchObj.input = ruleSlice;
-					return matchObj;
-				}
-			}
-		}
-
-		return null;
-	}
-
-	/**
-	 * Finds the first balanced block (including nested braces) in the string, starting from fromIndex.
-	 * Returns an object similar to RegExp.prototype.match output.
-	 * @param {string} str - The string to search.
-	 * @param {number} [fromIndex=0] - The index to start searching from.
-	 * @returns {object|null} - { 0: matchedString, index: startIndex, input: str } or null if not found.
-	 */
-	function matchBalancedBlock(str, fromIndex) {
-		fromIndex = fromIndex || 0;
-		var openIndex = str.indexOf('{', fromIndex);
-		if (openIndex === -1) return null;
-		var depth = 0;
-		for (var i = openIndex; i < str.length; i++) {
-			if (str[i] === '{') {
-				depth++;
-			} else if (str[i] === '}') {
-				depth--;
-				if (depth === 0) {
-					var matchedString = str.slice(openIndex, i + 1);
-					return {
-						0: matchedString,
-						index: openIndex,
-						input: str
-					};
-				}
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * Advances the index `i` to skip over a balanced block of curly braces in the given string.
-	 * This is typically used to ignore the contents of a CSS rule block.
-	 *
-	 * @param {number} i - The current index in the string to start searching from.
-	 * @param {string} str - The string containing the CSS code.
-	 * @param {number} fromIndex - The index in the string where the balanced block search should begin.
-	 * @returns {number} The updated index after skipping the balanced block.
-	 */
-	function ignoreBalancedBlock(i, str, fromIndex) {
-		var ruleClosingMatch = matchBalancedBlock(str, fromIndex);
-		if (ruleClosingMatch) {
-			var ignoreRange = ruleClosingMatch.index + ruleClosingMatch[0].length;
-			i += ignoreRange;
-			if (token.charAt(i) === '}') {
-				i -= 1;
-			}
-		} else {
-			i += str.length;
-		}
-		return i;
-	}
-
-	/**
-	 * Parses the scope prelude and extracts start and end selectors.
-	 * @param {string} preludeContent - The scope prelude content (without @scope keyword)
-	 * @returns {object} Object with startSelector and endSelector properties
-	 */
-	function parseScopePrelude(preludeContent) {
-		var parts = preludeContent.split(scopePreludeSplitRegExp);
-
-		// Restore the parentheses that were consumed by the split
-		if (parts.length === 2) {
-			parts[0] = parts[0] + ')';
-			parts[1] = '(' + parts[1];
-		}
-
-		var hasStart = parts[0] &&
-			parts[0].charAt(0) === '(' &&
-			parts[0].charAt(parts[0].length - 1) === ')';
-		var hasEnd = parts[1] &&
-			parts[1].charAt(0) === '(' &&
-			parts[1].charAt(parts[1].length - 1) === ')';
-
-		// Handle case: @scope to (<end>)
-		var hasOnlyEnd = !hasStart &&
-			!hasEnd &&
-			parts[0].indexOf('to (') === 0 &&
-			parts[0].charAt(parts[0].length - 1) === ')';
-
-		var startSelector = '';
-		var endSelector = '';
-
-		if (hasStart) {
-			startSelector = parts[0].slice(1, -1).trim();
-		}
-		if (hasEnd) {
-			endSelector = parts[1].slice(1, -1).trim();
-		}
-		if (hasOnlyEnd) {
-			endSelector = parts[0].slice(4, -1).trim();
-		}
-
-		return {
-			startSelector: startSelector,
-			endSelector: endSelector,
-			hasStart: hasStart,
-			hasEnd: hasEnd,
-			hasOnlyEnd: hasOnlyEnd
-		};
-	};
-
-	/**
-	 * Checks if a selector contains pseudo-elements.
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains pseudo-elements
-	 */
-	function hasPseudoElement(selector) {
-		// Match only double-colon (::) pseudo-elements
-		// Also match legacy single-colon pseudo-elements: :before, :after, :first-line, :first-letter
-		// These must NOT be followed by alphanumeric characters (to avoid matching :before-x or similar)
-		return pseudoElementRegExp.test(selector);
-	};
-
-	/**
-	 * Validates balanced parentheses, brackets, and quotes in a selector.
-	 * 
-	 * @param {string} selector - The CSS selector to validate
-	 * @param {boolean} trackAttributes - Whether to track attribute selector context
-	 * @param {boolean} useStack - Whether to use a stack for parentheses (needed for nested validation)
-	 * @returns {boolean} True if the syntax is valid (all brackets, parentheses, and quotes are balanced)
-	 */
-	function validateBalancedSyntax(selector, trackAttributes, useStack) {
-		var parenDepth = 0;
-		var bracketDepth = 0;
-		var inSingleQuote = false;
-		var inDoubleQuote = false;
-		var inAttr = false;
-		var stack = useStack ? [] : null;
-
-		for (var i = 0; i < selector.length; i++) {
-			var char = selector[i];
-
-			// Handle escape sequences - skip hex escapes or simple escapes
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-
-			if (inSingleQuote) {
-				if (char === "'") {
-					inSingleQuote = false;
-				}
-			} else if (inDoubleQuote) {
-				if (char === '"') {
-					inDoubleQuote = false;
-				}
-			} else if (trackAttributes && inAttr) {
-				if (char === "]") {
-					inAttr = false;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				}
-			} else {
-				if (trackAttributes && char === "[") {
-					inAttr = true;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				} else if (char === '(') {
-					if (useStack) {
-						stack.push("(");
-					} else {
-						parenDepth++;
-					}
-				} else if (char === ')') {
-					if (useStack) {
-						if (!stack.length || stack.pop() !== "(") {
-							return false;
-						}
-					} else {
-						parenDepth--;
-						if (parenDepth < 0) {
-							return false;
-						}
-					}
-				} else if (char === '[') {
-					bracketDepth++;
-				} else if (char === ']') {
-					bracketDepth--;
-					if (bracketDepth < 0) {
-						return false;
-					}
-				}
-			}
-		}
-
-		// Check if everything is balanced
-		if (useStack) {
-			return stack.length === 0 && bracketDepth === 0 && !inSingleQuote && !inDoubleQuote && !inAttr;
-		} else {
-			return parenDepth === 0 && bracketDepth === 0 && !inSingleQuote && !inDoubleQuote;
-		}
-	};
-
-	/**
-	 * Checks for basic syntax errors in selectors (mismatched parentheses, brackets, quotes).
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if there are syntax errors
-	 */
-	function hasBasicSyntaxError(selector) {
-		return !validateBalancedSyntax(selector, false, false);
-	};
-
-	/**
-	 * Checks for invalid combinator patterns in selectors.
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid combinators
-	 */
-	function hasInvalidCombinators(selector) {
-		// Check for invalid combinator patterns:
-		// - <> (not a valid combinator)
-		// - >> (deep descendant combinator, deprecated and invalid)
-		// - Multiple consecutive combinators like >>, >~, etc.
-		if (invalidCombinatorLtGtRegExp.test(selector)) return true;
-		if (invalidCombinatorDoubleGtRegExp.test(selector)) return true;
-		// Check for other invalid consecutive combinator patterns
-		if (consecutiveCombinatorsRegExp.test(selector)) return true;
-		return false;
-	};
-
-	/**
-	 * Checks for invalid pseudo-like syntax (function calls without proper pseudo prefix).
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid pseudo-like syntax
-	 */
-	function hasInvalidPseudoSyntax(selector) {
-		// Check for specific known pseudo-elements used without : or :: prefix
-		// Examples: slotted(div), part(name), cue(selector)
-		// These are ONLY valid as ::slotted(), ::part(), ::cue()
-		var invalidPatterns = [
-			invalidSlottedRegExp,
-			invalidPartRegExp,
-			invalidCueRegExp,
-			invalidCueRegionRegExp
-		];
-
-		for (var i = 0; i < invalidPatterns.length; i++) {
-			if (invalidPatterns[i].test(selector)) {
-				return true;
-			}
-		}
-		return false;
-	};
-
-	/**
-	 * Checks for invalid nesting selector (&) usage.
-	 * The & selector cannot be directly followed by a type selector without a delimiter.
-	 * Valid: &.class, &#id, &[attr], &:hover, &::before, & div, &>div
-	 * Invalid: &div, &span
-	 * @param {string} selector - The CSS selector to check
-	 * @returns {boolean} True if the selector contains invalid & usage
-	 */
-	function hasInvalidNestingSelector(selector) {
-		// Check for & followed directly by a letter (type selector) without any delimiter
-		// This regex matches & followed by a letter (start of type selector) that's not preceded by an escape
-		// We need to exclude valid cases like &.class, &#id, &[attr], &:pseudo, &::pseudo, & (with space), &>
-		return invalidNestingPattern.test(selector);
-	};
-
-	/**
-	 * Checks if an at-rule can be nested based on parent chain validation.
-	 * Used for at-rules like `@counter-style`, `@property` and `@font-face` rules that can only be nested inside
-	 * `CSSScopeRule` or `CSSConditionRule` without `CSSStyleRule` in parent chain.
-	 * @returns {boolean} `true` if nesting is allowed, `false` otherwise
-	 */
-	function canAtRuleBeNested() {
-		if (currentScope === topScope) {
-			return true; // Top-level is always allowed
-		}
-
-		var hasStyleRuleInChain = false;
-		var hasValidParent = false;
-
-		// Check currentScope
-		if (currentScope.constructor.name === 'CSSStyleRule') {
-			hasStyleRuleInChain = true;
-		} else if (currentScope instanceof CSSOM.CSSScopeRule || currentScope instanceof CSSOM.CSSConditionRule) {
-			hasValidParent = true;
-		}
-
-		// Check ancestorRules for CSSStyleRule
-		if (!hasStyleRuleInChain) {
-			for (var j = 0; j < ancestorRules.length; j++) {
-				if (ancestorRules[j].constructor.name === 'CSSStyleRule') {
-					hasStyleRuleInChain = true;
-					break;
-				}
-				if (ancestorRules[j] instanceof CSSOM.CSSScopeRule || ancestorRules[j] instanceof CSSOM.CSSConditionRule) {
-					hasValidParent = true;
-				}
-			}
-		}
-
-		// Allow nesting if we have a valid parent and no style rule in the chain
-		return hasValidParent && !hasStyleRuleInChain;
-	}
-
-	function validateAtRule(atRuleKey, validCallback, cannotBeNested) {
-		var isValid = false;
-		// Use cached regex instead of creating new one each time
-		var ruleRegExp = getValidationRegex(atRuleKey);
-		//  Only slice what we need for validation (max 100 chars)
-		// since we only check match at position 0
-		var lookAheadLength = Math.min(100, token.length - i);
-		var ruleSlice = token.slice(i, i + lookAheadLength);
-		// Not all rules can be nested, if the rule cannot be nested and is in the root scope, do not perform the check
-		var shouldPerformCheck = cannotBeNested && currentScope !== topScope ? false : true;
-		// First, check if there is no invalid characters just after the at-rule
-		if (shouldPerformCheck && ruleSlice.search(ruleRegExp) === 0) {
-			// Only scan from the last known validation boundary
-			var searchStart = Math.max(0, lastValidationBoundary);
-			var beforeSlice = token.slice(searchStart, i);
-			
-			// Use pre-compiled regex instead of creating new one each time
-			var matches = beforeSlice.match(regexBefore);
-			var lastI = matches ? searchStart + beforeSlice.lastIndexOf(matches[matches.length - 1]) : searchStart;
-			var toCheckSlice = token.slice(lastI, i);
-			// Check if we don't have any invalid in the portion before the `at-rule` and the closest allowed character
-			var checkedSlice = toCheckSlice.search(beforeRuleValidationRegExp);
-			if (checkedSlice === 0) {
-				isValid = true;
-				// Update the validation boundary cache to this position
-				lastValidationBoundary = lastI;
-			}
-		}
-
-		// Additional validation for @scope rule
-		if (isValid && atRuleKey === "@scope") {
-			var openBraceIndex = ruleSlice.indexOf('{');
-			if (openBraceIndex !== -1) {
-				// Extract the rule prelude (everything between the at-rule and {)
-				var rulePrelude = ruleSlice.slice(0, openBraceIndex).trim();
-
-				// Skip past at-rule keyword and whitespace
-				var preludeContent = rulePrelude.slice("@scope".length).trim();
-
-				if (preludeContent.length > 0) {
-					// Parse the scope prelude
-					var parsedScopePrelude = parseScopePrelude(preludeContent);
-					var startSelector = parsedScopePrelude.startSelector;
-					var endSelector = parsedScopePrelude.endSelector;
-					var hasStart = parsedScopePrelude.hasStart;
-					var hasEnd = parsedScopePrelude.hasEnd;
-					var hasOnlyEnd = parsedScopePrelude.hasOnlyEnd;
-
-					// Validation rules for @scope:
-					// 1. Empty selectors in parentheses are invalid: @scope () {} or @scope (.a) to () {}
-					if ((hasStart && startSelector === '') || (hasEnd && endSelector === '') || (hasOnlyEnd && endSelector === '')) {
-						isValid = false;
-					}
-					// 2. Pseudo-elements are invalid in scope selectors
-					else if ((startSelector && hasPseudoElement(startSelector)) || (endSelector && hasPseudoElement(endSelector))) {
-						isValid = false;
-					}
-					// 3. Basic syntax errors (mismatched parens, brackets, quotes)
-					else if ((startSelector && hasBasicSyntaxError(startSelector)) || (endSelector && hasBasicSyntaxError(endSelector))) {
-						isValid = false;
-					}
-					// 4. Invalid combinator patterns
-					else if ((startSelector && hasInvalidCombinators(startSelector)) || (endSelector && hasInvalidCombinators(endSelector))) {
-						isValid = false;
-					}
-					// 5. Invalid pseudo-like syntax (function without : or :: prefix)
-					else if ((startSelector && hasInvalidPseudoSyntax(startSelector)) || (endSelector && hasInvalidPseudoSyntax(endSelector))) {
-						isValid = false;
-					}
-					// 6. Invalid structure (no proper parentheses found when prelude is not empty)
-					else if (!hasStart && !hasOnlyEnd) {
-						isValid = false;
-					}
-				}
-				// Empty prelude (@scope {}) is valid
-			}
-		}
-
-		if (isValid && atRuleKey === "@page") {
-			var openBraceIndex = ruleSlice.indexOf('{');
-			if (openBraceIndex !== -1) {
-				// Extract the rule prelude (everything between the at-rule and {)
-				var rulePrelude = ruleSlice.slice(0, openBraceIndex).trim();
-
-				// Skip past at-rule keyword and whitespace
-				var preludeContent = rulePrelude.slice("@page".length).trim();
-
-				if (preludeContent.length > 0) {
-					var trimmedValue = preludeContent.trim();
-
-					// Empty selector is valid for @page
-					if (trimmedValue !== '') {
-						// Parse @page selectorText for page name and pseudo-pages
-						// Valid formats:
-						// - (empty - no name, no pseudo-page)
-						// - :left, :right, :first, :blank (pseudo-page only)
-						// - named (named page only)
-						// - named:first (named page with single pseudo-page)
-						// - named:first:left (named page with multiple pseudo-pages)
-						var match = trimmedValue.match(atPageRuleSelectorRegExp);
-						if (match) {
-							var pageName = match[1] || '';
-							var pseudoPages = match[2] || '';
-
-							// Validate page name if present
-							if (pageName) {
-								if (!cssCustomIdentifierRegExp.test(pageName)) {
-									isValid = false;
-								}
-							}
-
-							// Validate pseudo-pages if present
-							if (pseudoPages) {
-								var pseudos = pseudoPages.split(':').filter(function (p) { return p; });
-								var validPseudos = ['left', 'right', 'first', 'blank'];
-								var allValid = true;
-								for (var j = 0; j < pseudos.length; j++) {
-									if (validPseudos.indexOf(pseudos[j].toLowerCase()) === -1) {
-										allValid = false;
-										break;
-									}
-								}
-
-								if (!allValid) {
-									isValid = false;
-								}
-							}
-						} else {
-							isValid = false;
-						}
-					}
-
-				}
-			}
-		}
-
-		if (!isValid) {
-			// If it's invalid the browser will simply ignore the entire invalid block
-			// Use regex to find the closing brace of the invalid rule
-
-			// Regex used above is not ES5 compliant. Using alternative.
-			// var ruleStatementMatch = ruleSlice.match(atRulesStatemenRegExp); //
-			var ruleStatementMatch = atRulesStatemenRegExpES5Alternative(ruleSlice);
-
-			// If it's a statement inside a nested rule, ignore only the statement
-			if (ruleStatementMatch && currentScope !== topScope) {
-				var ignoreEnd = ruleStatementMatch[0].indexOf(";");
-				i += ruleStatementMatch.index + ignoreEnd;
-				return;
-			}
-
-			// Check if there's a semicolon before the invalid at-rule and the first opening brace
-			if (atRuleKey === "@layer") {
-				var ruleSemicolonAndOpeningBraceMatch = ruleSlice.match(forwardRuleSemicolonAndOpeningBraceRegExp);
-				if (ruleSemicolonAndOpeningBraceMatch && ruleSemicolonAndOpeningBraceMatch[1] === ";") {
-					// Ignore the rule block until the semicolon
-					i += ruleSemicolonAndOpeningBraceMatch.index + ruleSemicolonAndOpeningBraceMatch[0].length;
-					state = "before-selector";
-					return;
-				}
-			}
-
-			// Ignore the entire rule block (if it's a statement it should ignore the statement plus the next block)
-			i = ignoreBalancedBlock(i, ruleSlice);
-			state = "before-selector";
-		} else {
-			validCallback.call(this);
-		}
-	}
-
-	// Helper functions for looseSelectorValidator
-	// Defined outside to avoid recreation on every validation call
-
-	/**
-	 * Check if character is a valid identifier start
-	 * @param {string} c - Character to check
-	 * @returns {boolean}
-	 */
-	function isIdentStart(c) {
-		return /[a-zA-Z_\u00A0-\uFFFF]/.test(c);
-	}
-
-	/**
-	 * Check if character is a valid identifier character
-	 * @param {string} c - Character to check
-	 * @returns {boolean}
-	 */
-	function isIdentChar(c) {
-		return /[a-zA-Z0-9_\u00A0-\uFFFF\-]/.test(c);
-	}
-
-	/**
-	 * Helper function to validate CSS selector syntax without regex backtracking.
-	 * Iteratively parses the selector string to identify valid components.
-	 * 
-	 * Supports:
-	 * - Escaped characters (e.g., .class\!, #id\@name)
-	 * - Namespace selectors (ns|element, *|element, |element)
-	 * - All standard CSS selectors (class, ID, type, attribute, pseudo, etc.)
-	 * - Combinators (>, +, ~, whitespace)
-	 * - Nesting selector (&)
-	 * 
-	 * This approach eliminates exponential backtracking by using explicit character-by-character
-	 * parsing instead of nested quantifiers in regex.
-	 * 
-	 * @param {string} selector - The selector to validate
-	 * @returns {boolean} - True if valid selector syntax
-	 */
-	function looseSelectorValidator(selector) {
-		if (!selector || selector.length === 0) {
-			return false;
-		}
-
-		var i = 0;
-		var len = selector.length;
-		var hasMatchedComponent = false;
-
-		// Helper: Skip escaped character (backslash + hex escape or any char)
-		function skipEscape() {
-			if (i < len && selector[i] === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen; // Skip entire escape sequence
-					return true;
-				}
-			}
-			return false;
-		}
-
-		// Helper: Parse identifier (with possible escapes)
-		function parseIdentifier() {
-			var start = i;
-			while (i < len) {
-				if (skipEscape()) {
-					continue;
-				} else if (isIdentChar(selector[i])) {
-					i++;
-				} else {
-					break;
-				}
-			}
-			return i > start;
-		}
-
-		// Helper: Parse namespace prefix (optional)
-		function parseNamespace() {
-			var start = i;
-
-			// Match: *| or identifier| or |
-			if (i < len && selector[i] === '*') {
-				i++;
-			} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
-				parseIdentifier();
-			}
-
-			if (i < len && selector[i] === '|') {
-				i++;
-				return true;
-			}
-
-			// Rollback if no pipe found
-			i = start;
-			return false;
-		}
-
-		// Helper: Parse pseudo-class/element arguments (with balanced parens)
-		function parsePseudoArgs() {
-			if (i >= len || selector[i] !== '(') {
-				return false;
-			}
-
-			i++; // Skip opening paren
-			var depth = 1;
-			var inString = false;
-			var stringChar = '';
-
-			while (i < len && depth > 0) {
-				var c = selector[i];
-
-				if (c === '\\' && i + 1 < len) {
-					i += 2; // Skip escaped character
-				} else if (!inString && (c === '"' || c === '\'')) {
-					inString = true;
-					stringChar = c;
-					i++;
-				} else if (inString && c === stringChar) {
-					inString = false;
-					i++;
-				} else if (!inString && c === '(') {
-					depth++;
-					i++;
-				} else if (!inString && c === ')') {
-					depth--;
-					i++;
-				} else {
-					i++;
-				}
-			}
-
-			return depth === 0;
-		}
-
-		// Main parsing loop
-		while (i < len) {
-			var matched = false;
-			var start = i;
-
-			// Skip whitespace
-			while (i < len && /\s/.test(selector[i])) {
-				i++;
-			}
-			if (i > start) {
-				hasMatchedComponent = true;
-				continue;
-			}
-
-			// Match combinators: >, +, ~
-			if (i < len && /[>+~]/.test(selector[i])) {
-				i++;
-				hasMatchedComponent = true;
-				// Skip trailing whitespace
-				while (i < len && /\s/.test(selector[i])) {
-					i++;
-				}
-				continue;
-			}
-
-			// Match nesting selector: &
-			if (i < len && selector[i] === '&') {
-				i++;
-				hasMatchedComponent = true;
-				matched = true;
-			}
-			// Match class selector: .identifier
-			else if (i < len && selector[i] === '.') {
-				i++;
-				if (parseIdentifier()) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match ID selector: #identifier
-			else if (i < len && selector[i] === '#') {
-				i++;
-				if (parseIdentifier()) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match pseudo-class/element: :identifier or ::identifier
-			else if (i < len && selector[i] === ':') {
-				i++;
-				if (i < len && selector[i] === ':') {
-					i++; // Pseudo-element
-				}
-				if (parseIdentifier()) {
-					parsePseudoArgs(); // Optional arguments
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match attribute selector: [...]
-			else if (i < len && selector[i] === '[') {
-				i++;
-				var depth = 1;
-				while (i < len && depth > 0) {
-					if (selector[i] === '\\') {
-						i += 2;
-					} else if (selector[i] === '\'') {
-						i++;
-						while (i < len && selector[i] !== '\'') {
-							if (selector[i] === '\\') i += 2;
-							else i++;
-						}
-						if (i < len) i++; // Skip closing quote
-					} else if (selector[i] === '"') {
-						i++;
-						while (i < len && selector[i] !== '"') {
-							if (selector[i] === '\\') i += 2;
-							else i++;
-						}
-						if (i < len) i++; // Skip closing quote
-					} else if (selector[i] === '[') {
-						depth++;
-						i++;
-					} else if (selector[i] === ']') {
-						depth--;
-						i++;
-					} else {
-						i++;
-					}
-				}
-				if (depth === 0) {
-					hasMatchedComponent = true;
-					matched = true;
-				}
-			}
-			// Match type selector with optional namespace: [namespace|]identifier
-			else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\' || selector[i] === '*' || selector[i] === '|')) {
-				parseNamespace(); // Optional namespace prefix
-
-				if (i < len && selector[i] === '*') {
-					i++; // Universal selector
-					hasMatchedComponent = true;
-					matched = true;
-				} else if (i < len && (isIdentStart(selector[i]) || selector[i] === '\\')) {
-					if (parseIdentifier()) {
-						hasMatchedComponent = true;
-						matched = true;
-					}
-				}
-			}
-
-			// If no match found, invalid selector
-			if (!matched && i === start) {
-				return false;
-			}
-		}
-
-		return hasMatchedComponent;
-	}
-
-	/**
-	 * Validates a basic CSS selector, allowing for deeply nested balanced parentheses in pseudo-classes.
-	 * This function replaces the previous basicSelectorRegExp.
-	 * 
-	 * This function matches:
-	 * - Type selectors (e.g., `div`, `span`)
-	 * - Universal selector (`*`)
-	 * - Namespace selectors (e.g., `*|div`, `custom|div`, `|div`)
-	 * - ID selectors (e.g., `#header`, `#a\ b`, `#åèiöú`)
-	 * - Class selectors (e.g., `.container`, `.a\ b`, `.åèiöú`)
-	 * - Attribute selectors (e.g., `[type="text"]`)
-	 * - Pseudo-classes and pseudo-elements (e.g., `:hover`, `::before`, `:nth-child(2)`)
-	 * - Pseudo-classes with nested parentheses, including cases where parentheses are nested inside arguments,
-	 *   such as `:has(.sel:nth-child(3n))`
-	 * - The parent selector (`&`)
-	 * - Combinators (`>`, `+`, `~`) with optional whitespace
-	 * - Whitespace (descendant combinator)
-	 *
-	 * Unicode and escape sequences are allowed in identifiers.
-	 *
-	 * @param {string} selector
-	 * @returns {boolean}
-	 */
-	function basicSelectorValidator(selector) {
-		// Guard against extremely long selectors to prevent potential regex performance issues
-		// Reasonable selectors are typically under 1000 characters
-		if (selector.length > 10000) {
-			return false;
-		}
-
-		// Validate balanced syntax with attribute tracking and stack-based parentheses matching
-		if (!validateBalancedSyntax(selector, true, true)) {
-			return false;
-		}
-
-		// Check for invalid combinator patterns
-		if (hasInvalidCombinators(selector)) {
-			return false;
-		}
-
-		// Check for invalid pseudo-like syntax
-		if (hasInvalidPseudoSyntax(selector)) {
-			return false;
-		}
-
-		// Check for invalid nesting selector (&) usage
-		if (hasInvalidNestingSelector(selector)) {
-			return false;
-		}
-
-		// Check for invalid pseudo-class usage with quoted strings
-		// Pseudo-classes like :lang(), :dir(), :nth-*() should not accept quoted strings
-		// Using iterative parsing instead of regex to avoid exponential backtracking
-		var noQuotesPseudos = ['lang', 'dir', 'nth-child', 'nth-last-child', 'nth-of-type', 'nth-last-of-type'];
-
-		for (var idx = 0; idx < selector.length; idx++) {
-			// Look for pseudo-class/element start
-			if (selector[idx] === ':') {
-				var pseudoStart = idx;
-				idx++;
-
-				// Skip second colon for pseudo-elements
-				if (idx < selector.length && selector[idx] === ':') {
-					idx++;
-				}
-
-				// Extract pseudo name
-				var nameStart = idx;
-				while (idx < selector.length && /[a-zA-Z0-9\-]/.test(selector[idx])) {
-					idx++;
-				}
-
-				if (idx === nameStart) {
-					continue; // No name found
-				}
-
-				var pseudoName = selector.substring(nameStart, idx).toLowerCase();
-
-				// Check if this pseudo has arguments
-				if (idx < selector.length && selector[idx] === '(') {
-					idx++;
-					var contentStart = idx;
-					var depth = 1;
-
-					// Find matching closing paren (handle nesting)
-					while (idx < selector.length && depth > 0) {
-						if (selector[idx] === '\\') {
-							idx += 2; // Skip escaped character
-						} else if (selector[idx] === '(') {
-							depth++;
-							idx++;
-						} else if (selector[idx] === ')') {
-							depth--;
-							idx++;
-						} else {
-							idx++;
-						}
-					}
-
-					if (depth === 0) {
-						var pseudoContent = selector.substring(contentStart, idx - 1);
-
-						// Check if this pseudo should not have quoted strings
-						for (var j = 0; j < noQuotesPseudos.length; j++) {
-							if (pseudoName === noQuotesPseudos[j] && /['"]/.test(pseudoContent)) {
-								return false;
-							}
-						}
-					}
-				}
-			}
-		}
-
-		// Use the iterative validator to avoid regex backtracking issues
-		return looseSelectorValidator(selector);
-	}
-
-	/**
-	 * Regular expression to match CSS pseudo-classes with arguments.
-	 *
-	 * Matches patterns like `:pseudo-class(argument)`, capturing the pseudo-class name and its argument.
-	 *
-	 * Capture groups:
-	 *   1. The pseudo-class name (letters and hyphens).
-	 *   2. The argument inside the parentheses (can contain nested parentheses, quoted strings, and other characters.).
-	 *
-	 * Global flag (`g`) is used to find all matches in the input string.
-	 *
-	 * Example matches:
-	 *   - :nth-child(2n+1)
-	 *   - :has(.sel:nth-child(3n))
-	 *   - :not(".foo, .bar")
-	 *
-	 * REPLACED WITH FUNCTION to avoid exponential backtracking.
-	 */
-
-	/**
-	 * Extract pseudo-classes with arguments from a selector using iterative parsing.
-	 * Replaces the previous globalPseudoClassRegExp to avoid exponential backtracking.
-	 * 
-	 * Handles:
-	 * - Regular content without parentheses or quotes
-	 * - Single-quoted strings
-	 * - Double-quoted strings  
-	 * - Nested parentheses (arbitrary depth)
-	 * 
-	 * @param {string} selector - The CSS selector to parse
-	 * @returns {Array} Array of matches, each with: [fullMatch, pseudoName, pseudoArgs, startIndex]
-	 */
-	function extractPseudoClasses(selector) {
-		var matches = [];
-
-		for (var i = 0; i < selector.length; i++) {
-			// Look for pseudo-class start (single or double colon)
-			if (selector[i] === ':') {
-				var pseudoStart = i;
-				i++;
-
-				// Skip second colon for pseudo-elements (::)
-				if (i < selector.length && selector[i] === ':') {
-					i++;
-				}
-
-				// Extract pseudo name
-				var nameStart = i;
-				while (i < selector.length && /[a-zA-Z\-]/.test(selector[i])) {
-					i++;
-				}
-
-				if (i === nameStart) {
-					continue; // No name found
-				}
-
-				var pseudoName = selector.substring(nameStart, i);
-
-				// Check if this pseudo has arguments
-				if (i < selector.length && selector[i] === '(') {
-					i++;
-					var argsStart = i;
-					var depth = 1;
-					var inSingleQuote = false;
-					var inDoubleQuote = false;
-
-					// Find matching closing paren (handle nesting and strings)
-					while (i < selector.length && depth > 0) {
-						var ch = selector[i];
-
-						if (ch === '\\') {
-							i += 2; // Skip escaped character
-						} else if (ch === "'" && !inDoubleQuote) {
-							inSingleQuote = !inSingleQuote;
-							i++;
-						} else if (ch === '"' && !inSingleQuote) {
-							inDoubleQuote = !inDoubleQuote;
-							i++;
-						} else if (ch === '(' && !inSingleQuote && !inDoubleQuote) {
-							depth++;
-							i++;
-						} else if (ch === ')' && !inSingleQuote && !inDoubleQuote) {
-							depth--;
-							i++;
-						} else {
-							i++;
-						}
-					}
-
-					if (depth === 0) {
-						var pseudoArgs = selector.substring(argsStart, i - 1);
-						var fullMatch = selector.substring(pseudoStart, i);
-
-						// Store match in same format as regex: [fullMatch, pseudoName, pseudoArgs, startIndex]
-						matches.push([fullMatch, pseudoName, pseudoArgs, pseudoStart]);
-					}
-
-					// Move back one since loop will increment
-					i--;
-				}
-			}
-		}
-
-		return matches;
-	}
-
-	/**
-	 * Parses a CSS selector string and splits it into parts, handling nested parentheses.
-	 *
-	 * This function is useful for splitting selectors that may contain nested function-like
-	 * syntax (e.g., :not(.foo, .bar)), ensuring that commas inside parentheses do not split
-	 * the selector.
-	 *
-	 * @param {string} selector - The CSS selector string to parse.
-	 * @returns {string[]} An array of selector parts, split by top-level commas, with whitespace trimmed.
-	 */
-	function parseAndSplitNestedSelectors(selector) {
-		var depth = 0;           // Track parenthesis nesting depth
-		var buffer = "";         // Accumulate characters for current selector part
-		var parts = [];          // Array of split selector parts
-		var inSingleQuote = false; // Track if we're inside single quotes
-		var inDoubleQuote = false; // Track if we're inside double quotes
-		var i, char;
-
-		for (i = 0; i < selector.length; i++) {
-			char = selector.charAt(i);
-
-			// Handle escape sequences - skip them entirely
-			if (char === '\\' && i + 1 < selector.length) {
-				buffer += char;
-				i++;
-				buffer += selector.charAt(i);
-				continue;
-			}
-
-			// Handle single quote strings
-			if (char === "'" && !inDoubleQuote) {
-				inSingleQuote = !inSingleQuote;
-				buffer += char;
-			}
-			// Handle double quote strings
-			else if (char === '"' && !inSingleQuote) {
-				inDoubleQuote = !inDoubleQuote;
-				buffer += char;
-			}
-			// Process characters outside of quoted strings
-			else if (!inSingleQuote && !inDoubleQuote) {
-				if (char === '(') {
-					// Entering a nested level (e.g., :is(...))
-					depth++;
-					buffer += char;
-				} else if (char === ')') {
-					// Exiting a nested level
-					depth--;
-					buffer += char;
-				} else if (char === ',' && depth === 0) {
-					// Found a top-level comma separator - split here
-					// Note: escaped commas (\,) are already handled above
-					if (buffer.trim()) {
-						parts.push(buffer.trim());
-					}
-					buffer = "";
-				} else {
-					// Regular character - add to buffer
-					buffer += char;
-				}
-			}
-			// Characters inside quoted strings - add to buffer
-			else {
-				buffer += char;
-			}
-		}
-
-		// Add any remaining content in buffer as the last part
-		var trimmed = buffer.trim();
-		if (trimmed) {
-			// Preserve trailing space if selector ends with hex escape
-			var endsWithHexEscape = endsWithHexEscapeRegExp.test(buffer);
-			parts.push(endsWithHexEscape ? buffer.replace(leadingWhitespaceRegExp, '') : trimmed);
-		}
-
-		return parts;
-	}
-
-	/**
-	 * Validates a CSS selector string, including handling of nested selectors within certain pseudo-classes.
-	 *
-	 * This function checks if the provided selector is valid according to the rules defined by
-	 * `basicSelectorValidator`. For pseudo-classes that accept selector lists (such as :not, :is, :has, :where),
-	 * it recursively validates each nested selector using the same validation logic.
-	 *
-	 * @param {string} selector - The CSS selector string to validate.
-	 * @returns {boolean} Returns `true` if the selector is valid, otherwise `false`.
-	 */
-
-	// Cache to store validated selectors (previously a ES6 Map, now an ES5-compliant object)
-	var validatedSelectorsCache = {};
-
-	// Only pseudo-classes that accept selector lists should recurse
-	var selectorListPseudoClasses = {
-		'not': true,
-		'is': true,
-		'has': true,
-		'where': true
-	};
-
-	function validateSelector(selector) {
-		if (validatedSelectorsCache.hasOwnProperty(selector)) {
-			return validatedSelectorsCache[selector];
-		}
-
-		// Use function-based parsing to extract pseudo-classes (avoids backtracking)
-		var pseudoClassMatches = extractPseudoClasses(selector);
-
-		for (var j = 0; j < pseudoClassMatches.length; j++) {
-			var pseudoClass = pseudoClassMatches[j][1];
-			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				var nestedSelectors = parseAndSplitNestedSelectors(pseudoClassMatches[j][2]);
-
-				// Check if ANY selector in the list contains & (nesting selector)
-				// If so, skip validation for the entire selector list since & will be replaced at runtime
-				var hasAmpersand = false;
-				for (var k = 0; k < nestedSelectors.length; k++) {
-					if (ampersandRegExp.test(nestedSelectors[k])) {
-						hasAmpersand = true;
-						break;
-					}
-				}
-
-				// If any selector has &, skip validation for this entire pseudo-class
-				if (hasAmpersand) {
-					continue;
-				}
-
-				// Otherwise, validate each selector normally
-				for (var i = 0; i < nestedSelectors.length; i++) {
-					var nestedSelector = nestedSelectors[i];
-					if (!validatedSelectorsCache.hasOwnProperty(nestedSelector)) {
-						var nestedSelectorValidation = validateSelector(nestedSelector);
-						validatedSelectorsCache[nestedSelector] = nestedSelectorValidation;
-						if (!nestedSelectorValidation) {
-							validatedSelectorsCache[selector] = false;
-							return false;
-						}
-					} else if (!validatedSelectorsCache[nestedSelector]) {
-						validatedSelectorsCache[selector] = false;
-						return false;
-					}
-				}
-			}
-		}
-
-		var basicSelectorValidation = basicSelectorValidator(selector);
-		validatedSelectorsCache[selector] = basicSelectorValidation;
-
-		return basicSelectorValidation;
-	}
-
-	/**
-	 * Validates namespace selectors by checking if the namespace prefix is defined.
-	 * 
-	 * @param {string} selector - The CSS selector to validate
-	 * @returns {boolean} Returns true if the namespace is valid, false otherwise
-	 */
-	function validateNamespaceSelector(selector) {
-		// Check if selector contains a namespace prefix
-		// We need to ignore pipes inside attribute selectors
-		var pipeIndex = -1;
-		var inAttr = false;
-		var inSingleQuote = false;
-		var inDoubleQuote = false;
-
-		for (var i = 0; i < selector.length; i++) {
-			var char = selector[i];
-
-			// Handle escape sequences - skip hex escapes or simple escapes
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-
-			if (inSingleQuote) {
-				if (char === "'") {
-					inSingleQuote = false;
-				}
-			} else if (inDoubleQuote) {
-				if (char === '"') {
-					inDoubleQuote = false;
-				}
-			} else if (inAttr) {
-				if (char === "]") {
-					inAttr = false;
-				} else if (char === "'") {
-					inSingleQuote = true;
-				} else if (char === '"') {
-					inDoubleQuote = true;
-				}
-			} else {
-				if (char === "[") {
-					inAttr = true;
-				} else if (char === "|" && !inAttr) {
-					// This is a namespace separator, not an attribute operator
-					pipeIndex = i;
-					break;
-				}
-			}
-		}
-
-		if (pipeIndex === -1) {
-			return true; // No namespace, always valid
-		}
-
-		var namespacePrefix = selector.substring(0, pipeIndex);
-
-		// Universal namespace (*|) and default namespace (|) are always valid
-		if (namespacePrefix === '*' || namespacePrefix === '') {
-			return true;
-		}
-
-		// Check if the custom namespace prefix is defined
-		return definedNamespacePrefixes.hasOwnProperty(namespacePrefix);
-	}
-
-	/**
-	 * Normalizes escape sequences in a selector to match browser behavior.
-	 * Decodes escape sequences and re-encodes them in canonical form.
-	 * 
-	 * @param {string} selector - The selector to normalize
-	 * @returns {string} Normalized selector
-	 */
-	function normalizeSelectorEscapes(selector) {
-		var result = '';
-		var i = 0;
-		var nextChar = '';
-		
-		// Track context for identifier boundaries
-		var inIdentifier = false;
-		var inAttribute = false;
-		var attributeDepth = 0;
-		var needsEscapeForIdent = false;
-		var lastWasHexEscape = false;
-		
-		while (i < selector.length) {
-			var char = selector[i];
-			
-			// Track attribute selector context
-			if (char === '[' && !inAttribute) {
-				inAttribute = true;
-				attributeDepth = 1;
-				result += char;
-				i++;
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				continue;
-			}
-			
-			if (inAttribute) {
-				if (char === '[') attributeDepth++;
-				if (char === ']') {
-					attributeDepth--;
-					if (attributeDepth === 0) inAttribute = false;
-				}
-				// Don't normalize escapes inside attribute selectors
-				if (char === '\\' && i + 1 < selector.length) {
-					var escapeLen = getEscapeSequenceLength(selector, i);
-					result += selector.substr(i, escapeLen);
-					i += escapeLen;
-				} else {
-					result += char;
-					i++;
-				}
-				lastWasHexEscape = false;
-				continue;
-			}
-			
-			// Handle escape sequences
-			if (char === '\\') {
-				var escapeLen = getEscapeSequenceLength(selector, i);
-				if (escapeLen > 0) {
-					var escapeSeq = selector.substr(i, escapeLen);
-					var decoded = decodeEscapeSequence(escapeSeq);
-					var wasHexEscape = startsWithHexEscapeRegExp.test(escapeSeq);
-					var hadTerminatingSpace = wasHexEscape && escapeSeq[escapeLen - 1] === ' ';
-					nextChar = selector[i + escapeLen] || '';
-					
-					// Check if this character needs escaping
-					var needsEscape = false;
-					var useHexEscape = false;
-					
-					if (needsEscapeForIdent) {
-						// At start of identifier (after . # or -)
-						// Digits must be escaped, letters/underscore/_/- don't need escaping
-						if (isDigit(decoded)) {
-							needsEscape = true;
-							useHexEscape = true;
-						} else if (decoded === '-') {
-							// Dash at identifier start: keep escaped if it's the only character,
-							// otherwise it can be decoded
-							var remainingSelector = selector.substring(i + escapeLen);
-							var hasMoreIdentChars = remainingSelector && identCharRegExp.test(remainingSelector[0]);
-							needsEscape = !hasMoreIdentChars;
-						} else if (!identStartCharRegExp.test(decoded)) {
-							needsEscape = true;
-						}
-					} else {
-						if (specialCharsNeedEscapeRegExp.test(decoded)) {
-							needsEscape = true;
-						}
-					}
-					
-					if (needsEscape) {
-						if (useHexEscape) {
-							// Use normalized hex escape
-							var codePoint = decoded.charCodeAt(0);
-							var hex = codePoint.toString(16);
-							result += '\\' + hex;
-							// Add space if next char could continue the hex sequence, 
-							// or if at end of selector (to disambiguate the escape)
-							if (isHexDigit(nextChar) || !nextChar || afterHexEscapeSeparatorRegExp.test(nextChar)) {
-								result += ' ';
-								lastWasHexEscape = false;
-							} else {
-								lastWasHexEscape = true;
-							}
-						} else {
-							// Use simple character escape
-							result += '\\' + decoded;
-							lastWasHexEscape = false;
-						}
-					} else {
-						// No escape needed, use the character directly
-						// But if previous was hex escape (without terminating space) and this is alphanumeric, add space
-						if (lastWasHexEscape && !hadTerminatingSpace && isAlphanumeric(decoded)) {
-							result += ' ';
-						}
-						result += decoded;
-						// Preserve terminating space at end of selector (when followed by non-ident char)
-						if (hadTerminatingSpace && (!nextChar || afterHexEscapeSeparatorRegExp.test(nextChar))) {
-							result += ' ';
-						}
-						lastWasHexEscape = false;
-					}
-					
-					i += escapeLen;
-					// After processing escape, check if we're still needing ident validation
-					// Only stay in needsEscapeForIdent state if decoded was '-'
-					needsEscapeForIdent = needsEscapeForIdent && decoded === '-';
-					inIdentifier = true;
-					continue;
-				}
-			}
-			
-			// Handle regular characters
-			if (char === '.' || char === '#') {
-				result += char;
-				needsEscapeForIdent = true;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else if (char === '-' && needsEscapeForIdent) {
-				// Dash after . or # - next char must be valid ident start or digit (which needs escaping)
-				result += char;
-				needsEscapeForIdent = true;
-				lastWasHexEscape = false;
-				i++;
-			} else if (isDigit(char) && needsEscapeForIdent) {
-				// Digit at identifier start must be hex escaped
-				var codePoint = char.charCodeAt(0);
-				var hex = codePoint.toString(16);
-				result += '\\' + hex;
-				nextChar = selector[i + 1] || '';
-				// Add space if next char could continue the hex sequence,
-				// or if at end of selector (to disambiguate the escape)
-				if (isHexDigit(nextChar) || !nextChar || afterHexEscapeSeparatorRegExp.test(nextChar)) {
-					result += ' ';
-					lastWasHexEscape = false;
-				} else {
-					lastWasHexEscape = true;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				i++;
-			} else if (char === ':' || combinatorOrSeparatorRegExp.test(char)) {
-				// Combinators, separators, and pseudo-class markers reset identifier state
-				// Preserve trailing space from hex escape
-				if (!(char === ' ' && lastWasHexEscape && result[result.length - 1] === ' ')) {
-					result += char;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else if (isLetter(char) && lastWasHexEscape) {
-				// Letter after hex escape needs a space separator
-				result += ' ' + char;
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				lastWasHexEscape = false;
-				i++;
-			} else if (char === ' ' && lastWasHexEscape) {
-				// Trailing space - keep it if at end or before non-ident char
-				nextChar = selector[i + 1] || '';
-				if (!nextChar || trailingSpaceSeparatorRegExp.test(nextChar)) {
-					result += char;
-				}
-				needsEscapeForIdent = false;
-				inIdentifier = false;
-				lastWasHexEscape = false;
-				i++;
-			} else {
-				result += char;
-				needsEscapeForIdent = false;
-				inIdentifier = true;
-				lastWasHexEscape = false;
-				i++;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Helper function to decode all escape sequences in a string.
-	 * 
-	 * @param {string} str - The string to decode
-	 * @returns {string} The decoded string
-	 */
-	function decodeEscapeSequencesInString(str) {
-		var result = '';
-		for (var i = 0; i < str.length; i++) {
-			if (str[i] === '\\' && i + 1 < str.length) {
-				// Get the escape sequence length
-				var escapeLen = getEscapeSequenceLength(str, i);
-				if (escapeLen > 0) {
-					var escapeSeq = str.substr(i, escapeLen);
-					var decoded = decodeEscapeSequence(escapeSeq);
-					result += decoded;
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			result += str[i];
-		}
-		return result;
-	}
-
-	/**
-	 * Decodes a CSS escape sequence to its character value.
-	 * 
-	 * @param {string} escapeSeq - The escape sequence (including backslash)
-	 * @returns {string} The decoded character
-	 */
-	function decodeEscapeSequence(escapeSeq) {
-		if (escapeSeq.length < 2 || escapeSeq[0] !== '\\') {
-			return escapeSeq;
-		}
-		
-		var content = escapeSeq.substring(1);
-		
-		// Check if it's a hex escape
-		var hexMatch = content.match(hexEscapeSequenceRegExp);
-		if (hexMatch) {
-			var codePoint = parseInt(hexMatch[1], 16);
-			// Handle surrogate pairs for code points > 0xFFFF
-			if (codePoint > 0xFFFF) {
-				// Convert to surrogate pair
-				codePoint -= 0x10000;
-				var high = 0xD800 + (codePoint >> 10);
-				var low = 0xDC00 + (codePoint & 0x3FF);
-				return String.fromCharCode(high, low);
-			}
-			return String.fromCharCode(codePoint);
-		}
-		
-		// Simple escape - return the character after backslash
-		return content[0] || '';
-	}
-
-	/**
-	 * Normalizes attribute selectors by ensuring values are properly quoted with double quotes.
-	 * Examples:
-	 *   [attr=value] -> [attr="value"]
-	 *   [attr="value"] -> [attr="value"] (unchanged)
-	 *   [attr='value'] -> [attr="value"] (converted to double quotes)
-	 * 
-	 * @param {string} selector - The selector to normalize
-	 * @returns {string|null} Normalized selector, or null if invalid
-	 */
-	function normalizeAttributeSelectors(selector) {
-		var result = '';
-		var i = 0;
-		
-		while (i < selector.length) {
-			// Look for attribute selector start
-			if (selector[i] === '[') {
-				result += '[';
-				i++;
-				
-				var attrContent = '';
-				var depth = 1;
-				
-				// Find the closing bracket, handling nested brackets and escapes
-				while (i < selector.length && depth > 0) {
-					if (selector[i] === '\\' && i + 1 < selector.length) {
-						attrContent += selector.substring(i, i + 2);
-						i += 2;
-						continue;
-					}
-					if (selector[i] === '[') depth++;
-					if (selector[i] === ']') {
-						depth--;
-						if (depth === 0) break;
-					}
-					attrContent += selector[i];
-					i++;
-				}
-				
-				// Normalize the attribute content
-				var normalized = normalizeAttributeContent(attrContent);
-				if (normalized === null) {
-					// Invalid attribute selector (e.g., unclosed quote)
-					return null;
-				}
-				result += normalized;
-				if (i < selector.length && selector[i] === ']') {
-					result += ']';
-					i++;
-				}
-			} else {
-				result += selector[i];
-				i++;
-			}
-		}
-		
-		return result;
-	}
-
-	/**
-	 * Processes a quoted attribute value by checking for proper closure and decoding escape sequences.
-	 * @param {string} trimmedValue - The quoted value (with quotes)
-	 * @param {string} quoteChar - The quote character ('"' or "'")
-	 * @param {string} attrName - The attribute name
-	 * @param {string} operator - The attribute operator
-	 * @param {string} flag - Optional case-sensitivity flag
-	 * @returns {string|null} Normalized attribute content, or null if invalid
-	 */
-	function processQuotedAttributeValue(trimmedValue, quoteChar, attrName, operator, flag) {
-		// Check if the closing quote is properly closed (not escaped)
-		if (trimmedValue.length < 2) {
-			return null; // Too short
-		}
-		// Find the actual closing quote (not escaped)
-		var i = 1;
-		var foundClose = false;
-		while (i < trimmedValue.length) {
-			if (trimmedValue[i] === '\\' && i + 1 < trimmedValue.length) {
-				// Skip escape sequence
-				var escapeLen = getEscapeSequenceLength(trimmedValue, i);
-				i += escapeLen;
-				continue;
-			}
-			if (trimmedValue[i] === quoteChar) {
-				// Found closing quote
-				foundClose = (i === trimmedValue.length - 1);
-				break;
-			}
-			i++;
-		}
-		if (!foundClose) {
-			return null; // Unclosed quote - invalid
-		}
-		// Extract inner value and decode escape sequences
-		var innerValue = trimmedValue.slice(1, -1);
-		var decodedValue = decodeEscapeSequencesInString(innerValue);
-		// If decoded value contains quotes, we need to escape them
-		var escapedValue = decodedValue.replace(doubleQuoteRegExp, '\\"');
-		return attrName + operator + '"' + escapedValue + '"' + (flag ? ' ' + flag : '');
-	}
-
-	/**
-	 * Normalizes the content inside an attribute selector.
-	 * @param {string} content - The content between [ and ]
-	 * @returns {string} Normalized content, or null if invalid
-	 */
-	function normalizeAttributeContent(content) {
-		// Match: attribute-name [operator] [value] [flag]
-		var match = content.match(attributeSelectorContentRegExp);
-		
-		if (!match) {
-			// No operator (e.g., [disabled]) or malformed - return as is
-			return content;
-		}
-		
-		var attrName = match[1];
-		var operator = match[2];
-		var valueAndFlag = match[3].trim(); // Trim here instead of in regex
-		
-		// Check if there's a case-sensitivity flag (i or s) at the end
-		var flagMatch = valueAndFlag.match(attributeCaseFlagRegExp);
-		var value = flagMatch ? flagMatch[1] : valueAndFlag;
-		var flag = flagMatch ? flagMatch[2] : '';
-		
-		// Check for unclosed quotes - this makes the selector invalid
-		var trimmedValue = value.trim();
-		var firstChar = trimmedValue[0];
-		
-		if (firstChar === '"') {
-			return processQuotedAttributeValue(trimmedValue, '"', attrName, operator, flag);
-		}
-		
-		if (firstChar === "'") {
-			return processQuotedAttributeValue(trimmedValue, "'", attrName, operator, flag);
-		}
-		
-		// Check for unescaped special characters in unquoted values
-		// Escaped special characters are valid (e.g., \` is valid, but ` is not)
-		var hasUnescapedSpecialChar = false;
-		for (var i = 0; i < trimmedValue.length; i++) {
-			var char = trimmedValue[i];
-			if (char === '\\' && i + 1 < trimmedValue.length) {
-				// Skip the entire escape sequence
-				var escapeLen = getEscapeSequenceLength(trimmedValue, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			// Check if this is an unescaped special character
-			if (specialCharsNeedEscapeRegExp.test(char)) {
-				hasUnescapedSpecialChar = true;
-				break;
-			}
-		}
-		
-		if (hasUnescapedSpecialChar) {
-			return null; // Unescaped special characters not allowed in unquoted attribute values
-		}
-		
-		// Decode escape sequences in the value before quoting
-		// Inside quotes, special characters don't need escaping
-		var decodedValue = decodeEscapeSequencesInString(trimmedValue);
-		
-		// If the decoded value contains double quotes, escape them for the output
-		// (since we're using double quotes as delimiters)
-		var escapedValue = decodedValue.replace(backslashRegExp, '\\\\').replace(doubleQuoteRegExp, '\\"');
-		
-		// Unquoted value - add double quotes with decoded and re-escaped content
-		return attrName + operator + '"' + escapedValue + '"' + (flag ? ' ' + flag : '');
-	}
-
-	/**
-	 * Processes a CSS selector text 
-	 * 
-	 * @param {string} selectorText - The CSS selector text to process
-	 * @returns {string} The processed selector text with normalized whitespace and invalid selectors removed
-	 */
-	function processSelectorText(selectorText) {
-		// Normalize whitespace first
-		var normalized = selectorText.replace(whitespaceNormalizationRegExp, function (match, _, newline) {
-			if (newline) return " ";
-			return match;
-		});
-
-		// Normalize escape sequences to match browser behavior
-		normalized = normalizeSelectorEscapes(normalized);
-
-		// Normalize attribute selectors (add quotes to unquoted values)
-		// Returns null if invalid (e.g., unclosed quotes)
-		normalized = normalizeAttributeSelectors(normalized);
-		if (normalized === null) {
-			return ''; // Invalid selector - return empty to trigger validation failure
-		}
-
-		// Recursively process pseudo-classes to handle nesting
-		return processNestedPseudoClasses(normalized);
-	}
-
-	/**
-	 * Recursively processes pseudo-classes to filter invalid selectors
-	 * 
-	 * @param {string} selectorText - The CSS selector text to process
-	 * @param {number} depth - Current recursion depth (to prevent infinite loops)
-	 * @returns {string} The processed selector text with invalid selectors removed
-	 */
-	function processNestedPseudoClasses(selectorText, depth) {
-		// Prevent infinite recursion
-		if (typeof depth === 'undefined') {
-			depth = 0;
-		}
-		if (depth > 10) {
-			return selectorText;
-		}
-
-		var pseudoClassMatches = extractPseudoClasses(selectorText);
-
-		// If no pseudo-classes found, return as-is
-		if (pseudoClassMatches.length === 0) {
-			return selectorText;
-		}
-
-		// Build result by processing matches from right to left (to preserve positions)
-		var result = selectorText;
-
-		for (var j = pseudoClassMatches.length - 1; j >= 0; j--) {
-			var pseudoClass = pseudoClassMatches[j][1];
-			if (selectorListPseudoClasses.hasOwnProperty(pseudoClass)) {
-				var fullMatch = pseudoClassMatches[j][0];
-				var pseudoArgs = pseudoClassMatches[j][2];
-				var matchStart = pseudoClassMatches[j][3];
-
-				// Check if ANY selector contains & BEFORE processing
-				var nestedSelectorsRaw = parseAndSplitNestedSelectors(pseudoArgs);
-				var hasAmpersand = false;
-				for (var k = 0; k < nestedSelectorsRaw.length; k++) {
-					if (ampersandRegExp.test(nestedSelectorsRaw[k])) {
-						hasAmpersand = true;
-						break;
-					}
-				}
-
-				// If & is present, skip all processing (keep everything unchanged)
-				if (hasAmpersand) {
-					continue;
-				}
-
-				// Recursively process the arguments
-				var processedArgs = processNestedPseudoClasses(pseudoArgs, depth + 1);
-				var nestedSelectors = parseAndSplitNestedSelectors(processedArgs);
-
-				// Filter out invalid selectors
-				var validSelectors = [];
-				for (var i = 0; i < nestedSelectors.length; i++) {
-					var nestedSelector = nestedSelectors[i];
-					if (basicSelectorValidator(nestedSelector)) {
-						validSelectors.push(nestedSelector);
-					}
-				}
-
-				// Reconstruct the pseudo-class with only valid selectors
-				var newArgs = validSelectors.join(', ');
-				var newPseudoClass = ':' + pseudoClass + '(' + newArgs + ')';
-
-				// Replace in the result string using position (processing right to left preserves positions)
-				result = result.substring(0, matchStart) + newPseudoClass + result.substring(matchStart + fullMatch.length);
-			}
-		}
-
-		return result;
-
-		return normalized;
-	}
-
-	/**
-	 * Checks if a selector contains newlines inside quoted strings.
-	 * Uses iterative parsing to avoid regex backtracking issues.
-	 * @param {string} selectorText - The selector to check
-	 * @returns {boolean} True if newlines found inside quotes
-	 */
-	function hasNewlineInQuotedString(selectorText) {
-		for (var i = 0; i < selectorText.length; i++) {
-			var char = selectorText[i];
-			
-			// Start of single-quoted string
-			if (char === "'") {
-				i++;
-				while (i < selectorText.length) {
-					if (selectorText[i] === '\\' && i + 1 < selectorText.length) {
-						// Skip escape sequence
-						i += 2;
-						continue;
-					}
-					if (selectorText[i] === "'") {
-						// End of string
-						break;
-					}
-					if (selectorText[i] === '\r' || selectorText[i] === '\n') {
-						return true;
-					}
-					i++;
-				}
-			}
-			// Start of double-quoted string
-			else if (char === '"') {
-				i++;
-				while (i < selectorText.length) {
-					if (selectorText[i] === '\\' && i + 1 < selectorText.length) {
-						// Skip escape sequence
-						i += 2;
-						continue;
-					}
-					if (selectorText[i] === '"') {
-						// End of string
-						break;
-					}
-					if (selectorText[i] === '\r' || selectorText[i] === '\n') {
-						return true;
-					}
-					i++;
-				}
-			}
-		}
-		return false;
-	}
-
-	/**
-	 * Checks if a given CSS selector text is valid by splitting it by commas
-	 * and validating each individual selector using the `validateSelector` function.
-	 *
-	 * @param {string} selectorText - The CSS selector text to validate. Can contain multiple selectors separated by commas.
-	 * @returns {boolean} Returns true if all selectors are valid, otherwise false.
-	 */
-	function isValidSelectorText(selectorText) {
-		// TODO: The same validations here needs to be reused in CSSStyleRule.selectorText setter
-		// TODO: Move these validation logic to a shared function to be reused in CSSStyleRule.selectorText setter
-
-		// Check for empty or whitespace-only selector
-		if (!selectorText || selectorText.trim() === '') {
-			return false;
-		}
-
-		// Check for empty selector lists in pseudo-classes (e.g., :is(), :not(), :where(), :has())
-		// These are invalid after filtering out invalid selectors
-		if (emptyPseudoClassRegExp.test(selectorText)) {
-			return false;
-		}
-
-		// Check for newlines inside single or double quotes
-		// Uses helper function to avoid regex security issues
-		if (hasNewlineInQuotedString(selectorText)) {
-			return false;
-		}
-
-		// Split selectorText by commas and validate each part
-		var selectors = parseAndSplitNestedSelectors(selectorText);
-		for (var i = 0; i < selectors.length; i++) {
-			var selector = selectors[i].trim();
-			if (!validateSelector(selector) || !validateNamespaceSelector(selector)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	function pushToAncestorRules(rule) {
-		ancestorRules.push(rule);
-	}
-
-	function parseError(message, isNested) {
-		var lines = token.substring(0, i).split('\n');
-		var lineCount = lines.length;
-		var charCount = lines.pop().length + 1;
-		var error = new Error(message + ' (line ' + lineCount + ', char ' + charCount + ')');
-		error.line = lineCount;
-		/* jshint sub : true */
-		error['char'] = charCount;
-		error.styleSheet = styleSheet;
-		error.isNested = !!isNested;
-		// Print the error but continue parsing the sheet
-		try {
-			throw error;
-		} catch (e) {
-			errorHandler && errorHandler(e);
-		}
-	};
-
-	/**
-	 * Handles invalid selectors with unmatched quotes by skipping the entire rule block.
-	 * @param {string} nextState - The parser state to transition to after skipping
-	 */
-	function handleUnmatchedQuoteInSelector(nextState) {
-		// parseError('Invalid selector with unmatched quote: ' + buffer.trim());
-		// Skip this entire invalid rule including its block
-		var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-		if (ruleClosingMatch) {
-			i += ruleClosingMatch.index + ruleClosingMatch[0].length - 1;
-		}
-		styleRule = null;
-		buffer = "";
-		hasUnmatchedQuoteInSelector = false; // Reset flag
-		state = nextState;
-	}
-
-	// Helper functions to check character types
-	function isSelectorStartChar(char) {
-		return '.:#&*['.indexOf(char) !== -1;
-	}
-
-	function isWhitespaceChar(char) {
-		return ' \t\n\r'.indexOf(char) !== -1;
-	}
-
-	// Helper functions for character type checking (faster than regex for single chars)
-	function isDigit(char) {
-		var code = char.charCodeAt(0);
-		return code >= 0x0030 && code <= 0x0039; // 0-9
-	}
-
-	function isHexDigit(char) {
-		if (!char) return false;
-		var code = char.charCodeAt(0);
-		return (code >= 0x0030 && code <= 0x0039) || // 0-9
-		       (code >= 0x0041 && code <= 0x0046) || // A-F
-		       (code >= 0x0061 && code <= 0x0066);   // a-f
-	}
-
-	function isLetter(char) {
-		if (!char) return false;
-		var code = char.charCodeAt(0);
-		return (code >= 0x0041 && code <= 0x005A) || // A-Z
-		       (code >= 0x0061 && code <= 0x007A);   // a-z
-	}
-
-	function isAlphanumeric(char) {
-		var code = char.charCodeAt(0);
-		return (code >= 0x0030 && code <= 0x0039) || // 0-9
-		       (code >= 0x0041 && code <= 0x005A) || // A-Z
-		       (code >= 0x0061 && code <= 0x007A);   // a-z
-	}
-
-	/**
-	 * Get the length of an escape sequence starting at the given position.
-	 * CSS escape sequences are:
-	 * - Backslash followed by 1-6 hex digits, optionally followed by a whitespace (consumed)
-	 * - Backslash followed by any non-hex character
-	 * @param {string} str - The string to check
-	 * @param {number} pos - Position of the backslash
-	 * @returns {number} Number of characters in the escape sequence (including backslash)
-	 */
-	function getEscapeSequenceLength(str, pos) {
-		if (str[pos] !== '\\' || pos + 1 >= str.length) {
-			return 0;
-		}
-		
-		var nextChar = str[pos + 1];
-		
-		// Check if it's a hex escape
-		if (isHexDigit(nextChar)) {
-			var hexLength = 1;
-			// Count up to 6 hex digits
-			while (hexLength < 6 && pos + 1 + hexLength < str.length && isHexDigit(str[pos + 1 + hexLength])) {
-				hexLength++;
-			}
-			// Check if followed by optional whitespace (which gets consumed)
-			if (pos + 1 + hexLength < str.length && isWhitespaceChar(str[pos + 1 + hexLength])) {
-				return 1 + hexLength + 1; // backslash + hex digits + whitespace
-			}
-			return 1 + hexLength; // backslash + hex digits
-		}
-		
-		// Simple escape: backslash + any character
-		return 2;
-	}
-
-	/**
-	 * Check if a string contains an unescaped occurrence of a specific character
-	 * @param {string} str - The string to search
-	 * @param {string} char - The character to look for
-	 * @returns {boolean} True if the character appears unescaped
-	 */
-	function containsUnescaped(str, char) {
-		for (var i = 0; i < str.length; i++) {
-			if (str[i] === '\\') {
-				var escapeLen = getEscapeSequenceLength(str, i);
-				if (escapeLen > 0) {
-					i += escapeLen - 1; // -1 because loop will increment
-					continue;
-				}
-			}
-			if (str[i] === char) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	var endingIndex = token.length - 1;
-	var initialEndingIndex = endingIndex;
-
-	for (var character; (character = token.charAt(i)); i++) {
-		if (i === endingIndex) {
-			switch (state) {
-				case "importRule":
-				case "namespaceRule":
-				case "layerBlock":
-					if (character !== ";") {
-						token += ";";
-						endingIndex += 1;
-					}
-					break;
-				case "value":
-					if (character !== "}") {
-						if (character === ";") {
-							token += "}"
-						} else {
-							token += ";";
-						}
-						endingIndex += 1;
-						break;
-					}
-				case "name":
-				case "before-name":
-					if (character === "}") {
-						token += " "
-					} else {
-						token += "}"
-					}
-					endingIndex += 1
-					break;
-				case "before-selector":
-					if (character !== "}" && currentScope !== styleSheet) {
-						token += "}"
-						endingIndex += 1
-						break;
-					}
-			}
-		}
-
-		// Handle escape sequences before processing special characters
-		// CSS escape sequences: \HHHHHH (1-6 hex digits) optionally followed by whitespace, or \ + any char
-		if (character === '\\' && i + 1 < token.length) {
-			var escapeLen = getEscapeSequenceLength(token, i);
-			if (escapeLen > 0) {
-				buffer += token.substr(i, escapeLen);
-				i += escapeLen - 1; // -1 because loop will increment
-				continue;
-			}
-		}
-
-		switch (character) {
-
-			case " ":
-			case "\t":
-			case "\r":
-			case "\n":
-			case "\f":
-				if (SIGNIFICANT_WHITESPACE[state]) {
-					buffer += character;
-				}
-				break;
-
-			// String
-			case '"':
-				index = i + 1;
-				do {
-					index = token.indexOf('"', index) + 1;
-					if (!index) {
-						parseError('Unmatched "');
-						// If we're parsing a selector, flag it as invalid
-						if (state === "selector" || state === "atRule") {
-							hasUnmatchedQuoteInSelector = true;
-						}
-					}
-				} while (token[index - 2] === '\\');
-				if (index === 0) {
-					break;
-				}
-				buffer += token.slice(i, index);
-				i = index - 1;
-				switch (state) {
-					case 'before-value':
-						state = 'value';
-						break;
-					case 'importRule-begin':
-						state = 'importRule';
-						if (i === endingIndex) {
-							token += ';'
-						}
-						break;
-					case 'namespaceRule-begin':
-						state = 'namespaceRule';
-						if (i === endingIndex) {
-							token += ';'
-						}
-						break;
-				}
-				break;
-
-			case "'":
-				index = i + 1;
-				do {
-					index = token.indexOf("'", index) + 1;
-					if (!index) {
-						parseError("Unmatched '");
-						// If we're parsing a selector, flag it as invalid
-						if (state === "selector" || state === "atRule") {
-							hasUnmatchedQuoteInSelector = true;
-						}
-					}
-				} while (token[index - 2] === '\\');
-				if (index === 0) {
-					break;
-				}
-				buffer += token.slice(i, index);
-				i = index - 1;
-				switch (state) {
-					case 'before-value':
-						state = 'value';
-						break;
-					case 'importRule-begin':
-						state = 'importRule';
-						break;
-					case 'namespaceRule-begin':
-						state = 'namespaceRule';
-						break;
-				}
-				break;
-
-			// Comment
-			case "/":
-				if (token.charAt(i + 1) === "*") {
-					i += 2;
-					index = token.indexOf("*/", i);
-					if (index === -1) {
-						i = token.length - 1;
-						buffer = "";
-					} else {
-						i = index + 1;
-					}
-				} else {
-					buffer += character;
-				}
-				if (state === "importRule-begin") {
-					buffer += " ";
-					state = "importRule";
-				}
-				if (state === "namespaceRule-begin") {
-					buffer += " ";
-					state = "namespaceRule";
-				}
-				break;
-
-			// At-rule
-			case "@":
-				if (nestedSelectorRule) {
-					if (styleRule && styleRule.constructor.name === "CSSNestedDeclarations") {
-						currentScope.cssRules.push(styleRule);
-					}
-					// Only reset styleRule to parent if styleRule is not the nestedSelectorRule itself
-					// This preserves nested selectors when followed immediately by @-rules
-					if (styleRule !== nestedSelectorRule && nestedSelectorRule.parentRule && nestedSelectorRule.parentRule.constructor.name === "CSSStyleRule") {
-						styleRule = nestedSelectorRule.parentRule;
-					}
-					// Don't reset nestedSelectorRule here - preserve it through @-rules
-				}
-				if (token.indexOf("@-moz-document", i) === i) {
-					validateAtRule("@-moz-document", function () {
-						state = "documentRule-begin";
-						documentRule = new CSSOM.CSSDocumentRule();
-						documentRule.__starts = i;
-						i += "-moz-document".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@media", i) === i) {
-					validateAtRule("@media", function () {
-						state = "atBlock";
-						mediaRule = new CSSOM.CSSMediaRule();
-						mediaRule.__starts = i;
-						i += "media".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@container", i) === i) {
-					validateAtRule("@container", function () {
-						state = "containerBlock";
-						containerRule = new CSSOM.CSSContainerRule();
-						containerRule.__starts = i;
-						i += "container".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@counter-style", i) === i) {
-					buffer = "";
-					// @counter-style can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@counter-style", function () {
-						state = "counterStyleBlock"
-						counterStyleRule = new CSSOM.CSSCounterStyleRule();
-						counterStyleRule.__starts = i;
-						i += "counter-style".length;
-					}, cannotBeNested);
-					break;
-				} else if (token.indexOf("@property", i) === i) {
-					buffer = "";
-					// @property can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@property", function () {
-						state = "propertyBlock"
-						propertyRule = new CSSOM.CSSPropertyRule();
-						propertyRule.__starts = i;
-						i += "property".length;
-					}, cannotBeNested);
-					break;
-				} else if (token.indexOf("@scope", i) === i) {
-					validateAtRule("@scope", function () {
-						state = "scopeBlock";
-						scopeRule = new CSSOM.CSSScopeRule();
-						scopeRule.__starts = i;
-						i += "scope".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@layer", i) === i) {
-					validateAtRule("@layer", function () {
-						state = "layerBlock"
-						layerBlockRule = new CSSOM.CSSLayerBlockRule();
-						layerBlockRule.__starts = i;
-						i += "layer".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@page", i) === i) {
-					validateAtRule("@page", function () {
-						state = "pageBlock"
-						pageRule = new CSSOM.CSSPageRule();
-						pageRule.__starts = i;
-						i += "page".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@supports", i) === i) {
-					validateAtRule("@supports", function () {
-						state = "conditionBlock";
-						supportsRule = new CSSOM.CSSSupportsRule();
-						supportsRule.__starts = i;
-						i += "supports".length;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@host", i) === i) {
-					validateAtRule("@host", function () {
-						state = "hostRule-begin";
-						i += "host".length;
-						hostRule = new CSSOM.CSSHostRule();
-						hostRule.__starts = i;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@starting-style", i) === i) {
-					validateAtRule("@starting-style", function () {
-						state = "startingStyleRule-begin";
-						i += "starting-style".length;
-						startingStyleRule = new CSSOM.CSSStartingStyleRule();
-						startingStyleRule.__starts = i;
-					});
-					buffer = "";
-					break;
-				} else if (token.indexOf("@import", i) === i) {
-					buffer = "";
-					validateAtRule("@import", function () {
-						state = "importRule-begin";
-						i += "import".length;
-						buffer += "@import";
-					}, true);
-					break;
-				} else if (token.indexOf("@namespace", i) === i) {
-					buffer = "";
-					validateAtRule("@namespace", function () {
-						state = "namespaceRule-begin";
-						i += "namespace".length;
-						buffer += "@namespace";
-					}, true);
-					break;
-				} else if (token.indexOf("@font-face", i) === i) {
-					buffer = "";
-					// @font-face can be nested only inside CSSScopeRule or CSSConditionRule
-					// and only if there's no CSSStyleRule in the parent chain
-					var cannotBeNested = !canAtRuleBeNested();
-					validateAtRule("@font-face", function () {
-						state = "fontFaceRule-begin";
-						i += "font-face".length;
-						fontFaceRule = new CSSOM.CSSFontFaceRule();
-						fontFaceRule.__starts = i;
-					}, cannotBeNested);
-					break;
-				} else {
-					// Reset lastIndex before using global regex (shared instance)
-					atKeyframesRegExp.lastIndex = i;
-					var matchKeyframes = atKeyframesRegExp.exec(token);
-					if (matchKeyframes && matchKeyframes.index === i) {
-						state = "keyframesRule-begin";
-						keyframesRule = new CSSOM.CSSKeyframesRule();
-						keyframesRule.__starts = i;
-						keyframesRule._vendorPrefix = matchKeyframes[1]; // Will come out as undefined if no prefix was found
-						i += matchKeyframes[0].length - 1;
-						buffer = "";
-						break;
-					} else if (state === "selector") {
-						state = "atRule";
-					}
-				}
-				buffer += character;
-				break;
-
-			case "{":
-				if (currentScope === topScope) {
-					nestedSelectorRule = null;
-				}
-				if (state === 'before-selector') {
-					parseError("Unexpected {");
-					i = ignoreBalancedBlock(i, token.slice(i));
-					break;
-				}
-				if (state === "selector" || state === "atRule") {
-					if (!nestedSelectorRule && containsUnescaped(buffer, ";")) {
-						var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-						if (ruleClosingMatch) {
-							styleRule = null;
-							buffer = "";
-							state = "before-selector";
-							i += ruleClosingMatch.index + ruleClosingMatch[0].length;
-							break;
-						}
-					}
-
-					// Ensure styleRule exists before trying to set properties on it
-					if (!styleRule) {
-						styleRule = new CSSOM.CSSStyleRule();
-						styleRule.__starts = i;
-					}
-
-					// Check if tokenizer detected an unmatched quote BEFORE setting up the rule
-					if (hasUnmatchedQuoteInSelector) {
-						handleUnmatchedQuoteInSelector("before-selector");
-						break;
-					}
-
-					var originalParentRule = parentRule;
-
-					if (parentRule) {
-						styleRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = styleRule;
-					
-					var processedSelectorText = processSelectorText(buffer.trim());
-					// In a nested selector, ensure each selector contains '&' at the beginning, except for selectors that already have '&' somewhere
-					if (originalParentRule && originalParentRule.constructor.name === "CSSStyleRule") {
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).map(function (sel) {
-							// Add & at the beginning if there's no & in the selector, or if it starts with a combinator
-							return (sel.indexOf('&') === -1 || startsWithCombinatorRegExp.test(sel)) ? '& ' + sel : sel;
-						}).join(', ');
-					} else {
-						// Normalize comma spacing: split by commas and rejoin with ", "
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).join(', ');
-					}
-					styleRule.style.__starts = i;
-					styleRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "atBlock") {
-					mediaRule.media.mediaText = buffer.trim();
-
-					if (parentRule) {
-						mediaRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						// If entering @media from within a CSSStyleRule, set nestedSelectorRule
-						// so that & selectors and declarations work correctly inside
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = mediaRule;
-					pushToAncestorRules(mediaRule);
-					mediaRule.__parentStyleSheet = styleSheet;
-					
-					// Don't reset styleRule to null if it's a nested CSSStyleRule that will contain this @-rule
-					if (!styleRule || styleRule.constructor.name !== "CSSStyleRule" || !styleRule.__parentRule) {
-						styleRule = null; // Reset styleRule when entering @-rule
-					}
-					
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "containerBlock") {
-					containerRule.__conditionText = buffer.trim();
-
-					if (parentRule) {
-						containerRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-					currentScope = parentRule = containerRule;
-					pushToAncestorRules(containerRule);
-					containerRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "counterStyleBlock") {
-					var counterStyleName = buffer.trim().replace(newlineRemovalRegExp, "");
-					// Validate: name cannot be empty, contain whitespace, or contain dots
-					var isValidCounterStyleName = counterStyleName.length > 0 && !whitespaceAndDotRegExp.test(counterStyleName);
-
-					if (isValidCounterStyleName) {
-						counterStyleRule.name = counterStyleName;
-						if (parentRule) {
-							counterStyleRule.__parentRule = parentRule;
-						}
-						counterStyleRule.__parentStyleSheet = styleSheet;
-						styleRule = counterStyleRule;
-					}
-					buffer = "";
-				} else if (state === "propertyBlock") {
-					var propertyName = buffer.trim().replace(newlineRemovalRegExp, "");
-					// Validate: name must start with -- (custom property)
-					var isValidPropertyName = propertyName.indexOf("--") === 0;
-
-					if (isValidPropertyName) {
-						propertyRule.__name = propertyName;
-						if (parentRule) {
-							propertyRule.__parentRule = parentRule;
-						}
-						propertyRule.__parentStyleSheet = styleSheet;
-						styleRule = propertyRule;
-					}
-					buffer = "";
-				} else if (state === "conditionBlock") {
-					supportsRule.__conditionText = buffer.trim();
-
-					if (parentRule) {
-						supportsRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = supportsRule;
-					pushToAncestorRules(supportsRule);
-					supportsRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "scopeBlock") {
-					var parsedScopePrelude = parseScopePrelude(buffer.trim());
-
-					if (parsedScopePrelude.hasStart) {
-						scopeRule.__start = parsedScopePrelude.startSelector;
-					}
-					if (parsedScopePrelude.hasEnd) {
-						scopeRule.__end = parsedScopePrelude.endSelector;
-					}
-					if (parsedScopePrelude.hasOnlyEnd) {
-						scopeRule.__end = parsedScopePrelude.endSelector;
-					}
-
-					if (parentRule) {
-						scopeRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-					currentScope = parentRule = scopeRule;
-					pushToAncestorRules(scopeRule);
-					scopeRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "layerBlock") {
-					layerBlockRule.name = buffer.trim();
-
-					var isValidName = layerBlockRule.name.length === 0 || layerBlockRule.name.match(cssCustomIdentifierRegExp) !== null;
-
-					if (isValidName) {
-						if (parentRule) {
-							layerBlockRule.__parentRule = parentRule;
-							pushToAncestorRules(parentRule);
-							if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-								nestedSelectorRule = parentRule;
-							}
-						}
-
-						currentScope = parentRule = layerBlockRule;
-						pushToAncestorRules(layerBlockRule);
-						layerBlockRule.__parentStyleSheet = styleSheet;
-					}
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "pageBlock") {
-					pageRule.selectorText = buffer.trim();
-
-					if (parentRule) {
-						pageRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = pageRule;
-					pageRule.__parentStyleSheet = styleSheet;
-					styleRule = pageRule;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "hostRule-begin") {
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-					}
-
-					currentScope = parentRule = hostRule;
-					pushToAncestorRules(hostRule);
-					hostRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "startingStyleRule-begin") {
-					if (parentRule) {
-						startingStyleRule.__parentRule = parentRule;
-						pushToAncestorRules(parentRule);
-						if (parentRule.constructor.name === "CSSStyleRule" && !nestedSelectorRule) {
-							nestedSelectorRule = parentRule;
-						}
-					}
-
-					currentScope = parentRule = startingStyleRule;
-					pushToAncestorRules(startingStyleRule);
-					startingStyleRule.__parentStyleSheet = styleSheet;
-					styleRule = null; // Reset styleRule when entering @-rule
-					buffer = "";
-					state = "before-selector";
-
-				} else if (state === "fontFaceRule-begin") {
-					if (parentRule) {
-						fontFaceRule.__parentRule = parentRule;
-					}
-					fontFaceRule.__parentStyleSheet = styleSheet;
-					styleRule = fontFaceRule;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "keyframesRule-begin") {
-					keyframesRule.name = buffer.trim();
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-						keyframesRule.__parentRule = parentRule;
-					}
-					keyframesRule.__parentStyleSheet = styleSheet;
-					currentScope = parentRule = keyframesRule;
-					buffer = "";
-					state = "keyframeRule-begin";
-				} else if (state === "keyframeRule-begin") {
-					styleRule = new CSSOM.CSSKeyframeRule();
-					styleRule.keyText = buffer.trim();
-					styleRule.__starts = i;
-					buffer = "";
-					state = "before-name";
-				} else if (state === "documentRule-begin") {
-					// FIXME: what if this '{' is in the url text of the match function?
-					documentRule.matcher.matcherText = buffer.trim();
-					if (parentRule) {
-						pushToAncestorRules(parentRule);
-						documentRule.__parentRule = parentRule;
-					}
-					currentScope = parentRule = documentRule;
-					pushToAncestorRules(documentRule);
-					documentRule.__parentStyleSheet = styleSheet;
-					buffer = "";
-					state = "before-selector";
-				} else if (state === "before-name" || state === "name") {
-					// @font-face and similar rules don't support nested selectors
-					// If we encounter a nested selector block inside them, skip it
-					if (styleRule.constructor.name === "CSSFontFaceRule" ||
-						styleRule.constructor.name === "CSSKeyframeRule" ||
-						(styleRule.constructor.name === "CSSPageRule" && parentRule === styleRule)) {
-						// Skip the nested block
-						var ruleClosingMatch = token.slice(i).match(forwardRuleClosingBraceRegExp);
-						if (ruleClosingMatch) {
-							i += ruleClosingMatch.index + ruleClosingMatch[0].length - 1;
-							buffer = "";
-							state = "before-name";
-							break;
-						}
-					}
-
-					if (styleRule.constructor.name === "CSSNestedDeclarations") {
-						if (styleRule.style.length) {
-							parentRule.cssRules.push(styleRule);
-							styleRule.__parentRule = parentRule;
-							styleRule.__parentStyleSheet = styleSheet;
-							pushToAncestorRules(parentRule);
-						} else {
-							// If the styleRule is empty, we can assume that it's a nested selector
-							pushToAncestorRules(parentRule);
-						}
-					} else {
-						currentScope = parentRule = styleRule;
-						pushToAncestorRules(parentRule);
-						styleRule.__parentStyleSheet = styleSheet;
-					}
-
-					styleRule = new CSSOM.CSSStyleRule();
-					
-					// Check if tokenizer detected an unmatched quote BEFORE setting up the rule
-					if (hasUnmatchedQuoteInSelector) {
-						handleUnmatchedQuoteInSelector("before-name");
-						break;
-					}
-					
-					var processedSelectorText = processSelectorText(buffer.trim());
-					// In a nested selector, ensure each selector contains '&' at the beginning, except for selectors that already have '&' somewhere
-					if (parentRule.constructor.name === "CSSScopeRule" || (parentRule.constructor.name !== "CSSStyleRule" && parentRule.parentRule === null)) {
-						// Normalize comma spacing: split by commas and rejoin with ", "
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).join(', ');
-					} else {
-						styleRule.selectorText = parseAndSplitNestedSelectors(processedSelectorText).map(function (sel) {
-							// Add & at the beginning if there's no & in the selector, or if it starts with a combinator
-							return (sel.indexOf('&') === -1 || startsWithCombinatorRegExp.test(sel)) ? '& ' + sel : sel;
-						}).join(', ');
-					}
-					styleRule.style.__starts = i - buffer.length;
-					styleRule.__parentRule = parentRule;
-					// Only set nestedSelectorRule if we're directly inside a CSSStyleRule or CSSScopeRule,
-					// not inside other grouping rules like @media/@supports
-					if (parentRule.constructor.name === "CSSStyleRule" || parentRule.constructor.name === "CSSScopeRule") {
-						nestedSelectorRule = styleRule;
-					}
-					
-					// Set __parentStyleSheet for the new nested styleRule
-					styleRule.__parentStyleSheet = styleSheet;
-					
-					// Update currentScope and parentRule to the new nested styleRule
-					// so that subsequent content (like @-rules) will be children of this rule
-					currentScope = parentRule = styleRule;
-
-					buffer = "";
-					state = "before-name";
-				}
-				break;
-
-			case ":":
-				if (state === "name") {
-					// It can be a nested selector, let's check
-					var openBraceBeforeMatch = token.slice(i).match(declarationOrOpenBraceRegExp);
-					var hasOpenBraceBefore = openBraceBeforeMatch && openBraceBeforeMatch[0] === '{';
-					if (hasOpenBraceBefore) {
-						// Is a selector
-						buffer += character;
-					} else {
-						// Is a declaration
-						name = buffer.trim();
-						buffer = "";
-						state = "before-value";
-					}
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case "(":
-				if (state === 'value') {
-					// ie css expression mode
-					if (buffer.trim() === 'expression') {
-						var info = (new CSSOM.CSSValueExpression(token, i)).parse();
-
-						if (info.error) {
-							parseError(info.error);
-						} else {
-							buffer += info.expression;
-							i = info.idx;
-						}
-					} else {
-						state = 'value-parenthesis';
-						//always ensure this is reset to 1 on transition
-						//from value to value-parenthesis
-						valueParenthesisDepth = 1;
-						buffer += character;
-					}
-				} else if (state === 'value-parenthesis') {
-					valueParenthesisDepth++;
-					buffer += character;
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case ")":
-				if (state === 'value-parenthesis') {
-					valueParenthesisDepth--;
-					if (valueParenthesisDepth === 0) state = 'value';
-				}
-				buffer += character;
-				break;
-
-			case "!":
-				if (state === "value" && token.indexOf("!important", i) === i) {
-					priority = "important";
-					i += "important".length;
-				} else {
-					buffer += character;
-				}
-				break;
-
-			case ";":
-				switch (state) {
-					case "before-value":
-					case "before-name":
-						parseError("Unexpected ;");
-						buffer = "";
-						state = "before-name";
-						break;
-					case "value":
-						styleRule.style.setProperty(name, buffer.trim(), priority, parseError);
-						priority = "";
-						buffer = "";
-						state = "before-name";
-						break;
-					case "atRule":
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "importRule":
-						var isValid = topScope.cssRules.length === 0 || topScope.cssRules.some(function (rule) {
-							return ['CSSImportRule', 'CSSLayerStatementRule'].indexOf(rule.constructor.name) !== -1
-						});
-						if (isValid) {
-							importRule = new CSSOM.CSSImportRule();
-							if (opts && opts.globalObject && opts.globalObject.CSSStyleSheet) {
-								importRule.__styleSheet = new opts.globalObject.CSSStyleSheet();
-							}
-							importRule.styleSheet.__constructed = false;
-							importRule.__parentStyleSheet = importRule.styleSheet.__parentStyleSheet = styleSheet;
-							importRule.parse(buffer + character);
-							topScope.cssRules.push(importRule);
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "namespaceRule":
-						var isValid = topScope.cssRules.length === 0 || topScope.cssRules.every(function (rule) {
-							return ['CSSImportRule', 'CSSLayerStatementRule', 'CSSNamespaceRule'].indexOf(rule.constructor.name) !== -1
-						});
-						if (isValid) {
-							try {
-								// Validate namespace syntax before creating the rule
-								var testNamespaceRule = new CSSOM.CSSNamespaceRule();
-								testNamespaceRule.parse(buffer + character);
-
-								namespaceRule = testNamespaceRule;
-								namespaceRule.__parentStyleSheet = styleSheet;
-								topScope.cssRules.push(namespaceRule);
-
-								// Track the namespace prefix for validation
-								if (namespaceRule.prefix) {
-									definedNamespacePrefixes[namespaceRule.prefix] = namespaceRule.namespaceURI;
-								}
-							} catch (e) {
-								parseError(e.message);
-							}
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					case "layerBlock":
-						var nameListStr = buffer.trim().split(",").map(function (name) {
-							return name.trim();
-						});
-						var isInvalid = nameListStr.some(function (name) {
-							return name.trim().match(cssCustomIdentifierRegExp) === null;
-						});
-
-						// Check if there's a CSSStyleRule in the parent chain
-						var hasStyleRuleParent = false;
-						if (parentRule) {
-							var checkParent = parentRule;
-							while (checkParent) {
-								if (checkParent.constructor.name === "CSSStyleRule") {
-									hasStyleRuleParent = true;
-									break;
-								}
-								checkParent = checkParent.__parentRule;
-							}
-						}
-
-						if (!isInvalid && !hasStyleRuleParent) {
-							layerStatementRule = new CSSOM.CSSLayerStatementRule();
-							layerStatementRule.__parentStyleSheet = styleSheet;
-							layerStatementRule.__starts = layerBlockRule.__starts;
-							layerStatementRule.__ends = i;
-							layerStatementRule.nameList = nameListStr;
-
-							// Add to parent rule if nested, otherwise to top scope
-							if (parentRule) {
-								layerStatementRule.__parentRule = parentRule;
-								parentRule.cssRules.push(layerStatementRule);
-							} else {
-								topScope.cssRules.push(layerStatementRule);
-							}
-						}
-						buffer = "";
-						state = "before-selector";
-						break;
-					default:
-						buffer += character;
-						break;
-				}
-				break;
-
-			case "}":
-				if (state === "counterStyleBlock") {
-					// FIXME : Implement missing properties on CSSCounterStyleRule interface and update parse method
-					// For now it's just assigning entire rule text
-					if (counterStyleRule.name) {
-						// Only process if name was set (valid)
-						counterStyleRule.parse("@counter-style " + counterStyleRule.name + " { " + buffer + " }");
-						counterStyleRule.__ends = i + 1;
-						// Add to parent's cssRules
-						if (counterStyleRule.__parentRule) {
-							counterStyleRule.__parentRule.cssRules.push(counterStyleRule);
-						} else {
-							topScope.cssRules.push(counterStyleRule);
-						}
-					}
-					// Restore currentScope to parent after closing this rule
-					if (counterStyleRule.__parentRule) {
-						currentScope = counterStyleRule.__parentRule;
-					}
-					styleRule = null;
-					buffer = "";
-					state = "before-selector";
-					break;
-				}
-				if (state === "propertyBlock") {
-					// Only process if name was set (valid)
-					if (propertyRule.__name) {
-						var parseSuccess = propertyRule.parse("@property " + propertyRule.__name + " { " + buffer + " }");
-						// Only add the rule if parse was successful (syntax, inherits, and initial-value validation passed)
-						if (parseSuccess) {
-							propertyRule.__ends = i + 1;
-							// Add to parent's cssRules
-							if (propertyRule.__parentRule) {
-								propertyRule.__parentRule.cssRules.push(propertyRule);
-							} else {
-								topScope.cssRules.push(propertyRule);
-							}
-						}
-					}
-					// Restore currentScope to parent after closing this rule
-					if (propertyRule.__parentRule) {
-						currentScope = propertyRule.__parentRule;
-					}
-					styleRule = null;
-					buffer = "";
-					state = "before-selector";
-					break;
-				}
-				switch (state) {
-					case "value":
-						styleRule.style.setProperty(name, buffer.trim(), priority, parseError);
-						priority = "";
-					/* falls through */
-					case "before-value":
-					case "before-name":
-					case "name":
-						styleRule.__ends = i + 1;
-
-						if (parentRule === styleRule) {
-							parentRule = ancestorRules.pop()
-						}
-
-						if (parentRule) {
-							styleRule.__parentRule = parentRule;
-						}
-						styleRule.__parentStyleSheet = styleSheet;
-
-						if (currentScope === styleRule) {
-							currentScope = parentRule || topScope;
-						}
-
-						if (styleRule.constructor.name === "CSSStyleRule" && !isValidSelectorText(styleRule.selectorText)) {
-							if (styleRule === nestedSelectorRule) {
-								nestedSelectorRule = null;
-							}
-							parseError('Invalid CSSStyleRule (selectorText = "' + styleRule.selectorText + '")', styleRule.parentRule !== null);
-						} else {
-							if (styleRule.parentRule) {
-								styleRule.parentRule.cssRules.push(styleRule);
-							} else {
-								currentScope.cssRules.push(styleRule);
-							}
-						}
-						buffer = "";
-						if (currentScope.constructor === CSSOM.CSSKeyframesRule) {
-							state = "keyframeRule-begin";
-						} else {
-							state = "before-selector";
-						}
-
-						if (styleRule.constructor.name === "CSSNestedDeclarations") {
-							if (currentScope !== topScope) {
-								// Only set nestedSelectorRule if currentScope is CSSStyleRule or CSSScopeRule
-								// Not for other grouping rules like @media/@supports
-								if (currentScope.constructor.name === "CSSStyleRule" || currentScope.constructor.name === "CSSScopeRule") {
-									nestedSelectorRule = currentScope;
-								}
-							}
-							styleRule = null;
-						} else {
-							// Update nestedSelectorRule when closing a CSSStyleRule
-							if (styleRule === nestedSelectorRule) {
-								var selector = styleRule.selectorText && styleRule.selectorText.trim();
-								// Check if this is proper nesting (&.class, &:pseudo) vs prepended & (& :is, & .class with space)
-								// Prepended & has pattern "& X" where X starts with : or .
-								var isPrependedAmpersand = selector && selector.match(prependedAmpersandRegExp);
-
-								// Check if parent is a grouping rule that can contain nested selectors
-								var isGroupingRule = currentScope && currentScope instanceof CSSOM.CSSGroupingRule;
-
-								if (!isPrependedAmpersand && isGroupingRule) {
-									// Proper nesting - set nestedSelectorRule to parent for more nested selectors
-									// But only if it's a CSSStyleRule or CSSScopeRule, not other grouping rules like @media
-									if (currentScope.constructor.name === "CSSStyleRule" || currentScope.constructor.name === "CSSScopeRule") {
-										nestedSelectorRule = currentScope;
-									}
-									// If currentScope is another type of grouping rule (like @media), keep nestedSelectorRule unchanged
-								} else {
-									// Prepended & or not nested in grouping rule - reset to prevent CSSNestedDeclarations
-									nestedSelectorRule = null;
-								}
-							} else if (nestedSelectorRule && currentScope instanceof CSSOM.CSSGroupingRule) {
-								// When closing a nested rule that's not the nestedSelectorRule itself,
-								// maintain nestedSelectorRule if we're still inside a grouping rule
-								// This ensures declarations after nested selectors inside @media/@supports etc. work correctly
-							}
-							styleRule = null;
-							break;
-						}
-					case "keyframeRule-begin":
-					case "before-selector":
-					case "selector":
-						// End of media/supports/document rule.
-						if (!parentRule) {
-							parseError("Unexpected }");
-
-							var hasPreviousStyleRule = currentScope.cssRules.length && currentScope.cssRules[currentScope.cssRules.length - 1].constructor.name === "CSSStyleRule";
-							if (hasPreviousStyleRule) {
-								i = ignoreBalancedBlock(i, token.slice(i), 1);
-							}
-
-							break;
-						}
-
-						// Find the actual parent rule by popping from ancestor stack
-						while (ancestorRules.length > 0) {
-							parentRule = ancestorRules.pop();
-
-							// Skip if we popped the current scope itself (happens because we push both rule and parent)
-							if (parentRule === currentScope) {
-								continue;
-							}
-
-							// Only process valid grouping rules
-							if (!(parentRule instanceof CSSOM.CSSGroupingRule && (parentRule.constructor.name !== 'CSSStyleRule' || parentRule.__parentRule))) {
-								continue;
-							}
-
-							// Determine if we're closing a special nested selector context
-							var isClosingNestedSelectorContext = nestedSelectorRule && 
-								(currentScope === nestedSelectorRule || nestedSelectorRule.__parentRule === currentScope);
-
-							if (isClosingNestedSelectorContext) {
-								// Closing the nestedSelectorRule or its direct container
-								if (nestedSelectorRule.parentRule) {
-									// Add nestedSelectorRule to its parent and update scope
-									prevScope = nestedSelectorRule;
-									currentScope = nestedSelectorRule.parentRule;
-									// Use object lookup instead of O(n) indexOf
-									var scopeId = getRuleId(prevScope);
-									if (!addedToCurrentScope[scopeId]) {
-										currentScope.cssRules.push(prevScope);
-										addedToCurrentScope[scopeId] = true;
-									}
-									nestedSelectorRule = currentScope;
-									// Stop here to preserve context for sibling selectors
-									break;
-								} else {
-									// Top-level CSSStyleRule with nested grouping rule
-									prevScope = currentScope;
-									var actualParent = ancestorRules.length > 0 ? ancestorRules[ancestorRules.length - 1] : nestedSelectorRule;
-									if (actualParent !== prevScope) {
-										actualParent.cssRules.push(prevScope);
-									}
-									currentScope = actualParent;
-									parentRule = actualParent;
-									break;
-								}
-							} else {
-								// Regular case: add currentScope to parentRule
-								prevScope = currentScope;
-								if (parentRule !== prevScope) {
-									parentRule.cssRules.push(prevScope);
-								}
-								break;
-							}
-						}
-
-						// If currentScope has a __parentRule and wasn't added yet, add it
-						if (ancestorRules.length === 0 && currentScope.__parentRule && currentScope.__parentRule.cssRules) {
-							// Use object lookup instead of O(n) findIndex
-							var parentId = getRuleId(currentScope);
-							if (!addedToParent[parentId]) {
-								currentScope.__parentRule.cssRules.push(currentScope);
-								addedToParent[parentId] = true;
-							}
-						}
-
-						// Only handle top-level rule closing if we processed all ancestors
-						if (ancestorRules.length === 0 && currentScope.parentRule == null) {
-							currentScope.__ends = i + 1;
-							// Use object lookup instead of O(n) findIndex
-							var topId = getRuleId(currentScope);
-							if (currentScope !== topScope && !addedToTopScope[topId]) {
-								topScope.cssRules.push(currentScope);
-								addedToTopScope[topId] = true;
-							}
-							currentScope = topScope;
-							if (nestedSelectorRule === parentRule) {
-								// Check if this selector is really starting inside another selector
-								var nestedSelectorTokenToCurrentSelectorToken = token.slice(nestedSelectorRule.__starts, i + 1);
-								var openingBraceMatch = nestedSelectorTokenToCurrentSelectorToken.match(openBraceGlobalRegExp);
-								var closingBraceMatch = nestedSelectorTokenToCurrentSelectorToken.match(closeBraceGlobalRegExp);
-								var openingBraceLen = openingBraceMatch && openingBraceMatch.length;
-								var closingBraceLen = closingBraceMatch && closingBraceMatch.length;
-
-								if (openingBraceLen === closingBraceLen) {
-									// If the number of opening and closing braces are equal, we can assume that the new selector is starting outside the nestedSelectorRule
-									nestedSelectorRule.__ends = i + 1;
-									nestedSelectorRule = null;
-									parentRule = null;
-								}
-							} else {
-								parentRule = null;
-							}
-						} else {
-							currentScope = parentRule;
-						}
-
-						buffer = "";
-						state = "before-selector";
-						break;
-				}
-				break;
-
-			default:
-				switch (state) {
-					case "before-selector":
-						state = "selector";
-						if ((styleRule || scopeRule) && parentRule) {
-							// Assuming it's a declaration inside Nested Selector OR a Nested Declaration
-							// If Declaration inside Nested Selector let's keep the same styleRule
-							if (!isSelectorStartChar(character) && !isWhitespaceChar(character) && parentRule instanceof CSSOM.CSSGroupingRule) {
-								// parentRule.__parentRule = styleRule;
-								state = "before-name";
-								if (styleRule !== parentRule) {
-									styleRule = new CSSOM.CSSNestedDeclarations();
-									styleRule.__starts = i;
-								}
-							}
-
-						} else if (nestedSelectorRule && parentRule && parentRule instanceof CSSOM.CSSGroupingRule) {
-							if (isSelectorStartChar(character)) {
-								// If starting with a selector character, create CSSStyleRule instead of CSSNestedDeclarations
-								styleRule = new CSSOM.CSSStyleRule();
-								styleRule.__starts = i;
-							} else if (!isWhitespaceChar(character)) {
-								// Starting a declaration (not whitespace, not a selector)
-								state = "before-name";
-								// Check if we should create CSSNestedDeclarations
-								// This happens if: parent has cssRules OR nestedSelectorRule exists (indicating CSSStyleRule in hierarchy)
-								if (parentRule.cssRules.length || nestedSelectorRule) {
-									currentScope = parentRule;
-									// Only set nestedSelectorRule if parentRule is CSSStyleRule or CSSScopeRule
-									if (parentRule.constructor.name === "CSSStyleRule" || parentRule.constructor.name === "CSSScopeRule") {
-										nestedSelectorRule = parentRule;
-									}
-									styleRule = new CSSOM.CSSNestedDeclarations();
-									styleRule.__starts = i;
-								} else {
-									if (parentRule.constructor.name === "CSSStyleRule") {
-										styleRule = parentRule;
-									} else {
-										styleRule = new CSSOM.CSSStyleRule();
-										styleRule.__starts = i;
-									}
-								}
-							}
-						}
-						break;
-					case "before-name":
-						state = "name";
-						break;
-					case "before-value":
-						state = "value";
-						break;
-					case "importRule-begin":
-						state = "importRule";
-						break;
-					case "namespaceRule-begin":
-						state = "namespaceRule";
-						break;
-				}
-				buffer += character;
-				break;
-		}
-
-		// Auto-close all unclosed nested structures
-		// Check AFTER processing the character, at the ORIGINAL ending index
-		// Only add closing braces if CSS is incomplete (not at top scope)
-		if (i === initialEndingIndex && (currentScope !== topScope || ancestorRules.length > 0)) {
-			var needsClosing = ancestorRules.length;
-			if (currentScope !== topScope && ancestorRules.indexOf(currentScope) === -1) {
-				needsClosing += 1;
-			}
-			// Add closing braces for all unclosed structures
-			for (var closeIdx = 0; closeIdx < needsClosing; closeIdx++) {
-				token += "}";
-				endingIndex += 1;
-			}
-		}
-	}
-
-	if (buffer.trim() !== "") {
-		parseError("Unexpected end of input");
-	}
-
-	return styleSheet;
-};
-
-
-//.CommonJS
-exports.parse = CSSOM.parse;
-// The following modules cannot be included sooner due to the mutual dependency with parse.js
-CSSOM.CSSStyleSheet = require("./CSSStyleSheet").CSSStyleSheet;
-CSSOM.CSSStyleRule = require("./CSSStyleRule").CSSStyleRule;
-CSSOM.CSSNestedDeclarations = require("./CSSNestedDeclarations").CSSNestedDeclarations;
-CSSOM.CSSImportRule = require("./CSSImportRule").CSSImportRule;
-CSSOM.CSSNamespaceRule = require("./CSSNamespaceRule").CSSNamespaceRule;
-CSSOM.CSSGroupingRule = require("./CSSGroupingRule").CSSGroupingRule;
-CSSOM.CSSMediaRule = require("./CSSMediaRule").CSSMediaRule;
-CSSOM.CSSCounterStyleRule = require("./CSSCounterStyleRule").CSSCounterStyleRule;
-CSSOM.CSSPropertyRule = require("./CSSPropertyRule").CSSPropertyRule;
-CSSOM.CSSContainerRule = require("./CSSContainerRule").CSSContainerRule;
-CSSOM.CSSConditionRule = require("./CSSConditionRule").CSSConditionRule;
-CSSOM.CSSSupportsRule = require("./CSSSupportsRule").CSSSupportsRule;
-CSSOM.CSSFontFaceRule = require("./CSSFontFaceRule").CSSFontFaceRule;
-CSSOM.CSSHostRule = require("./CSSHostRule").CSSHostRule;
-CSSOM.CSSStartingStyleRule = require("./CSSStartingStyleRule").CSSStartingStyleRule;
-CSSOM.CSSStyleDeclaration = require('./CSSStyleDeclaration').CSSStyleDeclaration;
-CSSOM.CSSKeyframeRule = require('./CSSKeyframeRule').CSSKeyframeRule;
-CSSOM.CSSKeyframesRule = require('./CSSKeyframesRule').CSSKeyframesRule;
-CSSOM.CSSValueExpression = require('./CSSValueExpression').CSSValueExpression;
-CSSOM.CSSDocumentRule = require('./CSSDocumentRule').CSSDocumentRule;
-CSSOM.CSSScopeRule = require('./CSSScopeRule').CSSScopeRule;
-CSSOM.CSSLayerBlockRule = require("./CSSLayerBlockRule").CSSLayerBlockRule;
-CSSOM.CSSLayerStatementRule = require("./CSSLayerStatementRule").CSSLayerStatementRule;
-CSSOM.CSSPageRule = require("./CSSPageRule").CSSPageRule;
-// Use cssstyle if available
-require("./cssstyleTryCatchBlock");
-///CommonJS

node_modules/@acemir/cssom/lib/regexPatterns.js

@@ -1,162 +0,0 @@
-// Shared regex patterns for CSS parsing and validation
-// These patterns are compiled once and reused across multiple files for better performance
-
-// Regex patterns for CSS parsing
-var atKeyframesRegExp = /@(-(?:\w+-)+)?keyframes/g; // Match @keyframes and vendor-prefixed @keyframes
-var beforeRulePortionRegExp = /{(?!.*{)|}(?!.*})|;(?!.*;)|\*\/(?!.*\*\/)/g; // Match the closest allowed character (a opening or closing brace, a semicolon or a comment ending) before the rule
-var beforeRuleValidationRegExp = /^[\s{};]*(\*\/\s*)?$/; // Match that the portion before the rule is empty or contains only whitespace, semicolons, opening/closing braces, and optionally a comment ending (*/) followed by whitespace
-var forwardRuleValidationRegExp = /(?:\s|\/\*|\{|\()/; // Match that the rule is followed by any whitespace, a opening comment, a condition opening parenthesis or a opening brace
-var forwardImportRuleValidationRegExp = /(?:\s|\/\*|'|")/; // Match that the rule is followed by any whitespace, an opening comment, a single quote or double quote
-var forwardRuleClosingBraceRegExp = /{[^{}]*}|}/; // Finds the next closing brace of a rule block
-var forwardRuleSemicolonAndOpeningBraceRegExp = /^.*?({|;)/; // Finds the next semicolon or opening brace after the at-rule
-
-// Regex patterns for CSS selector validation and parsing
-var cssCustomIdentifierRegExp = /^(-?[_a-zA-Z]+(\.[_a-zA-Z]+)*[_a-zA-Z0-9-]*)$/; // Validates a css custom identifier
-var startsWithCombinatorRegExp = /^\s*[>+~]/; // Checks if a selector starts with a CSS combinator (>, +, ~)
-
-/**
- * Parse `@page` selectorText for page name and pseudo-pages
- * Valid formats:
- * - (empty - no name, no pseudo-page)
- * - `:left`, `:right`, `:first`, `:blank` (pseudo-page only)
- * - `named` (named page only)
- * - `named:first` (named page with single pseudo-page)
- * - `named:first:left` (named page with multiple pseudo-pages)
- */
-var atPageRuleSelectorRegExp = /^([^\s:]+)?((?::\w+)*)$/; // Validates @page rule selectors
-
-// Regex patterns for CSSImportRule parsing
-var layerRegExp = /layer\(([^)]*)\)/; // Matches layer() function in @import
-var layerRuleNameRegExp = /^(-?[_a-zA-Z]+(\.[_a-zA-Z]+)*[_a-zA-Z0-9-]*)$/; // Validates layer name (same as custom identifier)
-var doubleOrMoreSpacesRegExp = /\s{2,}/g; // Matches two or more consecutive whitespace characters
-
-
-// Regex patterns for CSS escape sequences and identifiers
-var startsWithHexEscapeRegExp = /^\\[0-9a-fA-F]/; // Checks if escape sequence starts with hex escape
-var identStartCharRegExp = /[a-zA-Z_\u00A0-\uFFFF]/; // Valid identifier start character
-var identCharRegExp = /^[a-zA-Z0-9_\-\u00A0-\uFFFF\\]/; // Valid identifier character
-var specialCharsNeedEscapeRegExp = /[!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~\s]/; // Characters that need escaping
-var combinatorOrSeparatorRegExp = /[\s>+~,()]/; // Selector boundaries and combinators
-var afterHexEscapeSeparatorRegExp = /[\s>+~,(){}\[\]]/; // Characters that separate after hex escape
-var trailingSpaceSeparatorRegExp = /[\s>+~,(){}]/; // Characters that allow trailing space
-var endsWithHexEscapeRegExp = /\\[0-9a-fA-F]{1,6}\s+$/; // Matches selector ending with hex escape + space(s)
-
-/**
- * Regular expression to detect invalid characters in the value portion of a CSS style declaration.
- *
- * This regex matches a colon (:) that is not inside parentheses and not inside single or double quotes.
- * It is used to ensure that the value part of a CSS property does not contain unexpected colons,
- * which would indicate a malformed declaration (e.g., "color: foo:bar;" is invalid).
- *
- * The negative lookahead `(?![^(]*\))` ensures that the colon is not followed by a closing
- * parenthesis without encountering an opening parenthesis, effectively ignoring colons inside
- * function-like values (e.g., `url(data:image/png;base64,...)`).
- *
- * The lookahead `(?=(?:[^'"]|'[^']*'|"[^"]*")*$)` ensures that the colon is not inside single or double quotes,
- * allowing colons within quoted strings (e.g., `content: ":";` or `background: url("foo:bar.png");`).
- *
- * Example:
- * - `color: red;`         // valid, does not match
- * - `background: url(data:image/png;base64,...);` // valid, does not match
- * - `content: ':';`       // valid, does not match
- * - `color: foo:bar;`     // invalid, matches
- */
-var basicStylePropertyValueValidationRegExp = /:(?![^(]*\))(?=(?:[^'"]|'[^']*'|"[^"]*")*$)/;
-
-// Attribute selector pattern: matches attribute-name operator value
-// Operators: =, ~=, |=, ^=, $=, *=
-// Rewritten to avoid ReDoS by using greedy match and trimming in JavaScript
-var attributeSelectorContentRegExp = /^([^\s=~|^$*]+)\s*(~=|\|=|\^=|\$=|\*=|=)\s*(.+)$/;
-
-// Selector validation patterns
-var pseudoElementRegExp = /::[a-zA-Z][\w-]*|:(before|after|first-line|first-letter)(?![a-zA-Z0-9_-])/; // Matches pseudo-elements
-var invalidCombinatorLtGtRegExp = /<>/; // Invalid <> combinator
-var invalidCombinatorDoubleGtRegExp = />>/; // Invalid >> combinator
-var consecutiveCombinatorsRegExp = /[>+~]\s*[>+~]/; // Invalid consecutive combinators
-var invalidSlottedRegExp = /(?:^|[\s>+~,\[])slotted\s*\(/i; // Invalid slotted() without ::
-var invalidPartRegExp = /(?:^|[\s>+~,\[])part\s*\(/i; // Invalid part() without ::
-var invalidCueRegExp = /(?:^|[\s>+~,\[])cue\s*\(/i; // Invalid cue() without ::
-var invalidCueRegionRegExp = /(?:^|[\s>+~,\[])cue-region\s*\(/i; // Invalid cue-region() without ::
-var invalidNestingPattern = /&(?![.\#\[:>\+~\s])[a-zA-Z]/; // Invalid & followed by type selector
-var emptyPseudoClassRegExp = /:(?:is|not|where|has)\(\s*\)/; // Empty pseudo-class like :is()
-var whitespaceNormalizationRegExp = /(['"])(?:\\.|[^\\])*?\1|(\r\n|\r|\n)/g; // Normalize newlines outside quotes
-var newlineRemovalRegExp = /\n/g; // Remove all newlines
-var whitespaceAndDotRegExp = /[\s.]/; // Matches whitespace or dot
-var declarationOrOpenBraceRegExp = /[{;}]/; // Matches declaration separator or open brace
-var ampersandRegExp = /&/; // Matches nesting selector
-var hexEscapeSequenceRegExp = /^([0-9a-fA-F]{1,6})[ \t\r\n\f]?/; // Matches hex escape sequence (1-6 hex digits optionally followed by whitespace)
-var attributeCaseFlagRegExp = /^(.+?)\s+([is])$/i; // Matches case-sensitivity flag at end of attribute value
-var prependedAmpersandRegExp = /^&\s+[:\\.]/; // Matches prepended ampersand pattern (& followed by space and : or .)
-var openBraceGlobalRegExp = /{/g; // Matches opening braces (global)
-var closeBraceGlobalRegExp = /}/g; // Matches closing braces (global)
-var scopePreludeSplitRegExp = /\s*\)\s*to\s+\(/; // Splits scope prelude by ") to ("
-var leadingWhitespaceRegExp = /^\s+/; // Matches leading whitespace (used to implement a ES5-compliant alternative to trimStart())
-var doubleQuoteRegExp = /"/g; // Match all double quotes (for escaping in attribute values)
-var backslashRegExp = /\\/g; // Match all backslashes (for escaping in attribute values)
-
-var regexPatterns = {
-	// Parsing patterns
-	atKeyframesRegExp: atKeyframesRegExp,
-	beforeRulePortionRegExp: beforeRulePortionRegExp,
-	beforeRuleValidationRegExp: beforeRuleValidationRegExp,
-	forwardRuleValidationRegExp: forwardRuleValidationRegExp,
-	forwardImportRuleValidationRegExp: forwardImportRuleValidationRegExp,
-	forwardRuleClosingBraceRegExp: forwardRuleClosingBraceRegExp,
-	forwardRuleSemicolonAndOpeningBraceRegExp: forwardRuleSemicolonAndOpeningBraceRegExp,
-	
-	// Selector validation patterns
-	cssCustomIdentifierRegExp: cssCustomIdentifierRegExp,
-	startsWithCombinatorRegExp: startsWithCombinatorRegExp,
-	atPageRuleSelectorRegExp: atPageRuleSelectorRegExp,
-	
-	// Parsing patterns used in CSSImportRule
-	layerRegExp: layerRegExp,
-	layerRuleNameRegExp: layerRuleNameRegExp,
-	doubleOrMoreSpacesRegExp: doubleOrMoreSpacesRegExp,
-	
-	// Escape sequence and identifier patterns
-	startsWithHexEscapeRegExp: startsWithHexEscapeRegExp,
-	identStartCharRegExp: identStartCharRegExp,
-	identCharRegExp: identCharRegExp,
-	specialCharsNeedEscapeRegExp: specialCharsNeedEscapeRegExp,
-	combinatorOrSeparatorRegExp: combinatorOrSeparatorRegExp,
-	afterHexEscapeSeparatorRegExp: afterHexEscapeSeparatorRegExp,
-	trailingSpaceSeparatorRegExp: trailingSpaceSeparatorRegExp,
-	endsWithHexEscapeRegExp: endsWithHexEscapeRegExp,
-
-	// Basic style property value validation
-	basicStylePropertyValueValidationRegExp: basicStylePropertyValueValidationRegExp,
-
-	// Attribute selector patterns
-	attributeSelectorContentRegExp: attributeSelectorContentRegExp,
-
-	// Selector validation patterns
-	pseudoElementRegExp: pseudoElementRegExp,
-	invalidCombinatorLtGtRegExp: invalidCombinatorLtGtRegExp,
-	invalidCombinatorDoubleGtRegExp: invalidCombinatorDoubleGtRegExp,
-	consecutiveCombinatorsRegExp: consecutiveCombinatorsRegExp,
-	invalidSlottedRegExp: invalidSlottedRegExp,
-	invalidPartRegExp: invalidPartRegExp,
-	invalidCueRegExp: invalidCueRegExp,
-	invalidCueRegionRegExp: invalidCueRegionRegExp,
-	invalidNestingPattern: invalidNestingPattern,
-	emptyPseudoClassRegExp: emptyPseudoClassRegExp,
-	whitespaceNormalizationRegExp: whitespaceNormalizationRegExp,
-	newlineRemovalRegExp: newlineRemovalRegExp,
-	whitespaceAndDotRegExp: whitespaceAndDotRegExp,
-	declarationOrOpenBraceRegExp: declarationOrOpenBraceRegExp,
-	ampersandRegExp: ampersandRegExp,
-	hexEscapeSequenceRegExp: hexEscapeSequenceRegExp,
-	attributeCaseFlagRegExp: attributeCaseFlagRegExp,
-	prependedAmpersandRegExp: prependedAmpersandRegExp,
-	openBraceGlobalRegExp: openBraceGlobalRegExp,
-	closeBraceGlobalRegExp: closeBraceGlobalRegExp,
-	scopePreludeSplitRegExp: scopePreludeSplitRegExp,
-	leadingWhitespaceRegExp: leadingWhitespaceRegExp,
-	doubleQuoteRegExp: doubleQuoteRegExp,
-	backslashRegExp: backslashRegExp
-};
-
-//.CommonJS
-exports.regexPatterns = regexPatterns;
-///CommonJS

node_modules/@acemir/cssom/package.json

@@ -1,32 +0,0 @@
-{
-  "name": "@acemir/cssom",
-  "description": "CSS Object Model implementation and CSS parser",
-  "keywords": [
-    "CSS",
-    "CSSOM",
-    "parser",
-    "styleSheet"
-  ],
-  "version": "0.9.31",
-  "author": "Nikita Vasilyev <me@elv1s.ru>",
-  "contributors": [
-    "Acemir Sousa Mendes <acemirsm@gmail.com>"
-  ],
-  "repository": "acemir/CSSOM",
-  "files": [
-    "lib/",
-    "build/"
-  ],
-  "browser": "./build/CSSOM.js",
-  "main": "./lib/index.js",
-  "license": "MIT",
-  "scripts": {
-    "build": "node build.js",
-    "release": "npm run build && changeset publish"
-  },
-  "devDependencies": {
-    "@changesets/changelog-github": "^0.5.2",
-    "@changesets/cli": "^2.29.8",
-    "@changesets/get-release-plan": "^4.0.14"
-  }
-}

node_modules/@asamuzakjp/css-color/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 asamuzaK (Kazz)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

node_modules/@asamuzakjp/css-color/README.md

@@ -1,316 +0,0 @@
-# CSS color
-
-[![build](https://github.com/asamuzaK/cssColor/actions/workflows/node.js.yml/badge.svg)](https://github.com/asamuzaK/cssColor/actions/workflows/node.js.yml)
-[![CodeQL](https://github.com/asamuzaK/cssColor/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/asamuzaK/cssColor/actions/workflows/github-code-scanning/codeql)
-[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/css-color)](https://www.npmjs.com/package/@asamuzakjp/css-color)
-
-Resolve and convert CSS colors.
-
-## Install
-
-```console
-npm i @asamuzakjp/css-color
-```
-
-## Usage
-
-```javascript
-import { convert, resolve, utils } from '@asamuzakjp/css-color';
-
-const resolvedValue = resolve(
-  'color-mix(in oklab, lch(67.5345 42.5 258.2), color(srgb 0 0.5 0))'
-);
-// 'oklab(0.620754 -0.0931934 -0.00374881)'
-
-const convertedValue = convert.colorToHex('lab(46.2775% -47.5621 48.5837)');
-// '#008000'
-
-const result = utils.isColor('green');
-// true
-```
-
-<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
-
-### resolve(color, opt)
-
-resolves CSS color
-
-#### Parameters
-
-- `color` **[string][133]** color value
-  - system colors are not supported
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.currentColor` **[string][133]?**
-    - color to use for `currentcolor` keyword
-    - if omitted, it will be treated as a missing color,
-      i.e. `rgb(none none none / none)`
-  - `opt.customProperty` **[object][135]?**
-    - custom properties
-    - pair of `--` prefixed property name as a key and it's value,
-      e.g.
-      ```javascript
-      const opt = {
-        customProperty: {
-          '--some-color': '#008000',
-          '--some-length': '16px'
-        }
-      };
-      ```
-    - and/or `callback` function to get the value of the custom property,
-      e.g.
-      ```javascript
-      const node = document.getElementById('foo');
-      const opt = {
-        customProperty: {
-          callback: node.style.getPropertyValue
-        }
-      };
-      ```
-  - `opt.dimension` **[object][135]?**
-    - dimension, e.g. for converting relative length to pixels
-    - pair of unit as a key and number in pixels as it's value,
-      e.g. suppose `1em === 12px`, `1rem === 16px` and `100vw === 1024px`, then
-      ```javascript
-      const opt = {
-        dimension: {
-          em: 12,
-          rem: 16,
-          vw: 10.24
-        }
-      };
-      ```
-    - and/or `callback` function to get the value as a number in pixels,
-      e.g.
-      ```javascript
-      const opt = {
-        dimension: {
-          callback: unit => {
-            switch (unit) {
-              case 'em':
-                return 12;
-              case 'rem':
-                return 16;
-              case 'vw':
-                return 10.24;
-              default:
-                return;
-            }
-          }
-        }
-      };
-      ```
-  - `opt.format` **[string][133]?**
-    - output format, one of below
-      - `computedValue` (default), [computed value][139] of the color
-      - `specifiedValue`, [specified value][140] of the color
-      - `hex`, hex color notation, i.e. `#rrggbb`
-      - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
-
-Returns **[string][133]?** one of `rgba?()`, `#rrggbb(aa)?`, `color-name`, `color(color-space r g b / alpha)`, `color(color-space x y z / alpha)`, `(ok)?lab(l a b / alpha)`, `(ok)?lch(l c h / alpha)`, `'(empty-string)'`, `null`
-
-- in `computedValue`, values are numbers, however `rgb()` values are integers
-- in `specifiedValue`, returns `empty string` for unknown and/or invalid color
-- in `hex`, returns `null` for `transparent`, and also returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
-- in `hexAlpha`, returns `#00000000` for `transparent`, however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
-
-### convert
-
-Contains various color conversion functions.
-
-### convert.numberToHex(value)
-
-convert number to hex string
-
-#### Parameters
-
-- `value` **[number][134]** color value
-
-Returns **[string][133]** hex string: 00..ff
-
-### convert.colorToHex(value, opt)
-
-convert color to hex
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.alpha` **[boolean][136]?** return in #rrggbbaa notation
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[string][133]** #rrggbb(aa)?
-
-### convert.colorToHsl(value, opt)
-
-convert color to hsl
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[h, s, l, alpha]
-
-### convert.colorToHwb(value, opt)
-
-convert color to hwb
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[h, w, b, alpha]
-
-### convert.colorToLab(value, opt)
-
-convert color to lab
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[l, a, b, alpha]
-
-### convert.colorToLch(value, opt)
-
-convert color to lch
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[l, c, h, alpha]
-
-### convert.colorToOklab(value, opt)
-
-convert color to oklab
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[l, a, b, alpha]
-
-### convert.colorToOklch(value, opt)
-
-convert color to oklch
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[l, c, h, alpha]
-
-### convert.colorToRgb(value, opt)
-
-convert color to rgb
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[r, g, b, alpha]
-
-### convert.colorToXyz(value, opt)
-
-convert color to xyz
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-  - `opt.d50` **[boolean][136]?** xyz in d50 white point
-
-Returns **[Array][137]<[number][134]>** \[x, y, z, alpha]
-
-### convert.colorToXyzD50(value, opt)
-
-convert color to xyz-d50
-
-#### Parameters
-
-- `value` **[string][133]** color value
-- `opt` **[object][135]?** options (optional, default `{}`)
-  - `opt.customProperty` **[object][135]?**
-    - custom properties, see `resolve()` function above
-  - `opt.dimension` **[object][135]?**
-    - dimension, see `resolve()` function above
-
-Returns **[Array][137]<[number][134]>** \[x, y, z, alpha]
-
-### utils
-
-Contains utility functions.
-
-### utils.isColor(color)
-
-is valid color type
-
-#### Parameters
-
-- `color` **[string][133]** color value
-  - system colors are not supported
-
-Returns **[boolean][136]**
-
-## Acknowledgments
-
-The following resources have been of great help in the development of the CSS color.
-
-- [csstools/postcss-plugins](https://github.com/csstools/postcss-plugins)
-- [lru-cache](https://github.com/isaacs/node-lru-cache)
-
----
-
-Copyright (c) 2024 [asamuzaK (Kazz)](https://github.com/asamuzaK/)
-
-[133]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
-[134]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number
-[135]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
-[136]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
-[137]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
-[138]: https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code
-[139]: https://developer.mozilla.org/en-US/docs/Web/CSS/computed_value
-[140]: https://developer.mozilla.org/en-US/docs/Web/CSS/specified_value
-[141]: https://www.npmjs.com/package/@csstools/css-calc

node_modules/@asamuzakjp/css-color/dist/cjs/index.cjs

@@ -1,5764 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  convert: () => convert,
-  resolve: () => resolve,
-  utils: () => utils
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/js/css-calc.ts
-var import_css_calc4 = require("@csstools/css-calc");
-var import_css_tokenizer4 = require("@csstools/css-tokenizer");
-
-// src/js/cache.ts
-var import_lru_cache = require("lru-cache");
-
-// src/js/util.ts
-var import_css_tokenizer3 = require("@csstools/css-tokenizer");
-
-// src/js/common.ts
-var isString = (o) => typeof o === "string" || o instanceof String;
-var isStringOrNumber = (o) => isString(o) || typeof o === "number";
-
-// src/js/constant.ts
-var _DIGIT = "(?:0|[1-9]\\d*)";
-var _COMPARE = "clamp|max|min";
-var _EXPO = "exp|hypot|log|pow|sqrt";
-var _SIGN = "abs|sign";
-var _STEP = "mod|rem|round";
-var _TRIG = "a?(?:cos|sin|tan)|atan2";
-var _MATH = `${_COMPARE}|${_EXPO}|${_SIGN}|${_STEP}|${_TRIG}`;
-var _CALC = `calc|${_MATH}`;
-var _VAR = `var|${_CALC}`;
-var ANGLE = "deg|g?rad|turn";
-var LENGTH = "[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)";
-var NUM = `[+-]?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-var NUM_POSITIVE = `\\+?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-var NONE = "none";
-var PCT = `${NUM}%`;
-var SYN_FN_CALC = `^(?:${_CALC})\\(|(?<=[*\\/\\s\\(])(?:${_CALC})\\(`;
-var SYN_FN_MATH_START = `^(?:${_MATH})\\($`;
-var SYN_FN_VAR = "^var\\(|(?<=[*\\/\\s\\(])var\\(";
-var SYN_FN_VAR_START = `^(?:${_VAR})\\(`;
-var _ALPHA = `(?:\\s*\\/\\s*(?:${NUM}|${PCT}|${NONE}))?`;
-var _ALPHA_LV3 = `(?:\\s*,\\s*(?:${NUM}|${PCT}))?`;
-var _COLOR_FUNC = "(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?";
-var _COLOR_KEY = "[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}";
-var _CS_HUE = "(?:ok)?lch|hsl|hwb";
-var _CS_HUE_ARC = "(?:de|in)creasing|longer|shorter";
-var _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;
-var _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;
-var _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;
-var CS_HUE = `(?:${_CS_HUE})(?:\\s(?:${_CS_HUE_ARC})\\shue)?`;
-var CS_HUE_CAPT = `(${_CS_HUE})(?:\\s(${_CS_HUE_ARC})\\shue)?`;
-var CS_LAB = "(?:ok)?lab";
-var CS_LCH = "(?:ok)?lch";
-var CS_SRGB = "srgb(?:-linear)?";
-var CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|${CS_SRGB}`;
-var CS_XYZ = "xyz(?:-d(?:50|65))?";
-var CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;
-var CS_MIX = `${CS_HUE}|${CS_RECT}`;
-var FN_COLOR = "color(";
-var FN_LIGHT_DARK = "light-dark(";
-var FN_MIX = "color-mix(";
-var FN_REL = `(?:${_COLOR_FUNC})\\(\\s*from\\s+`;
-var FN_REL_CAPT = `(${_COLOR_FUNC})\\(\\s*from\\s+`;
-var FN_VAR = "var(";
-var SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;
-var SYN_FN_LIGHT_DARK = "^light-dark\\(";
-var SYN_FN_REL = `^${FN_REL}|(?<=[\\s])${FN_REL}`;
-var SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-var SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\s*,\\s*${PCT}){2}${_ALPHA_LV3}`;
-var SYN_LCH = `(?:${_NUM_PCT_NONE}\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;
-var SYN_MOD = `${_NUM_PCT_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-var SYN_RGB_LV3 = `(?:${NUM}(?:\\s*,\\s*${NUM}){2}|${PCT}(?:\\s*,\\s*${PCT}){2})${_ALPHA_LV3}`;
-var SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\(\\s*${SYN_HSL_LV3}\\s*\\)|rgba?\\(\\s*${SYN_RGB_LV3}\\s*\\)|(?:hsla?|hwb)\\(\\s*${SYN_HSL}\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*${SYN_MOD}\\s*\\)|(?:ok)?lch\\(\\s*${SYN_LCH}\\s*\\)|color\\(\\s*${SYN_FN_COLOR}\\s*\\)`;
-var SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\s+${PCT})?`;
-var SYN_MIX = `color-mix\\(\\s*in\\s+(?:${CS_MIX})\\s*,\\s*${SYN_MIX_PART}\\s*,\\s*${SYN_MIX_PART}\\s*\\)`;
-var SYN_MIX_CAPT = `color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,\\s*(${SYN_MIX_PART})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)`;
-var VAL_COMP = "computedValue";
-var VAL_MIX = "mixValue";
-var VAL_SPEC = "specifiedValue";
-
-// src/js/color.ts
-var NAMESPACE = "color";
-var PPTH = 1e-3;
-var HALF = 0.5;
-var DUO = 2;
-var TRIA = 3;
-var QUAD = 4;
-var OCT = 8;
-var DEC = 10;
-var DOZ = 12;
-var HEX = 16;
-var SEXA = 60;
-var DEG_HALF = 180;
-var DEG = 360;
-var MAX_PCT = 100;
-var MAX_RGB = 255;
-var POW_SQR = 2;
-var POW_CUBE = 3;
-var POW_LINEAR = 2.4;
-var LINEAR_COEF = 12.92;
-var LINEAR_OFFSET = 0.055;
-var LAB_L = 116;
-var LAB_A = 500;
-var LAB_B = 200;
-var LAB_EPSILON = 216 / 24389;
-var LAB_KAPPA = 24389 / 27;
-var D50 = [
-  0.3457 / 0.3585,
-  1,
-  (1 - 0.3457 - 0.3585) / 0.3585
-];
-var MATRIX_D50_TO_D65 = [
-  [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
-  [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
-  [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
-];
-var MATRIX_D65_TO_D50 = [
-  [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
-  [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
-  [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
-];
-var MATRIX_L_RGB_TO_XYZ = [
-  [506752 / 1228815, 87881 / 245763, 12673 / 70218],
-  [87098 / 409605, 175762 / 245763, 12673 / 175545],
-  [7918 / 409605, 87881 / 737289, 1001167 / 1053270]
-];
-var MATRIX_XYZ_TO_L_RGB = [
-  [12831 / 3959, -329 / 214, -1974 / 3959],
-  [-851781 / 878810, 1648619 / 878810, 36519 / 878810],
-  [705 / 12673, -2585 / 12673, 705 / 667]
-];
-var MATRIX_XYZ_TO_LMS = [
-  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
-  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
-  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
-];
-var MATRIX_LMS_TO_XYZ = [
-  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
-  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
-  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
-];
-var MATRIX_OKLAB_TO_LMS = [
-  [1, 0.3963377773761749, 0.2158037573099136],
-  [1, -0.1055613458156586, -0.0638541728258133],
-  [1, -0.0894841775298119, -1.2914855480194092]
-];
-var MATRIX_LMS_TO_OKLAB = [
-  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
-  [1.9779985324311684, -2.42859224204858, 0.450593709617411],
-  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
-];
-var MATRIX_P3_TO_XYZ = [
-  [608311 / 1250200, 189793 / 714400, 198249 / 1000160],
-  [35783 / 156275, 247089 / 357200, 198249 / 2500400],
-  [0 / 1, 32229 / 714400, 5220557 / 5000800]
-];
-var MATRIX_REC2020_TO_XYZ = [
-  [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
-  [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
-  [0 / 1, 19567812 / 697040785, 295819943 / 278816314]
-];
-var MATRIX_A98_TO_XYZ = [
-  [573536 / 994567, 263643 / 1420810, 187206 / 994567],
-  [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],
-  [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835]
-];
-var MATRIX_PROPHOTO_TO_XYZ_D50 = [
-  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
-  [0.2880748288194013, 0.711835234241873, 8993693872564e-17],
-  [0, 0, 0.8251046025104602]
-];
-var REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
-var REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);
-var REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;
-var REG_CURRENT = /^currentColor$/i;
-var REG_FN_COLOR = new RegExp(`^color\\(\\s*(${SYN_FN_COLOR})\\s*\\)$`);
-var REG_HSL = new RegExp(`^hsla?\\(\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\s*\\)$`);
-var REG_HWB = new RegExp(`^hwb\\(\\s*(${SYN_HSL})\\s*\\)$`);
-var REG_LAB = new RegExp(`^lab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-var REG_LCH = new RegExp(`^lch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-var REG_MIX = new RegExp(`^${SYN_MIX}$`);
-var REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);
-var REG_MIX_NEST = new RegExp(`${SYN_MIX}`, "g");
-var REG_OKLAB = new RegExp(`^oklab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-var REG_OKLCH = new RegExp(`^oklch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-var REG_SPEC = /^(?:specifi|comput)edValue$/;
-var NAMED_COLORS = {
-  aliceblue: [240, 248, 255],
-  antiquewhite: [250, 235, 215],
-  aqua: [0, 255, 255],
-  aquamarine: [127, 255, 212],
-  azure: [240, 255, 255],
-  beige: [245, 245, 220],
-  bisque: [255, 228, 196],
-  black: [0, 0, 0],
-  blanchedalmond: [255, 235, 205],
-  blue: [0, 0, 255],
-  blueviolet: [138, 43, 226],
-  brown: [165, 42, 42],
-  burlywood: [222, 184, 135],
-  cadetblue: [95, 158, 160],
-  chartreuse: [127, 255, 0],
-  chocolate: [210, 105, 30],
-  coral: [255, 127, 80],
-  cornflowerblue: [100, 149, 237],
-  cornsilk: [255, 248, 220],
-  crimson: [220, 20, 60],
-  cyan: [0, 255, 255],
-  darkblue: [0, 0, 139],
-  darkcyan: [0, 139, 139],
-  darkgoldenrod: [184, 134, 11],
-  darkgray: [169, 169, 169],
-  darkgreen: [0, 100, 0],
-  darkgrey: [169, 169, 169],
-  darkkhaki: [189, 183, 107],
-  darkmagenta: [139, 0, 139],
-  darkolivegreen: [85, 107, 47],
-  darkorange: [255, 140, 0],
-  darkorchid: [153, 50, 204],
-  darkred: [139, 0, 0],
-  darksalmon: [233, 150, 122],
-  darkseagreen: [143, 188, 143],
-  darkslateblue: [72, 61, 139],
-  darkslategray: [47, 79, 79],
-  darkslategrey: [47, 79, 79],
-  darkturquoise: [0, 206, 209],
-  darkviolet: [148, 0, 211],
-  deeppink: [255, 20, 147],
-  deepskyblue: [0, 191, 255],
-  dimgray: [105, 105, 105],
-  dimgrey: [105, 105, 105],
-  dodgerblue: [30, 144, 255],
-  firebrick: [178, 34, 34],
-  floralwhite: [255, 250, 240],
-  forestgreen: [34, 139, 34],
-  fuchsia: [255, 0, 255],
-  gainsboro: [220, 220, 220],
-  ghostwhite: [248, 248, 255],
-  gold: [255, 215, 0],
-  goldenrod: [218, 165, 32],
-  gray: [128, 128, 128],
-  green: [0, 128, 0],
-  greenyellow: [173, 255, 47],
-  grey: [128, 128, 128],
-  honeydew: [240, 255, 240],
-  hotpink: [255, 105, 180],
-  indianred: [205, 92, 92],
-  indigo: [75, 0, 130],
-  ivory: [255, 255, 240],
-  khaki: [240, 230, 140],
-  lavender: [230, 230, 250],
-  lavenderblush: [255, 240, 245],
-  lawngreen: [124, 252, 0],
-  lemonchiffon: [255, 250, 205],
-  lightblue: [173, 216, 230],
-  lightcoral: [240, 128, 128],
-  lightcyan: [224, 255, 255],
-  lightgoldenrodyellow: [250, 250, 210],
-  lightgray: [211, 211, 211],
-  lightgreen: [144, 238, 144],
-  lightgrey: [211, 211, 211],
-  lightpink: [255, 182, 193],
-  lightsalmon: [255, 160, 122],
-  lightseagreen: [32, 178, 170],
-  lightskyblue: [135, 206, 250],
-  lightslategray: [119, 136, 153],
-  lightslategrey: [119, 136, 153],
-  lightsteelblue: [176, 196, 222],
-  lightyellow: [255, 255, 224],
-  lime: [0, 255, 0],
-  limegreen: [50, 205, 50],
-  linen: [250, 240, 230],
-  magenta: [255, 0, 255],
-  maroon: [128, 0, 0],
-  mediumaquamarine: [102, 205, 170],
-  mediumblue: [0, 0, 205],
-  mediumorchid: [186, 85, 211],
-  mediumpurple: [147, 112, 219],
-  mediumseagreen: [60, 179, 113],
-  mediumslateblue: [123, 104, 238],
-  mediumspringgreen: [0, 250, 154],
-  mediumturquoise: [72, 209, 204],
-  mediumvioletred: [199, 21, 133],
-  midnightblue: [25, 25, 112],
-  mintcream: [245, 255, 250],
-  mistyrose: [255, 228, 225],
-  moccasin: [255, 228, 181],
-  navajowhite: [255, 222, 173],
-  navy: [0, 0, 128],
-  oldlace: [253, 245, 230],
-  olive: [128, 128, 0],
-  olivedrab: [107, 142, 35],
-  orange: [255, 165, 0],
-  orangered: [255, 69, 0],
-  orchid: [218, 112, 214],
-  palegoldenrod: [238, 232, 170],
-  palegreen: [152, 251, 152],
-  paleturquoise: [175, 238, 238],
-  palevioletred: [219, 112, 147],
-  papayawhip: [255, 239, 213],
-  peachpuff: [255, 218, 185],
-  peru: [205, 133, 63],
-  pink: [255, 192, 203],
-  plum: [221, 160, 221],
-  powderblue: [176, 224, 230],
-  purple: [128, 0, 128],
-  rebeccapurple: [102, 51, 153],
-  red: [255, 0, 0],
-  rosybrown: [188, 143, 143],
-  royalblue: [65, 105, 225],
-  saddlebrown: [139, 69, 19],
-  salmon: [250, 128, 114],
-  sandybrown: [244, 164, 96],
-  seagreen: [46, 139, 87],
-  seashell: [255, 245, 238],
-  sienna: [160, 82, 45],
-  silver: [192, 192, 192],
-  skyblue: [135, 206, 235],
-  slateblue: [106, 90, 205],
-  slategray: [112, 128, 144],
-  slategrey: [112, 128, 144],
-  snow: [255, 250, 250],
-  springgreen: [0, 255, 127],
-  steelblue: [70, 130, 180],
-  tan: [210, 180, 140],
-  teal: [0, 128, 128],
-  thistle: [216, 191, 216],
-  tomato: [255, 99, 71],
-  turquoise: [64, 224, 208],
-  violet: [238, 130, 238],
-  wheat: [245, 222, 179],
-  white: [255, 255, 255],
-  whitesmoke: [245, 245, 245],
-  yellow: [255, 255, 0],
-  yellowgreen: [154, 205, 50]
-};
-var cacheInvalidColorValue = (cacheKey, format, nullable = false) => {
-  if (format === VAL_SPEC) {
-    const res2 = "";
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  if (nullable) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const res = ["rgb", 0, 0, 0, 0];
-  setCache(cacheKey, res);
-  return res;
-};
-var resolveInvalidColorValue = (format, nullable = false) => {
-  switch (format) {
-    case "hsl":
-    case "hwb":
-    case VAL_MIX: {
-      return new NullObject();
-    }
-    case VAL_SPEC: {
-      return "";
-    }
-    default: {
-      if (nullable) {
-        return new NullObject();
-      }
-      return ["rgb", 0, 0, 0, 0];
-    }
-  }
-};
-var validateColorComponents = (arr, opt = {}) => {
-  if (!Array.isArray(arr)) {
-    throw new TypeError(`${arr} is not an array.`);
-  }
-  const {
-    alpha = false,
-    minLength = TRIA,
-    maxLength = QUAD,
-    minRange = 0,
-    maxRange = 1,
-    validateRange = true
-  } = opt;
-  if (!Number.isFinite(minLength)) {
-    throw new TypeError(`${minLength} is not a number.`);
-  }
-  if (!Number.isFinite(maxLength)) {
-    throw new TypeError(`${maxLength} is not a number.`);
-  }
-  if (!Number.isFinite(minRange)) {
-    throw new TypeError(`${minRange} is not a number.`);
-  }
-  if (!Number.isFinite(maxRange)) {
-    throw new TypeError(`${maxRange} is not a number.`);
-  }
-  const l = arr.length;
-  if (l < minLength || l > maxLength) {
-    throw new Error(`Unexpected array length ${l}.`);
-  }
-  let i = 0;
-  while (i < l) {
-    const v = arr[i];
-    if (!Number.isFinite(v)) {
-      throw new TypeError(`${v} is not a number.`);
-    } else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) {
-      throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);
-    } else if (i === TRIA && (v < 0 || v > 1)) {
-      throw new RangeError(`${v} is not between 0 and 1.`);
-    }
-    i++;
-  }
-  if (alpha && l === TRIA) {
-    arr.push(1);
-  }
-  return arr;
-};
-var transformMatrix = (mtx, vct, skip = false) => {
-  if (!Array.isArray(mtx)) {
-    throw new TypeError(`${mtx} is not an array.`);
-  } else if (mtx.length !== TRIA) {
-    throw new Error(`Unexpected array length ${mtx.length}.`);
-  } else if (!skip) {
-    for (let i of mtx) {
-      i = validateColorComponents(i, {
-        maxLength: TRIA,
-        validateRange: false
-      });
-    }
-  }
-  const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;
-  let v1, v2, v3;
-  if (skip) {
-    [v1, v2, v3] = vct;
-  } else {
-    [v1, v2, v3] = validateColorComponents(vct, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const p1 = r1c1 * v1 + r1c2 * v2 + r1c3 * v3;
-  const p2 = r2c1 * v1 + r2c2 * v2 + r2c3 * v3;
-  const p3 = r3c1 * v1 + r3c2 * v2 + r3c3 * v3;
-  return [p1, p2, p3];
-};
-var normalizeColorComponents = (colorA, colorB, skip = false) => {
-  if (!Array.isArray(colorA)) {
-    throw new TypeError(`${colorA} is not an array.`);
-  } else if (colorA.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorA.length}.`);
-  }
-  if (!Array.isArray(colorB)) {
-    throw new TypeError(`${colorB} is not an array.`);
-  } else if (colorB.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorB.length}.`);
-  }
-  let i = 0;
-  while (i < QUAD) {
-    if (colorA[i] === NONE && colorB[i] === NONE) {
-      colorA[i] = 0;
-      colorB[i] = 0;
-    } else if (colorA[i] === NONE) {
-      colorA[i] = colorB[i];
-    } else if (colorB[i] === NONE) {
-      colorB[i] = colorA[i];
-    }
-    i++;
-  }
-  if (skip) {
-    return [colorA, colorB];
-  }
-  const validatedColorA = validateColorComponents(colorA, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  const validatedColorB = validateColorComponents(colorB, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  return [validatedColorA, validatedColorB];
-};
-var numberToHexString = (value) => {
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`${value} is not a number.`);
-  } else {
-    value = Math.round(value);
-    if (value < 0 || value > MAX_RGB) {
-      throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);
-    }
-  }
-  let hex = value.toString(HEX);
-  if (hex.length === 1) {
-    hex = `0${hex}`;
-  }
-  return hex;
-};
-var angleToDeg = (angle) => {
-  if (isString(angle)) {
-    angle = angle.trim();
-  } else {
-    throw new TypeError(`${angle} is not a string.`);
-  }
-  const GRAD = DEG / 400;
-  const RAD = DEG / (Math.PI * DUO);
-  const reg = new RegExp(`^(${NUM})(${ANGLE})?$`);
-  if (!reg.test(angle)) {
-    throw new SyntaxError(`Invalid property value: ${angle}`);
-  }
-  const [, value, unit] = angle.match(reg);
-  let deg;
-  switch (unit) {
-    case "grad":
-      deg = parseFloat(value) * GRAD;
-      break;
-    case "rad":
-      deg = parseFloat(value) * RAD;
-      break;
-    case "turn":
-      deg = parseFloat(value) * DEG;
-      break;
-    default:
-      deg = parseFloat(value);
-  }
-  deg %= DEG;
-  if (deg < 0) {
-    deg += DEG;
-  } else if (Object.is(deg, -0)) {
-    deg = 0;
-  }
-  return deg;
-};
-var parseAlpha = (alpha = "") => {
-  if (isString(alpha)) {
-    alpha = alpha.trim();
-    if (!alpha) {
-      alpha = "1";
-    } else if (alpha === NONE) {
-      alpha = "0";
-    } else {
-      let a;
-      if (alpha.endsWith("%")) {
-        a = parseFloat(alpha) / MAX_PCT;
-      } else {
-        a = parseFloat(alpha);
-      }
-      if (!Number.isFinite(a)) {
-        throw new TypeError(`${a} is not a finite number.`);
-      }
-      if (a < PPTH) {
-        alpha = "0";
-      } else if (a > 1) {
-        alpha = "1";
-      } else {
-        alpha = a.toFixed(TRIA);
-      }
-    }
-  } else {
-    alpha = "1";
-  }
-  return parseFloat(alpha);
-};
-var parseHexAlpha = (value) => {
-  if (isString(value)) {
-    if (value === "") {
-      throw new SyntaxError("Invalid property value: (empty string)");
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  let alpha = parseInt(value, HEX);
-  if (alpha <= 0) {
-    return 0;
-  }
-  if (alpha >= MAX_RGB) {
-    return 1;
-  }
-  const alphaMap = /* @__PURE__ */ new Map();
-  for (let i = 1; i < MAX_PCT; i++) {
-    alphaMap.set(Math.round(i * MAX_RGB / MAX_PCT), i);
-  }
-  if (alphaMap.has(alpha)) {
-    alpha = alphaMap.get(alpha) / MAX_PCT;
-  } else {
-    alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;
-  }
-  return parseFloat(alpha.toFixed(TRIA));
-};
-var transformRgbToLinearRgb = (rgb, skip = false) => {
-  let rr, gg, bb;
-  if (skip) {
-    [rr, gg, bb] = rgb;
-  } else {
-    [rr, gg, bb] = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    });
-  }
-  let r = rr / MAX_RGB;
-  let g = gg / MAX_RGB;
-  let b = bb / MAX_RGB;
-  const COND_POW = 0.04045;
-  if (r > COND_POW) {
-    r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    r /= LINEAR_COEF;
-  }
-  if (g > COND_POW) {
-    g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    g /= LINEAR_COEF;
-  }
-  if (b > COND_POW) {
-    b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    b /= LINEAR_COEF;
-  }
-  return [r, g, b];
-};
-var transformRgbToXyz = (rgb, skip = false) => {
-  if (!skip) {
-    rgb = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    });
-  }
-  rgb = transformRgbToLinearRgb(rgb, true);
-  const xyz = transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);
-  return xyz;
-};
-var transformLinearRgbToRgb = (rgb, round = false) => {
-  let [r, g, b] = validateColorComponents(rgb, {
-    maxLength: TRIA
-  });
-  const COND_POW = 809 / 258400;
-  if (r > COND_POW) {
-    r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    r *= LINEAR_COEF;
-  }
-  r *= MAX_RGB;
-  if (g > COND_POW) {
-    g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    g *= LINEAR_COEF;
-  }
-  g *= MAX_RGB;
-  if (b > COND_POW) {
-    b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    b *= LINEAR_COEF;
-  }
-  b *= MAX_RGB;
-  return [
-    round ? Math.round(r) : r,
-    round ? Math.round(g) : g,
-    round ? Math.round(b) : b
-  ];
-};
-var transformXyzToRgb = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);
-  [r, g, b] = transformLinearRgbToRgb(
-    [
-      Math.min(Math.max(r, 0), 1),
-      Math.min(Math.max(g, 0), 1),
-      Math.min(Math.max(b, 0), 1)
-    ],
-    true
-  );
-  return [r, g, b];
-};
-var transformXyzToHsl = (xyz, skip = false) => {
-  const [rr, gg, bb] = transformXyzToRgb(xyz, skip);
-  const r = rr / MAX_RGB;
-  const g = gg / MAX_RGB;
-  const b = bb / MAX_RGB;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const d = max - min;
-  const l = (max + min) * HALF * MAX_PCT;
-  let h, s;
-  if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {
-    h = 0;
-    s = 0;
-  } else {
-    s = d / (1 - Math.abs(max + min - 1)) * MAX_PCT;
-    if (s === 0) {
-      h = 0;
-    } else {
-      switch (max) {
-        case r:
-          h = (g - b) / d;
-          break;
-        case g:
-          h = (b - r) / d + DUO;
-          break;
-        case b:
-        default:
-          h = (r - g) / d + QUAD;
-          break;
-      }
-      h = h * SEXA % DEG;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [h, s, l];
-};
-var transformXyzToHwb = (xyz, skip = false) => {
-  const [r, g, b] = transformXyzToRgb(xyz, skip);
-  const wh = Math.min(r, g, b) / MAX_RGB;
-  const bk = 1 - Math.max(r, g, b) / MAX_RGB;
-  let h;
-  if (wh + bk === 1) {
-    h = 0;
-  } else {
-    [h] = transformXyzToHsl(xyz);
-  }
-  return [h, wh * MAX_PCT, bk * MAX_PCT];
-};
-var transformXyzToOklab = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const lms = transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true);
-  const xyzLms = lms.map((c) => Math.cbrt(c));
-  let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, xyzLms, true);
-  l = Math.min(Math.max(l, 0), 1);
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    a = 0;
-    b = 0;
-  }
-  return [l, a, b];
-};
-var transformXyzToOklch = (xyz, skip = false) => {
-  const [l, a, b] = transformXyzToOklab(xyz, skip);
-  let c, h;
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    if (parseFloat(c.toFixed(QUAD)) === 0) {
-      h = 0;
-    } else {
-      h = Math.atan2(b, a) * DEG_HALF / Math.PI;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [l, c, h];
-};
-var transformXyzD50ToRgb = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, xyz, true);
-  const rgb = transformXyzToRgb(xyzD65, true);
-  return rgb;
-};
-var transformXyzD50ToLab = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const xyzD50 = xyz.map((val, i) => val / D50[i]);
-  const [f0, f1, f2] = xyzD50.map(
-    (val) => val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L
-  );
-  const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);
-  let a, b;
-  if (l === 0 || l === MAX_PCT) {
-    a = 0;
-    b = 0;
-  } else {
-    a = (f0 - f1) * LAB_A;
-    b = (f1 - f2) * LAB_B;
-  }
-  return [l, a, b];
-};
-var transformXyzD50ToLch = (xyz, skip = false) => {
-  const [l, a, b] = transformXyzD50ToLab(xyz, skip);
-  let c, h;
-  if (l === 0 || l === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    h = Math.atan2(b, a) * DEG_HALF / Math.PI;
-    if (h < 0) {
-      h += DEG;
-    }
-  }
-  return [l, c, h];
-};
-var convertRgbToHex = (rgb) => {
-  const [r, g, b, alpha] = validateColorComponents(rgb, {
-    alpha: true,
-    maxRange: MAX_RGB
-  });
-  const rr = numberToHexString(r);
-  const gg = numberToHexString(g);
-  const bb = numberToHexString(b);
-  const aa = numberToHexString(alpha * MAX_RGB);
-  let hex;
-  if (aa === "ff") {
-    hex = `#${rr}${gg}${bb}`;
-  } else {
-    hex = `#${rr}${gg}${bb}${aa}`;
-  }
-  return hex;
-};
-var convertHexToRgb = (value) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  if (!(/^#[\da-f]{6}$/.test(value) || /^#[\da-f]{3}$/.test(value) || /^#[\da-f]{8}$/.test(value) || /^#[\da-f]{4}$/.test(value))) {
-    throw new SyntaxError(`Invalid property value: ${value}`);
-  }
-  const arr = [];
-  if (/^#[\da-f]{3}$/.test(value)) {
-    const [, r, g, b] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])$/
-    );
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      1
-    );
-  } else if (/^#[\da-f]{4}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])([\da-f])$/
-    );
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      parseHexAlpha(`${alpha}${alpha}`)
-    );
-  } else if (/^#[\da-f]{8}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    );
-    arr.push(
-      parseInt(r, HEX),
-      parseInt(g, HEX),
-      parseInt(b, HEX),
-      parseHexAlpha(alpha)
-    );
-  } else {
-    const [, r, g, b] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    );
-    arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);
-  }
-  return arr;
-};
-var convertHexToLinearRgb = (value) => {
-  const [rr, gg, bb, alpha] = convertHexToRgb(value);
-  const [r, g, b] = transformRgbToLinearRgb([rr, gg, bb], true);
-  return [r, g, b, alpha];
-};
-var convertHexToXyz = (value) => {
-  const [r, g, b, alpha] = convertHexToLinearRgb(value);
-  const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b], true);
-  return [x, y, z, alpha];
-};
-var parseRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  const reg = new RegExp(`^rgba?\\(\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\s*\\)$`);
-  if (!reg.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(reg);
-  const [v1, v2, v3, v4 = ""] = val.replace(/[,/]/g, " ").split(/\s+/);
-  let r, g, b;
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    if (v1.endsWith("%")) {
-      r = parseFloat(v1) * MAX_RGB / MAX_PCT;
-    } else {
-      r = parseFloat(v1);
-    }
-    r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    if (v2.endsWith("%")) {
-      g = parseFloat(v2) * MAX_RGB / MAX_PCT;
-    } else {
-      g = parseFloat(v2);
-    }
-    g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    if (v3.endsWith("%")) {
-      b = parseFloat(v3) * MAX_RGB / MAX_PCT;
-    } else {
-      b = parseFloat(v3);
-    }
-    b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);
-  }
-  const alpha = parseAlpha(v4);
-  return ["rgb", r, g, b, format === VAL_MIX && v4 === NONE ? NONE : alpha];
-};
-var parseHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_HSL.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_HSL);
-  const [v1, v2, v3, v4 = ""] = val.replace(/[,/]/g, " ").split(/\s+/);
-  let h, s, l;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    s = 0;
-  } else {
-    s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);
-  }
-  if (v3 === NONE) {
-    l = 0;
-  } else {
-    l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);
-  }
-  const alpha = parseAlpha(v4);
-  if (format === "hsl") {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : s,
-      v3 === NONE ? v3 : l,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  h = h / DEG * DOZ;
-  l /= MAX_PCT;
-  const sa = s / MAX_PCT * Math.min(l, 1 - l);
-  const rk = h % DOZ;
-  const gk = (8 + h) % DOZ;
-  const bk = (4 + h) % DOZ;
-  const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));
-  const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));
-  const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));
-  return [
-    "rgb",
-    Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),
-    alpha
-  ];
-};
-var parseHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_HWB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_HWB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let h, wh, bk;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    wh = 0;
-  } else {
-    wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;
-  }
-  if (v3 === NONE) {
-    bk = 0;
-  } else {
-    bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;
-  }
-  const alpha = parseAlpha(v4);
-  if (format === "hwb") {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : wh * MAX_PCT,
-      v3 === NONE ? v3 : bk * MAX_PCT,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  if (wh + bk >= 1) {
-    const v = roundToPrecision(wh / (wh + bk) * MAX_RGB, OCT);
-    return ["rgb", v, v, v, alpha];
-  }
-  const factor = (1 - wh - bk) / MAX_RGB;
-  let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`);
-  r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);
-  g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);
-  b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);
-  return [
-    "rgb",
-    Math.min(Math.max(r, 0), MAX_RGB),
-    Math.min(Math.max(g, 0), MAX_RGB),
-    Math.min(Math.max(b, 0), MAX_RGB),
-    alpha
-  ];
-};
-var parseLab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_LAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 1.25;
-  const COND_POW = 8;
-  const [, val] = value.match(REG_LAB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    if (v1.endsWith("%")) {
-      l = parseFloat(v1);
-      if (l > MAX_PCT) {
-        l = MAX_PCT;
-      }
-    } else {
-      l = parseFloat(v1);
-    }
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else {
-    a = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith("%") ? parseFloat(v3) * COEF_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "lab",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const fl = (l + HEX) / LAB_L;
-  const fa = a / LAB_A + fl;
-  const fb = fl - b / LAB_B;
-  const powFl = Math.pow(fl, POW_CUBE);
-  const powFa = Math.pow(fa, POW_CUBE);
-  const powFb = Math.pow(fb, POW_CUBE);
-  const xyz = [
-    powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,
-    l > COND_POW ? powFl : l / LAB_KAPPA,
-    powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA
-  ];
-  const [x, y, z] = xyz.map(
-    (val2, i) => val2 * D50[i]
-  );
-  return [
-    "xyz-d50",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-var parseLch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_LCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 1.5;
-  const [, val] = value.match(REG_LCH);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    c = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "lch",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos(h * Math.PI / DEG_HALF);
-  const b = c * Math.sin(h * Math.PI / DEG_HALF);
-  const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`);
-  return [
-    "xyz-d50",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-var parseOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_OKLAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLAB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else if (v2.endsWith("%")) {
-    a = parseFloat(v2) * COEF_PCT / MAX_PCT;
-  } else {
-    a = parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else if (v3.endsWith("%")) {
-    b = parseFloat(v3) * COEF_PCT / MAX_PCT;
-  } else {
-    b = parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "oklab",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map((c) => Math.pow(c, POW_CUBE));
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-var parseOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_OKLCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLCH);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    if (v2.endsWith("%")) {
-      c = parseFloat(v2) * COEF_PCT / MAX_PCT;
-    } else {
-      c = parseFloat(v2);
-    }
-    if (c < 0) {
-      c = 0;
-    }
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "oklch",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos(h * Math.PI / DEG_HALF);
-  const b = c * Math.sin(h * Math.PI / DEG_HALF);
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map((cc) => Math.pow(cc, POW_CUBE));
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-var parseColorFunc = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", d50 = false, format = "", nullable = false } = opt;
-  if (!REG_FN_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_FN_COLOR);
-  let [cs, v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let r, g, b;
-  if (cs === "xyz") {
-    cs = "xyz-d65";
-  }
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    r = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    g = v2.endsWith("%") ? parseFloat(v2) / MAX_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith("%") ? parseFloat(v3) / MAX_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format) || format === VAL_MIX && cs === colorSpace) {
-    return [
-      cs,
-      v1 === NONE ? v1 : roundToPrecision(r, DEC),
-      v2 === NONE ? v2 : roundToPrecision(g, DEC),
-      v3 === NONE ? v3 : roundToPrecision(b, DEC),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  if (cs === "srgb-linear") {
-    [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "display-p3") {
-    const linearRgb = transformRgbToLinearRgb([
-      r * MAX_RGB,
-      g * MAX_RGB,
-      b * MAX_RGB
-    ]);
-    [x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "rec2020") {
-    const ALPHA = 1.09929682680944;
-    const BETA = 0.018053968510807;
-    const REC_COEF = 0.45;
-    const rgb = [r, g, b].map((c) => {
-      let cl;
-      if (c < BETA * REC_COEF * DEC) {
-        cl = c / (REC_COEF * DEC);
-      } else {
-        cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);
-      }
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "a98-rgb") {
-    const POW_A98 = 563 / 256;
-    const rgb = [r, g, b].map((c) => {
-      const cl = Math.pow(c, POW_A98);
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "prophoto-rgb") {
-    const POW_PROPHOTO = 1.8;
-    const rgb = [r, g, b].map((c) => {
-      let cl;
-      if (c > 1 / (HEX * DUO)) {
-        cl = Math.pow(c, POW_PROPHOTO);
-      } else {
-        cl = c / HEX;
-      }
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {
-    [x, y, z] = [r, g, b];
-    if (cs === "xyz-d50") {
-      if (!d50) {
-        [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z]);
-      }
-    } else if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else {
-    [x, y, z] = transformRgbToXyz([r * MAX_RGB, g * MAX_RGB, b * MAX_RGB]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? "xyz-d50" : "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    format === VAL_MIX && v4 === NONE ? v4 : alpha
-  ];
-};
-var parseColorValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = "", nullable = false } = opt;
-  if (!REG_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  let alpha = 0;
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_COMP) {
-      return ["rgb", 0, 0, 0, 0];
-    }
-    if (format === VAL_SPEC) {
-      return value;
-    }
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      }
-      const [r, g, b] = NAMED_COLORS[value];
-      alpha = 1;
-      if (format === VAL_COMP) {
-        return ["rgb", r, g, b, alpha];
-      }
-      [x, y, z] = transformRgbToXyz([r, g, b], true);
-      if (d50) {
-        [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-      }
-    } else {
-      switch (format) {
-        case VAL_COMP: {
-          if (nullable && value !== "transparent") {
-            return new NullObject();
-          }
-          return ["rgb", 0, 0, 0, 0];
-        }
-        case VAL_SPEC: {
-          if (value === "transparent") {
-            return value;
-          }
-          return "";
-        }
-        case VAL_MIX: {
-          if (value === "transparent") {
-            return ["rgb", 0, 0, 0, 0];
-          }
-          return new NullObject();
-        }
-        default:
-      }
-    }
-  } else if (value[0] === "#") {
-    if (REG_SPEC.test(format)) {
-      const rgb = convertHexToRgb(value);
-      return ["rgb", ...rgb];
-    }
-    [x, y, z, alpha] = convertHexToXyz(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (value.startsWith("lab")) {
-    if (REG_SPEC.test(format)) {
-      return parseLab(value, opt);
-    }
-    [, x, y, z, alpha] = parseLab(value);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (value.startsWith("lch")) {
-    if (REG_SPEC.test(format)) {
-      return parseLch(value, opt);
-    }
-    [, x, y, z, alpha] = parseLch(value);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (value.startsWith("oklab")) {
-    if (REG_SPEC.test(format)) {
-      return parseOklab(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklab(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (value.startsWith("oklch")) {
-    if (REG_SPEC.test(format)) {
-      return parseOklch(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklch(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else {
-    let r, g, b;
-    if (value.startsWith("hsl")) {
-      [, r, g, b, alpha] = parseHsl(value);
-    } else if (value.startsWith("hwb")) {
-      [, r, g, b, alpha] = parseHwb(value);
-    } else {
-      [, r, g, b, alpha] = parseRgb(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      return ["rgb", Math.round(r), Math.round(g), Math.round(b), alpha];
-    }
-    [x, y, z] = transformRgbToXyz([r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? "xyz-d50" : "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-var resolveColorValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorValue",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  if (!REG_COLOR.test(value)) {
-    const res2 = resolveInvalidColorValue(format, nullable);
-    if (res2 instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res2;
-    }
-    setCache(cacheKey, res2);
-    if (isString(res2)) {
-      return res2;
-    }
-    return res2;
-  }
-  let cs = "";
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        setCache(cacheKey, value);
-        return value;
-      }
-      [r, g, b] = NAMED_COLORS[value];
-      alpha = 1;
-    } else {
-      switch (format) {
-        case VAL_SPEC: {
-          if (value === "transparent") {
-            setCache(cacheKey, value);
-            return value;
-          }
-          const res2 = "";
-          setCache(cacheKey, res2);
-          return res2;
-        }
-        case VAL_MIX: {
-          if (value === "transparent") {
-            const res2 = ["rgb", 0, 0, 0, 0];
-            setCache(cacheKey, res2);
-            return res2;
-          }
-          setCache(cacheKey, null);
-          return new NullObject();
-        }
-        case VAL_COMP:
-        default: {
-          if (nullable && value !== "transparent") {
-            setCache(cacheKey, null);
-            return new NullObject();
-          }
-          const res2 = ["rgb", 0, 0, 0, 0];
-          setCache(cacheKey, res2);
-          return res2;
-        }
-      }
-    }
-  } else if (value[0] === "#") {
-    [r, g, b, alpha] = convertHexToRgb(value);
-  } else if (value.startsWith("hsl")) {
-    [, r, g, b, alpha] = parseHsl(value, opt);
-  } else if (value.startsWith("hwb")) {
-    [, r, g, b, alpha] = parseHwb(value, opt);
-  } else if (/^l(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith("lab")) {
-      [cs, x, y, z, alpha] = parseLab(value, opt);
-    } else {
-      [cs, x, y, z, alpha] = parseLch(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      const res2 = [cs, x, y, z, alpha];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [r, g, b] = transformXyzD50ToRgb([x, y, z]);
-  } else if (/^okl(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith("oklab")) {
-      [cs, x, y, z, alpha] = parseOklab(value, opt);
-    } else {
-      [cs, x, y, z, alpha] = parseOklch(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      const res2 = [cs, x, y, z, alpha];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [r, g, b] = transformXyzToRgb([x, y, z]);
-  } else {
-    [, r, g, b, alpha] = parseRgb(value, opt);
-  }
-  if (format === VAL_MIX && colorSpace === "srgb") {
-    const res2 = [
-      "srgb",
-      r / MAX_RGB,
-      g / MAX_RGB,
-      b / MAX_RGB,
-      alpha
-    ];
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  const res = [
-    "rgb",
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    alpha
-  ];
-  setCache(cacheKey, res);
-  return res;
-};
-var resolveColorFunc = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorFunc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  if (!REG_FN_COLOR.test(value)) {
-    const res2 = resolveInvalidColorValue(format, nullable);
-    if (res2 instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res2;
-    }
-    setCache(cacheKey, res2);
-    if (isString(res2)) {
-      return res2;
-    }
-    return res2;
-  }
-  const [cs, v1, v2, v3, v4] = parseColorFunc(
-    value,
-    opt
-  );
-  if (REG_SPEC.test(format) || format === VAL_MIX && cs === colorSpace) {
-    const res2 = [cs, v1, v2, v3, v4];
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  const x = parseFloat(`${v1}`);
-  const y = parseFloat(`${v2}`);
-  const z = parseFloat(`${v3}`);
-  const alpha = parseAlpha(`${v4}`);
-  const [r, g, b] = transformXyzToRgb([x, y, z], true);
-  const res = ["rgb", r, g, b, alpha];
-  setCache(cacheKey, res);
-  return res;
-};
-var convertColorToLinearRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "" } = opt;
-  let cs = "";
-  let r, g, b, alpha, x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [cs, x, y, z, alpha] = xyz;
-    if (cs === colorSpace) {
-      return [x, y, z, alpha];
-    }
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs2] = val.replace("/", " ").split(/\s+/);
-    if (cs2 === "srgb-linear") {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value);
-      [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  }
-  return [
-    Math.min(Math.max(r, 0), 1),
-    Math.min(Math.max(g, 0), 1),
-    Math.min(Math.max(b, 0), 1),
-    alpha
-  ];
-};
-var convertColorToRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let r, g, b, alpha;
-  if (format === VAL_MIX) {
-    let rgb;
-    if (value.startsWith(FN_COLOR)) {
-      rgb = resolveColorFunc(value, opt);
-    } else {
-      rgb = resolveColorValue(value, opt);
-    }
-    if (rgb instanceof NullObject) {
-      return rgb;
-    }
-    [, r, g, b, alpha] = rgb;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs] = val.replace("/", " ").split(/\s+/);
-    if (cs === "srgb") {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-      r *= MAX_RGB;
-      g *= MAX_RGB;
-      b *= MAX_RGB;
-    } else {
-      [, r, g, b, alpha] = resolveColorFunc(value);
-    }
-  } else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {
-    [r, g, b, alpha] = convertColorToLinearRgb(value);
-    [r, g, b] = transformLinearRgbToRgb([r, g, b]);
-  } else {
-    [, r, g, b, alpha] = resolveColorValue(value, {
-      format: VAL_COMP
-    });
-  }
-  return [r, g, b, alpha];
-};
-var convertColorToXyz = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = "" } = opt;
-  let x, y, z, alpha;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs] = val.replace("/", " ").split(/\s+/);
-    if (d50) {
-      if (cs === "xyz-d50") {
-        [, x, y, z, alpha] = resolveColorFunc(value, {
-          format: VAL_COMP
-        });
-      } else {
-        [, x, y, z, alpha] = parseColorFunc(
-          value,
-          opt
-        );
-      }
-    } else if (/^xyz(?:-d65)?$/.test(cs)) {
-      [, x, y, z, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value);
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, opt);
-  }
-  return [x, y, z, alpha];
-};
-var convertColorToHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let h, s, l, alpha;
-  if (REG_HSL.test(value)) {
-    [, h, s, l, alpha] = parseHsl(value, {
-      format: "hsl"
-    });
-    if (format === "hsl") {
-      return [Math.round(h), Math.round(s), Math.round(l), alpha];
-    }
-    return [h, s, l, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [h, s, l] = transformXyzToHsl([x, y, z], true);
-  if (format === "hsl") {
-    return [Math.round(h), Math.round(s), Math.round(l), alpha];
-  }
-  return [format === VAL_MIX && s === 0 ? NONE : h, s, l, alpha];
-};
-var convertColorToHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let h, w, b, alpha;
-  if (REG_HWB.test(value)) {
-    [, h, w, b, alpha] = parseHwb(value, {
-      format: "hwb"
-    });
-    if (format === "hwb") {
-      return [Math.round(h), Math.round(w), Math.round(b), alpha];
-    }
-    return [h, w, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [h, w, b] = transformXyzToHwb([x, y, z], true);
-  if (format === "hwb") {
-    return [Math.round(h), Math.round(w), Math.round(b), alpha];
-  }
-  return [format === VAL_MIX && w + b >= 100 ? NONE : h, w, b, alpha];
-};
-var convertColorToLab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, a, b, alpha;
-  if (REG_LAB.test(value)) {
-    [, l, a, b, alpha] = parseLab(value, {
-      format: VAL_COMP
-    });
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    });
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    });
-  }
-  [l, a, b] = transformXyzD50ToLab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-var convertColorToLch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, c, h, alpha;
-  if (REG_LCH.test(value)) {
-    [, l, c, h, alpha] = parseLch(value, {
-      format: VAL_COMP
-    });
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    });
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    });
-  }
-  [l, c, h] = transformXyzD50ToLch([x, y, z], true);
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-var convertColorToOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, a, b, alpha;
-  if (REG_OKLAB.test(value)) {
-    [, l, a, b, alpha] = parseOklab(value, {
-      format: VAL_COMP
-    });
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [l, a, b] = transformXyzToOklab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-var convertColorToOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, c, h, alpha;
-  if (REG_OKLCH.test(value)) {
-    [, l, c, h, alpha] = parseOklch(value, {
-      format: VAL_COMP
-    });
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [l, c, h] = transformXyzToOklch([x, y, z], true);
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-var resolveColorMix = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorMix",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  const nestedItems = [];
-  let colorSpace = "";
-  let hueArc = "";
-  let colorA = "";
-  let pctA = "";
-  let colorB = "";
-  let pctB = "";
-  let parsed = false;
-  if (!REG_MIX.test(value)) {
-    if (value.startsWith(FN_MIX) && REG_MIX_NEST.test(value)) {
-      const regColorSpace = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);
-      const items = value.match(REG_MIX_NEST);
-      for (const item of items) {
-        if (item) {
-          let val = resolveColorMix(item, {
-            format: format === VAL_SPEC ? format : VAL_COMP
-          });
-          if (Array.isArray(val)) {
-            const [cs, v1, v2, v3, v4] = val;
-            if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {
-              value = "";
-              break;
-            }
-            if (regColorSpace.test(cs)) {
-              if (v4 === 1) {
-                val = `color(${cs} ${v1} ${v2} ${v3})`;
-              } else {
-                val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-              }
-            } else if (v4 === 1) {
-              val = `${cs}(${v1} ${v2} ${v3})`;
-            } else {
-              val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-            }
-          } else if (!REG_MIX.test(val)) {
-            value = "";
-            break;
-          }
-          nestedItems.push(val);
-          value = value.replace(item, val);
-        }
-      }
-      if (!value) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-    } else if (value.startsWith(FN_MIX) && value.endsWith(")") && value.includes(FN_LIGHT_DARK)) {
-      const regColorSpace = new RegExp(`in\\s+(${CS_MIX})`);
-      const colorParts = value.replace(FN_MIX, "").replace(/\)$/, "");
-      const [csPart = "", partA = "", partB = ""] = splitValue(colorParts, {
-        delimiter: ","
-      });
-      const [colorPartA = "", pctPartA = ""] = splitValue(partA);
-      const [colorPartB = "", pctPartB = ""] = splitValue(partB);
-      const specifiedColorA = resolveColor(colorPartA, {
-        format: VAL_SPEC
-      });
-      const specifiedColorB = resolveColor(colorPartB, {
-        format: VAL_SPEC
-      });
-      if (regColorSpace.test(csPart) && specifiedColorA && specifiedColorB) {
-        if (format === VAL_SPEC) {
-          const [, cs] = csPart.match(regColorSpace);
-          if (REG_CS_HUE.test(cs)) {
-            [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-          } else {
-            colorSpace = cs;
-          }
-          colorA = specifiedColorA;
-          if (pctPartA) {
-            pctA = pctPartA;
-          }
-          colorB = specifiedColorB;
-          if (pctPartB) {
-            pctB = pctPartB;
-          }
-          value = value.replace(colorPartA, specifiedColorA).replace(colorPartB, specifiedColorB);
-          parsed = true;
-        } else {
-          const resolvedColorA = resolveColor(colorPartA, opt);
-          const resolvedColorB = resolveColor(colorPartB, opt);
-          if (isString(resolvedColorA) && isString(resolvedColorB)) {
-            value = value.replace(colorPartA, resolvedColorA).replace(colorPartB, resolvedColorB);
-          }
-        }
-      } else {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-    } else {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-  }
-  if (nestedItems.length && format === VAL_SPEC) {
-    const regColorSpace = new RegExp(`^color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,`);
-    const [, cs] = value.match(regColorSpace);
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-    } else {
-      colorSpace = cs;
-    }
-    if (nestedItems.length === 2) {
-      let [itemA, itemB] = nestedItems;
-      itemA = itemA.replace(/(?=[()])/g, "\\");
-      itemB = itemB.replace(/(?=[()])/g, "\\");
-      const regA = new RegExp(`(${itemA})(?:\\s+(${PCT}))?`);
-      const regB = new RegExp(`(${itemB})(?:\\s+(${PCT}))?`);
-      [, colorA, pctA] = value.match(regA);
-      [, colorB, pctB] = value.match(regB);
-    } else {
-      let [item] = nestedItems;
-      item = item.replace(/(?=[()])/g, "\\");
-      const itemPart = `${item}(?:\\s+${PCT})?`;
-      const itemPartCapt = `(${item})(?:\\s+(${PCT}))?`;
-      const regItemPart = new RegExp(`^${itemPartCapt}$`);
-      const regLastItem = new RegExp(`${itemPartCapt}\\s*\\)$`);
-      const regColorPart = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-      if (regLastItem.test(value)) {
-        const reg = new RegExp(
-          `(${SYN_MIX_PART})\\s*,\\s*(${itemPart})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg);
-        [, colorA, pctA] = colorPartA.match(regColorPart);
-        [, colorB, pctB] = colorPartB.match(regItemPart);
-      } else {
-        const reg = new RegExp(
-          `(${itemPart})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg);
-        [, colorA, pctA] = colorPartA.match(regItemPart);
-        [, colorB, pctB] = colorPartB.match(regColorPart);
-      }
-    }
-  } else if (!parsed) {
-    const [, cs, colorPartA, colorPartB] = value.match(
-      REG_MIX_CAPT
-    );
-    const reg = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-    [, colorA, pctA] = colorPartA.match(reg);
-    [, colorB, pctB] = colorPartB.match(reg);
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-    } else {
-      colorSpace = cs;
-    }
-  }
-  let pA, pB, m;
-  if (pctA && pctB) {
-    const p1 = parseFloat(pctA) / MAX_PCT;
-    const p2 = parseFloat(pctB) / MAX_PCT;
-    if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || p1 === 0 && p2 === 0) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const factor = p1 + p2;
-    pA = p1 / factor;
-    pB = p2 / factor;
-    m = factor < 1 ? factor : 1;
-  } else {
-    if (pctA) {
-      pA = parseFloat(pctA) / MAX_PCT;
-      if (pA < 0 || pA > 1) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-      pB = 1 - pA;
-    } else if (pctB) {
-      pB = parseFloat(pctB) / MAX_PCT;
-      if (pB < 0 || pB > 1) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-      pA = 1 - pB;
-    } else {
-      pA = HALF;
-      pB = HALF;
-    }
-    m = 1;
-  }
-  if (colorSpace === "xyz") {
-    colorSpace = "xyz-d65";
-  }
-  if (format === VAL_SPEC) {
-    let valueA = "";
-    let valueB = "";
-    if (colorA.startsWith(FN_MIX) || colorA.startsWith(FN_LIGHT_DARK)) {
-      valueA = colorA;
-    } else if (colorA.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorA,
-        opt
-      );
-      if (v4 === 1) {
-        valueA = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorA, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === "rgb") {
-            valueA = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueA = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === "rgb") {
-          valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, "");
-          return "";
-        }
-        valueA = val;
-      }
-    }
-    if (colorB.startsWith(FN_MIX) || colorB.startsWith(FN_LIGHT_DARK)) {
-      valueB = colorB;
-    } else if (colorB.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorB,
-        opt
-      );
-      if (v4 === 1) {
-        valueB = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorB, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === "rgb") {
-            valueB = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueB = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === "rgb") {
-          valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, "");
-          return "";
-        }
-        valueB = val;
-      }
-    }
-    if (pctA && pctB) {
-      valueA += ` ${parseFloat(pctA)}%`;
-      valueB += ` ${parseFloat(pctB)}%`;
-    } else if (pctA) {
-      const pA2 = parseFloat(pctA);
-      if (pA2 !== MAX_PCT * HALF) {
-        valueA += ` ${pA2}%`;
-      }
-    } else if (pctB) {
-      const pA2 = MAX_PCT - parseFloat(pctB);
-      if (pA2 !== MAX_PCT * HALF) {
-        valueA += ` ${pA2}%`;
-      }
-    }
-    if (hueArc) {
-      const res2 = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res2);
-      return res2;
-    } else {
-      const res2 = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  }
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  if (/^srgb(?:-linear)?$/.test(colorSpace)) {
-    let rgbA, rgbB;
-    if (colorSpace === "srgb") {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToLinearRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToLinearRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (rgbA instanceof NullObject || rgbB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [rrA, ggA, bbA, aaA] = rgbA;
-    const [rrB, ggB, bbB, aaB] = rgbB;
-    const rNone = rrA === NONE && rrB === NONE;
-    const gNone = ggA === NONE && ggB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] = normalizeColorComponents(
-      [rrA, ggA, bbA, aaA],
-      [rrB, ggB, bbB, aaB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    if (alpha === 0) {
-      r = rA * pA + rB * pB;
-      g = gA * pA + gB * pB;
-      b = bA * pA + bB * pB;
-    } else {
-      r = (rA * factorA + rB * factorB) / alpha;
-      g = (gA * factorA + gB * factorB) / alpha;
-      b = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        rNone ? NONE : roundToPrecision(r, HEX),
-        gNone ? NONE : roundToPrecision(g, HEX),
-        bNone ? NONE : roundToPrecision(b, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    r *= MAX_RGB;
-    g *= MAX_RGB;
-    b *= MAX_RGB;
-  } else if (REG_CS_XYZ.test(colorSpace)) {
-    let xyzA, xyzB;
-    if (REG_CURRENT.test(colorA)) {
-      xyzA = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzA = convertColorToXyz(colorA, {
-        colorSpace,
-        d50: colorSpace === "xyz-d50",
-        format: VAL_MIX
-      });
-    }
-    if (REG_CURRENT.test(colorB)) {
-      xyzB = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzB = convertColorToXyz(colorB, {
-        colorSpace,
-        d50: colorSpace === "xyz-d50",
-        format: VAL_MIX
-      });
-    }
-    if (xyzA instanceof NullObject || xyzB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [xxA, yyA, zzA, aaA] = xyzA;
-    const [xxB, yyB, zzB, aaB] = xyzB;
-    const xNone = xxA === NONE && xxB === NONE;
-    const yNone = yyA === NONE && yyB === NONE;
-    const zNone = zzA === NONE && zzB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] = normalizeColorComponents(
-      [xxA, yyA, zzA, aaA],
-      [xxB, yyB, zzB, aaB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let x, y, z;
-    if (alpha === 0) {
-      x = xA * pA + xB * pB;
-      y = yA * pA + yB * pB;
-      z = zA * pA + zB * pB;
-    } else {
-      x = (xA * factorA + xB * factorB) / alpha;
-      y = (yA * factorA + yB * factorB) / alpha;
-      z = (zA * factorA + zB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        xNone ? NONE : roundToPrecision(x, HEX),
-        yNone ? NONE : roundToPrecision(y, HEX),
-        zNone ? NONE : roundToPrecision(z, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (colorSpace === "xyz-d50") {
-      [r, g, b] = transformXyzD50ToRgb([x, y, z], true);
-    } else {
-      [r, g, b] = transformXyzToRgb([x, y, z], true);
-    }
-  } else if (/^h(?:sl|wb)$/.test(colorSpace)) {
-    let hslA, hslB;
-    if (colorSpace === "hsl") {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHsl(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHsl(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHwb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHwb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (hslA instanceof NullObject || hslB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [hhA, ssA, llA, aaA] = hslA;
-    const [hhB, ssB, llB, aaB] = hslB;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents(
-      [hhA, ssA, llA, aaA],
-      [hhB, ssB, llB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let s, l;
-    if (alpha === 0) {
-      s = sA * pA + sB * pB;
-      l = lA * pA + lB * pB;
-    } else {
-      s = (sA * factorA + sB * factorB) / alpha;
-      l = (lA * factorA + lB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    [r, g, b] = convertColorToRgb(
-      `${colorSpace}(${h} ${s} ${l})`
-    );
-    if (format === VAL_COMP) {
-      const res2 = [
-        "srgb",
-        roundToPrecision(r / MAX_RGB, HEX),
-        roundToPrecision(g / MAX_RGB, HEX),
-        roundToPrecision(b / MAX_RGB, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (/^(?:ok)?lch$/.test(colorSpace)) {
-    let lchA, lchB;
-    if (colorSpace === "lch") {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToLch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToLch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToOklch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToOklch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (lchA instanceof NullObject || lchB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [llA, ccA, hhA, aaA] = lchA;
-    const [llB, ccB, hhB, aaB] = lchB;
-    const lNone = llA === NONE && llB === NONE;
-    const cNone = ccA === NONE && ccB === NONE;
-    const hNone = hhA === NONE && hhB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents(
-      [llA, ccA, hhA, aaA],
-      [llB, ccB, hhB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let l, c;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      c = cA * pA + cB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      c = (cA * factorA + cB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        cNone ? NONE : roundToPrecision(c, HEX),
-        hNone ? NONE : roundToPrecision(h, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${c} ${h})`
-    );
-  } else {
-    let labA, labB;
-    if (colorSpace === "lab") {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToLab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToLab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToOklab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToOklab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (labA instanceof NullObject || labB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [llA, aaA, bbA, alA] = labA;
-    const [llB, aaB, bbB, alB] = labB;
-    const lNone = llA === NONE && llB === NONE;
-    const aNone = aaA === NONE && aaB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = alA === NONE && alB === NONE;
-    const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] = normalizeColorComponents(
-      [llA, aaA, bbA, alA],
-      [llB, aaB, bbB, alB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let l, aO, bO;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      aO = aA * pA + aB * pB;
-      bO = bA * pA + bB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      aO = (aA * factorA + aB * factorB) / alpha;
-      bO = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        aNone ? NONE : roundToPrecision(aO, HEX),
-        bNone ? NONE : roundToPrecision(bO, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${aO} ${bO})`
-    );
-  }
-  const res = [
-    "rgb",
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    parseFloat((alpha * m).toFixed(3))
-  ];
-  setCache(cacheKey, res);
-  return res;
-};
-
-// src/js/css-var.ts
-var import_css_tokenizer = require("@csstools/css-tokenizer");
-var {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  EOF,
-  Ident: IDENT,
-  Whitespace: W_SPACE
-} = import_css_tokenizer.TokenType;
-var NAMESPACE2 = "css-var";
-var REG_FN_CALC = new RegExp(SYN_FN_CALC);
-var REG_FN_VAR = new RegExp(SYN_FN_VAR);
-function resolveCustomProperty(tokens, opt = {}) {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { customProperty = {} } = opt;
-  const items = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value] = token;
-    if (type === PAREN_CLOSE) {
-      break;
-    }
-    if (value === FN_VAR) {
-      const [restTokens, item] = resolveCustomProperty(tokens, opt);
-      tokens = restTokens;
-      if (item) {
-        items.push(item);
-      }
-    } else if (type === IDENT) {
-      if (value.startsWith("--")) {
-        let item;
-        if (Object.hasOwn(customProperty, value)) {
-          item = customProperty[value];
-        } else if (typeof customProperty.callback === "function") {
-          item = customProperty.callback(value);
-        }
-        if (item) {
-          items.push(item);
-        }
-      } else if (value) {
-        items.push(value);
-      }
-    }
-  }
-  let resolveAsColor = false;
-  if (items.length > 1) {
-    const lastValue = items[items.length - 1];
-    resolveAsColor = isColor(lastValue);
-  }
-  let resolvedValue = "";
-  for (let item of items) {
-    item = item.trim();
-    if (REG_FN_VAR.test(item)) {
-      const resolvedItem = resolveVar(item, opt);
-      if (isString(resolvedItem)) {
-        if (resolveAsColor) {
-          if (isColor(resolvedItem)) {
-            resolvedValue = resolvedItem;
-          }
-        } else {
-          resolvedValue = resolvedItem;
-        }
-      }
-    } else if (REG_FN_CALC.test(item)) {
-      item = cssCalc(item, opt);
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    } else if (item && !/^(?:inherit|initial|revert(?:-layer)?|unset)$/.test(item)) {
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    }
-    if (resolvedValue) {
-      break;
-    }
-  }
-  return [tokens, resolvedValue];
-}
-function parseTokens(tokens, opt = {}) {
-  const res = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    const [type = "", value = ""] = token;
-    if (value === FN_VAR) {
-      const [restTokens, resolvedValue] = resolveCustomProperty(tokens, opt);
-      if (!resolvedValue) {
-        return new NullObject();
-      }
-      tokens = restTokens;
-      res.push(resolvedValue);
-    } else {
-      switch (type) {
-        case PAREN_CLOSE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (lastValue === " ") {
-              res.splice(-1, 1, value);
-            } else {
-              res.push(value);
-            }
-          } else {
-            res.push(value);
-          }
-          break;
-        }
-        case W_SPACE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-              res.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF) {
-            res.push(value);
-          }
-        }
-      }
-    }
-  }
-  return res;
-}
-function resolveVar(value, opt = {}) {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR.test(value) || format === VAL_SPEC) {
-      return value;
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE2,
-      name: "resolveVar",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  const tokens = (0, import_css_tokenizer.tokenize)({ css: value });
-  const values = parseTokens(tokens, opt);
-  if (Array.isArray(values)) {
-    let color = values.join("");
-    if (REG_FN_CALC.test(color)) {
-      color = cssCalc(color, opt);
-    }
-    setCache(cacheKey, color);
-    return color;
-  } else {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-}
-var cssVar = (value, opt = {}) => {
-  const resolvedValue = resolveVar(value, opt);
-  if (isString(resolvedValue)) {
-    return resolvedValue;
-  }
-  return "";
-};
-
-// src/js/relative-color.ts
-var import_css_color_parser = require("@csstools/css-color-parser");
-var import_css_parser_algorithms = require("@csstools/css-parser-algorithms");
-var import_css_tokenizer2 = require("@csstools/css-tokenizer");
-var {
-  CloseParen: PAREN_CLOSE2,
-  Comment: COMMENT2,
-  Delim: DELIM,
-  Dimension: DIM,
-  EOF: EOF2,
-  Function: FUNC,
-  Ident: IDENT2,
-  Number: NUM2,
-  OpenParen: PAREN_OPEN,
-  Percentage: PCT2,
-  Whitespace: W_SPACE2
-} = import_css_tokenizer2.TokenType;
-var { HasNoneKeywords: KEY_NONE } = import_css_color_parser.SyntaxFlag;
-var NAMESPACE3 = "relative-color";
-var OCT2 = 8;
-var DEC2 = 10;
-var HEX2 = 16;
-var MAX_PCT2 = 100;
-var MAX_RGB2 = 255;
-var REG_COLOR_CAPT = new RegExp(
-  `^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\s+`
-);
-var REG_CS_HSL = /(?:hsla?|hwb)$/;
-var REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);
-var REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\(/;
-var REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
-var REG_FN_REL = new RegExp(FN_REL);
-var REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);
-var REG_FN_REL_START = new RegExp(`^${FN_REL}`);
-var REG_FN_VAR2 = new RegExp(SYN_FN_VAR);
-function resolveColorChannels(tokens, opt = {}) {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { colorSpace = "", format = "" } = opt;
-  const colorChannels = /* @__PURE__ */ new Map([
-    ["color", ["r", "g", "b", "alpha"]],
-    ["hsl", ["h", "s", "l", "alpha"]],
-    ["hsla", ["h", "s", "l", "alpha"]],
-    ["hwb", ["h", "w", "b", "alpha"]],
-    ["lab", ["l", "a", "b", "alpha"]],
-    ["lch", ["l", "c", "h", "alpha"]],
-    ["oklab", ["l", "a", "b", "alpha"]],
-    ["oklch", ["l", "c", "h", "alpha"]],
-    ["rgb", ["r", "g", "b", "alpha"]],
-    ["rgba", ["r", "g", "b", "alpha"]]
-  ]);
-  const colorChannel = colorChannels.get(colorSpace);
-  if (!colorChannel) {
-    return new NullObject();
-  }
-  const mathFunc = /* @__PURE__ */ new Set();
-  const channels = [[], [], [], []];
-  let i = 0;
-  let nest = 0;
-  let func = "";
-  let precededPct = false;
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value, , , detail] = token;
-    const channel = channels[i];
-    if (Array.isArray(channel)) {
-      switch (type) {
-        case DELIM: {
-          if (func) {
-            if ((value === "+" || value === "-") && precededPct && !REG_FN_CALC_SUM.test(func)) {
-              return new NullObject();
-            }
-            precededPct = false;
-            channel.push(value);
-          }
-          break;
-        }
-        case DIM: {
-          if (!func || !REG_FN_CALC_SUM.test(func)) {
-            return new NullObject();
-          }
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            channel.push(resolvedValue);
-          } else {
-            channel.push(value);
-          }
-          break;
-        }
-        case FUNC: {
-          channel.push(value);
-          func = value;
-          nest++;
-          if (REG_FN_MATH_START.test(value)) {
-            mathFunc.add(nest);
-          }
-          break;
-        }
-        case IDENT2: {
-          if (!colorChannel.includes(value)) {
-            return new NullObject();
-          }
-          channel.push(value);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case NUM2: {
-          channel.push(Number(detail?.value));
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case PAREN_OPEN: {
-          channel.push(value);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE2: {
-          if (func) {
-            const lastValue = channel[channel.length - 1];
-            if (lastValue === " ") {
-              channel.splice(-1, 1, value);
-            } else {
-              channel.push(value);
-            }
-            if (mathFunc.has(nest)) {
-              mathFunc.delete(nest);
-            }
-            nest--;
-            if (nest === 0) {
-              func = "";
-              i++;
-            }
-          }
-          break;
-        }
-        case PCT2: {
-          if (!func) {
-            return new NullObject();
-          } else if (!REG_FN_CALC_SUM.test(func)) {
-            const lastValue = channel.toReversed().find((v) => v !== " ");
-            if (lastValue === "+" || lastValue === "-") {
-              return new NullObject();
-            } else if (lastValue === "*" || lastValue === "/") {
-              precededPct = false;
-            } else {
-              precededPct = true;
-            }
-          }
-          channel.push(Number(detail?.value) / MAX_PCT2);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case W_SPACE2: {
-          if (channel.length && func) {
-            const lastValue = channel[channel.length - 1];
-            if (typeof lastValue === "number") {
-              channel.push(value);
-            } else if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-              channel.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT2 && type !== EOF2 && func) {
-            channel.push(value);
-          }
-        }
-      }
-    }
-  }
-  const channelValues = [];
-  for (const channel of channels) {
-    if (channel.length === 1) {
-      const [resolvedValue] = channel;
-      if (isStringOrNumber(resolvedValue)) {
-        channelValues.push(resolvedValue);
-      }
-    } else if (channel.length) {
-      const resolvedValue = serializeCalc(channel.join(""), {
-        format
-      });
-      channelValues.push(resolvedValue);
-    }
-  }
-  return channelValues;
-}
-function extractOriginColor(value, opt = {}) {
-  const { colorScheme = "normal", currentColor = "", format = "" } = opt;
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (!value) {
-      return new NullObject();
-    }
-    if (!REG_FN_REL_START.test(value)) {
-      return value;
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE3,
-      name: "extractOriginColor",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (/currentcolor/.test(value)) {
-    if (currentColor) {
-      value = value.replace(/currentcolor/g, currentColor);
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  let colorSpace = "";
-  if (REG_FN_REL_CAPT.test(value)) {
-    [, colorSpace] = value.match(REG_FN_REL_CAPT);
-  }
-  opt.colorSpace = colorSpace;
-  if (value.includes(FN_LIGHT_DARK)) {
-    const colorParts = value.replace(new RegExp(`^${colorSpace}\\(`), "").replace(/\)$/, "");
-    const [, originColor = ""] = splitValue(colorParts);
-    const specifiedOriginColor = resolveColor(originColor, {
-      colorScheme,
-      format: VAL_SPEC
-    });
-    if (specifiedOriginColor === "") {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-    if (format === VAL_SPEC) {
-      value = value.replace(originColor, specifiedOriginColor);
-    } else {
-      const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-  }
-  if (REG_COLOR_CAPT.test(value)) {
-    const [, originColor] = value.match(REG_COLOR_CAPT);
-    const [, restValue] = value.split(originColor);
-    if (/^[a-z]+$/.test(originColor)) {
-      if (!/^transparent$/.test(originColor) && !Object.hasOwn(NAMED_COLORS, originColor)) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-    } else if (format === VAL_SPEC) {
-      const resolvedOriginColor = resolveColor(originColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-    if (format === VAL_SPEC) {
-      const tokens = (0, import_css_tokenizer2.tokenize)({ css: restValue });
-      const channelValues = resolveColorChannels(tokens, opt);
-      if (channelValues instanceof NullObject) {
-        setCache(cacheKey, null);
-        return channelValues;
-      }
-      const [v1, v2, v3, v4] = channelValues;
-      let channelValue = "";
-      if (isStringOrNumber(v4)) {
-        channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-      } else {
-        channelValue = ` ${channelValues.join(" ")})`;
-      }
-      if (restValue !== channelValue) {
-        value = value.replace(restValue, channelValue);
-      }
-    }
-  } else {
-    const [, restValue] = value.split(REG_FN_REL_START);
-    const tokens = (0, import_css_tokenizer2.tokenize)({ css: restValue });
-    const originColor = [];
-    let nest = 0;
-    while (tokens.length) {
-      const [type, tokenValue] = tokens.shift();
-      switch (type) {
-        case FUNC:
-        case PAREN_OPEN: {
-          originColor.push(tokenValue);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE2: {
-          const lastValue = originColor[originColor.length - 1];
-          if (lastValue === " ") {
-            originColor.splice(-1, 1, tokenValue);
-          } else if (isString(lastValue)) {
-            originColor.push(tokenValue);
-          }
-          nest--;
-          break;
-        }
-        case W_SPACE2: {
-          const lastValue = originColor[originColor.length - 1];
-          if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-            originColor.push(tokenValue);
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT2 && type !== EOF2) {
-            originColor.push(tokenValue);
-          }
-        }
-      }
-      if (nest === 0) {
-        break;
-      }
-    }
-    const resolvedOriginColor = resolveRelativeColor(
-      originColor.join("").trim(),
-      opt
-    );
-    if (resolvedOriginColor instanceof NullObject) {
-      setCache(cacheKey, null);
-      return resolvedOriginColor;
-    }
-    const channelValues = resolveColorChannels(tokens, opt);
-    if (channelValues instanceof NullObject) {
-      setCache(cacheKey, null);
-      return channelValues;
-    }
-    const [v1, v2, v3, v4] = channelValues;
-    let channelValue = "";
-    if (isStringOrNumber(v4)) {
-      channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-    } else {
-      channelValue = ` ${channelValues.join(" ")})`;
-    }
-    value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);
-  }
-  setCache(cacheKey, value);
-  return value;
-}
-function resolveRelativeColor(value, opt = {}) {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR2.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      } else {
-        throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);
-      }
-    } else if (!REG_FN_REL.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE3,
-      name: "resolveRelativeColor",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  const originColor = extractOriginColor(value, opt);
-  if (originColor instanceof NullObject) {
-    setCache(cacheKey, null);
-    return originColor;
-  }
-  value = originColor;
-  if (format === VAL_SPEC) {
-    if (value.startsWith("rgba(")) {
-      value = value.replace(/^rgba\(/, "rgb(");
-    } else if (value.startsWith("hsla(")) {
-      value = value.replace(/^hsla\(/, "hsl(");
-    }
-    return value;
-  }
-  const tokens = (0, import_css_tokenizer2.tokenize)({ css: value });
-  const components = (0, import_css_parser_algorithms.parseComponentValue)(tokens);
-  const parsedComponents = (0, import_css_color_parser.color)(components);
-  if (!parsedComponents) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const {
-    alpha: alphaComponent,
-    channels: channelsComponent,
-    colorNotation,
-    syntaxFlags
-  } = parsedComponents;
-  let alpha;
-  if (Number.isNaN(Number(alphaComponent))) {
-    if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) {
-      alpha = NONE;
-    } else {
-      alpha = 0;
-    }
-  } else {
-    alpha = roundToPrecision(Number(alphaComponent), OCT2);
-  }
-  let v1;
-  let v2;
-  let v3;
-  [v1, v2, v3] = channelsComponent;
-  let resolvedValue;
-  if (REG_CS_CIE.test(colorNotation)) {
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, HEX2);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, HEX2);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, HEX2);
-    }
-    if (alpha === 1) {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  } else if (REG_CS_HSL.test(colorNotation)) {
-    if (Number.isNaN(v1)) {
-      v1 = 0;
-    }
-    if (Number.isNaN(v2)) {
-      v2 = 0;
-    }
-    if (Number.isNaN(v3)) {
-      v3 = 0;
-    }
-    let [r, g, b] = convertColorToRgb(
-      `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`
-    );
-    r = roundToPrecision(r / MAX_RGB2, DEC2);
-    g = roundToPrecision(g / MAX_RGB2, DEC2);
-    b = roundToPrecision(b / MAX_RGB2, DEC2);
-    if (alpha === 1) {
-      resolvedValue = `color(srgb ${r} ${g} ${b})`;
-    } else {
-      resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;
-    }
-  } else {
-    const cs = colorNotation === "rgb" ? "srgb" : colorNotation;
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, DEC2);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, DEC2);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, DEC2);
-    }
-    if (alpha === 1) {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-}
-
-// src/js/resolve.ts
-var NAMESPACE4 = "resolve";
-var RGB_TRANSPARENT = "rgba(0, 0, 0, 0)";
-var REG_FN_CALC2 = new RegExp(SYN_FN_CALC);
-var REG_FN_LIGHT_DARK = new RegExp(SYN_FN_LIGHT_DARK);
-var REG_FN_REL2 = new RegExp(SYN_FN_REL);
-var REG_FN_VAR3 = new RegExp(SYN_FN_VAR);
-var resolveColor = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const {
-    colorScheme = "normal",
-    currentColor = "",
-    format = VAL_COMP,
-    nullable = false
-  } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE4,
-      name: "resolve",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (REG_FN_VAR3.test(value)) {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-    const resolvedValue = resolveVar(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      switch (format) {
-        case "hex":
-        case "hexAlpha": {
-          setCache(cacheKey, resolvedValue);
-          return resolvedValue;
-        }
-        default: {
-          if (nullable) {
-            setCache(cacheKey, resolvedValue);
-            return resolvedValue;
-          }
-          const res2 = RGB_TRANSPARENT;
-          setCache(cacheKey, res2);
-          return res2;
-        }
-      }
-    } else {
-      value = resolvedValue;
-    }
-  }
-  if (opt.format !== format) {
-    opt.format = format;
-  }
-  value = value.toLowerCase();
-  if (REG_FN_LIGHT_DARK.test(value) && value.endsWith(")")) {
-    const colorParts = value.replace(REG_FN_LIGHT_DARK, "").replace(/\)$/, "");
-    const [light = "", dark = ""] = splitValue(colorParts, {
-      delimiter: ","
-    });
-    if (light && dark) {
-      if (format === VAL_SPEC) {
-        const lightColor = resolveColor(light, opt);
-        const darkColor = resolveColor(dark, opt);
-        let res3;
-        if (lightColor && darkColor) {
-          res3 = `light-dark(${lightColor}, ${darkColor})`;
-        } else {
-          res3 = "";
-        }
-        setCache(cacheKey, res3);
-        return res3;
-      }
-      let resolvedValue;
-      if (colorScheme === "dark") {
-        resolvedValue = resolveColor(dark, opt);
-      } else {
-        resolvedValue = resolveColor(light, opt);
-      }
-      let res2;
-      if (resolvedValue instanceof NullObject) {
-        if (nullable) {
-          res2 = resolvedValue;
-        } else {
-          res2 = RGB_TRANSPARENT;
-        }
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    switch (format) {
-      case VAL_SPEC: {
-        setCache(cacheKey, "");
-        return "";
-      }
-      case "hex":
-      case "hexAlpha": {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      case VAL_COMP:
-      default: {
-        const res2 = RGB_TRANSPARENT;
-        setCache(cacheKey, res2);
-        return res2;
-      }
-    }
-  }
-  if (REG_FN_REL2.test(value)) {
-    const resolvedValue = resolveRelativeColor(value, opt);
-    if (format === VAL_COMP) {
-      let res2;
-      if (resolvedValue instanceof NullObject) {
-        if (nullable) {
-          res2 = resolvedValue;
-        } else {
-          res2 = RGB_TRANSPARENT;
-        }
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (format === VAL_SPEC) {
-      let res2 = "";
-      if (resolvedValue instanceof NullObject) {
-        res2 = "";
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (resolvedValue instanceof NullObject) {
-      value = "";
-    } else {
-      value = resolvedValue;
-    }
-  }
-  if (REG_FN_CALC2.test(value)) {
-    value = cssCalc(value, opt);
-  }
-  let cs = "";
-  let r = NaN;
-  let g = NaN;
-  let b = NaN;
-  let alpha = NaN;
-  if (value === "transparent") {
-    switch (format) {
-      case VAL_SPEC: {
-        setCache(cacheKey, value);
-        return value;
-      }
-      case "hex": {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      case "hexAlpha": {
-        const res2 = "#00000000";
-        setCache(cacheKey, res2);
-        return res2;
-      }
-      case VAL_COMP:
-      default: {
-        const res2 = RGB_TRANSPARENT;
-        setCache(cacheKey, res2);
-        return res2;
-      }
-    }
-  } else if (value === "currentcolor") {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-    if (currentColor) {
-      let resolvedValue;
-      if (currentColor.startsWith(FN_MIX)) {
-        resolvedValue = resolveColorMix(currentColor, opt);
-      } else if (currentColor.startsWith(FN_COLOR)) {
-        resolvedValue = resolveColorFunc(currentColor, opt);
-      } else {
-        resolvedValue = resolveColorValue(currentColor, opt);
-      }
-      if (resolvedValue instanceof NullObject) {
-        setCache(cacheKey, resolvedValue);
-        return resolvedValue;
-      }
-      [cs, r, g, b, alpha] = resolvedValue;
-    } else if (format === VAL_COMP) {
-      const res2 = RGB_TRANSPARENT;
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (format === VAL_SPEC) {
-    if (value.startsWith(FN_MIX)) {
-      const res2 = resolveColorMix(value, opt);
-      setCache(cacheKey, res2);
-      return res2;
-    } else if (value.startsWith(FN_COLOR)) {
-      const [scs, rr, gg, bb, aa] = resolveColorFunc(
-        value,
-        opt
-      );
-      let res2 = "";
-      if (aa === 1) {
-        res2 = `color(${scs} ${rr} ${gg} ${bb})`;
-      } else {
-        res2 = `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    } else {
-      const rgb = resolveColorValue(value, opt);
-      if (isString(rgb)) {
-        setCache(cacheKey, rgb);
-        return rgb;
-      }
-      const [scs, rr, gg, bb, aa] = rgb;
-      let res2 = "";
-      if (scs === "rgb") {
-        if (aa === 1) {
-          res2 = `${scs}(${rr}, ${gg}, ${bb})`;
-        } else {
-          res2 = `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;
-        }
-      } else if (aa === 1) {
-        res2 = `${scs}(${rr} ${gg} ${bb})`;
-      } else {
-        res2 = `${scs}(${rr} ${gg} ${bb} / ${aa})`;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (value.startsWith(FN_MIX)) {
-    if (/currentcolor/.test(value)) {
-      if (currentColor) {
-        value = value.replace(/currentcolor/g, currentColor);
-      }
-    }
-    if (/transparent/.test(value)) {
-      value = value.replace(/transparent/g, RGB_TRANSPARENT);
-    }
-    const resolvedValue = resolveColorMix(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  } else if (value.startsWith(FN_COLOR)) {
-    const resolvedValue = resolveColorFunc(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  } else if (value) {
-    const resolvedValue = resolveColorValue(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  }
-  let res = "";
-  switch (format) {
-    case "hex": {
-      if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(alpha) || alpha === 0) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      res = convertRgbToHex([r, g, b, 1]);
-      break;
-    }
-    case "hexAlpha": {
-      if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(alpha)) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      res = convertRgbToHex([r, g, b, alpha]);
-      break;
-    }
-    case VAL_COMP:
-    default: {
-      switch (cs) {
-        case "rgb": {
-          if (alpha === 1) {
-            res = `${cs}(${r}, ${g}, ${b})`;
-          } else {
-            res = `${cs}a(${r}, ${g}, ${b}, ${alpha})`;
-          }
-          break;
-        }
-        case "lab":
-        case "lch":
-        case "oklab":
-        case "oklch": {
-          if (alpha === 1) {
-            res = `${cs}(${r} ${g} ${b})`;
-          } else {
-            res = `${cs}(${r} ${g} ${b} / ${alpha})`;
-          }
-          break;
-        }
-        // color()
-        default: {
-          if (alpha === 1) {
-            res = `color(${cs} ${r} ${g} ${b})`;
-          } else {
-            res = `color(${cs} ${r} ${g} ${b} / ${alpha})`;
-          }
-        }
-      }
-    }
-  }
-  setCache(cacheKey, res);
-  return res;
-};
-var resolve = (value, opt = {}) => {
-  opt.nullable = false;
-  const resolvedValue = resolveColor(value, opt);
-  if (resolvedValue instanceof NullObject) {
-    return null;
-  }
-  return resolvedValue;
-};
-
-// src/js/util.ts
-var {
-  CloseParen: PAREN_CLOSE3,
-  Comma: COMMA,
-  Comment: COMMENT3,
-  Delim: DELIM2,
-  EOF: EOF3,
-  Function: FUNC2,
-  Ident: IDENT3,
-  OpenParen: PAREN_OPEN2,
-  Whitespace: W_SPACE3
-} = import_css_tokenizer3.TokenType;
-var NAMESPACE5 = "util";
-var DEC3 = 10;
-var HEX3 = 16;
-var DEG2 = 360;
-var DEG_HALF2 = 180;
-var REG_COLOR2 = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
-var REG_FN_COLOR2 = /^(?:(?:ok)?l(?:ab|ch)|color(?:-mix)?|hsla?|hwb|rgba?|var)\(/;
-var REG_MIX2 = new RegExp(SYN_MIX);
-var splitValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { delimiter = " ", preserveComment = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE5,
-      name: "splitValue",
-      value
-    },
-    {
-      delimiter,
-      preserveComment
-    }
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  let regDelimiter;
-  if (delimiter === ",") {
-    regDelimiter = /^,$/;
-  } else if (delimiter === "/") {
-    regDelimiter = /^\/$/;
-  } else {
-    regDelimiter = /^\s+$/;
-  }
-  const tokens = (0, import_css_tokenizer3.tokenize)({ css: value });
-  let nest = 0;
-  let str = "";
-  const res = [];
-  while (tokens.length) {
-    const [type, value2] = tokens.shift();
-    switch (type) {
-      case COMMA: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            res.push(str.trim());
-            str = "";
-          } else {
-            str += value2;
-          }
-        } else {
-          str += value2;
-        }
-        break;
-      }
-      case DELIM2: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            res.push(str.trim());
-            str = "";
-          } else {
-            str += value2;
-          }
-        } else {
-          str += value2;
-        }
-        break;
-      }
-      case COMMENT3: {
-        if (preserveComment && (delimiter === "," || delimiter === "/")) {
-          str += value2;
-        }
-        break;
-      }
-      case FUNC2:
-      case PAREN_OPEN2: {
-        str += value2;
-        nest++;
-        break;
-      }
-      case PAREN_CLOSE3: {
-        str += value2;
-        nest--;
-        break;
-      }
-      case W_SPACE3: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            if (str) {
-              res.push(str.trim());
-              str = "";
-            }
-          } else {
-            str += " ";
-          }
-        } else if (!str.endsWith(" ")) {
-          str += " ";
-        }
-        break;
-      }
-      default: {
-        if (type === EOF3) {
-          res.push(str.trim());
-          str = "";
-        } else {
-          str += value2;
-        }
-      }
-    }
-  }
-  setCache(cacheKey, res);
-  return res;
-};
-var extractDashedIdent = (value) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey({
-    namespace: NAMESPACE5,
-    name: "extractDashedIdent",
-    value
-  });
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const tokens = (0, import_css_tokenizer3.tokenize)({ css: value });
-  const items = /* @__PURE__ */ new Set();
-  while (tokens.length) {
-    const [type, value2] = tokens.shift();
-    if (type === IDENT3 && value2.startsWith("--")) {
-      items.add(value2);
-    }
-  }
-  const res = [...items];
-  setCache(cacheKey, res);
-  return res;
-};
-var isColor = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (value && isString(value)) {
-      if (/^[a-z]+$/.test(value)) {
-        if (/^(?:currentcolor|transparent)$/.test(value) || Object.hasOwn(NAMED_COLORS, value)) {
-          return true;
-        }
-      } else if (REG_COLOR2.test(value) || REG_MIX2.test(value)) {
-        return true;
-      } else if (REG_FN_COLOR2.test(value)) {
-        opt.nullable = true;
-        if (!opt.format) {
-          opt.format = VAL_SPEC;
-        }
-        const resolvedValue = resolveColor(value, opt);
-        if (resolvedValue) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-var valueToJsonString = (value, func = false) => {
-  if (typeof value === "undefined") {
-    return "";
-  }
-  const res = JSON.stringify(value, (_key, val) => {
-    let replacedValue;
-    if (typeof val === "undefined") {
-      replacedValue = null;
-    } else if (typeof val === "function") {
-      if (func) {
-        replacedValue = val.toString().replace(/\s/g, "").substring(0, HEX3);
-      } else {
-        replacedValue = val.name;
-      }
-    } else if (val instanceof Map || val instanceof Set) {
-      replacedValue = [...val];
-    } else if (typeof val === "bigint") {
-      replacedValue = val.toString();
-    } else {
-      replacedValue = val;
-    }
-    return replacedValue;
-  });
-  return res;
-};
-var roundToPrecision = (value, bit = 0) => {
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`${value} is not a finite number.`);
-  }
-  if (!Number.isFinite(bit)) {
-    throw new TypeError(`${bit} is not a finite number.`);
-  } else if (bit < 0 || bit > HEX3) {
-    throw new RangeError(`${bit} is not between 0 and ${HEX3}.`);
-  }
-  if (bit === 0) {
-    return Math.round(value);
-  }
-  let val;
-  if (bit === HEX3) {
-    val = value.toPrecision(6);
-  } else if (bit < DEC3) {
-    val = value.toPrecision(4);
-  } else {
-    val = value.toPrecision(5);
-  }
-  return parseFloat(val);
-};
-var interpolateHue = (hueA, hueB, arc = "shorter") => {
-  if (!Number.isFinite(hueA)) {
-    throw new TypeError(`${hueA} is not a finite number.`);
-  }
-  if (!Number.isFinite(hueB)) {
-    throw new TypeError(`${hueB} is not a finite number.`);
-  }
-  switch (arc) {
-    case "decreasing": {
-      if (hueB > hueA) {
-        hueA += DEG2;
-      }
-      break;
-    }
-    case "increasing": {
-      if (hueB < hueA) {
-        hueB += DEG2;
-      }
-      break;
-    }
-    case "longer": {
-      if (hueB > hueA && hueB < hueA + DEG_HALF2) {
-        hueA += DEG2;
-      } else if (hueB > hueA + DEG_HALF2 * -1 && hueB <= hueA) {
-        hueB += DEG2;
-      }
-      break;
-    }
-    case "shorter":
-    default: {
-      if (hueB > hueA + DEG_HALF2) {
-        hueA += DEG2;
-      } else if (hueB < hueA + DEG_HALF2 * -1) {
-        hueB += DEG2;
-      }
-    }
-  }
-  return [hueA, hueB];
-};
-var absoluteFontSize = /* @__PURE__ */ new Map([
-  ["xx-small", 3 / 5],
-  ["x-small", 3 / 4],
-  ["small", 8 / 9],
-  ["medium", 1],
-  ["large", 6 / 5],
-  ["x-large", 3 / 2],
-  ["xx-large", 2],
-  ["xxx-large", 3]
-]);
-var relativeFontSize = /* @__PURE__ */ new Map([
-  ["smaller", 1 / 1.2],
-  ["larger", 1.2]
-]);
-var absoluteLength = /* @__PURE__ */ new Map([
-  ["cm", 96 / 2.54],
-  ["mm", 96 / 2.54 / 10],
-  ["q", 96 / 2.54 / 40],
-  ["in", 96],
-  ["pc", 96 / 6],
-  ["pt", 96 / 72],
-  ["px", 1]
-]);
-var relativeLength = /* @__PURE__ */ new Map([
-  ["rcap", 1],
-  ["rch", 0.5],
-  ["rem", 1],
-  ["rex", 0.5],
-  ["ric", 1],
-  ["rlh", 1.2]
-]);
-var resolveLengthInPixels = (value, unit, opt = {}) => {
-  const { dimension = {} } = opt;
-  const { callback, em, rem, vh, vw } = dimension;
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (absoluteFontSize.has(value)) {
-      return Number(absoluteFontSize.get(value)) * rem;
-    } else if (relativeFontSize.has(value)) {
-      return Number(relativeFontSize.get(value)) * em;
-    }
-    return Number.NaN;
-  } else if (Number.isFinite(value) && unit) {
-    if (Object.hasOwn(dimension, unit)) {
-      return value * Number(dimension[unit]);
-    } else if (typeof callback === "function") {
-      return value * callback(unit);
-    } else if (absoluteLength.has(unit)) {
-      return value * Number(absoluteLength.get(unit));
-    } else if (relativeLength.has(unit)) {
-      return value * Number(relativeLength.get(unit)) * rem;
-    } else if (relativeLength.has(`r${unit}`)) {
-      return value * Number(relativeLength.get(`r${unit}`)) * em;
-    } else {
-      switch (unit) {
-        case "vb":
-        case "vi": {
-          return value * vw;
-        }
-        case "vmax": {
-          if (vh > vw) {
-            return value * vh;
-          }
-          return value * vw;
-        }
-        case "vmin": {
-          if (vh < vw) {
-            return value * vh;
-          }
-          return value * vw;
-        }
-        default: {
-          return Number.NaN;
-        }
-      }
-    }
-  }
-  return Number.NaN;
-};
-
-// src/js/cache.ts
-var MAX_CACHE = 4096;
-var CacheItem = class {
-  /* private */
-  #isNull;
-  #item;
-  /**
-   * constructor
-   */
-  constructor(item, isNull = false) {
-    this.#item = item;
-    this.#isNull = !!isNull;
-  }
-  get item() {
-    return this.#item;
-  }
-  get isNull() {
-    return this.#isNull;
-  }
-};
-var NullObject = class extends CacheItem {
-  /**
-   * constructor
-   */
-  constructor() {
-    super(/* @__PURE__ */ Symbol("null"), true);
-  }
-};
-var lruCache = new import_lru_cache.LRUCache({
-  max: MAX_CACHE
-});
-var setCache = (key, value) => {
-  if (key) {
-    if (value === null) {
-      lruCache.set(key, new NullObject());
-    } else if (value instanceof CacheItem) {
-      lruCache.set(key, value);
-    } else {
-      lruCache.set(key, new CacheItem(value));
-    }
-  }
-};
-var getCache = (key) => {
-  if (key && lruCache.has(key)) {
-    const item = lruCache.get(key);
-    if (item instanceof CacheItem) {
-      return item;
-    }
-    lruCache.delete(key);
-    return false;
-  }
-  return false;
-};
-var createCacheKey = (keyData, opt = {}) => {
-  const { customProperty = {}, dimension = {} } = opt;
-  let cacheKey = "";
-  if (keyData && Object.keys(keyData).length && typeof customProperty.callback !== "function" && typeof dimension.callback !== "function") {
-    keyData.opt = valueToJsonString(opt);
-    cacheKey = valueToJsonString(keyData);
-  }
-  return cacheKey;
-};
-
-// src/js/css-calc.ts
-var {
-  CloseParen: PAREN_CLOSE4,
-  Comment: COMMENT4,
-  Dimension: DIM2,
-  EOF: EOF4,
-  Function: FUNC3,
-  OpenParen: PAREN_OPEN3,
-  Whitespace: W_SPACE4
-} = import_css_tokenizer4.TokenType;
-var NAMESPACE6 = "css-calc";
-var TRIA2 = 3;
-var HEX4 = 16;
-var MAX_PCT3 = 100;
-var REG_FN_CALC3 = new RegExp(SYN_FN_CALC);
-var REG_FN_CALC_NUM = new RegExp(`^calc\\((${NUM})\\)$`);
-var REG_FN_MATH_START2 = new RegExp(SYN_FN_MATH_START);
-var REG_FN_VAR4 = new RegExp(SYN_FN_VAR);
-var REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);
-var REG_OPERATOR = /\s[*+/-]\s/;
-var REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);
-var REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);
-var REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);
-var Calculator = class {
-  /* private */
-  // number
-  #hasNum;
-  #numSum;
-  #numMul;
-  // percentage
-  #hasPct;
-  #pctSum;
-  #pctMul;
-  // dimension
-  #hasDim;
-  #dimSum;
-  #dimSub;
-  #dimMul;
-  #dimDiv;
-  // et cetra
-  #hasEtc;
-  #etcSum;
-  #etcSub;
-  #etcMul;
-  #etcDiv;
-  /**
-   * constructor
-   */
-  constructor() {
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-  get hasNum() {
-    return this.#hasNum;
-  }
-  set hasNum(value) {
-    this.#hasNum = !!value;
-  }
-  get numSum() {
-    return this.#numSum;
-  }
-  get numMul() {
-    return this.#numMul;
-  }
-  get hasPct() {
-    return this.#hasPct;
-  }
-  set hasPct(value) {
-    this.#hasPct = !!value;
-  }
-  get pctSum() {
-    return this.#pctSum;
-  }
-  get pctMul() {
-    return this.#pctMul;
-  }
-  get hasDim() {
-    return this.#hasDim;
-  }
-  set hasDim(value) {
-    this.#hasDim = !!value;
-  }
-  get dimSum() {
-    return this.#dimSum;
-  }
-  get dimSub() {
-    return this.#dimSub;
-  }
-  get dimMul() {
-    return this.#dimMul;
-  }
-  get dimDiv() {
-    return this.#dimDiv;
-  }
-  get hasEtc() {
-    return this.#hasEtc;
-  }
-  set hasEtc(value) {
-    this.#hasEtc = !!value;
-  }
-  get etcSum() {
-    return this.#etcSum;
-  }
-  get etcSub() {
-    return this.#etcSub;
-  }
-  get etcMul() {
-    return this.#etcMul;
-  }
-  get etcDiv() {
-    return this.#etcDiv;
-  }
-  /**
-   * clear values
-   * @returns void
-   */
-  clear() {
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-  /**
-   * sort values
-   * @param values - values
-   * @returns sorted values
-   */
-  sort(values = []) {
-    const arr = [...values];
-    if (arr.length > 1) {
-      arr.sort((a, b) => {
-        let res;
-        if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {
-          const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT);
-          const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT);
-          if (unitA === unitB) {
-            if (Number(valA) === Number(valB)) {
-              res = 0;
-            } else if (Number(valA) > Number(valB)) {
-              res = 1;
-            } else {
-              res = -1;
-            }
-          } else if (unitA > unitB) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        } else {
-          if (a === b) {
-            res = 0;
-          } else if (a > b) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        }
-        return res;
-      });
-    }
-    return arr;
-  }
-  /**
-   * multiply values
-   * @returns resolved value
-   */
-  multiply() {
-    const value = [];
-    let num;
-    if (this.#hasNum) {
-      num = 1;
-      for (const i of this.#numMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {
-        if (Number.isFinite(num)) {
-          num = roundToPrecision(num, HEX4);
-        }
-        value.push(num);
-      }
-    }
-    if (this.#hasPct) {
-      if (typeof num !== "number") {
-        num = 1;
-      }
-      for (const i of this.#pctMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${roundToPrecision(num, HEX4)}%`;
-      }
-      if (!this.#hasDim && !this.hasEtc) {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim = "";
-      let mul = "";
-      let div = "";
-      if (this.#dimMul.length) {
-        if (this.#dimMul.length === 1) {
-          [mul] = this.#dimMul;
-        } else {
-          mul = `${this.sort(this.#dimMul).join(" * ")}`;
-        }
-      }
-      if (this.#dimDiv.length) {
-        if (this.#dimDiv.length === 1) {
-          [div] = this.#dimDiv;
-        } else {
-          div = `${this.sort(this.#dimDiv).join(" * ")}`;
-        }
-      }
-      if (Number.isFinite(num)) {
-        if (mul) {
-          if (div) {
-            if (div.includes("*")) {
-              dim = (0, import_css_calc4.calc)(`calc(${num} * ${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = (0, import_css_calc4.calc)(`calc(${num} * ${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = (0, import_css_calc4.calc)(`calc(${num} * ${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else if (div.includes("*")) {
-          dim = (0, import_css_calc4.calc)(`calc(${num} / (${div}))`, {
-            toCanonicalUnits: true
-          });
-        } else {
-          dim = (0, import_css_calc4.calc)(`calc(${num} / ${div})`, {
-            toCanonicalUnits: true
-          });
-        }
-        value.push(dim.replace(/^calc/, ""));
-      } else {
-        if (!value.length && num !== void 0) {
-          value.push(num);
-        }
-        if (mul) {
-          if (div) {
-            if (div.includes("*")) {
-              dim = (0, import_css_calc4.calc)(`calc(${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = (0, import_css_calc4.calc)(`calc(${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = (0, import_css_calc4.calc)(`calc(${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-          if (value.length) {
-            value.push("*", dim.replace(/^calc/, ""));
-          } else {
-            value.push(dim.replace(/^calc/, ""));
-          }
-        } else {
-          dim = (0, import_css_calc4.calc)(`calc(${div})`, {
-            toCanonicalUnits: true
-          });
-          if (value.length) {
-            value.push("/", dim.replace(/^calc/, ""));
-          } else {
-            value.push("1", "/", dim.replace(/^calc/, ""));
-          }
-        }
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcMul.length) {
-        if (!value.length && num !== void 0) {
-          value.push(num);
-        }
-        const mul = this.sort(this.#etcMul).join(" * ");
-        if (value.length) {
-          value.push(`* ${mul}`);
-        } else {
-          value.push(`${mul}`);
-        }
-      }
-      if (this.#etcDiv.length) {
-        const div = this.sort(this.#etcDiv).join(" * ");
-        if (div.includes("*")) {
-          if (value.length) {
-            value.push(`/ (${div})`);
-          } else {
-            value.push(`1 / (${div})`);
-          }
-        } else if (value.length) {
-          value.push(`/ ${div}`);
-        } else {
-          value.push(`1 / ${div}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(" ");
-    }
-    return "";
-  }
-  /**
-   * sum values
-   * @returns resolved value
-   */
-  sum() {
-    const value = [];
-    if (this.#hasNum) {
-      let num = 0;
-      for (const i of this.#numSum) {
-        num += i;
-        if (!Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      value.push(num);
-    }
-    if (this.#hasPct) {
-      let num = 0;
-      for (const i of this.#pctSum) {
-        num += i;
-        if (!Number.isFinite(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${num}%`;
-      }
-      if (value.length) {
-        value.push(`+ ${num}`);
-      } else {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim, sum, sub;
-      if (this.#dimSum.length) {
-        sum = this.sort(this.#dimSum).join(" + ");
-      }
-      if (this.#dimSub.length) {
-        sub = this.sort(this.#dimSub).join(" + ");
-      }
-      if (sum) {
-        if (sub) {
-          if (sub.includes("-")) {
-            dim = (0, import_css_calc4.calc)(`calc(${sum} - (${sub}))`, {
-              toCanonicalUnits: true
-            });
-          } else {
-            dim = (0, import_css_calc4.calc)(`calc(${sum} - ${sub})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else {
-          dim = (0, import_css_calc4.calc)(`calc(${sum})`, {
-            toCanonicalUnits: true
-          });
-        }
-      } else {
-        dim = (0, import_css_calc4.calc)(`calc(-1 * (${sub}))`, {
-          toCanonicalUnits: true
-        });
-      }
-      if (value.length) {
-        value.push("+", dim.replace(/^calc/, ""));
-      } else {
-        value.push(dim.replace(/^calc/, ""));
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcSum.length) {
-        const sum = this.sort(this.#etcSum).map((item) => {
-          let res;
-          if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) {
-            res = `(${item})`;
-          } else {
-            res = item;
-          }
-          return res;
-        }).join(" + ");
-        if (value.length) {
-          if (this.#etcSum.length > 1) {
-            value.push(`+ (${sum})`);
-          } else {
-            value.push(`+ ${sum}`);
-          }
-        } else {
-          value.push(`${sum}`);
-        }
-      }
-      if (this.#etcSub.length) {
-        const sub = this.sort(this.#etcSub).map((item) => {
-          let res;
-          if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) {
-            res = `(${item})`;
-          } else {
-            res = item;
-          }
-          return res;
-        }).join(" + ");
-        if (value.length) {
-          if (this.#etcSub.length > 1) {
-            value.push(`- (${sub})`);
-          } else {
-            value.push(`- ${sub}`);
-          }
-        } else if (this.#etcSub.length > 1) {
-          value.push(`-1 * (${sub})`);
-        } else {
-          value.push(`-1 * ${sub}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(" ");
-    }
-    return "";
-  }
-};
-var sortCalcValues = (values = [], finalize = false) => {
-  if (values.length < TRIA2) {
-    throw new Error(`Unexpected array length ${values.length}.`);
-  }
-  const start = values.shift();
-  if (!isString(start) || !start.endsWith("(")) {
-    throw new Error(`Unexpected token ${start}.`);
-  }
-  const end = values.pop();
-  if (end !== ")") {
-    throw new Error(`Unexpected token ${end}.`);
-  }
-  if (values.length === 1) {
-    const [value] = values;
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    return `${start}${value}${end}`;
-  }
-  const sortedValues = [];
-  const cal = new Calculator();
-  let operator = "";
-  const l = values.length;
-  for (let i = 0; i < l; i++) {
-    const value = values[i];
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    if (value === "*" || value === "/") {
-      operator = value;
-    } else if (value === "+" || value === "-") {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue, value);
-      }
-      cal.clear();
-      operator = "";
-    } else {
-      const numValue = Number(value);
-      const strValue = `${value}`;
-      switch (operator) {
-        case "/": {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(1 / numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT);
-            cal.hasPct = true;
-            cal.pctMul.push(MAX_PCT3 * MAX_PCT3 / Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimDiv.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcDiv.push(strValue);
-          }
-          break;
-        }
-        case "*":
-        default: {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT);
-            cal.hasPct = true;
-            cal.pctMul.push(Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimMul.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcMul.push(strValue);
-          }
-        }
-      }
-    }
-    if (i === l - 1) {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue);
-      }
-      cal.clear();
-      operator = "";
-    }
-  }
-  let resolvedValue = "";
-  if (finalize && (sortedValues.includes("+") || sortedValues.includes("-"))) {
-    const finalizedValues = [];
-    cal.clear();
-    operator = "";
-    const l2 = sortedValues.length;
-    for (let i = 0; i < l2; i++) {
-      const value = sortedValues[i];
-      if (isStringOrNumber(value)) {
-        if (value === "+" || value === "-") {
-          operator = value;
-        } else {
-          const numValue = Number(value);
-          const strValue = `${value}`;
-          switch (operator) {
-            case "-": {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(-1 * numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT);
-                cal.hasPct = true;
-                cal.pctSum.push(-1 * Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSub.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSub.push(strValue);
-              }
-              break;
-            }
-            case "+":
-            default: {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT);
-                cal.hasPct = true;
-                cal.pctSum.push(Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSum.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSum.push(strValue);
-              }
-            }
-          }
-        }
-      }
-      if (i === l2 - 1) {
-        const sortedValue = cal.sum();
-        if (sortedValue) {
-          finalizedValues.push(sortedValue);
-        }
-        cal.clear();
-        operator = "";
-      }
-    }
-    resolvedValue = finalizedValues.join(" ").replace(/\+\s-/g, "- ");
-  } else {
-    resolvedValue = sortedValues.join(" ").replace(/\+\s-/g, "- ");
-  }
-  if (resolvedValue.startsWith("(") && resolvedValue.endsWith(")") && resolvedValue.lastIndexOf("(") === 0 && resolvedValue.indexOf(")") === resolvedValue.length - 1) {
-    resolvedValue = resolvedValue.replace(/^\(/, "").replace(/\)$/, "");
-  }
-  return `${start}${resolvedValue}${end}`;
-};
-var serializeCalc = (value, opt = {}) => {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR_START.test(value) || format !== VAL_SPEC) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE6,
-      name: "serializeCalc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const items = (0, import_css_tokenizer4.tokenize)({ css: value }).map((token) => {
-    const [type, value2] = token;
-    let res = "";
-    if (type !== W_SPACE4 && type !== COMMENT4) {
-      res = value2;
-    }
-    return res;
-  }).filter((v) => v);
-  let startIndex = items.findLastIndex((item) => /\($/.test(item));
-  while (startIndex) {
-    const endIndex = items.findIndex((item, index) => {
-      return item === ")" && index > startIndex;
-    });
-    const slicedValues = items.slice(startIndex, endIndex + 1);
-    let serializedValue = sortCalcValues(slicedValues);
-    if (REG_FN_VAR_START.test(serializedValue)) {
-      serializedValue = (0, import_css_calc4.calc)(serializedValue, {
-        toCanonicalUnits: true
-      });
-    }
-    items.splice(startIndex, endIndex - startIndex + 1, serializedValue);
-    startIndex = items.findLastIndex((item) => /\($/.test(item));
-  }
-  const serializedCalc = sortCalcValues(items, true);
-  setCache(cacheKey, serializedCalc);
-  return serializedCalc;
-};
-var resolveDimension = (token, opt = {}) => {
-  if (!Array.isArray(token)) {
-    throw new TypeError(`${token} is not an array.`);
-  }
-  const [, , , , detail = {}] = token;
-  const { unit, value } = detail;
-  if (unit === "px") {
-    return `${value}${unit}`;
-  }
-  const pixelValue = resolveLengthInPixels(Number(value), unit, opt);
-  if (Number.isFinite(pixelValue)) {
-    return `${roundToPrecision(pixelValue, HEX4)}px`;
-  }
-  return new NullObject();
-};
-var parseTokens2 = (tokens, opt = {}) => {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { format = "" } = opt;
-  const mathFunc = /* @__PURE__ */ new Set();
-  let nest = 0;
-  const res = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type = "", value = ""] = token;
-    switch (type) {
-      case DIM2: {
-        if (format === VAL_SPEC && !mathFunc.has(nest)) {
-          res.push(value);
-        } else {
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            res.push(resolvedValue);
-          } else {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      case FUNC3:
-      case PAREN_OPEN3: {
-        res.push(value);
-        nest++;
-        if (REG_FN_MATH_START2.test(value)) {
-          mathFunc.add(nest);
-        }
-        break;
-      }
-      case PAREN_CLOSE4: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (lastValue === " ") {
-            res.splice(-1, 1, value);
-          } else {
-            res.push(value);
-          }
-        } else {
-          res.push(value);
-        }
-        if (mathFunc.has(nest)) {
-          mathFunc.delete(nest);
-        }
-        nest--;
-        break;
-      }
-      case W_SPACE4: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      default: {
-        if (type !== COMMENT4 && type !== EOF4) {
-          res.push(value);
-        }
-      }
-    }
-  }
-  return res;
-};
-var cssCalc = (value, opt = {}) => {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR4.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      } else {
-        const resolvedValue2 = resolveVar(value, opt);
-        if (isString(resolvedValue2)) {
-          return resolvedValue2;
-        } else {
-          return "";
-        }
-      }
-    } else if (!REG_FN_CALC3.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE6,
-      name: "cssCalc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const tokens = (0, import_css_tokenizer4.tokenize)({ css: value });
-  const values = parseTokens2(tokens, opt);
-  let resolvedValue = (0, import_css_calc4.calc)(values.join(""), {
-    toCanonicalUnits: true
-  });
-  if (REG_FN_VAR_START.test(value)) {
-    if (REG_TYPE_DIM_PCT.test(resolvedValue)) {
-      const [, val, unit] = resolvedValue.match(
-        REG_TYPE_DIM_PCT
-      );
-      resolvedValue = `${roundToPrecision(Number(val), HEX4)}${unit}`;
-    }
-    if (resolvedValue && !REG_FN_VAR_START.test(resolvedValue) && format === VAL_SPEC) {
-      resolvedValue = `calc(${resolvedValue})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    if (/\s[-+*/]\s/.test(resolvedValue) && !resolvedValue.includes("NaN")) {
-      resolvedValue = serializeCalc(resolvedValue, opt);
-    } else if (REG_FN_CALC_NUM.test(resolvedValue)) {
-      const [, val] = resolvedValue.match(REG_FN_CALC_NUM);
-      resolvedValue = `calc(${roundToPrecision(Number(val), HEX4)})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-};
-
-// src/js/css-gradient.ts
-var NAMESPACE7 = "css-gradient";
-var DIM_ANGLE = `${NUM}(?:${ANGLE})`;
-var DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;
-var DIM_LEN = `${NUM}(?:${LENGTH})|0`;
-var DIM_LEN_PCT = `${DIM_LEN}|${PCT}`;
-var DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;
-var DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;
-var CTR = "center";
-var L_R = "left|right";
-var T_B = "top|bottom";
-var S_E = "start|end";
-var AXIS_X = `${L_R}|x-(?:${S_E})`;
-var AXIS_Y = `${T_B}|y-(?:${S_E})`;
-var BLOCK = `block-(?:${S_E})`;
-var INLINE = `inline-(?:${S_E})`;
-var POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;
-var POS_2 = [
-  `(?:${CTR}|${AXIS_X})\\s+(?:${CTR}|${AXIS_Y})`,
-  `(?:${CTR}|${AXIS_Y})\\s+(?:${CTR}|${AXIS_X})`,
-  `(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,
-  `(?:${CTR}|${BLOCK})\\s+(?:${CTR}|${INLINE})`,
-  `(?:${CTR}|${INLINE})\\s+(?:${CTR}|${BLOCK})`,
-  `(?:${CTR}|${S_E})\\s+(?:${CTR}|${S_E})`
-].join("|");
-var POS_4 = [
-  `(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})\\s+(?:${INLINE})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${INLINE})\\s+(?:${DIM_LEN_PCT})\\s+(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${S_E})\\s+(?:${DIM_LEN_PCT})\\s+(?:${S_E})\\s+(?:${DIM_LEN_PCT})`
-].join("|");
-var RAD_EXTENT = "(?:clos|farth)est-(?:corner|side)";
-var RAD_SIZE = [
-  `${RAD_EXTENT}(?:\\s+${RAD_EXTENT})?`,
-  `${DIM_LEN_POSI}`,
-  `(?:${DIM_LEN_PCT_POSI})\\s+(?:${DIM_LEN_PCT_POSI})`
-].join("|");
-var RAD_SHAPE = "circle|ellipse";
-var FROM_ANGLE = `from\\s+${DIM_ANGLE}`;
-var AT_POSITION = `at\\s+(?:${POS_1}|${POS_2}|${POS_4})`;
-var TO_SIDE_CORNER = `to\\s+(?:(?:${L_R})(?:\\s(?:${T_B}))?|(?:${T_B})(?:\\s(?:${L_R}))?)`;
-var IN_COLOR_SPACE = `in\\s+(?:${CS_RECT}|${CS_HUE})`;
-var REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\(/;
-var REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\(/;
-var getGradientType = (value) => {
-  if (isString(value)) {
-    value = value.trim();
-    if (REG_GRAD.test(value)) {
-      const [, type] = value.match(REG_GRAD_CAPT);
-      return type;
-    }
-  }
-  return "";
-};
-var validateGradientLine = (value, type) => {
-  if (isString(value) && isString(type)) {
-    value = value.trim();
-    type = type.trim();
-    let lineSyntax = "";
-    const defaultValues = [];
-    if (/^(?:repeating-)?linear-gradient$/.test(type)) {
-      lineSyntax = [
-        `(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`
-      ].join("|");
-      defaultValues.push(/to\s+bottom/);
-    } else if (/^(?:repeating-)?radial-gradient$/.test(type)) {
-      lineSyntax = [
-        `(?:${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `(?:${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${AT_POSITION})?`
-      ].join("|");
-      defaultValues.push(/ellipse/, /farthest-corner/, /at\s+center/);
-    } else if (/^(?:repeating-)?conic-gradient$/.test(type)) {
-      lineSyntax = [
-        `${FROM_ANGLE}(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${FROM_ANGLE})?(?:\\s+${AT_POSITION})?`
-      ].join("|");
-      defaultValues.push(/at\s+center/);
-    }
-    if (lineSyntax) {
-      const reg = new RegExp(`^(?:${lineSyntax})$`);
-      const valid = reg.test(value);
-      if (valid) {
-        let line = value;
-        for (const defaultValue of defaultValues) {
-          line = line.replace(defaultValue, "");
-        }
-        line = line.replace(/\s{2,}/g, " ").trim();
-        return {
-          line,
-          valid
-        };
-      }
-      return {
-        valid,
-        line: value
-      };
-    }
-  }
-  return {
-    line: value,
-    valid: false
-  };
-};
-var validateColorStopList = (list, type, opt = {}) => {
-  if (Array.isArray(list) && list.length > 1) {
-    const dimension = /^(?:repeating-)?conic-gradient$/.test(type) ? DIM_ANGLE_PCT : DIM_LEN_PCT;
-    const regColorHint = new RegExp(`^(?:${dimension})$`);
-    const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-    const valueTypes = [];
-    const valueList = [];
-    for (const item of list) {
-      if (isString(item)) {
-        if (regColorHint.test(item)) {
-          valueTypes.push("hint");
-          valueList.push(item);
-        } else {
-          const itemColor = item.replace(regDimension, "");
-          if (isColor(itemColor, { format: VAL_SPEC })) {
-            const resolvedColor = resolveColor(itemColor, opt);
-            valueTypes.push("color");
-            valueList.push(item.replace(itemColor, resolvedColor));
-          } else {
-            return {
-              colorStops: list,
-              valid: false
-            };
-          }
-        }
-      }
-    }
-    const valid = /^color(?:,(?:hint,)?color)+$/.test(valueTypes.join(","));
-    return {
-      valid,
-      colorStops: valueList
-    };
-  }
-  return {
-    colorStops: list,
-    valid: false
-  };
-};
-var parseGradient = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-    const cacheKey = createCacheKey(
-      {
-        namespace: NAMESPACE7,
-        name: "parseGradient",
-        value
-      },
-      opt
-    );
-    const cachedResult = getCache(cacheKey);
-    if (cachedResult instanceof CacheItem) {
-      if (cachedResult.isNull) {
-        return null;
-      }
-      return cachedResult.item;
-    }
-    const type = getGradientType(value);
-    const gradValue = value.replace(REG_GRAD, "").replace(/\)$/, "");
-    if (type && gradValue) {
-      const [lineOrColorStop = "", ...itemList] = splitValue(gradValue, {
-        delimiter: ","
-      });
-      const dimension = /^(?:repeating-)?conic-gradient$/.test(type) ? DIM_ANGLE_PCT : DIM_LEN_PCT;
-      const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-      let colorStop = "";
-      if (regDimension.test(lineOrColorStop)) {
-        const itemColor = lineOrColorStop.replace(regDimension, "");
-        if (isColor(itemColor, { format: VAL_SPEC })) {
-          const resolvedColor = resolveColor(itemColor, opt);
-          colorStop = lineOrColorStop.replace(itemColor, resolvedColor);
-        }
-      } else if (isColor(lineOrColorStop, { format: VAL_SPEC })) {
-        colorStop = resolveColor(lineOrColorStop, opt);
-      }
-      if (colorStop) {
-        itemList.unshift(colorStop);
-        const { colorStops, valid } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (valid) {
-          const res = {
-            value,
-            type,
-            colorStopList: colorStops
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      } else if (itemList.length > 1) {
-        const { line: gradientLine, valid: validLine } = validateGradientLine(
-          lineOrColorStop,
-          type
-        );
-        const { colorStops, valid: validColorStops } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (validLine && validColorStops) {
-          const res = {
-            value,
-            type,
-            gradientLine,
-            colorStopList: colorStops
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      }
-    }
-    setCache(cacheKey, null);
-    return null;
-  }
-  return null;
-};
-var resolveGradient = (value, opt = {}) => {
-  const { format = VAL_COMP } = opt;
-  const gradient = parseGradient(value, opt);
-  if (gradient) {
-    const { type = "", gradientLine = "", colorStopList = [] } = gradient;
-    if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {
-      if (gradientLine) {
-        return `${type}(${gradientLine}, ${colorStopList.join(", ")})`;
-      }
-      return `${type}(${colorStopList.join(", ")})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    return "";
-  }
-  return "none";
-};
-var isGradient = (value, opt = {}) => {
-  const gradient = parseGradient(value, opt);
-  return gradient !== null;
-};
-
-// src/js/convert.ts
-var NAMESPACE8 = "convert";
-var REG_FN_CALC4 = new RegExp(SYN_FN_CALC);
-var REG_FN_REL3 = new RegExp(SYN_FN_REL);
-var REG_FN_VAR5 = new RegExp(SYN_FN_VAR);
-var preProcess = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-    if (!value) {
-      return new NullObject();
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "preProcess",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (REG_FN_VAR5.test(value)) {
-    const resolvedValue = resolveVar(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  if (REG_FN_REL3.test(value)) {
-    const resolvedValue = resolveRelativeColor(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  } else if (REG_FN_CALC4.test(value)) {
-    value = cssCalc(value, opt);
-  }
-  if (value.startsWith("color-mix")) {
-    const clonedOpt = structuredClone(opt);
-    clonedOpt.format = VAL_COMP;
-    clonedOpt.nullable = true;
-    const resolvedValue = resolveColor(value, clonedOpt);
-    setCache(cacheKey, resolvedValue);
-    return resolvedValue;
-  }
-  setCache(cacheKey, value);
-  return value;
-};
-var numberToHex = (value) => {
-  const hex = numberToHexString(value);
-  return hex;
-};
-var colorToHex = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return null;
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { alpha = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToHex",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return null;
-    }
-    return cachedResult.item;
-  }
-  let hex;
-  opt.nullable = true;
-  if (alpha) {
-    opt.format = "hexAlpha";
-    hex = resolveColor(value, opt);
-  } else {
-    opt.format = "hex";
-    hex = resolveColor(value, opt);
-  }
-  if (isString(hex)) {
-    setCache(cacheKey, hex);
-    return hex;
-  }
-  setCache(cacheKey, null);
-  return null;
-};
-var colorToHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToHsl",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  opt.format = "hsl";
-  const hsl = convertColorToHsl(value, opt);
-  setCache(cacheKey, hsl);
-  return hsl;
-};
-var colorToHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToHwb",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  opt.format = "hwb";
-  const hwb = convertColorToHwb(value, opt);
-  setCache(cacheKey, hwb);
-  return hwb;
-};
-var colorToLab = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToLab",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lab = convertColorToLab(value, opt);
-  setCache(cacheKey, lab);
-  return lab;
-};
-var colorToLch = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToLch",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lch = convertColorToLch(value, opt);
-  setCache(cacheKey, lch);
-  return lch;
-};
-var colorToOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToOklab",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lab = convertColorToOklab(value, opt);
-  setCache(cacheKey, lab);
-  return lab;
-};
-var colorToOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToOklch",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lch = convertColorToOklch(value, opt);
-  setCache(cacheKey, lch);
-  return lch;
-};
-var colorToRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToRgb",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const rgb = convertColorToRgb(value, opt);
-  setCache(cacheKey, rgb);
-  return rgb;
-};
-var colorToXyz = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE8,
-      name: "colorToXyz",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  let xyz;
-  if (value.startsWith("color(")) {
-    [, ...xyz] = parseColorFunc(value, opt);
-  } else {
-    [, ...xyz] = parseColorValue(value, opt);
-  }
-  setCache(cacheKey, xyz);
-  return xyz;
-};
-var colorToXyzD50 = (value, opt = {}) => {
-  opt.d50 = true;
-  return colorToXyz(value, opt);
-};
-var convert = {
-  colorToHex,
-  colorToHsl,
-  colorToHwb,
-  colorToLab,
-  colorToLch,
-  colorToOklab,
-  colorToOklch,
-  colorToRgb,
-  colorToXyz,
-  colorToXyzD50,
-  numberToHex
-};
-
-// src/index.ts
-var utils = {
-  cssCalc,
-  cssVar,
-  extractDashedIdent,
-  isColor,
-  isGradient,
-  resolveGradient,
-  resolveLengthInPixels,
-  splitValue
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  convert,
-  resolve,
-  utils
-});
-/*!
- * CSS color - Resolve, parse, convert CSS color.
- * @license MIT
- * @copyright asamuzaK (Kazz)
- * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
- */
-//# sourceMappingURL=index.cjs.map

node_modules/@asamuzakjp/css-color/dist/cjs/index.d.cts

@@ -1,110 +0,0 @@
-/**
- * typedef
- */
-/**
- * @typedef Options - options
- * @property [alpha] - enable alpha
- * @property [colorSpace] - color space
- * @property [currentColor] - color for currentcolor
- * @property [customProperty] - custom properties
- * @property [d50] - white point in d50
- * @property [dimension] - dimension
- * @property [format] - output format
- * @property [key] - key
- */
-interface Options {
-    alpha?: boolean;
-    colorScheme?: string;
-    colorSpace?: string;
-    currentColor?: string;
-    customProperty?: Record<string, string | ((K: string) => string)>;
-    d50?: boolean;
-    delimiter?: string | string[];
-    dimension?: Record<string, number | ((K: string) => number)>;
-    format?: string;
-    nullable?: boolean;
-    preserveComment?: boolean;
-}
-/**
- * @type ColorChannels - color channels
- */
-type ColorChannels = [x: number, y: number, z: number, alpha: number];
-
-/**
- * convert
- */
-
-declare const convert: {
-    colorToHex: (value: string, opt?: Options) => string | null;
-    colorToHsl: (value: string, opt?: Options) => ColorChannels;
-    colorToHwb: (value: string, opt?: Options) => ColorChannels;
-    colorToLab: (value: string, opt?: Options) => ColorChannels;
-    colorToLch: (value: string, opt?: Options) => ColorChannels;
-    colorToOklab: (value: string, opt?: Options) => ColorChannels;
-    colorToOklch: (value: string, opt?: Options) => ColorChannels;
-    colorToRgb: (value: string, opt?: Options) => ColorChannels;
-    colorToXyz: (value: string, opt?: Options) => ColorChannels;
-    colorToXyzD50: (value: string, opt?: Options) => ColorChannels;
-    numberToHex: (value: number) => string;
-};
-
-/**
- * resolve
- */
-
-/**
- * resolve CSS color
- * @param value
- *   - CSS color value
- *   - system colors are not supported
- * @param [opt] - options
- * @param [opt.currentColor]
- *   - color to use for `currentcolor` keyword
- *   - if omitted, it will be treated as a missing color
- *     i.e. `rgb(none none none / none)`
- * @param [opt.customProperty]
- *   - custom properties
- *   - pair of `--` prefixed property name and value,
- *     e.g. `customProperty: { '--some-color': '#0000ff' }`
- *   - and/or `callback` function to get the value of the custom property,
- *     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`
- * @param [opt.dimension]
- *   - dimension, convert relative length to pixels
- *   - pair of unit and it's value as a number in pixels,
- *     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`
- *   - and/or `callback` function to get the value as a number in pixels,
- *     e.g. `dimension: { callback: convertUnitToPixel }`
- * @param [opt.format]
- *   - output format, one of below
- *   - `computedValue` (default), [computed value][139] of the color
- *   - `specifiedValue`, [specified value][140] of the color
- *   - `hex`, hex color notation, i.e. `rrggbb`
- *   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
- * @returns
- *   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',
- *     color(color-space r g b / alpha), color(color-space x y z / alpha),
- *     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),
- *     oklch(l c h / alpha), null
- *   - in `computedValue`, values are numbers, however `rgb()` values are
- *     integers
- *   - in `specifiedValue`, returns `empty string` for unknown and/or invalid
- *     color
- *   - in `hex`, returns `null` for `transparent`, and also returns `null` if
- *     any of `r`, `g`, `b`, `alpha` is not a number
- *   - in `hexAlpha`, returns `#00000000` for `transparent`,
- *     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
- */
-declare const resolve: (value: string, opt?: Options) => string | null;
-
-declare const utils: {
-    cssCalc: (value: string, opt?: Options) => string;
-    cssVar: (value: string, opt?: Options) => string;
-    extractDashedIdent: (value: string) => string[];
-    isColor: (value: unknown, opt?: Options) => boolean;
-    isGradient: (value: string, opt?: Options) => boolean;
-    resolveGradient: (value: string, opt?: Options) => string;
-    resolveLengthInPixels: (value: number | string, unit: string | undefined, opt?: Options) => number;
-    splitValue: (value: string, opt?: Options) => string[];
-};
-
-export { convert, resolve, utils };

node_modules/@asamuzakjp/css-color/dist/esm/index.d.ts

@@ -1,18 +0,0 @@
-/*!
- * CSS color - Resolve, parse, convert CSS color.
- * @license MIT
- * @copyright asamuzaK (Kazz)
- * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
- */
-export { convert } from './js/convert.js';
-export { resolve } from './js/resolve.js';
-export declare const utils: {
-    cssCalc: (value: string, opt?: import('./js/typedef.js').Options) => string;
-    cssVar: (value: string, opt?: import('./js/typedef.js').Options) => string;
-    extractDashedIdent: (value: string) => string[];
-    isColor: (value: unknown, opt?: import('./js/typedef.js').Options) => boolean;
-    isGradient: (value: string, opt?: import('./js/typedef.js').Options) => boolean;
-    resolveGradient: (value: string, opt?: import('./js/typedef.js').Options) => string;
-    resolveLengthInPixels: (value: number | string, unit: string | undefined, opt?: import('./js/typedef.js').Options) => number;
-    splitValue: (value: string, opt?: import('./js/typedef.js').Options) => string[];
-};

node_modules/@asamuzakjp/css-color/dist/esm/index.js

@@ -1,22 +0,0 @@
-import { cssCalc } from "./js/css-calc.js";
-import { resolveGradient, isGradient } from "./js/css-gradient.js";
-import { cssVar } from "./js/css-var.js";
-import { splitValue, resolveLengthInPixels, isColor, extractDashedIdent } from "./js/util.js";
-import { convert } from "./js/convert.js";
-import { resolve } from "./js/resolve.js";
-const utils = {
-  cssCalc,
-  cssVar,
-  extractDashedIdent,
-  isColor,
-  isGradient,
-  resolveGradient,
-  resolveLengthInPixels,
-  splitValue
-};
-export {
-  convert,
-  resolve,
-  utils
-};
-//# sourceMappingURL=index.js.map

node_modules/@asamuzakjp/css-color/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../src/index.ts"],"sourcesContent":["/*!\n * CSS color - Resolve, parse, convert CSS color.\n * @license MIT\n * @copyright asamuzaK (Kazz)\n * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}\n */\n\nimport { cssCalc } from './js/css-calc';\nimport { isGradient, resolveGradient } from './js/css-gradient';\nimport { cssVar } from './js/css-var';\nimport {\n  extractDashedIdent,\n  isColor,\n  resolveLengthInPixels,\n  splitValue\n} from './js/util';\n\nexport { convert } from './js/convert';\nexport { resolve } from './js/resolve';\n/* utils */\nexport const utils = {\n  cssCalc,\n  cssVar,\n  extractDashedIdent,\n  isColor,\n  isGradient,\n  resolveGradient,\n  resolveLengthInPixels,\n  splitValue\n};\n"],"names":[],"mappings":";;;;;;AAoBO,MAAM,QAAQ;AAAA,EACnB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;"}

node_modules/@asamuzakjp/css-color/dist/esm/js/cache.d.ts

@@ -1,44 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import { Options } from './typedef.js';
-/**
- * CacheItem
- */
-export declare class CacheItem {
-    #private;
-    /**
-     * constructor
-     */
-    constructor(item: unknown, isNull?: boolean);
-    get item(): unknown;
-    get isNull(): boolean;
-}
-/**
- * NullObject
- */
-export declare class NullObject extends CacheItem {
-    /**
-     * constructor
-     */
-    constructor();
-}
-export declare const lruCache: LRUCache<{}, {}, unknown>;
-/**
- * set cache
- * @param key - cache key
- * @param value - value to cache
- * @returns void
- */
-export declare const setCache: (key: string, value: unknown) => void;
-/**
- * get cache
- * @param key - cache key
- * @returns cached item or false otherwise
- */
-export declare const getCache: (key: string) => CacheItem | boolean;
-/**
- * create cache key
- * @param keyData - key data
- * @param [opt] - options
- * @returns cache key
- */
-export declare const createCacheKey: (keyData: Record<string, string>, opt?: Options) => string;

node_modules/@asamuzakjp/css-color/dist/esm/js/cache.js

@@ -1,72 +0,0 @@
-import { LRUCache } from "lru-cache";
-import { valueToJsonString } from "./util.js";
-const MAX_CACHE = 4096;
-class CacheItem {
-  /* private */
-  #isNull;
-  #item;
-  /**
-   * constructor
-   */
-  constructor(item, isNull = false) {
-    this.#item = item;
-    this.#isNull = !!isNull;
-  }
-  get item() {
-    return this.#item;
-  }
-  get isNull() {
-    return this.#isNull;
-  }
-}
-class NullObject extends CacheItem {
-  /**
-   * constructor
-   */
-  constructor() {
-    super(/* @__PURE__ */ Symbol("null"), true);
-  }
-}
-const lruCache = new LRUCache({
-  max: MAX_CACHE
-});
-const setCache = (key, value) => {
-  if (key) {
-    if (value === null) {
-      lruCache.set(key, new NullObject());
-    } else if (value instanceof CacheItem) {
-      lruCache.set(key, value);
-    } else {
-      lruCache.set(key, new CacheItem(value));
-    }
-  }
-};
-const getCache = (key) => {
-  if (key && lruCache.has(key)) {
-    const item = lruCache.get(key);
-    if (item instanceof CacheItem) {
-      return item;
-    }
-    lruCache.delete(key);
-    return false;
-  }
-  return false;
-};
-const createCacheKey = (keyData, opt = {}) => {
-  const { customProperty = {}, dimension = {} } = opt;
-  let cacheKey = "";
-  if (keyData && Object.keys(keyData).length && typeof customProperty.callback !== "function" && typeof dimension.callback !== "function") {
-    keyData.opt = valueToJsonString(opt);
-    cacheKey = valueToJsonString(keyData);
-  }
-  return cacheKey;
-};
-export {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  lruCache,
-  setCache
-};
-//# sourceMappingURL=cache.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/color.d.ts

@@ -1,537 +0,0 @@
-import { NullObject } from './cache.js';
-import { ColorChannels, Options, SpecifiedColorChannels } from './typedef.js';
-/**
- * @type TriColorChannels - color channels without alpha
- */
-type TriColorChannels = [x: number, y: number, z: number];
-/**
- * @type ColorMatrix - color matrix
- */
-type ColorMatrix = [
-    r1: TriColorChannels,
-    r2: TriColorChannels,
-    r3: TriColorChannels
-];
-/**
- * named colors
- */
-export declare const NAMED_COLORS: {
-    readonly aliceblue: [240, 248, 255];
-    readonly antiquewhite: [250, 235, 215];
-    readonly aqua: [0, 255, 255];
-    readonly aquamarine: [127, 255, 212];
-    readonly azure: [240, 255, 255];
-    readonly beige: [245, 245, 220];
-    readonly bisque: [255, 228, 196];
-    readonly black: [0, 0, 0];
-    readonly blanchedalmond: [255, 235, 205];
-    readonly blue: [0, 0, 255];
-    readonly blueviolet: [138, 43, 226];
-    readonly brown: [165, 42, 42];
-    readonly burlywood: [222, 184, 135];
-    readonly cadetblue: [95, 158, 160];
-    readonly chartreuse: [127, 255, 0];
-    readonly chocolate: [210, 105, 30];
-    readonly coral: [255, 127, 80];
-    readonly cornflowerblue: [100, 149, 237];
-    readonly cornsilk: [255, 248, 220];
-    readonly crimson: [220, 20, 60];
-    readonly cyan: [0, 255, 255];
-    readonly darkblue: [0, 0, 139];
-    readonly darkcyan: [0, 139, 139];
-    readonly darkgoldenrod: [184, 134, 11];
-    readonly darkgray: [169, 169, 169];
-    readonly darkgreen: [0, 100, 0];
-    readonly darkgrey: [169, 169, 169];
-    readonly darkkhaki: [189, 183, 107];
-    readonly darkmagenta: [139, 0, 139];
-    readonly darkolivegreen: [85, 107, 47];
-    readonly darkorange: [255, 140, 0];
-    readonly darkorchid: [153, 50, 204];
-    readonly darkred: [139, 0, 0];
-    readonly darksalmon: [233, 150, 122];
-    readonly darkseagreen: [143, 188, 143];
-    readonly darkslateblue: [72, 61, 139];
-    readonly darkslategray: [47, 79, 79];
-    readonly darkslategrey: [47, 79, 79];
-    readonly darkturquoise: [0, 206, 209];
-    readonly darkviolet: [148, 0, 211];
-    readonly deeppink: [255, 20, 147];
-    readonly deepskyblue: [0, 191, 255];
-    readonly dimgray: [105, 105, 105];
-    readonly dimgrey: [105, 105, 105];
-    readonly dodgerblue: [30, 144, 255];
-    readonly firebrick: [178, 34, 34];
-    readonly floralwhite: [255, 250, 240];
-    readonly forestgreen: [34, 139, 34];
-    readonly fuchsia: [255, 0, 255];
-    readonly gainsboro: [220, 220, 220];
-    readonly ghostwhite: [248, 248, 255];
-    readonly gold: [255, 215, 0];
-    readonly goldenrod: [218, 165, 32];
-    readonly gray: [128, 128, 128];
-    readonly green: [0, 128, 0];
-    readonly greenyellow: [173, 255, 47];
-    readonly grey: [128, 128, 128];
-    readonly honeydew: [240, 255, 240];
-    readonly hotpink: [255, 105, 180];
-    readonly indianred: [205, 92, 92];
-    readonly indigo: [75, 0, 130];
-    readonly ivory: [255, 255, 240];
-    readonly khaki: [240, 230, 140];
-    readonly lavender: [230, 230, 250];
-    readonly lavenderblush: [255, 240, 245];
-    readonly lawngreen: [124, 252, 0];
-    readonly lemonchiffon: [255, 250, 205];
-    readonly lightblue: [173, 216, 230];
-    readonly lightcoral: [240, 128, 128];
-    readonly lightcyan: [224, 255, 255];
-    readonly lightgoldenrodyellow: [250, 250, 210];
-    readonly lightgray: [211, 211, 211];
-    readonly lightgreen: [144, 238, 144];
-    readonly lightgrey: [211, 211, 211];
-    readonly lightpink: [255, 182, 193];
-    readonly lightsalmon: [255, 160, 122];
-    readonly lightseagreen: [32, 178, 170];
-    readonly lightskyblue: [135, 206, 250];
-    readonly lightslategray: [119, 136, 153];
-    readonly lightslategrey: [119, 136, 153];
-    readonly lightsteelblue: [176, 196, 222];
-    readonly lightyellow: [255, 255, 224];
-    readonly lime: [0, 255, 0];
-    readonly limegreen: [50, 205, 50];
-    readonly linen: [250, 240, 230];
-    readonly magenta: [255, 0, 255];
-    readonly maroon: [128, 0, 0];
-    readonly mediumaquamarine: [102, 205, 170];
-    readonly mediumblue: [0, 0, 205];
-    readonly mediumorchid: [186, 85, 211];
-    readonly mediumpurple: [147, 112, 219];
-    readonly mediumseagreen: [60, 179, 113];
-    readonly mediumslateblue: [123, 104, 238];
-    readonly mediumspringgreen: [0, 250, 154];
-    readonly mediumturquoise: [72, 209, 204];
-    readonly mediumvioletred: [199, 21, 133];
-    readonly midnightblue: [25, 25, 112];
-    readonly mintcream: [245, 255, 250];
-    readonly mistyrose: [255, 228, 225];
-    readonly moccasin: [255, 228, 181];
-    readonly navajowhite: [255, 222, 173];
-    readonly navy: [0, 0, 128];
-    readonly oldlace: [253, 245, 230];
-    readonly olive: [128, 128, 0];
-    readonly olivedrab: [107, 142, 35];
-    readonly orange: [255, 165, 0];
-    readonly orangered: [255, 69, 0];
-    readonly orchid: [218, 112, 214];
-    readonly palegoldenrod: [238, 232, 170];
-    readonly palegreen: [152, 251, 152];
-    readonly paleturquoise: [175, 238, 238];
-    readonly palevioletred: [219, 112, 147];
-    readonly papayawhip: [255, 239, 213];
-    readonly peachpuff: [255, 218, 185];
-    readonly peru: [205, 133, 63];
-    readonly pink: [255, 192, 203];
-    readonly plum: [221, 160, 221];
-    readonly powderblue: [176, 224, 230];
-    readonly purple: [128, 0, 128];
-    readonly rebeccapurple: [102, 51, 153];
-    readonly red: [255, 0, 0];
-    readonly rosybrown: [188, 143, 143];
-    readonly royalblue: [65, 105, 225];
-    readonly saddlebrown: [139, 69, 19];
-    readonly salmon: [250, 128, 114];
-    readonly sandybrown: [244, 164, 96];
-    readonly seagreen: [46, 139, 87];
-    readonly seashell: [255, 245, 238];
-    readonly sienna: [160, 82, 45];
-    readonly silver: [192, 192, 192];
-    readonly skyblue: [135, 206, 235];
-    readonly slateblue: [106, 90, 205];
-    readonly slategray: [112, 128, 144];
-    readonly slategrey: [112, 128, 144];
-    readonly snow: [255, 250, 250];
-    readonly springgreen: [0, 255, 127];
-    readonly steelblue: [70, 130, 180];
-    readonly tan: [210, 180, 140];
-    readonly teal: [0, 128, 128];
-    readonly thistle: [216, 191, 216];
-    readonly tomato: [255, 99, 71];
-    readonly turquoise: [64, 224, 208];
-    readonly violet: [238, 130, 238];
-    readonly wheat: [245, 222, 179];
-    readonly white: [255, 255, 255];
-    readonly whitesmoke: [245, 245, 245];
-    readonly yellow: [255, 255, 0];
-    readonly yellowgreen: [154, 205, 50];
-};
-/**
- * cache invalid color value
- * @param key - cache key
- * @param nullable - is nullable
- * @returns cached value
- */
-export declare const cacheInvalidColorValue: (cacheKey: string, format: string, nullable?: boolean) => SpecifiedColorChannels | string | NullObject;
-/**
- * resolve invalid color value
- * @param format - output format
- * @param nullable - is nullable
- * @returns resolved value
- */
-export declare const resolveInvalidColorValue: (format: string, nullable?: boolean) => SpecifiedColorChannels | string | NullObject;
-/**
- * validate color components
- * @param arr - color components
- * @param [opt] - options
- * @param [opt.alpha] - alpha channel
- * @param [opt.minLength] - min length
- * @param [opt.maxLength] - max length
- * @param [opt.minRange] - min range
- * @param [opt.maxRange] - max range
- * @param [opt.validateRange] - validate range
- * @returns result - validated color components
- */
-export declare const validateColorComponents: (arr: ColorChannels | TriColorChannels, opt?: {
-    alpha?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    minRange?: number;
-    maxRange?: number;
-    validateRange?: boolean;
-}) => ColorChannels | TriColorChannels;
-/**
- * transform matrix
- * @param mtx - 3 * 3 matrix
- * @param vct - vector
- * @param [skip] - skip validate
- * @returns TriColorChannels - [p1, p2, p3]
- */
-export declare const transformMatrix: (mtx: ColorMatrix, vct: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * normalize color components
- * @param colorA - color components [v1, v2, v3, v4]
- * @param colorB - color components [v1, v2, v3, v4]
- * @param [skip] - skip validate
- * @returns result - [colorA, colorB]
- */
-export declare const normalizeColorComponents: (colorA: [number | string, number | string, number | string, number | string], colorB: [number | string, number | string, number | string, number | string], skip?: boolean) => [ColorChannels, ColorChannels];
-/**
- * number to hex string
- * @param value - numeric value
- * @returns hex string
- */
-export declare const numberToHexString: (value: number) => string;
-/**
- * angle to deg
- * @param angle
- * @returns deg: 0..360
- */
-export declare const angleToDeg: (angle: string) => number;
-/**
- * parse alpha
- * @param [alpha] - alpha value
- * @returns alpha: 0..1
- */
-export declare const parseAlpha: (alpha?: string) => number;
-/**
- * parse hex alpha
- * @param value - alpha value in hex string
- * @returns alpha: 0..1
- */
-export declare const parseHexAlpha: (value: string) => number;
-/**
- * transform rgb to linear rgb
- * @param rgb - [r, g, b] r|g|b: 0..255
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..1
- */
-export declare const transformRgbToLinearRgb: (rgb: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform rgb to xyz
- * @param rgb - [r, g, b] r|g|b: 0..255
- * @param [skip] - skip validate
- * @returns TriColorChannels - [x, y, z]
- */
-export declare const transformRgbToXyz: (rgb: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform rgb to xyz-d50
- * @param rgb - [r, g, b] r|g|b: 0..255 alpha: 0..1
- * @returns TriColorChannels - [x, y, z]
- */
-export declare const transformRgbToXyzD50: (rgb: TriColorChannels) => TriColorChannels;
-/**
- * transform linear rgb to rgb
- * @param rgb - [r, g, b] r|g|b: 0..1
- * @param [round] - round result
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export declare const transformLinearRgbToRgb: (rgb: TriColorChannels, round?: boolean) => TriColorChannels;
-/**
- * transform xyz to rgb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export declare const transformXyzToRgb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz to xyz-d50
- * @param xyz - [x, y, z]
- * @returns TriColorChannels - [x, y, z]
- */
-export declare const transformXyzToXyzD50: (xyz: TriColorChannels) => TriColorChannels;
-/**
- * transform xyz to hsl
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [h, s, l]
- */
-export declare const transformXyzToHsl: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz to hwb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [h, w, b]
- */
-export declare const transformXyzToHwb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz to oklab
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, a, b]
- */
-export declare const transformXyzToOklab: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz to oklch
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, c, h]
- */
-export declare const transformXyzToOklch: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz D50 to rgb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export declare const transformXyzD50ToRgb: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz-d50 to lab
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, a, b]
- */
-export declare const transformXyzD50ToLab: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * transform xyz-d50 to lch
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, c, h]
- */
-export declare const transformXyzD50ToLch: (xyz: TriColorChannels, skip?: boolean) => TriColorChannels;
-/**
- * convert rgb to hex color
- * @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- * @returns hex color
- */
-export declare const convertRgbToHex: (rgb: ColorChannels) => string;
-/**
- * convert linear rgb to hex color
- * @param rgb - [r, g, b, alpha] r|g|b|alpha: 0..1
- * @param [skip] - skip validate
- * @returns hex color
- */
-export declare const convertLinearRgbToHex: (rgb: ColorChannels, skip?: boolean) => string;
-/**
- * convert xyz to hex color
- * @param xyz - [x, y, z, alpha]
- * @returns hex color
- */
-export declare const convertXyzToHex: (xyz: ColorChannels) => string;
-/**
- * convert xyz D50 to hex color
- * @param xyz - [x, y, z, alpha]
- * @returns hex color
- */
-export declare const convertXyzD50ToHex: (xyz: ColorChannels) => string;
-/**
- * convert hex color to rgb
- * @param value - hex color value
- * @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- */
-export declare const convertHexToRgb: (value: string) => ColorChannels;
-/**
- * convert hex color to linear rgb
- * @param value - hex color value
- * @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1
- */
-export declare const convertHexToLinearRgb: (value: string) => ColorChannels;
-/**
- * convert hex color to xyz
- * @param value - hex color value
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export declare const convertHexToXyz: (value: string) => ColorChannels;
-/**
- * parse rgb()
- * @param value - rgb color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export declare const parseRgb: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse hsl()
- * @param value - hsl color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export declare const parseHsl: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse hwb()
- * @param value - hwb color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export declare const parseHwb: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse lab()
- * @param value - lab color value
- * @param [opt] - options
- * @returns parsed color
- *   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject
- */
-export declare const parseLab: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse lch()
- * @param value - lch color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]
- *   - '(empty)', NullObject
- */
-export declare const parseLch: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse oklab()
- * @param value - oklab color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]
- *   - '(empty)', NullObject
- */
-export declare const parseOklab: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse oklch()
- * @param value - oklch color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]
- *   - '(empty)', NullObject
- */
-export declare const parseOklch: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse color()
- * @param value - color function value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]
- *   - '(empty)', NullObject
- */
-export declare const parseColorFunc: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * parse color value
- * @param value - CSS color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]
- *   - value, '(empty)', NullObject
- */
-export declare const parseColorValue: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * resolve color value
- * @param value - CSS color value
- * @param [opt] - options
- * @returns resolved color
- *   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject
- */
-export declare const resolveColorValue: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * resolve color()
- * @param value - color function value
- * @param [opt] - options
- * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject
- */
-export declare const resolveColorFunc: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-/**
- * convert color value to linear rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1
- */
-export declare const convertColorToLinearRgb: (value: string, opt?: {
-    colorSpace?: string;
-    format?: string;
-}) => ColorChannels | NullObject;
-/**
- * convert color value to rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject
- *   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- */
-export declare const convertColorToRgb: (value: string, opt?: Options) => ColorChannels | NullObject;
-/**
- * convert color value to xyz
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [x, y, z, alpha]
- */
-export declare const convertColorToXyz: (value: string, opt?: Options) => ColorChannels | NullObject;
-/**
- * convert color value to hsl
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless
- */
-export declare const convertColorToHsl: (value: string, opt?: Options) => ColorChannels | [number | string, number, number, number] | NullObject;
-/**
- * convert color value to hwb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless
- */
-export declare const convertColorToHwb: (value: string, opt?: Options) => ColorChannels | [number | string, number, number, number] | NullObject;
-/**
- * convert color value to lab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, a, b, alpha]
- */
-export declare const convertColorToLab: (value: string, opt?: Options) => ColorChannels | NullObject;
-/**
- * convert color value to lch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
- */
-export declare const convertColorToLch: (value: string, opt?: Options) => ColorChannels | [number, number, number | string, number] | NullObject;
-/**
- * convert color value to oklab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, a, b, alpha]
- */
-export declare const convertColorToOklab: (value: string, opt?: Options) => ColorChannels | NullObject;
-/**
- * convert color value to oklch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
- */
-export declare const convertColorToOklch: (value: string, opt?: Options) => ColorChannels | [number, number, number | string, number] | NullObject;
-/**
- * resolve color-mix()
- * @param value - color-mix color value
- * @param [opt] - options
- * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'
- */
-export declare const resolveColorMix: (value: string, opt?: Options) => SpecifiedColorChannels | string | NullObject;
-export {};

node_modules/@asamuzakjp/css-color/dist/esm/js/color.js

@@ -1,2833 +0,0 @@
-import { NullObject, createCacheKey, getCache, CacheItem, setCache } from "./cache.js";
-import { isString } from "./common.js";
-import { resolveColor } from "./resolve.js";
-import { roundToPrecision, splitValue, interpolateHue } from "./util.js";
-import { NONE, VAL_MIX, VAL_COMP, VAL_SPEC, FN_COLOR, SYN_FN_COLOR, SYN_COLOR_TYPE, SYN_LCH, SYN_MOD, SYN_HSL, SYN_HSL_LV3, FN_MIX, FN_LIGHT_DARK, SYN_RGB_LV3, SYN_MIX, CS_RGB, CS_XYZ, CS_MIX, CS_HUE_CAPT, PCT, SYN_MIX_PART, SYN_MIX_CAPT, NUM, ANGLE } from "./constant.js";
-const NAMESPACE = "color";
-const PPTH = 1e-3;
-const HALF = 0.5;
-const DUO = 2;
-const TRIA = 3;
-const QUAD = 4;
-const OCT = 8;
-const DEC = 10;
-const DOZ = 12;
-const HEX = 16;
-const SEXA = 60;
-const DEG_HALF = 180;
-const DEG = 360;
-const MAX_PCT = 100;
-const MAX_RGB = 255;
-const POW_SQR = 2;
-const POW_CUBE = 3;
-const POW_LINEAR = 2.4;
-const LINEAR_COEF = 12.92;
-const LINEAR_OFFSET = 0.055;
-const LAB_L = 116;
-const LAB_A = 500;
-const LAB_B = 200;
-const LAB_EPSILON = 216 / 24389;
-const LAB_KAPPA = 24389 / 27;
-const D50 = [
-  0.3457 / 0.3585,
-  1,
-  (1 - 0.3457 - 0.3585) / 0.3585
-];
-const MATRIX_D50_TO_D65 = [
-  [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
-  [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
-  [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
-];
-const MATRIX_D65_TO_D50 = [
-  [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
-  [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
-  [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
-];
-const MATRIX_L_RGB_TO_XYZ = [
-  [506752 / 1228815, 87881 / 245763, 12673 / 70218],
-  [87098 / 409605, 175762 / 245763, 12673 / 175545],
-  [7918 / 409605, 87881 / 737289, 1001167 / 1053270]
-];
-const MATRIX_XYZ_TO_L_RGB = [
-  [12831 / 3959, -329 / 214, -1974 / 3959],
-  [-851781 / 878810, 1648619 / 878810, 36519 / 878810],
-  [705 / 12673, -2585 / 12673, 705 / 667]
-];
-const MATRIX_XYZ_TO_LMS = [
-  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
-  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
-  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
-];
-const MATRIX_LMS_TO_XYZ = [
-  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
-  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
-  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
-];
-const MATRIX_OKLAB_TO_LMS = [
-  [1, 0.3963377773761749, 0.2158037573099136],
-  [1, -0.1055613458156586, -0.0638541728258133],
-  [1, -0.0894841775298119, -1.2914855480194092]
-];
-const MATRIX_LMS_TO_OKLAB = [
-  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
-  [1.9779985324311684, -2.42859224204858, 0.450593709617411],
-  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
-];
-const MATRIX_P3_TO_XYZ = [
-  [608311 / 1250200, 189793 / 714400, 198249 / 1000160],
-  [35783 / 156275, 247089 / 357200, 198249 / 2500400],
-  [0 / 1, 32229 / 714400, 5220557 / 5000800]
-];
-const MATRIX_REC2020_TO_XYZ = [
-  [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
-  [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
-  [0 / 1, 19567812 / 697040785, 295819943 / 278816314]
-];
-const MATRIX_A98_TO_XYZ = [
-  [573536 / 994567, 263643 / 1420810, 187206 / 994567],
-  [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],
-  [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835]
-];
-const MATRIX_PROPHOTO_TO_XYZ_D50 = [
-  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
-  [0.2880748288194013, 0.711835234241873, 8993693872564e-17],
-  [0, 0, 0.8251046025104602]
-];
-const REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
-const REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);
-const REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;
-const REG_CURRENT = /^currentColor$/i;
-const REG_FN_COLOR = new RegExp(`^color\\(\\s*(${SYN_FN_COLOR})\\s*\\)$`);
-const REG_HSL = new RegExp(`^hsla?\\(\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\s*\\)$`);
-const REG_HWB = new RegExp(`^hwb\\(\\s*(${SYN_HSL})\\s*\\)$`);
-const REG_LAB = new RegExp(`^lab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-const REG_LCH = new RegExp(`^lch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-const REG_MIX = new RegExp(`^${SYN_MIX}$`);
-const REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);
-const REG_MIX_NEST = new RegExp(`${SYN_MIX}`, "g");
-const REG_OKLAB = new RegExp(`^oklab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-const REG_OKLCH = new RegExp(`^oklch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-const REG_SPEC = /^(?:specifi|comput)edValue$/;
-const NAMED_COLORS = {
-  aliceblue: [240, 248, 255],
-  antiquewhite: [250, 235, 215],
-  aqua: [0, 255, 255],
-  aquamarine: [127, 255, 212],
-  azure: [240, 255, 255],
-  beige: [245, 245, 220],
-  bisque: [255, 228, 196],
-  black: [0, 0, 0],
-  blanchedalmond: [255, 235, 205],
-  blue: [0, 0, 255],
-  blueviolet: [138, 43, 226],
-  brown: [165, 42, 42],
-  burlywood: [222, 184, 135],
-  cadetblue: [95, 158, 160],
-  chartreuse: [127, 255, 0],
-  chocolate: [210, 105, 30],
-  coral: [255, 127, 80],
-  cornflowerblue: [100, 149, 237],
-  cornsilk: [255, 248, 220],
-  crimson: [220, 20, 60],
-  cyan: [0, 255, 255],
-  darkblue: [0, 0, 139],
-  darkcyan: [0, 139, 139],
-  darkgoldenrod: [184, 134, 11],
-  darkgray: [169, 169, 169],
-  darkgreen: [0, 100, 0],
-  darkgrey: [169, 169, 169],
-  darkkhaki: [189, 183, 107],
-  darkmagenta: [139, 0, 139],
-  darkolivegreen: [85, 107, 47],
-  darkorange: [255, 140, 0],
-  darkorchid: [153, 50, 204],
-  darkred: [139, 0, 0],
-  darksalmon: [233, 150, 122],
-  darkseagreen: [143, 188, 143],
-  darkslateblue: [72, 61, 139],
-  darkslategray: [47, 79, 79],
-  darkslategrey: [47, 79, 79],
-  darkturquoise: [0, 206, 209],
-  darkviolet: [148, 0, 211],
-  deeppink: [255, 20, 147],
-  deepskyblue: [0, 191, 255],
-  dimgray: [105, 105, 105],
-  dimgrey: [105, 105, 105],
-  dodgerblue: [30, 144, 255],
-  firebrick: [178, 34, 34],
-  floralwhite: [255, 250, 240],
-  forestgreen: [34, 139, 34],
-  fuchsia: [255, 0, 255],
-  gainsboro: [220, 220, 220],
-  ghostwhite: [248, 248, 255],
-  gold: [255, 215, 0],
-  goldenrod: [218, 165, 32],
-  gray: [128, 128, 128],
-  green: [0, 128, 0],
-  greenyellow: [173, 255, 47],
-  grey: [128, 128, 128],
-  honeydew: [240, 255, 240],
-  hotpink: [255, 105, 180],
-  indianred: [205, 92, 92],
-  indigo: [75, 0, 130],
-  ivory: [255, 255, 240],
-  khaki: [240, 230, 140],
-  lavender: [230, 230, 250],
-  lavenderblush: [255, 240, 245],
-  lawngreen: [124, 252, 0],
-  lemonchiffon: [255, 250, 205],
-  lightblue: [173, 216, 230],
-  lightcoral: [240, 128, 128],
-  lightcyan: [224, 255, 255],
-  lightgoldenrodyellow: [250, 250, 210],
-  lightgray: [211, 211, 211],
-  lightgreen: [144, 238, 144],
-  lightgrey: [211, 211, 211],
-  lightpink: [255, 182, 193],
-  lightsalmon: [255, 160, 122],
-  lightseagreen: [32, 178, 170],
-  lightskyblue: [135, 206, 250],
-  lightslategray: [119, 136, 153],
-  lightslategrey: [119, 136, 153],
-  lightsteelblue: [176, 196, 222],
-  lightyellow: [255, 255, 224],
-  lime: [0, 255, 0],
-  limegreen: [50, 205, 50],
-  linen: [250, 240, 230],
-  magenta: [255, 0, 255],
-  maroon: [128, 0, 0],
-  mediumaquamarine: [102, 205, 170],
-  mediumblue: [0, 0, 205],
-  mediumorchid: [186, 85, 211],
-  mediumpurple: [147, 112, 219],
-  mediumseagreen: [60, 179, 113],
-  mediumslateblue: [123, 104, 238],
-  mediumspringgreen: [0, 250, 154],
-  mediumturquoise: [72, 209, 204],
-  mediumvioletred: [199, 21, 133],
-  midnightblue: [25, 25, 112],
-  mintcream: [245, 255, 250],
-  mistyrose: [255, 228, 225],
-  moccasin: [255, 228, 181],
-  navajowhite: [255, 222, 173],
-  navy: [0, 0, 128],
-  oldlace: [253, 245, 230],
-  olive: [128, 128, 0],
-  olivedrab: [107, 142, 35],
-  orange: [255, 165, 0],
-  orangered: [255, 69, 0],
-  orchid: [218, 112, 214],
-  palegoldenrod: [238, 232, 170],
-  palegreen: [152, 251, 152],
-  paleturquoise: [175, 238, 238],
-  palevioletred: [219, 112, 147],
-  papayawhip: [255, 239, 213],
-  peachpuff: [255, 218, 185],
-  peru: [205, 133, 63],
-  pink: [255, 192, 203],
-  plum: [221, 160, 221],
-  powderblue: [176, 224, 230],
-  purple: [128, 0, 128],
-  rebeccapurple: [102, 51, 153],
-  red: [255, 0, 0],
-  rosybrown: [188, 143, 143],
-  royalblue: [65, 105, 225],
-  saddlebrown: [139, 69, 19],
-  salmon: [250, 128, 114],
-  sandybrown: [244, 164, 96],
-  seagreen: [46, 139, 87],
-  seashell: [255, 245, 238],
-  sienna: [160, 82, 45],
-  silver: [192, 192, 192],
-  skyblue: [135, 206, 235],
-  slateblue: [106, 90, 205],
-  slategray: [112, 128, 144],
-  slategrey: [112, 128, 144],
-  snow: [255, 250, 250],
-  springgreen: [0, 255, 127],
-  steelblue: [70, 130, 180],
-  tan: [210, 180, 140],
-  teal: [0, 128, 128],
-  thistle: [216, 191, 216],
-  tomato: [255, 99, 71],
-  turquoise: [64, 224, 208],
-  violet: [238, 130, 238],
-  wheat: [245, 222, 179],
-  white: [255, 255, 255],
-  whitesmoke: [245, 245, 245],
-  yellow: [255, 255, 0],
-  yellowgreen: [154, 205, 50]
-};
-const cacheInvalidColorValue = (cacheKey, format, nullable = false) => {
-  if (format === VAL_SPEC) {
-    const res2 = "";
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  if (nullable) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const res = ["rgb", 0, 0, 0, 0];
-  setCache(cacheKey, res);
-  return res;
-};
-const resolveInvalidColorValue = (format, nullable = false) => {
-  switch (format) {
-    case "hsl":
-    case "hwb":
-    case VAL_MIX: {
-      return new NullObject();
-    }
-    case VAL_SPEC: {
-      return "";
-    }
-    default: {
-      if (nullable) {
-        return new NullObject();
-      }
-      return ["rgb", 0, 0, 0, 0];
-    }
-  }
-};
-const validateColorComponents = (arr, opt = {}) => {
-  if (!Array.isArray(arr)) {
-    throw new TypeError(`${arr} is not an array.`);
-  }
-  const {
-    alpha = false,
-    minLength = TRIA,
-    maxLength = QUAD,
-    minRange = 0,
-    maxRange = 1,
-    validateRange = true
-  } = opt;
-  if (!Number.isFinite(minLength)) {
-    throw new TypeError(`${minLength} is not a number.`);
-  }
-  if (!Number.isFinite(maxLength)) {
-    throw new TypeError(`${maxLength} is not a number.`);
-  }
-  if (!Number.isFinite(minRange)) {
-    throw new TypeError(`${minRange} is not a number.`);
-  }
-  if (!Number.isFinite(maxRange)) {
-    throw new TypeError(`${maxRange} is not a number.`);
-  }
-  const l = arr.length;
-  if (l < minLength || l > maxLength) {
-    throw new Error(`Unexpected array length ${l}.`);
-  }
-  let i = 0;
-  while (i < l) {
-    const v = arr[i];
-    if (!Number.isFinite(v)) {
-      throw new TypeError(`${v} is not a number.`);
-    } else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) {
-      throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);
-    } else if (i === TRIA && (v < 0 || v > 1)) {
-      throw new RangeError(`${v} is not between 0 and 1.`);
-    }
-    i++;
-  }
-  if (alpha && l === TRIA) {
-    arr.push(1);
-  }
-  return arr;
-};
-const transformMatrix = (mtx, vct, skip = false) => {
-  if (!Array.isArray(mtx)) {
-    throw new TypeError(`${mtx} is not an array.`);
-  } else if (mtx.length !== TRIA) {
-    throw new Error(`Unexpected array length ${mtx.length}.`);
-  } else if (!skip) {
-    for (let i of mtx) {
-      i = validateColorComponents(i, {
-        maxLength: TRIA,
-        validateRange: false
-      });
-    }
-  }
-  const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;
-  let v1, v2, v3;
-  if (skip) {
-    [v1, v2, v3] = vct;
-  } else {
-    [v1, v2, v3] = validateColorComponents(vct, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const p1 = r1c1 * v1 + r1c2 * v2 + r1c3 * v3;
-  const p2 = r2c1 * v1 + r2c2 * v2 + r2c3 * v3;
-  const p3 = r3c1 * v1 + r3c2 * v2 + r3c3 * v3;
-  return [p1, p2, p3];
-};
-const normalizeColorComponents = (colorA, colorB, skip = false) => {
-  if (!Array.isArray(colorA)) {
-    throw new TypeError(`${colorA} is not an array.`);
-  } else if (colorA.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorA.length}.`);
-  }
-  if (!Array.isArray(colorB)) {
-    throw new TypeError(`${colorB} is not an array.`);
-  } else if (colorB.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorB.length}.`);
-  }
-  let i = 0;
-  while (i < QUAD) {
-    if (colorA[i] === NONE && colorB[i] === NONE) {
-      colorA[i] = 0;
-      colorB[i] = 0;
-    } else if (colorA[i] === NONE) {
-      colorA[i] = colorB[i];
-    } else if (colorB[i] === NONE) {
-      colorB[i] = colorA[i];
-    }
-    i++;
-  }
-  if (skip) {
-    return [colorA, colorB];
-  }
-  const validatedColorA = validateColorComponents(colorA, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  const validatedColorB = validateColorComponents(colorB, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  return [validatedColorA, validatedColorB];
-};
-const numberToHexString = (value) => {
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`${value} is not a number.`);
-  } else {
-    value = Math.round(value);
-    if (value < 0 || value > MAX_RGB) {
-      throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);
-    }
-  }
-  let hex = value.toString(HEX);
-  if (hex.length === 1) {
-    hex = `0${hex}`;
-  }
-  return hex;
-};
-const angleToDeg = (angle) => {
-  if (isString(angle)) {
-    angle = angle.trim();
-  } else {
-    throw new TypeError(`${angle} is not a string.`);
-  }
-  const GRAD = DEG / 400;
-  const RAD = DEG / (Math.PI * DUO);
-  const reg = new RegExp(`^(${NUM})(${ANGLE})?$`);
-  if (!reg.test(angle)) {
-    throw new SyntaxError(`Invalid property value: ${angle}`);
-  }
-  const [, value, unit] = angle.match(reg);
-  let deg;
-  switch (unit) {
-    case "grad":
-      deg = parseFloat(value) * GRAD;
-      break;
-    case "rad":
-      deg = parseFloat(value) * RAD;
-      break;
-    case "turn":
-      deg = parseFloat(value) * DEG;
-      break;
-    default:
-      deg = parseFloat(value);
-  }
-  deg %= DEG;
-  if (deg < 0) {
-    deg += DEG;
-  } else if (Object.is(deg, -0)) {
-    deg = 0;
-  }
-  return deg;
-};
-const parseAlpha = (alpha = "") => {
-  if (isString(alpha)) {
-    alpha = alpha.trim();
-    if (!alpha) {
-      alpha = "1";
-    } else if (alpha === NONE) {
-      alpha = "0";
-    } else {
-      let a;
-      if (alpha.endsWith("%")) {
-        a = parseFloat(alpha) / MAX_PCT;
-      } else {
-        a = parseFloat(alpha);
-      }
-      if (!Number.isFinite(a)) {
-        throw new TypeError(`${a} is not a finite number.`);
-      }
-      if (a < PPTH) {
-        alpha = "0";
-      } else if (a > 1) {
-        alpha = "1";
-      } else {
-        alpha = a.toFixed(TRIA);
-      }
-    }
-  } else {
-    alpha = "1";
-  }
-  return parseFloat(alpha);
-};
-const parseHexAlpha = (value) => {
-  if (isString(value)) {
-    if (value === "") {
-      throw new SyntaxError("Invalid property value: (empty string)");
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  let alpha = parseInt(value, HEX);
-  if (alpha <= 0) {
-    return 0;
-  }
-  if (alpha >= MAX_RGB) {
-    return 1;
-  }
-  const alphaMap = /* @__PURE__ */ new Map();
-  for (let i = 1; i < MAX_PCT; i++) {
-    alphaMap.set(Math.round(i * MAX_RGB / MAX_PCT), i);
-  }
-  if (alphaMap.has(alpha)) {
-    alpha = alphaMap.get(alpha) / MAX_PCT;
-  } else {
-    alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;
-  }
-  return parseFloat(alpha.toFixed(TRIA));
-};
-const transformRgbToLinearRgb = (rgb, skip = false) => {
-  let rr, gg, bb;
-  if (skip) {
-    [rr, gg, bb] = rgb;
-  } else {
-    [rr, gg, bb] = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    });
-  }
-  let r = rr / MAX_RGB;
-  let g = gg / MAX_RGB;
-  let b = bb / MAX_RGB;
-  const COND_POW = 0.04045;
-  if (r > COND_POW) {
-    r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    r /= LINEAR_COEF;
-  }
-  if (g > COND_POW) {
-    g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    g /= LINEAR_COEF;
-  }
-  if (b > COND_POW) {
-    b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    b /= LINEAR_COEF;
-  }
-  return [r, g, b];
-};
-const transformRgbToXyz = (rgb, skip = false) => {
-  if (!skip) {
-    rgb = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    });
-  }
-  rgb = transformRgbToLinearRgb(rgb, true);
-  const xyz = transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);
-  return xyz;
-};
-const transformLinearRgbToRgb = (rgb, round = false) => {
-  let [r, g, b] = validateColorComponents(rgb, {
-    maxLength: TRIA
-  });
-  const COND_POW = 809 / 258400;
-  if (r > COND_POW) {
-    r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    r *= LINEAR_COEF;
-  }
-  r *= MAX_RGB;
-  if (g > COND_POW) {
-    g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    g *= LINEAR_COEF;
-  }
-  g *= MAX_RGB;
-  if (b > COND_POW) {
-    b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    b *= LINEAR_COEF;
-  }
-  b *= MAX_RGB;
-  return [
-    round ? Math.round(r) : r,
-    round ? Math.round(g) : g,
-    round ? Math.round(b) : b
-  ];
-};
-const transformXyzToRgb = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);
-  [r, g, b] = transformLinearRgbToRgb(
-    [
-      Math.min(Math.max(r, 0), 1),
-      Math.min(Math.max(g, 0), 1),
-      Math.min(Math.max(b, 0), 1)
-    ],
-    true
-  );
-  return [r, g, b];
-};
-const transformXyzToHsl = (xyz, skip = false) => {
-  const [rr, gg, bb] = transformXyzToRgb(xyz, skip);
-  const r = rr / MAX_RGB;
-  const g = gg / MAX_RGB;
-  const b = bb / MAX_RGB;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const d = max - min;
-  const l = (max + min) * HALF * MAX_PCT;
-  let h, s;
-  if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {
-    h = 0;
-    s = 0;
-  } else {
-    s = d / (1 - Math.abs(max + min - 1)) * MAX_PCT;
-    if (s === 0) {
-      h = 0;
-    } else {
-      switch (max) {
-        case r:
-          h = (g - b) / d;
-          break;
-        case g:
-          h = (b - r) / d + DUO;
-          break;
-        case b:
-        default:
-          h = (r - g) / d + QUAD;
-          break;
-      }
-      h = h * SEXA % DEG;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [h, s, l];
-};
-const transformXyzToHwb = (xyz, skip = false) => {
-  const [r, g, b] = transformXyzToRgb(xyz, skip);
-  const wh = Math.min(r, g, b) / MAX_RGB;
-  const bk = 1 - Math.max(r, g, b) / MAX_RGB;
-  let h;
-  if (wh + bk === 1) {
-    h = 0;
-  } else {
-    [h] = transformXyzToHsl(xyz);
-  }
-  return [h, wh * MAX_PCT, bk * MAX_PCT];
-};
-const transformXyzToOklab = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const lms = transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true);
-  const xyzLms = lms.map((c) => Math.cbrt(c));
-  let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, xyzLms, true);
-  l = Math.min(Math.max(l, 0), 1);
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    a = 0;
-    b = 0;
-  }
-  return [l, a, b];
-};
-const transformXyzToOklch = (xyz, skip = false) => {
-  const [l, a, b] = transformXyzToOklab(xyz, skip);
-  let c, h;
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    if (parseFloat(c.toFixed(QUAD)) === 0) {
-      h = 0;
-    } else {
-      h = Math.atan2(b, a) * DEG_HALF / Math.PI;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [l, c, h];
-};
-const transformXyzD50ToRgb = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, xyz, true);
-  const rgb = transformXyzToRgb(xyzD65, true);
-  return rgb;
-};
-const transformXyzD50ToLab = (xyz, skip = false) => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const xyzD50 = xyz.map((val, i) => val / D50[i]);
-  const [f0, f1, f2] = xyzD50.map(
-    (val) => val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L
-  );
-  const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);
-  let a, b;
-  if (l === 0 || l === MAX_PCT) {
-    a = 0;
-    b = 0;
-  } else {
-    a = (f0 - f1) * LAB_A;
-    b = (f1 - f2) * LAB_B;
-  }
-  return [l, a, b];
-};
-const transformXyzD50ToLch = (xyz, skip = false) => {
-  const [l, a, b] = transformXyzD50ToLab(xyz, skip);
-  let c, h;
-  if (l === 0 || l === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    h = Math.atan2(b, a) * DEG_HALF / Math.PI;
-    if (h < 0) {
-      h += DEG;
-    }
-  }
-  return [l, c, h];
-};
-const convertRgbToHex = (rgb) => {
-  const [r, g, b, alpha] = validateColorComponents(rgb, {
-    alpha: true,
-    maxRange: MAX_RGB
-  });
-  const rr = numberToHexString(r);
-  const gg = numberToHexString(g);
-  const bb = numberToHexString(b);
-  const aa = numberToHexString(alpha * MAX_RGB);
-  let hex;
-  if (aa === "ff") {
-    hex = `#${rr}${gg}${bb}`;
-  } else {
-    hex = `#${rr}${gg}${bb}${aa}`;
-  }
-  return hex;
-};
-const convertHexToRgb = (value) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  if (!(/^#[\da-f]{6}$/.test(value) || /^#[\da-f]{3}$/.test(value) || /^#[\da-f]{8}$/.test(value) || /^#[\da-f]{4}$/.test(value))) {
-    throw new SyntaxError(`Invalid property value: ${value}`);
-  }
-  const arr = [];
-  if (/^#[\da-f]{3}$/.test(value)) {
-    const [, r, g, b] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])$/
-    );
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      1
-    );
-  } else if (/^#[\da-f]{4}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])([\da-f])$/
-    );
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      parseHexAlpha(`${alpha}${alpha}`)
-    );
-  } else if (/^#[\da-f]{8}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    );
-    arr.push(
-      parseInt(r, HEX),
-      parseInt(g, HEX),
-      parseInt(b, HEX),
-      parseHexAlpha(alpha)
-    );
-  } else {
-    const [, r, g, b] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    );
-    arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);
-  }
-  return arr;
-};
-const convertHexToLinearRgb = (value) => {
-  const [rr, gg, bb, alpha] = convertHexToRgb(value);
-  const [r, g, b] = transformRgbToLinearRgb([rr, gg, bb], true);
-  return [r, g, b, alpha];
-};
-const convertHexToXyz = (value) => {
-  const [r, g, b, alpha] = convertHexToLinearRgb(value);
-  const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b], true);
-  return [x, y, z, alpha];
-};
-const parseRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  const reg = new RegExp(`^rgba?\\(\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\s*\\)$`);
-  if (!reg.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(reg);
-  const [v1, v2, v3, v4 = ""] = val.replace(/[,/]/g, " ").split(/\s+/);
-  let r, g, b;
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    if (v1.endsWith("%")) {
-      r = parseFloat(v1) * MAX_RGB / MAX_PCT;
-    } else {
-      r = parseFloat(v1);
-    }
-    r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    if (v2.endsWith("%")) {
-      g = parseFloat(v2) * MAX_RGB / MAX_PCT;
-    } else {
-      g = parseFloat(v2);
-    }
-    g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    if (v3.endsWith("%")) {
-      b = parseFloat(v3) * MAX_RGB / MAX_PCT;
-    } else {
-      b = parseFloat(v3);
-    }
-    b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);
-  }
-  const alpha = parseAlpha(v4);
-  return ["rgb", r, g, b, format === VAL_MIX && v4 === NONE ? NONE : alpha];
-};
-const parseHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_HSL.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_HSL);
-  const [v1, v2, v3, v4 = ""] = val.replace(/[,/]/g, " ").split(/\s+/);
-  let h, s, l;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    s = 0;
-  } else {
-    s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);
-  }
-  if (v3 === NONE) {
-    l = 0;
-  } else {
-    l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);
-  }
-  const alpha = parseAlpha(v4);
-  if (format === "hsl") {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : s,
-      v3 === NONE ? v3 : l,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  h = h / DEG * DOZ;
-  l /= MAX_PCT;
-  const sa = s / MAX_PCT * Math.min(l, 1 - l);
-  const rk = h % DOZ;
-  const gk = (8 + h) % DOZ;
-  const bk = (4 + h) % DOZ;
-  const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));
-  const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));
-  const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));
-  return [
-    "rgb",
-    Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),
-    alpha
-  ];
-};
-const parseHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_HWB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_HWB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let h, wh, bk;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    wh = 0;
-  } else {
-    wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;
-  }
-  if (v3 === NONE) {
-    bk = 0;
-  } else {
-    bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;
-  }
-  const alpha = parseAlpha(v4);
-  if (format === "hwb") {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : wh * MAX_PCT,
-      v3 === NONE ? v3 : bk * MAX_PCT,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  if (wh + bk >= 1) {
-    const v = roundToPrecision(wh / (wh + bk) * MAX_RGB, OCT);
-    return ["rgb", v, v, v, alpha];
-  }
-  const factor = (1 - wh - bk) / MAX_RGB;
-  let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`);
-  r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);
-  g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);
-  b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);
-  return [
-    "rgb",
-    Math.min(Math.max(r, 0), MAX_RGB),
-    Math.min(Math.max(g, 0), MAX_RGB),
-    Math.min(Math.max(b, 0), MAX_RGB),
-    alpha
-  ];
-};
-const parseLab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_LAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 1.25;
-  const COND_POW = 8;
-  const [, val] = value.match(REG_LAB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    if (v1.endsWith("%")) {
-      l = parseFloat(v1);
-      if (l > MAX_PCT) {
-        l = MAX_PCT;
-      }
-    } else {
-      l = parseFloat(v1);
-    }
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else {
-    a = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith("%") ? parseFloat(v3) * COEF_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "lab",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const fl = (l + HEX) / LAB_L;
-  const fa = a / LAB_A + fl;
-  const fb = fl - b / LAB_B;
-  const powFl = Math.pow(fl, POW_CUBE);
-  const powFa = Math.pow(fa, POW_CUBE);
-  const powFb = Math.pow(fb, POW_CUBE);
-  const xyz = [
-    powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,
-    l > COND_POW ? powFl : l / LAB_KAPPA,
-    powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA
-  ];
-  const [x, y, z] = xyz.map(
-    (val2, i) => val2 * D50[i]
-  );
-  return [
-    "xyz-d50",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-const parseLch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_LCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 1.5;
-  const [, val] = value.match(REG_LCH);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    c = v2.endsWith("%") ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "lch",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos(h * Math.PI / DEG_HALF);
-  const b = c * Math.sin(h * Math.PI / DEG_HALF);
-  const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`);
-  return [
-    "xyz-d50",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-const parseOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_OKLAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLAB);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else if (v2.endsWith("%")) {
-    a = parseFloat(v2) * COEF_PCT / MAX_PCT;
-  } else {
-    a = parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else if (v3.endsWith("%")) {
-    b = parseFloat(v3) * COEF_PCT / MAX_PCT;
-  } else {
-    b = parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "oklab",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map((c) => Math.pow(c, POW_CUBE));
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-const parseOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  if (!REG_OKLCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLCH);
-  const [v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    if (v2.endsWith("%")) {
-      c = parseFloat(v2) * COEF_PCT / MAX_PCT;
-    } else {
-      c = parseFloat(v2);
-    }
-    if (c < 0) {
-      c = 0;
-    }
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      "oklch",
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos(h * Math.PI / DEG_HALF);
-  const b = c * Math.sin(h * Math.PI / DEG_HALF);
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map((cc) => Math.pow(cc, POW_CUBE));
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-const parseColorFunc = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", d50 = false, format = "", nullable = false } = opt;
-  if (!REG_FN_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  const [, val] = value.match(REG_FN_COLOR);
-  let [cs, v1, v2, v3, v4 = ""] = val.replace("/", " ").split(/\s+/);
-  let r, g, b;
-  if (cs === "xyz") {
-    cs = "xyz-d65";
-  }
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    r = v1.endsWith("%") ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    g = v2.endsWith("%") ? parseFloat(v2) / MAX_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith("%") ? parseFloat(v3) / MAX_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format) || format === VAL_MIX && cs === colorSpace) {
-    return [
-      cs,
-      v1 === NONE ? v1 : roundToPrecision(r, DEC),
-      v2 === NONE ? v2 : roundToPrecision(g, DEC),
-      v3 === NONE ? v3 : roundToPrecision(b, DEC),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  if (cs === "srgb-linear") {
-    [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "display-p3") {
-    const linearRgb = transformRgbToLinearRgb([
-      r * MAX_RGB,
-      g * MAX_RGB,
-      b * MAX_RGB
-    ]);
-    [x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "rec2020") {
-    const ALPHA = 1.09929682680944;
-    const BETA = 0.018053968510807;
-    const REC_COEF = 0.45;
-    const rgb = [r, g, b].map((c) => {
-      let cl;
-      if (c < BETA * REC_COEF * DEC) {
-        cl = c / (REC_COEF * DEC);
-      } else {
-        cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);
-      }
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "a98-rgb") {
-    const POW_A98 = 563 / 256;
-    const rgb = [r, g, b].map((c) => {
-      const cl = Math.pow(c, POW_A98);
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (cs === "prophoto-rgb") {
-    const POW_PROPHOTO = 1.8;
-    const rgb = [r, g, b].map((c) => {
-      let cl;
-      if (c > 1 / (HEX * DUO)) {
-        cl = Math.pow(c, POW_PROPHOTO);
-      } else {
-        cl = c / HEX;
-      }
-      return cl;
-    });
-    [x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {
-    [x, y, z] = [r, g, b];
-    if (cs === "xyz-d50") {
-      if (!d50) {
-        [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z]);
-      }
-    } else if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else {
-    [x, y, z] = transformRgbToXyz([r * MAX_RGB, g * MAX_RGB, b * MAX_RGB]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? "xyz-d50" : "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    format === VAL_MIX && v4 === NONE ? v4 : alpha
-  ];
-};
-const parseColorValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = "", nullable = false } = opt;
-  if (!REG_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res;
-    }
-    return res;
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  let alpha = 0;
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_COMP) {
-      return ["rgb", 0, 0, 0, 0];
-    }
-    if (format === VAL_SPEC) {
-      return value;
-    }
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      }
-      const [r, g, b] = NAMED_COLORS[value];
-      alpha = 1;
-      if (format === VAL_COMP) {
-        return ["rgb", r, g, b, alpha];
-      }
-      [x, y, z] = transformRgbToXyz([r, g, b], true);
-      if (d50) {
-        [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-      }
-    } else {
-      switch (format) {
-        case VAL_COMP: {
-          if (nullable && value !== "transparent") {
-            return new NullObject();
-          }
-          return ["rgb", 0, 0, 0, 0];
-        }
-        case VAL_SPEC: {
-          if (value === "transparent") {
-            return value;
-          }
-          return "";
-        }
-        case VAL_MIX: {
-          if (value === "transparent") {
-            return ["rgb", 0, 0, 0, 0];
-          }
-          return new NullObject();
-        }
-      }
-    }
-  } else if (value[0] === "#") {
-    if (REG_SPEC.test(format)) {
-      const rgb = convertHexToRgb(value);
-      return ["rgb", ...rgb];
-    }
-    [x, y, z, alpha] = convertHexToXyz(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (value.startsWith("lab")) {
-    if (REG_SPEC.test(format)) {
-      return parseLab(value, opt);
-    }
-    [, x, y, z, alpha] = parseLab(value);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (value.startsWith("lch")) {
-    if (REG_SPEC.test(format)) {
-      return parseLch(value, opt);
-    }
-    [, x, y, z, alpha] = parseLch(value);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-  } else if (value.startsWith("oklab")) {
-    if (REG_SPEC.test(format)) {
-      return parseOklab(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklab(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else if (value.startsWith("oklch")) {
-    if (REG_SPEC.test(format)) {
-      return parseOklch(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklch(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else {
-    let r, g, b;
-    if (value.startsWith("hsl")) {
-      [, r, g, b, alpha] = parseHsl(value);
-    } else if (value.startsWith("hwb")) {
-      [, r, g, b, alpha] = parseHwb(value);
-    } else {
-      [, r, g, b, alpha] = parseRgb(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      return ["rgb", Math.round(r), Math.round(g), Math.round(b), alpha];
-    }
-    [x, y, z] = transformRgbToXyz([r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? "xyz-d50" : "xyz-d65",
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-const resolveColorValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorValue",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  if (!REG_COLOR.test(value)) {
-    const res2 = resolveInvalidColorValue(format, nullable);
-    if (res2 instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res2;
-    }
-    setCache(cacheKey, res2);
-    if (isString(res2)) {
-      return res2;
-    }
-    return res2;
-  }
-  let cs = "";
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        setCache(cacheKey, value);
-        return value;
-      }
-      [r, g, b] = NAMED_COLORS[value];
-      alpha = 1;
-    } else {
-      switch (format) {
-        case VAL_SPEC: {
-          if (value === "transparent") {
-            setCache(cacheKey, value);
-            return value;
-          }
-          const res2 = "";
-          setCache(cacheKey, res2);
-          return res2;
-        }
-        case VAL_MIX: {
-          if (value === "transparent") {
-            const res2 = ["rgb", 0, 0, 0, 0];
-            setCache(cacheKey, res2);
-            return res2;
-          }
-          setCache(cacheKey, null);
-          return new NullObject();
-        }
-        case VAL_COMP:
-        default: {
-          if (nullable && value !== "transparent") {
-            setCache(cacheKey, null);
-            return new NullObject();
-          }
-          const res2 = ["rgb", 0, 0, 0, 0];
-          setCache(cacheKey, res2);
-          return res2;
-        }
-      }
-    }
-  } else if (value[0] === "#") {
-    [r, g, b, alpha] = convertHexToRgb(value);
-  } else if (value.startsWith("hsl")) {
-    [, r, g, b, alpha] = parseHsl(value, opt);
-  } else if (value.startsWith("hwb")) {
-    [, r, g, b, alpha] = parseHwb(value, opt);
-  } else if (/^l(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith("lab")) {
-      [cs, x, y, z, alpha] = parseLab(value, opt);
-    } else {
-      [cs, x, y, z, alpha] = parseLch(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      const res2 = [cs, x, y, z, alpha];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [r, g, b] = transformXyzD50ToRgb([x, y, z]);
-  } else if (/^okl(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith("oklab")) {
-      [cs, x, y, z, alpha] = parseOklab(value, opt);
-    } else {
-      [cs, x, y, z, alpha] = parseOklch(value, opt);
-    }
-    if (REG_SPEC.test(format)) {
-      const res2 = [cs, x, y, z, alpha];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [r, g, b] = transformXyzToRgb([x, y, z]);
-  } else {
-    [, r, g, b, alpha] = parseRgb(value, opt);
-  }
-  if (format === VAL_MIX && colorSpace === "srgb") {
-    const res2 = [
-      "srgb",
-      r / MAX_RGB,
-      g / MAX_RGB,
-      b / MAX_RGB,
-      alpha
-    ];
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  const res = [
-    "rgb",
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    alpha
-  ];
-  setCache(cacheKey, res);
-  return res;
-};
-const resolveColorFunc = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorFunc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  if (!REG_FN_COLOR.test(value)) {
-    const res2 = resolveInvalidColorValue(format, nullable);
-    if (res2 instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res2;
-    }
-    setCache(cacheKey, res2);
-    if (isString(res2)) {
-      return res2;
-    }
-    return res2;
-  }
-  const [cs, v1, v2, v3, v4] = parseColorFunc(
-    value,
-    opt
-  );
-  if (REG_SPEC.test(format) || format === VAL_MIX && cs === colorSpace) {
-    const res2 = [cs, v1, v2, v3, v4];
-    setCache(cacheKey, res2);
-    return res2;
-  }
-  const x = parseFloat(`${v1}`);
-  const y = parseFloat(`${v2}`);
-  const z = parseFloat(`${v3}`);
-  const alpha = parseAlpha(`${v4}`);
-  const [r, g, b] = transformXyzToRgb([x, y, z], true);
-  const res = ["rgb", r, g, b, alpha];
-  setCache(cacheKey, res);
-  return res;
-};
-const convertColorToLinearRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = "", format = "" } = opt;
-  let cs = "";
-  let r, g, b, alpha, x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [cs, x, y, z, alpha] = xyz;
-    if (cs === colorSpace) {
-      return [x, y, z, alpha];
-    }
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs2] = val.replace("/", " ").split(/\s+/);
-    if (cs2 === "srgb-linear") {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value);
-      [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  }
-  return [
-    Math.min(Math.max(r, 0), 1),
-    Math.min(Math.max(g, 0), 1),
-    Math.min(Math.max(b, 0), 1),
-    alpha
-  ];
-};
-const convertColorToRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let r, g, b, alpha;
-  if (format === VAL_MIX) {
-    let rgb;
-    if (value.startsWith(FN_COLOR)) {
-      rgb = resolveColorFunc(value, opt);
-    } else {
-      rgb = resolveColorValue(value, opt);
-    }
-    if (rgb instanceof NullObject) {
-      return rgb;
-    }
-    [, r, g, b, alpha] = rgb;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs] = val.replace("/", " ").split(/\s+/);
-    if (cs === "srgb") {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-      r *= MAX_RGB;
-      g *= MAX_RGB;
-      b *= MAX_RGB;
-    } else {
-      [, r, g, b, alpha] = resolveColorFunc(value);
-    }
-  } else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {
-    [r, g, b, alpha] = convertColorToLinearRgb(value);
-    [r, g, b] = transformLinearRgbToRgb([r, g, b]);
-  } else {
-    [, r, g, b, alpha] = resolveColorValue(value, {
-      format: VAL_COMP
-    });
-  }
-  return [r, g, b, alpha];
-};
-const convertColorToXyz = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = "" } = opt;
-  let x, y, z, alpha;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR);
-    const [cs] = val.replace("/", " ").split(/\s+/);
-    if (d50) {
-      if (cs === "xyz-d50") {
-        [, x, y, z, alpha] = resolveColorFunc(value, {
-          format: VAL_COMP
-        });
-      } else {
-        [, x, y, z, alpha] = parseColorFunc(
-          value,
-          opt
-        );
-      }
-    } else if (/^xyz(?:-d65)?$/.test(cs)) {
-      [, x, y, z, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      });
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value);
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, opt);
-  }
-  return [x, y, z, alpha];
-};
-const convertColorToHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let h, s, l, alpha;
-  if (REG_HSL.test(value)) {
-    [, h, s, l, alpha] = parseHsl(value, {
-      format: "hsl"
-    });
-    if (format === "hsl") {
-      return [Math.round(h), Math.round(s), Math.round(l), alpha];
-    }
-    return [h, s, l, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [h, s, l] = transformXyzToHsl([x, y, z], true);
-  if (format === "hsl") {
-    return [Math.round(h), Math.round(s), Math.round(l), alpha];
-  }
-  return [format === VAL_MIX && s === 0 ? NONE : h, s, l, alpha];
-};
-const convertColorToHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let h, w, b, alpha;
-  if (REG_HWB.test(value)) {
-    [, h, w, b, alpha] = parseHwb(value, {
-      format: "hwb"
-    });
-    if (format === "hwb") {
-      return [Math.round(h), Math.round(w), Math.round(b), alpha];
-    }
-    return [h, w, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [h, w, b] = transformXyzToHwb([x, y, z], true);
-  if (format === "hwb") {
-    return [Math.round(h), Math.round(w), Math.round(b), alpha];
-  }
-  return [format === VAL_MIX && w + b >= 100 ? NONE : h, w, b, alpha];
-};
-const convertColorToLab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, a, b, alpha;
-  if (REG_LAB.test(value)) {
-    [, l, a, b, alpha] = parseLab(value, {
-      format: VAL_COMP
-    });
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    });
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    });
-  }
-  [l, a, b] = transformXyzD50ToLab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-const convertColorToLch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, c, h, alpha;
-  if (REG_LCH.test(value)) {
-    [, l, c, h, alpha] = parseLch(value, {
-      format: VAL_COMP
-    });
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    });
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    });
-  }
-  [l, c, h] = transformXyzD50ToLch([x, y, z], true);
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-const convertColorToOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, a, b, alpha;
-  if (REG_OKLAB.test(value)) {
-    [, l, a, b, alpha] = parseOklab(value, {
-      format: VAL_COMP
-    });
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [l, a, b] = transformXyzToOklab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-const convertColorToOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "" } = opt;
-  let l, c, h, alpha;
-  if (REG_OKLCH.test(value)) {
-    [, l, c, h, alpha] = parseOklch(value, {
-      format: VAL_COMP
-    });
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value);
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value);
-  }
-  [l, c, h] = transformXyzToOklch([x, y, z], true);
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-const resolveColorMix = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = "", nullable = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveColorMix",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem;
-    }
-    return cachedItem;
-  }
-  const nestedItems = [];
-  let colorSpace = "";
-  let hueArc = "";
-  let colorA = "";
-  let pctA = "";
-  let colorB = "";
-  let pctB = "";
-  let parsed = false;
-  if (!REG_MIX.test(value)) {
-    if (value.startsWith(FN_MIX) && REG_MIX_NEST.test(value)) {
-      const regColorSpace = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);
-      const items = value.match(REG_MIX_NEST);
-      for (const item of items) {
-        if (item) {
-          let val = resolveColorMix(item, {
-            format: format === VAL_SPEC ? format : VAL_COMP
-          });
-          if (Array.isArray(val)) {
-            const [cs, v1, v2, v3, v4] = val;
-            if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {
-              value = "";
-              break;
-            }
-            if (regColorSpace.test(cs)) {
-              if (v4 === 1) {
-                val = `color(${cs} ${v1} ${v2} ${v3})`;
-              } else {
-                val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-              }
-            } else if (v4 === 1) {
-              val = `${cs}(${v1} ${v2} ${v3})`;
-            } else {
-              val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-            }
-          } else if (!REG_MIX.test(val)) {
-            value = "";
-            break;
-          }
-          nestedItems.push(val);
-          value = value.replace(item, val);
-        }
-      }
-      if (!value) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-    } else if (value.startsWith(FN_MIX) && value.endsWith(")") && value.includes(FN_LIGHT_DARK)) {
-      const regColorSpace = new RegExp(`in\\s+(${CS_MIX})`);
-      const colorParts = value.replace(FN_MIX, "").replace(/\)$/, "");
-      const [csPart = "", partA = "", partB = ""] = splitValue(colorParts, {
-        delimiter: ","
-      });
-      const [colorPartA = "", pctPartA = ""] = splitValue(partA);
-      const [colorPartB = "", pctPartB = ""] = splitValue(partB);
-      const specifiedColorA = resolveColor(colorPartA, {
-        format: VAL_SPEC
-      });
-      const specifiedColorB = resolveColor(colorPartB, {
-        format: VAL_SPEC
-      });
-      if (regColorSpace.test(csPart) && specifiedColorA && specifiedColorB) {
-        if (format === VAL_SPEC) {
-          const [, cs] = csPart.match(regColorSpace);
-          if (REG_CS_HUE.test(cs)) {
-            [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-          } else {
-            colorSpace = cs;
-          }
-          colorA = specifiedColorA;
-          if (pctPartA) {
-            pctA = pctPartA;
-          }
-          colorB = specifiedColorB;
-          if (pctPartB) {
-            pctB = pctPartB;
-          }
-          value = value.replace(colorPartA, specifiedColorA).replace(colorPartB, specifiedColorB);
-          parsed = true;
-        } else {
-          const resolvedColorA = resolveColor(colorPartA, opt);
-          const resolvedColorB = resolveColor(colorPartB, opt);
-          if (isString(resolvedColorA) && isString(resolvedColorB)) {
-            value = value.replace(colorPartA, resolvedColorA).replace(colorPartB, resolvedColorB);
-          }
-        }
-      } else {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-    } else {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-  }
-  if (nestedItems.length && format === VAL_SPEC) {
-    const regColorSpace = new RegExp(`^color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,`);
-    const [, cs] = value.match(regColorSpace);
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-    } else {
-      colorSpace = cs;
-    }
-    if (nestedItems.length === 2) {
-      let [itemA, itemB] = nestedItems;
-      itemA = itemA.replace(/(?=[()])/g, "\\");
-      itemB = itemB.replace(/(?=[()])/g, "\\");
-      const regA = new RegExp(`(${itemA})(?:\\s+(${PCT}))?`);
-      const regB = new RegExp(`(${itemB})(?:\\s+(${PCT}))?`);
-      [, colorA, pctA] = value.match(regA);
-      [, colorB, pctB] = value.match(regB);
-    } else {
-      let [item] = nestedItems;
-      item = item.replace(/(?=[()])/g, "\\");
-      const itemPart = `${item}(?:\\s+${PCT})?`;
-      const itemPartCapt = `(${item})(?:\\s+(${PCT}))?`;
-      const regItemPart = new RegExp(`^${itemPartCapt}$`);
-      const regLastItem = new RegExp(`${itemPartCapt}\\s*\\)$`);
-      const regColorPart = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-      if (regLastItem.test(value)) {
-        const reg = new RegExp(
-          `(${SYN_MIX_PART})\\s*,\\s*(${itemPart})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg);
-        [, colorA, pctA] = colorPartA.match(regColorPart);
-        [, colorB, pctB] = colorPartB.match(regItemPart);
-      } else {
-        const reg = new RegExp(
-          `(${itemPart})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg);
-        [, colorA, pctA] = colorPartA.match(regItemPart);
-        [, colorB, pctB] = colorPartB.match(regColorPart);
-      }
-    }
-  } else if (!parsed) {
-    const [, cs, colorPartA, colorPartB] = value.match(
-      REG_MIX_CAPT
-    );
-    const reg = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-    [, colorA, pctA] = colorPartA.match(reg);
-    [, colorB, pctB] = colorPartB.match(reg);
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE);
-    } else {
-      colorSpace = cs;
-    }
-  }
-  let pA, pB, m;
-  if (pctA && pctB) {
-    const p1 = parseFloat(pctA) / MAX_PCT;
-    const p2 = parseFloat(pctB) / MAX_PCT;
-    if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || p1 === 0 && p2 === 0) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const factor = p1 + p2;
-    pA = p1 / factor;
-    pB = p2 / factor;
-    m = factor < 1 ? factor : 1;
-  } else {
-    if (pctA) {
-      pA = parseFloat(pctA) / MAX_PCT;
-      if (pA < 0 || pA > 1) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-      pB = 1 - pA;
-    } else if (pctB) {
-      pB = parseFloat(pctB) / MAX_PCT;
-      if (pB < 0 || pB > 1) {
-        const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res2;
-      }
-      pA = 1 - pB;
-    } else {
-      pA = HALF;
-      pB = HALF;
-    }
-    m = 1;
-  }
-  if (colorSpace === "xyz") {
-    colorSpace = "xyz-d65";
-  }
-  if (format === VAL_SPEC) {
-    let valueA = "";
-    let valueB = "";
-    if (colorA.startsWith(FN_MIX) || colorA.startsWith(FN_LIGHT_DARK)) {
-      valueA = colorA;
-    } else if (colorA.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorA,
-        opt
-      );
-      if (v4 === 1) {
-        valueA = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorA, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === "rgb") {
-            valueA = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueA = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === "rgb") {
-          valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, "");
-          return "";
-        }
-        valueA = val;
-      }
-    }
-    if (colorB.startsWith(FN_MIX) || colorB.startsWith(FN_LIGHT_DARK)) {
-      valueB = colorB;
-    } else if (colorB.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorB,
-        opt
-      );
-      if (v4 === 1) {
-        valueB = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorB, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === "rgb") {
-            valueB = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueB = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === "rgb") {
-          valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, "");
-          return "";
-        }
-        valueB = val;
-      }
-    }
-    if (pctA && pctB) {
-      valueA += ` ${parseFloat(pctA)}%`;
-      valueB += ` ${parseFloat(pctB)}%`;
-    } else if (pctA) {
-      const pA2 = parseFloat(pctA);
-      if (pA2 !== MAX_PCT * HALF) {
-        valueA += ` ${pA2}%`;
-      }
-    } else if (pctB) {
-      const pA2 = MAX_PCT - parseFloat(pctB);
-      if (pA2 !== MAX_PCT * HALF) {
-        valueA += ` ${pA2}%`;
-      }
-    }
-    if (hueArc) {
-      const res2 = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res2);
-      return res2;
-    } else {
-      const res2 = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  }
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  if (/^srgb(?:-linear)?$/.test(colorSpace)) {
-    let rgbA, rgbB;
-    if (colorSpace === "srgb") {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToLinearRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToLinearRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (rgbA instanceof NullObject || rgbB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [rrA, ggA, bbA, aaA] = rgbA;
-    const [rrB, ggB, bbB, aaB] = rgbB;
-    const rNone = rrA === NONE && rrB === NONE;
-    const gNone = ggA === NONE && ggB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] = normalizeColorComponents(
-      [rrA, ggA, bbA, aaA],
-      [rrB, ggB, bbB, aaB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    if (alpha === 0) {
-      r = rA * pA + rB * pB;
-      g = gA * pA + gB * pB;
-      b = bA * pA + bB * pB;
-    } else {
-      r = (rA * factorA + rB * factorB) / alpha;
-      g = (gA * factorA + gB * factorB) / alpha;
-      b = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        rNone ? NONE : roundToPrecision(r, HEX),
-        gNone ? NONE : roundToPrecision(g, HEX),
-        bNone ? NONE : roundToPrecision(b, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    r *= MAX_RGB;
-    g *= MAX_RGB;
-    b *= MAX_RGB;
-  } else if (REG_CS_XYZ.test(colorSpace)) {
-    let xyzA, xyzB;
-    if (REG_CURRENT.test(colorA)) {
-      xyzA = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzA = convertColorToXyz(colorA, {
-        colorSpace,
-        d50: colorSpace === "xyz-d50",
-        format: VAL_MIX
-      });
-    }
-    if (REG_CURRENT.test(colorB)) {
-      xyzB = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzB = convertColorToXyz(colorB, {
-        colorSpace,
-        d50: colorSpace === "xyz-d50",
-        format: VAL_MIX
-      });
-    }
-    if (xyzA instanceof NullObject || xyzB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [xxA, yyA, zzA, aaA] = xyzA;
-    const [xxB, yyB, zzB, aaB] = xyzB;
-    const xNone = xxA === NONE && xxB === NONE;
-    const yNone = yyA === NONE && yyB === NONE;
-    const zNone = zzA === NONE && zzB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] = normalizeColorComponents(
-      [xxA, yyA, zzA, aaA],
-      [xxB, yyB, zzB, aaB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let x, y, z;
-    if (alpha === 0) {
-      x = xA * pA + xB * pB;
-      y = yA * pA + yB * pB;
-      z = zA * pA + zB * pB;
-    } else {
-      x = (xA * factorA + xB * factorB) / alpha;
-      y = (yA * factorA + yB * factorB) / alpha;
-      z = (zA * factorA + zB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        xNone ? NONE : roundToPrecision(x, HEX),
-        yNone ? NONE : roundToPrecision(y, HEX),
-        zNone ? NONE : roundToPrecision(z, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (colorSpace === "xyz-d50") {
-      [r, g, b] = transformXyzD50ToRgb([x, y, z], true);
-    } else {
-      [r, g, b] = transformXyzToRgb([x, y, z], true);
-    }
-  } else if (/^h(?:sl|wb)$/.test(colorSpace)) {
-    let hslA, hslB;
-    if (colorSpace === "hsl") {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHsl(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHsl(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHwb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHwb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (hslA instanceof NullObject || hslB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [hhA, ssA, llA, aaA] = hslA;
-    const [hhB, ssB, llB, aaB] = hslB;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents(
-      [hhA, ssA, llA, aaA],
-      [hhB, ssB, llB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let s, l;
-    if (alpha === 0) {
-      s = sA * pA + sB * pB;
-      l = lA * pA + lB * pB;
-    } else {
-      s = (sA * factorA + sB * factorB) / alpha;
-      l = (lA * factorA + lB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    [r, g, b] = convertColorToRgb(
-      `${colorSpace}(${h} ${s} ${l})`
-    );
-    if (format === VAL_COMP) {
-      const res2 = [
-        "srgb",
-        roundToPrecision(r / MAX_RGB, HEX),
-        roundToPrecision(g / MAX_RGB, HEX),
-        roundToPrecision(b / MAX_RGB, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (/^(?:ok)?lch$/.test(colorSpace)) {
-    let lchA, lchB;
-    if (colorSpace === "lch") {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToLch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToLch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToOklch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToOklch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (lchA instanceof NullObject || lchB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [llA, ccA, hhA, aaA] = lchA;
-    const [llB, ccB, hhB, aaB] = lchB;
-    const lNone = llA === NONE && llB === NONE;
-    const cNone = ccA === NONE && ccB === NONE;
-    const hNone = hhA === NONE && hhB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents(
-      [llA, ccA, hhA, aaA],
-      [llB, ccB, hhB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let l, c;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      c = cA * pA + cB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      c = (cA * factorA + cB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        cNone ? NONE : roundToPrecision(c, HEX),
-        hNone ? NONE : roundToPrecision(h, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${c} ${h})`
-    );
-  } else {
-    let labA, labB;
-    if (colorSpace === "lab") {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToLab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToLab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToOklab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToOklab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (labA instanceof NullObject || labB instanceof NullObject) {
-      const res2 = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res2;
-    }
-    const [llA, aaA, bbA, alA] = labA;
-    const [llB, aaB, bbB, alB] = labB;
-    const lNone = llA === NONE && llB === NONE;
-    const aNone = aaA === NONE && aaB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = alA === NONE && alB === NONE;
-    const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] = normalizeColorComponents(
-      [llA, aaA, bbA, alA],
-      [llB, aaB, bbB, alB],
-      true
-    );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let l, aO, bO;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      aO = aA * pA + aB * pB;
-      bO = bA * pA + bB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      aO = (aA * factorA + aB * factorB) / alpha;
-      bO = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res2 = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        aNone ? NONE : roundToPrecision(aO, HEX),
-        bNone ? NONE : roundToPrecision(bO, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${aO} ${bO})`
-    );
-  }
-  const res = [
-    "rgb",
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    parseFloat((alpha * m).toFixed(3))
-  ];
-  setCache(cacheKey, res);
-  return res;
-};
-export {
-  NAMED_COLORS,
-  angleToDeg,
-  cacheInvalidColorValue,
-  convertColorToHsl,
-  convertColorToHwb,
-  convertColorToLab,
-  convertColorToLch,
-  convertColorToLinearRgb,
-  convertColorToOklab,
-  convertColorToOklch,
-  convertColorToRgb,
-  convertColorToXyz,
-  convertHexToLinearRgb,
-  convertHexToRgb,
-  convertHexToXyz,
-  convertRgbToHex,
-  normalizeColorComponents,
-  numberToHexString,
-  parseAlpha,
-  parseColorFunc,
-  parseColorValue,
-  parseHexAlpha,
-  parseHsl,
-  parseHwb,
-  parseLab,
-  parseLch,
-  parseOklab,
-  parseOklch,
-  parseRgb,
-  resolveColorFunc,
-  resolveColorMix,
-  resolveColorValue,
-  resolveInvalidColorValue,
-  transformLinearRgbToRgb,
-  transformMatrix,
-  transformRgbToLinearRgb,
-  transformRgbToXyz,
-  transformXyzD50ToLab,
-  transformXyzD50ToLch,
-  transformXyzD50ToRgb,
-  transformXyzToHsl,
-  transformXyzToHwb,
-  transformXyzToOklab,
-  transformXyzToOklch,
-  transformXyzToRgb,
-  validateColorComponents
-};
-//# sourceMappingURL=color.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/common.d.ts

@@ -1,21 +0,0 @@
-/**
- * common
- */
-/**
- * get type
- * @param o - object to check
- * @returns type of object
- */
-export declare const getType: (o: unknown) => string;
-/**
- * is string
- * @param o - object to check
- * @returns result
- */
-export declare const isString: (o: unknown) => o is string;
-/**
- * is string or number
- * @param o - object to check
- * @returns result
- */
-export declare const isStringOrNumber: (o: unknown) => boolean;

node_modules/@asamuzakjp/css-color/dist/esm/js/common.js

@@ -1,7 +0,0 @@
-const isString = (o) => typeof o === "string" || o instanceof String;
-const isStringOrNumber = (o) => isString(o) || typeof o === "number";
-export {
-  isString,
-  isStringOrNumber
-};
-//# sourceMappingURL=common.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/common.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.js","sources":["../../../src/js/common.ts"],"sourcesContent":["/**\n * common\n */\n\n/* numeric constants */\nconst TYPE_FROM = 8;\nconst TYPE_TO = -1;\n\n/**\n * get type\n * @param o - object to check\n * @returns type of object\n */\nexport const getType = (o: unknown): string =>\n  Object.prototype.toString.call(o).slice(TYPE_FROM, TYPE_TO);\n\n/**\n * is string\n * @param o - object to check\n * @returns result\n */\nexport const isString = (o: unknown): o is string =>\n  typeof o === 'string' || o instanceof String;\n\n/**\n * is string or number\n * @param o - object to check\n * @returns result\n */\nexport const isStringOrNumber = (o: unknown): boolean =>\n  isString(o) || typeof o === 'number';\n"],"names":[],"mappings":"AAqBO,MAAM,WAAW,CAAC,MACvB,OAAO,MAAM,YAAY,aAAa;AAOjC,MAAM,mBAAmB,CAAC,MAC/B,SAAS,CAAC,KAAK,OAAO,MAAM;"}

node_modules/@asamuzakjp/css-color/dist/esm/js/constant.js

@@ -1,101 +0,0 @@
-const _DIGIT = "(?:0|[1-9]\\d*)";
-const _COMPARE = "clamp|max|min";
-const _EXPO = "exp|hypot|log|pow|sqrt";
-const _SIGN = "abs|sign";
-const _STEP = "mod|rem|round";
-const _TRIG = "a?(?:cos|sin|tan)|atan2";
-const _MATH = `${_COMPARE}|${_EXPO}|${_SIGN}|${_STEP}|${_TRIG}`;
-const _CALC = `calc|${_MATH}`;
-const _VAR = `var|${_CALC}`;
-const ANGLE = "deg|g?rad|turn";
-const LENGTH = "[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)";
-const NUM = `[+-]?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-const NUM_POSITIVE = `\\+?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-const NONE = "none";
-const PCT = `${NUM}%`;
-const SYN_FN_CALC = `^(?:${_CALC})\\(|(?<=[*\\/\\s\\(])(?:${_CALC})\\(`;
-const SYN_FN_MATH_START = `^(?:${_MATH})\\($`;
-const SYN_FN_VAR = "^var\\(|(?<=[*\\/\\s\\(])var\\(";
-const SYN_FN_VAR_START = `^(?:${_VAR})\\(`;
-const _ALPHA = `(?:\\s*\\/\\s*(?:${NUM}|${PCT}|${NONE}))?`;
-const _ALPHA_LV3 = `(?:\\s*,\\s*(?:${NUM}|${PCT}))?`;
-const _COLOR_FUNC = "(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?";
-const _COLOR_KEY = "[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}";
-const _CS_HUE = "(?:ok)?lch|hsl|hwb";
-const _CS_HUE_ARC = "(?:de|in)creasing|longer|shorter";
-const _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;
-const _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;
-const _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;
-const CS_HUE = `(?:${_CS_HUE})(?:\\s(?:${_CS_HUE_ARC})\\shue)?`;
-const CS_HUE_CAPT = `(${_CS_HUE})(?:\\s(${_CS_HUE_ARC})\\shue)?`;
-const CS_LAB = "(?:ok)?lab";
-const CS_LCH = "(?:ok)?lch";
-const CS_SRGB = "srgb(?:-linear)?";
-const CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|${CS_SRGB}`;
-const CS_XYZ = "xyz(?:-d(?:50|65))?";
-const CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;
-const CS_MIX = `${CS_HUE}|${CS_RECT}`;
-const FN_COLOR = "color(";
-const FN_LIGHT_DARK = "light-dark(";
-const FN_MIX = "color-mix(";
-const FN_REL = `(?:${_COLOR_FUNC})\\(\\s*from\\s+`;
-const FN_REL_CAPT = `(${_COLOR_FUNC})\\(\\s*from\\s+`;
-const FN_VAR = "var(";
-const SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;
-const SYN_FN_LIGHT_DARK = "^light-dark\\(";
-const SYN_FN_REL = `^${FN_REL}|(?<=[\\s])${FN_REL}`;
-const SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-const SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\s*,\\s*${PCT}){2}${_ALPHA_LV3}`;
-const SYN_LCH = `(?:${_NUM_PCT_NONE}\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;
-const SYN_MOD = `${_NUM_PCT_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-const SYN_RGB_LV3 = `(?:${NUM}(?:\\s*,\\s*${NUM}){2}|${PCT}(?:\\s*,\\s*${PCT}){2})${_ALPHA_LV3}`;
-const SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\(\\s*${SYN_HSL_LV3}\\s*\\)|rgba?\\(\\s*${SYN_RGB_LV3}\\s*\\)|(?:hsla?|hwb)\\(\\s*${SYN_HSL}\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*${SYN_MOD}\\s*\\)|(?:ok)?lch\\(\\s*${SYN_LCH}\\s*\\)|color\\(\\s*${SYN_FN_COLOR}\\s*\\)`;
-const SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\s+${PCT})?`;
-const SYN_MIX = `color-mix\\(\\s*in\\s+(?:${CS_MIX})\\s*,\\s*${SYN_MIX_PART}\\s*,\\s*${SYN_MIX_PART}\\s*\\)`;
-const SYN_MIX_CAPT = `color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,\\s*(${SYN_MIX_PART})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)`;
-const VAL_COMP = "computedValue";
-const VAL_MIX = "mixValue";
-const VAL_SPEC = "specifiedValue";
-export {
-  ANGLE,
-  CS_HUE,
-  CS_HUE_CAPT,
-  CS_LAB,
-  CS_LCH,
-  CS_MIX,
-  CS_RECT,
-  CS_RGB,
-  CS_SRGB,
-  CS_XYZ,
-  FN_COLOR,
-  FN_LIGHT_DARK,
-  FN_MIX,
-  FN_REL,
-  FN_REL_CAPT,
-  FN_VAR,
-  LENGTH,
-  NONE,
-  NUM,
-  NUM_POSITIVE,
-  PCT,
-  SYN_COLOR_TYPE,
-  SYN_FN_CALC,
-  SYN_FN_COLOR,
-  SYN_FN_LIGHT_DARK,
-  SYN_FN_MATH_START,
-  SYN_FN_REL,
-  SYN_FN_VAR,
-  SYN_FN_VAR_START,
-  SYN_HSL,
-  SYN_HSL_LV3,
-  SYN_LCH,
-  SYN_MIX,
-  SYN_MIX_CAPT,
-  SYN_MIX_PART,
-  SYN_MOD,
-  SYN_RGB_LV3,
-  VAL_COMP,
-  VAL_MIX,
-  VAL_SPEC
-};
-//# sourceMappingURL=constant.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/convert.d.ts

@@ -1,99 +0,0 @@
-import { NullObject } from './cache.js';
-import { ColorChannels, Options } from './typedef.js';
-/**
- * pre process
- * @param value - CSS color value
- * @param [opt] - options
- * @returns value
- */
-export declare const preProcess: (value: string, opt?: Options) => string | NullObject;
-/**
- * convert number to hex string
- * @param value - numeric value
- * @returns hex string: 00..ff
- */
-export declare const numberToHex: (value: number) => string;
-/**
- * convert color to hex
- * @param value - CSS color value
- * @param [opt] - options
- * @param [opt.alpha] - enable alpha channel
- * @returns #rrggbb | #rrggbbaa | null
- */
-export declare const colorToHex: (value: string, opt?: Options) => string | null;
-/**
- * convert color to hsl
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [h, s, l, alpha]
- */
-export declare const colorToHsl: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to hwb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [h, w, b, alpha]
- */
-export declare const colorToHwb: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to lab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, a, b, alpha]
- */
-export declare const colorToLab: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to lch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, c, h, alpha]
- */
-export declare const colorToLch: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to oklab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, a, b, alpha]
- */
-export declare const colorToOklab: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to oklch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, c, h, alpha]
- */
-export declare const colorToOklch: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [r, g, b, alpha]
- */
-export declare const colorToRgb: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to xyz
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export declare const colorToXyz: (value: string, opt?: Options) => ColorChannels;
-/**
- * convert color to xyz-d50
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export declare const colorToXyzD50: (value: string, opt?: Options) => ColorChannels;
-export declare const convert: {
-    colorToHex: (value: string, opt?: Options) => string | null;
-    colorToHsl: (value: string, opt?: Options) => ColorChannels;
-    colorToHwb: (value: string, opt?: Options) => ColorChannels;
-    colorToLab: (value: string, opt?: Options) => ColorChannels;
-    colorToLch: (value: string, opt?: Options) => ColorChannels;
-    colorToOklab: (value: string, opt?: Options) => ColorChannels;
-    colorToOklch: (value: string, opt?: Options) => ColorChannels;
-    colorToRgb: (value: string, opt?: Options) => ColorChannels;
-    colorToXyz: (value: string, opt?: Options) => ColorChannels;
-    colorToXyzD50: (value: string, opt?: Options) => ColorChannels;
-    numberToHex: (value: number) => string;
-};

node_modules/@asamuzakjp/css-color/dist/esm/js/convert.js

@@ -1,361 +0,0 @@
-import { NullObject, createCacheKey, getCache, CacheItem, setCache } from "./cache.js";
-import { numberToHexString, parseColorFunc, parseColorValue, convertColorToRgb, convertColorToOklch, convertColorToOklab, convertColorToLch, convertColorToLab, convertColorToHwb, convertColorToHsl } from "./color.js";
-import { isString } from "./common.js";
-import { cssCalc } from "./css-calc.js";
-import { resolveVar } from "./css-var.js";
-import { resolveRelativeColor } from "./relative-color.js";
-import { resolveColor } from "./resolve.js";
-import { VAL_COMP, SYN_FN_VAR, SYN_FN_REL, SYN_FN_CALC } from "./constant.js";
-const NAMESPACE = "convert";
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_REL = new RegExp(SYN_FN_REL);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-const preProcess = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-    if (!value) {
-      return new NullObject();
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "preProcess",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (REG_FN_VAR.test(value)) {
-    const resolvedValue = resolveVar(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  if (REG_FN_REL.test(value)) {
-    const resolvedValue = resolveRelativeColor(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  } else if (REG_FN_CALC.test(value)) {
-    value = cssCalc(value, opt);
-  }
-  if (value.startsWith("color-mix")) {
-    const clonedOpt = structuredClone(opt);
-    clonedOpt.format = VAL_COMP;
-    clonedOpt.nullable = true;
-    const resolvedValue = resolveColor(value, clonedOpt);
-    setCache(cacheKey, resolvedValue);
-    return resolvedValue;
-  }
-  setCache(cacheKey, value);
-  return value;
-};
-const numberToHex = (value) => {
-  const hex = numberToHexString(value);
-  return hex;
-};
-const colorToHex = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return null;
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { alpha = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToHex",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return null;
-    }
-    return cachedResult.item;
-  }
-  let hex;
-  opt.nullable = true;
-  if (alpha) {
-    opt.format = "hexAlpha";
-    hex = resolveColor(value, opt);
-  } else {
-    opt.format = "hex";
-    hex = resolveColor(value, opt);
-  }
-  if (isString(hex)) {
-    setCache(cacheKey, hex);
-    return hex;
-  }
-  setCache(cacheKey, null);
-  return null;
-};
-const colorToHsl = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToHsl",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  opt.format = "hsl";
-  const hsl = convertColorToHsl(value, opt);
-  setCache(cacheKey, hsl);
-  return hsl;
-};
-const colorToHwb = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToHwb",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  opt.format = "hwb";
-  const hwb = convertColorToHwb(value, opt);
-  setCache(cacheKey, hwb);
-  return hwb;
-};
-const colorToLab = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToLab",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lab = convertColorToLab(value, opt);
-  setCache(cacheKey, lab);
-  return lab;
-};
-const colorToLch = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToLch",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lch = convertColorToLch(value, opt);
-  setCache(cacheKey, lch);
-  return lch;
-};
-const colorToOklab = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToOklab",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lab = convertColorToOklab(value, opt);
-  setCache(cacheKey, lab);
-  return lab;
-};
-const colorToOklch = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToOklch",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const lch = convertColorToOklch(value, opt);
-  setCache(cacheKey, lch);
-  return lch;
-};
-const colorToRgb = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToRgb",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const rgb = convertColorToRgb(value, opt);
-  setCache(cacheKey, rgb);
-  return rgb;
-};
-const colorToXyz = (value, opt = {}) => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "colorToXyz",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  let xyz;
-  if (value.startsWith("color(")) {
-    [, ...xyz] = parseColorFunc(value, opt);
-  } else {
-    [, ...xyz] = parseColorValue(value, opt);
-  }
-  setCache(cacheKey, xyz);
-  return xyz;
-};
-const colorToXyzD50 = (value, opt = {}) => {
-  opt.d50 = true;
-  return colorToXyz(value, opt);
-};
-const convert = {
-  colorToHex,
-  colorToHsl,
-  colorToHwb,
-  colorToLab,
-  colorToLch,
-  colorToOklab,
-  colorToOklch,
-  colorToRgb,
-  colorToXyz,
-  colorToXyzD50,
-  numberToHex
-};
-export {
-  colorToHex,
-  colorToHsl,
-  colorToHwb,
-  colorToLab,
-  colorToLch,
-  colorToOklab,
-  colorToOklch,
-  colorToRgb,
-  colorToXyz,
-  colorToXyzD50,
-  convert,
-  numberToHex,
-  preProcess
-};
-//# sourceMappingURL=convert.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.d.ts

@@ -1,89 +0,0 @@
-import { CSSToken } from '@csstools/css-tokenizer';
-import { NullObject } from './cache.js';
-import { Options } from './typedef.js';
-/**
- * Calclator
- */
-export declare class Calculator {
-    #private;
-    /**
-     * constructor
-     */
-    constructor();
-    get hasNum(): boolean;
-    set hasNum(value: boolean);
-    get numSum(): number[];
-    get numMul(): number[];
-    get hasPct(): boolean;
-    set hasPct(value: boolean);
-    get pctSum(): number[];
-    get pctMul(): number[];
-    get hasDim(): boolean;
-    set hasDim(value: boolean);
-    get dimSum(): string[];
-    get dimSub(): string[];
-    get dimMul(): string[];
-    get dimDiv(): string[];
-    get hasEtc(): boolean;
-    set hasEtc(value: boolean);
-    get etcSum(): string[];
-    get etcSub(): string[];
-    get etcMul(): string[];
-    get etcDiv(): string[];
-    /**
-     * clear values
-     * @returns void
-     */
-    clear(): void;
-    /**
-     * sort values
-     * @param values - values
-     * @returns sorted values
-     */
-    sort(values?: string[]): string[];
-    /**
-     * multiply values
-     * @returns resolved value
-     */
-    multiply(): string;
-    /**
-     * sum values
-     * @returns resolved value
-     */
-    sum(): string;
-}
-/**
- * sort calc values
- * @param values - values to sort
- * @param [finalize] - finalize values
- * @returns sorted values
- */
-export declare const sortCalcValues: (values?: (number | string)[], finalize?: boolean) => string;
-/**
- * serialize calc
- * @param value - CSS value
- * @param [opt] - options
- * @returns serialized value
- */
-export declare const serializeCalc: (value: string, opt?: Options) => string;
-/**
- * resolve dimension
- * @param token - CSS token
- * @param [opt] - options
- * @returns resolved value
- */
-export declare const resolveDimension: (token: CSSToken, opt?: Options) => string | NullObject;
-/**
- * parse tokens
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns parsed tokens
- */
-export declare const parseTokens: (tokens: CSSToken[], opt?: Options) => string[];
-/**
- * CSS calc()
- * @param value - CSS value including calc()
- * @param [opt] - options
- * @returns resolved value
- */
-export declare const cssCalc: (value: string, opt?: Options) => string;

node_modules/@asamuzakjp/css-color/dist/esm/js/css-calc.js

@@ -1,826 +0,0 @@
-import { calc } from "@csstools/css-calc";
-import { TokenType, tokenize } from "@csstools/css-tokenizer";
-import { createCacheKey, getCache, CacheItem, setCache, NullObject } from "./cache.js";
-import { isString, isStringOrNumber } from "./common.js";
-import { resolveVar } from "./css-var.js";
-import { roundToPrecision, resolveLengthInPixels } from "./util.js";
-import { VAL_SPEC, SYN_FN_VAR, SYN_FN_CALC, SYN_FN_VAR_START, NUM, ANGLE, LENGTH, SYN_FN_MATH_START } from "./constant.js";
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  Dimension: DIM,
-  EOF,
-  Function: FUNC,
-  OpenParen: PAREN_OPEN,
-  Whitespace: W_SPACE
-} = TokenType;
-const NAMESPACE = "css-calc";
-const TRIA = 3;
-const HEX = 16;
-const MAX_PCT = 100;
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_CALC_NUM = new RegExp(`^calc\\((${NUM})\\)$`);
-const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-const REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);
-const REG_OPERATOR = /\s[*+/-]\s/;
-const REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);
-const REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);
-const REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);
-class Calculator {
-  /* private */
-  // number
-  #hasNum;
-  #numSum;
-  #numMul;
-  // percentage
-  #hasPct;
-  #pctSum;
-  #pctMul;
-  // dimension
-  #hasDim;
-  #dimSum;
-  #dimSub;
-  #dimMul;
-  #dimDiv;
-  // et cetra
-  #hasEtc;
-  #etcSum;
-  #etcSub;
-  #etcMul;
-  #etcDiv;
-  /**
-   * constructor
-   */
-  constructor() {
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-  get hasNum() {
-    return this.#hasNum;
-  }
-  set hasNum(value) {
-    this.#hasNum = !!value;
-  }
-  get numSum() {
-    return this.#numSum;
-  }
-  get numMul() {
-    return this.#numMul;
-  }
-  get hasPct() {
-    return this.#hasPct;
-  }
-  set hasPct(value) {
-    this.#hasPct = !!value;
-  }
-  get pctSum() {
-    return this.#pctSum;
-  }
-  get pctMul() {
-    return this.#pctMul;
-  }
-  get hasDim() {
-    return this.#hasDim;
-  }
-  set hasDim(value) {
-    this.#hasDim = !!value;
-  }
-  get dimSum() {
-    return this.#dimSum;
-  }
-  get dimSub() {
-    return this.#dimSub;
-  }
-  get dimMul() {
-    return this.#dimMul;
-  }
-  get dimDiv() {
-    return this.#dimDiv;
-  }
-  get hasEtc() {
-    return this.#hasEtc;
-  }
-  set hasEtc(value) {
-    this.#hasEtc = !!value;
-  }
-  get etcSum() {
-    return this.#etcSum;
-  }
-  get etcSub() {
-    return this.#etcSub;
-  }
-  get etcMul() {
-    return this.#etcMul;
-  }
-  get etcDiv() {
-    return this.#etcDiv;
-  }
-  /**
-   * clear values
-   * @returns void
-   */
-  clear() {
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-  /**
-   * sort values
-   * @param values - values
-   * @returns sorted values
-   */
-  sort(values = []) {
-    const arr = [...values];
-    if (arr.length > 1) {
-      arr.sort((a, b) => {
-        let res;
-        if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {
-          const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT);
-          const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT);
-          if (unitA === unitB) {
-            if (Number(valA) === Number(valB)) {
-              res = 0;
-            } else if (Number(valA) > Number(valB)) {
-              res = 1;
-            } else {
-              res = -1;
-            }
-          } else if (unitA > unitB) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        } else {
-          if (a === b) {
-            res = 0;
-          } else if (a > b) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        }
-        return res;
-      });
-    }
-    return arr;
-  }
-  /**
-   * multiply values
-   * @returns resolved value
-   */
-  multiply() {
-    const value = [];
-    let num;
-    if (this.#hasNum) {
-      num = 1;
-      for (const i of this.#numMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {
-        if (Number.isFinite(num)) {
-          num = roundToPrecision(num, HEX);
-        }
-        value.push(num);
-      }
-    }
-    if (this.#hasPct) {
-      if (typeof num !== "number") {
-        num = 1;
-      }
-      for (const i of this.#pctMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${roundToPrecision(num, HEX)}%`;
-      }
-      if (!this.#hasDim && !this.hasEtc) {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim = "";
-      let mul = "";
-      let div = "";
-      if (this.#dimMul.length) {
-        if (this.#dimMul.length === 1) {
-          [mul] = this.#dimMul;
-        } else {
-          mul = `${this.sort(this.#dimMul).join(" * ")}`;
-        }
-      }
-      if (this.#dimDiv.length) {
-        if (this.#dimDiv.length === 1) {
-          [div] = this.#dimDiv;
-        } else {
-          div = `${this.sort(this.#dimDiv).join(" * ")}`;
-        }
-      }
-      if (Number.isFinite(num)) {
-        if (mul) {
-          if (div) {
-            if (div.includes("*")) {
-              dim = calc(`calc(${num} * ${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = calc(`calc(${num} * ${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = calc(`calc(${num} * ${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else if (div.includes("*")) {
-          dim = calc(`calc(${num} / (${div}))`, {
-            toCanonicalUnits: true
-          });
-        } else {
-          dim = calc(`calc(${num} / ${div})`, {
-            toCanonicalUnits: true
-          });
-        }
-        value.push(dim.replace(/^calc/, ""));
-      } else {
-        if (!value.length && num !== void 0) {
-          value.push(num);
-        }
-        if (mul) {
-          if (div) {
-            if (div.includes("*")) {
-              dim = calc(`calc(${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = calc(`calc(${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = calc(`calc(${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-          if (value.length) {
-            value.push("*", dim.replace(/^calc/, ""));
-          } else {
-            value.push(dim.replace(/^calc/, ""));
-          }
-        } else {
-          dim = calc(`calc(${div})`, {
-            toCanonicalUnits: true
-          });
-          if (value.length) {
-            value.push("/", dim.replace(/^calc/, ""));
-          } else {
-            value.push("1", "/", dim.replace(/^calc/, ""));
-          }
-        }
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcMul.length) {
-        if (!value.length && num !== void 0) {
-          value.push(num);
-        }
-        const mul = this.sort(this.#etcMul).join(" * ");
-        if (value.length) {
-          value.push(`* ${mul}`);
-        } else {
-          value.push(`${mul}`);
-        }
-      }
-      if (this.#etcDiv.length) {
-        const div = this.sort(this.#etcDiv).join(" * ");
-        if (div.includes("*")) {
-          if (value.length) {
-            value.push(`/ (${div})`);
-          } else {
-            value.push(`1 / (${div})`);
-          }
-        } else if (value.length) {
-          value.push(`/ ${div}`);
-        } else {
-          value.push(`1 / ${div}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(" ");
-    }
-    return "";
-  }
-  /**
-   * sum values
-   * @returns resolved value
-   */
-  sum() {
-    const value = [];
-    if (this.#hasNum) {
-      let num = 0;
-      for (const i of this.#numSum) {
-        num += i;
-        if (!Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      value.push(num);
-    }
-    if (this.#hasPct) {
-      let num = 0;
-      for (const i of this.#pctSum) {
-        num += i;
-        if (!Number.isFinite(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${num}%`;
-      }
-      if (value.length) {
-        value.push(`+ ${num}`);
-      } else {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim, sum, sub;
-      if (this.#dimSum.length) {
-        sum = this.sort(this.#dimSum).join(" + ");
-      }
-      if (this.#dimSub.length) {
-        sub = this.sort(this.#dimSub).join(" + ");
-      }
-      if (sum) {
-        if (sub) {
-          if (sub.includes("-")) {
-            dim = calc(`calc(${sum} - (${sub}))`, {
-              toCanonicalUnits: true
-            });
-          } else {
-            dim = calc(`calc(${sum} - ${sub})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else {
-          dim = calc(`calc(${sum})`, {
-            toCanonicalUnits: true
-          });
-        }
-      } else {
-        dim = calc(`calc(-1 * (${sub}))`, {
-          toCanonicalUnits: true
-        });
-      }
-      if (value.length) {
-        value.push("+", dim.replace(/^calc/, ""));
-      } else {
-        value.push(dim.replace(/^calc/, ""));
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcSum.length) {
-        const sum = this.sort(this.#etcSum).map((item) => {
-          let res;
-          if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) {
-            res = `(${item})`;
-          } else {
-            res = item;
-          }
-          return res;
-        }).join(" + ");
-        if (value.length) {
-          if (this.#etcSum.length > 1) {
-            value.push(`+ (${sum})`);
-          } else {
-            value.push(`+ ${sum}`);
-          }
-        } else {
-          value.push(`${sum}`);
-        }
-      }
-      if (this.#etcSub.length) {
-        const sub = this.sort(this.#etcSub).map((item) => {
-          let res;
-          if (REG_OPERATOR.test(item) && !item.startsWith("(") && !item.endsWith(")")) {
-            res = `(${item})`;
-          } else {
-            res = item;
-          }
-          return res;
-        }).join(" + ");
-        if (value.length) {
-          if (this.#etcSub.length > 1) {
-            value.push(`- (${sub})`);
-          } else {
-            value.push(`- ${sub}`);
-          }
-        } else if (this.#etcSub.length > 1) {
-          value.push(`-1 * (${sub})`);
-        } else {
-          value.push(`-1 * ${sub}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(" ");
-    }
-    return "";
-  }
-}
-const sortCalcValues = (values = [], finalize = false) => {
-  if (values.length < TRIA) {
-    throw new Error(`Unexpected array length ${values.length}.`);
-  }
-  const start = values.shift();
-  if (!isString(start) || !start.endsWith("(")) {
-    throw new Error(`Unexpected token ${start}.`);
-  }
-  const end = values.pop();
-  if (end !== ")") {
-    throw new Error(`Unexpected token ${end}.`);
-  }
-  if (values.length === 1) {
-    const [value] = values;
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    return `${start}${value}${end}`;
-  }
-  const sortedValues = [];
-  const cal = new Calculator();
-  let operator = "";
-  const l = values.length;
-  for (let i = 0; i < l; i++) {
-    const value = values[i];
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    if (value === "*" || value === "/") {
-      operator = value;
-    } else if (value === "+" || value === "-") {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue, value);
-      }
-      cal.clear();
-      operator = "";
-    } else {
-      const numValue = Number(value);
-      const strValue = `${value}`;
-      switch (operator) {
-        case "/": {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(1 / numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT);
-            cal.hasPct = true;
-            cal.pctMul.push(MAX_PCT * MAX_PCT / Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimDiv.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcDiv.push(strValue);
-          }
-          break;
-        }
-        case "*":
-        default: {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT);
-            cal.hasPct = true;
-            cal.pctMul.push(Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimMul.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcMul.push(strValue);
-          }
-        }
-      }
-    }
-    if (i === l - 1) {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue);
-      }
-      cal.clear();
-      operator = "";
-    }
-  }
-  let resolvedValue = "";
-  if (finalize && (sortedValues.includes("+") || sortedValues.includes("-"))) {
-    const finalizedValues = [];
-    cal.clear();
-    operator = "";
-    const l2 = sortedValues.length;
-    for (let i = 0; i < l2; i++) {
-      const value = sortedValues[i];
-      if (isStringOrNumber(value)) {
-        if (value === "+" || value === "-") {
-          operator = value;
-        } else {
-          const numValue = Number(value);
-          const strValue = `${value}`;
-          switch (operator) {
-            case "-": {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(-1 * numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT);
-                cal.hasPct = true;
-                cal.pctSum.push(-1 * Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSub.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSub.push(strValue);
-              }
-              break;
-            }
-            case "+":
-            default: {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT);
-                cal.hasPct = true;
-                cal.pctSum.push(Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSum.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSum.push(strValue);
-              }
-            }
-          }
-        }
-      }
-      if (i === l2 - 1) {
-        const sortedValue = cal.sum();
-        if (sortedValue) {
-          finalizedValues.push(sortedValue);
-        }
-        cal.clear();
-        operator = "";
-      }
-    }
-    resolvedValue = finalizedValues.join(" ").replace(/\+\s-/g, "- ");
-  } else {
-    resolvedValue = sortedValues.join(" ").replace(/\+\s-/g, "- ");
-  }
-  if (resolvedValue.startsWith("(") && resolvedValue.endsWith(")") && resolvedValue.lastIndexOf("(") === 0 && resolvedValue.indexOf(")") === resolvedValue.length - 1) {
-    resolvedValue = resolvedValue.replace(/^\(/, "").replace(/\)$/, "");
-  }
-  return `${start}${resolvedValue}${end}`;
-};
-const serializeCalc = (value, opt = {}) => {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR_START.test(value) || format !== VAL_SPEC) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "serializeCalc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const items = tokenize({ css: value }).map((token) => {
-    const [type, value2] = token;
-    let res = "";
-    if (type !== W_SPACE && type !== COMMENT) {
-      res = value2;
-    }
-    return res;
-  }).filter((v) => v);
-  let startIndex = items.findLastIndex((item) => /\($/.test(item));
-  while (startIndex) {
-    const endIndex = items.findIndex((item, index) => {
-      return item === ")" && index > startIndex;
-    });
-    const slicedValues = items.slice(startIndex, endIndex + 1);
-    let serializedValue = sortCalcValues(slicedValues);
-    if (REG_FN_VAR_START.test(serializedValue)) {
-      serializedValue = calc(serializedValue, {
-        toCanonicalUnits: true
-      });
-    }
-    items.splice(startIndex, endIndex - startIndex + 1, serializedValue);
-    startIndex = items.findLastIndex((item) => /\($/.test(item));
-  }
-  const serializedCalc = sortCalcValues(items, true);
-  setCache(cacheKey, serializedCalc);
-  return serializedCalc;
-};
-const resolveDimension = (token, opt = {}) => {
-  if (!Array.isArray(token)) {
-    throw new TypeError(`${token} is not an array.`);
-  }
-  const [, , , , detail = {}] = token;
-  const { unit, value } = detail;
-  if (unit === "px") {
-    return `${value}${unit}`;
-  }
-  const pixelValue = resolveLengthInPixels(Number(value), unit, opt);
-  if (Number.isFinite(pixelValue)) {
-    return `${roundToPrecision(pixelValue, HEX)}px`;
-  }
-  return new NullObject();
-};
-const parseTokens = (tokens, opt = {}) => {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { format = "" } = opt;
-  const mathFunc = /* @__PURE__ */ new Set();
-  let nest = 0;
-  const res = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type = "", value = ""] = token;
-    switch (type) {
-      case DIM: {
-        if (format === VAL_SPEC && !mathFunc.has(nest)) {
-          res.push(value);
-        } else {
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            res.push(resolvedValue);
-          } else {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      case FUNC:
-      case PAREN_OPEN: {
-        res.push(value);
-        nest++;
-        if (REG_FN_MATH_START.test(value)) {
-          mathFunc.add(nest);
-        }
-        break;
-      }
-      case PAREN_CLOSE: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (lastValue === " ") {
-            res.splice(-1, 1, value);
-          } else {
-            res.push(value);
-          }
-        } else {
-          res.push(value);
-        }
-        if (mathFunc.has(nest)) {
-          mathFunc.delete(nest);
-        }
-        nest--;
-        break;
-      }
-      case W_SPACE: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      default: {
-        if (type !== COMMENT && type !== EOF) {
-          res.push(value);
-        }
-      }
-    }
-  }
-  return res;
-};
-const cssCalc = (value, opt = {}) => {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      } else {
-        const resolvedValue2 = resolveVar(value, opt);
-        if (isString(resolvedValue2)) {
-          return resolvedValue2;
-        } else {
-          return "";
-        }
-      }
-    } else if (!REG_FN_CALC.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "cssCalc",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const tokens = tokenize({ css: value });
-  const values = parseTokens(tokens, opt);
-  let resolvedValue = calc(values.join(""), {
-    toCanonicalUnits: true
-  });
-  if (REG_FN_VAR_START.test(value)) {
-    if (REG_TYPE_DIM_PCT.test(resolvedValue)) {
-      const [, val, unit] = resolvedValue.match(
-        REG_TYPE_DIM_PCT
-      );
-      resolvedValue = `${roundToPrecision(Number(val), HEX)}${unit}`;
-    }
-    if (resolvedValue && !REG_FN_VAR_START.test(resolvedValue) && format === VAL_SPEC) {
-      resolvedValue = `calc(${resolvedValue})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    if (/\s[-+*/]\s/.test(resolvedValue) && !resolvedValue.includes("NaN")) {
-      resolvedValue = serializeCalc(resolvedValue, opt);
-    } else if (REG_FN_CALC_NUM.test(resolvedValue)) {
-      const [, val] = resolvedValue.match(REG_FN_CALC_NUM);
-      resolvedValue = `calc(${roundToPrecision(Number(val), HEX)})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-};
-export {
-  Calculator,
-  cssCalc,
-  parseTokens,
-  resolveDimension,
-  serializeCalc,
-  sortCalcValues
-};
-//# sourceMappingURL=css-calc.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.d.ts

@@ -1,79 +0,0 @@
-import { Options } from './typedef.js';
-/**
- * @type ColorStopList - list of color stops
- */
-type ColorStopList = [string, string, ...string[]];
-/**
- * @typedef ValidateGradientLine - validate gradient line
- * @property line - gradient line
- * @property valid - result
- */
-interface ValidateGradientLine {
-    line: string;
-    valid: boolean;
-}
-/**
- * @typedef ValidateColorStops - validate color stops
- * @property colorStops - list of color stops
- * @property valid - result
- */
-interface ValidateColorStops {
-    colorStops: string[];
-    valid: boolean;
-}
-/**
- * @typedef Gradient - parsed CSS gradient
- * @property value - input value
- * @property type - gradient type
- * @property [gradientLine] - gradient line
- * @property colorStopList - list of color stops
- */
-interface Gradient {
-    value: string;
-    type: string;
-    gradientLine?: string;
-    colorStopList: ColorStopList;
-}
-/**
- * get gradient type
- * @param value - gradient value
- * @returns gradient type
- */
-export declare const getGradientType: (value: string) => string;
-/**
- * validate gradient line
- * @param value - gradient line value
- * @param type - gradient type
- * @returns result
- */
-export declare const validateGradientLine: (value: string, type: string) => ValidateGradientLine;
-/**
- * validate color stop list
- * @param list
- * @param type
- * @param [opt]
- * @returns result
- */
-export declare const validateColorStopList: (list: string[], type: string, opt?: Options) => ValidateColorStops;
-/**
- * parse CSS gradient
- * @param value - gradient value
- * @param [opt] - options
- * @returns parsed result
- */
-export declare const parseGradient: (value: string, opt?: Options) => Gradient | null;
-/**
- * resolve CSS gradient
- * @param value - CSS value
- * @param [opt] - options
- * @returns result
- */
-export declare const resolveGradient: (value: string, opt?: Options) => string;
-/**
- * is CSS gradient
- * @param value - CSS value
- * @param [opt] - options
- * @returns result
- */
-export declare const isGradient: (value: string, opt?: Options) => boolean;
-export {};

node_modules/@asamuzakjp/css-color/dist/esm/js/css-gradient.js

@@ -1,261 +0,0 @@
-import { createCacheKey, getCache, CacheItem, setCache } from "./cache.js";
-import { resolveColor } from "./resolve.js";
-import { isString } from "./common.js";
-import { splitValue, isColor } from "./util.js";
-import { VAL_COMP, VAL_SPEC, NUM, ANGLE, PCT, LENGTH, CS_RECT, CS_HUE, NUM_POSITIVE } from "./constant.js";
-const NAMESPACE = "css-gradient";
-const DIM_ANGLE = `${NUM}(?:${ANGLE})`;
-const DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;
-const DIM_LEN = `${NUM}(?:${LENGTH})|0`;
-const DIM_LEN_PCT = `${DIM_LEN}|${PCT}`;
-const DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;
-const DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;
-const CTR = "center";
-const L_R = "left|right";
-const T_B = "top|bottom";
-const S_E = "start|end";
-const AXIS_X = `${L_R}|x-(?:${S_E})`;
-const AXIS_Y = `${T_B}|y-(?:${S_E})`;
-const BLOCK = `block-(?:${S_E})`;
-const INLINE = `inline-(?:${S_E})`;
-const POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;
-const POS_2 = [
-  `(?:${CTR}|${AXIS_X})\\s+(?:${CTR}|${AXIS_Y})`,
-  `(?:${CTR}|${AXIS_Y})\\s+(?:${CTR}|${AXIS_X})`,
-  `(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,
-  `(?:${CTR}|${BLOCK})\\s+(?:${CTR}|${INLINE})`,
-  `(?:${CTR}|${INLINE})\\s+(?:${CTR}|${BLOCK})`,
-  `(?:${CTR}|${S_E})\\s+(?:${CTR}|${S_E})`
-].join("|");
-const POS_4 = [
-  `(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})\\s+(?:${INLINE})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${INLINE})\\s+(?:${DIM_LEN_PCT})\\s+(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${S_E})\\s+(?:${DIM_LEN_PCT})\\s+(?:${S_E})\\s+(?:${DIM_LEN_PCT})`
-].join("|");
-const RAD_EXTENT = "(?:clos|farth)est-(?:corner|side)";
-const RAD_SIZE = [
-  `${RAD_EXTENT}(?:\\s+${RAD_EXTENT})?`,
-  `${DIM_LEN_POSI}`,
-  `(?:${DIM_LEN_PCT_POSI})\\s+(?:${DIM_LEN_PCT_POSI})`
-].join("|");
-const RAD_SHAPE = "circle|ellipse";
-const FROM_ANGLE = `from\\s+${DIM_ANGLE}`;
-const AT_POSITION = `at\\s+(?:${POS_1}|${POS_2}|${POS_4})`;
-const TO_SIDE_CORNER = `to\\s+(?:(?:${L_R})(?:\\s(?:${T_B}))?|(?:${T_B})(?:\\s(?:${L_R}))?)`;
-const IN_COLOR_SPACE = `in\\s+(?:${CS_RECT}|${CS_HUE})`;
-const REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\(/;
-const REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\(/;
-const getGradientType = (value) => {
-  if (isString(value)) {
-    value = value.trim();
-    if (REG_GRAD.test(value)) {
-      const [, type] = value.match(REG_GRAD_CAPT);
-      return type;
-    }
-  }
-  return "";
-};
-const validateGradientLine = (value, type) => {
-  if (isString(value) && isString(type)) {
-    value = value.trim();
-    type = type.trim();
-    let lineSyntax = "";
-    const defaultValues = [];
-    if (/^(?:repeating-)?linear-gradient$/.test(type)) {
-      lineSyntax = [
-        `(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`
-      ].join("|");
-      defaultValues.push(/to\s+bottom/);
-    } else if (/^(?:repeating-)?radial-gradient$/.test(type)) {
-      lineSyntax = [
-        `(?:${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `(?:${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${AT_POSITION})?`
-      ].join("|");
-      defaultValues.push(/ellipse/, /farthest-corner/, /at\s+center/);
-    } else if (/^(?:repeating-)?conic-gradient$/.test(type)) {
-      lineSyntax = [
-        `${FROM_ANGLE}(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${FROM_ANGLE})?(?:\\s+${AT_POSITION})?`
-      ].join("|");
-      defaultValues.push(/at\s+center/);
-    }
-    if (lineSyntax) {
-      const reg = new RegExp(`^(?:${lineSyntax})$`);
-      const valid = reg.test(value);
-      if (valid) {
-        let line = value;
-        for (const defaultValue of defaultValues) {
-          line = line.replace(defaultValue, "");
-        }
-        line = line.replace(/\s{2,}/g, " ").trim();
-        return {
-          line,
-          valid
-        };
-      }
-      return {
-        valid,
-        line: value
-      };
-    }
-  }
-  return {
-    line: value,
-    valid: false
-  };
-};
-const validateColorStopList = (list, type, opt = {}) => {
-  if (Array.isArray(list) && list.length > 1) {
-    const dimension = /^(?:repeating-)?conic-gradient$/.test(type) ? DIM_ANGLE_PCT : DIM_LEN_PCT;
-    const regColorHint = new RegExp(`^(?:${dimension})$`);
-    const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-    const valueTypes = [];
-    const valueList = [];
-    for (const item of list) {
-      if (isString(item)) {
-        if (regColorHint.test(item)) {
-          valueTypes.push("hint");
-          valueList.push(item);
-        } else {
-          const itemColor = item.replace(regDimension, "");
-          if (isColor(itemColor, { format: VAL_SPEC })) {
-            const resolvedColor = resolveColor(itemColor, opt);
-            valueTypes.push("color");
-            valueList.push(item.replace(itemColor, resolvedColor));
-          } else {
-            return {
-              colorStops: list,
-              valid: false
-            };
-          }
-        }
-      }
-    }
-    const valid = /^color(?:,(?:hint,)?color)+$/.test(valueTypes.join(","));
-    return {
-      valid,
-      colorStops: valueList
-    };
-  }
-  return {
-    colorStops: list,
-    valid: false
-  };
-};
-const parseGradient = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-    const cacheKey = createCacheKey(
-      {
-        namespace: NAMESPACE,
-        name: "parseGradient",
-        value
-      },
-      opt
-    );
-    const cachedResult = getCache(cacheKey);
-    if (cachedResult instanceof CacheItem) {
-      if (cachedResult.isNull) {
-        return null;
-      }
-      return cachedResult.item;
-    }
-    const type = getGradientType(value);
-    const gradValue = value.replace(REG_GRAD, "").replace(/\)$/, "");
-    if (type && gradValue) {
-      const [lineOrColorStop = "", ...itemList] = splitValue(gradValue, {
-        delimiter: ","
-      });
-      const dimension = /^(?:repeating-)?conic-gradient$/.test(type) ? DIM_ANGLE_PCT : DIM_LEN_PCT;
-      const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-      let colorStop = "";
-      if (regDimension.test(lineOrColorStop)) {
-        const itemColor = lineOrColorStop.replace(regDimension, "");
-        if (isColor(itemColor, { format: VAL_SPEC })) {
-          const resolvedColor = resolveColor(itemColor, opt);
-          colorStop = lineOrColorStop.replace(itemColor, resolvedColor);
-        }
-      } else if (isColor(lineOrColorStop, { format: VAL_SPEC })) {
-        colorStop = resolveColor(lineOrColorStop, opt);
-      }
-      if (colorStop) {
-        itemList.unshift(colorStop);
-        const { colorStops, valid } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (valid) {
-          const res = {
-            value,
-            type,
-            colorStopList: colorStops
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      } else if (itemList.length > 1) {
-        const { line: gradientLine, valid: validLine } = validateGradientLine(
-          lineOrColorStop,
-          type
-        );
-        const { colorStops, valid: validColorStops } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (validLine && validColorStops) {
-          const res = {
-            value,
-            type,
-            gradientLine,
-            colorStopList: colorStops
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      }
-    }
-    setCache(cacheKey, null);
-    return null;
-  }
-  return null;
-};
-const resolveGradient = (value, opt = {}) => {
-  const { format = VAL_COMP } = opt;
-  const gradient = parseGradient(value, opt);
-  if (gradient) {
-    const { type = "", gradientLine = "", colorStopList = [] } = gradient;
-    if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {
-      if (gradientLine) {
-        return `${type}(${gradientLine}, ${colorStopList.join(", ")})`;
-      }
-      return `${type}(${colorStopList.join(", ")})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    return "";
-  }
-  return "none";
-};
-const isGradient = (value, opt = {}) => {
-  const gradient = parseGradient(value, opt);
-  return gradient !== null;
-};
-export {
-  getGradientType,
-  isGradient,
-  parseGradient,
-  resolveGradient,
-  validateColorStopList,
-  validateGradientLine
-};
-//# sourceMappingURL=css-gradient.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.d.ts

@@ -1,31 +0,0 @@
-import { CSSToken } from '@csstools/css-tokenizer';
-import { NullObject } from './cache.js';
-import { Options } from './typedef.js';
-/**
- * resolve custom property
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns result - [tokens, resolvedValue]
- */
-export declare function resolveCustomProperty(tokens: CSSToken[], opt?: Options): [CSSToken[], string];
-/**
- * parse tokens
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns parsed tokens
- */
-export declare function parseTokens(tokens: CSSToken[], opt?: Options): string[] | NullObject;
-/**
- * resolve CSS var()
- * @param value - CSS value including var()
- * @param [opt] - options
- * @returns resolved value
- */
-export declare function resolveVar(value: string, opt?: Options): string | NullObject;
-/**
- * CSS var()
- * @param value - CSS value including var()
- * @param [opt] - options
- * @returns resolved value
- */
-export declare const cssVar: (value: string, opt?: Options) => string;

node_modules/@asamuzakjp/css-color/dist/esm/js/css-var.js

@@ -1,195 +0,0 @@
-import { TokenType, tokenize } from "@csstools/css-tokenizer";
-import { createCacheKey, getCache, CacheItem, setCache, NullObject } from "./cache.js";
-import { isString } from "./common.js";
-import { cssCalc } from "./css-calc.js";
-import { isColor } from "./util.js";
-import { VAL_SPEC, SYN_FN_VAR, FN_VAR, SYN_FN_CALC } from "./constant.js";
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  EOF,
-  Ident: IDENT,
-  Whitespace: W_SPACE
-} = TokenType;
-const NAMESPACE = "css-var";
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-function resolveCustomProperty(tokens, opt = {}) {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { customProperty = {} } = opt;
-  const items = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value] = token;
-    if (type === PAREN_CLOSE) {
-      break;
-    }
-    if (value === FN_VAR) {
-      const [restTokens, item] = resolveCustomProperty(tokens, opt);
-      tokens = restTokens;
-      if (item) {
-        items.push(item);
-      }
-    } else if (type === IDENT) {
-      if (value.startsWith("--")) {
-        let item;
-        if (Object.hasOwn(customProperty, value)) {
-          item = customProperty[value];
-        } else if (typeof customProperty.callback === "function") {
-          item = customProperty.callback(value);
-        }
-        if (item) {
-          items.push(item);
-        }
-      } else if (value) {
-        items.push(value);
-      }
-    }
-  }
-  let resolveAsColor = false;
-  if (items.length > 1) {
-    const lastValue = items[items.length - 1];
-    resolveAsColor = isColor(lastValue);
-  }
-  let resolvedValue = "";
-  for (let item of items) {
-    item = item.trim();
-    if (REG_FN_VAR.test(item)) {
-      const resolvedItem = resolveVar(item, opt);
-      if (isString(resolvedItem)) {
-        if (resolveAsColor) {
-          if (isColor(resolvedItem)) {
-            resolvedValue = resolvedItem;
-          }
-        } else {
-          resolvedValue = resolvedItem;
-        }
-      }
-    } else if (REG_FN_CALC.test(item)) {
-      item = cssCalc(item, opt);
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    } else if (item && !/^(?:inherit|initial|revert(?:-layer)?|unset)$/.test(item)) {
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    }
-    if (resolvedValue) {
-      break;
-    }
-  }
-  return [tokens, resolvedValue];
-}
-function parseTokens(tokens, opt = {}) {
-  const res = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    const [type = "", value = ""] = token;
-    if (value === FN_VAR) {
-      const [restTokens, resolvedValue] = resolveCustomProperty(tokens, opt);
-      if (!resolvedValue) {
-        return new NullObject();
-      }
-      tokens = restTokens;
-      res.push(resolvedValue);
-    } else {
-      switch (type) {
-        case PAREN_CLOSE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (lastValue === " ") {
-              res.splice(-1, 1, value);
-            } else {
-              res.push(value);
-            }
-          } else {
-            res.push(value);
-          }
-          break;
-        }
-        case W_SPACE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-              res.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF) {
-            res.push(value);
-          }
-        }
-      }
-    }
-  }
-  return res;
-}
-function resolveVar(value, opt = {}) {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR.test(value) || format === VAL_SPEC) {
-      return value;
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveVar",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  const tokens = tokenize({ css: value });
-  const values = parseTokens(tokens, opt);
-  if (Array.isArray(values)) {
-    let color = values.join("");
-    if (REG_FN_CALC.test(color)) {
-      color = cssCalc(color, opt);
-    }
-    setCache(cacheKey, color);
-    return color;
-  } else {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-}
-const cssVar = (value, opt = {}) => {
-  const resolvedValue = resolveVar(value, opt);
-  if (isString(resolvedValue)) {
-    return resolvedValue;
-  }
-  return "";
-};
-export {
-  cssVar,
-  parseTokens,
-  resolveCustomProperty,
-  resolveVar
-};
-//# sourceMappingURL=css-var.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.d.ts

@@ -1,29 +0,0 @@
-import { CSSToken } from '@csstools/css-tokenizer';
-import { NullObject } from './cache.js';
-import { ColorChannels, Options, StringColorChannels } from './typedef.js';
-/**
- * @type NumberOrStringColorChannels - color channel
- */
-type NumberOrStringColorChannels = ColorChannels & StringColorChannels;
-/**
- * resolve relative color channels
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns resolved color channels
- */
-export declare function resolveColorChannels(tokens: CSSToken[], opt?: Options): NumberOrStringColorChannels | NullObject;
-/**
- * extract origin color
- * @param value - CSS color value
- * @param [opt] - options
- * @returns origin color value
- */
-export declare function extractOriginColor(value: string, opt?: Options): string | NullObject;
-/**
- * resolve relative color
- * @param value - CSS relative color value
- * @param [opt] - options
- * @returns resolved value
- */
-export declare function resolveRelativeColor(value: string, opt?: Options): string | NullObject;
-export {};

node_modules/@asamuzakjp/css-color/dist/esm/js/relative-color.js

@@ -1,535 +0,0 @@
-import { SyntaxFlag, color } from "@csstools/css-color-parser";
-import { parseComponentValue } from "@csstools/css-parser-algorithms";
-import { TokenType, tokenize } from "@csstools/css-tokenizer";
-import { createCacheKey, getCache, CacheItem, NullObject, setCache } from "./cache.js";
-import { convertColorToRgb, NAMED_COLORS } from "./color.js";
-import { isString, isStringOrNumber } from "./common.js";
-import { resolveDimension, serializeCalc } from "./css-calc.js";
-import { resolveColor } from "./resolve.js";
-import { roundToPrecision, splitValue } from "./util.js";
-import { VAL_SPEC, FN_VAR, NONE, SYN_FN_VAR, FN_REL, FN_LIGHT_DARK, CS_LAB, CS_LCH, FN_REL_CAPT, SYN_COLOR_TYPE, SYN_MIX, SYN_FN_MATH_START } from "./constant.js";
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  Delim: DELIM,
-  Dimension: DIM,
-  EOF,
-  Function: FUNC,
-  Ident: IDENT,
-  Number: NUM,
-  OpenParen: PAREN_OPEN,
-  Percentage: PCT,
-  Whitespace: W_SPACE
-} = TokenType;
-const { HasNoneKeywords: KEY_NONE } = SyntaxFlag;
-const NAMESPACE = "relative-color";
-const OCT = 8;
-const DEC = 10;
-const HEX = 16;
-const MAX_PCT = 100;
-const MAX_RGB = 255;
-const REG_COLOR_CAPT = new RegExp(
-  `^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\s+`
-);
-const REG_CS_HSL = /(?:hsla?|hwb)$/;
-const REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);
-const REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\(/;
-const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
-const REG_FN_REL = new RegExp(FN_REL);
-const REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);
-const REG_FN_REL_START = new RegExp(`^${FN_REL}`);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-function resolveColorChannels(tokens, opt = {}) {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { colorSpace = "", format = "" } = opt;
-  const colorChannels = /* @__PURE__ */ new Map([
-    ["color", ["r", "g", "b", "alpha"]],
-    ["hsl", ["h", "s", "l", "alpha"]],
-    ["hsla", ["h", "s", "l", "alpha"]],
-    ["hwb", ["h", "w", "b", "alpha"]],
-    ["lab", ["l", "a", "b", "alpha"]],
-    ["lch", ["l", "c", "h", "alpha"]],
-    ["oklab", ["l", "a", "b", "alpha"]],
-    ["oklch", ["l", "c", "h", "alpha"]],
-    ["rgb", ["r", "g", "b", "alpha"]],
-    ["rgba", ["r", "g", "b", "alpha"]]
-  ]);
-  const colorChannel = colorChannels.get(colorSpace);
-  if (!colorChannel) {
-    return new NullObject();
-  }
-  const mathFunc = /* @__PURE__ */ new Set();
-  const channels = [[], [], [], []];
-  let i = 0;
-  let nest = 0;
-  let func = "";
-  let precededPct = false;
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value, , , detail] = token;
-    const channel = channels[i];
-    if (Array.isArray(channel)) {
-      switch (type) {
-        case DELIM: {
-          if (func) {
-            if ((value === "+" || value === "-") && precededPct && !REG_FN_CALC_SUM.test(func)) {
-              return new NullObject();
-            }
-            precededPct = false;
-            channel.push(value);
-          }
-          break;
-        }
-        case DIM: {
-          if (!func || !REG_FN_CALC_SUM.test(func)) {
-            return new NullObject();
-          }
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            channel.push(resolvedValue);
-          } else {
-            channel.push(value);
-          }
-          break;
-        }
-        case FUNC: {
-          channel.push(value);
-          func = value;
-          nest++;
-          if (REG_FN_MATH_START.test(value)) {
-            mathFunc.add(nest);
-          }
-          break;
-        }
-        case IDENT: {
-          if (!colorChannel.includes(value)) {
-            return new NullObject();
-          }
-          channel.push(value);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case NUM: {
-          channel.push(Number(detail?.value));
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case PAREN_OPEN: {
-          channel.push(value);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE: {
-          if (func) {
-            const lastValue = channel[channel.length - 1];
-            if (lastValue === " ") {
-              channel.splice(-1, 1, value);
-            } else {
-              channel.push(value);
-            }
-            if (mathFunc.has(nest)) {
-              mathFunc.delete(nest);
-            }
-            nest--;
-            if (nest === 0) {
-              func = "";
-              i++;
-            }
-          }
-          break;
-        }
-        case PCT: {
-          if (!func) {
-            return new NullObject();
-          } else if (!REG_FN_CALC_SUM.test(func)) {
-            const lastValue = channel.toReversed().find((v) => v !== " ");
-            if (lastValue === "+" || lastValue === "-") {
-              return new NullObject();
-            } else if (lastValue === "*" || lastValue === "/") {
-              precededPct = false;
-            } else {
-              precededPct = true;
-            }
-          }
-          channel.push(Number(detail?.value) / MAX_PCT);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case W_SPACE: {
-          if (channel.length && func) {
-            const lastValue = channel[channel.length - 1];
-            if (typeof lastValue === "number") {
-              channel.push(value);
-            } else if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-              channel.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF && func) {
-            channel.push(value);
-          }
-        }
-      }
-    }
-  }
-  const channelValues = [];
-  for (const channel of channels) {
-    if (channel.length === 1) {
-      const [resolvedValue] = channel;
-      if (isStringOrNumber(resolvedValue)) {
-        channelValues.push(resolvedValue);
-      }
-    } else if (channel.length) {
-      const resolvedValue = serializeCalc(channel.join(""), {
-        format
-      });
-      channelValues.push(resolvedValue);
-    }
-  }
-  return channelValues;
-}
-function extractOriginColor(value, opt = {}) {
-  const { colorScheme = "normal", currentColor = "", format = "" } = opt;
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (!value) {
-      return new NullObject();
-    }
-    if (!REG_FN_REL_START.test(value)) {
-      return value;
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "extractOriginColor",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (/currentcolor/.test(value)) {
-    if (currentColor) {
-      value = value.replace(/currentcolor/g, currentColor);
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  let colorSpace = "";
-  if (REG_FN_REL_CAPT.test(value)) {
-    [, colorSpace] = value.match(REG_FN_REL_CAPT);
-  }
-  opt.colorSpace = colorSpace;
-  if (value.includes(FN_LIGHT_DARK)) {
-    const colorParts = value.replace(new RegExp(`^${colorSpace}\\(`), "").replace(/\)$/, "");
-    const [, originColor = ""] = splitValue(colorParts);
-    const specifiedOriginColor = resolveColor(originColor, {
-      colorScheme,
-      format: VAL_SPEC
-    });
-    if (specifiedOriginColor === "") {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-    if (format === VAL_SPEC) {
-      value = value.replace(originColor, specifiedOriginColor);
-    } else {
-      const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-  }
-  if (REG_COLOR_CAPT.test(value)) {
-    const [, originColor] = value.match(REG_COLOR_CAPT);
-    const [, restValue] = value.split(originColor);
-    if (/^[a-z]+$/.test(originColor)) {
-      if (!/^transparent$/.test(originColor) && !Object.hasOwn(NAMED_COLORS, originColor)) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-    } else if (format === VAL_SPEC) {
-      const resolvedOriginColor = resolveColor(originColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-    if (format === VAL_SPEC) {
-      const tokens = tokenize({ css: restValue });
-      const channelValues = resolveColorChannels(tokens, opt);
-      if (channelValues instanceof NullObject) {
-        setCache(cacheKey, null);
-        return channelValues;
-      }
-      const [v1, v2, v3, v4] = channelValues;
-      let channelValue = "";
-      if (isStringOrNumber(v4)) {
-        channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-      } else {
-        channelValue = ` ${channelValues.join(" ")})`;
-      }
-      if (restValue !== channelValue) {
-        value = value.replace(restValue, channelValue);
-      }
-    }
-  } else {
-    const [, restValue] = value.split(REG_FN_REL_START);
-    const tokens = tokenize({ css: restValue });
-    const originColor = [];
-    let nest = 0;
-    while (tokens.length) {
-      const [type, tokenValue] = tokens.shift();
-      switch (type) {
-        case FUNC:
-        case PAREN_OPEN: {
-          originColor.push(tokenValue);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE: {
-          const lastValue = originColor[originColor.length - 1];
-          if (lastValue === " ") {
-            originColor.splice(-1, 1, tokenValue);
-          } else if (isString(lastValue)) {
-            originColor.push(tokenValue);
-          }
-          nest--;
-          break;
-        }
-        case W_SPACE: {
-          const lastValue = originColor[originColor.length - 1];
-          if (isString(lastValue) && !lastValue.endsWith("(") && lastValue !== " ") {
-            originColor.push(tokenValue);
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF) {
-            originColor.push(tokenValue);
-          }
-        }
-      }
-      if (nest === 0) {
-        break;
-      }
-    }
-    const resolvedOriginColor = resolveRelativeColor(
-      originColor.join("").trim(),
-      opt
-    );
-    if (resolvedOriginColor instanceof NullObject) {
-      setCache(cacheKey, null);
-      return resolvedOriginColor;
-    }
-    const channelValues = resolveColorChannels(tokens, opt);
-    if (channelValues instanceof NullObject) {
-      setCache(cacheKey, null);
-      return channelValues;
-    }
-    const [v1, v2, v3, v4] = channelValues;
-    let channelValue = "";
-    if (isStringOrNumber(v4)) {
-      channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-    } else {
-      channelValue = ` ${channelValues.join(" ")})`;
-    }
-    value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);
-  }
-  setCache(cacheKey, value);
-  return value;
-}
-function resolveRelativeColor(value, opt = {}) {
-  const { format = "" } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      } else {
-        throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);
-      }
-    } else if (!REG_FN_REL.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolveRelativeColor",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  const originColor = extractOriginColor(value, opt);
-  if (originColor instanceof NullObject) {
-    setCache(cacheKey, null);
-    return originColor;
-  }
-  value = originColor;
-  if (format === VAL_SPEC) {
-    if (value.startsWith("rgba(")) {
-      value = value.replace(/^rgba\(/, "rgb(");
-    } else if (value.startsWith("hsla(")) {
-      value = value.replace(/^hsla\(/, "hsl(");
-    }
-    return value;
-  }
-  const tokens = tokenize({ css: value });
-  const components = parseComponentValue(tokens);
-  const parsedComponents = color(components);
-  if (!parsedComponents) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const {
-    alpha: alphaComponent,
-    channels: channelsComponent,
-    colorNotation,
-    syntaxFlags
-  } = parsedComponents;
-  let alpha;
-  if (Number.isNaN(Number(alphaComponent))) {
-    if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) {
-      alpha = NONE;
-    } else {
-      alpha = 0;
-    }
-  } else {
-    alpha = roundToPrecision(Number(alphaComponent), OCT);
-  }
-  let v1;
-  let v2;
-  let v3;
-  [v1, v2, v3] = channelsComponent;
-  let resolvedValue;
-  if (REG_CS_CIE.test(colorNotation)) {
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, HEX);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, HEX);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, HEX);
-    }
-    if (alpha === 1) {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  } else if (REG_CS_HSL.test(colorNotation)) {
-    if (Number.isNaN(v1)) {
-      v1 = 0;
-    }
-    if (Number.isNaN(v2)) {
-      v2 = 0;
-    }
-    if (Number.isNaN(v3)) {
-      v3 = 0;
-    }
-    let [r, g, b] = convertColorToRgb(
-      `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`
-    );
-    r = roundToPrecision(r / MAX_RGB, DEC);
-    g = roundToPrecision(g / MAX_RGB, DEC);
-    b = roundToPrecision(b / MAX_RGB, DEC);
-    if (alpha === 1) {
-      resolvedValue = `color(srgb ${r} ${g} ${b})`;
-    } else {
-      resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;
-    }
-  } else {
-    const cs = colorNotation === "rgb" ? "srgb" : colorNotation;
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, DEC);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, DEC);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, DEC);
-    }
-    if (alpha === 1) {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-}
-export {
-  extractOriginColor,
-  resolveColorChannels,
-  resolveRelativeColor
-};
-//# sourceMappingURL=relative-color.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.d.ts

@@ -1,52 +0,0 @@
-import { NullObject } from './cache.js';
-import { Options } from './typedef.js';
-/**
- * resolve color
- * @param value - CSS color value
- * @param [opt] - options
- * @returns resolved color
- */
-export declare const resolveColor: (value: string, opt?: Options) => string | NullObject;
-/**
- * resolve CSS color
- * @param value
- *   - CSS color value
- *   - system colors are not supported
- * @param [opt] - options
- * @param [opt.currentColor]
- *   - color to use for `currentcolor` keyword
- *   - if omitted, it will be treated as a missing color
- *     i.e. `rgb(none none none / none)`
- * @param [opt.customProperty]
- *   - custom properties
- *   - pair of `--` prefixed property name and value,
- *     e.g. `customProperty: { '--some-color': '#0000ff' }`
- *   - and/or `callback` function to get the value of the custom property,
- *     e.g. `customProperty: { callback: someDeclaration.getPropertyValue }`
- * @param [opt.dimension]
- *   - dimension, convert relative length to pixels
- *   - pair of unit and it's value as a number in pixels,
- *     e.g. `dimension: { em: 12, rem: 16, vw: 10.26 }`
- *   - and/or `callback` function to get the value as a number in pixels,
- *     e.g. `dimension: { callback: convertUnitToPixel }`
- * @param [opt.format]
- *   - output format, one of below
- *   - `computedValue` (default), [computed value][139] of the color
- *   - `specifiedValue`, [specified value][140] of the color
- *   - `hex`, hex color notation, i.e. `rrggbb`
- *   - `hexAlpha`, hex color notation with alpha channel, i.e. `#rrggbbaa`
- * @returns
- *   - one of rgba?(), #rrggbb(aa)?, color-name, '(empty-string)',
- *     color(color-space r g b / alpha), color(color-space x y z / alpha),
- *     lab(l a b / alpha), lch(l c h / alpha), oklab(l a b / alpha),
- *     oklch(l c h / alpha), null
- *   - in `computedValue`, values are numbers, however `rgb()` values are
- *     integers
- *   - in `specifiedValue`, returns `empty string` for unknown and/or invalid
- *     color
- *   - in `hex`, returns `null` for `transparent`, and also returns `null` if
- *     any of `r`, `g`, `b`, `alpha` is not a number
- *   - in `hexAlpha`, returns `#00000000` for `transparent`,
- *     however returns `null` if any of `r`, `g`, `b`, `alpha` is not a number
- */
-export declare const resolve: (value: string, opt?: Options) => string | null;

node_modules/@asamuzakjp/css-color/dist/esm/js/resolve.js

@@ -1,350 +0,0 @@
-import { NullObject, createCacheKey, getCache, CacheItem, setCache } from "./cache.js";
-import { resolveColorMix, resolveColorFunc, resolveColorValue, convertRgbToHex } from "./color.js";
-import { isString } from "./common.js";
-import { cssCalc } from "./css-calc.js";
-import { resolveVar } from "./css-var.js";
-import { resolveRelativeColor } from "./relative-color.js";
-import { splitValue } from "./util.js";
-import { VAL_COMP, VAL_SPEC, FN_MIX, FN_COLOR, SYN_FN_VAR, SYN_FN_LIGHT_DARK, SYN_FN_REL, SYN_FN_CALC } from "./constant.js";
-const NAMESPACE = "resolve";
-const RGB_TRANSPARENT = "rgba(0, 0, 0, 0)";
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_LIGHT_DARK = new RegExp(SYN_FN_LIGHT_DARK);
-const REG_FN_REL = new RegExp(SYN_FN_REL);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-const resolveColor = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const {
-    colorScheme = "normal",
-    currentColor = "",
-    format = VAL_COMP,
-    nullable = false
-  } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "resolve",
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult;
-    }
-    return cachedResult.item;
-  }
-  if (REG_FN_VAR.test(value)) {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-    const resolvedValue = resolveVar(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      switch (format) {
-        case "hex":
-        case "hexAlpha": {
-          setCache(cacheKey, resolvedValue);
-          return resolvedValue;
-        }
-        default: {
-          if (nullable) {
-            setCache(cacheKey, resolvedValue);
-            return resolvedValue;
-          }
-          const res2 = RGB_TRANSPARENT;
-          setCache(cacheKey, res2);
-          return res2;
-        }
-      }
-    } else {
-      value = resolvedValue;
-    }
-  }
-  if (opt.format !== format) {
-    opt.format = format;
-  }
-  value = value.toLowerCase();
-  if (REG_FN_LIGHT_DARK.test(value) && value.endsWith(")")) {
-    const colorParts = value.replace(REG_FN_LIGHT_DARK, "").replace(/\)$/, "");
-    const [light = "", dark = ""] = splitValue(colorParts, {
-      delimiter: ","
-    });
-    if (light && dark) {
-      if (format === VAL_SPEC) {
-        const lightColor = resolveColor(light, opt);
-        const darkColor = resolveColor(dark, opt);
-        let res3;
-        if (lightColor && darkColor) {
-          res3 = `light-dark(${lightColor}, ${darkColor})`;
-        } else {
-          res3 = "";
-        }
-        setCache(cacheKey, res3);
-        return res3;
-      }
-      let resolvedValue;
-      if (colorScheme === "dark") {
-        resolvedValue = resolveColor(dark, opt);
-      } else {
-        resolvedValue = resolveColor(light, opt);
-      }
-      let res2;
-      if (resolvedValue instanceof NullObject) {
-        if (nullable) {
-          res2 = resolvedValue;
-        } else {
-          res2 = RGB_TRANSPARENT;
-        }
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    switch (format) {
-      case VAL_SPEC: {
-        setCache(cacheKey, "");
-        return "";
-      }
-      case "hex":
-      case "hexAlpha": {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      case VAL_COMP:
-      default: {
-        const res2 = RGB_TRANSPARENT;
-        setCache(cacheKey, res2);
-        return res2;
-      }
-    }
-  }
-  if (REG_FN_REL.test(value)) {
-    const resolvedValue = resolveRelativeColor(value, opt);
-    if (format === VAL_COMP) {
-      let res2;
-      if (resolvedValue instanceof NullObject) {
-        if (nullable) {
-          res2 = resolvedValue;
-        } else {
-          res2 = RGB_TRANSPARENT;
-        }
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (format === VAL_SPEC) {
-      let res2 = "";
-      if (resolvedValue instanceof NullObject) {
-        res2 = "";
-      } else {
-        res2 = resolvedValue;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-    if (resolvedValue instanceof NullObject) {
-      value = "";
-    } else {
-      value = resolvedValue;
-    }
-  }
-  if (REG_FN_CALC.test(value)) {
-    value = cssCalc(value, opt);
-  }
-  let cs = "";
-  let r = NaN;
-  let g = NaN;
-  let b = NaN;
-  let alpha = NaN;
-  if (value === "transparent") {
-    switch (format) {
-      case VAL_SPEC: {
-        setCache(cacheKey, value);
-        return value;
-      }
-      case "hex": {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      case "hexAlpha": {
-        const res2 = "#00000000";
-        setCache(cacheKey, res2);
-        return res2;
-      }
-      case VAL_COMP:
-      default: {
-        const res2 = RGB_TRANSPARENT;
-        setCache(cacheKey, res2);
-        return res2;
-      }
-    }
-  } else if (value === "currentcolor") {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-    if (currentColor) {
-      let resolvedValue;
-      if (currentColor.startsWith(FN_MIX)) {
-        resolvedValue = resolveColorMix(currentColor, opt);
-      } else if (currentColor.startsWith(FN_COLOR)) {
-        resolvedValue = resolveColorFunc(currentColor, opt);
-      } else {
-        resolvedValue = resolveColorValue(currentColor, opt);
-      }
-      if (resolvedValue instanceof NullObject) {
-        setCache(cacheKey, resolvedValue);
-        return resolvedValue;
-      }
-      [cs, r, g, b, alpha] = resolvedValue;
-    } else if (format === VAL_COMP) {
-      const res2 = RGB_TRANSPARENT;
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (format === VAL_SPEC) {
-    if (value.startsWith(FN_MIX)) {
-      const res2 = resolveColorMix(value, opt);
-      setCache(cacheKey, res2);
-      return res2;
-    } else if (value.startsWith(FN_COLOR)) {
-      const [scs, rr, gg, bb, aa] = resolveColorFunc(
-        value,
-        opt
-      );
-      let res2 = "";
-      if (aa === 1) {
-        res2 = `color(${scs} ${rr} ${gg} ${bb})`;
-      } else {
-        res2 = `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    } else {
-      const rgb = resolveColorValue(value, opt);
-      if (isString(rgb)) {
-        setCache(cacheKey, rgb);
-        return rgb;
-      }
-      const [scs, rr, gg, bb, aa] = rgb;
-      let res2 = "";
-      if (scs === "rgb") {
-        if (aa === 1) {
-          res2 = `${scs}(${rr}, ${gg}, ${bb})`;
-        } else {
-          res2 = `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;
-        }
-      } else if (aa === 1) {
-        res2 = `${scs}(${rr} ${gg} ${bb})`;
-      } else {
-        res2 = `${scs}(${rr} ${gg} ${bb} / ${aa})`;
-      }
-      setCache(cacheKey, res2);
-      return res2;
-    }
-  } else if (value.startsWith(FN_MIX)) {
-    if (/currentcolor/.test(value)) {
-      if (currentColor) {
-        value = value.replace(/currentcolor/g, currentColor);
-      }
-    }
-    if (/transparent/.test(value)) {
-      value = value.replace(/transparent/g, RGB_TRANSPARENT);
-    }
-    const resolvedValue = resolveColorMix(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  } else if (value.startsWith(FN_COLOR)) {
-    const resolvedValue = resolveColorFunc(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  } else if (value) {
-    const resolvedValue = resolveColorValue(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      setCache(cacheKey, resolvedValue);
-      return resolvedValue;
-    }
-    [cs, r, g, b, alpha] = resolvedValue;
-  }
-  let res = "";
-  switch (format) {
-    case "hex": {
-      if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(alpha) || alpha === 0) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      res = convertRgbToHex([r, g, b, 1]);
-      break;
-    }
-    case "hexAlpha": {
-      if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(alpha)) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-      res = convertRgbToHex([r, g, b, alpha]);
-      break;
-    }
-    case VAL_COMP:
-    default: {
-      switch (cs) {
-        case "rgb": {
-          if (alpha === 1) {
-            res = `${cs}(${r}, ${g}, ${b})`;
-          } else {
-            res = `${cs}a(${r}, ${g}, ${b}, ${alpha})`;
-          }
-          break;
-        }
-        case "lab":
-        case "lch":
-        case "oklab":
-        case "oklch": {
-          if (alpha === 1) {
-            res = `${cs}(${r} ${g} ${b})`;
-          } else {
-            res = `${cs}(${r} ${g} ${b} / ${alpha})`;
-          }
-          break;
-        }
-        // color()
-        default: {
-          if (alpha === 1) {
-            res = `color(${cs} ${r} ${g} ${b})`;
-          } else {
-            res = `color(${cs} ${r} ${g} ${b} / ${alpha})`;
-          }
-        }
-      }
-    }
-  }
-  setCache(cacheKey, res);
-  return res;
-};
-const resolve = (value, opt = {}) => {
-  opt.nullable = false;
-  const resolvedValue = resolveColor(value, opt);
-  if (resolvedValue instanceof NullObject) {
-    return null;
-  }
-  return resolvedValue;
-};
-export {
-  resolve,
-  resolveColor
-};
-//# sourceMappingURL=resolve.js.map

node_modules/@asamuzakjp/css-color/dist/esm/js/typedef.d.ts

@@ -1,80 +0,0 @@
-/**
- * typedef
- */
-/**
- * @typedef Options - options
- * @property [alpha] - enable alpha
- * @property [colorSpace] - color space
- * @property [currentColor] - color for currentcolor
- * @property [customProperty] - custom properties
- * @property [d50] - white point in d50
- * @property [dimension] - dimension
- * @property [format] - output format
- * @property [key] - key
- */
-export interface Options {
-    alpha?: boolean;
-    colorScheme?: string;
-    colorSpace?: string;
-    currentColor?: string;
-    customProperty?: Record<string, string | ((K: string) => string)>;
-    d50?: boolean;
-    delimiter?: string | string[];
-    dimension?: Record<string, number | ((K: string) => number)>;
-    format?: string;
-    nullable?: boolean;
-    preserveComment?: boolean;
-}
-/**
- * @type ColorChannels - color channels
- */
-export type ColorChannels = [x: number, y: number, z: number, alpha: number];
-/**
- * @type StringColorChannels - color channels
- */
-export type StringColorChannels = [
-    x: string,
-    y: string,
-    z: string,
-    alpha: string | undefined
-];
-/**
- * @type StringColorSpacedChannels - specified value
- */
-export type StringColorSpacedChannels = [
-    cs: string,
-    x: string,
-    y: string,
-    z: string,
-    alpha: string | undefined
-];
-/**
- * @type ComputedColorChannels - computed value
- */
-export type ComputedColorChannels = [
-    cs: string,
-    x: number,
-    y: number,
-    z: number,
-    alpha: number
-];
-/**
- * @type SpecifiedColorChannels - specified value
- */
-export type SpecifiedColorChannels = [
-    cs: string,
-    x: number | string,
-    y: number | string,
-    z: number | string,
-    alpha: number | string
-];
-/**
- * @type MatchedRegExp - matched regexp array
- */
-export type MatchedRegExp = [
-    match: string,
-    gr1: string,
-    gr2: string,
-    gr3: string,
-    gr4: string
-];

node_modules/@asamuzakjp/css-color/dist/esm/js/util.d.ts

@@ -1,53 +0,0 @@
-import { Options } from './typedef.js';
-/**
- * split value
- * NOTE: comments are stripped, it can be preserved if, in the options param,
- * `delimiter` is either ',' or '/' and with `preserveComment` set to `true`
- * @param value - CSS value
- * @param [opt] - options
- * @returns array of values
- */
-export declare const splitValue: (value: string, opt?: Options) => string[];
-/**
- * extract dashed-ident tokens
- * @param value - CSS value
- * @returns array of dashed-ident tokens
- */
-export declare const extractDashedIdent: (value: string) => string[];
-/**
- * is color
- * @param value - CSS value
- * @param [opt] - options
- * @returns result
- */
-export declare const isColor: (value: unknown, opt?: Options) => boolean;
-/**
- * value to JSON string
- * @param value - CSS value
- * @param [func] - stringify function
- * @returns stringified value in JSON notation
- */
-export declare const valueToJsonString: (value: unknown, func?: boolean) => string;
-/**
- * round to specified precision
- * @param value - numeric value
- * @param bit - minimum bits
- * @returns rounded value
- */
-export declare const roundToPrecision: (value: number, bit?: number) => number;
-/**
- * interpolate hue
- * @param hueA - hue value
- * @param hueB - hue value
- * @param arc - shorter | longer | increasing | decreasing
- * @returns result - [hueA, hueB]
- */
-export declare const interpolateHue: (hueA: number, hueB: number, arc?: string) => [number, number];
-/**
- * resolve length in pixels
- * @param value - value
- * @param unit - unit
- * @param [opt] - options
- * @returns pixelated value
- */
-export declare const resolveLengthInPixels: (value: number | string, unit: string | undefined, opt?: Options) => number;

node_modules/@asamuzakjp/css-color/dist/esm/js/util.js

@@ -1,359 +0,0 @@
-import { TokenType, tokenize } from "@csstools/css-tokenizer";
-import { createCacheKey, getCache, CacheItem, setCache } from "./cache.js";
-import { isString } from "./common.js";
-import { resolveColor } from "./resolve.js";
-import { NAMED_COLORS } from "./color.js";
-import { VAL_SPEC, SYN_COLOR_TYPE, SYN_MIX } from "./constant.js";
-const {
-  CloseParen: PAREN_CLOSE,
-  Comma: COMMA,
-  Comment: COMMENT,
-  Delim: DELIM,
-  EOF,
-  Function: FUNC,
-  Ident: IDENT,
-  OpenParen: PAREN_OPEN,
-  Whitespace: W_SPACE
-} = TokenType;
-const NAMESPACE = "util";
-const DEC = 10;
-const HEX = 16;
-const DEG = 360;
-const DEG_HALF = 180;
-const REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
-const REG_FN_COLOR = /^(?:(?:ok)?l(?:ab|ch)|color(?:-mix)?|hsla?|hwb|rgba?|var)\(/;
-const REG_MIX = new RegExp(SYN_MIX);
-const splitValue = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { delimiter = " ", preserveComment = false } = opt;
-  const cacheKey = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: "splitValue",
-      value
-    },
-    {
-      delimiter,
-      preserveComment
-    }
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  let regDelimiter;
-  if (delimiter === ",") {
-    regDelimiter = /^,$/;
-  } else if (delimiter === "/") {
-    regDelimiter = /^\/$/;
-  } else {
-    regDelimiter = /^\s+$/;
-  }
-  const tokens = tokenize({ css: value });
-  let nest = 0;
-  let str = "";
-  const res = [];
-  while (tokens.length) {
-    const [type, value2] = tokens.shift();
-    switch (type) {
-      case COMMA: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            res.push(str.trim());
-            str = "";
-          } else {
-            str += value2;
-          }
-        } else {
-          str += value2;
-        }
-        break;
-      }
-      case DELIM: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            res.push(str.trim());
-            str = "";
-          } else {
-            str += value2;
-          }
-        } else {
-          str += value2;
-        }
-        break;
-      }
-      case COMMENT: {
-        if (preserveComment && (delimiter === "," || delimiter === "/")) {
-          str += value2;
-        }
-        break;
-      }
-      case FUNC:
-      case PAREN_OPEN: {
-        str += value2;
-        nest++;
-        break;
-      }
-      case PAREN_CLOSE: {
-        str += value2;
-        nest--;
-        break;
-      }
-      case W_SPACE: {
-        if (regDelimiter.test(value2)) {
-          if (nest === 0) {
-            if (str) {
-              res.push(str.trim());
-              str = "";
-            }
-          } else {
-            str += " ";
-          }
-        } else if (!str.endsWith(" ")) {
-          str += " ";
-        }
-        break;
-      }
-      default: {
-        if (type === EOF) {
-          res.push(str.trim());
-          str = "";
-        } else {
-          str += value2;
-        }
-      }
-    }
-  }
-  setCache(cacheKey, res);
-  return res;
-};
-const extractDashedIdent = (value) => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey = createCacheKey({
-    namespace: NAMESPACE,
-    name: "extractDashedIdent",
-    value
-  });
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item;
-  }
-  const tokens = tokenize({ css: value });
-  const items = /* @__PURE__ */ new Set();
-  while (tokens.length) {
-    const [type, value2] = tokens.shift();
-    if (type === IDENT && value2.startsWith("--")) {
-      items.add(value2);
-    }
-  }
-  const res = [...items];
-  setCache(cacheKey, res);
-  return res;
-};
-const isColor = (value, opt = {}) => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (value && isString(value)) {
-      if (/^[a-z]+$/.test(value)) {
-        if (/^(?:currentcolor|transparent)$/.test(value) || Object.hasOwn(NAMED_COLORS, value)) {
-          return true;
-        }
-      } else if (REG_COLOR.test(value) || REG_MIX.test(value)) {
-        return true;
-      } else if (REG_FN_COLOR.test(value)) {
-        opt.nullable = true;
-        if (!opt.format) {
-          opt.format = VAL_SPEC;
-        }
-        const resolvedValue = resolveColor(value, opt);
-        if (resolvedValue) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-const valueToJsonString = (value, func = false) => {
-  if (typeof value === "undefined") {
-    return "";
-  }
-  const res = JSON.stringify(value, (_key, val) => {
-    let replacedValue;
-    if (typeof val === "undefined") {
-      replacedValue = null;
-    } else if (typeof val === "function") {
-      if (func) {
-        replacedValue = val.toString().replace(/\s/g, "").substring(0, HEX);
-      } else {
-        replacedValue = val.name;
-      }
-    } else if (val instanceof Map || val instanceof Set) {
-      replacedValue = [...val];
-    } else if (typeof val === "bigint") {
-      replacedValue = val.toString();
-    } else {
-      replacedValue = val;
-    }
-    return replacedValue;
-  });
-  return res;
-};
-const roundToPrecision = (value, bit = 0) => {
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`${value} is not a finite number.`);
-  }
-  if (!Number.isFinite(bit)) {
-    throw new TypeError(`${bit} is not a finite number.`);
-  } else if (bit < 0 || bit > HEX) {
-    throw new RangeError(`${bit} is not between 0 and ${HEX}.`);
-  }
-  if (bit === 0) {
-    return Math.round(value);
-  }
-  let val;
-  if (bit === HEX) {
-    val = value.toPrecision(6);
-  } else if (bit < DEC) {
-    val = value.toPrecision(4);
-  } else {
-    val = value.toPrecision(5);
-  }
-  return parseFloat(val);
-};
-const interpolateHue = (hueA, hueB, arc = "shorter") => {
-  if (!Number.isFinite(hueA)) {
-    throw new TypeError(`${hueA} is not a finite number.`);
-  }
-  if (!Number.isFinite(hueB)) {
-    throw new TypeError(`${hueB} is not a finite number.`);
-  }
-  switch (arc) {
-    case "decreasing": {
-      if (hueB > hueA) {
-        hueA += DEG;
-      }
-      break;
-    }
-    case "increasing": {
-      if (hueB < hueA) {
-        hueB += DEG;
-      }
-      break;
-    }
-    case "longer": {
-      if (hueB > hueA && hueB < hueA + DEG_HALF) {
-        hueA += DEG;
-      } else if (hueB > hueA + DEG_HALF * -1 && hueB <= hueA) {
-        hueB += DEG;
-      }
-      break;
-    }
-    case "shorter":
-    default: {
-      if (hueB > hueA + DEG_HALF) {
-        hueA += DEG;
-      } else if (hueB < hueA + DEG_HALF * -1) {
-        hueB += DEG;
-      }
-    }
-  }
-  return [hueA, hueB];
-};
-const absoluteFontSize = /* @__PURE__ */ new Map([
-  ["xx-small", 3 / 5],
-  ["x-small", 3 / 4],
-  ["small", 8 / 9],
-  ["medium", 1],
-  ["large", 6 / 5],
-  ["x-large", 3 / 2],
-  ["xx-large", 2],
-  ["xxx-large", 3]
-]);
-const relativeFontSize = /* @__PURE__ */ new Map([
-  ["smaller", 1 / 1.2],
-  ["larger", 1.2]
-]);
-const absoluteLength = /* @__PURE__ */ new Map([
-  ["cm", 96 / 2.54],
-  ["mm", 96 / 2.54 / 10],
-  ["q", 96 / 2.54 / 40],
-  ["in", 96],
-  ["pc", 96 / 6],
-  ["pt", 96 / 72],
-  ["px", 1]
-]);
-const relativeLength = /* @__PURE__ */ new Map([
-  ["rcap", 1],
-  ["rch", 0.5],
-  ["rem", 1],
-  ["rex", 0.5],
-  ["ric", 1],
-  ["rlh", 1.2]
-]);
-const resolveLengthInPixels = (value, unit, opt = {}) => {
-  const { dimension = {} } = opt;
-  const { callback, em, rem, vh, vw } = dimension;
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (absoluteFontSize.has(value)) {
-      return Number(absoluteFontSize.get(value)) * rem;
-    } else if (relativeFontSize.has(value)) {
-      return Number(relativeFontSize.get(value)) * em;
-    }
-    return Number.NaN;
-  } else if (Number.isFinite(value) && unit) {
-    if (Object.hasOwn(dimension, unit)) {
-      return value * Number(dimension[unit]);
-    } else if (typeof callback === "function") {
-      return value * callback(unit);
-    } else if (absoluteLength.has(unit)) {
-      return value * Number(absoluteLength.get(unit));
-    } else if (relativeLength.has(unit)) {
-      return value * Number(relativeLength.get(unit)) * rem;
-    } else if (relativeLength.has(`r${unit}`)) {
-      return value * Number(relativeLength.get(`r${unit}`)) * em;
-    } else {
-      switch (unit) {
-        case "vb":
-        case "vi": {
-          return value * vw;
-        }
-        case "vmax": {
-          if (vh > vw) {
-            return value * vh;
-          }
-          return value * vw;
-        }
-        case "vmin": {
-          if (vh < vw) {
-            return value * vh;
-          }
-          return value * vw;
-        }
-        default: {
-          return Number.NaN;
-        }
-      }
-    }
-  }
-  return Number.NaN;
-};
-export {
-  extractDashedIdent,
-  interpolateHue,
-  isColor,
-  resolveLengthInPixels,
-  roundToPrecision,
-  splitValue,
-  valueToJsonString
-};
-//# sourceMappingURL=util.js.map

node_modules/@asamuzakjp/css-color/package.json

@@ -1,82 +0,0 @@
-{
-  "name": "@asamuzakjp/css-color",
-  "description": "CSS color - Resolve and convert CSS colors.",
-  "author": "asamuzaK",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/asamuzaK/cssColor.git"
-  },
-  "homepage": "https://github.com/asamuzaK/cssColor#readme",
-  "bugs": {
-    "url": "https://github.com/asamuzaK/cssColor/issues"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "type": "module",
-  "types": "dist/esm/index.d.ts",
-  "module": "dist/esm/index.js",
-  "main": "dist/cjs/index.cjs",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
-      }
-    },
-    "./package.json": "./package.json"
-  },
-  "dependencies": {
-    "@csstools/css-calc": "^3.0.0",
-    "@csstools/css-color-parser": "^4.0.1",
-    "@csstools/css-parser-algorithms": "^4.0.0",
-    "@csstools/css-tokenizer": "^4.0.0",
-    "lru-cache": "^11.2.5"
-  },
-  "devDependencies": {
-    "@tanstack/vite-config": "^0.4.3",
-    "@vitest/coverage-istanbul": "^4.0.18",
-    "esbuild": "^0.27.2",
-    "eslint": "^9.39.2",
-    "eslint-plugin-regexp": "^3.0.0",
-    "globals": "^17.3.0",
-    "knip": "^5.83.0",
-    "neostandard": "^0.12.2",
-    "prettier": "^3.8.1",
-    "publint": "^0.3.17",
-    "rimraf": "^6.1.2",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
-  },
-  "packageManager": "pnpm@10.28.2",
-  "pnpm": {
-    "onlyBuiltDependencies": [
-      "esbuild",
-      "oxc-resolver",
-      "unrs-resolver"
-    ]
-  },
-  "scripts": {
-    "build": "pnpm run clean && pnpm run test && pnpm run knip && pnpm run build:prod && pnpm run build:cjs && pnpm run build:browser && pnpm run publint",
-    "build:browser": "vite build -c ./vite.browser.config.ts",
-    "build:prod": "vite build",
-    "build:cjs": "tsup ./src/index.ts --format=cjs --platform=node --outDir=./dist/cjs/ --sourcemap --dts",
-    "clean": "rimraf ./coverage ./dist",
-    "knip": "knip",
-    "prettier": "prettier . --ignore-unknown --write",
-    "publint": "publint --strict",
-    "test": "pnpm run prettier && pnpm run --stream \"/^test:.*/\"",
-    "test:eslint": "eslint ./src ./test --fix",
-    "test:types": "tsc",
-    "test:unit": "vitest"
-  },
-  "version": "4.1.2"
-}

node_modules/@asamuzakjp/css-color/src/index.ts

@@ -1,30 +0,0 @@
-/*!
- * CSS color - Resolve, parse, convert CSS color.
- * @license MIT
- * @copyright asamuzaK (Kazz)
- * @see {@link https://github.com/asamuzaK/cssColor/blob/main/LICENSE}
- */
-
-import { cssCalc } from './js/css-calc';
-import { isGradient, resolveGradient } from './js/css-gradient';
-import { cssVar } from './js/css-var';
-import {
-  extractDashedIdent,
-  isColor,
-  resolveLengthInPixels,
-  splitValue
-} from './js/util';
-
-export { convert } from './js/convert';
-export { resolve } from './js/resolve';
-/* utils */
-export const utils = {
-  cssCalc,
-  cssVar,
-  extractDashedIdent,
-  isColor,
-  isGradient,
-  resolveGradient,
-  resolveLengthInPixels,
-  splitValue
-};

node_modules/@asamuzakjp/css-color/src/js/cache.ts

@@ -1,114 +0,0 @@
-/**
- * cache
- */
-
-import { LRUCache } from 'lru-cache';
-import { Options } from './typedef';
-import { valueToJsonString } from './util';
-
-/* numeric constants */
-const MAX_CACHE = 4096;
-
-/**
- * CacheItem
- */
-export class CacheItem {
-  /* private */
-  #isNull: boolean;
-  #item: unknown;
-
-  /**
-   * constructor
-   */
-  constructor(item: unknown, isNull: boolean = false) {
-    this.#item = item;
-    this.#isNull = !!isNull;
-  }
-
-  get item() {
-    return this.#item;
-  }
-
-  get isNull() {
-    return this.#isNull;
-  }
-}
-
-/**
- * NullObject
- */
-export class NullObject extends CacheItem {
-  /**
-   * constructor
-   */
-  constructor() {
-    super(Symbol('null'), true);
-  }
-}
-
-/*
- * lru cache
- */
-export const lruCache = new LRUCache({
-  max: MAX_CACHE
-});
-
-/**
- * set cache
- * @param key - cache key
- * @param value - value to cache
- * @returns void
- */
-export const setCache = (key: string, value: unknown): void => {
-  if (key) {
-    if (value === null) {
-      lruCache.set(key, new NullObject());
-    } else if (value instanceof CacheItem) {
-      lruCache.set(key, value);
-    } else {
-      lruCache.set(key, new CacheItem(value));
-    }
-  }
-};
-
-/**
- * get cache
- * @param key - cache key
- * @returns cached item or false otherwise
- */
-export const getCache = (key: string): CacheItem | boolean => {
-  if (key && lruCache.has(key)) {
-    const item = lruCache.get(key);
-    if (item instanceof CacheItem) {
-      return item;
-    }
-    // delete unexpected cached item
-    lruCache.delete(key);
-    return false;
-  }
-  return false;
-};
-
-/**
- * create cache key
- * @param keyData - key data
- * @param [opt] - options
- * @returns cache key
- */
-export const createCacheKey = (
-  keyData: Record<string, string>,
-  opt: Options = {}
-): string => {
-  const { customProperty = {}, dimension = {} } = opt;
-  let cacheKey = '';
-  if (
-    keyData &&
-    Object.keys(keyData).length &&
-    typeof customProperty.callback !== 'function' &&
-    typeof dimension.callback !== 'function'
-  ) {
-    keyData.opt = valueToJsonString(opt);
-    cacheKey = valueToJsonString(keyData);
-  }
-  return cacheKey;
-};

node_modules/@asamuzakjp/css-color/src/js/color.ts

@@ -1,3511 +0,0 @@
-/**
- * color
- *
- * Ref: CSS Color Module Level 4
- *      Sample code for Color Conversions
- *      https://w3c.github.io/csswg-drafts/css-color-4/#color-conversion-code
- */
-
-import {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  setCache
-} from './cache';
-import { isString } from './common';
-import { resolveColor } from './resolve';
-import { interpolateHue, roundToPrecision, splitValue } from './util';
-import {
-  ColorChannels,
-  ComputedColorChannels,
-  Options,
-  MatchedRegExp,
-  SpecifiedColorChannels,
-  StringColorChannels,
-  StringColorSpacedChannels
-} from './typedef';
-
-/* constants */
-import {
-  ANGLE,
-  CS_HUE_CAPT,
-  CS_MIX,
-  CS_RGB,
-  CS_XYZ,
-  FN_COLOR,
-  FN_LIGHT_DARK,
-  FN_MIX,
-  NONE,
-  NUM,
-  PCT,
-  SYN_COLOR_TYPE,
-  SYN_FN_COLOR,
-  SYN_HSL,
-  SYN_HSL_LV3,
-  SYN_LCH,
-  SYN_MIX,
-  SYN_MIX_CAPT,
-  SYN_MIX_PART,
-  SYN_MOD,
-  SYN_RGB_LV3,
-  VAL_COMP,
-  VAL_MIX,
-  VAL_SPEC
-} from './constant';
-const NAMESPACE = 'color';
-
-/* numeric constants */
-const PPTH = 0.001;
-const HALF = 0.5;
-const DUO = 2;
-const TRIA = 3;
-const QUAD = 4;
-const OCT = 8;
-const DEC = 10;
-const DOZ = 12;
-const HEX = 16;
-const SEXA = 60;
-const DEG_HALF = 180;
-const DEG = 360;
-const MAX_PCT = 100;
-const MAX_RGB = 255;
-const POW_SQR = 2;
-const POW_CUBE = 3;
-const POW_LINEAR = 2.4;
-const LINEAR_COEF = 12.92;
-const LINEAR_OFFSET = 0.055;
-const LAB_L = 116;
-const LAB_A = 500;
-const LAB_B = 200;
-const LAB_EPSILON = 216 / 24389;
-const LAB_KAPPA = 24389 / 27;
-
-/* type definitions */
-/**
- * @type NumStrColorChannels - string or numeric color channels
- */
-type NumStrColorChannels = [
-  x: number | string,
-  y: number | string,
-  z: number | string,
-  alpha: number | string
-];
-
-/**
- * @type TriColorChannels - color channels without alpha
- */
-type TriColorChannels = [x: number, y: number, z: number];
-
-/**
- * @type ColorMatrix - color matrix
- */
-type ColorMatrix = [
-  r1: TriColorChannels,
-  r2: TriColorChannels,
-  r3: TriColorChannels
-];
-
-/* white point */
-const D50: TriColorChannels = [
-  0.3457 / 0.3585,
-  1.0,
-  (1.0 - 0.3457 - 0.3585) / 0.3585
-];
-const MATRIX_D50_TO_D65: ColorMatrix = [
-  [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
-  [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
-  [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
-];
-const MATRIX_D65_TO_D50: ColorMatrix = [
-  [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
-  [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
-  [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
-];
-
-/* color space */
-const MATRIX_L_RGB_TO_XYZ: ColorMatrix = [
-  [506752 / 1228815, 87881 / 245763, 12673 / 70218],
-  [87098 / 409605, 175762 / 245763, 12673 / 175545],
-  [7918 / 409605, 87881 / 737289, 1001167 / 1053270]
-];
-const MATRIX_XYZ_TO_L_RGB: ColorMatrix = [
-  [12831 / 3959, -329 / 214, -1974 / 3959],
-  [-851781 / 878810, 1648619 / 878810, 36519 / 878810],
-  [705 / 12673, -2585 / 12673, 705 / 667]
-];
-const MATRIX_XYZ_TO_LMS: ColorMatrix = [
-  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
-  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
-  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
-];
-const MATRIX_LMS_TO_XYZ: ColorMatrix = [
-  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
-  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
-  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
-];
-const MATRIX_OKLAB_TO_LMS: ColorMatrix = [
-  [1.0, 0.3963377773761749, 0.2158037573099136],
-  [1.0, -0.1055613458156586, -0.0638541728258133],
-  [1.0, -0.0894841775298119, -1.2914855480194092]
-];
-const MATRIX_LMS_TO_OKLAB: ColorMatrix = [
-  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
-  [1.9779985324311684, -2.4285922420485799, 0.450593709617411],
-  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
-];
-const MATRIX_P3_TO_XYZ: ColorMatrix = [
-  [608311 / 1250200, 189793 / 714400, 198249 / 1000160],
-  [35783 / 156275, 247089 / 357200, 198249 / 2500400],
-  [0 / 1, 32229 / 714400, 5220557 / 5000800]
-];
-const MATRIX_REC2020_TO_XYZ: ColorMatrix = [
-  [63426534 / 99577255, 20160776 / 139408157, 47086771 / 278816314],
-  [26158966 / 99577255, 472592308 / 697040785, 8267143 / 139408157],
-  [0 / 1, 19567812 / 697040785, 295819943 / 278816314]
-];
-const MATRIX_A98_TO_XYZ: ColorMatrix = [
-  [573536 / 994567, 263643 / 1420810, 187206 / 994567],
-  [591459 / 1989134, 6239551 / 9945670, 374412 / 4972835],
-  [53769 / 1989134, 351524 / 4972835, 4929758 / 4972835]
-];
-const MATRIX_PROPHOTO_TO_XYZ_D50: ColorMatrix = [
-  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
-  [0.2880748288194013, 0.711835234241873, 0.00008993693872564],
-  [0.0, 0.0, 0.8251046025104602]
-];
-
-/* regexp */
-const REG_COLOR = new RegExp(`^(?:${SYN_COLOR_TYPE})$`);
-const REG_CS_HUE = new RegExp(`^${CS_HUE_CAPT}$`);
-const REG_CS_XYZ = /^xyz(?:-d(?:50|65))?$/;
-const REG_CURRENT = /^currentColor$/i;
-const REG_FN_COLOR = new RegExp(`^color\\(\\s*(${SYN_FN_COLOR})\\s*\\)$`);
-const REG_HSL = new RegExp(`^hsla?\\(\\s*(${SYN_HSL}|${SYN_HSL_LV3})\\s*\\)$`);
-const REG_HWB = new RegExp(`^hwb\\(\\s*(${SYN_HSL})\\s*\\)$`);
-const REG_LAB = new RegExp(`^lab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-const REG_LCH = new RegExp(`^lch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-const REG_MIX = new RegExp(`^${SYN_MIX}$`);
-const REG_MIX_CAPT = new RegExp(`^${SYN_MIX_CAPT}$`);
-const REG_MIX_NEST = new RegExp(`${SYN_MIX}`, 'g');
-const REG_OKLAB = new RegExp(`^oklab\\(\\s*(${SYN_MOD})\\s*\\)$`);
-const REG_OKLCH = new RegExp(`^oklch\\(\\s*(${SYN_LCH})\\s*\\)$`);
-const REG_SPEC = /^(?:specifi|comput)edValue$/;
-
-/**
- * named colors
- */
-export const NAMED_COLORS = {
-  aliceblue: [0xf0, 0xf8, 0xff],
-  antiquewhite: [0xfa, 0xeb, 0xd7],
-  aqua: [0x00, 0xff, 0xff],
-  aquamarine: [0x7f, 0xff, 0xd4],
-  azure: [0xf0, 0xff, 0xff],
-  beige: [0xf5, 0xf5, 0xdc],
-  bisque: [0xff, 0xe4, 0xc4],
-  black: [0x00, 0x00, 0x00],
-  blanchedalmond: [0xff, 0xeb, 0xcd],
-  blue: [0x00, 0x00, 0xff],
-  blueviolet: [0x8a, 0x2b, 0xe2],
-  brown: [0xa5, 0x2a, 0x2a],
-  burlywood: [0xde, 0xb8, 0x87],
-  cadetblue: [0x5f, 0x9e, 0xa0],
-  chartreuse: [0x7f, 0xff, 0x00],
-  chocolate: [0xd2, 0x69, 0x1e],
-  coral: [0xff, 0x7f, 0x50],
-  cornflowerblue: [0x64, 0x95, 0xed],
-  cornsilk: [0xff, 0xf8, 0xdc],
-  crimson: [0xdc, 0x14, 0x3c],
-  cyan: [0x00, 0xff, 0xff],
-  darkblue: [0x00, 0x00, 0x8b],
-  darkcyan: [0x00, 0x8b, 0x8b],
-  darkgoldenrod: [0xb8, 0x86, 0x0b],
-  darkgray: [0xa9, 0xa9, 0xa9],
-  darkgreen: [0x00, 0x64, 0x00],
-  darkgrey: [0xa9, 0xa9, 0xa9],
-  darkkhaki: [0xbd, 0xb7, 0x6b],
-  darkmagenta: [0x8b, 0x00, 0x8b],
-  darkolivegreen: [0x55, 0x6b, 0x2f],
-  darkorange: [0xff, 0x8c, 0x00],
-  darkorchid: [0x99, 0x32, 0xcc],
-  darkred: [0x8b, 0x00, 0x00],
-  darksalmon: [0xe9, 0x96, 0x7a],
-  darkseagreen: [0x8f, 0xbc, 0x8f],
-  darkslateblue: [0x48, 0x3d, 0x8b],
-  darkslategray: [0x2f, 0x4f, 0x4f],
-  darkslategrey: [0x2f, 0x4f, 0x4f],
-  darkturquoise: [0x00, 0xce, 0xd1],
-  darkviolet: [0x94, 0x00, 0xd3],
-  deeppink: [0xff, 0x14, 0x93],
-  deepskyblue: [0x00, 0xbf, 0xff],
-  dimgray: [0x69, 0x69, 0x69],
-  dimgrey: [0x69, 0x69, 0x69],
-  dodgerblue: [0x1e, 0x90, 0xff],
-  firebrick: [0xb2, 0x22, 0x22],
-  floralwhite: [0xff, 0xfa, 0xf0],
-  forestgreen: [0x22, 0x8b, 0x22],
-  fuchsia: [0xff, 0x00, 0xff],
-  gainsboro: [0xdc, 0xdc, 0xdc],
-  ghostwhite: [0xf8, 0xf8, 0xff],
-  gold: [0xff, 0xd7, 0x00],
-  goldenrod: [0xda, 0xa5, 0x20],
-  gray: [0x80, 0x80, 0x80],
-  green: [0x00, 0x80, 0x00],
-  greenyellow: [0xad, 0xff, 0x2f],
-  grey: [0x80, 0x80, 0x80],
-  honeydew: [0xf0, 0xff, 0xf0],
-  hotpink: [0xff, 0x69, 0xb4],
-  indianred: [0xcd, 0x5c, 0x5c],
-  indigo: [0x4b, 0x00, 0x82],
-  ivory: [0xff, 0xff, 0xf0],
-  khaki: [0xf0, 0xe6, 0x8c],
-  lavender: [0xe6, 0xe6, 0xfa],
-  lavenderblush: [0xff, 0xf0, 0xf5],
-  lawngreen: [0x7c, 0xfc, 0x00],
-  lemonchiffon: [0xff, 0xfa, 0xcd],
-  lightblue: [0xad, 0xd8, 0xe6],
-  lightcoral: [0xf0, 0x80, 0x80],
-  lightcyan: [0xe0, 0xff, 0xff],
-  lightgoldenrodyellow: [0xfa, 0xfa, 0xd2],
-  lightgray: [0xd3, 0xd3, 0xd3],
-  lightgreen: [0x90, 0xee, 0x90],
-  lightgrey: [0xd3, 0xd3, 0xd3],
-  lightpink: [0xff, 0xb6, 0xc1],
-  lightsalmon: [0xff, 0xa0, 0x7a],
-  lightseagreen: [0x20, 0xb2, 0xaa],
-  lightskyblue: [0x87, 0xce, 0xfa],
-  lightslategray: [0x77, 0x88, 0x99],
-  lightslategrey: [0x77, 0x88, 0x99],
-  lightsteelblue: [0xb0, 0xc4, 0xde],
-  lightyellow: [0xff, 0xff, 0xe0],
-  lime: [0x00, 0xff, 0x00],
-  limegreen: [0x32, 0xcd, 0x32],
-  linen: [0xfa, 0xf0, 0xe6],
-  magenta: [0xff, 0x00, 0xff],
-  maroon: [0x80, 0x00, 0x00],
-  mediumaquamarine: [0x66, 0xcd, 0xaa],
-  mediumblue: [0x00, 0x00, 0xcd],
-  mediumorchid: [0xba, 0x55, 0xd3],
-  mediumpurple: [0x93, 0x70, 0xdb],
-  mediumseagreen: [0x3c, 0xb3, 0x71],
-  mediumslateblue: [0x7b, 0x68, 0xee],
-  mediumspringgreen: [0x00, 0xfa, 0x9a],
-  mediumturquoise: [0x48, 0xd1, 0xcc],
-  mediumvioletred: [0xc7, 0x15, 0x85],
-  midnightblue: [0x19, 0x19, 0x70],
-  mintcream: [0xf5, 0xff, 0xfa],
-  mistyrose: [0xff, 0xe4, 0xe1],
-  moccasin: [0xff, 0xe4, 0xb5],
-  navajowhite: [0xff, 0xde, 0xad],
-  navy: [0x00, 0x00, 0x80],
-  oldlace: [0xfd, 0xf5, 0xe6],
-  olive: [0x80, 0x80, 0x00],
-  olivedrab: [0x6b, 0x8e, 0x23],
-  orange: [0xff, 0xa5, 0x00],
-  orangered: [0xff, 0x45, 0x00],
-  orchid: [0xda, 0x70, 0xd6],
-  palegoldenrod: [0xee, 0xe8, 0xaa],
-  palegreen: [0x98, 0xfb, 0x98],
-  paleturquoise: [0xaf, 0xee, 0xee],
-  palevioletred: [0xdb, 0x70, 0x93],
-  papayawhip: [0xff, 0xef, 0xd5],
-  peachpuff: [0xff, 0xda, 0xb9],
-  peru: [0xcd, 0x85, 0x3f],
-  pink: [0xff, 0xc0, 0xcb],
-  plum: [0xdd, 0xa0, 0xdd],
-  powderblue: [0xb0, 0xe0, 0xe6],
-  purple: [0x80, 0x00, 0x80],
-  rebeccapurple: [0x66, 0x33, 0x99],
-  red: [0xff, 0x00, 0x00],
-  rosybrown: [0xbc, 0x8f, 0x8f],
-  royalblue: [0x41, 0x69, 0xe1],
-  saddlebrown: [0x8b, 0x45, 0x13],
-  salmon: [0xfa, 0x80, 0x72],
-  sandybrown: [0xf4, 0xa4, 0x60],
-  seagreen: [0x2e, 0x8b, 0x57],
-  seashell: [0xff, 0xf5, 0xee],
-  sienna: [0xa0, 0x52, 0x2d],
-  silver: [0xc0, 0xc0, 0xc0],
-  skyblue: [0x87, 0xce, 0xeb],
-  slateblue: [0x6a, 0x5a, 0xcd],
-  slategray: [0x70, 0x80, 0x90],
-  slategrey: [0x70, 0x80, 0x90],
-  snow: [0xff, 0xfa, 0xfa],
-  springgreen: [0x00, 0xff, 0x7f],
-  steelblue: [0x46, 0x82, 0xb4],
-  tan: [0xd2, 0xb4, 0x8c],
-  teal: [0x00, 0x80, 0x80],
-  thistle: [0xd8, 0xbf, 0xd8],
-  tomato: [0xff, 0x63, 0x47],
-  turquoise: [0x40, 0xe0, 0xd0],
-  violet: [0xee, 0x82, 0xee],
-  wheat: [0xf5, 0xde, 0xb3],
-  white: [0xff, 0xff, 0xff],
-  whitesmoke: [0xf5, 0xf5, 0xf5],
-  yellow: [0xff, 0xff, 0x00],
-  yellowgreen: [0x9a, 0xcd, 0x32]
-} as const satisfies {
-  [key: string]: TriColorChannels;
-};
-
-/**
- * cache invalid color value
- * @param key - cache key
- * @param nullable - is nullable
- * @returns cached value
- */
-export const cacheInvalidColorValue = (
-  cacheKey: string,
-  format: string,
-  nullable: boolean = false
-): SpecifiedColorChannels | string | NullObject => {
-  if (format === VAL_SPEC) {
-    const res = '';
-    setCache(cacheKey, res);
-    return res;
-  }
-  if (nullable) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
-  setCache(cacheKey, res);
-  return res;
-};
-
-/**
- * resolve invalid color value
- * @param format - output format
- * @param nullable - is nullable
- * @returns resolved value
- */
-export const resolveInvalidColorValue = (
-  format: string,
-  nullable: boolean = false
-): SpecifiedColorChannels | string | NullObject => {
-  switch (format) {
-    case 'hsl':
-    case 'hwb':
-    case VAL_MIX: {
-      return new NullObject();
-    }
-    case VAL_SPEC: {
-      return '';
-    }
-    default: {
-      if (nullable) {
-        return new NullObject();
-      }
-      return ['rgb', 0, 0, 0, 0] as SpecifiedColorChannels;
-    }
-  }
-};
-
-/**
- * validate color components
- * @param arr - color components
- * @param [opt] - options
- * @param [opt.alpha] - alpha channel
- * @param [opt.minLength] - min length
- * @param [opt.maxLength] - max length
- * @param [opt.minRange] - min range
- * @param [opt.maxRange] - max range
- * @param [opt.validateRange] - validate range
- * @returns result - validated color components
- */
-export const validateColorComponents = (
-  arr: ColorChannels | TriColorChannels,
-  opt: {
-    alpha?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    minRange?: number;
-    maxRange?: number;
-    validateRange?: boolean;
-  } = {}
-): ColorChannels | TriColorChannels => {
-  if (!Array.isArray(arr)) {
-    throw new TypeError(`${arr} is not an array.`);
-  }
-  const {
-    alpha = false,
-    minLength = TRIA,
-    maxLength = QUAD,
-    minRange = 0,
-    maxRange = 1,
-    validateRange = true
-  } = opt;
-  if (!Number.isFinite(minLength)) {
-    throw new TypeError(`${minLength} is not a number.`);
-  }
-  if (!Number.isFinite(maxLength)) {
-    throw new TypeError(`${maxLength} is not a number.`);
-  }
-  if (!Number.isFinite(minRange)) {
-    throw new TypeError(`${minRange} is not a number.`);
-  }
-  if (!Number.isFinite(maxRange)) {
-    throw new TypeError(`${maxRange} is not a number.`);
-  }
-  const l = arr.length;
-  if (l < minLength || l > maxLength) {
-    throw new Error(`Unexpected array length ${l}.`);
-  }
-  let i = 0;
-  while (i < l) {
-    const v = arr[i] as number;
-    if (!Number.isFinite(v)) {
-      throw new TypeError(`${v} is not a number.`);
-    } else if (i < TRIA && validateRange && (v < minRange || v > maxRange)) {
-      throw new RangeError(`${v} is not between ${minRange} and ${maxRange}.`);
-    } else if (i === TRIA && (v < 0 || v > 1)) {
-      throw new RangeError(`${v} is not between 0 and 1.`);
-    }
-    i++;
-  }
-  if (alpha && l === TRIA) {
-    arr.push(1);
-  }
-  return arr;
-};
-
-/**
- * transform matrix
- * @param mtx - 3 * 3 matrix
- * @param vct - vector
- * @param [skip] - skip validate
- * @returns TriColorChannels - [p1, p2, p3]
- */
-export const transformMatrix = (
-  mtx: ColorMatrix,
-  vct: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!Array.isArray(mtx)) {
-    throw new TypeError(`${mtx} is not an array.`);
-  } else if (mtx.length !== TRIA) {
-    throw new Error(`Unexpected array length ${mtx.length}.`);
-  } else if (!skip) {
-    for (let i of mtx) {
-      i = validateColorComponents(i as TriColorChannels, {
-        maxLength: TRIA,
-        validateRange: false
-      }) as TriColorChannels;
-    }
-  }
-  const [[r1c1, r1c2, r1c3], [r2c1, r2c2, r2c3], [r3c1, r3c2, r3c3]] = mtx;
-  let v1, v2, v3;
-  if (skip) {
-    [v1, v2, v3] = vct;
-  } else {
-    [v1, v2, v3] = validateColorComponents(vct, {
-      maxLength: TRIA,
-      validateRange: false
-    });
-  }
-  const p1 = r1c1 * v1 + r1c2 * v2 + r1c3 * v3;
-  const p2 = r2c1 * v1 + r2c2 * v2 + r2c3 * v3;
-  const p3 = r3c1 * v1 + r3c2 * v2 + r3c3 * v3;
-  return [p1, p2, p3];
-};
-
-/**
- * normalize color components
- * @param colorA - color components [v1, v2, v3, v4]
- * @param colorB - color components [v1, v2, v3, v4]
- * @param [skip] - skip validate
- * @returns result - [colorA, colorB]
- */
-export const normalizeColorComponents = (
-  colorA: [number | string, number | string, number | string, number | string],
-  colorB: [number | string, number | string, number | string, number | string],
-  skip: boolean = false
-): [ColorChannels, ColorChannels] => {
-  if (!Array.isArray(colorA)) {
-    throw new TypeError(`${colorA} is not an array.`);
-  } else if (colorA.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorA.length}.`);
-  }
-  if (!Array.isArray(colorB)) {
-    throw new TypeError(`${colorB} is not an array.`);
-  } else if (colorB.length !== QUAD) {
-    throw new Error(`Unexpected array length ${colorB.length}.`);
-  }
-  let i = 0;
-  while (i < QUAD) {
-    if (colorA[i] === NONE && colorB[i] === NONE) {
-      colorA[i] = 0;
-      colorB[i] = 0;
-    } else if (colorA[i] === NONE) {
-      colorA[i] = colorB[i] as number;
-    } else if (colorB[i] === NONE) {
-      colorB[i] = colorA[i] as number;
-    }
-    i++;
-  }
-  if (skip) {
-    return [colorA as ColorChannels, colorB as ColorChannels];
-  }
-  const validatedColorA = validateColorComponents(colorA as ColorChannels, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  const validatedColorB = validateColorComponents(colorB as ColorChannels, {
-    minLength: QUAD,
-    validateRange: false
-  });
-  return [validatedColorA as ColorChannels, validatedColorB as ColorChannels];
-};
-
-/**
- * number to hex string
- * @param value - numeric value
- * @returns hex string
- */
-export const numberToHexString = (value: number): string => {
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`${value} is not a number.`);
-  } else {
-    value = Math.round(value);
-    if (value < 0 || value > MAX_RGB) {
-      throw new RangeError(`${value} is not between 0 and ${MAX_RGB}.`);
-    }
-  }
-  let hex = value.toString(HEX);
-  if (hex.length === 1) {
-    hex = `0${hex}`;
-  }
-  return hex;
-};
-
-/**
- * angle to deg
- * @param angle
- * @returns deg: 0..360
- */
-export const angleToDeg = (angle: string): number => {
-  if (isString(angle)) {
-    angle = angle.trim();
-  } else {
-    throw new TypeError(`${angle} is not a string.`);
-  }
-  const GRAD = DEG / 400;
-  const RAD = DEG / (Math.PI * DUO);
-  const reg = new RegExp(`^(${NUM})(${ANGLE})?$`);
-  if (!reg.test(angle)) {
-    throw new SyntaxError(`Invalid property value: ${angle}`);
-  }
-  const [, value, unit] = angle.match(reg) as MatchedRegExp;
-  let deg;
-  switch (unit) {
-    case 'grad':
-      deg = parseFloat(value) * GRAD;
-      break;
-    case 'rad':
-      deg = parseFloat(value) * RAD;
-      break;
-    case 'turn':
-      deg = parseFloat(value) * DEG;
-      break;
-    default:
-      deg = parseFloat(value);
-  }
-  deg %= DEG;
-  if (deg < 0) {
-    deg += DEG;
-  } else if (Object.is(deg, -0)) {
-    deg = 0;
-  }
-  return deg;
-};
-
-/**
- * parse alpha
- * @param [alpha] - alpha value
- * @returns alpha: 0..1
- */
-export const parseAlpha = (alpha: string = ''): number => {
-  if (isString(alpha)) {
-    alpha = alpha.trim();
-    if (!alpha) {
-      alpha = '1';
-    } else if (alpha === NONE) {
-      alpha = '0';
-    } else {
-      let a;
-      if (alpha.endsWith('%')) {
-        a = parseFloat(alpha) / MAX_PCT;
-      } else {
-        a = parseFloat(alpha);
-      }
-      if (!Number.isFinite(a)) {
-        throw new TypeError(`${a} is not a finite number.`);
-      }
-      if (a < PPTH) {
-        alpha = '0';
-      } else if (a > 1) {
-        alpha = '1';
-      } else {
-        alpha = a.toFixed(TRIA);
-      }
-    }
-  } else {
-    alpha = '1';
-  }
-  return parseFloat(alpha);
-};
-
-/**
- * parse hex alpha
- * @param value - alpha value in hex string
- * @returns alpha: 0..1
- */
-export const parseHexAlpha = (value: string): number => {
-  if (isString(value)) {
-    if (value === '') {
-      throw new SyntaxError('Invalid property value: (empty string)');
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  let alpha = parseInt(value, HEX);
-  if (alpha <= 0) {
-    return 0;
-  }
-  if (alpha >= MAX_RGB) {
-    return 1;
-  }
-  const alphaMap = new Map();
-  for (let i = 1; i < MAX_PCT; i++) {
-    alphaMap.set(Math.round((i * MAX_RGB) / MAX_PCT), i);
-  }
-  if (alphaMap.has(alpha)) {
-    alpha = alphaMap.get(alpha) / MAX_PCT;
-  } else {
-    alpha = Math.round(alpha / MAX_RGB / PPTH) * PPTH;
-  }
-  return parseFloat(alpha.toFixed(TRIA));
-};
-
-/**
- * transform rgb to linear rgb
- * @param rgb - [r, g, b] r|g|b: 0..255
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..1
- */
-export const transformRgbToLinearRgb = (
-  rgb: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  let rr, gg, bb;
-  if (skip) {
-    [rr, gg, bb] = rgb;
-  } else {
-    [rr, gg, bb] = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    });
-  }
-  let r = rr / MAX_RGB;
-  let g = gg / MAX_RGB;
-  let b = bb / MAX_RGB;
-  const COND_POW = 0.04045;
-  if (r > COND_POW) {
-    r = Math.pow((r + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    r /= LINEAR_COEF;
-  }
-  if (g > COND_POW) {
-    g = Math.pow((g + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    g /= LINEAR_COEF;
-  }
-  if (b > COND_POW) {
-    b = Math.pow((b + LINEAR_OFFSET) / (1 + LINEAR_OFFSET), POW_LINEAR);
-  } else {
-    b /= LINEAR_COEF;
-  }
-  return [r, g, b];
-};
-
-/**
- * transform rgb to xyz
- * @param rgb - [r, g, b] r|g|b: 0..255
- * @param [skip] - skip validate
- * @returns TriColorChannels - [x, y, z]
- */
-export const transformRgbToXyz = (
-  rgb: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!skip) {
-    rgb = validateColorComponents(rgb, {
-      maxLength: TRIA,
-      maxRange: MAX_RGB
-    }) as TriColorChannels;
-  }
-  rgb = transformRgbToLinearRgb(rgb, true);
-  const xyz = transformMatrix(MATRIX_L_RGB_TO_XYZ, rgb, true);
-  return xyz;
-};
-
-/**
- * transform rgb to xyz-d50
- * @param rgb - [r, g, b] r|g|b: 0..255 alpha: 0..1
- * @returns TriColorChannels - [x, y, z]
- */
-export const transformRgbToXyzD50 = (
-  rgb: TriColorChannels
-): TriColorChannels => {
-  let xyz = transformRgbToXyz(rgb);
-  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);
-  return xyz;
-};
-
-/**
- * transform linear rgb to rgb
- * @param rgb - [r, g, b] r|g|b: 0..1
- * @param [round] - round result
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export const transformLinearRgbToRgb = (
-  rgb: TriColorChannels,
-  round: boolean = false
-): TriColorChannels => {
-  let [r, g, b] = validateColorComponents(rgb, {
-    maxLength: TRIA
-  });
-  const COND_POW = 809 / 258400;
-  if (r > COND_POW) {
-    r = Math.pow(r, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    r *= LINEAR_COEF;
-  }
-  r *= MAX_RGB;
-  if (g > COND_POW) {
-    g = Math.pow(g, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    g *= LINEAR_COEF;
-  }
-  g *= MAX_RGB;
-  if (b > COND_POW) {
-    b = Math.pow(b, 1 / POW_LINEAR) * (1 + LINEAR_OFFSET) - LINEAR_OFFSET;
-  } else {
-    b *= LINEAR_COEF;
-  }
-  b *= MAX_RGB;
-  return [
-    round ? Math.round(r) : r,
-    round ? Math.round(g) : g,
-    round ? Math.round(b) : b
-  ];
-};
-
-/**
- * transform xyz to rgb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export const transformXyzToRgb = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    }) as TriColorChannels;
-  }
-  let [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyz, true);
-  [r, g, b] = transformLinearRgbToRgb(
-    [
-      Math.min(Math.max(r, 0), 1),
-      Math.min(Math.max(g, 0), 1),
-      Math.min(Math.max(b, 0), 1)
-    ],
-    true
-  );
-  return [r, g, b];
-};
-
-/**
- * transform xyz to xyz-d50
- * @param xyz - [x, y, z]
- * @returns TriColorChannels - [x, y, z]
- */
-export const transformXyzToXyzD50 = (
-  xyz: TriColorChannels
-): TriColorChannels => {
-  xyz = validateColorComponents(xyz, {
-    maxLength: TRIA,
-    validateRange: false
-  }) as TriColorChannels;
-  xyz = transformMatrix(MATRIX_D65_TO_D50, xyz, true);
-  return xyz;
-};
-
-/**
- * transform xyz to hsl
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [h, s, l]
- */
-export const transformXyzToHsl = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  const [rr, gg, bb] = transformXyzToRgb(xyz, skip);
-  const r = rr / MAX_RGB;
-  const g = gg / MAX_RGB;
-  const b = bb / MAX_RGB;
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  const d = max - min;
-  const l = (max + min) * HALF * MAX_PCT;
-  let h, s;
-  if (Math.round(l) === 0 || Math.round(l) === MAX_PCT) {
-    h = 0;
-    s = 0;
-  } else {
-    s = (d / (1 - Math.abs(max + min - 1))) * MAX_PCT;
-    if (s === 0) {
-      h = 0;
-    } else {
-      switch (max) {
-        case r:
-          h = (g - b) / d;
-          break;
-        case g:
-          h = (b - r) / d + DUO;
-          break;
-        case b:
-        default:
-          h = (r - g) / d + QUAD;
-          break;
-      }
-      h = (h * SEXA) % DEG;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [h, s, l];
-};
-
-/**
- * transform xyz to hwb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [h, w, b]
- */
-export const transformXyzToHwb = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  const [r, g, b] = transformXyzToRgb(xyz, skip);
-  const wh = Math.min(r, g, b) / MAX_RGB;
-  const bk = 1 - Math.max(r, g, b) / MAX_RGB;
-  let h;
-  if (wh + bk === 1) {
-    h = 0;
-  } else {
-    [h] = transformXyzToHsl(xyz);
-  }
-  return [h, wh * MAX_PCT, bk * MAX_PCT];
-};
-
-/**
- * transform xyz to oklab
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, a, b]
- */
-export const transformXyzToOklab = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    }) as TriColorChannels;
-  }
-  const lms = transformMatrix(MATRIX_XYZ_TO_LMS, xyz, true);
-  const xyzLms = lms.map(c => Math.cbrt(c)) as TriColorChannels;
-  let [l, a, b] = transformMatrix(MATRIX_LMS_TO_OKLAB, xyzLms, true);
-  l = Math.min(Math.max(l, 0), 1);
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    a = 0;
-    b = 0;
-  }
-  return [l, a, b];
-};
-
-/**
- * transform xyz to oklch
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, c, h]
- */
-export const transformXyzToOklch = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  const [l, a, b] = transformXyzToOklab(xyz, skip);
-  let c, h;
-  const lPct = Math.round(parseFloat(l.toFixed(QUAD)) * MAX_PCT);
-  if (lPct === 0 || lPct === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    if (parseFloat(c.toFixed(QUAD)) === 0) {
-      h = 0;
-    } else {
-      h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;
-      if (h < 0) {
-        h += DEG;
-      }
-    }
-  }
-  return [l, c, h];
-};
-
-/**
- * transform xyz D50 to rgb
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [r, g, b] r|g|b: 0..255
- */
-export const transformXyzD50ToRgb = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    }) as TriColorChannels;
-  }
-  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, xyz, true);
-  const rgb = transformXyzToRgb(xyzD65, true);
-  return rgb;
-};
-
-/**
- * transform xyz-d50 to lab
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, a, b]
- */
-export const transformXyzD50ToLab = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  if (!skip) {
-    xyz = validateColorComponents(xyz, {
-      maxLength: TRIA,
-      validateRange: false
-    }) as TriColorChannels;
-  }
-  const xyzD50 = xyz.map((val, i) => val / (D50[i] as number));
-  const [f0, f1, f2] = xyzD50.map(val =>
-    val > LAB_EPSILON ? Math.cbrt(val) : (val * LAB_KAPPA + HEX) / LAB_L
-  ) as TriColorChannels;
-  const l = Math.min(Math.max(LAB_L * f1 - HEX, 0), MAX_PCT);
-  let a, b;
-  if (l === 0 || l === MAX_PCT) {
-    a = 0;
-    b = 0;
-  } else {
-    a = (f0 - f1) * LAB_A;
-    b = (f1 - f2) * LAB_B;
-  }
-  return [l, a, b];
-};
-
-/**
- * transform xyz-d50 to lch
- * @param xyz - [x, y, z]
- * @param [skip] - skip validate
- * @returns TriColorChannels - [l, c, h]
- */
-export const transformXyzD50ToLch = (
-  xyz: TriColorChannels,
-  skip: boolean = false
-): TriColorChannels => {
-  const [l, a, b] = transformXyzD50ToLab(xyz, skip);
-  let c, h;
-  if (l === 0 || l === MAX_PCT) {
-    c = 0;
-    h = 0;
-  } else {
-    c = Math.max(Math.sqrt(Math.pow(a, POW_SQR) + Math.pow(b, POW_SQR)), 0);
-    h = (Math.atan2(b, a) * DEG_HALF) / Math.PI;
-    if (h < 0) {
-      h += DEG;
-    }
-  }
-  return [l, c, h];
-};
-
-/**
- * convert rgb to hex color
- * @param rgb - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- * @returns hex color
- */
-export const convertRgbToHex = (rgb: ColorChannels): string => {
-  const [r, g, b, alpha] = validateColorComponents(rgb, {
-    alpha: true,
-    maxRange: MAX_RGB
-  }) as ColorChannels;
-  const rr = numberToHexString(r);
-  const gg = numberToHexString(g);
-  const bb = numberToHexString(b);
-  const aa = numberToHexString(alpha * MAX_RGB);
-  let hex;
-  if (aa === 'ff') {
-    hex = `#${rr}${gg}${bb}`;
-  } else {
-    hex = `#${rr}${gg}${bb}${aa}`;
-  }
-  return hex;
-};
-
-/**
- * convert linear rgb to hex color
- * @param rgb - [r, g, b, alpha] r|g|b|alpha: 0..1
- * @param [skip] - skip validate
- * @returns hex color
- */
-export const convertLinearRgbToHex = (
-  rgb: ColorChannels,
-  skip: boolean = false
-): string => {
-  let r, g, b, alpha;
-  if (skip) {
-    [r, g, b, alpha] = rgb;
-  } else {
-    [r, g, b, alpha] = validateColorComponents(rgb, {
-      minLength: QUAD
-    }) as ColorChannels;
-  }
-  [r, g, b] = transformLinearRgbToRgb([r, g, b], true);
-  const rr = numberToHexString(r);
-  const gg = numberToHexString(g);
-  const bb = numberToHexString(b);
-  const aa = numberToHexString(alpha * MAX_RGB);
-  let hex;
-  if (aa === 'ff') {
-    hex = `#${rr}${gg}${bb}`;
-  } else {
-    hex = `#${rr}${gg}${bb}${aa}`;
-  }
-  return hex;
-};
-
-/**
- * convert xyz to hex color
- * @param xyz - [x, y, z, alpha]
- * @returns hex color
- */
-export const convertXyzToHex = (xyz: ColorChannels): string => {
-  const [x, y, z, alpha] = validateColorComponents(xyz, {
-    minLength: QUAD,
-    validateRange: false
-  }) as ColorChannels;
-  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  const hex = convertLinearRgbToHex(
-    [
-      Math.min(Math.max(r, 0), 1),
-      Math.min(Math.max(g, 0), 1),
-      Math.min(Math.max(b, 0), 1),
-      alpha
-    ],
-    true
-  );
-  return hex;
-};
-
-/**
- * convert xyz D50 to hex color
- * @param xyz - [x, y, z, alpha]
- * @returns hex color
- */
-export const convertXyzD50ToHex = (xyz: ColorChannels): string => {
-  const [x, y, z, alpha] = validateColorComponents(xyz, {
-    minLength: QUAD,
-    validateRange: false
-  }) as ColorChannels;
-  const xyzD65 = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-  const [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, xyzD65, true);
-  const hex = convertLinearRgbToHex([
-    Math.min(Math.max(r, 0), 1),
-    Math.min(Math.max(g, 0), 1),
-    Math.min(Math.max(b, 0), 1),
-    alpha
-  ]);
-  return hex;
-};
-
-/**
- * convert hex color to rgb
- * @param value - hex color value
- * @returns ColorChannels - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- */
-export const convertHexToRgb = (value: string): ColorChannels => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  if (
-    !(
-      /^#[\da-f]{6}$/.test(value) ||
-      /^#[\da-f]{3}$/.test(value) ||
-      /^#[\da-f]{8}$/.test(value) ||
-      /^#[\da-f]{4}$/.test(value)
-    )
-  ) {
-    throw new SyntaxError(`Invalid property value: ${value}`);
-  }
-  const arr: number[] = [];
-  if (/^#[\da-f]{3}$/.test(value)) {
-    const [, r, g, b] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])$/
-    ) as MatchedRegExp;
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      1
-    );
-  } else if (/^#[\da-f]{4}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f])([\da-f])([\da-f])([\da-f])$/
-    ) as MatchedRegExp;
-    arr.push(
-      parseInt(`${r}${r}`, HEX),
-      parseInt(`${g}${g}`, HEX),
-      parseInt(`${b}${b}`, HEX),
-      parseHexAlpha(`${alpha}${alpha}`)
-    );
-  } else if (/^#[\da-f]{8}$/.test(value)) {
-    const [, r, g, b, alpha] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    ) as MatchedRegExp;
-    arr.push(
-      parseInt(r, HEX),
-      parseInt(g, HEX),
-      parseInt(b, HEX),
-      parseHexAlpha(alpha)
-    );
-  } else {
-    const [, r, g, b] = value.match(
-      /^#([\da-f]{2})([\da-f]{2})([\da-f]{2})$/
-    ) as MatchedRegExp;
-    arr.push(parseInt(r, HEX), parseInt(g, HEX), parseInt(b, HEX), 1);
-  }
-  return arr as ColorChannels;
-};
-
-/**
- * convert hex color to linear rgb
- * @param value - hex color value
- * @returns ColorChannels - [r, g, b, alpha] r|g|b|alpha: 0..1
- */
-export const convertHexToLinearRgb = (value: string): ColorChannels => {
-  const [rr, gg, bb, alpha] = convertHexToRgb(value);
-  const [r, g, b] = transformRgbToLinearRgb([rr, gg, bb], true);
-  return [r, g, b, alpha];
-};
-
-/**
- * convert hex color to xyz
- * @param value - hex color value
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export const convertHexToXyz = (value: string): ColorChannels => {
-  const [r, g, b, alpha] = convertHexToLinearRgb(value);
-  const [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b], true);
-  return [x, y, z, alpha];
-};
-
-/**
- * parse rgb()
- * @param value - rgb color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export const parseRgb = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  const reg = new RegExp(`^rgba?\\(\\s*(${SYN_MOD}|${SYN_RGB_LV3})\\s*\\)$`);
-  if (!reg.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const [, val] = value.match(reg) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace(/[,/]/g, ' ')
-    .split(/\s+/) as StringColorChannels;
-  let r, g, b;
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    if (v1.endsWith('%')) {
-      r = (parseFloat(v1) * MAX_RGB) / MAX_PCT;
-    } else {
-      r = parseFloat(v1);
-    }
-    r = Math.min(Math.max(roundToPrecision(r, OCT), 0), MAX_RGB);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    if (v2.endsWith('%')) {
-      g = (parseFloat(v2) * MAX_RGB) / MAX_PCT;
-    } else {
-      g = parseFloat(v2);
-    }
-    g = Math.min(Math.max(roundToPrecision(g, OCT), 0), MAX_RGB);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    if (v3.endsWith('%')) {
-      b = (parseFloat(v3) * MAX_RGB) / MAX_PCT;
-    } else {
-      b = parseFloat(v3);
-    }
-    b = Math.min(Math.max(roundToPrecision(b, OCT), 0), MAX_RGB);
-  }
-  const alpha = parseAlpha(v4);
-  return ['rgb', r, g, b, format === VAL_MIX && v4 === NONE ? NONE : alpha];
-};
-
-/**
- * parse hsl()
- * @param value - hsl color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export const parseHsl = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_HSL.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const [, val] = value.match(REG_HSL) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace(/[,/]/g, ' ')
-    .split(/\s+/) as StringColorChannels;
-  let h, s, l;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    s = 0;
-  } else {
-    s = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT);
-  }
-  if (v3 === NONE) {
-    l = 0;
-  } else {
-    l = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT);
-  }
-  const alpha = parseAlpha(v4);
-  if (format === 'hsl') {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : s,
-      v3 === NONE ? v3 : l,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  h = (h / DEG) * DOZ;
-  l /= MAX_PCT;
-  const sa = (s / MAX_PCT) * Math.min(l, 1 - l);
-  const rk = h % DOZ;
-  const gk = (8 + h) % DOZ;
-  const bk = (4 + h) % DOZ;
-  const r = l - sa * Math.max(-1, Math.min(rk - TRIA, TRIA ** POW_SQR - rk, 1));
-  const g = l - sa * Math.max(-1, Math.min(gk - TRIA, TRIA ** POW_SQR - gk, 1));
-  const b = l - sa * Math.max(-1, Math.min(bk - TRIA, TRIA ** POW_SQR - bk, 1));
-  return [
-    'rgb',
-    Math.min(Math.max(roundToPrecision(r * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(g * MAX_RGB, OCT), 0), MAX_RGB),
-    Math.min(Math.max(roundToPrecision(b * MAX_RGB, OCT), 0), MAX_RGB),
-    alpha
-  ];
-};
-
-/**
- * parse hwb()
- * @param value - hwb color value
- * @param [opt] - options
- * @returns parsed color - ['rgb', r, g, b, alpha], '(empty)', NullObject
- */
-export const parseHwb = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_HWB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const [, val] = value.match(REG_HWB) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorChannels;
-  let h, wh, bk;
-  if (v1 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v1);
-  }
-  if (v2 === NONE) {
-    wh = 0;
-  } else {
-    wh = Math.min(Math.max(parseFloat(v2), 0), MAX_PCT) / MAX_PCT;
-  }
-  if (v3 === NONE) {
-    bk = 0;
-  } else {
-    bk = Math.min(Math.max(parseFloat(v3), 0), MAX_PCT) / MAX_PCT;
-  }
-  const alpha = parseAlpha(v4);
-  if (format === 'hwb') {
-    return [
-      format,
-      v1 === NONE ? v1 : h,
-      v2 === NONE ? v2 : wh * MAX_PCT,
-      v3 === NONE ? v3 : bk * MAX_PCT,
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  if (wh + bk >= 1) {
-    const v = roundToPrecision((wh / (wh + bk)) * MAX_RGB, OCT);
-    return ['rgb', v, v, v, alpha];
-  }
-  const factor = (1 - wh - bk) / MAX_RGB;
-  let [, r, g, b] = parseHsl(`hsl(${h} 100 50)`) as ComputedColorChannels;
-  r = roundToPrecision((r * factor + wh) * MAX_RGB, OCT);
-  g = roundToPrecision((g * factor + wh) * MAX_RGB, OCT);
-  b = roundToPrecision((b * factor + wh) * MAX_RGB, OCT);
-  return [
-    'rgb',
-    Math.min(Math.max(r, 0), MAX_RGB),
-    Math.min(Math.max(g, 0), MAX_RGB),
-    Math.min(Math.max(b, 0), MAX_RGB),
-    alpha
-  ];
-};
-
-/**
- * parse lab()
- * @param value - lab color value
- * @param [opt] - options
- * @returns parsed color
- *   - [xyz-d50, x, y, z, alpha], ['lab', l, a, b, alpha], '(empty)', NullObject
- */
-export const parseLab = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_LAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const COEF_PCT = 1.25;
-  const COND_POW = 8;
-  const [, val] = value.match(REG_LAB) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorChannels;
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    if (v1.endsWith('%')) {
-      l = parseFloat(v1);
-      if (l > MAX_PCT) {
-        l = MAX_PCT;
-      }
-    } else {
-      l = parseFloat(v1);
-    }
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else {
-    a = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith('%') ? parseFloat(v3) * COEF_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      'lab',
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const fl = (l + HEX) / LAB_L;
-  const fa = a / LAB_A + fl;
-  const fb = fl - b / LAB_B;
-  const powFl = Math.pow(fl, POW_CUBE);
-  const powFa = Math.pow(fa, POW_CUBE);
-  const powFb = Math.pow(fb, POW_CUBE);
-  const xyz = [
-    powFa > LAB_EPSILON ? powFa : (fa * LAB_L - HEX) / LAB_KAPPA,
-    l > COND_POW ? powFl : l / LAB_KAPPA,
-    powFb > LAB_EPSILON ? powFb : (fb * LAB_L - HEX) / LAB_KAPPA
-  ];
-  const [x, y, z] = xyz.map(
-    (val, i) => val * (D50[i] as number)
-  ) as TriColorChannels;
-  return [
-    'xyz-d50',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-
-/**
- * parse lch()
- * @param value - lch color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d50', x, y, z, alpha], ['lch', l, c, h, alpha]
- *   - '(empty)', NullObject
- */
-export const parseLch = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_LCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const COEF_PCT = 1.5;
-  const [, val] = value.match(REG_LCH) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorChannels;
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    c = v2.endsWith('%') ? parseFloat(v2) * COEF_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      'lch',
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos((h * Math.PI) / DEG_HALF);
-  const b = c * Math.sin((h * Math.PI) / DEG_HALF);
-  const [, x, y, z] = parseLab(`lab(${l} ${a} ${b})`) as ComputedColorChannels;
-  return [
-    'xyz-d50',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha as number
-  ];
-};
-
-/**
- * parse oklab()
- * @param value - oklab color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d65', x, y, z, alpha], ['oklab', l, a, b, alpha]
- *   - '(empty)', NullObject
- */
-export const parseOklab = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_OKLAB.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLAB) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorChannels;
-  let l, a, b;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    a = 0;
-  } else if (v2.endsWith('%')) {
-    a = (parseFloat(v2) * COEF_PCT) / MAX_PCT;
-  } else {
-    a = parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else if (v3.endsWith('%')) {
-    b = (parseFloat(v3) * COEF_PCT) / MAX_PCT;
-  } else {
-    b = parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      'oklab',
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(a, HEX),
-      v3 === NONE ? v3 : roundToPrecision(b, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map(c => Math.pow(c, POW_CUBE)) as TriColorChannels;
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    'xyz-d65',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha as number
-  ];
-};
-
-/**
- * parse oklch()
- * @param value - oklch color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-d65', x, y, z, alpha], ['oklch', l, c, h, alpha]
- *   - '(empty)', NullObject
- */
-export const parseOklch = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  if (!REG_OKLCH.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const COEF_PCT = 0.4;
-  const [, val] = value.match(REG_OKLCH) as MatchedRegExp;
-  const [v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorChannels;
-  let l, c, h;
-  if (v1 === NONE) {
-    l = 0;
-  } else {
-    l = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-    if (l < 0) {
-      l = 0;
-    }
-  }
-  if (v2 === NONE) {
-    c = 0;
-  } else {
-    if (v2.endsWith('%')) {
-      c = (parseFloat(v2) * COEF_PCT) / MAX_PCT;
-    } else {
-      c = parseFloat(v2);
-    }
-    if (c < 0) {
-      c = 0;
-    }
-  }
-  if (v3 === NONE) {
-    h = 0;
-  } else {
-    h = angleToDeg(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format)) {
-    return [
-      'oklch',
-      v1 === NONE ? v1 : roundToPrecision(l, HEX),
-      v2 === NONE ? v2 : roundToPrecision(c, HEX),
-      v3 === NONE ? v3 : roundToPrecision(h, HEX),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  const a = c * Math.cos((h * Math.PI) / DEG_HALF);
-  const b = c * Math.sin((h * Math.PI) / DEG_HALF);
-  const lms = transformMatrix(MATRIX_OKLAB_TO_LMS, [l, a, b]);
-  const xyzLms = lms.map(cc => Math.pow(cc, POW_CUBE)) as TriColorChannels;
-  const [x, y, z] = transformMatrix(MATRIX_LMS_TO_XYZ, xyzLms, true);
-  return [
-    'xyz-d65',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-
-/**
- * parse color()
- * @param value - color function value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-(d50|d65)', x, y, z, alpha], [cs, r, g, b, alpha]
- *   - '(empty)', NullObject
- */
-export const parseColorFunc = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = '', d50 = false, format = '', nullable = false } = opt;
-  if (!REG_FN_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
-  let [cs, v1, v2, v3, v4 = ''] = val
-    .replace('/', ' ')
-    .split(/\s+/) as StringColorSpacedChannels;
-  let r, g, b;
-  if (cs === 'xyz') {
-    cs = 'xyz-d65';
-  }
-  if (v1 === NONE) {
-    r = 0;
-  } else {
-    r = v1.endsWith('%') ? parseFloat(v1) / MAX_PCT : parseFloat(v1);
-  }
-  if (v2 === NONE) {
-    g = 0;
-  } else {
-    g = v2.endsWith('%') ? parseFloat(v2) / MAX_PCT : parseFloat(v2);
-  }
-  if (v3 === NONE) {
-    b = 0;
-  } else {
-    b = v3.endsWith('%') ? parseFloat(v3) / MAX_PCT : parseFloat(v3);
-  }
-  const alpha = parseAlpha(v4);
-  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {
-    return [
-      cs,
-      v1 === NONE ? v1 : roundToPrecision(r, DEC),
-      v2 === NONE ? v2 : roundToPrecision(g, DEC),
-      v3 === NONE ? v3 : roundToPrecision(b, DEC),
-      v4 === NONE ? v4 : alpha
-    ];
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  // srgb-linear
-  if (cs === 'srgb-linear') {
-    [x, y, z] = transformMatrix(MATRIX_L_RGB_TO_XYZ, [r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // display-p3
-  } else if (cs === 'display-p3') {
-    const linearRgb = transformRgbToLinearRgb([
-      r * MAX_RGB,
-      g * MAX_RGB,
-      b * MAX_RGB
-    ]);
-    [x, y, z] = transformMatrix(MATRIX_P3_TO_XYZ, linearRgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // rec2020
-  } else if (cs === 'rec2020') {
-    const ALPHA = 1.09929682680944;
-    const BETA = 0.018053968510807;
-    const REC_COEF = 0.45;
-    const rgb = [r, g, b].map(c => {
-      let cl;
-      if (c < BETA * REC_COEF * DEC) {
-        cl = c / (REC_COEF * DEC);
-      } else {
-        cl = Math.pow((c + ALPHA - 1) / ALPHA, 1 / REC_COEF);
-      }
-      return cl;
-    }) as TriColorChannels;
-    [x, y, z] = transformMatrix(MATRIX_REC2020_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // a98-rgb
-  } else if (cs === 'a98-rgb') {
-    const POW_A98 = 563 / 256;
-    const rgb = [r, g, b].map(c => {
-      const cl = Math.pow(c, POW_A98);
-      return cl;
-    }) as TriColorChannels;
-    [x, y, z] = transformMatrix(MATRIX_A98_TO_XYZ, rgb);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // prophoto-rgb
-  } else if (cs === 'prophoto-rgb') {
-    const POW_PROPHOTO = 1.8;
-    const rgb = [r, g, b].map(c => {
-      let cl;
-      if (c > 1 / (HEX * DUO)) {
-        cl = Math.pow(c, POW_PROPHOTO);
-      } else {
-        cl = c / HEX;
-      }
-      return cl;
-    }) as TriColorChannels;
-    [x, y, z] = transformMatrix(MATRIX_PROPHOTO_TO_XYZ_D50, rgb);
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-    // xyz, xyz-d50, xyz-d65
-  } else if (/^xyz(?:-d(?:50|65))?$/.test(cs)) {
-    [x, y, z] = [r, g, b];
-    if (cs === 'xyz-d50') {
-      if (!d50) {
-        [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z]);
-      }
-    } else if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // srgb
-  } else {
-    [x, y, z] = transformRgbToXyz([r * MAX_RGB, g * MAX_RGB, b * MAX_RGB]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? 'xyz-d50' : 'xyz-d65',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    format === VAL_MIX && v4 === NONE ? v4 : alpha
-  ];
-};
-
-/**
- * parse color value
- * @param value - CSS color value
- * @param [opt] - options
- * @returns parsed color
- *   - ['xyz-(d50|d65)', x, y, z, alpha], ['rgb', r, g, b, alpha]
- *   - value, '(empty)', NullObject
- */
-export const parseColorValue = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = '', nullable = false } = opt;
-  if (!REG_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      return res;
-    }
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  let x = 0;
-  let y = 0;
-  let z = 0;
-  let alpha = 0;
-  // complement currentcolor as a missing color
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_COMP) {
-      return ['rgb', 0, 0, 0, 0];
-    }
-    if (format === VAL_SPEC) {
-      return value;
-    }
-    // named-color
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      }
-      const [r, g, b] = NAMED_COLORS[
-        value as keyof typeof NAMED_COLORS
-      ] as TriColorChannels;
-      alpha = 1;
-      if (format === VAL_COMP) {
-        return ['rgb', r, g, b, alpha];
-      }
-      [x, y, z] = transformRgbToXyz([r, g, b], true);
-      if (d50) {
-        [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-      }
-    } else {
-      switch (format) {
-        case VAL_COMP: {
-          if (nullable && value !== 'transparent') {
-            return new NullObject();
-          }
-          return ['rgb', 0, 0, 0, 0];
-        }
-        case VAL_SPEC: {
-          if (value === 'transparent') {
-            return value;
-          }
-          return '';
-        }
-        case VAL_MIX: {
-          if (value === 'transparent') {
-            return ['rgb', 0, 0, 0, 0];
-          }
-          return new NullObject();
-        }
-        default:
-      }
-    }
-    // hex-color
-  } else if (value[0] === '#') {
-    if (REG_SPEC.test(format)) {
-      const rgb = convertHexToRgb(value);
-      return ['rgb', ...rgb];
-    }
-    [x, y, z, alpha] = convertHexToXyz(value);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // lab()
-  } else if (value.startsWith('lab')) {
-    if (REG_SPEC.test(format)) {
-      return parseLab(value, opt);
-    }
-    [, x, y, z, alpha] = parseLab(value) as ComputedColorChannels;
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-    // lch()
-  } else if (value.startsWith('lch')) {
-    if (REG_SPEC.test(format)) {
-      return parseLch(value, opt);
-    }
-    [, x, y, z, alpha] = parseLch(value) as ComputedColorChannels;
-    if (!d50) {
-      [x, y, z] = transformMatrix(MATRIX_D50_TO_D65, [x, y, z], true);
-    }
-    // oklab()
-  } else if (value.startsWith('oklab')) {
-    if (REG_SPEC.test(format)) {
-      return parseOklab(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklab(value) as ComputedColorChannels;
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-    // oklch()
-  } else if (value.startsWith('oklch')) {
-    if (REG_SPEC.test(format)) {
-      return parseOklch(value, opt);
-    }
-    [, x, y, z, alpha] = parseOklch(value) as ComputedColorChannels;
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  } else {
-    let r, g, b;
-    // hsl()
-    if (value.startsWith('hsl')) {
-      [, r, g, b, alpha] = parseHsl(value) as ComputedColorChannels;
-      // hwb()
-    } else if (value.startsWith('hwb')) {
-      [, r, g, b, alpha] = parseHwb(value) as ComputedColorChannels;
-      // rgb()
-    } else {
-      [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;
-    }
-    if (REG_SPEC.test(format)) {
-      return ['rgb', Math.round(r), Math.round(g), Math.round(b), alpha];
-    }
-    [x, y, z] = transformRgbToXyz([r, g, b]);
-    if (d50) {
-      [x, y, z] = transformMatrix(MATRIX_D65_TO_D50, [x, y, z], true);
-    }
-  }
-  return [
-    d50 ? 'xyz-d50' : 'xyz-d65',
-    roundToPrecision(x, HEX),
-    roundToPrecision(y, HEX),
-    roundToPrecision(z, HEX),
-    alpha
-  ];
-};
-
-/**
- * resolve color value
- * @param value - CSS color value
- * @param [opt] - options
- * @returns resolved color
- *   - [cs, v1, v2, v3, alpha], value, '(empty)', NullObject
- */
-export const resolveColorValue = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = '', format = '', nullable = false } = opt;
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'resolveColorValue',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem as string;
-    }
-    return cachedItem as SpecifiedColorChannels;
-  }
-  if (!REG_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res;
-    }
-    setCache(cacheKey, res);
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  let cs = '';
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  // complement currentcolor as a missing color
-  if (REG_CURRENT.test(value)) {
-    if (format === VAL_SPEC) {
-      setCache(cacheKey, value);
-      return value;
-    }
-    // named-color
-  } else if (/^[a-z]+$/.test(value)) {
-    if (Object.hasOwn(NAMED_COLORS, value)) {
-      if (format === VAL_SPEC) {
-        setCache(cacheKey, value);
-        return value;
-      }
-      [r, g, b] = NAMED_COLORS[
-        value as keyof typeof NAMED_COLORS
-      ] as TriColorChannels;
-      alpha = 1;
-    } else {
-      switch (format) {
-        case VAL_SPEC: {
-          if (value === 'transparent') {
-            setCache(cacheKey, value);
-            return value;
-          }
-          const res = '';
-          setCache(cacheKey, res);
-          return res;
-        }
-        case VAL_MIX: {
-          if (value === 'transparent') {
-            const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
-            setCache(cacheKey, res);
-            return res;
-          }
-          setCache(cacheKey, null);
-          return new NullObject();
-        }
-        case VAL_COMP:
-        default: {
-          if (nullable && value !== 'transparent') {
-            setCache(cacheKey, null);
-            return new NullObject();
-          }
-          const res: SpecifiedColorChannels = ['rgb', 0, 0, 0, 0];
-          setCache(cacheKey, res);
-          return res;
-        }
-      }
-    }
-    // hex-color
-  } else if (value[0] === '#') {
-    [r, g, b, alpha] = convertHexToRgb(value);
-    // hsl()
-  } else if (value.startsWith('hsl')) {
-    [, r, g, b, alpha] = parseHsl(value, opt) as ComputedColorChannels;
-    // hwb()
-  } else if (value.startsWith('hwb')) {
-    [, r, g, b, alpha] = parseHwb(value, opt) as ComputedColorChannels;
-    // lab(), lch()
-  } else if (/^l(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith('lab')) {
-      [cs, x, y, z, alpha] = parseLab(value, opt) as ComputedColorChannels;
-    } else {
-      [cs, x, y, z, alpha] = parseLch(value, opt) as ComputedColorChannels;
-    }
-    if (REG_SPEC.test(format)) {
-      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];
-      setCache(cacheKey, res);
-      return res;
-    }
-    [r, g, b] = transformXyzD50ToRgb([x, y, z]);
-    // oklab(), oklch()
-  } else if (/^okl(?:ab|ch)/.test(value)) {
-    let x, y, z;
-    if (value.startsWith('oklab')) {
-      [cs, x, y, z, alpha] = parseOklab(value, opt) as ComputedColorChannels;
-    } else {
-      [cs, x, y, z, alpha] = parseOklch(value, opt) as ComputedColorChannels;
-    }
-    if (REG_SPEC.test(format)) {
-      const res: SpecifiedColorChannels = [cs, x, y, z, alpha];
-      setCache(cacheKey, res);
-      return res;
-    }
-    [r, g, b] = transformXyzToRgb([x, y, z]);
-    // rgb()
-  } else {
-    [, r, g, b, alpha] = parseRgb(value, opt) as ComputedColorChannels;
-  }
-  if (format === VAL_MIX && colorSpace === 'srgb') {
-    const res: SpecifiedColorChannels = [
-      'srgb',
-      r / MAX_RGB,
-      g / MAX_RGB,
-      b / MAX_RGB,
-      alpha
-    ];
-    setCache(cacheKey, res);
-    return res;
-  }
-  const res: SpecifiedColorChannels = [
-    'rgb',
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    alpha
-  ];
-  setCache(cacheKey, res);
-  return res;
-};
-
-/**
- * resolve color()
- * @param value - color function value
- * @param [opt] - options
- * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)', NullObject
- */
-export const resolveColorFunc = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = '', format = '', nullable = false } = opt;
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'resolveColorFunc',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem as string;
-    }
-    return cachedItem as SpecifiedColorChannels;
-  }
-  if (!REG_FN_COLOR.test(value)) {
-    const res = resolveInvalidColorValue(format, nullable);
-    if (res instanceof NullObject) {
-      setCache(cacheKey, null);
-      return res;
-    }
-    setCache(cacheKey, res);
-    if (isString(res)) {
-      return res as string;
-    }
-    return res as SpecifiedColorChannels;
-  }
-  const [cs, v1, v2, v3, v4] = parseColorFunc(
-    value,
-    opt
-  ) as SpecifiedColorChannels;
-  if (REG_SPEC.test(format) || (format === VAL_MIX && cs === colorSpace)) {
-    const res: SpecifiedColorChannels = [cs, v1, v2, v3, v4];
-    setCache(cacheKey, res);
-    return res;
-  }
-  const x = parseFloat(`${v1}`);
-  const y = parseFloat(`${v2}`);
-  const z = parseFloat(`${v3}`);
-  const alpha = parseAlpha(`${v4}`);
-  const [r, g, b] = transformXyzToRgb([x, y, z], true);
-  const res: SpecifiedColorChannels = ['rgb', r, g, b, alpha];
-  setCache(cacheKey, res);
-  return res;
-};
-
-/**
- * convert color value to linear rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [r, g, b, alpha] r|g|b|alpha: 0..1
- */
-export const convertColorToLinearRgb = (
-  value: string,
-  opt: {
-    colorSpace?: string;
-    format?: string;
-  } = {}
-): ColorChannels | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { colorSpace = '', format = '' } = opt;
-  let cs = '';
-  let r, g, b, alpha, x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [cs, x, y, z, alpha] = xyz as ComputedColorChannels;
-    if (cs === colorSpace) {
-      return [x, y, z, alpha];
-    }
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
-    const [cs] = val
-      .replace('/', ' ')
-      .split(/\s+/) as StringColorSpacedChannels;
-    if (cs === 'srgb-linear') {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      }) as ComputedColorChannels;
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-      [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
-    [r, g, b] = transformMatrix(MATRIX_XYZ_TO_L_RGB, [x, y, z], true);
-  }
-  return [
-    Math.min(Math.max(r, 0), 1),
-    Math.min(Math.max(g, 0), 1),
-    Math.min(Math.max(b, 0), 1),
-    alpha
-  ];
-};
-
-/**
- * convert color value to rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject
- *   - [r, g, b, alpha] r|g|b: 0..255 alpha: 0..1
- */
-export const convertColorToRgb = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let r, g, b, alpha;
-  if (format === VAL_MIX) {
-    let rgb;
-    if (value.startsWith(FN_COLOR)) {
-      rgb = resolveColorFunc(value, opt);
-    } else {
-      rgb = resolveColorValue(value, opt);
-    }
-    if (rgb instanceof NullObject) {
-      return rgb;
-    }
-    [, r, g, b, alpha] = rgb as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
-    const [cs] = val
-      .replace('/', ' ')
-      .split(/\s+/) as StringColorSpacedChannels;
-    if (cs === 'srgb') {
-      [, r, g, b, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      }) as ComputedColorChannels;
-      r *= MAX_RGB;
-      g *= MAX_RGB;
-      b *= MAX_RGB;
-    } else {
-      [, r, g, b, alpha] = resolveColorFunc(value) as ComputedColorChannels;
-    }
-  } else if (/^(?:ok)?l(?:ab|ch)/.test(value)) {
-    [r, g, b, alpha] = convertColorToLinearRgb(value) as ColorChannels;
-    [r, g, b] = transformLinearRgbToRgb([r, g, b]);
-  } else {
-    [, r, g, b, alpha] = resolveColorValue(value, {
-      format: VAL_COMP
-    }) as ComputedColorChannels;
-  }
-  return [r, g, b, alpha];
-};
-
-/**
- * convert color value to xyz
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [x, y, z, alpha]
- */
-export const convertColorToXyz = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { d50 = false, format = '' } = opt;
-  let x, y, z, alpha;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    const [, val] = value.match(REG_FN_COLOR) as MatchedRegExp;
-    const [cs] = val
-      .replace('/', ' ')
-      .split(/\s+/) as StringColorSpacedChannels;
-    if (d50) {
-      if (cs === 'xyz-d50') {
-        [, x, y, z, alpha] = resolveColorFunc(value, {
-          format: VAL_COMP
-        }) as ComputedColorChannels;
-      } else {
-        [, x, y, z, alpha] = parseColorFunc(
-          value,
-          opt
-        ) as ComputedColorChannels;
-      }
-    } else if (/^xyz(?:-d65)?$/.test(cs)) {
-      [, x, y, z, alpha] = resolveColorFunc(value, {
-        format: VAL_COMP
-      }) as ComputedColorChannels;
-    } else {
-      [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-    }
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, opt) as ComputedColorChannels;
-  }
-  return [x, y, z, alpha];
-};
-
-/**
- * convert color value to hsl
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [h, s, l, alpha], hue may be powerless
- */
-export const convertColorToHsl = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | [number | string, number, number, number] | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let h, s, l, alpha;
-  if (REG_HSL.test(value)) {
-    [, h, s, l, alpha] = parseHsl(value, {
-      format: 'hsl'
-    }) as ComputedColorChannels;
-    if (format === 'hsl') {
-      return [Math.round(h), Math.round(s), Math.round(l), alpha];
-    }
-    return [h, s, l, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
-  }
-  [h, s, l] = transformXyzToHsl([x, y, z], true) as TriColorChannels;
-  if (format === 'hsl') {
-    return [Math.round(h), Math.round(s), Math.round(l), alpha];
-  }
-  return [format === VAL_MIX && s === 0 ? NONE : h, s, l, alpha];
-};
-
-/**
- * convert color value to hwb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [h, w, b, alpha], hue may be powerless
- */
-export const convertColorToHwb = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | [number | string, number, number, number] | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let h, w, b, alpha;
-  if (REG_HWB.test(value)) {
-    [, h, w, b, alpha] = parseHwb(value, {
-      format: 'hwb'
-    }) as ComputedColorChannels;
-    if (format === 'hwb') {
-      return [Math.round(h), Math.round(w), Math.round(b), alpha];
-    }
-    return [h, w, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
-  }
-  [h, w, b] = transformXyzToHwb([x, y, z], true) as TriColorChannels;
-  if (format === 'hwb') {
-    return [Math.round(h), Math.round(w), Math.round(b), alpha];
-  }
-  return [format === VAL_MIX && w + b >= 100 ? NONE : h, w, b, alpha];
-};
-
-/**
- * convert color value to lab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, a, b, alpha]
- */
-export const convertColorToLab = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let l, a, b, alpha;
-  if (REG_LAB.test(value)) {
-    [, l, a, b, alpha] = parseLab(value, {
-      format: VAL_COMP
-    }) as ComputedColorChannels;
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    }) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    }) as ComputedColorChannels;
-  }
-  [l, a, b] = transformXyzD50ToLab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-
-/**
- * convert color value to lch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
- */
-export const convertColorToLch = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | [number, number, number | string, number] | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let l, c, h, alpha;
-  if (REG_LCH.test(value)) {
-    [, l, c, h, alpha] = parseLch(value, {
-      format: VAL_COMP
-    }) as ComputedColorChannels;
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    opt.d50 = true;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value, {
-      d50: true
-    }) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value, {
-      d50: true
-    }) as ComputedColorChannels;
-  }
-  [l, c, h] = transformXyzD50ToLch([x, y, z], true);
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-
-/**
- * convert color value to oklab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, a, b, alpha]
- */
-export const convertColorToOklab = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let l, a, b, alpha;
-  if (REG_OKLAB.test(value)) {
-    [, l, a, b, alpha] = parseOklab(value, {
-      format: VAL_COMP
-    }) as ComputedColorChannels;
-    return [l, a, b, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
-  }
-  [l, a, b] = transformXyzToOklab([x, y, z], true);
-  return [l, a, b, alpha];
-};
-
-/**
- * convert color value to oklch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels | NullObject - [l, c, h, alpha], hue may be powerless
- */
-export const convertColorToOklch = (
-  value: string,
-  opt: Options = {}
-): ColorChannels | [number, number, number | string, number] | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '' } = opt;
-  let l, c, h, alpha;
-  if (REG_OKLCH.test(value)) {
-    [, l, c, h, alpha] = parseOklch(value, {
-      format: VAL_COMP
-    }) as ComputedColorChannels;
-    return [l, c, h, alpha];
-  }
-  let x, y, z;
-  if (format === VAL_MIX) {
-    let xyz;
-    if (value.startsWith(FN_COLOR)) {
-      xyz = parseColorFunc(value, opt);
-    } else {
-      xyz = parseColorValue(value, opt);
-    }
-    if (xyz instanceof NullObject) {
-      return xyz;
-    }
-    [, x, y, z, alpha] = xyz as ComputedColorChannels;
-  } else if (value.startsWith(FN_COLOR)) {
-    [, x, y, z, alpha] = parseColorFunc(value) as ComputedColorChannels;
-  } else {
-    [, x, y, z, alpha] = parseColorValue(value) as ComputedColorChannels;
-  }
-  [l, c, h] = transformXyzToOklch([x, y, z], true) as TriColorChannels;
-  return [l, c, format === VAL_MIX && c === 0 ? NONE : h, alpha];
-};
-
-/**
- * resolve color-mix()
- * @param value - color-mix color value
- * @param [opt] - options
- * @returns resolved color - [cs, v1, v2, v3, alpha], '(empty)'
- */
-export const resolveColorMix = (
-  value: string,
-  opt: Options = {}
-): SpecifiedColorChannels | string | NullObject => {
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { format = '', nullable = false } = opt;
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'resolveColorMix',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    const cachedItem = cachedResult.item;
-    if (isString(cachedItem)) {
-      return cachedItem as string;
-    }
-    return cachedItem as SpecifiedColorChannels;
-  }
-  const nestedItems = [];
-  let colorSpace = '';
-  let hueArc = '';
-  let colorA = '';
-  let pctA = '';
-  let colorB = '';
-  let pctB = '';
-  let parsed = false;
-  if (!REG_MIX.test(value)) {
-    // nested color-mix()
-    if (value.startsWith(FN_MIX) && REG_MIX_NEST.test(value)) {
-      const regColorSpace = new RegExp(`^(?:${CS_RGB}|${CS_XYZ})$`);
-      const items = value.match(REG_MIX_NEST) as RegExpMatchArray;
-      for (const item of items) {
-        if (item) {
-          let val = resolveColorMix(item, {
-            format: format === VAL_SPEC ? format : VAL_COMP
-          }) as ComputedColorChannels | string;
-          // computed value
-          if (Array.isArray(val)) {
-            const [cs, v1, v2, v3, v4] = val as ComputedColorChannels;
-            if (v1 === 0 && v2 === 0 && v3 === 0 && v4 === 0) {
-              value = '';
-              break;
-            }
-            if (regColorSpace.test(cs)) {
-              if (v4 === 1) {
-                val = `color(${cs} ${v1} ${v2} ${v3})`;
-              } else {
-                val = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-              }
-            } else if (v4 === 1) {
-              val = `${cs}(${v1} ${v2} ${v3})`;
-            } else {
-              val = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-            }
-          } else if (!REG_MIX.test(val)) {
-            value = '';
-            break;
-          }
-          nestedItems.push(val);
-          value = value.replace(item, val);
-        }
-      }
-      if (!value) {
-        const res = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res;
-      }
-      // contains light-dark()
-    } else if (
-      value.startsWith(FN_MIX) &&
-      value.endsWith(')') &&
-      value.includes(FN_LIGHT_DARK)
-    ) {
-      const regColorSpace = new RegExp(`in\\s+(${CS_MIX})`);
-      const colorParts = value.replace(FN_MIX, '').replace(/\)$/, '');
-      const [csPart = '', partA = '', partB = ''] = splitValue(colorParts, {
-        delimiter: ','
-      });
-      const [colorPartA = '', pctPartA = ''] = splitValue(partA);
-      const [colorPartB = '', pctPartB = ''] = splitValue(partB);
-      const specifiedColorA = resolveColor(colorPartA, {
-        format: VAL_SPEC
-      }) as string;
-      const specifiedColorB = resolveColor(colorPartB, {
-        format: VAL_SPEC
-      }) as string;
-      if (regColorSpace.test(csPart) && specifiedColorA && specifiedColorB) {
-        if (format === VAL_SPEC) {
-          const [, cs] = csPart.match(regColorSpace) as MatchedRegExp;
-          if (REG_CS_HUE.test(cs)) {
-            [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
-          } else {
-            colorSpace = cs;
-          }
-          colorA = specifiedColorA;
-          if (pctPartA) {
-            pctA = pctPartA;
-          }
-          colorB = specifiedColorB;
-          if (pctPartB) {
-            pctB = pctPartB;
-          }
-          value = value
-            .replace(colorPartA, specifiedColorA)
-            .replace(colorPartB, specifiedColorB);
-          parsed = true;
-        } else {
-          const resolvedColorA = resolveColor(colorPartA, opt);
-          const resolvedColorB = resolveColor(colorPartB, opt);
-          if (isString(resolvedColorA) && isString(resolvedColorB)) {
-            value = value
-              .replace(colorPartA, resolvedColorA)
-              .replace(colorPartB, resolvedColorB);
-          }
-        }
-      } else {
-        const res = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res;
-      }
-    } else {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-  }
-  if (nestedItems.length && format === VAL_SPEC) {
-    const regColorSpace = new RegExp(`^color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,`);
-    const [, cs] = value.match(regColorSpace) as MatchedRegExp;
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
-    } else {
-      colorSpace = cs;
-    }
-    if (nestedItems.length === 2) {
-      let [itemA, itemB] = nestedItems as [string, string];
-      itemA = itemA.replace(/(?=[()])/g, '\\');
-      itemB = itemB.replace(/(?=[()])/g, '\\');
-      const regA = new RegExp(`(${itemA})(?:\\s+(${PCT}))?`);
-      const regB = new RegExp(`(${itemB})(?:\\s+(${PCT}))?`);
-      [, colorA, pctA] = value.match(regA) as MatchedRegExp;
-      [, colorB, pctB] = value.match(regB) as MatchedRegExp;
-    } else {
-      let [item] = nestedItems as [string];
-      item = item.replace(/(?=[()])/g, '\\');
-      const itemPart = `${item}(?:\\s+${PCT})?`;
-      const itemPartCapt = `(${item})(?:\\s+(${PCT}))?`;
-      const regItemPart = new RegExp(`^${itemPartCapt}$`);
-      const regLastItem = new RegExp(`${itemPartCapt}\\s*\\)$`);
-      const regColorPart = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-      // item is at the end
-      if (regLastItem.test(value)) {
-        const reg = new RegExp(
-          `(${SYN_MIX_PART})\\s*,\\s*(${itemPart})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;
-        [, colorA, pctA] = colorPartA.match(regColorPart) as MatchedRegExp;
-        [, colorB, pctB] = colorPartB.match(regItemPart) as MatchedRegExp;
-      } else {
-        const reg = new RegExp(
-          `(${itemPart})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)$`
-        );
-        const [, colorPartA, colorPartB] = value.match(reg) as MatchedRegExp;
-        [, colorA, pctA] = colorPartA.match(regItemPart) as MatchedRegExp;
-        [, colorB, pctB] = colorPartB.match(regColorPart) as MatchedRegExp;
-      }
-    }
-  } else if (!parsed) {
-    const [, cs, colorPartA, colorPartB] = value.match(
-      REG_MIX_CAPT
-    ) as MatchedRegExp;
-    const reg = new RegExp(`^(${SYN_COLOR_TYPE})(?:\\s+(${PCT}))?$`);
-    [, colorA, pctA] = colorPartA.match(reg) as MatchedRegExp;
-    [, colorB, pctB] = colorPartB.match(reg) as MatchedRegExp;
-    if (REG_CS_HUE.test(cs)) {
-      [, colorSpace, hueArc] = cs.match(REG_CS_HUE) as MatchedRegExp;
-    } else {
-      colorSpace = cs;
-    }
-  }
-  // normalize percentages and set multipler
-  let pA, pB, m;
-  if (pctA && pctB) {
-    const p1 = parseFloat(pctA) / MAX_PCT;
-    const p2 = parseFloat(pctB) / MAX_PCT;
-    if (p1 < 0 || p1 > 1 || p2 < 0 || p2 > 1 || (p1 === 0 && p2 === 0)) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const factor = p1 + p2;
-    pA = p1 / factor;
-    pB = p2 / factor;
-    m = factor < 1 ? factor : 1;
-  } else {
-    if (pctA) {
-      pA = parseFloat(pctA) / MAX_PCT;
-      if (pA < 0 || pA > 1) {
-        const res = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res;
-      }
-      pB = 1 - pA;
-    } else if (pctB) {
-      pB = parseFloat(pctB) / MAX_PCT;
-      if (pB < 0 || pB > 1) {
-        const res = cacheInvalidColorValue(cacheKey, format, nullable);
-        return res;
-      }
-      pA = 1 - pB;
-    } else {
-      pA = HALF;
-      pB = HALF;
-    }
-    m = 1;
-  }
-  if (colorSpace === 'xyz') {
-    colorSpace = 'xyz-d65';
-  }
-  // specified value
-  if (format === VAL_SPEC) {
-    let valueA = '';
-    let valueB = '';
-    if (colorA.startsWith(FN_MIX) || colorA.startsWith(FN_LIGHT_DARK)) {
-      valueA = colorA;
-    } else if (colorA.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorA,
-        opt
-      ) as SpecifiedColorChannels;
-      if (v4 === 1) {
-        valueA = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueA = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorA, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === 'rgb') {
-            valueA = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueA = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === 'rgb') {
-          valueA = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueA = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, '');
-          return '';
-        }
-        valueA = val;
-      }
-    }
-    if (colorB.startsWith(FN_MIX) || colorB.startsWith(FN_LIGHT_DARK)) {
-      valueB = colorB;
-    } else if (colorB.startsWith(FN_COLOR)) {
-      const [cs, v1, v2, v3, v4] = parseColorFunc(
-        colorB,
-        opt
-      ) as SpecifiedColorChannels;
-      if (v4 === 1) {
-        valueB = `color(${cs} ${v1} ${v2} ${v3})`;
-      } else {
-        valueB = `color(${cs} ${v1} ${v2} ${v3} / ${v4})`;
-      }
-    } else {
-      const val = parseColorValue(colorB, opt);
-      if (Array.isArray(val)) {
-        const [cs, v1, v2, v3, v4] = val;
-        if (v4 === 1) {
-          if (cs === 'rgb') {
-            valueB = `${cs}(${v1}, ${v2}, ${v3})`;
-          } else {
-            valueB = `${cs}(${v1} ${v2} ${v3})`;
-          }
-        } else if (cs === 'rgb') {
-          valueB = `${cs}a(${v1}, ${v2}, ${v3}, ${v4})`;
-        } else {
-          valueB = `${cs}(${v1} ${v2} ${v3} / ${v4})`;
-        }
-      } else {
-        if (!isString(val) || !val) {
-          setCache(cacheKey, '');
-          return '';
-        }
-        valueB = val;
-      }
-    }
-    if (pctA && pctB) {
-      valueA += ` ${parseFloat(pctA)}%`;
-      valueB += ` ${parseFloat(pctB)}%`;
-    } else if (pctA) {
-      const pA = parseFloat(pctA);
-      if (pA !== MAX_PCT * HALF) {
-        valueA += ` ${pA}%`;
-      }
-    } else if (pctB) {
-      const pA = MAX_PCT - parseFloat(pctB);
-      if (pA !== MAX_PCT * HALF) {
-        valueA += ` ${pA}%`;
-      }
-    }
-    if (hueArc) {
-      const res = `color-mix(in ${colorSpace} ${hueArc} hue, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res);
-      return res;
-    } else {
-      const res = `color-mix(in ${colorSpace}, ${valueA}, ${valueB})`;
-      setCache(cacheKey, res);
-      return res;
-    }
-  }
-  let r = 0;
-  let g = 0;
-  let b = 0;
-  let alpha = 0;
-  // in srgb, srgb-linear
-  if (/^srgb(?:-linear)?$/.test(colorSpace)) {
-    let rgbA, rgbB;
-    if (colorSpace === 'srgb') {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        rgbA = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbA = convertColorToLinearRgb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        rgbB = [NONE, NONE, NONE, NONE];
-      } else {
-        rgbB = convertColorToLinearRgb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (rgbA instanceof NullObject || rgbB instanceof NullObject) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const [rrA, ggA, bbA, aaA] = rgbA as NumStrColorChannels;
-    const [rrB, ggB, bbB, aaB] = rgbB as NumStrColorChannels;
-    const rNone = rrA === NONE && rrB === NONE;
-    const gNone = ggA === NONE && ggB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[rA, gA, bA, alphaA], [rB, gB, bB, alphaB]] =
-      normalizeColorComponents(
-        [rrA, ggA, bbA, aaA],
-        [rrB, ggB, bbB, aaB],
-        true
-      );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    if (alpha === 0) {
-      r = rA * pA + rB * pB;
-      g = gA * pA + gB * pB;
-      b = bA * pA + bB * pB;
-    } else {
-      r = (rA * factorA + rB * factorB) / alpha;
-      g = (gA * factorA + gB * factorB) / alpha;
-      b = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res: SpecifiedColorChannels = [
-        colorSpace,
-        rNone ? NONE : roundToPrecision(r, HEX),
-        gNone ? NONE : roundToPrecision(g, HEX),
-        bNone ? NONE : roundToPrecision(b, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res);
-      return res;
-    }
-    r *= MAX_RGB;
-    g *= MAX_RGB;
-    b *= MAX_RGB;
-    // in xyz, xyz-d65, xyz-d50
-  } else if (REG_CS_XYZ.test(colorSpace)) {
-    let xyzA, xyzB;
-    if (REG_CURRENT.test(colorA)) {
-      xyzA = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzA = convertColorToXyz(colorA, {
-        colorSpace,
-        d50: colorSpace === 'xyz-d50',
-        format: VAL_MIX
-      });
-    }
-    if (REG_CURRENT.test(colorB)) {
-      xyzB = [NONE, NONE, NONE, NONE];
-    } else {
-      xyzB = convertColorToXyz(colorB, {
-        colorSpace,
-        d50: colorSpace === 'xyz-d50',
-        format: VAL_MIX
-      });
-    }
-    if (xyzA instanceof NullObject || xyzB instanceof NullObject) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const [xxA, yyA, zzA, aaA] = xyzA;
-    const [xxB, yyB, zzB, aaB] = xyzB;
-    const xNone = xxA === NONE && xxB === NONE;
-    const yNone = yyA === NONE && yyB === NONE;
-    const zNone = zzA === NONE && zzB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    const [[xA, yA, zA, alphaA], [xB, yB, zB, alphaB]] =
-      normalizeColorComponents(
-        [xxA, yyA, zzA, aaA],
-        [xxB, yyB, zzB, aaB],
-        true
-      );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let x, y, z;
-    if (alpha === 0) {
-      x = xA * pA + xB * pB;
-      y = yA * pA + yB * pB;
-      z = zA * pA + zB * pB;
-    } else {
-      x = (xA * factorA + xB * factorB) / alpha;
-      y = (yA * factorA + yB * factorB) / alpha;
-      z = (zA * factorA + zB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res: SpecifiedColorChannels = [
-        colorSpace,
-        xNone ? NONE : roundToPrecision(x, HEX),
-        yNone ? NONE : roundToPrecision(y, HEX),
-        zNone ? NONE : roundToPrecision(z, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res);
-      return res;
-    }
-    if (colorSpace === 'xyz-d50') {
-      [r, g, b] = transformXyzD50ToRgb([x, y, z], true);
-    } else {
-      [r, g, b] = transformXyzToRgb([x, y, z], true);
-    }
-    // in hsl, hwb
-  } else if (/^h(?:sl|wb)$/.test(colorSpace)) {
-    let hslA, hslB;
-    if (colorSpace === 'hsl') {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHsl(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHsl(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        hslA = [NONE, NONE, NONE, NONE];
-      } else {
-        hslA = convertColorToHwb(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        hslB = [NONE, NONE, NONE, NONE];
-      } else {
-        hslB = convertColorToHwb(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (hslA instanceof NullObject || hslB instanceof NullObject) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const [hhA, ssA, llA, aaA] = hslA;
-    const [hhB, ssB, llB, aaB] = hslB;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[hA, sA, lA, alphaA], [hB, sB, lB, alphaB]] = normalizeColorComponents(
-      [hhA, ssA, llA, aaA],
-      [hhB, ssB, llB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let s, l;
-    if (alpha === 0) {
-      s = sA * pA + sB * pB;
-      l = lA * pA + lB * pB;
-    } else {
-      s = (sA * factorA + sB * factorB) / alpha;
-      l = (lA * factorA + lB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    [r, g, b] = convertColorToRgb(
-      `${colorSpace}(${h} ${s} ${l})`
-    ) as ColorChannels;
-    if (format === VAL_COMP) {
-      const res: SpecifiedColorChannels = [
-        'srgb',
-        roundToPrecision(r / MAX_RGB, HEX),
-        roundToPrecision(g / MAX_RGB, HEX),
-        roundToPrecision(b / MAX_RGB, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res);
-      return res;
-    }
-    // in lch, oklch
-  } else if (/^(?:ok)?lch$/.test(colorSpace)) {
-    let lchA, lchB;
-    if (colorSpace === 'lch') {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToLch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToLch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        lchA = [NONE, NONE, NONE, NONE];
-      } else {
-        lchA = convertColorToOklch(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        lchB = [NONE, NONE, NONE, NONE];
-      } else {
-        lchB = convertColorToOklch(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (lchA instanceof NullObject || lchB instanceof NullObject) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const [llA, ccA, hhA, aaA] = lchA;
-    const [llB, ccB, hhB, aaB] = lchB;
-    const lNone = llA === NONE && llB === NONE;
-    const cNone = ccA === NONE && ccB === NONE;
-    const hNone = hhA === NONE && hhB === NONE;
-    const alphaNone = aaA === NONE && aaB === NONE;
-    let [[lA, cA, hA, alphaA], [lB, cB, hB, alphaB]] = normalizeColorComponents(
-      [llA, ccA, hhA, aaA],
-      [llB, ccB, hhB, aaB],
-      true
-    );
-    if (hueArc) {
-      [hA, hB] = interpolateHue(hA, hB, hueArc);
-    }
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    const h = (hA * pA + hB * pB) % DEG;
-    let l, c;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      c = cA * pA + cB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      c = (cA * factorA + cB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res: SpecifiedColorChannels = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        cNone ? NONE : roundToPrecision(c, HEX),
-        hNone ? NONE : roundToPrecision(h, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res);
-      return res;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${c} ${h})`
-    ) as ComputedColorChannels;
-    // in lab, oklab
-  } else {
-    let labA, labB;
-    if (colorSpace === 'lab') {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToLab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToLab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    } else {
-      if (REG_CURRENT.test(colorA)) {
-        labA = [NONE, NONE, NONE, NONE];
-      } else {
-        labA = convertColorToOklab(colorA, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-      if (REG_CURRENT.test(colorB)) {
-        labB = [NONE, NONE, NONE, NONE];
-      } else {
-        labB = convertColorToOklab(colorB, {
-          colorSpace,
-          format: VAL_MIX
-        });
-      }
-    }
-    if (labA instanceof NullObject || labB instanceof NullObject) {
-      const res = cacheInvalidColorValue(cacheKey, format, nullable);
-      return res;
-    }
-    const [llA, aaA, bbA, alA] = labA;
-    const [llB, aaB, bbB, alB] = labB;
-    const lNone = llA === NONE && llB === NONE;
-    const aNone = aaA === NONE && aaB === NONE;
-    const bNone = bbA === NONE && bbB === NONE;
-    const alphaNone = alA === NONE && alB === NONE;
-    const [[lA, aA, bA, alphaA], [lB, aB, bB, alphaB]] =
-      normalizeColorComponents(
-        [llA, aaA, bbA, alA],
-        [llB, aaB, bbB, alB],
-        true
-      );
-    const factorA = alphaA * pA;
-    const factorB = alphaB * pB;
-    alpha = factorA + factorB;
-    let l, aO, bO;
-    if (alpha === 0) {
-      l = lA * pA + lB * pB;
-      aO = aA * pA + aB * pB;
-      bO = bA * pA + bB * pB;
-    } else {
-      l = (lA * factorA + lB * factorB) / alpha;
-      aO = (aA * factorA + aB * factorB) / alpha;
-      bO = (bA * factorA + bB * factorB) / alpha;
-      alpha = parseFloat(alpha.toFixed(3));
-    }
-    if (format === VAL_COMP) {
-      const res: SpecifiedColorChannels = [
-        colorSpace,
-        lNone ? NONE : roundToPrecision(l, HEX),
-        aNone ? NONE : roundToPrecision(aO, HEX),
-        bNone ? NONE : roundToPrecision(bO, HEX),
-        alphaNone ? NONE : alpha * m
-      ];
-      setCache(cacheKey, res);
-      return res;
-    }
-    [, r, g, b] = resolveColorValue(
-      `${colorSpace}(${l} ${aO} ${bO})`
-    ) as ComputedColorChannels;
-  }
-  const res: SpecifiedColorChannels = [
-    'rgb',
-    Math.round(r),
-    Math.round(g),
-    Math.round(b),
-    parseFloat((alpha * m).toFixed(3))
-  ];
-  setCache(cacheKey, res);
-  return res;
-};

node_modules/@asamuzakjp/css-color/src/js/common.ts

@@ -1,31 +0,0 @@
-/**
- * common
- */
-
-/* numeric constants */
-const TYPE_FROM = 8;
-const TYPE_TO = -1;
-
-/**
- * get type
- * @param o - object to check
- * @returns type of object
- */
-export const getType = (o: unknown): string =>
-  Object.prototype.toString.call(o).slice(TYPE_FROM, TYPE_TO);
-
-/**
- * is string
- * @param o - object to check
- * @returns result
- */
-export const isString = (o: unknown): o is string =>
-  typeof o === 'string' || o instanceof String;
-
-/**
- * is string or number
- * @param o - object to check
- * @returns result
- */
-export const isStringOrNumber = (o: unknown): boolean =>
-  isString(o) || typeof o === 'number';

node_modules/@asamuzakjp/css-color/src/js/constant.ts

@@ -1,68 +0,0 @@
-/**
- * constant
- */
-
-/* values and units */
-const _DIGIT = '(?:0|[1-9]\\d*)';
-const _COMPARE = 'clamp|max|min';
-const _EXPO = 'exp|hypot|log|pow|sqrt';
-const _SIGN = 'abs|sign';
-const _STEP = 'mod|rem|round';
-const _TRIG = 'a?(?:cos|sin|tan)|atan2';
-const _MATH = `${_COMPARE}|${_EXPO}|${_SIGN}|${_STEP}|${_TRIG}`;
-const _CALC = `calc|${_MATH}`;
-const _VAR = `var|${_CALC}`;
-export const ANGLE = 'deg|g?rad|turn';
-export const LENGTH =
-  '[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic)';
-export const NUM = `[+-]?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-export const NUM_POSITIVE = `\\+?(?:${_DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${_DIGIT})?`;
-export const NONE = 'none';
-export const PCT = `${NUM}%`;
-export const SYN_FN_CALC = `^(?:${_CALC})\\(|(?<=[*\\/\\s\\(])(?:${_CALC})\\(`;
-export const SYN_FN_MATH_START = `^(?:${_MATH})\\($`;
-export const SYN_FN_VAR = '^var\\(|(?<=[*\\/\\s\\(])var\\(';
-export const SYN_FN_VAR_START = `^(?:${_VAR})\\(`;
-
-/* colors */
-const _ALPHA = `(?:\\s*\\/\\s*(?:${NUM}|${PCT}|${NONE}))?`;
-const _ALPHA_LV3 = `(?:\\s*,\\s*(?:${NUM}|${PCT}))?`;
-const _COLOR_FUNC = '(?:ok)?l(?:ab|ch)|color|hsla?|hwb|rgba?';
-const _COLOR_KEY = '[a-z]+|#[\\da-f]{3}|#[\\da-f]{4}|#[\\da-f]{6}|#[\\da-f]{8}';
-const _CS_HUE = '(?:ok)?lch|hsl|hwb';
-const _CS_HUE_ARC = '(?:de|in)creasing|longer|shorter';
-const _NUM_ANGLE = `${NUM}(?:${ANGLE})?`;
-const _NUM_ANGLE_NONE = `(?:${NUM}(?:${ANGLE})?|${NONE})`;
-const _NUM_PCT_NONE = `(?:${NUM}|${PCT}|${NONE})`;
-export const CS_HUE = `(?:${_CS_HUE})(?:\\s(?:${_CS_HUE_ARC})\\shue)?`;
-export const CS_HUE_CAPT = `(${_CS_HUE})(?:\\s(${_CS_HUE_ARC})\\shue)?`;
-export const CS_LAB = '(?:ok)?lab';
-export const CS_LCH = '(?:ok)?lch';
-export const CS_SRGB = 'srgb(?:-linear)?';
-export const CS_RGB = `(?:a98|prophoto)-rgb|display-p3|rec2020|${CS_SRGB}`;
-export const CS_XYZ = 'xyz(?:-d(?:50|65))?';
-export const CS_RECT = `${CS_LAB}|${CS_RGB}|${CS_XYZ}`;
-export const CS_MIX = `${CS_HUE}|${CS_RECT}`;
-export const FN_COLOR = 'color(';
-export const FN_LIGHT_DARK = 'light-dark(';
-export const FN_MIX = 'color-mix(';
-export const FN_REL = `(?:${_COLOR_FUNC})\\(\\s*from\\s+`;
-export const FN_REL_CAPT = `(${_COLOR_FUNC})\\(\\s*from\\s+`;
-export const FN_VAR = 'var(';
-export const SYN_FN_COLOR = `(?:${CS_RGB}|${CS_XYZ})(?:\\s+${_NUM_PCT_NONE}){3}${_ALPHA}`;
-export const SYN_FN_LIGHT_DARK = '^light-dark\\(';
-export const SYN_FN_REL = `^${FN_REL}|(?<=[\\s])${FN_REL}`;
-export const SYN_HSL = `${_NUM_ANGLE_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-export const SYN_HSL_LV3 = `${_NUM_ANGLE}(?:\\s*,\\s*${PCT}){2}${_ALPHA_LV3}`;
-export const SYN_LCH = `(?:${_NUM_PCT_NONE}\\s+){2}${_NUM_ANGLE_NONE}${_ALPHA}`;
-export const SYN_MOD = `${_NUM_PCT_NONE}(?:\\s+${_NUM_PCT_NONE}){2}${_ALPHA}`;
-export const SYN_RGB_LV3 = `(?:${NUM}(?:\\s*,\\s*${NUM}){2}|${PCT}(?:\\s*,\\s*${PCT}){2})${_ALPHA_LV3}`;
-export const SYN_COLOR_TYPE = `${_COLOR_KEY}|hsla?\\(\\s*${SYN_HSL_LV3}\\s*\\)|rgba?\\(\\s*${SYN_RGB_LV3}\\s*\\)|(?:hsla?|hwb)\\(\\s*${SYN_HSL}\\s*\\)|(?:(?:ok)?lab|rgba?)\\(\\s*${SYN_MOD}\\s*\\)|(?:ok)?lch\\(\\s*${SYN_LCH}\\s*\\)|color\\(\\s*${SYN_FN_COLOR}\\s*\\)`;
-export const SYN_MIX_PART = `(?:${SYN_COLOR_TYPE})(?:\\s+${PCT})?`;
-export const SYN_MIX = `color-mix\\(\\s*in\\s+(?:${CS_MIX})\\s*,\\s*${SYN_MIX_PART}\\s*,\\s*${SYN_MIX_PART}\\s*\\)`;
-export const SYN_MIX_CAPT = `color-mix\\(\\s*in\\s+(${CS_MIX})\\s*,\\s*(${SYN_MIX_PART})\\s*,\\s*(${SYN_MIX_PART})\\s*\\)`;
-
-/* formats */
-export const VAL_COMP = 'computedValue';
-export const VAL_MIX = 'mixValue';
-export const VAL_SPEC = 'specifiedValue';

node_modules/@asamuzakjp/css-color/src/js/convert.ts

@@ -1,469 +0,0 @@
-/**
- * convert
- */
-
-import {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  setCache
-} from './cache';
-import {
-  convertColorToHsl,
-  convertColorToHwb,
-  convertColorToLab,
-  convertColorToLch,
-  convertColorToOklab,
-  convertColorToOklch,
-  convertColorToRgb,
-  numberToHexString,
-  parseColorFunc,
-  parseColorValue
-} from './color';
-import { isString } from './common';
-import { cssCalc } from './css-calc';
-import { resolveVar } from './css-var';
-import { resolveRelativeColor } from './relative-color';
-import { resolveColor } from './resolve';
-import { ColorChannels, ComputedColorChannels, Options } from './typedef';
-
-/* constants */
-import { SYN_FN_CALC, SYN_FN_REL, SYN_FN_VAR, VAL_COMP } from './constant';
-const NAMESPACE = 'convert';
-
-/* regexp */
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_REL = new RegExp(SYN_FN_REL);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-
-/**
- * pre process
- * @param value - CSS color value
- * @param [opt] - options
- * @returns value
- */
-export const preProcess = (
-  value: string,
-  opt: Options = {}
-): string | NullObject => {
-  if (isString(value)) {
-    value = value.trim();
-    if (!value) {
-      return new NullObject();
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'preProcess',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    return cachedResult.item as string;
-  }
-  if (REG_FN_VAR.test(value)) {
-    const resolvedValue = resolveVar(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  if (REG_FN_REL.test(value)) {
-    const resolvedValue = resolveRelativeColor(value, opt);
-    if (isString(resolvedValue)) {
-      value = resolvedValue;
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  } else if (REG_FN_CALC.test(value)) {
-    value = cssCalc(value, opt);
-  }
-  if (value.startsWith('color-mix')) {
-    const clonedOpt = structuredClone(opt);
-    clonedOpt.format = VAL_COMP;
-    clonedOpt.nullable = true;
-    const resolvedValue = resolveColor(value, clonedOpt);
-    setCache(cacheKey, resolvedValue);
-    return resolvedValue;
-  }
-  setCache(cacheKey, value);
-  return value;
-};
-
-/**
- * convert number to hex string
- * @param value - numeric value
- * @returns hex string: 00..ff
- */
-export const numberToHex = (value: number): string => {
-  const hex = numberToHexString(value);
-  return hex;
-};
-
-/**
- * convert color to hex
- * @param value - CSS color value
- * @param [opt] - options
- * @param [opt.alpha] - enable alpha channel
- * @returns #rrggbb | #rrggbbaa | null
- */
-export const colorToHex = (value: string, opt: Options = {}): string | null => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return null;
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const { alpha = false } = opt;
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToHex',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return null;
-    }
-    return cachedResult.item as string;
-  }
-  let hex;
-  opt.nullable = true;
-  if (alpha) {
-    opt.format = 'hexAlpha';
-    hex = resolveColor(value, opt);
-  } else {
-    opt.format = 'hex';
-    hex = resolveColor(value, opt);
-  }
-  if (isString(hex)) {
-    setCache(cacheKey, hex);
-    return hex;
-  }
-  setCache(cacheKey, null);
-  return null;
-};
-
-/**
- * convert color to hsl
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [h, s, l, alpha]
- */
-export const colorToHsl = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToHsl',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  opt.format = 'hsl';
-  const hsl = convertColorToHsl(value, opt) as ColorChannels;
-  setCache(cacheKey, hsl);
-  return hsl;
-};
-
-/**
- * convert color to hwb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [h, w, b, alpha]
- */
-export const colorToHwb = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToHwb',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  opt.format = 'hwb';
-  const hwb = convertColorToHwb(value, opt) as ColorChannels;
-  setCache(cacheKey, hwb);
-  return hwb;
-};
-
-/**
- * convert color to lab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, a, b, alpha]
- */
-export const colorToLab = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToLab',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  const lab = convertColorToLab(value, opt) as ColorChannels;
-  setCache(cacheKey, lab);
-  return lab;
-};
-
-/**
- * convert color to lch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, c, h, alpha]
- */
-export const colorToLch = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToLch',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  const lch = convertColorToLch(value, opt) as ColorChannels;
-  setCache(cacheKey, lch);
-  return lch;
-};
-
-/**
- * convert color to oklab
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, a, b, alpha]
- */
-export const colorToOklab = (
-  value: string,
-  opt: Options = {}
-): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToOklab',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  const lab = convertColorToOklab(value, opt) as ColorChannels;
-  setCache(cacheKey, lab);
-  return lab;
-};
-
-/**
- * convert color to oklch
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [l, c, h, alpha]
- */
-export const colorToOklch = (
-  value: string,
-  opt: Options = {}
-): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToOklch',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  const lch = convertColorToOklch(value, opt) as ColorChannels;
-  setCache(cacheKey, lch);
-  return lch;
-};
-
-/**
- * convert color to rgb
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [r, g, b, alpha]
- */
-export const colorToRgb = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToRgb',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  const rgb = convertColorToRgb(value, opt) as ColorChannels;
-  setCache(cacheKey, rgb);
-  return rgb;
-};
-
-/**
- * convert color to xyz
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export const colorToXyz = (value: string, opt: Options = {}): ColorChannels => {
-  if (isString(value)) {
-    const resolvedValue = preProcess(value, opt);
-    if (resolvedValue instanceof NullObject) {
-      return [0, 0, 0, 0];
-    }
-    value = resolvedValue.toLowerCase();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'colorToXyz',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as ColorChannels;
-  }
-  let xyz;
-  if (value.startsWith('color(')) {
-    [, ...xyz] = parseColorFunc(value, opt) as ComputedColorChannels;
-  } else {
-    [, ...xyz] = parseColorValue(value, opt) as ComputedColorChannels;
-  }
-  setCache(cacheKey, xyz);
-  return xyz as ColorChannels;
-};
-
-/**
- * convert color to xyz-d50
- * @param value - CSS color value
- * @param [opt] - options
- * @returns ColorChannels - [x, y, z, alpha]
- */
-export const colorToXyzD50 = (
-  value: string,
-  opt: Options = {}
-): ColorChannels => {
-  opt.d50 = true;
-  return colorToXyz(value, opt);
-};
-
-/* convert */
-export const convert = {
-  colorToHex,
-  colorToHsl,
-  colorToHwb,
-  colorToLab,
-  colorToLch,
-  colorToOklab,
-  colorToOklch,
-  colorToRgb,
-  colorToXyz,
-  colorToXyzD50,
-  numberToHex
-};

node_modules/@asamuzakjp/css-color/src/js/css-calc.ts

@@ -1,955 +0,0 @@
-/**
- * css-calc
- */
-
-import { calc } from '@csstools/css-calc';
-import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
-import {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  setCache
-} from './cache';
-import { isString, isStringOrNumber } from './common';
-import { resolveVar } from './css-var';
-import { resolveLengthInPixels, roundToPrecision } from './util';
-import { MatchedRegExp, Options } from './typedef';
-
-/* constants */
-import {
-  ANGLE,
-  LENGTH,
-  NUM,
-  SYN_FN_CALC,
-  SYN_FN_MATH_START,
-  SYN_FN_VAR,
-  SYN_FN_VAR_START,
-  VAL_SPEC
-} from './constant';
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  Dimension: DIM,
-  EOF,
-  Function: FUNC,
-  OpenParen: PAREN_OPEN,
-  Whitespace: W_SPACE
-} = TokenType;
-const NAMESPACE = 'css-calc';
-
-/* numeric constants */
-const TRIA = 3;
-const HEX = 16;
-const MAX_PCT = 100;
-
-/* regexp */
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_CALC_NUM = new RegExp(`^calc\\((${NUM})\\)$`);
-const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-const REG_FN_VAR_START = new RegExp(SYN_FN_VAR_START);
-const REG_OPERATOR = /\s[*+/-]\s/;
-const REG_TYPE_DIM = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH})$`);
-const REG_TYPE_DIM_PCT = new RegExp(`^(${NUM})(${ANGLE}|${LENGTH}|%)$`);
-const REG_TYPE_PCT = new RegExp(`^(${NUM})%$`);
-
-/**
- * Calclator
- */
-export class Calculator {
-  /* private */
-  // number
-  #hasNum: boolean;
-  #numSum: number[];
-  #numMul: number[];
-  // percentage
-  #hasPct: boolean;
-  #pctSum: number[];
-  #pctMul: number[];
-  // dimension
-  #hasDim: boolean;
-  #dimSum: string[];
-  #dimSub: string[];
-  #dimMul: string[];
-  #dimDiv: string[];
-  // et cetra
-  #hasEtc: boolean;
-  #etcSum: string[];
-  #etcSub: string[];
-  #etcMul: string[];
-  #etcDiv: string[];
-
-  /**
-   * constructor
-   */
-  constructor() {
-    // number
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    // percentage
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    // dimension
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    // et cetra
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-
-  get hasNum() {
-    return this.#hasNum;
-  }
-
-  set hasNum(value: boolean) {
-    this.#hasNum = !!value;
-  }
-
-  get numSum() {
-    return this.#numSum;
-  }
-
-  get numMul() {
-    return this.#numMul;
-  }
-
-  get hasPct() {
-    return this.#hasPct;
-  }
-
-  set hasPct(value: boolean) {
-    this.#hasPct = !!value;
-  }
-
-  get pctSum() {
-    return this.#pctSum;
-  }
-
-  get pctMul() {
-    return this.#pctMul;
-  }
-
-  get hasDim() {
-    return this.#hasDim;
-  }
-
-  set hasDim(value: boolean) {
-    this.#hasDim = !!value;
-  }
-
-  get dimSum() {
-    return this.#dimSum;
-  }
-
-  get dimSub() {
-    return this.#dimSub;
-  }
-
-  get dimMul() {
-    return this.#dimMul;
-  }
-
-  get dimDiv() {
-    return this.#dimDiv;
-  }
-
-  get hasEtc() {
-    return this.#hasEtc;
-  }
-
-  set hasEtc(value: boolean) {
-    this.#hasEtc = !!value;
-  }
-
-  get etcSum() {
-    return this.#etcSum;
-  }
-
-  get etcSub() {
-    return this.#etcSub;
-  }
-
-  get etcMul() {
-    return this.#etcMul;
-  }
-
-  get etcDiv() {
-    return this.#etcDiv;
-  }
-
-  /**
-   * clear values
-   * @returns void
-   */
-  clear() {
-    // number
-    this.#hasNum = false;
-    this.#numSum = [];
-    this.#numMul = [];
-    // percentage
-    this.#hasPct = false;
-    this.#pctSum = [];
-    this.#pctMul = [];
-    // dimension
-    this.#hasDim = false;
-    this.#dimSum = [];
-    this.#dimSub = [];
-    this.#dimMul = [];
-    this.#dimDiv = [];
-    // et cetra
-    this.#hasEtc = false;
-    this.#etcSum = [];
-    this.#etcSub = [];
-    this.#etcMul = [];
-    this.#etcDiv = [];
-  }
-
-  /**
-   * sort values
-   * @param values - values
-   * @returns sorted values
-   */
-  sort(values: string[] = []): string[] {
-    const arr = [...values];
-    if (arr.length > 1) {
-      arr.sort((a, b) => {
-        let res;
-        if (REG_TYPE_DIM_PCT.test(a) && REG_TYPE_DIM_PCT.test(b)) {
-          const [, valA, unitA] = a.match(REG_TYPE_DIM_PCT) as MatchedRegExp;
-          const [, valB, unitB] = b.match(REG_TYPE_DIM_PCT) as MatchedRegExp;
-          if (unitA === unitB) {
-            if (Number(valA) === Number(valB)) {
-              res = 0;
-            } else if (Number(valA) > Number(valB)) {
-              res = 1;
-            } else {
-              res = -1;
-            }
-          } else if (unitA > unitB) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        } else {
-          if (a === b) {
-            res = 0;
-          } else if (a > b) {
-            res = 1;
-          } else {
-            res = -1;
-          }
-        }
-        return res;
-      });
-    }
-    return arr;
-  }
-
-  /**
-   * multiply values
-   * @returns resolved value
-   */
-  multiply(): string {
-    const value = [];
-    let num;
-    if (this.#hasNum) {
-      num = 1;
-      for (const i of this.#numMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (!this.#hasPct && !this.#hasDim && !this.hasEtc) {
-        if (Number.isFinite(num)) {
-          num = roundToPrecision(num, HEX);
-        }
-        value.push(num);
-      }
-    }
-    if (this.#hasPct) {
-      if (typeof num !== 'number') {
-        num = 1;
-      }
-      for (const i of this.#pctMul) {
-        num *= i;
-        if (num === 0 || !Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${roundToPrecision(num, HEX)}%`;
-      }
-      if (!this.#hasDim && !this.hasEtc) {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim = '';
-      let mul = '';
-      let div = '';
-      if (this.#dimMul.length) {
-        if (this.#dimMul.length === 1) {
-          [mul] = this.#dimMul as [string];
-        } else {
-          mul = `${this.sort(this.#dimMul).join(' * ')}`;
-        }
-      }
-      if (this.#dimDiv.length) {
-        if (this.#dimDiv.length === 1) {
-          [div] = this.#dimDiv as [string];
-        } else {
-          div = `${this.sort(this.#dimDiv).join(' * ')}`;
-        }
-      }
-      if (Number.isFinite(num)) {
-        if (mul) {
-          if (div) {
-            if (div.includes('*')) {
-              dim = calc(`calc(${num} * ${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = calc(`calc(${num} * ${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = calc(`calc(${num} * ${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else if (div.includes('*')) {
-          dim = calc(`calc(${num} / (${div}))`, {
-            toCanonicalUnits: true
-          });
-        } else {
-          dim = calc(`calc(${num} / ${div})`, {
-            toCanonicalUnits: true
-          });
-        }
-        value.push(dim.replace(/^calc/, ''));
-      } else {
-        if (!value.length && num !== undefined) {
-          value.push(num);
-        }
-        if (mul) {
-          if (div) {
-            if (div.includes('*')) {
-              dim = calc(`calc(${mul} / (${div}))`, {
-                toCanonicalUnits: true
-              });
-            } else {
-              dim = calc(`calc(${mul} / ${div})`, {
-                toCanonicalUnits: true
-              });
-            }
-          } else {
-            dim = calc(`calc(${mul})`, {
-              toCanonicalUnits: true
-            });
-          }
-          if (value.length) {
-            value.push('*', dim.replace(/^calc/, ''));
-          } else {
-            value.push(dim.replace(/^calc/, ''));
-          }
-        } else {
-          dim = calc(`calc(${div})`, {
-            toCanonicalUnits: true
-          });
-          if (value.length) {
-            value.push('/', dim.replace(/^calc/, ''));
-          } else {
-            value.push('1', '/', dim.replace(/^calc/, ''));
-          }
-        }
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcMul.length) {
-        if (!value.length && num !== undefined) {
-          value.push(num);
-        }
-        const mul = this.sort(this.#etcMul).join(' * ');
-        if (value.length) {
-          value.push(`* ${mul}`);
-        } else {
-          value.push(`${mul}`);
-        }
-      }
-      if (this.#etcDiv.length) {
-        const div = this.sort(this.#etcDiv).join(' * ');
-        if (div.includes('*')) {
-          if (value.length) {
-            value.push(`/ (${div})`);
-          } else {
-            value.push(`1 / (${div})`);
-          }
-        } else if (value.length) {
-          value.push(`/ ${div}`);
-        } else {
-          value.push(`1 / ${div}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(' ');
-    }
-    return '';
-  }
-
-  /**
-   * sum values
-   * @returns resolved value
-   */
-  sum(): string {
-    const value = [];
-    if (this.#hasNum) {
-      let num = 0;
-      for (const i of this.#numSum) {
-        num += i;
-        if (!Number.isFinite(num) || Number.isNaN(num)) {
-          break;
-        }
-      }
-      value.push(num);
-    }
-    if (this.#hasPct) {
-      let num: number | string = 0;
-      for (const i of this.#pctSum) {
-        num += i;
-        if (!Number.isFinite(num)) {
-          break;
-        }
-      }
-      if (Number.isFinite(num)) {
-        num = `${num}%`;
-      }
-      if (value.length) {
-        value.push(`+ ${num}`);
-      } else {
-        value.push(num);
-      }
-    }
-    if (this.#hasDim) {
-      let dim, sum, sub;
-      if (this.#dimSum.length) {
-        sum = this.sort(this.#dimSum).join(' + ');
-      }
-      if (this.#dimSub.length) {
-        sub = this.sort(this.#dimSub).join(' + ');
-      }
-      if (sum) {
-        if (sub) {
-          if (sub.includes('-')) {
-            dim = calc(`calc(${sum} - (${sub}))`, {
-              toCanonicalUnits: true
-            });
-          } else {
-            dim = calc(`calc(${sum} - ${sub})`, {
-              toCanonicalUnits: true
-            });
-          }
-        } else {
-          dim = calc(`calc(${sum})`, {
-            toCanonicalUnits: true
-          });
-        }
-      } else {
-        dim = calc(`calc(-1 * (${sub}))`, {
-          toCanonicalUnits: true
-        });
-      }
-      if (value.length) {
-        value.push('+', dim.replace(/^calc/, ''));
-      } else {
-        value.push(dim.replace(/^calc/, ''));
-      }
-    }
-    if (this.#hasEtc) {
-      if (this.#etcSum.length) {
-        const sum = this.sort(this.#etcSum)
-          .map(item => {
-            let res;
-            if (
-              REG_OPERATOR.test(item) &&
-              !item.startsWith('(') &&
-              !item.endsWith(')')
-            ) {
-              res = `(${item})`;
-            } else {
-              res = item;
-            }
-            return res;
-          })
-          .join(' + ');
-        if (value.length) {
-          if (this.#etcSum.length > 1) {
-            value.push(`+ (${sum})`);
-          } else {
-            value.push(`+ ${sum}`);
-          }
-        } else {
-          value.push(`${sum}`);
-        }
-      }
-      if (this.#etcSub.length) {
-        const sub = this.sort(this.#etcSub)
-          .map(item => {
-            let res;
-            if (
-              REG_OPERATOR.test(item) &&
-              !item.startsWith('(') &&
-              !item.endsWith(')')
-            ) {
-              res = `(${item})`;
-            } else {
-              res = item;
-            }
-            return res;
-          })
-          .join(' + ');
-        if (value.length) {
-          if (this.#etcSub.length > 1) {
-            value.push(`- (${sub})`);
-          } else {
-            value.push(`- ${sub}`);
-          }
-        } else if (this.#etcSub.length > 1) {
-          value.push(`-1 * (${sub})`);
-        } else {
-          value.push(`-1 * ${sub}`);
-        }
-      }
-    }
-    if (value.length) {
-      return value.join(' ');
-    }
-    return '';
-  }
-}
-
-/**
- * sort calc values
- * @param values - values to sort
- * @param [finalize] - finalize values
- * @returns sorted values
- */
-export const sortCalcValues = (
-  values: (number | string)[] = [],
-  finalize: boolean = false
-): string => {
-  if (values.length < TRIA) {
-    throw new Error(`Unexpected array length ${values.length}.`);
-  }
-  const start = values.shift();
-  if (!isString(start) || !start.endsWith('(')) {
-    throw new Error(`Unexpected token ${start}.`);
-  }
-  const end = values.pop();
-  if (end !== ')') {
-    throw new Error(`Unexpected token ${end}.`);
-  }
-  if (values.length === 1) {
-    const [value] = values;
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    return `${start}${value}${end}`;
-  }
-  const sortedValues = [];
-  const cal = new Calculator();
-  let operator: string = '';
-  const l = values.length;
-  for (let i = 0; i < l; i++) {
-    const value = values[i];
-    if (!isStringOrNumber(value)) {
-      throw new Error(`Unexpected token ${value}.`);
-    }
-    if (value === '*' || value === '/') {
-      operator = value;
-    } else if (value === '+' || value === '-') {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue, value);
-      }
-      cal.clear();
-      operator = '';
-    } else {
-      const numValue = Number(value);
-      const strValue = `${value}`;
-      switch (operator) {
-        case '/': {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(1 / numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
-            cal.hasPct = true;
-            cal.pctMul.push((MAX_PCT * MAX_PCT) / Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimDiv.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcDiv.push(strValue);
-          }
-          break;
-        }
-        case '*':
-        default: {
-          if (Number.isFinite(numValue)) {
-            cal.hasNum = true;
-            cal.numMul.push(numValue);
-          } else if (REG_TYPE_PCT.test(strValue)) {
-            const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
-            cal.hasPct = true;
-            cal.pctMul.push(Number(val));
-          } else if (REG_TYPE_DIM.test(strValue)) {
-            cal.hasDim = true;
-            cal.dimMul.push(strValue);
-          } else {
-            cal.hasEtc = true;
-            cal.etcMul.push(strValue);
-          }
-        }
-      }
-    }
-    if (i === l - 1) {
-      const sortedValue = cal.multiply();
-      if (sortedValue) {
-        sortedValues.push(sortedValue);
-      }
-      cal.clear();
-      operator = '';
-    }
-  }
-  let resolvedValue = '';
-  if (finalize && (sortedValues.includes('+') || sortedValues.includes('-'))) {
-    const finalizedValues = [];
-    cal.clear();
-    operator = '';
-    const l = sortedValues.length;
-    for (let i = 0; i < l; i++) {
-      const value = sortedValues[i];
-      if (isStringOrNumber(value)) {
-        if (value === '+' || value === '-') {
-          operator = value;
-        } else {
-          const numValue = Number(value);
-          const strValue = `${value}`;
-          switch (operator) {
-            case '-': {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(-1 * numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
-                cal.hasPct = true;
-                cal.pctSum.push(-1 * Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSub.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSub.push(strValue);
-              }
-              break;
-            }
-            case '+':
-            default: {
-              if (Number.isFinite(numValue)) {
-                cal.hasNum = true;
-                cal.numSum.push(numValue);
-              } else if (REG_TYPE_PCT.test(strValue)) {
-                const [, val] = strValue.match(REG_TYPE_PCT) as MatchedRegExp;
-                cal.hasPct = true;
-                cal.pctSum.push(Number(val));
-              } else if (REG_TYPE_DIM.test(strValue)) {
-                cal.hasDim = true;
-                cal.dimSum.push(strValue);
-              } else {
-                cal.hasEtc = true;
-                cal.etcSum.push(strValue);
-              }
-            }
-          }
-        }
-      }
-      if (i === l - 1) {
-        const sortedValue = cal.sum();
-        if (sortedValue) {
-          finalizedValues.push(sortedValue);
-        }
-        cal.clear();
-        operator = '';
-      }
-    }
-    resolvedValue = finalizedValues.join(' ').replace(/\+\s-/g, '- ');
-  } else {
-    resolvedValue = sortedValues.join(' ').replace(/\+\s-/g, '- ');
-  }
-  if (
-    resolvedValue.startsWith('(') &&
-    resolvedValue.endsWith(')') &&
-    resolvedValue.lastIndexOf('(') === 0 &&
-    resolvedValue.indexOf(')') === resolvedValue.length - 1
-  ) {
-    resolvedValue = resolvedValue.replace(/^\(/, '').replace(/\)$/, '');
-  }
-  return `${start}${resolvedValue}${end}`;
-};
-
-/**
- * serialize calc
- * @param value - CSS value
- * @param [opt] - options
- * @returns serialized value
- */
-export const serializeCalc = (value: string, opt: Options = {}): string => {
-  const { format = '' } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR_START.test(value) || format !== VAL_SPEC) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'serializeCalc',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as string;
-  }
-  const items: string[] = tokenize({ css: value })
-    .map((token: CSSToken): string => {
-      const [type, value] = token as [TokenType, string];
-      let res = '';
-      if (type !== W_SPACE && type !== COMMENT) {
-        res = value;
-      }
-      return res;
-    })
-    .filter(v => v);
-  let startIndex = items.findLastIndex((item: string) => /\($/.test(item));
-  while (startIndex) {
-    const endIndex = items.findIndex((item: unknown, index: number) => {
-      return item === ')' && index > startIndex;
-    });
-    const slicedValues: string[] = items.slice(startIndex, endIndex + 1);
-    let serializedValue: string = sortCalcValues(slicedValues);
-    if (REG_FN_VAR_START.test(serializedValue)) {
-      serializedValue = calc(serializedValue, {
-        toCanonicalUnits: true
-      });
-    }
-    items.splice(startIndex, endIndex - startIndex + 1, serializedValue);
-    startIndex = items.findLastIndex((item: string) => /\($/.test(item));
-  }
-  const serializedCalc = sortCalcValues(items, true);
-  setCache(cacheKey, serializedCalc);
-  return serializedCalc;
-};
-
-/**
- * resolve dimension
- * @param token - CSS token
- * @param [opt] - options
- * @returns resolved value
- */
-export const resolveDimension = (
-  token: CSSToken,
-  opt: Options = {}
-): string | NullObject => {
-  if (!Array.isArray(token)) {
-    throw new TypeError(`${token} is not an array.`);
-  }
-  const [, , , , detail = {}] = token;
-  const { unit, value } = detail as {
-    unit: string;
-    value: number;
-  };
-  if (unit === 'px') {
-    return `${value}${unit}`;
-  }
-  const pixelValue = resolveLengthInPixels(Number(value), unit, opt);
-  if (Number.isFinite(pixelValue)) {
-    return `${roundToPrecision(pixelValue, HEX)}px`;
-  }
-  return new NullObject();
-};
-
-/**
- * parse tokens
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns parsed tokens
- */
-export const parseTokens = (
-  tokens: CSSToken[],
-  opt: Options = {}
-): string[] => {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { format = '' } = opt;
-  const mathFunc = new Set();
-  let nest = 0;
-  const res: string[] = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type = '', value = ''] = token as [TokenType, string];
-    switch (type) {
-      case DIM: {
-        if (format === VAL_SPEC && !mathFunc.has(nest)) {
-          res.push(value);
-        } else {
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            res.push(resolvedValue);
-          } else {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      case FUNC:
-      case PAREN_OPEN: {
-        res.push(value);
-        nest++;
-        if (REG_FN_MATH_START.test(value)) {
-          mathFunc.add(nest);
-        }
-        break;
-      }
-      case PAREN_CLOSE: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (lastValue === ' ') {
-            res.splice(-1, 1, value);
-          } else {
-            res.push(value);
-          }
-        } else {
-          res.push(value);
-        }
-        if (mathFunc.has(nest)) {
-          mathFunc.delete(nest);
-        }
-        nest--;
-        break;
-      }
-      case W_SPACE: {
-        if (res.length) {
-          const lastValue = res[res.length - 1];
-          if (
-            isString(lastValue) &&
-            !lastValue.endsWith('(') &&
-            lastValue !== ' '
-          ) {
-            res.push(value);
-          }
-        }
-        break;
-      }
-      default: {
-        if (type !== COMMENT && type !== EOF) {
-          res.push(value);
-        }
-      }
-    }
-  }
-  return res;
-};
-
-/**
- * CSS calc()
- * @param value - CSS value including calc()
- * @param [opt] - options
- * @returns resolved value
- */
-export const cssCalc = (value: string, opt: Options = {}): string => {
-  const { format = '' } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-      } else {
-        const resolvedValue = resolveVar(value, opt);
-        if (isString(resolvedValue)) {
-          return resolvedValue;
-        } else {
-          return '';
-        }
-      }
-    } else if (!REG_FN_CALC.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'cssCalc',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    return cachedResult.item as string;
-  }
-  const tokens = tokenize({ css: value });
-  const values = parseTokens(tokens, opt);
-  let resolvedValue: string = calc(values.join(''), {
-    toCanonicalUnits: true
-  });
-  if (REG_FN_VAR_START.test(value)) {
-    if (REG_TYPE_DIM_PCT.test(resolvedValue)) {
-      const [, val, unit] = resolvedValue.match(
-        REG_TYPE_DIM_PCT
-      ) as MatchedRegExp;
-      resolvedValue = `${roundToPrecision(Number(val), HEX)}${unit}`;
-    }
-    // wrap with `calc()`
-    if (
-      resolvedValue &&
-      !REG_FN_VAR_START.test(resolvedValue) &&
-      format === VAL_SPEC
-    ) {
-      resolvedValue = `calc(${resolvedValue})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    if (/\s[-+*/]\s/.test(resolvedValue) && !resolvedValue.includes('NaN')) {
-      resolvedValue = serializeCalc(resolvedValue, opt);
-    } else if (REG_FN_CALC_NUM.test(resolvedValue)) {
-      const [, val] = resolvedValue.match(REG_FN_CALC_NUM) as MatchedRegExp;
-      resolvedValue = `calc(${roundToPrecision(Number(val), HEX)})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-};

node_modules/@asamuzakjp/css-color/src/js/css-gradient.ts

@@ -1,384 +0,0 @@
-/**
- * css-gradient
- */
-
-import { CacheItem, createCacheKey, getCache, setCache } from './cache';
-import { resolveColor } from './resolve';
-import { isString } from './common';
-import { MatchedRegExp, Options } from './typedef';
-import { isColor, splitValue } from './util';
-
-/* constants */
-import {
-  ANGLE,
-  CS_HUE,
-  CS_RECT,
-  LENGTH,
-  NUM,
-  NUM_POSITIVE,
-  PCT,
-  VAL_COMP,
-  VAL_SPEC
-} from './constant';
-const NAMESPACE = 'css-gradient';
-const DIM_ANGLE = `${NUM}(?:${ANGLE})`;
-const DIM_ANGLE_PCT = `${DIM_ANGLE}|${PCT}`;
-const DIM_LEN = `${NUM}(?:${LENGTH})|0`;
-const DIM_LEN_PCT = `${DIM_LEN}|${PCT}`;
-const DIM_LEN_PCT_POSI = `${NUM_POSITIVE}(?:${LENGTH}|%)|0`;
-const DIM_LEN_POSI = `${NUM_POSITIVE}(?:${LENGTH})|0`;
-const CTR = 'center';
-const L_R = 'left|right';
-const T_B = 'top|bottom';
-const S_E = 'start|end';
-const AXIS_X = `${L_R}|x-(?:${S_E})`;
-const AXIS_Y = `${T_B}|y-(?:${S_E})`;
-const BLOCK = `block-(?:${S_E})`;
-const INLINE = `inline-(?:${S_E})`;
-const POS_1 = `${CTR}|${AXIS_X}|${AXIS_Y}|${BLOCK}|${INLINE}|${DIM_LEN_PCT}`;
-const POS_2 = [
-  `(?:${CTR}|${AXIS_X})\\s+(?:${CTR}|${AXIS_Y})`,
-  `(?:${CTR}|${AXIS_Y})\\s+(?:${CTR}|${AXIS_X})`,
-  `(?:${CTR}|${AXIS_X}|${DIM_LEN_PCT})\\s+(?:${CTR}|${AXIS_Y}|${DIM_LEN_PCT})`,
-  `(?:${CTR}|${BLOCK})\\s+(?:${CTR}|${INLINE})`,
-  `(?:${CTR}|${INLINE})\\s+(?:${CTR}|${BLOCK})`,
-  `(?:${CTR}|${S_E})\\s+(?:${CTR}|${S_E})`
-].join('|');
-const POS_4 = [
-  `(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${AXIS_Y})\\s+(?:${DIM_LEN_PCT})\\s+(?:${AXIS_X})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})\\s+(?:${INLINE})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${INLINE})\\s+(?:${DIM_LEN_PCT})\\s+(?:${BLOCK})\\s+(?:${DIM_LEN_PCT})`,
-  `(?:${S_E})\\s+(?:${DIM_LEN_PCT})\\s+(?:${S_E})\\s+(?:${DIM_LEN_PCT})`
-].join('|');
-const RAD_EXTENT = '(?:clos|farth)est-(?:corner|side)';
-const RAD_SIZE = [
-  `${RAD_EXTENT}(?:\\s+${RAD_EXTENT})?`,
-  `${DIM_LEN_POSI}`,
-  `(?:${DIM_LEN_PCT_POSI})\\s+(?:${DIM_LEN_PCT_POSI})`
-].join('|');
-const RAD_SHAPE = 'circle|ellipse';
-const FROM_ANGLE = `from\\s+${DIM_ANGLE}`;
-const AT_POSITION = `at\\s+(?:${POS_1}|${POS_2}|${POS_4})`;
-const TO_SIDE_CORNER = `to\\s+(?:(?:${L_R})(?:\\s(?:${T_B}))?|(?:${T_B})(?:\\s(?:${L_R}))?)`;
-const IN_COLOR_SPACE = `in\\s+(?:${CS_RECT}|${CS_HUE})`;
-
-/* type definitions */
-/**
- * @type ColorStopList - list of color stops
- */
-type ColorStopList = [string, string, ...string[]];
-
-/**
- * @typedef ValidateGradientLine - validate gradient line
- * @property line - gradient line
- * @property valid - result
- */
-interface ValidateGradientLine {
-  line: string;
-  valid: boolean;
-}
-
-/**
- * @typedef ValidateColorStops - validate color stops
- * @property colorStops - list of color stops
- * @property valid - result
- */
-interface ValidateColorStops {
-  colorStops: string[];
-  valid: boolean;
-}
-
-/**
- * @typedef Gradient - parsed CSS gradient
- * @property value - input value
- * @property type - gradient type
- * @property [gradientLine] - gradient line
- * @property colorStopList - list of color stops
- */
-interface Gradient {
-  value: string;
-  type: string;
-  gradientLine?: string;
-  colorStopList: ColorStopList;
-}
-
-/* regexp */
-const REG_GRAD = /^(?:repeating-)?(?:conic|linear|radial)-gradient\(/;
-const REG_GRAD_CAPT = /^((?:repeating-)?(?:conic|linear|radial)-gradient)\(/;
-
-/**
- * get gradient type
- * @param value - gradient value
- * @returns gradient type
- */
-export const getGradientType = (value: string): string => {
-  if (isString(value)) {
-    value = value.trim();
-    if (REG_GRAD.test(value)) {
-      const [, type] = value.match(REG_GRAD_CAPT) as MatchedRegExp;
-      return type;
-    }
-  }
-  return '';
-};
-
-/**
- * validate gradient line
- * @param value - gradient line value
- * @param type - gradient type
- * @returns result
- */
-export const validateGradientLine = (
-  value: string,
-  type: string
-): ValidateGradientLine => {
-  if (isString(value) && isString(type)) {
-    value = value.trim();
-    type = type.trim();
-    let lineSyntax = '';
-    const defaultValues = [];
-    if (/^(?:repeating-)?linear-gradient$/.test(type)) {
-      /*
-       * <linear-gradient-line> = [
-       *   [ <angle> | to <side-or-corner> ] ||
-       *   <color-interpolation-method>
-       * ]
-       */
-      lineSyntax = [
-        `(?:${DIM_ANGLE}|${TO_SIDE_CORNER})(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+(?:${DIM_ANGLE}|${TO_SIDE_CORNER}))?`
-      ].join('|');
-      defaultValues.push(/to\s+bottom/);
-    } else if (/^(?:repeating-)?radial-gradient$/.test(type)) {
-      /*
-       * <radial-gradient-line> = [
-       *   [ [ <radial-shape> || <radial-size> ]? [ at <position> ]? ] ||
-       *   <color-interpolation-method>]?
-       */
-      lineSyntax = [
-        `(?:${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `(?:${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SHAPE})(?:\\s+(?:${RAD_SIZE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${RAD_SIZE})(?:\\s+(?:${RAD_SHAPE}))?(?:\\s+${AT_POSITION})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${AT_POSITION})?`
-      ].join('|');
-      defaultValues.push(/ellipse/, /farthest-corner/, /at\s+center/);
-    } else if (/^(?:repeating-)?conic-gradient$/.test(type)) {
-      /*
-       * <conic-gradient-line> = [
-       *   [ [ from <angle> ]? [ at <position> ]? ] ||
-       *   <color-interpolation-method>
-       * ]
-       */
-      lineSyntax = [
-        `${FROM_ANGLE}(?:\\s+${AT_POSITION})?(?:\\s+${IN_COLOR_SPACE})?`,
-        `${AT_POSITION}(?:\\s+${IN_COLOR_SPACE})?`,
-        `${IN_COLOR_SPACE}(?:\\s+${FROM_ANGLE})?(?:\\s+${AT_POSITION})?`
-      ].join('|');
-      defaultValues.push(/at\s+center/);
-    }
-    if (lineSyntax) {
-      const reg = new RegExp(`^(?:${lineSyntax})$`);
-      const valid = reg.test(value);
-      if (valid) {
-        let line = value;
-        for (const defaultValue of defaultValues) {
-          line = line.replace(defaultValue, '');
-        }
-        line = line.replace(/\s{2,}/g, ' ').trim();
-        return {
-          line,
-          valid
-        };
-      }
-      return {
-        valid,
-        line: value
-      };
-    }
-  }
-  return {
-    line: value,
-    valid: false
-  };
-};
-
-/**
- * validate color stop list
- * @param list
- * @param type
- * @param [opt]
- * @returns result
- */
-export const validateColorStopList = (
-  list: string[],
-  type: string,
-  opt: Options = {}
-): ValidateColorStops => {
-  if (Array.isArray(list) && list.length > 1) {
-    const dimension = /^(?:repeating-)?conic-gradient$/.test(type)
-      ? DIM_ANGLE_PCT
-      : DIM_LEN_PCT;
-    const regColorHint = new RegExp(`^(?:${dimension})$`);
-    const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-    const valueTypes = [];
-    const valueList = [];
-    for (const item of list) {
-      if (isString(item)) {
-        if (regColorHint.test(item)) {
-          valueTypes.push('hint');
-          valueList.push(item);
-        } else {
-          const itemColor = item.replace(regDimension, '');
-          if (isColor(itemColor, { format: VAL_SPEC })) {
-            const resolvedColor = resolveColor(itemColor, opt) as string;
-            valueTypes.push('color');
-            valueList.push(item.replace(itemColor, resolvedColor));
-          } else {
-            return {
-              colorStops: list,
-              valid: false
-            };
-          }
-        }
-      }
-    }
-    const valid = /^color(?:,(?:hint,)?color)+$/.test(valueTypes.join(','));
-    return {
-      valid,
-      colorStops: valueList
-    };
-  }
-  return {
-    colorStops: list,
-    valid: false
-  };
-};
-
-/**
- * parse CSS gradient
- * @param value - gradient value
- * @param [opt] - options
- * @returns parsed result
- */
-export const parseGradient = (
-  value: string,
-  opt: Options = {}
-): Gradient | null => {
-  if (isString(value)) {
-    value = value.trim();
-    const cacheKey: string = createCacheKey(
-      {
-        namespace: NAMESPACE,
-        name: 'parseGradient',
-        value
-      },
-      opt
-    );
-    const cachedResult = getCache(cacheKey);
-    if (cachedResult instanceof CacheItem) {
-      if (cachedResult.isNull) {
-        return null;
-      }
-      return cachedResult.item as Gradient;
-    }
-    const type = getGradientType(value);
-    const gradValue = value.replace(REG_GRAD, '').replace(/\)$/, '');
-    if (type && gradValue) {
-      const [lineOrColorStop = '', ...itemList] = splitValue(gradValue, {
-        delimiter: ','
-      });
-      const dimension = /^(?:repeating-)?conic-gradient$/.test(type)
-        ? DIM_ANGLE_PCT
-        : DIM_LEN_PCT;
-      const regDimension = new RegExp(`(?:\\s+(?:${dimension})){1,2}$`);
-      let colorStop = '';
-      if (regDimension.test(lineOrColorStop)) {
-        const itemColor = lineOrColorStop.replace(regDimension, '');
-        if (isColor(itemColor, { format: VAL_SPEC })) {
-          const resolvedColor = resolveColor(itemColor, opt) as string;
-          colorStop = lineOrColorStop.replace(itemColor, resolvedColor);
-        }
-      } else if (isColor(lineOrColorStop, { format: VAL_SPEC })) {
-        colorStop = resolveColor(lineOrColorStop, opt) as string;
-      }
-      if (colorStop) {
-        itemList.unshift(colorStop);
-        const { colorStops, valid } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (valid) {
-          const res: Gradient = {
-            value,
-            type,
-            colorStopList: colorStops as ColorStopList
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      } else if (itemList.length > 1) {
-        const { line: gradientLine, valid: validLine } = validateGradientLine(
-          lineOrColorStop,
-          type
-        );
-        const { colorStops, valid: validColorStops } = validateColorStopList(
-          itemList,
-          type,
-          opt
-        );
-        if (validLine && validColorStops) {
-          const res: Gradient = {
-            value,
-            type,
-            gradientLine,
-            colorStopList: colorStops as ColorStopList
-          };
-          setCache(cacheKey, res);
-          return res;
-        }
-      }
-    }
-    setCache(cacheKey, null);
-    return null;
-  }
-  return null;
-};
-
-/**
- * resolve CSS gradient
- * @param value - CSS value
- * @param [opt] - options
- * @returns result
- */
-export const resolveGradient = (value: string, opt: Options = {}): string => {
-  const { format = VAL_COMP } = opt;
-  const gradient = parseGradient(value, opt);
-  if (gradient) {
-    const { type = '', gradientLine = '', colorStopList = [] } = gradient;
-    if (type && Array.isArray(colorStopList) && colorStopList.length > 1) {
-      if (gradientLine) {
-        return `${type}(${gradientLine}, ${colorStopList.join(', ')})`;
-      }
-      return `${type}(${colorStopList.join(', ')})`;
-    }
-  }
-  if (format === VAL_SPEC) {
-    return '';
-  }
-  return 'none';
-};
-
-/**
- * is CSS gradient
- * @param value - CSS value
- * @param [opt] - options
- * @returns result
- */
-export const isGradient = (value: string, opt: Options = {}): boolean => {
-  const gradient = parseGradient(value, opt);
-  return gradient !== null;
-};

node_modules/@asamuzakjp/css-color/src/js/css-var.ts

@@ -1,250 +0,0 @@
-/**
- * css-var
- */
-
-import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
-import {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  setCache
-} from './cache';
-import { isString } from './common';
-import { cssCalc } from './css-calc';
-import { isColor } from './util';
-import { Options } from './typedef';
-
-/* constants */
-import { FN_VAR, SYN_FN_CALC, SYN_FN_VAR, VAL_SPEC } from './constant';
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  EOF,
-  Ident: IDENT,
-  Whitespace: W_SPACE
-} = TokenType;
-const NAMESPACE = 'css-var';
-
-/* regexp */
-const REG_FN_CALC = new RegExp(SYN_FN_CALC);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-
-/**
- * resolve custom property
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns result - [tokens, resolvedValue]
- */
-export function resolveCustomProperty(
-  tokens: CSSToken[],
-  opt: Options = {}
-): [CSSToken[], string] {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { customProperty = {} } = opt;
-  const items: string[] = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value] = token as [TokenType, string];
-    // end of var()
-    if (type === PAREN_CLOSE) {
-      break;
-    }
-    // nested var()
-    if (value === FN_VAR) {
-      const [restTokens, item] = resolveCustomProperty(tokens, opt);
-      tokens = restTokens;
-      if (item) {
-        items.push(item);
-      }
-    } else if (type === IDENT) {
-      if (value.startsWith('--')) {
-        let item;
-        if (Object.hasOwn(customProperty, value)) {
-          item = customProperty[value] as string;
-        } else if (typeof customProperty.callback === 'function') {
-          item = customProperty.callback(value);
-        }
-        if (item) {
-          items.push(item);
-        }
-      } else if (value) {
-        items.push(value);
-      }
-    }
-  }
-  let resolveAsColor = false;
-  if (items.length > 1) {
-    const lastValue = items[items.length - 1];
-    resolveAsColor = isColor(lastValue);
-  }
-  let resolvedValue = '';
-  for (let item of items) {
-    item = item.trim();
-    if (REG_FN_VAR.test(item)) {
-      // recurse resolveVar()
-      const resolvedItem = resolveVar(item, opt);
-      if (isString(resolvedItem)) {
-        if (resolveAsColor) {
-          if (isColor(resolvedItem)) {
-            resolvedValue = resolvedItem;
-          }
-        } else {
-          resolvedValue = resolvedItem;
-        }
-      }
-    } else if (REG_FN_CALC.test(item)) {
-      item = cssCalc(item, opt);
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    } else if (
-      item &&
-      !/^(?:inherit|initial|revert(?:-layer)?|unset)$/.test(item)
-    ) {
-      if (resolveAsColor) {
-        if (isColor(item)) {
-          resolvedValue = item;
-        }
-      } else {
-        resolvedValue = item;
-      }
-    }
-    if (resolvedValue) {
-      break;
-    }
-  }
-  return [tokens, resolvedValue];
-}
-
-/**
- * parse tokens
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns parsed tokens
- */
-export function parseTokens(
-  tokens: CSSToken[],
-  opt: Options = {}
-): string[] | NullObject {
-  const res: string[] = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    const [type = '', value = ''] = token as [TokenType, string];
-    if (value === FN_VAR) {
-      const [restTokens, resolvedValue] = resolveCustomProperty(tokens, opt);
-      if (!resolvedValue) {
-        return new NullObject();
-      }
-      tokens = restTokens;
-      res.push(resolvedValue);
-    } else {
-      switch (type) {
-        case PAREN_CLOSE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (lastValue === ' ') {
-              res.splice(-1, 1, value);
-            } else {
-              res.push(value);
-            }
-          } else {
-            res.push(value);
-          }
-          break;
-        }
-        case W_SPACE: {
-          if (res.length) {
-            const lastValue = res[res.length - 1];
-            if (
-              isString(lastValue) &&
-              !lastValue.endsWith('(') &&
-              lastValue !== ' '
-            ) {
-              res.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF) {
-            res.push(value);
-          }
-        }
-      }
-    }
-  }
-  return res;
-}
-
-/**
- * resolve CSS var()
- * @param value - CSS value including var()
- * @param [opt] - options
- * @returns resolved value
- */
-export function resolveVar(
-  value: string,
-  opt: Options = {}
-): string | NullObject {
-  const { format = '' } = opt;
-  if (isString(value)) {
-    if (!REG_FN_VAR.test(value) || format === VAL_SPEC) {
-      return value;
-    }
-    value = value.trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'resolveVar',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    return cachedResult.item as string;
-  }
-  const tokens = tokenize({ css: value });
-  const values = parseTokens(tokens, opt);
-  if (Array.isArray(values)) {
-    let color = values.join('');
-    if (REG_FN_CALC.test(color)) {
-      color = cssCalc(color, opt);
-    }
-    setCache(cacheKey, color);
-    return color;
-  } else {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-}
-
-/**
- * CSS var()
- * @param value - CSS value including var()
- * @param [opt] - options
- * @returns resolved value
- */
-export const cssVar = (value: string, opt: Options = {}): string => {
-  const resolvedValue = resolveVar(value, opt);
-  if (isString(resolvedValue)) {
-    return resolvedValue;
-  }
-  return '';
-};

node_modules/@asamuzakjp/css-color/src/js/relative-color.ts

@@ -1,635 +0,0 @@
-/**
- * relative-color
- */
-
-import { SyntaxFlag, color as colorParser } from '@csstools/css-color-parser';
-import {
-  ComponentValue,
-  parseComponentValue
-} from '@csstools/css-parser-algorithms';
-import { CSSToken, TokenType, tokenize } from '@csstools/css-tokenizer';
-import {
-  CacheItem,
-  NullObject,
-  createCacheKey,
-  getCache,
-  setCache
-} from './cache';
-import { NAMED_COLORS, convertColorToRgb } from './color';
-import { isString, isStringOrNumber } from './common';
-import { resolveDimension, serializeCalc } from './css-calc';
-import { resolveColor } from './resolve';
-import { roundToPrecision, splitValue } from './util';
-import {
-  ColorChannels,
-  MatchedRegExp,
-  Options,
-  StringColorChannels
-} from './typedef';
-
-/* constants */
-import {
-  CS_LAB,
-  CS_LCH,
-  FN_LIGHT_DARK,
-  FN_REL,
-  FN_REL_CAPT,
-  FN_VAR,
-  NONE,
-  SYN_COLOR_TYPE,
-  SYN_FN_MATH_START,
-  SYN_FN_VAR,
-  SYN_MIX,
-  VAL_SPEC
-} from './constant';
-const {
-  CloseParen: PAREN_CLOSE,
-  Comment: COMMENT,
-  Delim: DELIM,
-  Dimension: DIM,
-  EOF,
-  Function: FUNC,
-  Ident: IDENT,
-  Number: NUM,
-  OpenParen: PAREN_OPEN,
-  Percentage: PCT,
-  Whitespace: W_SPACE
-} = TokenType;
-const { HasNoneKeywords: KEY_NONE } = SyntaxFlag;
-const NAMESPACE = 'relative-color';
-
-/* numeric constants */
-const OCT = 8;
-const DEC = 10;
-const HEX = 16;
-const MAX_PCT = 100;
-const MAX_RGB = 255;
-
-/* type definitions */
-/**
- * @type NumberOrStringColorChannels - color channel
- */
-type NumberOrStringColorChannels = ColorChannels & StringColorChannels;
-
-/* regexp */
-const REG_COLOR_CAPT = new RegExp(
-  `^${FN_REL}(${SYN_COLOR_TYPE}|${SYN_MIX})\\s+`
-);
-const REG_CS_HSL = /(?:hsla?|hwb)$/;
-const REG_CS_CIE = new RegExp(`^(?:${CS_LAB}|${CS_LCH})$`);
-const REG_FN_CALC_SUM = /^(?:abs|sig?n|cos|tan)\(/;
-const REG_FN_MATH_START = new RegExp(SYN_FN_MATH_START);
-const REG_FN_REL = new RegExp(FN_REL);
-const REG_FN_REL_CAPT = new RegExp(`^${FN_REL_CAPT}`);
-const REG_FN_REL_START = new RegExp(`^${FN_REL}`);
-const REG_FN_VAR = new RegExp(SYN_FN_VAR);
-
-/**
- * resolve relative color channels
- * @param tokens - CSS tokens
- * @param [opt] - options
- * @returns resolved color channels
- */
-export function resolveColorChannels(
-  tokens: CSSToken[],
-  opt: Options = {}
-): NumberOrStringColorChannels | NullObject {
-  if (!Array.isArray(tokens)) {
-    throw new TypeError(`${tokens} is not an array.`);
-  }
-  const { colorSpace = '', format = '' } = opt;
-  const colorChannels = new Map([
-    ['color', ['r', 'g', 'b', 'alpha']],
-    ['hsl', ['h', 's', 'l', 'alpha']],
-    ['hsla', ['h', 's', 'l', 'alpha']],
-    ['hwb', ['h', 'w', 'b', 'alpha']],
-    ['lab', ['l', 'a', 'b', 'alpha']],
-    ['lch', ['l', 'c', 'h', 'alpha']],
-    ['oklab', ['l', 'a', 'b', 'alpha']],
-    ['oklch', ['l', 'c', 'h', 'alpha']],
-    ['rgb', ['r', 'g', 'b', 'alpha']],
-    ['rgba', ['r', 'g', 'b', 'alpha']]
-  ]);
-  const colorChannel = colorChannels.get(colorSpace);
-  // invalid color channel
-  if (!colorChannel) {
-    return new NullObject();
-  }
-  const mathFunc = new Set();
-  const channels: [
-    (number | string)[],
-    (number | string)[],
-    (number | string)[],
-    (number | string)[]
-  ] = [[], [], [], []];
-  let i = 0;
-  let nest = 0;
-  let func = '';
-  let precededPct = false;
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (!Array.isArray(token)) {
-      throw new TypeError(`${token} is not an array.`);
-    }
-    const [type, value, , , detail] = token as [
-      TokenType,
-      string,
-      number,
-      number,
-      { value: string | number } | undefined
-    ];
-    const channel = channels[i];
-    if (Array.isArray(channel)) {
-      switch (type) {
-        case DELIM: {
-          if (func) {
-            if (
-              (value === '+' || value === '-') &&
-              precededPct &&
-              !REG_FN_CALC_SUM.test(func)
-            ) {
-              return new NullObject();
-            }
-            precededPct = false;
-            channel.push(value);
-          }
-          break;
-        }
-        case DIM: {
-          if (!func || !REG_FN_CALC_SUM.test(func)) {
-            return new NullObject();
-          }
-          const resolvedValue = resolveDimension(token, opt);
-          if (isString(resolvedValue)) {
-            channel.push(resolvedValue);
-          } else {
-            channel.push(value);
-          }
-          break;
-        }
-        case FUNC: {
-          channel.push(value);
-          func = value;
-          nest++;
-          if (REG_FN_MATH_START.test(value)) {
-            mathFunc.add(nest);
-          }
-          break;
-        }
-        case IDENT: {
-          // invalid channel key
-          if (!colorChannel.includes(value)) {
-            return new NullObject();
-          }
-          channel.push(value);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case NUM: {
-          channel.push(Number(detail?.value));
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case PAREN_OPEN: {
-          channel.push(value);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE: {
-          if (func) {
-            const lastValue = channel[channel.length - 1];
-            if (lastValue === ' ') {
-              channel.splice(-1, 1, value);
-            } else {
-              channel.push(value);
-            }
-            if (mathFunc.has(nest)) {
-              mathFunc.delete(nest);
-            }
-            nest--;
-            if (nest === 0) {
-              func = '';
-              i++;
-            }
-          }
-          break;
-        }
-        case PCT: {
-          if (!func) {
-            return new NullObject();
-          } else if (!REG_FN_CALC_SUM.test(func)) {
-            const lastValue = channel.toReversed().find(v => v !== ' ');
-            if (lastValue === '+' || lastValue === '-') {
-              return new NullObject();
-            } else if (lastValue === '*' || lastValue === '/') {
-              precededPct = false;
-            } else {
-              precededPct = true;
-            }
-          }
-          channel.push(Number(detail?.value) / MAX_PCT);
-          if (!func) {
-            i++;
-          }
-          break;
-        }
-        case W_SPACE: {
-          if (channel.length && func) {
-            const lastValue = channel[channel.length - 1];
-            if (typeof lastValue === 'number') {
-              channel.push(value);
-            } else if (
-              isString(lastValue) &&
-              !lastValue.endsWith('(') &&
-              lastValue !== ' '
-            ) {
-              channel.push(value);
-            }
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF && func) {
-            channel.push(value);
-          }
-        }
-      }
-    }
-  }
-  const channelValues = [];
-  for (const channel of channels) {
-    if (channel.length === 1) {
-      const [resolvedValue] = channel;
-      if (isStringOrNumber(resolvedValue)) {
-        channelValues.push(resolvedValue);
-      }
-    } else if (channel.length) {
-      const resolvedValue = serializeCalc(channel.join(''), {
-        format
-      });
-      channelValues.push(resolvedValue);
-    }
-  }
-  return channelValues as NumberOrStringColorChannels;
-}
-
-/**
- * extract origin color
- * @param value - CSS color value
- * @param [opt] - options
- * @returns origin color value
- */
-export function extractOriginColor(
-  value: string,
-  opt: Options = {}
-): string | NullObject {
-  const { colorScheme = 'normal', currentColor = '', format = '' } = opt;
-  if (isString(value)) {
-    value = value.toLowerCase().trim();
-    if (!value) {
-      return new NullObject();
-    }
-    if (!REG_FN_REL_START.test(value)) {
-      return value;
-    }
-  } else {
-    return new NullObject();
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'extractOriginColor',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    return cachedResult.item as string;
-  }
-  if (/currentcolor/.test(value)) {
-    if (currentColor) {
-      value = value.replace(/currentcolor/g, currentColor);
-    } else {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-  }
-  let colorSpace = '';
-  if (REG_FN_REL_CAPT.test(value)) {
-    [, colorSpace] = value.match(REG_FN_REL_CAPT) as MatchedRegExp;
-  }
-  opt.colorSpace = colorSpace;
-  if (value.includes(FN_LIGHT_DARK)) {
-    const colorParts = value
-      .replace(new RegExp(`^${colorSpace}\\(`), '')
-      .replace(/\)$/, '');
-    const [, originColor = ''] = splitValue(colorParts);
-    const specifiedOriginColor = resolveColor(originColor, {
-      colorScheme,
-      format: VAL_SPEC
-    }) as string;
-    if (specifiedOriginColor === '') {
-      setCache(cacheKey, null);
-      return new NullObject();
-    }
-    if (format === VAL_SPEC) {
-      value = value.replace(originColor, specifiedOriginColor);
-    } else {
-      const resolvedOriginColor = resolveColor(specifiedOriginColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-  }
-  if (REG_COLOR_CAPT.test(value)) {
-    const [, originColor] = value.match(REG_COLOR_CAPT) as MatchedRegExp;
-    const [, restValue] = value.split(originColor) as MatchedRegExp;
-    if (/^[a-z]+$/.test(originColor)) {
-      if (
-        !/^transparent$/.test(originColor) &&
-        !Object.hasOwn(NAMED_COLORS, originColor)
-      ) {
-        setCache(cacheKey, null);
-        return new NullObject();
-      }
-    } else if (format === VAL_SPEC) {
-      const resolvedOriginColor = resolveColor(originColor, opt);
-      if (isString(resolvedOriginColor)) {
-        value = value.replace(originColor, resolvedOriginColor);
-      }
-    }
-    if (format === VAL_SPEC) {
-      const tokens = tokenize({ css: restValue });
-      const channelValues = resolveColorChannels(tokens, opt);
-      if (channelValues instanceof NullObject) {
-        setCache(cacheKey, null);
-        return channelValues;
-      }
-      const [v1, v2, v3, v4] = channelValues;
-      let channelValue = '';
-      if (isStringOrNumber(v4)) {
-        channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-      } else {
-        channelValue = ` ${channelValues.join(' ')})`;
-      }
-      if (restValue !== channelValue) {
-        value = value.replace(restValue, channelValue);
-      }
-    }
-    // nested relative color
-  } else {
-    const [, restValue] = value.split(REG_FN_REL_START) as MatchedRegExp;
-    const tokens = tokenize({ css: restValue });
-    const originColor: string[] = [];
-    let nest = 0;
-    while (tokens.length) {
-      const [type, tokenValue] = tokens.shift() as [TokenType, string];
-      switch (type) {
-        case FUNC:
-        case PAREN_OPEN: {
-          originColor.push(tokenValue);
-          nest++;
-          break;
-        }
-        case PAREN_CLOSE: {
-          const lastValue = originColor[originColor.length - 1];
-          if (lastValue === ' ') {
-            originColor.splice(-1, 1, tokenValue);
-          } else if (isString(lastValue)) {
-            originColor.push(tokenValue);
-          }
-          nest--;
-          break;
-        }
-        case W_SPACE: {
-          const lastValue = originColor[originColor.length - 1];
-          if (
-            isString(lastValue) &&
-            !lastValue.endsWith('(') &&
-            lastValue !== ' '
-          ) {
-            originColor.push(tokenValue);
-          }
-          break;
-        }
-        default: {
-          if (type !== COMMENT && type !== EOF) {
-            originColor.push(tokenValue);
-          }
-        }
-      }
-      if (nest === 0) {
-        break;
-      }
-    }
-    const resolvedOriginColor = resolveRelativeColor(
-      originColor.join('').trim(),
-      opt
-    );
-    if (resolvedOriginColor instanceof NullObject) {
-      setCache(cacheKey, null);
-      return resolvedOriginColor;
-    }
-    const channelValues = resolveColorChannels(tokens, opt);
-    if (channelValues instanceof NullObject) {
-      setCache(cacheKey, null);
-      return channelValues;
-    }
-    const [v1, v2, v3, v4] = channelValues;
-    let channelValue = '';
-    if (isStringOrNumber(v4)) {
-      channelValue = ` ${v1} ${v2} ${v3} / ${v4})`;
-    } else {
-      channelValue = ` ${channelValues.join(' ')})`;
-    }
-    value = value.replace(restValue, `${resolvedOriginColor}${channelValue}`);
-  }
-  setCache(cacheKey, value);
-  return value;
-}
-
-/**
- * resolve relative color
- * @param value - CSS relative color value
- * @param [opt] - options
- * @returns resolved value
- */
-export function resolveRelativeColor(
-  value: string,
-  opt: Options = {}
-): string | NullObject {
-  const { format = '' } = opt;
-  if (isString(value)) {
-    if (REG_FN_VAR.test(value)) {
-      if (format === VAL_SPEC) {
-        return value;
-        // var() must be resolved before resolveRelativeColor()
-      } else {
-        throw new SyntaxError(`Unexpected token ${FN_VAR} found.`);
-      }
-    } else if (!REG_FN_REL.test(value)) {
-      return value;
-    }
-    value = value.toLowerCase().trim();
-  } else {
-    throw new TypeError(`${value} is not a string.`);
-  }
-  const cacheKey: string = createCacheKey(
-    {
-      namespace: NAMESPACE,
-      name: 'resolveRelativeColor',
-      value
-    },
-    opt
-  );
-  const cachedResult = getCache(cacheKey);
-  if (cachedResult instanceof CacheItem) {
-    if (cachedResult.isNull) {
-      return cachedResult as NullObject;
-    }
-    return cachedResult.item as string;
-  }
-  const originColor = extractOriginColor(value, opt);
-  if (originColor instanceof NullObject) {
-    setCache(cacheKey, null);
-    return originColor;
-  }
-  value = originColor;
-  if (format === VAL_SPEC) {
-    if (value.startsWith('rgba(')) {
-      value = value.replace(/^rgba\(/, 'rgb(');
-    } else if (value.startsWith('hsla(')) {
-      value = value.replace(/^hsla\(/, 'hsl(');
-    }
-    return value;
-  }
-  const tokens = tokenize({ css: value });
-  const components = parseComponentValue(tokens) as ComponentValue;
-  const parsedComponents = colorParser(components);
-  if (!parsedComponents) {
-    setCache(cacheKey, null);
-    return new NullObject();
-  }
-  const {
-    alpha: alphaComponent,
-    channels: channelsComponent,
-    colorNotation,
-    syntaxFlags
-  } = parsedComponents;
-  let alpha: number | string;
-  if (Number.isNaN(Number(alphaComponent))) {
-    if (syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE)) {
-      alpha = NONE;
-    } else {
-      alpha = 0;
-    }
-  } else {
-    alpha = roundToPrecision(Number(alphaComponent), OCT);
-  }
-  let v1: number | string;
-  let v2: number | string;
-  let v3: number | string;
-  [v1, v2, v3] = channelsComponent;
-  let resolvedValue;
-  if (REG_CS_CIE.test(colorNotation)) {
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, HEX);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, HEX);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, HEX);
-    }
-    if (alpha === 1) {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  } else if (REG_CS_HSL.test(colorNotation)) {
-    if (Number.isNaN(v1)) {
-      v1 = 0;
-    }
-    if (Number.isNaN(v2)) {
-      v2 = 0;
-    }
-    if (Number.isNaN(v3)) {
-      v3 = 0;
-    }
-    let [r, g, b] = convertColorToRgb(
-      `${colorNotation}(${v1} ${v2} ${v3} / ${alpha})`
-    ) as ColorChannels;
-    r = roundToPrecision(r / MAX_RGB, DEC);
-    g = roundToPrecision(g / MAX_RGB, DEC);
-    b = roundToPrecision(b / MAX_RGB, DEC);
-    if (alpha === 1) {
-      resolvedValue = `color(srgb ${r} ${g} ${b})`;
-    } else {
-      resolvedValue = `color(srgb ${r} ${g} ${b} / ${alpha})`;
-    }
-  } else {
-    const cs = colorNotation === 'rgb' ? 'srgb' : colorNotation;
-    const hasNone = syntaxFlags instanceof Set && syntaxFlags.has(KEY_NONE);
-    if (Number.isNaN(v1)) {
-      if (hasNone) {
-        v1 = NONE;
-      } else {
-        v1 = 0;
-      }
-    } else {
-      v1 = roundToPrecision(v1, DEC);
-    }
-    if (Number.isNaN(v2)) {
-      if (hasNone) {
-        v2 = NONE;
-      } else {
-        v2 = 0;
-      }
-    } else {
-      v2 = roundToPrecision(v2, DEC);
-    }
-    if (Number.isNaN(v3)) {
-      if (hasNone) {
-        v3 = NONE;
-      } else {
-        v3 = 0;
-      }
-    } else {
-      v3 = roundToPrecision(v3, DEC);
-    }
-    if (alpha === 1) {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3})`;
-    } else {
-      resolvedValue = `color(${cs} ${v1} ${v2} ${v3} / ${alpha})`;
-    }
-  }
-  setCache(cacheKey, resolvedValue);
-  return resolvedValue;
-}