Initial commit: Crypto trader application

frontend/node_modules/@asamuzakjp/css-color/LICENSE

@@ -0,0 +1,21 @@
+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.

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

@@ -0,0 +1,316 @@
+# 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

frontend/node_modules/@asamuzakjp/css-color/node_modules/lru-cache/LICENSE.md

@@ -0,0 +1,55 @@
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules.  The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+<https://blueoakcouncil.org/license/1.0.0>.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice.  If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+***As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim.***

frontend/node_modules/@asamuzakjp/css-color/node_modules/lru-cache/README.md

@@ -0,0 +1,334 @@
+# lru-cache
+
+A cache object that deletes the least-recently-used items.
+
+Specify a max number of the most recently used items that you
+want to keep, and this cache will keep that many of the most
+recently accessed items.
+
+This is not primarily a TTL cache, and does not make strong TTL
+guarantees. There is no preemptive pruning of expired items by
+default, but you _may_ set a TTL on the cache or on a single
+`set`. If you do so, it will treat expired items as missing, and
+delete them when fetched. If you are more interested in TTL
+caching than LRU caching, check out
+[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).
+
+As of version 7, this is one of the most performant LRU
+implementations available in JavaScript, and supports a wide
+diversity of use cases. However, note that using some of the
+features will necessarily impact performance, by causing the
+cache to have to do more work. See the "Performance" section
+below.
+
+## Installation
+
+```bash
+npm install lru-cache --save
+```
+
+## Usage
+
+```js
+// hybrid module, either works
+import { LRUCache } from 'lru-cache'
+// or:
+const { LRUCache } = require('lru-cache')
+// or in minified form for web browsers:
+import { LRUCache } from 'http://unpkg.com/lru-cache@9/dist/mjs/index.min.mjs'
+
+// At least one of 'max', 'ttl', or 'maxSize' is required, to prevent
+// unsafe unbounded storage.
+//
+// In most cases, it's best to specify a max for performance, so all
+// the required memory allocation is done up-front.
+//
+// All the other options are optional, see the sections below for
+// documentation on what each one does.  Most of them can be
+// overridden for specific items in get()/set()
+const options = {
+  max: 500,
+
+  // for use with tracking overall storage size
+  maxSize: 5000,
+  sizeCalculation: (value, key) => {
+    return 1
+  },
+
+  // for use when you need to clean up something when objects
+  // are evicted from the cache
+  dispose: (value, key, reason) => {
+    freeFromMemoryOrWhatever(value)
+  },
+
+  // for use when you need to know that an item is being inserted
+  // note that this does NOT allow you to prevent the insertion,
+  // it just allows you to know about it.
+  onInsert: (value, key, reason) => {
+    logInsertionOrWhatever(key, value)
+  },
+
+  // how long to live in ms
+  ttl: 1000 * 60 * 5,
+
+  // return stale items before removing from cache?
+  allowStale: false,
+
+  updateAgeOnGet: false,
+  updateAgeOnHas: false,
+
+  // async method to use for cache.fetch(), for
+  // stale-while-revalidate type of behavior
+  fetchMethod: async (key, staleValue, { options, signal, context }) => {},
+}
+
+const cache = new LRUCache(options)
+
+cache.set('key', 'value')
+cache.get('key') // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.clear() // empty the cache
+```
+
+If you put more stuff in the cache, then less recently used items
+will fall out. That's what an LRU cache is.
+
+For full description of the API and all options, please see [the
+LRUCache typedocs](https://isaacs.github.io/node-lru-cache/)
+
+## Storage Bounds Safety
+
+This implementation aims to be as flexible as possible, within
+the limits of safe memory consumption and optimal performance.
+
+At initial object creation, storage is allocated for `max` items.
+If `max` is set to zero, then some performance is lost, and item
+count is unbounded. Either `maxSize` or `ttl` _must_ be set if
+`max` is not specified.
+
+If `maxSize` is set, then this creates a safe limit on the
+maximum storage consumed, but without the performance benefits of
+pre-allocation. When `maxSize` is set, every item _must_ provide
+a size, either via the `sizeCalculation` method provided to the
+constructor, or via a `size` or `sizeCalculation` option provided
+to `cache.set()`. The size of every item _must_ be a positive
+integer.
+
+If neither `max` nor `maxSize` are set, then `ttl` tracking must
+be enabled. Note that, even when tracking item `ttl`, items are
+_not_ preemptively deleted when they become stale, unless
+`ttlAutopurge` is enabled. Instead, they are only purged the
+next time the key is requested. Thus, if `ttlAutopurge`, `max`,
+and `maxSize` are all not set, then the cache will potentially
+grow unbounded.
+
+In this case, a warning is printed to standard error. Future
+versions may require the use of `ttlAutopurge` if `max` and
+`maxSize` are not specified.
+
+If you truly wish to use a cache that is bound _only_ by TTL
+expiration, consider using a `Map` object, and calling
+`setTimeout` to delete entries when they expire. It will perform
+much better than an LRU cache.
+
+Here is an implementation you may use, under the same
+[license](./LICENSE) as this package:
+
+```js
+// a storage-unbounded ttl cache that is not an lru-cache
+const cache = {
+  data: new Map(),
+  timers: new Map(),
+  set: (k, v, ttl) => {
+    if (cache.timers.has(k)) {
+      clearTimeout(cache.timers.get(k))
+    }
+    cache.timers.set(
+      k,
+      setTimeout(() => cache.delete(k), ttl),
+    )
+    cache.data.set(k, v)
+  },
+  get: k => cache.data.get(k),
+  has: k => cache.data.has(k),
+  delete: k => {
+    if (cache.timers.has(k)) {
+      clearTimeout(cache.timers.get(k))
+    }
+    cache.timers.delete(k)
+    return cache.data.delete(k)
+  },
+  clear: () => {
+    cache.data.clear()
+    for (const v of cache.timers.values()) {
+      clearTimeout(v)
+    }
+    cache.timers.clear()
+  },
+}
+```
+
+If that isn't to your liking, check out
+[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).
+
+## Storing Undefined Values
+
+This cache never stores undefined values, as `undefined` is used
+internally in a few places to indicate that a key is not in the
+cache.
+
+You may call `cache.set(key, undefined)`, but this is just
+an alias for `cache.delete(key)`. Note that this has the effect
+that `cache.has(key)` will return _false_ after setting it to
+undefined.
+
+```js
+cache.set(myKey, undefined)
+cache.has(myKey) // false!
+```
+
+If you need to track `undefined` values, and still note that the
+key is in the cache, an easy workaround is to use a sigil object
+of your own.
+
+```js
+import { LRUCache } from 'lru-cache'
+const undefinedValue = Symbol('undefined')
+const cache = new LRUCache(...)
+const mySet = (key, value) =>
+  cache.set(key, value === undefined ? undefinedValue : value)
+const myGet = (key, value) => {
+  const v = cache.get(key)
+  return v === undefinedValue ? undefined : v
+}
+```
+
+## Performance
+
+As of January 2022, version 7 of this library is one of the most
+performant LRU cache implementations in JavaScript.
+
+Benchmarks can be extremely difficult to get right. In
+particular, the performance of set/get/delete operations on
+objects will vary _wildly_ depending on the type of key used. V8
+is highly optimized for objects with keys that are short strings,
+especially integer numeric strings. Thus any benchmark which
+tests _solely_ using numbers as keys will tend to find that an
+object-based approach performs the best.
+
+Note that coercing _anything_ to strings to use as object keys is
+unsafe, unless you can be 100% certain that no other type of
+value will be used. For example:
+
+```js
+const myCache = {}
+const set = (k, v) => (myCache[k] = v)
+const get = k => myCache[k]
+
+set({}, 'please hang onto this for me')
+set('[object Object]', 'oopsie')
+```
+
+Also beware of "Just So" stories regarding performance. Garbage
+collection of large (especially: deep) object graphs can be
+incredibly costly, with several "tipping points" where it
+increases exponentially. As a result, putting that off until
+later can make it much worse, and less predictable. If a library
+performs well, but only in a scenario where the object graph is
+kept shallow, then that won't help you if you are using large
+objects as keys.
+
+In general, when attempting to use a library to improve
+performance (such as a cache like this one), it's best to choose
+an option that will perform well in the sorts of scenarios where
+you'll actually use it.
+
+This library is optimized for repeated gets and minimizing
+eviction time, since that is the expected need of a LRU. Set
+operations are somewhat slower on average than a few other
+options, in part because of that optimization. It is assumed
+that you'll be caching some costly operation, ideally as rarely
+as possible, so optimizing set over get would be unwise.
+
+If performance matters to you:
+
+1. If it's at all possible to use small integer values as keys,
+   and you can guarantee that no other types of values will be
+   used as keys, then do that, and use a cache such as
+   [lru-fast](https://npmjs.com/package/lru-fast), or
+   [mnemonist's
+   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache)
+   which uses an Object as its data store.
+
+2. Failing that, if at all possible, use short non-numeric
+   strings (ie, less than 256 characters) as your keys, and use
+   [mnemonist's
+   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache).
+
+3. If the types of your keys will be anything else, especially
+   long strings, strings that look like floats, objects, or some
+   mix of types, or if you aren't sure, then this library will
+   work well for you.
+
+   If you do not need the features that this library provides
+   (like asynchronous fetching, a variety of TTL staleness
+   options, and so on), then [mnemonist's
+   LRUMap](https://yomguithereal.github.io/mnemonist/lru-map) is
+   a very good option, and just slightly faster than this module
+   (since it does considerably less).
+
+4. Do not use a `dispose` function, size tracking, or especially
+   ttl behavior, unless absolutely needed. These features are
+   convenient, and necessary in some use cases, and every attempt
+   has been made to make the performance impact minimal, but it
+   isn't nothing.
+
+## Breaking Changes in Version 7
+
+This library changed to a different algorithm and internal data
+structure in version 7, yielding significantly better
+performance, albeit with some subtle changes as a result.
+
+If you were relying on the internals of LRUCache in version 6 or
+before, it probably will not work in version 7 and above.
+
+## Breaking Changes in Version 8
+
+- The `fetchContext` option was renamed to `context`, and may no
+  longer be set on the cache instance itself.
+- Rewritten in TypeScript, so pretty much all the types moved
+  around a lot.
+- The AbortController/AbortSignal polyfill was removed. For this
+  reason, **Node version 16.14.0 or higher is now required**.
+- Internal properties were moved to actual private class
+  properties.
+- Keys and values must not be `null` or `undefined`.
+- Minified export available at `'lru-cache/min'`, for both CJS
+  and MJS builds.
+
+## Breaking Changes in Version 9
+
+- Named export only, no default export.
+- AbortController polyfill returned, albeit with a warning when
+  used.
+
+## Breaking Changes in Version 10
+
+- `cache.fetch()` return type is now `Promise<V | undefined>`
+  instead of `Promise<V | void>`. This is an irrelevant change
+  practically speaking, but can require changes for TypeScript
+  users.
+
+For more info, see the [change log](CHANGELOG.md).

frontend/node_modules/@asamuzakjp/css-color/node_modules/lru-cache/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "lru-cache",
+  "description": "A cache object that deletes the least-recently-used items.",
+  "version": "11.2.4",
+  "author": "Isaac Z. Schlueter <i@izs.me>",
+  "keywords": [
+    "mru",
+    "lru",
+    "cache"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "npm run prepare",
+    "prepare": "tshy && bash fixup.sh",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "format": "prettier --write .",
+    "typedoc": "typedoc --tsconfig ./.tshy/esm.json ./src/*.ts",
+    "benchmark-results-typedoc": "bash scripts/benchmark-results-typedoc.sh",
+    "prebenchmark": "npm run prepare",
+    "benchmark": "make -C benchmark",
+    "preprofile": "npm run prepare",
+    "profile": "make -C benchmark profile"
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./min": {
+        "import": {
+          "types": "./dist/esm/index.d.ts",
+          "default": "./dist/esm/index.min.js"
+        },
+        "require": {
+          "types": "./dist/commonjs/index.d.ts",
+          "default": "./dist/commonjs/index.min.js"
+        }
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-lru-cache.git"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "benchmark": "^2.1.4",
+    "esbuild": "^0.25.9",
+    "marked": "^4.2.12",
+    "mkdirp": "^3.0.1",
+    "prettier": "^3.6.2",
+    "tap": "^21.1.0",
+    "tshy": "^3.0.2",
+    "typedoc": "^0.28.12"
+  },
+  "license": "BlueOak-1.0.0",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "20 || >=22"
+  },
+  "tap": {
+    "node-arg": [
+      "--expose-gc"
+    ],
+    "plugin": [
+      "@tapjs/clock"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./min": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.min.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.min.js"
+      }
+    }
+  },
+  "type": "module",
+  "module": "./dist/esm/index.js"
+}

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

@@ -0,0 +1,82 @@
+{
+  "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": "^2.1.4",
+    "@csstools/css-color-parser": "^3.1.0",
+    "@csstools/css-parser-algorithms": "^3.0.5",
+    "@csstools/css-tokenizer": "^3.0.4",
+    "lru-cache": "^11.2.4"
+  },
+  "devDependencies": {
+    "@tanstack/vite-config": "^0.4.3",
+    "@vitest/coverage-istanbul": "^4.0.15",
+    "esbuild": "^0.27.1",
+    "eslint": "^9.39.2",
+    "eslint-plugin-regexp": "^2.10.0",
+    "globals": "^16.5.0",
+    "knip": "^5.74.0",
+    "neostandard": "^0.12.2",
+    "prettier": "^3.7.4",
+    "publint": "^0.3.16",
+    "rimraf": "^6.1.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.0",
+    "vitest": "^4.0.15"
+  },
+  "packageManager": "pnpm@10.25.0",
+  "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.1"
+}

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

@@ -0,0 +1,30 @@
+/*!
+ * 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
+};

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

@@ -0,0 +1,114 @@
+/**
+ * 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;
+};

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

@@ -0,0 +1,31 @@
+/**
+ * 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';

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

@@ -0,0 +1,68 @@
+/**
+ * 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';

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

@@ -0,0 +1,469 @@
+/**
+ * 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
+};

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

@@ -0,0 +1,955 @@
+/**
+ * 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;
+};

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

@@ -0,0 +1,384 @@
+/**
+ * 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;
+};

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

@@ -0,0 +1,250 @@
+/**
+ * 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 '';
+};

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

@@ -0,0 +1,635 @@
+/**
+ * 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;
+}

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

@@ -0,0 +1,443 @@
+/**
+ * resolve
+ */
+
+import {
+  CacheItem,
+  NullObject,
+  createCacheKey,
+  getCache,
+  setCache
+} from './cache';
+import {
+  convertRgbToHex,
+  resolveColorFunc,
+  resolveColorMix,
+  resolveColorValue
+} from './color';
+import { isString } from './common';
+import { cssCalc } from './css-calc';
+import { resolveVar } from './css-var';
+import { resolveRelativeColor } from './relative-color';
+import { splitValue } from './util';
+import {
+  ComputedColorChannels,
+  Options,
+  SpecifiedColorChannels
+} from './typedef';
+
+/* constants */
+import {
+  FN_COLOR,
+  FN_MIX,
+  SYN_FN_CALC,
+  SYN_FN_LIGHT_DARK,
+  SYN_FN_REL,
+  SYN_FN_VAR,
+  VAL_COMP,
+  VAL_SPEC
+} from './constant';
+const NAMESPACE = 'resolve';
+const RGB_TRANSPARENT = 'rgba(0, 0, 0, 0)';
+
+/* regexp */
+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);
+
+/**
+ * resolve color
+ * @param value - CSS color value
+ * @param [opt] - options
+ * @returns resolved color
+ */
+export const resolveColor = (
+  value: string,
+  opt: Options = {}
+): string | NullObject => {
+  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: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'resolve',
+      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)) {
+    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 res = RGB_TRANSPARENT;
+          setCache(cacheKey, res);
+          return res;
+        }
+      }
+    } 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 res;
+        if (lightColor && darkColor) {
+          res = `light-dark(${lightColor}, ${darkColor})`;
+        } else {
+          res = '';
+        }
+        setCache(cacheKey, res);
+        return res;
+      }
+      let resolvedValue;
+      if (colorScheme === 'dark') {
+        resolvedValue = resolveColor(dark, opt);
+      } else {
+        resolvedValue = resolveColor(light, opt);
+      }
+      let res;
+      if (resolvedValue instanceof NullObject) {
+        if (nullable) {
+          res = resolvedValue;
+        } else {
+          res = RGB_TRANSPARENT;
+        }
+      } else {
+        res = resolvedValue;
+      }
+      setCache(cacheKey, res);
+      return res;
+    }
+    // invalid value
+    switch (format) {
+      case VAL_SPEC: {
+        setCache(cacheKey, '');
+        return '';
+      }
+      case 'hex':
+      case 'hexAlpha': {
+        setCache(cacheKey, null);
+        return new NullObject();
+      }
+      case VAL_COMP:
+      default: {
+        const res = RGB_TRANSPARENT;
+        setCache(cacheKey, res);
+        return res;
+      }
+    }
+  }
+  if (REG_FN_REL.test(value)) {
+    const resolvedValue = resolveRelativeColor(value, opt);
+    if (format === VAL_COMP) {
+      let res;
+      if (resolvedValue instanceof NullObject) {
+        if (nullable) {
+          res = resolvedValue;
+        } else {
+          res = RGB_TRANSPARENT;
+        }
+      } else {
+        res = resolvedValue;
+      }
+      setCache(cacheKey, res);
+      return res;
+    }
+    if (format === VAL_SPEC) {
+      let res = '';
+      if (resolvedValue instanceof NullObject) {
+        res = '';
+      } else {
+        res = resolvedValue;
+      }
+      setCache(cacheKey, res);
+      return res;
+    }
+    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 res = '#00000000';
+        setCache(cacheKey, res);
+        return res;
+      }
+      case VAL_COMP:
+      default: {
+        const res = RGB_TRANSPARENT;
+        setCache(cacheKey, res);
+        return res;
+      }
+    }
+  } 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 as ComputedColorChannels;
+    } else if (format === VAL_COMP) {
+      const res = RGB_TRANSPARENT;
+      setCache(cacheKey, res);
+      return res;
+    }
+  } else if (format === VAL_SPEC) {
+    if (value.startsWith(FN_MIX)) {
+      const res = resolveColorMix(value, opt) as string;
+      setCache(cacheKey, res);
+      return res;
+    } else if (value.startsWith(FN_COLOR)) {
+      const [scs, rr, gg, bb, aa] = resolveColorFunc(
+        value,
+        opt
+      ) as SpecifiedColorChannels;
+      let res = '';
+      if (aa === 1) {
+        res = `color(${scs} ${rr} ${gg} ${bb})`;
+      } else {
+        res = `color(${scs} ${rr} ${gg} ${bb} / ${aa})`;
+      }
+      setCache(cacheKey, res);
+      return res;
+    } else {
+      const rgb = resolveColorValue(value, opt);
+      if (isString(rgb)) {
+        setCache(cacheKey, rgb);
+        return rgb;
+      }
+      const [scs, rr, gg, bb, aa] = rgb as SpecifiedColorChannels;
+      let res = '';
+      if (scs === 'rgb') {
+        if (aa === 1) {
+          res = `${scs}(${rr}, ${gg}, ${bb})`;
+        } else {
+          res = `${scs}a(${rr}, ${gg}, ${bb}, ${aa})`;
+        }
+      } else if (aa === 1) {
+        res = `${scs}(${rr} ${gg} ${bb})`;
+      } else {
+        res = `${scs}(${rr} ${gg} ${bb} / ${aa})`;
+      }
+      setCache(cacheKey, res);
+      return res;
+    }
+  } 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 as ComputedColorChannels;
+  } 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 as ComputedColorChannels;
+  } else if (value) {
+    const resolvedValue = resolveColorValue(value, opt);
+    if (resolvedValue instanceof NullObject) {
+      setCache(cacheKey, resolvedValue);
+      return resolvedValue;
+    }
+    [cs, r, g, b, alpha] = resolvedValue as ComputedColorChannels;
+  }
+  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;
+};
+
+/**
+ * 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 const resolve = (value: string, opt: Options = {}): string | null => {
+  opt.nullable = false;
+  const resolvedValue = resolveColor(value, opt);
+  if (resolvedValue instanceof NullObject) {
+    return null;
+  }
+  return resolvedValue as string;
+};

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

@@ -0,0 +1,88 @@
+/**
+ * typedef
+ */
+
+/* type definitions */
+/**
+ * @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
+];

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

@@ -0,0 +1,443 @@
+/**
+ * util
+ */
+
+import { TokenType, tokenize } from '@csstools/css-tokenizer';
+import { CacheItem, createCacheKey, getCache, setCache } from './cache';
+import { isString } from './common';
+import { resolveColor } from './resolve';
+import { Options } from './typedef';
+
+/* constants */
+import { NAMED_COLORS } from './color';
+import { SYN_COLOR_TYPE, SYN_MIX, VAL_SPEC } from './constant';
+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';
+
+/* numeric constants */
+const DEC = 10;
+const HEX = 16;
+const DEG = 360;
+const DEG_HALF = 180;
+
+/* regexp */
+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);
+
+/**
+ * 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 const splitValue = (value: string, opt: Options = {}): string[] => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const { delimiter = ' ', preserveComment = false } = opt;
+  const cacheKey: string = createCacheKey(
+    {
+      namespace: NAMESPACE,
+      name: 'splitValue',
+      value
+    },
+    {
+      delimiter,
+      preserveComment
+    }
+  );
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string[];
+  }
+  let regDelimiter;
+  if (delimiter === ',') {
+    regDelimiter = /^,$/;
+  } else if (delimiter === '/') {
+    regDelimiter = /^\/$/;
+  } else {
+    regDelimiter = /^\s+$/;
+  }
+  const tokens = tokenize({ css: value });
+  let nest = 0;
+  let str = '';
+  const res: string[] = [];
+  while (tokens.length) {
+    const [type, value] = tokens.shift() as [TokenType, string];
+    switch (type) {
+      case COMMA: {
+        if (regDelimiter.test(value)) {
+          if (nest === 0) {
+            res.push(str.trim());
+            str = '';
+          } else {
+            str += value;
+          }
+        } else {
+          str += value;
+        }
+        break;
+      }
+      case DELIM: {
+        if (regDelimiter.test(value)) {
+          if (nest === 0) {
+            res.push(str.trim());
+            str = '';
+          } else {
+            str += value;
+          }
+        } else {
+          str += value;
+        }
+        break;
+      }
+      case COMMENT: {
+        if (preserveComment && (delimiter === ',' || delimiter === '/')) {
+          str += value;
+        }
+        break;
+      }
+      case FUNC:
+      case PAREN_OPEN: {
+        str += value;
+        nest++;
+        break;
+      }
+      case PAREN_CLOSE: {
+        str += value;
+        nest--;
+        break;
+      }
+      case W_SPACE: {
+        if (regDelimiter.test(value)) {
+          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 += value;
+        }
+      }
+    }
+  }
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * extract dashed-ident tokens
+ * @param value - CSS value
+ * @returns array of dashed-ident tokens
+ */
+export const extractDashedIdent = (value: string): string[] => {
+  if (isString(value)) {
+    value = value.trim();
+  } else {
+    throw new TypeError(`${value} is not a string.`);
+  }
+  const cacheKey: string = createCacheKey({
+    namespace: NAMESPACE,
+    name: 'extractDashedIdent',
+    value
+  });
+  const cachedResult = getCache(cacheKey);
+  if (cachedResult instanceof CacheItem) {
+    return cachedResult.item as string[];
+  }
+  const tokens = tokenize({ css: value });
+  const items = new Set();
+  while (tokens.length) {
+    const [type, value] = tokens.shift() as [TokenType, string];
+    if (type === IDENT && value.startsWith('--')) {
+      items.add(value);
+    }
+  }
+  const res = [...items] as string[];
+  setCache(cacheKey, res);
+  return res;
+};
+
+/**
+ * is color
+ * @param value - CSS value
+ * @param [opt] - options
+ * @returns result
+ */
+export const isColor = (value: unknown, opt: Options = {}): boolean => {
+  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;
+};
+
+/**
+ * value to JSON string
+ * @param value - CSS value
+ * @param [func] - stringify function
+ * @returns stringified value in JSON notation
+ */
+export const valueToJsonString = (
+  value: unknown,
+  func: boolean = false
+): string => {
+  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;
+};
+
+/**
+ * round to specified precision
+ * @param value - numeric value
+ * @param bit - minimum bits
+ * @returns rounded value
+ */
+export const roundToPrecision = (value: number, bit: number = 0): number => {
+  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);
+};
+
+/**
+ * interpolate hue
+ * @param hueA - hue value
+ * @param hueB - hue value
+ * @param arc - shorter | longer | increasing | decreasing
+ * @returns result - [hueA, hueB]
+ */
+export const interpolateHue = (
+  hueA: number,
+  hueB: number,
+  arc: string = 'shorter'
+): [number, number] => {
+  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];
+};
+
+/* absolute font size to pixel ratio */
+const absoluteFontSize = 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]
+]);
+
+/* relative font size to pixel ratio */
+const relativeFontSize = new Map([
+  ['smaller', 1 / 1.2],
+  ['larger', 1.2]
+]);
+
+/* absolute length to pixel ratio */
+const absoluteLength = 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]
+]);
+
+/* relative length to pixel ratio */
+const relativeLength = new Map([
+  ['rcap', 1],
+  ['rch', 0.5],
+  ['rem', 1],
+  ['rex', 0.5],
+  ['ric', 1],
+  ['rlh', 1.2]
+]);
+
+/**
+ * resolve length in pixels
+ * @param value - value
+ * @param unit - unit
+ * @param [opt] - options
+ * @returns pixelated value
+ */
+export const resolveLengthInPixels = (
+  value: number | string,
+  unit: string | undefined,
+  opt: Options = {}
+): number => {
+  const { dimension = {} } = opt;
+  const { callback, em, rem, vh, vw } = dimension as {
+    callback: (K: string) => number;
+    em: number;
+    rem: number;
+    vh: number;
+    vw: number;
+  };
+  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: {
+          // unsupported or invalid unit
+          return Number.NaN;
+        }
+      }
+    }
+  }
+  // unsupported or invalid value
+  return Number.NaN;
+};

frontend/node_modules/@asamuzakjp/dom-selector/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 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.

frontend/node_modules/@asamuzakjp/dom-selector/README.md

@@ -0,0 +1,324 @@
+# DOM Selector
+
+[![build](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/node.js.yml)
+[![CodeQL](https://github.com/asamuzaK/domSelector/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/asamuzaK/domSelector/actions/workflows/github-code-scanning/codeql)
+[![npm (scoped)](https://img.shields.io/npm/v/@asamuzakjp/dom-selector)](https://www.npmjs.com/package/@asamuzakjp/dom-selector)
+
+A CSS selector engine.
+
+## Install
+
+```console
+npm i @asamuzakjp/dom-selector
+```
+
+## Usage
+
+```javascript
+import { DOMSelector } from '@asamuzakjp/dom-selector';
+import { JSDOM } from 'jsdom';
+
+const { window } = new JSDOM();
+const {
+  closest, matches, querySelector, querySelectorAll
+} = new DOMSelector(window);
+```
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+### matches(selector, node, opt)
+
+matches - equivalent to [Element.matches()][64]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[boolean][61]** `true` if matched, `false` otherwise
+
+
+### closest(selector, node, opt)
+
+closest - equivalent to [Element.closest()][65]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[object][60]?** matched node
+
+
+### querySelector(selector, node, opt)
+
+querySelector - equivalent to [Document.querySelector()][66], [DocumentFragment.querySelector()][67] and [Element.querySelector()][68]
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Document, DocumentFragment or Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[object][60]?** matched node
+
+
+### querySelectorAll(selector, node, opt)
+
+querySelectorAll - equivalent to [Document.querySelectorAll()][69], [DocumentFragment.querySelectorAll()][70] and [Element.querySelectorAll()][71]  
+**NOTE**: returns Array, not NodeList
+
+#### Parameters
+
+- `selector` **[string][59]** CSS selector
+- `node` **[object][60]** Document, DocumentFragment or Element node
+- `opt` **[object][60]?** options
+  - `opt.noexcept` **[boolean][61]?** no exception
+  - `opt.warn` **[boolean][61]?** console warn e.g. unsupported pseudo-class
+
+Returns **[Array][62]&lt;([object][60] \| [undefined][63])>** array of matched nodes
+
+
+## Monkey patch jsdom
+
+``` javascript
+import { DOMSelector } from '@asamuzakjp/dom-selector';
+import { JSDOM } from 'jsdom';
+
+const dom = new JSDOM('', {
+  runScripts: 'dangerously',
+  url: 'http://localhost/',
+  beforeParse: window => {
+    const domSelector = new DOMSelector(window);
+
+    const matches = domSelector.matches.bind(domSelector);
+    window.Element.prototype.matches = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return matches(selector, this);
+    };
+
+    const closest = domSelector.closest.bind(domSelector);
+    window.Element.prototype.closest = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return closest(selector, this);
+    };
+
+    const querySelector = domSelector.querySelector.bind(domSelector);
+    window.Document.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+    window.DocumentFragment.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+    window.Element.prototype.querySelector = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelector(selector, this);
+    };
+
+    const querySelectorAll = domSelector.querySelectorAll.bind(domSelector);
+    window.Document.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+    window.DocumentFragment.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+    window.Element.prototype.querySelectorAll = function (...args) {
+      if (!args.length) {
+        throw new window.TypeError('1 argument required, but only 0 present.');
+      }
+      const [selector] = args;
+      return querySelectorAll(selector, this);
+    };
+  }
+});
+```
+
+
+## Supported CSS selectors
+
+|Pattern|Supported|Note|
+|:--------|:-------:|:--------|
+|\*|✓| |
+|E|✓| |
+|ns\|E|✓| |
+|\*\|E|✓| |
+|\|E|✓| |
+|E&nbsp;F|✓| |
+|E > F|✓| |
+|E + F|✓| |
+|E ~ F|✓| |
+|F \|\| E|Unsupported| |
+|E.warning|✓| |
+|E#myid|✓| |
+|E\[foo\]|✓| |
+|E\[foo="bar"\]|✓| |
+|E\[foo="bar"&nbsp;i\]|✓| |
+|E\[foo="bar"&nbsp;s\]|✓| |
+|E\[foo~="bar"\]|✓| |
+|E\[foo^="bar"\]|✓| |
+|E\[foo$="bar"\]|✓| |
+|E\[foo*="bar"\]|✓| |
+|E\[foo\|="en"\]|✓| |
+|E:is(s1, s2, …)|✓| |
+|E:not(s1, s2, …)|✓| |
+|E:where(s1, s2, …)|✓| |
+|E:has(rs1, rs2, …)|✓| |
+|E:defined|Partially supported|Matching with MathML is not yet supported.|
+|E:dir(ltr)|✓| |
+|E:lang(en)|✓| |
+|E:any&#8209;link|✓| |
+|E:link|✓| |
+|E:visited|✓|Returns `false` or `null` to prevent fingerprinting.|
+|E:local&#8209;link|✓| |
+|E:target|✓| |
+|E:target&#8209;within|✓| |
+|E:scope|✓| |
+|E:hover|✓| |
+|E:active|✓| |
+|E:focus|✓| |
+|E:focus&#8209;visible|✓| |
+|E:focus&#8209;within|✓| |
+|E:current|Unsupported| |
+|E:current(s)|Unsupported| |
+|E:past|Unsupported| |
+|E:future|Unsupported| |
+|E:open<br>E:closed|Partially supported|Matching with &lt;select&gt;, e.g. `select:open`, is not supported.|
+|E:popover-open|✓| |
+|E:enabled<br>E:disabled|✓| |
+|E:read&#8209;write<br>E:read&#8209;only|✓| |
+|E:placeholder&#8209;shown|✓| |
+|E:default|✓| |
+|E:checked|✓| |
+|E:indeterminate|✓| |
+|E:blank|Unsupported| |
+|E:valid<br>E:invalid|✓| |
+|E:in-range<br>E:out-of-range|✓| |
+|E:required<br>E:optional|✓| |
+|E:user&#8209;valid<br>E:user&#8209;invalid|Unsupported| |
+|E:root|✓| |
+|E:empty|✓| |
+|E:nth&#8209;child(n&nbsp;[of&nbsp;S]?)|✓| |
+|E:nth&#8209;last&#8209;child(n&nbsp;[of&nbsp;S]?)|✓| |
+|E:first&#8209;child|✓| |
+|E:last&#8209;child|✓| |
+|E:only&#8209;child|✓| |
+|E:nth&#8209;of&#8209;type(n)|✓| |
+|E:nth&#8209;last&#8209;of&#8209;type(n)|✓| |
+|E:first&#8209;of&#8209;type|✓| |
+|E:last&#8209;of&#8209;type|✓| |
+|E:only&#8209;of&#8209;type|✓| |
+|E:nth&#8209;col(n)|Unsupported| |
+|E:nth&#8209;last&#8209;col(n)|Unsupported| |
+|CE:state(v)|✓|*1|
+|:host|✓| |
+|:host(s)|✓| |
+|:host(:state(v))|✓|*1|
+|:host:has(rs1, rs2, ...)|✓| |
+|:host(s):has(rs1, rs2, ...)|✓| |
+|:host&#8209;context(s)|✓| |
+|:host&#8209;context(s):has(rs1, rs2, ...)|✓| |
+|&amp;|✓|Only supports outermost `&`, i.e. equivalent to `:scope`|
+
+*1: `ElementInternals.states`, i.e. `CustomStateSet`, is not implemented in jsdom, so you need to apply a patch in the custom element constructor.
+
+``` javascript
+class LabeledCheckbox extends window.HTMLElement {
+  #internals;
+  constructor() {
+    super();
+    this.#internals = this.attachInternals();
+    // patch CustomStateSet
+    if (!this.#internals.states) {
+      this.#internals.states = new Set();
+    }
+    this.addEventListener('click', this._onClick.bind(this));
+  }
+  get checked() {
+    return this.#internals.states.has('checked');
+  }
+  set checked(flag) {
+    if (flag) {
+      this.#internals.states.add('checked');
+    } else {
+      this.#internals.states.delete('checked');
+    }
+  }
+  _onClick(event) {
+    this.checked = !this.checked;
+  }
+}
+```
+
+
+## Performance
+
+See [benchmark](https://github.com/asamuzaK/domSelector/actions/workflows/benchmark.yml) for the latest results.
+
+
+## Acknowledgments
+
+The following resources have been of great help in the development of the DOM Selector.
+
+- [CSSTree](https://github.com/csstree/csstree)
+- [selery](https://github.com/danburzo/selery)
+- [jsdom](https://github.com/jsdom/jsdom)
+- [nwsapi](https://github.com/dperini/nwsapi)
+
+---
+Copyright (c) 2023 [asamuzaK (Kazz)](https://github.com/asamuzaK/)
+
+
+[1]: #matches
+[2]: #parameters
+[3]: #closest
+[4]: #parameters-1
+[5]: #queryselector
+[6]: #parameters-2
+[7]: #queryselectorall
+[8]: #parameters-3
+[59]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String
+[60]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object
+[61]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean
+[62]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
+[63]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/undefined
+[64]: https://developer.mozilla.org/docs/Web/API/Element/matches
+[65]: https://developer.mozilla.org/docs/Web/API/Element/closest
+[66]: https://developer.mozilla.org/docs/Web/API/Document/querySelector
+[67]: https://developer.mozilla.org/docs/Web/API/DocumentFragment/querySelector
+[68]: https://developer.mozilla.org/docs/Web/API/Element/querySelector
+[69]: https://developer.mozilla.org/docs/Web/API/Document/querySelectorAll
+[70]: https://developer.mozilla.org/docs/Web/API/DocumentFragment/querySelectorAll
+[71]: https://developer.mozilla.org/docs/Web/API/Element/querySelectorAll

frontend/node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache/LICENSE.md

@@ -0,0 +1,55 @@
+# Blue Oak Model License
+
+Version 1.0.0
+
+## Purpose
+
+This license gives everyone as much permission to work with
+this software as possible, while protecting contributors
+from liability.
+
+## Acceptance
+
+In order to receive this license, you must agree to its
+rules.  The rules of this license are both obligations
+under that agreement and conditions to your license.
+You must not do anything with this software that triggers
+a rule that you cannot or will not follow.
+
+## Copyright
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe that contributor's
+copyright in it.
+
+## Notices
+
+You must ensure that everyone who gets a copy of
+any part of this software from you, with or without
+changes, also gets the text of this license or a link to
+<https://blueoakcouncil.org/license/1.0.0>.
+
+## Excuse
+
+If anyone notifies you in writing that you have not
+complied with [Notices](#notices), you can keep your
+license by taking all practical steps to comply within 30
+days after the notice.  If you do not do so, your license
+ends immediately.
+
+## Patent
+
+Each contributor licenses you to do everything with this
+software that would otherwise infringe any patent claims
+they can license or become able to license.
+
+## Reliability
+
+No contributor can revoke this license.
+
+## No Liability
+
+***As far as the law allows, this software comes as is,
+without any warranty or condition, and no contributor
+will be liable to anyone for any damages related to this
+software or this license, under any kind of legal claim.***

frontend/node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache/README.md

@@ -0,0 +1,334 @@
+# lru-cache
+
+A cache object that deletes the least-recently-used items.
+
+Specify a max number of the most recently used items that you
+want to keep, and this cache will keep that many of the most
+recently accessed items.
+
+This is not primarily a TTL cache, and does not make strong TTL
+guarantees. There is no preemptive pruning of expired items by
+default, but you _may_ set a TTL on the cache or on a single
+`set`. If you do so, it will treat expired items as missing, and
+delete them when fetched. If you are more interested in TTL
+caching than LRU caching, check out
+[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).
+
+As of version 7, this is one of the most performant LRU
+implementations available in JavaScript, and supports a wide
+diversity of use cases. However, note that using some of the
+features will necessarily impact performance, by causing the
+cache to have to do more work. See the "Performance" section
+below.
+
+## Installation
+
+```bash
+npm install lru-cache --save
+```
+
+## Usage
+
+```js
+// hybrid module, either works
+import { LRUCache } from 'lru-cache'
+// or:
+const { LRUCache } = require('lru-cache')
+// or in minified form for web browsers:
+import { LRUCache } from 'http://unpkg.com/lru-cache@9/dist/mjs/index.min.mjs'
+
+// At least one of 'max', 'ttl', or 'maxSize' is required, to prevent
+// unsafe unbounded storage.
+//
+// In most cases, it's best to specify a max for performance, so all
+// the required memory allocation is done up-front.
+//
+// All the other options are optional, see the sections below for
+// documentation on what each one does.  Most of them can be
+// overridden for specific items in get()/set()
+const options = {
+  max: 500,
+
+  // for use with tracking overall storage size
+  maxSize: 5000,
+  sizeCalculation: (value, key) => {
+    return 1
+  },
+
+  // for use when you need to clean up something when objects
+  // are evicted from the cache
+  dispose: (value, key, reason) => {
+    freeFromMemoryOrWhatever(value)
+  },
+
+  // for use when you need to know that an item is being inserted
+  // note that this does NOT allow you to prevent the insertion,
+  // it just allows you to know about it.
+  onInsert: (value, key, reason) => {
+    logInsertionOrWhatever(key, value)
+  },
+
+  // how long to live in ms
+  ttl: 1000 * 60 * 5,
+
+  // return stale items before removing from cache?
+  allowStale: false,
+
+  updateAgeOnGet: false,
+  updateAgeOnHas: false,
+
+  // async method to use for cache.fetch(), for
+  // stale-while-revalidate type of behavior
+  fetchMethod: async (key, staleValue, { options, signal, context }) => {},
+}
+
+const cache = new LRUCache(options)
+
+cache.set('key', 'value')
+cache.get('key') // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.clear() // empty the cache
+```
+
+If you put more stuff in the cache, then less recently used items
+will fall out. That's what an LRU cache is.
+
+For full description of the API and all options, please see [the
+LRUCache typedocs](https://isaacs.github.io/node-lru-cache/)
+
+## Storage Bounds Safety
+
+This implementation aims to be as flexible as possible, within
+the limits of safe memory consumption and optimal performance.
+
+At initial object creation, storage is allocated for `max` items.
+If `max` is set to zero, then some performance is lost, and item
+count is unbounded. Either `maxSize` or `ttl` _must_ be set if
+`max` is not specified.
+
+If `maxSize` is set, then this creates a safe limit on the
+maximum storage consumed, but without the performance benefits of
+pre-allocation. When `maxSize` is set, every item _must_ provide
+a size, either via the `sizeCalculation` method provided to the
+constructor, or via a `size` or `sizeCalculation` option provided
+to `cache.set()`. The size of every item _must_ be a positive
+integer.
+
+If neither `max` nor `maxSize` are set, then `ttl` tracking must
+be enabled. Note that, even when tracking item `ttl`, items are
+_not_ preemptively deleted when they become stale, unless
+`ttlAutopurge` is enabled. Instead, they are only purged the
+next time the key is requested. Thus, if `ttlAutopurge`, `max`,
+and `maxSize` are all not set, then the cache will potentially
+grow unbounded.
+
+In this case, a warning is printed to standard error. Future
+versions may require the use of `ttlAutopurge` if `max` and
+`maxSize` are not specified.
+
+If you truly wish to use a cache that is bound _only_ by TTL
+expiration, consider using a `Map` object, and calling
+`setTimeout` to delete entries when they expire. It will perform
+much better than an LRU cache.
+
+Here is an implementation you may use, under the same
+[license](./LICENSE) as this package:
+
+```js
+// a storage-unbounded ttl cache that is not an lru-cache
+const cache = {
+  data: new Map(),
+  timers: new Map(),
+  set: (k, v, ttl) => {
+    if (cache.timers.has(k)) {
+      clearTimeout(cache.timers.get(k))
+    }
+    cache.timers.set(
+      k,
+      setTimeout(() => cache.delete(k), ttl),
+    )
+    cache.data.set(k, v)
+  },
+  get: k => cache.data.get(k),
+  has: k => cache.data.has(k),
+  delete: k => {
+    if (cache.timers.has(k)) {
+      clearTimeout(cache.timers.get(k))
+    }
+    cache.timers.delete(k)
+    return cache.data.delete(k)
+  },
+  clear: () => {
+    cache.data.clear()
+    for (const v of cache.timers.values()) {
+      clearTimeout(v)
+    }
+    cache.timers.clear()
+  },
+}
+```
+
+If that isn't to your liking, check out
+[@isaacs/ttlcache](http://npm.im/@isaacs/ttlcache).
+
+## Storing Undefined Values
+
+This cache never stores undefined values, as `undefined` is used
+internally in a few places to indicate that a key is not in the
+cache.
+
+You may call `cache.set(key, undefined)`, but this is just
+an alias for `cache.delete(key)`. Note that this has the effect
+that `cache.has(key)` will return _false_ after setting it to
+undefined.
+
+```js
+cache.set(myKey, undefined)
+cache.has(myKey) // false!
+```
+
+If you need to track `undefined` values, and still note that the
+key is in the cache, an easy workaround is to use a sigil object
+of your own.
+
+```js
+import { LRUCache } from 'lru-cache'
+const undefinedValue = Symbol('undefined')
+const cache = new LRUCache(...)
+const mySet = (key, value) =>
+  cache.set(key, value === undefined ? undefinedValue : value)
+const myGet = (key, value) => {
+  const v = cache.get(key)
+  return v === undefinedValue ? undefined : v
+}
+```
+
+## Performance
+
+As of January 2022, version 7 of this library is one of the most
+performant LRU cache implementations in JavaScript.
+
+Benchmarks can be extremely difficult to get right. In
+particular, the performance of set/get/delete operations on
+objects will vary _wildly_ depending on the type of key used. V8
+is highly optimized for objects with keys that are short strings,
+especially integer numeric strings. Thus any benchmark which
+tests _solely_ using numbers as keys will tend to find that an
+object-based approach performs the best.
+
+Note that coercing _anything_ to strings to use as object keys is
+unsafe, unless you can be 100% certain that no other type of
+value will be used. For example:
+
+```js
+const myCache = {}
+const set = (k, v) => (myCache[k] = v)
+const get = k => myCache[k]
+
+set({}, 'please hang onto this for me')
+set('[object Object]', 'oopsie')
+```
+
+Also beware of "Just So" stories regarding performance. Garbage
+collection of large (especially: deep) object graphs can be
+incredibly costly, with several "tipping points" where it
+increases exponentially. As a result, putting that off until
+later can make it much worse, and less predictable. If a library
+performs well, but only in a scenario where the object graph is
+kept shallow, then that won't help you if you are using large
+objects as keys.
+
+In general, when attempting to use a library to improve
+performance (such as a cache like this one), it's best to choose
+an option that will perform well in the sorts of scenarios where
+you'll actually use it.
+
+This library is optimized for repeated gets and minimizing
+eviction time, since that is the expected need of a LRU. Set
+operations are somewhat slower on average than a few other
+options, in part because of that optimization. It is assumed
+that you'll be caching some costly operation, ideally as rarely
+as possible, so optimizing set over get would be unwise.
+
+If performance matters to you:
+
+1. If it's at all possible to use small integer values as keys,
+   and you can guarantee that no other types of values will be
+   used as keys, then do that, and use a cache such as
+   [lru-fast](https://npmjs.com/package/lru-fast), or
+   [mnemonist's
+   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache)
+   which uses an Object as its data store.
+
+2. Failing that, if at all possible, use short non-numeric
+   strings (ie, less than 256 characters) as your keys, and use
+   [mnemonist's
+   LRUCache](https://yomguithereal.github.io/mnemonist/lru-cache).
+
+3. If the types of your keys will be anything else, especially
+   long strings, strings that look like floats, objects, or some
+   mix of types, or if you aren't sure, then this library will
+   work well for you.
+
+   If you do not need the features that this library provides
+   (like asynchronous fetching, a variety of TTL staleness
+   options, and so on), then [mnemonist's
+   LRUMap](https://yomguithereal.github.io/mnemonist/lru-map) is
+   a very good option, and just slightly faster than this module
+   (since it does considerably less).
+
+4. Do not use a `dispose` function, size tracking, or especially
+   ttl behavior, unless absolutely needed. These features are
+   convenient, and necessary in some use cases, and every attempt
+   has been made to make the performance impact minimal, but it
+   isn't nothing.
+
+## Breaking Changes in Version 7
+
+This library changed to a different algorithm and internal data
+structure in version 7, yielding significantly better
+performance, albeit with some subtle changes as a result.
+
+If you were relying on the internals of LRUCache in version 6 or
+before, it probably will not work in version 7 and above.
+
+## Breaking Changes in Version 8
+
+- The `fetchContext` option was renamed to `context`, and may no
+  longer be set on the cache instance itself.
+- Rewritten in TypeScript, so pretty much all the types moved
+  around a lot.
+- The AbortController/AbortSignal polyfill was removed. For this
+  reason, **Node version 16.14.0 or higher is now required**.
+- Internal properties were moved to actual private class
+  properties.
+- Keys and values must not be `null` or `undefined`.
+- Minified export available at `'lru-cache/min'`, for both CJS
+  and MJS builds.
+
+## Breaking Changes in Version 9
+
+- Named export only, no default export.
+- AbortController polyfill returned, albeit with a warning when
+  used.
+
+## Breaking Changes in Version 10
+
+- `cache.fetch()` return type is now `Promise<V | undefined>`
+  instead of `Promise<V | void>`. This is an irrelevant change
+  practically speaking, but can require changes for TypeScript
+  users.
+
+For more info, see the [change log](CHANGELOG.md).

frontend/node_modules/@asamuzakjp/dom-selector/node_modules/lru-cache/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "lru-cache",
+  "description": "A cache object that deletes the least-recently-used items.",
+  "version": "11.2.4",
+  "author": "Isaac Z. Schlueter <i@izs.me>",
+  "keywords": [
+    "mru",
+    "lru",
+    "cache"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "npm run prepare",
+    "prepare": "tshy && bash fixup.sh",
+    "pretest": "npm run prepare",
+    "presnap": "npm run prepare",
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "format": "prettier --write .",
+    "typedoc": "typedoc --tsconfig ./.tshy/esm.json ./src/*.ts",
+    "benchmark-results-typedoc": "bash scripts/benchmark-results-typedoc.sh",
+    "prebenchmark": "npm run prepare",
+    "benchmark": "make -C benchmark",
+    "preprofile": "npm run prepare",
+    "profile": "make -C benchmark profile"
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./min": {
+        "import": {
+          "types": "./dist/esm/index.d.ts",
+          "default": "./dist/esm/index.min.js"
+        },
+        "require": {
+          "types": "./dist/commonjs/index.d.ts",
+          "default": "./dist/commonjs/index.min.js"
+        }
+      }
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-lru-cache.git"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "benchmark": "^2.1.4",
+    "esbuild": "^0.25.9",
+    "marked": "^4.2.12",
+    "mkdirp": "^3.0.1",
+    "prettier": "^3.6.2",
+    "tap": "^21.1.0",
+    "tshy": "^3.0.2",
+    "typedoc": "^0.28.12"
+  },
+  "license": "BlueOak-1.0.0",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "20 || >=22"
+  },
+  "tap": {
+    "node-arg": [
+      "--expose-gc"
+    ],
+    "plugin": [
+      "@tapjs/clock"
+    ]
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./min": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.min.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.min.js"
+      }
+    }
+  },
+  "type": "module",
+  "module": "./dist/esm/index.js"
+}

frontend/node_modules/@asamuzakjp/dom-selector/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@asamuzakjp/dom-selector",
+  "description": "A CSS selector engine.",
+  "author": "asamuzaK",
+  "license": "MIT",
+  "homepage": "https://github.com/asamuzaK/domSelector#readme",
+  "bugs": {
+    "url": "https://github.com/asamuzaK/domSelector/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/asamuzaK/domSelector.git"
+  },
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "type": "module",
+  "exports": {
+    "import": {
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "require": {
+      "types": "./dist/cjs/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    },
+    "default": {
+      "types": "./dist/cjs/types/index.d.cts",
+      "default": "./dist/cjs/index.cjs"
+    }
+  },
+  "types": "types/index.d.ts",
+  "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.4"
+  },
+  "devDependencies": {
+    "@types/css-tree": "^2.3.11",
+    "benchmark": "^2.1.4",
+    "c8": "^10.1.3",
+    "chai": "^6.2.1",
+    "commander": "^14.0.2",
+    "esbuild": "^0.27.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jsdoc": "^61.4.1",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-regexp": "^2.10.0",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "globals": "^16.5.0",
+    "jsdom": "^27.2.0",
+    "mocha": "^11.7.5",
+    "neostandard": "^0.12.2",
+    "prettier": "^3.7.4",
+    "sinon": "^21.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "wpt-runner": "^6.1.0"
+  },
+  "overrides": {
+    "jsdom": "$jsdom"
+  },
+  "scripts": {
+    "bench": "node benchmark/bench.js",
+    "bench:sizzle": "node benchmark/bench-sizzle.js",
+    "build": "npm run tsc && npm run lint && npm test && npm run bundle && npm run test:cjs",
+    "bundle": "tsup src/index.js --format=cjs --platform=node --outDir=dist/cjs/ --sourcemap --dts",
+    "lint": "eslint --fix .",
+    "test": "c8 --reporter=text mocha --parallel --exit test/**/*.test.js",
+    "test:cjs": "mocha --exit test/index.test.cjs",
+    "test:wpt": "node test/wpt/wpt-runner.js",
+    "tsc": "node scripts/index clean --dir=types -i && npx tsc",
+    "update:wpt": "git submodule update --init --recursive --remote"
+  },
+  "version": "6.7.6"
+}

frontend/node_modules/@asamuzakjp/dom-selector/src/index.js

@@ -0,0 +1,353 @@
+/*!
+ * DOM Selector - A CSS selector engine.
+ * @license MIT
+ * @copyright asamuzaK (Kazz)
+ * @see {@link https://github.com/asamuzaK/domSelector/blob/main/LICENSE}
+ */
+
+/* import */
+import { LRUCache } from 'lru-cache';
+import { Finder } from './js/finder.js';
+import { filterSelector, getType, initNwsapi } from './js/utility.js';
+
+/* constants */
+import {
+  DOCUMENT_NODE,
+  DOCUMENT_FRAGMENT_NODE,
+  ELEMENT_NODE,
+  TARGET_ALL,
+  TARGET_FIRST,
+  TARGET_LINEAL,
+  TARGET_SELF
+} from './js/constant.js';
+const MAX_CACHE = 1024;
+
+/**
+ * @typedef {object} CheckResult
+ * @property {boolean} match - The match result.
+ * @property {string?} pseudoElement - The pseudo-element, if any.
+ */
+
+/* DOMSelector */
+export class DOMSelector {
+  /* private fields */
+  #window;
+  #document;
+  #finder;
+  #idlUtils;
+  #nwsapi;
+  #cache;
+
+  /**
+   * Creates an instance of DOMSelector.
+   * @param {Window} window - The window object.
+   * @param {Document} document - The document object.
+   * @param {object} [opt] - Options.
+   */
+  constructor(window, document, opt = {}) {
+    const { idlUtils } = opt;
+    this.#window = window;
+    this.#document = document ?? window.document;
+    this.#finder = new Finder(window);
+    this.#idlUtils = idlUtils;
+    this.#nwsapi = initNwsapi(window, document);
+    this.#cache = new LRUCache({
+      max: MAX_CACHE
+    });
+  }
+
+  /**
+   * Clears the internal cache of finder results.
+   * @returns {void}
+   */
+  clear = () => {
+    this.#finder.clearResults(true);
+  };
+
+  /**
+   * Checks if an element matches a CSS selector.
+   * @param {string} selector - The CSS selector to check against.
+   * @param {Element} node - The element node to check.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {CheckResult} An object containing the check result.
+   */
+  check = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `check_${selector}`;
+      let filterMatches = false;
+      if (this.#cache.has(cacheKey)) {
+        filterMatches = this.#cache.get(cacheKey);
+      } else {
+        filterMatches = filterSelector(selector, TARGET_SELF);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const match = this.#nwsapi.match(selector, n);
+          return {
+            match,
+            pseudoElement: null
+          };
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      opt.check = true;
+      opt.noexept = true;
+      opt.warn = false;
+      this.#finder.setup(selector, node, opt);
+      res = this.#finder.find(TARGET_SELF);
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res;
+  };
+
+  /**
+   * Returns true if the element matches the selector.
+   * @param {string} selector - The CSS selector to match against.
+   * @param {Element} node - The element node to test.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {boolean} `true` if the element matches, or `false` otherwise.
+   */
+  matches = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `matches_${selector}`;
+      let filterMatches = false;
+      if (this.#cache.has(cacheKey)) {
+        filterMatches = this.#cache.get(cacheKey);
+      } else {
+        filterMatches = filterSelector(selector, TARGET_SELF);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const res = this.#nwsapi.match(selector, n);
+          return res;
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      this.#finder.setup(selector, node, opt);
+      const nodes = this.#finder.find(TARGET_SELF);
+      res = nodes.size;
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return !!res;
+  };
+
+  /**
+   * Traverses up the DOM tree to find the first node that matches the selector.
+   * @param {string} selector - The CSS selector to match against.
+   * @param {Element} node - The element from which to start traversing.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {?Element} The first matching ancestor element, or `null`.
+   */
+  closest = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    } else if (node.nodeType !== ELEMENT_NODE) {
+      const e = new this.#window.TypeError(`Unexpected node ${node.nodeName}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document = node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      node.parentNode
+    ) {
+      const cacheKey = `closest_${selector}`;
+      let filterMatches = false;
+      if (this.#cache.has(cacheKey)) {
+        filterMatches = this.#cache.get(cacheKey);
+      } else {
+        filterMatches = filterSelector(selector, TARGET_LINEAL);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const res = this.#nwsapi.closest(selector, n);
+          return res;
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      this.#finder.setup(selector, node, opt);
+      const nodes = this.#finder.find(TARGET_LINEAL);
+      if (nodes.size) {
+        let refNode = node;
+        while (refNode) {
+          if (nodes.has(refNode)) {
+            res = refNode;
+            break;
+          }
+          refNode = refNode.parentNode;
+        }
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? null;
+  };
+
+  /**
+   * Returns the first element within the subtree that matches the selector.
+   * @param {string} selector - The CSS selector to match.
+   * @param {Document|DocumentFragment|Element} node - The node to find within.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {?Element} The first matching element, or `null`.
+   */
+  querySelector = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    }
+    /*
+    const document =
+      node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      (node.nodeType !== DOCUMENT_FRAGMENT_NODE || !node.host)
+    ) {
+      const cacheKey = `querySelector_${selector}`;
+      let filterMatches = false;
+      if (this.#cache.has(cacheKey)) {
+        filterMatches = this.#cache.get(cacheKey);
+      } else {
+        filterMatches = filterSelector(selector, TARGET_FIRST);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const res = this.#nwsapi.first(selector, n);
+          return res;
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    */
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      this.#finder.setup(selector, node, opt);
+      const nodes = this.#finder.find(TARGET_FIRST);
+      if (nodes.size) {
+        [res] = [...nodes];
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? null;
+  };
+
+  /**
+   * Returns an array of elements within the subtree that match the selector.
+   * Note: This method returns an Array, not a NodeList.
+   * @param {string} selector - The CSS selector to match.
+   * @param {Document|DocumentFragment|Element} node - The node to find within.
+   * @param {object} [opt] - Optional parameters.
+   * @returns {Array<Element>} An array of elements, or an empty array.
+   */
+  querySelectorAll = (selector, node, opt = {}) => {
+    if (!node?.nodeType) {
+      const e = new this.#window.TypeError(`Unexpected type ${getType(node)}`);
+      return this.#finder.onError(e, opt);
+    }
+    const document =
+      node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
+    if (
+      document === this.#document &&
+      document.contentType === 'text/html' &&
+      document.documentElement &&
+      (node.nodeType !== DOCUMENT_FRAGMENT_NODE || !node.host)
+    ) {
+      const cacheKey = `querySelectorAll_${selector}`;
+      let filterMatches = false;
+      if (this.#cache.has(cacheKey)) {
+        filterMatches = this.#cache.get(cacheKey);
+      } else {
+        filterMatches = filterSelector(selector, TARGET_ALL);
+        this.#cache.set(cacheKey, filterMatches);
+      }
+      if (filterMatches) {
+        try {
+          const n = this.#idlUtils ? this.#idlUtils.wrapperForImpl(node) : node;
+          const res = this.#nwsapi.select(selector, n);
+          return res;
+        } catch (e) {
+          // fall through
+        }
+      }
+    }
+    let res;
+    try {
+      if (this.#idlUtils) {
+        node = this.#idlUtils.wrapperForImpl(node);
+      }
+      this.#finder.setup(selector, node, opt);
+      const nodes = this.#finder.find(TARGET_ALL);
+      if (nodes.size) {
+        res = [...nodes];
+      }
+    } catch (e) {
+      this.#finder.onError(e, opt);
+    }
+    return res ?? [];
+  };
+}

frontend/node_modules/@asamuzakjp/dom-selector/src/js/constant.js

@@ -0,0 +1,129 @@
+/**
+ * constant.js
+ */
+
+/* string */
+export const ATRULE = 'Atrule';
+export const ATTR_SELECTOR = 'AttributeSelector';
+export const CLASS_SELECTOR = 'ClassSelector';
+export const COMBINATOR = 'Combinator';
+export const IDENT = 'Identifier';
+export const ID_SELECTOR = 'IdSelector';
+export const NOT_SUPPORTED_ERR = 'NotSupportedError';
+export const NTH = 'Nth';
+export const OPERATOR = 'Operator';
+export const PS_CLASS_SELECTOR = 'PseudoClassSelector';
+export const PS_ELEMENT_SELECTOR = 'PseudoElementSelector';
+export const RULE = 'Rule';
+export const SCOPE = 'Scope';
+export const SELECTOR = 'Selector';
+export const SELECTOR_LIST = 'SelectorList';
+export const STRING = 'String';
+export const SYNTAX_ERR = 'SyntaxError';
+export const TARGET_ALL = 'all';
+export const TARGET_FIRST = 'first';
+export const TARGET_LINEAL = 'lineal';
+export const TARGET_SELF = 'self';
+export const TYPE_SELECTOR = 'TypeSelector';
+
+/* numeric */
+export const BIT_01 = 1;
+export const BIT_02 = 2;
+export const BIT_04 = 4;
+export const BIT_08 = 8;
+export const BIT_16 = 0x10;
+export const BIT_32 = 0x20;
+export const BIT_FFFF = 0xffff;
+export const DUO = 2;
+export const HEX = 16;
+export const TYPE_FROM = 8;
+export const TYPE_TO = -1;
+
+/* Node */
+export const ELEMENT_NODE = 1;
+export const TEXT_NODE = 3;
+export const DOCUMENT_NODE = 9;
+export const DOCUMENT_FRAGMENT_NODE = 11;
+export const DOCUMENT_POSITION_PRECEDING = 2;
+export const DOCUMENT_POSITION_CONTAINS = 8;
+export const DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+
+/* NodeFilter */
+export const SHOW_ALL = 0xffffffff;
+export const SHOW_CONTAINER = 0x501;
+export const SHOW_DOCUMENT = 0x100;
+export const SHOW_DOCUMENT_FRAGMENT = 0x400;
+export const SHOW_ELEMENT = 1;
+
+/* selectors */
+export const ALPHA_NUM = '[A-Z\\d]+';
+export const CHILD_IDX = '(?:first|last|only)-(?:child|of-type)';
+export const DIGIT = '(?:0|[1-9]\\d*)';
+export const LANG_PART = `(?:-${ALPHA_NUM})*`;
+export const PSEUDO_CLASS = `(?:any-)?link|${CHILD_IDX}|checked|empty|indeterminate|read-(?:only|write)|target`;
+export const ANB = `[+-]?(?:${DIGIT}n?|n)|(?:[+-]?${DIGIT})?n\\s*[+-]\\s*${DIGIT}`;
+// combinators
+export const COMBO = '\\s?[\\s>~+]\\s?';
+export const DESCEND = '\\s?[\\s>]\\s?';
+export const SIBLING = '\\s?[+~]\\s?';
+// LOGIC_IS: :is()
+export const LOGIC_IS = `:is\\(\\s*[^)]+\\s*\\)`;
+// N_TH: excludes An+B with selector list, e.g. :nth-child(2n+1 of .foo)
+export const N_TH = `nth-(?:last-)?(?:child|of-type)\\(\\s*(?:even|odd|${ANB})\\s*\\)`;
+// SUB_TYPE: attr, id, class, pseudo-class, note that [foo|=bar] is excluded
+export const SUB_TYPE = '\\[[^|\\]]+\\]|[#.:][\\w-]+';
+export const SUB_TYPE_WO_PSEUDO = '\\[[^|\\]]+\\]|[#.][\\w-]+';
+// TAG_TYPE: *, tag
+export const TAG_TYPE = '\\*|[A-Za-z][\\w-]*';
+export const TAG_TYPE_I = '\\*|[A-Z][\\w-]*';
+export const COMPOUND = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE})+)`;
+export const COMPOUND_L = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE}|${LOGIC_IS})+)`;
+export const COMPOUND_I = `(?:${TAG_TYPE_I}|(?:${TAG_TYPE_I})?(?:${SUB_TYPE})+)`;
+export const COMPOUND_WO_PSEUDO = `(?:${TAG_TYPE}|(?:${TAG_TYPE})?(?:${SUB_TYPE_WO_PSEUDO})+)`;
+export const COMPLEX = `${COMPOUND}(?:${COMBO}${COMPOUND})*`;
+export const COMPLEX_L = `${COMPOUND_L}(?:${COMBO}${COMPOUND_L})*`;
+export const HAS_COMPOUND = `has\\([\\s>]?\\s*${COMPOUND_WO_PSEUDO}\\s*\\)`;
+export const LOGIC_COMPOUND = `(?:is|not)\\(\\s*${COMPOUND_L}(?:\\s*,\\s*${COMPOUND_L})*\\s*\\)`;
+export const LOGIC_COMPLEX = `(?:is|not)\\(\\s*${COMPLEX_L}(?:\\s*,\\s*${COMPLEX_L})*\\s*\\)`;
+
+/* forms and input types */
+export const FORM_PARTS = Object.freeze([
+  'button',
+  'input',
+  'select',
+  'textarea'
+]);
+export const INPUT_BUTTON = Object.freeze(['button', 'reset', 'submit']);
+export const INPUT_CHECK = Object.freeze(['checkbox', 'radio']);
+export const INPUT_DATE = Object.freeze([
+  'date',
+  'datetime-local',
+  'month',
+  'time',
+  'week'
+]);
+export const INPUT_TEXT = Object.freeze([
+  'email',
+  'password',
+  'search',
+  'tel',
+  'text',
+  'url'
+]);
+export const INPUT_EDIT = Object.freeze([
+  ...INPUT_DATE,
+  ...INPUT_TEXT,
+  'number'
+]);
+export const INPUT_LTR = Object.freeze([
+  ...INPUT_CHECK,
+  'color',
+  'date',
+  'image',
+  'number',
+  'range',
+  'time'
+]);
+
+/* logical combination pseudo-classes */
+export const KEYS_LOGICAL = new Set(['has', 'is', 'not', 'where']);

frontend/node_modules/@asamuzakjp/dom-selector/src/js/matcher.js

@@ -0,0 +1,587 @@
+/**
+ * matcher.js
+ */
+
+/* import */
+import { generateCSS, parseAstName, unescapeSelector } from './parser.js';
+import {
+  generateException,
+  getDirectionality,
+  getLanguageAttribute,
+  getType,
+  isContentEditable,
+  isCustomElement,
+  isNamespaceDeclared
+} from './utility.js';
+
+/* constants */
+import {
+  ALPHA_NUM,
+  FORM_PARTS,
+  IDENT,
+  INPUT_EDIT,
+  LANG_PART,
+  NOT_SUPPORTED_ERR,
+  PS_ELEMENT_SELECTOR,
+  STRING,
+  SYNTAX_ERR
+} from './constant.js';
+const KEYS_FORM_PS_DISABLED = new Set([
+  ...FORM_PARTS,
+  'fieldset',
+  'optgroup',
+  'option'
+]);
+const KEYS_INPUT_EDIT = new Set(INPUT_EDIT);
+const REG_LANG_VALID = new RegExp(`^(?:\\*-)?${ALPHA_NUM}${LANG_PART}$`, 'i');
+const REG_TAG_NAME = /[A-Z][\\w-]*/i;
+
+/**
+ * Validates a pseudo-element selector.
+ * @param {string} astName - The name of the pseudo-element from the AST.
+ * @param {string} astType - The type of the selector from the AST.
+ * @param {object} [opt] - Optional parameters.
+ * @param {boolean} [opt.forgive] - If true, ignores unknown pseudo-elements.
+ * @param {boolean} [opt.warn] - If true, throws an error for unsupported ones.
+ * @throws {DOMException} If the selector is invalid or unsupported.
+ * @returns {void}
+ */
+export const matchPseudoElementSelector = (astName, astType, opt = {}) => {
+  const { forgive, globalObject, warn } = opt;
+  if (astType !== PS_ELEMENT_SELECTOR) {
+    // Ensure the AST node is a pseudo-element selector.
+    throw new TypeError(`Unexpected ast type ${getType(astType)}`);
+  }
+  switch (astName) {
+    case 'after':
+    case 'backdrop':
+    case 'before':
+    case 'cue':
+    case 'cue-region':
+    case 'first-letter':
+    case 'first-line':
+    case 'file-selector-button':
+    case 'marker':
+    case 'placeholder':
+    case 'selection':
+    case 'target-text': {
+      // Warn if the pseudo-element is known but unsupported.
+      if (warn) {
+        throw generateException(
+          `Unsupported pseudo-element ::${astName}`,
+          NOT_SUPPORTED_ERR,
+          globalObject
+        );
+      }
+      break;
+    }
+    case 'part':
+    case 'slotted': {
+      // Warn if the functional pseudo-element is known but unsupported.
+      if (warn) {
+        throw generateException(
+          `Unsupported pseudo-element ::${astName}()`,
+          NOT_SUPPORTED_ERR,
+          globalObject
+        );
+      }
+      break;
+    }
+    default: {
+      // Handle vendor-prefixed or unknown pseudo-elements.
+      if (astName.startsWith('-webkit-')) {
+        if (warn) {
+          throw generateException(
+            `Unsupported pseudo-element ::${astName}`,
+            NOT_SUPPORTED_ERR,
+            globalObject
+          );
+        }
+        // Throw an error for unknown pseudo-elements if not forgiven.
+      } else if (!forgive) {
+        throw generateException(
+          `Unknown pseudo-element ::${astName}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+    }
+  }
+};
+
+/**
+ * Matches the :dir() pseudo-class against an element's directionality.
+ * @param {object} ast - The AST object for the pseudo-class.
+ * @param {object} node - The element node to match against.
+ * @throws {TypeError} If the AST does not contain a valid direction value.
+ * @returns {boolean} - True if the directionality matches, otherwise false.
+ */
+export const matchDirectionPseudoClass = (ast, node) => {
+  const { name } = ast;
+  // The :dir() pseudo-class requires a direction argument (e.g., "ltr").
+  if (!name) {
+    const type = name === '' ? '(empty String)' : getType(name);
+    throw new TypeError(`Unexpected ast type ${type}`);
+  }
+  // Get the computed directionality of the element.
+  const dir = getDirectionality(node);
+  // Compare the expected direction with the element's actual direction.
+  return name === dir;
+};
+
+/**
+ * Matches the :lang() pseudo-class against an element's language.
+ * @see https://datatracker.ietf.org/doc/html/rfc4647#section-3.3.1
+ * @param {object} ast - The AST object for the pseudo-class.
+ * @param {object} node - The element node to match against.
+ * @returns {boolean} - True if the language matches, otherwise false.
+ */
+export const matchLanguagePseudoClass = (ast, node) => {
+  const { name, type, value } = ast;
+  let langPattern;
+  // Determine the language pattern from the AST.
+  if (type === STRING && value) {
+    langPattern = value;
+  } else if (type === IDENT && name) {
+    langPattern = unescapeSelector(name);
+  }
+  // If no valid language pattern is provided, it cannot match.
+  if (typeof langPattern !== 'string') {
+    return false;
+  }
+  // Get the effective language attribute for the current node.
+  const elementLang = getLanguageAttribute(node);
+  // If the element has no language, it cannot match a specific pattern.
+  if (elementLang === null) {
+    return false;
+  }
+  // Handle the universal selector '*' for :lang.
+  if (langPattern === '*') {
+    // It matches any language unless attribute is not empty.
+    return elementLang !== '';
+  }
+  // Validate the provided language pattern structure.
+  if (!REG_LANG_VALID.test(langPattern)) {
+    return false;
+  }
+  // Build a regex for extended language range matching.
+  let matcherRegex;
+  if (langPattern.indexOf('-') > -1) {
+    // Handle complex patterns with wildcards and sub-tags (e.g., '*-US').
+    const [langMain, langSub, ...langRest] = langPattern.split('-');
+    const extendedMain =
+      langMain === '*' ? `${ALPHA_NUM}${LANG_PART}` : `${langMain}${LANG_PART}`;
+    const extendedSub = `-${langSub}${LANG_PART}`;
+    let extendedRest = '';
+    // Use a standard for loop for performance as per the rules.
+    for (let i = 0; i < langRest.length; i++) {
+      extendedRest += `-${langRest[i]}${LANG_PART}`;
+    }
+    matcherRegex = new RegExp(
+      `^${extendedMain}${extendedSub}${extendedRest}$`,
+      'i'
+    );
+  } else {
+    // Handle simple language patterns (e.g., 'en').
+    matcherRegex = new RegExp(`^${langPattern}${LANG_PART}$`, 'i');
+  }
+  // Test the element's language against the constructed regex.
+  return matcherRegex.test(elementLang);
+};
+
+/**
+ * Matches the :disabled and :enabled pseudo-classes.
+ * @param {string} astName - pseudo-class name
+ * @param {object} node - Element node
+ * @returns {boolean} - True if matched
+ */
+export const matchDisabledPseudoClass = (astName, node) => {
+  const { localName, parentNode } = node;
+  if (
+    !KEYS_FORM_PS_DISABLED.has(localName) &&
+    !isCustomElement(node, { formAssociated: true })
+  ) {
+    return false;
+  }
+  let isDisabled = false;
+  if (node.disabled || node.hasAttribute('disabled')) {
+    isDisabled = true;
+  } else if (localName === 'option') {
+    if (
+      parentNode &&
+      parentNode.localName === 'optgroup' &&
+      (parentNode.disabled || parentNode.hasAttribute('disabled'))
+    ) {
+      isDisabled = true;
+    }
+  } else if (localName !== 'optgroup') {
+    let current = parentNode;
+    while (current) {
+      if (
+        current.localName === 'fieldset' &&
+        (current.disabled || current.hasAttribute('disabled'))
+      ) {
+        // The first <legend> in a disabled <fieldset> is not disabled.
+        let legend;
+        let element = current.firstElementChild;
+        while (element) {
+          if (element.localName === 'legend') {
+            legend = element;
+            break;
+          }
+          element = element.nextElementSibling;
+        }
+        if (!legend || !legend.contains(node)) {
+          isDisabled = true;
+        }
+        // Found the containing fieldset, stop searching up.
+        break;
+      }
+      current = current.parentNode;
+    }
+  }
+  if (astName === 'disabled') {
+    return isDisabled;
+  }
+  return !isDisabled;
+};
+
+/**
+ * Match the :read-only and :read-write pseudo-classes
+ * @param {string} astName - pseudo-class name
+ * @param {object} node - Element node
+ * @returns {boolean} - True if matched
+ */
+export const matchReadOnlyPseudoClass = (astName, node) => {
+  const { localName } = node;
+  let isReadOnly = false;
+  switch (localName) {
+    case 'textarea':
+    case 'input': {
+      const isEditableInput = !node.type || KEYS_INPUT_EDIT.has(node.type);
+      if (localName === 'textarea' || isEditableInput) {
+        isReadOnly =
+          node.readOnly ||
+          node.hasAttribute('readonly') ||
+          node.disabled ||
+          node.hasAttribute('disabled');
+      } else {
+        // Non-editable input types are always read-only
+        isReadOnly = true;
+      }
+      break;
+    }
+    default: {
+      isReadOnly = !isContentEditable(node);
+    }
+  }
+  if (astName === 'read-only') {
+    return isReadOnly;
+  }
+  return !isReadOnly;
+};
+
+/**
+ * Matches an attribute selector against an element.
+ * This function handles various attribute matchers like '=', '~=', '^=', etc.,
+ * and considers namespaces and case sensitivity based on document type.
+ * @param {object} ast - The AST for the attribute selector.
+ * @param {object} node - The element node to match against.
+ * @param {object} [opt] - Optional parameters.
+ * @param {boolean} [opt.check] - True if running in an internal check.
+ * @param {boolean} [opt.forgive] - True to forgive certain syntax errors.
+ * @returns {boolean} - True if the attribute selector matches, otherwise false.
+ */
+export const matchAttributeSelector = (ast, node, opt = {}) => {
+  const {
+    flags: astFlags,
+    matcher: astMatcher,
+    name: astName,
+    value: astValue
+  } = ast;
+  const { check, forgive, globalObject } = opt;
+  // Validate selector flags ('i' or 's').
+  if (typeof astFlags === 'string' && !/^[is]$/i.test(astFlags) && !forgive) {
+    const css = generateCSS(ast);
+    throw generateException(
+      `Invalid selector ${css}`,
+      SYNTAX_ERR,
+      globalObject
+    );
+  }
+  const { attributes } = node;
+  // An element with no attributes cannot match.
+  if (!attributes || !attributes.length) {
+    return false;
+  }
+  // Determine case sensitivity based on document type and flags.
+  const contentType = node.ownerDocument.contentType;
+  let caseInsensitive;
+  if (contentType === 'text/html') {
+    if (typeof astFlags === 'string' && /^s$/i.test(astFlags)) {
+      caseInsensitive = false;
+    } else {
+      caseInsensitive = true;
+    }
+  } else if (typeof astFlags === 'string' && /^i$/i.test(astFlags)) {
+    caseInsensitive = true;
+  } else {
+    caseInsensitive = false;
+  }
+  // Prepare the attribute name from the selector for matching.
+  let astAttrName = unescapeSelector(astName.name);
+  if (caseInsensitive) {
+    astAttrName = astAttrName.toLowerCase();
+  }
+  // A set to store the values of attributes whose names match.
+  const attrValues = new Set();
+  // Handle namespaced attribute names (e.g., [*|attr], [ns|attr]).
+  if (astAttrName.indexOf('|') > -1) {
+    const { prefix: astPrefix, localName: astLocalName } =
+      parseAstName(astAttrName);
+    for (const item of attributes) {
+      let { name: itemName, value: itemValue } = item;
+      if (caseInsensitive) {
+        itemName = itemName.toLowerCase();
+        itemValue = itemValue.toLowerCase();
+      }
+      switch (astPrefix) {
+        case '': {
+          if (astLocalName === itemName) {
+            attrValues.add(itemValue);
+          }
+          break;
+        }
+        case '*': {
+          if (itemName.indexOf(':') > -1) {
+            const [, ...restItemName] = itemName.split(':');
+            const itemLocalName = restItemName.join(':').replace(/^:/, '');
+            if (itemLocalName === astLocalName) {
+              attrValues.add(itemValue);
+            }
+          } else if (astLocalName === itemName) {
+            attrValues.add(itemValue);
+          }
+          break;
+        }
+        default: {
+          if (!check) {
+            if (forgive) {
+              return false;
+            }
+            const css = generateCSS(ast);
+            throw generateException(
+              `Invalid selector ${css}`,
+              SYNTAX_ERR,
+              globalObject
+            );
+          }
+          if (itemName.indexOf(':') > -1) {
+            const [itemPrefix, ...restItemName] = itemName.split(':');
+            const itemLocalName = restItemName.join(':').replace(/^:/, '');
+            // Ignore the 'xml:lang' attribute.
+            if (itemPrefix === 'xml' && itemLocalName === 'lang') {
+              continue;
+            } else if (
+              astPrefix === itemPrefix &&
+              astLocalName === itemLocalName
+            ) {
+              const namespaceDeclared = isNamespaceDeclared(astPrefix, node);
+              if (namespaceDeclared) {
+                attrValues.add(itemValue);
+              }
+            }
+          }
+        }
+      }
+    }
+    // Handle non-namespaced attribute names.
+  } else {
+    for (let { name: itemName, value: itemValue } of attributes) {
+      if (caseInsensitive) {
+        itemName = itemName.toLowerCase();
+        itemValue = itemValue.toLowerCase();
+      }
+      if (itemName.indexOf(':') > -1) {
+        const [itemPrefix, ...restItemName] = itemName.split(':');
+        const itemLocalName = restItemName.join(':').replace(/^:/, '');
+        // The attribute is starting with ':'.
+        if (!itemPrefix && astAttrName === `:${itemLocalName}`) {
+          attrValues.add(itemValue);
+          // Ignore the 'xml:lang' attribute.
+        } else if (itemPrefix === 'xml' && itemLocalName === 'lang') {
+          continue;
+        } else if (astAttrName === itemLocalName) {
+          attrValues.add(itemValue);
+        }
+      } else if (astAttrName === itemName) {
+        attrValues.add(itemValue);
+      }
+    }
+  }
+  if (!attrValues.size) {
+    return false;
+  }
+  // Prepare the value from the selector's RHS for comparison.
+  const { name: astIdentValue, value: astStringValue } = astValue ?? {};
+  let attrValue;
+  if (astIdentValue) {
+    if (caseInsensitive) {
+      attrValue = astIdentValue.toLowerCase();
+    } else {
+      attrValue = astIdentValue;
+    }
+  } else if (astStringValue) {
+    if (caseInsensitive) {
+      attrValue = astStringValue.toLowerCase();
+    } else {
+      attrValue = astStringValue;
+    }
+  } else if (astStringValue === '') {
+    attrValue = astStringValue;
+  }
+  // Perform the final match based on the specified matcher.
+  switch (astMatcher) {
+    case '=': {
+      return typeof attrValue === 'string' && attrValues.has(attrValue);
+    }
+    case '~=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          const item = new Set(value.split(/\s+/));
+          if (item.has(attrValue)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '|=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value === attrValue || value.startsWith(`${attrValue}-`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '^=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.startsWith(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '$=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.endsWith(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case '*=': {
+      if (attrValue && typeof attrValue === 'string') {
+        for (const value of attrValues) {
+          if (value.includes(`${attrValue}`)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    case null:
+    default: {
+      // This case handles attribute existence checks (e.g., '[disabled]').
+      return true;
+    }
+  }
+};
+
+/**
+ * match type selector
+ * @param {object} ast - AST
+ * @param {object} node - Element node
+ * @param {object} [opt] - options
+ * @param {boolean} [opt.check] - running in internal check()
+ * @param {boolean} [opt.forgive] - forgive undeclared namespace
+ * @returns {boolean} - result
+ */
+export const matchTypeSelector = (ast, node, opt = {}) => {
+  const astName = unescapeSelector(ast.name);
+  const { localName, namespaceURI, prefix } = node;
+  const { check, forgive, globalObject } = opt;
+  let { prefix: astPrefix, localName: astLocalName } = parseAstName(
+    astName,
+    node
+  );
+  if (
+    node.ownerDocument.contentType === 'text/html' &&
+    (!namespaceURI || namespaceURI === 'http://www.w3.org/1999/xhtml') &&
+    REG_TAG_NAME.test(localName)
+  ) {
+    astPrefix = astPrefix.toLowerCase();
+    astLocalName = astLocalName.toLowerCase();
+  }
+  let nodePrefix;
+  let nodeLocalName;
+  // just in case that the namespaced content is parsed as text/html
+  if (localName.indexOf(':') > -1) {
+    [nodePrefix, nodeLocalName] = localName.split(':');
+  } else {
+    nodePrefix = prefix || '';
+    nodeLocalName = localName;
+  }
+  switch (astPrefix) {
+    case '': {
+      if (
+        !nodePrefix &&
+        !namespaceURI &&
+        (astLocalName === '*' || astLocalName === nodeLocalName)
+      ) {
+        return true;
+      }
+      return false;
+    }
+    case '*': {
+      if (astLocalName === '*' || astLocalName === nodeLocalName) {
+        return true;
+      }
+      return false;
+    }
+    default: {
+      if (!check) {
+        if (forgive) {
+          return false;
+        }
+        const css = generateCSS(ast);
+        throw generateException(
+          `Invalid selector ${css}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+      const astNS = node.lookupNamespaceURI(astPrefix);
+      const nodeNS = node.lookupNamespaceURI(nodePrefix);
+      if (astNS === nodeNS && astPrefix === nodePrefix) {
+        if (astLocalName === '*' || astLocalName === nodeLocalName) {
+          return true;
+        }
+        return false;
+      } else if (!forgive && !astNS) {
+        throw generateException(
+          `Undeclared namespace ${astPrefix}`,
+          SYNTAX_ERR,
+          globalObject
+        );
+      }
+      return false;
+    }
+  }
+};

frontend/node_modules/@asamuzakjp/dom-selector/src/js/parser.js

@@ -0,0 +1,431 @@
+/**
+ * parser.js
+ */
+
+/* import */
+import * as cssTree from 'css-tree';
+import { getType } from './utility.js';
+
+/* constants */
+import {
+  ATTR_SELECTOR,
+  BIT_01,
+  BIT_02,
+  BIT_04,
+  BIT_08,
+  BIT_16,
+  BIT_32,
+  BIT_FFFF,
+  CLASS_SELECTOR,
+  DUO,
+  HEX,
+  ID_SELECTOR,
+  KEYS_LOGICAL,
+  NTH,
+  PS_CLASS_SELECTOR,
+  PS_ELEMENT_SELECTOR,
+  SELECTOR,
+  SYNTAX_ERR,
+  TYPE_SELECTOR
+} from './constant.js';
+const AST_SORT_ORDER = new Map([
+  [PS_ELEMENT_SELECTOR, BIT_01],
+  [ID_SELECTOR, BIT_02],
+  [CLASS_SELECTOR, BIT_04],
+  [TYPE_SELECTOR, BIT_08],
+  [ATTR_SELECTOR, BIT_16],
+  [PS_CLASS_SELECTOR, BIT_32]
+]);
+const KEYS_PS_CLASS_STATE = new Set([
+  'checked',
+  'closed',
+  'disabled',
+  'empty',
+  'enabled',
+  'in-range',
+  'indeterminate',
+  'invalid',
+  'open',
+  'out-of-range',
+  'placeholder-shown',
+  'read-only',
+  'read-write',
+  'valid'
+]);
+const KEYS_SHADOW_HOST = new Set(['host', 'host-context']);
+const REG_EMPTY_PS_FUNC =
+  /(?<=:(?:dir|has|host(?:-context)?|is|lang|not|nth-(?:last-)?(?:child|of-type)|where))\(\s+\)/g;
+const REG_SHADOW_PS_ELEMENT = /^part|slotted$/;
+const U_FFFD = '\uFFFD';
+
+/**
+ * Unescapes a CSS selector string.
+ * @param {string} selector - The CSS selector to unescape.
+ * @returns {string} The unescaped selector string.
+ */
+export const unescapeSelector = (selector = '') => {
+  if (typeof selector === 'string' && selector.indexOf('\\', 0) >= 0) {
+    const arr = selector.split('\\');
+    const selectorItems = [arr[0]];
+    const l = arr.length;
+    for (let i = 1; i < l; i++) {
+      const item = arr[i];
+      if (item === '' && i === l - 1) {
+        selectorItems.push(U_FFFD);
+      } else {
+        const hexExists = /^([\da-f]{1,6}\s?)/i.exec(item);
+        if (hexExists) {
+          const [, hex] = hexExists;
+          let str;
+          try {
+            const low = parseInt('D800', HEX);
+            const high = parseInt('DFFF', HEX);
+            const deci = parseInt(hex, HEX);
+            if (deci === 0 || (deci >= low && deci <= high)) {
+              str = U_FFFD;
+            } else {
+              str = String.fromCodePoint(deci);
+            }
+          } catch (e) {
+            str = U_FFFD;
+          }
+          let postStr = '';
+          if (item.length > hex.length) {
+            postStr = item.substring(hex.length);
+          }
+          selectorItems.push(`${str}${postStr}`);
+          // whitespace
+        } else if (/^[\n\r\f]/.test(item)) {
+          selectorItems.push(`\\${item}`);
+        } else {
+          selectorItems.push(item);
+        }
+      }
+    }
+    return selectorItems.join('');
+  }
+  return selector;
+};
+
+/**
+ * Preprocesses a selector string according to the specification.
+ * @see https://drafts.csswg.org/css-syntax-3/#input-preprocessing
+ * @param {string} value - The value to preprocess.
+ * @returns {string} The preprocessed selector string.
+ */
+export const preprocess = value => {
+  // Non-string values will be converted to string.
+  if (typeof value !== 'string') {
+    if (value === undefined || value === null) {
+      return getType(value).toLowerCase();
+    } else if (Array.isArray(value)) {
+      return value.join(',');
+    } else if (Object.hasOwn(value, 'toString')) {
+      return value.toString();
+    } else {
+      throw new DOMException(`Invalid selector ${value}`, SYNTAX_ERR);
+    }
+  }
+  let selector = value;
+  let index = 0;
+  while (index >= 0) {
+    // @see https://drafts.csswg.org/selectors/#id-selectors
+    index = selector.indexOf('#', index);
+    if (index < 0) {
+      break;
+    }
+    const preHash = selector.substring(0, index + 1);
+    let postHash = selector.substring(index + 1);
+    const codePoint = postHash.codePointAt(0);
+    if (codePoint > BIT_FFFF) {
+      const str = `\\${codePoint.toString(HEX)} `;
+      if (postHash.length === DUO) {
+        postHash = str;
+      } else {
+        postHash = `${str}${postHash.substring(DUO)}`;
+      }
+    }
+    selector = `${preHash}${postHash}`;
+    index++;
+  }
+  return selector
+    .replace(/\f|\r\n?/g, '\n')
+    .replace(/[\0\uD800-\uDFFF]|\\$/g, U_FFFD)
+    .replace(/\x26/g, ':scope');
+};
+
+/**
+ * Creates an Abstract Syntax Tree (AST) from a CSS selector string.
+ * @param {string} sel - The CSS selector string.
+ * @returns {object} The parsed AST object.
+ */
+export const parseSelector = sel => {
+  const selector = preprocess(sel);
+  // invalid selectors
+  if (/^$|^\s*>|,\s*$/.test(selector)) {
+    throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+  }
+  try {
+    const ast = cssTree.parse(selector, {
+      context: 'selectorList',
+      parseCustomProperty: true
+    });
+    return cssTree.toPlainObject(ast);
+  } catch (e) {
+    const { message } = e;
+    if (
+      /^(?:"\]"|Attribute selector [()\s,=~^$*|]+) is expected$/.test(
+        message
+      ) &&
+      !selector.endsWith(']')
+    ) {
+      const index = selector.lastIndexOf('[');
+      const selPart = selector.substring(index);
+      if (selPart.includes('"')) {
+        const quotes = selPart.match(/"/g).length;
+        if (quotes % 2) {
+          return parseSelector(`${selector}"]`);
+        }
+        return parseSelector(`${selector}]`);
+      }
+      return parseSelector(`${selector}]`);
+    } else if (message === '")" is expected') {
+      // workaround for https://github.com/csstree/csstree/issues/283
+      if (REG_EMPTY_PS_FUNC.test(selector)) {
+        return parseSelector(`${selector.replaceAll(REG_EMPTY_PS_FUNC, '()')}`);
+      } else if (!selector.endsWith(')')) {
+        return parseSelector(`${selector})`);
+      } else {
+        throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+      }
+    } else {
+      throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+    }
+  }
+};
+
+/**
+ * Walks the provided AST to collect selector branches and gather information
+ * about its contents.
+ * @param {object} ast - The AST to traverse.
+ * @returns {{branches: Array<object>, info: object}} An object containing the selector branches and info.
+ */
+export const walkAST = (ast = {}) => {
+  const branches = new Set();
+  const info = {
+    hasForgivenPseudoFunc: false,
+    hasHasPseudoFunc: false,
+    hasLogicalPseudoFunc: false,
+    hasNotPseudoFunc: false,
+    hasNthChildOfSelector: false,
+    hasNestedSelector: false,
+    hasStatePseudoClass: false
+  };
+  const opt = {
+    enter(node) {
+      switch (node.type) {
+        case CLASS_SELECTOR: {
+          if (/^-?\d/.test(node.name)) {
+            throw new DOMException(
+              `Invalid selector .${node.name}`,
+              SYNTAX_ERR
+            );
+          }
+          break;
+        }
+        case ID_SELECTOR: {
+          if (/^-?\d/.test(node.name)) {
+            throw new DOMException(
+              `Invalid selector #${node.name}`,
+              SYNTAX_ERR
+            );
+          }
+          break;
+        }
+        case PS_CLASS_SELECTOR: {
+          if (KEYS_LOGICAL.has(node.name)) {
+            info.hasNestedSelector = true;
+            info.hasLogicalPseudoFunc = true;
+            if (node.name === 'has') {
+              info.hasHasPseudoFunc = true;
+            } else if (node.name === 'not') {
+              info.hasNotPseudoFunc = true;
+            } else {
+              info.hasForgivenPseudoFunc = true;
+            }
+          } else if (KEYS_PS_CLASS_STATE.has(node.name)) {
+            info.hasStatePseudoClass = true;
+          } else if (
+            KEYS_SHADOW_HOST.has(node.name) &&
+            Array.isArray(node.children) &&
+            node.children.length
+          ) {
+            info.hasNestedSelector = true;
+          }
+          break;
+        }
+        case PS_ELEMENT_SELECTOR: {
+          if (REG_SHADOW_PS_ELEMENT.test(node.name)) {
+            info.hasNestedSelector = true;
+          }
+          break;
+        }
+        case NTH: {
+          if (node.selector) {
+            info.hasNestedSelector = true;
+            info.hasNthChildOfSelector = true;
+          }
+          break;
+        }
+        case SELECTOR: {
+          branches.add(node.children);
+          break;
+        }
+        default:
+      }
+    }
+  };
+  cssTree.walk(ast, opt);
+  if (info.hasNestedSelector === true) {
+    cssTree.findAll(ast, (node, item, list) => {
+      if (list) {
+        if (node.type === PS_CLASS_SELECTOR && KEYS_LOGICAL.has(node.name)) {
+          const itemList = list.filter(i => {
+            const { name, type } = i;
+            return type === PS_CLASS_SELECTOR && KEYS_LOGICAL.has(name);
+          });
+          for (const { children } of itemList) {
+            // SelectorList
+            for (const { children: grandChildren } of children) {
+              // Selector
+              for (const { children: greatGrandChildren } of grandChildren) {
+                if (branches.has(greatGrandChildren)) {
+                  branches.delete(greatGrandChildren);
+                }
+              }
+            }
+          }
+        } else if (
+          node.type === PS_CLASS_SELECTOR &&
+          KEYS_SHADOW_HOST.has(node.name) &&
+          Array.isArray(node.children) &&
+          node.children.length
+        ) {
+          const itemList = list.filter(i => {
+            const { children, name, type } = i;
+            const res =
+              type === PS_CLASS_SELECTOR &&
+              KEYS_SHADOW_HOST.has(name) &&
+              Array.isArray(children) &&
+              children.length;
+            return res;
+          });
+          for (const { children } of itemList) {
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        } else if (
+          node.type === PS_ELEMENT_SELECTOR &&
+          REG_SHADOW_PS_ELEMENT.test(node.name)
+        ) {
+          const itemList = list.filter(i => {
+            const { name, type } = i;
+            const res =
+              type === PS_ELEMENT_SELECTOR && REG_SHADOW_PS_ELEMENT.test(name);
+            return res;
+          });
+          for (const { children } of itemList) {
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        } else if (node.type === NTH && node.selector) {
+          const itemList = list.filter(i => {
+            const { selector, type } = i;
+            const res = type === NTH && selector;
+            return res;
+          });
+          for (const { selector } of itemList) {
+            const { children } = selector;
+            // Selector
+            for (const { children: grandChildren } of children) {
+              if (branches.has(grandChildren)) {
+                branches.delete(grandChildren);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  return {
+    info,
+    branches: [...branches]
+  };
+};
+
+/**
+ * Comparison function for sorting AST nodes based on specificity.
+ * @param {object} a - The first AST node.
+ * @param {object} b - The second AST node.
+ * @returns {number} -1, 0 or 1, depending on the sort order.
+ */
+export const compareASTNodes = (a, b) => {
+  const bitA = AST_SORT_ORDER.get(a.type);
+  const bitB = AST_SORT_ORDER.get(b.type);
+  if (bitA === bitB) {
+    return 0;
+  } else if (bitA > bitB) {
+    return 1;
+  } else {
+    return -1;
+  }
+};
+
+/**
+ * Sorts a collection of AST nodes based on CSS specificity rules.
+ * @param {Array<object>} asts - A collection of AST nodes to sort.
+ * @returns {Array<object>} A new array containing the sorted AST nodes.
+ */
+export const sortAST = asts => {
+  const arr = [...asts];
+  if (arr.length > 1) {
+    arr.sort(compareASTNodes);
+  }
+  return arr;
+};
+
+/**
+ * Parses a type selector's name, which may include a namespace prefix.
+ * @param {string} selector - The type selector name (e.g., 'ns|E' or 'E').
+ * @returns {{prefix: string, localName: string}} An object with `prefix` and
+ * `localName` properties.
+ */
+export const parseAstName = selector => {
+  let prefix;
+  let localName;
+  if (selector && typeof selector === 'string') {
+    if (selector.indexOf('|') > -1) {
+      [prefix, localName] = selector.split('|');
+    } else {
+      prefix = '*';
+      localName = selector;
+    }
+  } else {
+    throw new DOMException(`Invalid selector ${selector}`, SYNTAX_ERR);
+  }
+  return {
+    prefix,
+    localName
+  };
+};
+
+/* Re-exported from css-tree. */
+export { find as findAST, generate as generateCSS } from 'css-tree';

frontend/node_modules/@asamuzakjp/dom-selector/types/index.d.ts

@@ -0,0 +1,14 @@
+export class DOMSelector {
+    constructor(window: Window, document: Document, opt?: object);
+    clear: () => void;
+    check: (selector: string, node: Element, opt?: object) => CheckResult;
+    matches: (selector: string, node: Element, opt?: object) => boolean;
+    closest: (selector: string, node: Element, opt?: object) => Element | null;
+    querySelector: (selector: string, node: Document | DocumentFragment | Element, opt?: object) => Element | null;
+    querySelectorAll: (selector: string, node: Document | DocumentFragment | Element, opt?: object) => Array<Element>;
+    #private;
+}
+export type CheckResult = {
+    match: boolean;
+    pseudoElement: string | null;
+};

frontend/node_modules/@asamuzakjp/dom-selector/types/js/constant.d.ts

@@ -0,0 +1,77 @@
+export const ATRULE: "Atrule";
+export const ATTR_SELECTOR: "AttributeSelector";
+export const CLASS_SELECTOR: "ClassSelector";
+export const COMBINATOR: "Combinator";
+export const IDENT: "Identifier";
+export const ID_SELECTOR: "IdSelector";
+export const NOT_SUPPORTED_ERR: "NotSupportedError";
+export const NTH: "Nth";
+export const OPERATOR: "Operator";
+export const PS_CLASS_SELECTOR: "PseudoClassSelector";
+export const PS_ELEMENT_SELECTOR: "PseudoElementSelector";
+export const RULE: "Rule";
+export const SCOPE: "Scope";
+export const SELECTOR: "Selector";
+export const SELECTOR_LIST: "SelectorList";
+export const STRING: "String";
+export const SYNTAX_ERR: "SyntaxError";
+export const TARGET_ALL: "all";
+export const TARGET_FIRST: "first";
+export const TARGET_LINEAL: "lineal";
+export const TARGET_SELF: "self";
+export const TYPE_SELECTOR: "TypeSelector";
+export const BIT_01: 1;
+export const BIT_02: 2;
+export const BIT_04: 4;
+export const BIT_08: 8;
+export const BIT_16: 16;
+export const BIT_32: 32;
+export const BIT_FFFF: 65535;
+export const DUO: 2;
+export const HEX: 16;
+export const TYPE_FROM: 8;
+export const TYPE_TO: -1;
+export const ELEMENT_NODE: 1;
+export const TEXT_NODE: 3;
+export const DOCUMENT_NODE: 9;
+export const DOCUMENT_FRAGMENT_NODE: 11;
+export const DOCUMENT_POSITION_PRECEDING: 2;
+export const DOCUMENT_POSITION_CONTAINS: 8;
+export const DOCUMENT_POSITION_CONTAINED_BY: 16;
+export const SHOW_ALL: 4294967295;
+export const SHOW_CONTAINER: 1281;
+export const SHOW_DOCUMENT: 256;
+export const SHOW_DOCUMENT_FRAGMENT: 1024;
+export const SHOW_ELEMENT: 1;
+export const ALPHA_NUM: "[A-Z\\d]+";
+export const CHILD_IDX: "(?:first|last|only)-(?:child|of-type)";
+export const DIGIT: "(?:0|[1-9]\\d*)";
+export const LANG_PART: "(?:-[A-Z\\d]+)*";
+export const PSEUDO_CLASS: "(?:any-)?link|(?:first|last|only)-(?:child|of-type)|checked|empty|indeterminate|read-(?:only|write)|target";
+export const ANB: "[+-]?(?:(?:0|[1-9]\\d*)n?|n)|(?:[+-]?(?:0|[1-9]\\d*))?n\\s*[+-]\\s*(?:0|[1-9]\\d*)";
+export const COMBO: "\\s?[\\s>~+]\\s?";
+export const DESCEND: "\\s?[\\s>]\\s?";
+export const SIBLING: "\\s?[+~]\\s?";
+export const LOGIC_IS: ":is\\(\\s*[^)]+\\s*\\)";
+export const N_TH: "nth-(?:last-)?(?:child|of-type)\\(\\s*(?:even|odd|[+-]?(?:(?:0|[1-9]\\d*)n?|n)|(?:[+-]?(?:0|[1-9]\\d*))?n\\s*[+-]\\s*(?:0|[1-9]\\d*))\\s*\\)";
+export const SUB_TYPE: "\\[[^|\\]]+\\]|[#.:][\\w-]+";
+export const SUB_TYPE_WO_PSEUDO: "\\[[^|\\]]+\\]|[#.][\\w-]+";
+export const TAG_TYPE: "\\*|[A-Za-z][\\w-]*";
+export const TAG_TYPE_I: "\\*|[A-Z][\\w-]*";
+export const COMPOUND: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)";
+export const COMPOUND_L: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)";
+export const COMPOUND_I: "(?:\\*|[A-Z][\\w-]*|(?:\\*|[A-Z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)";
+export const COMPOUND_WO_PSEUDO: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.][\\w-]+)+)";
+export const COMPLEX: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+)+))*";
+export const COMPLEX_L: "(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*";
+export const HAS_COMPOUND: "has\\([\\s>]?\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.][\\w-]+)+)\\s*\\)";
+export const LOGIC_COMPOUND: "(?:is|not)\\(\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s*,\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*\\s*\\)";
+export const LOGIC_COMPLEX: "(?:is|not)\\(\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*(?:\\s*,\\s*(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+)(?:\\s?[\\s>~+]\\s?(?:\\*|[A-Za-z][\\w-]*|(?:\\*|[A-Za-z][\\w-]*)?(?:\\[[^|\\]]+\\]|[#.:][\\w-]+|:is\\(\\s*[^)]+\\s*\\))+))*)*\\s*\\)";
+export const FORM_PARTS: readonly string[];
+export const INPUT_BUTTON: readonly string[];
+export const INPUT_CHECK: readonly string[];
+export const INPUT_DATE: readonly string[];
+export const INPUT_TEXT: readonly string[];
+export const INPUT_EDIT: readonly string[];
+export const INPUT_LTR: readonly string[];
+export const KEYS_LOGICAL: Set<string>;

frontend/node_modules/@asamuzakjp/dom-selector/types/js/finder.d.ts

@@ -0,0 +1,64 @@
+export class Finder {
+    constructor(window: object);
+    onError: (e: Error, opt?: {
+        noexcept?: boolean;
+    }) => void;
+    setup: (selector: string, node: object, opt?: {
+        check?: boolean;
+        noexcept?: boolean;
+        warn?: boolean;
+    }) => object;
+    clearResults: (all?: boolean) => void;
+    private _handleFocusEvent;
+    private _handleKeyboardEvent;
+    private _handleMouseEvent;
+    private _registerEventListeners;
+    private _processSelectorBranches;
+    private _correspond;
+    private _createTreeWalker;
+    private _getSelectorBranches;
+    private _getFilteredChildren;
+    private _collectNthChild;
+    private _collectNthOfType;
+    private _matchAnPlusB;
+    private _matchHasPseudoFunc;
+    private _evaluateHasPseudo;
+    private _matchLogicalPseudoFunc;
+    private _matchPseudoClassSelector;
+    private _evaluateHostPseudo;
+    private _evaluateHostContextPseudo;
+    private _matchShadowHostPseudoClass;
+    private _matchSelectorForElement;
+    private _matchSelectorForShadowRoot;
+    private _matchSelector;
+    private _matchLeaves;
+    private _traverseAllDescendants;
+    private _findDescendantNodes;
+    private _matchDescendantCombinator;
+    private _matchChildCombinator;
+    private _matchAdjacentSiblingCombinator;
+    private _matchGeneralSiblingCombinator;
+    private _matchCombinator;
+    private _traverseAndCollectNodes;
+    private _findPrecede;
+    private _findNodeWalker;
+    private _matchSelf;
+    private _findLineal;
+    private _findEntryNodesForPseudoElement;
+    private _findEntryNodesForId;
+    private _findEntryNodesForClass;
+    private _findEntryNodesForType;
+    private _findEntryNodesForOther;
+    private _findEntryNodes;
+    private _determineTraversalStrategy;
+    private _processPendingItems;
+    private _collectNodes;
+    private _getCombinedNodes;
+    private _matchNodeNext;
+    private _matchNodePrev;
+    private _processComplexBranchAll;
+    private _findChildNodeContainedByNode;
+    private _processComplexBranchFirst;
+    find: (targetType: string) => Set<object>;
+    #private;
+}

frontend/node_modules/@asamuzakjp/dom-selector/types/js/matcher.d.ts

@@ -0,0 +1,16 @@
+export function matchPseudoElementSelector(astName: string, astType: string, opt?: {
+    forgive?: boolean;
+    warn?: boolean;
+}): void;
+export function matchDirectionPseudoClass(ast: object, node: object): boolean;
+export function matchLanguagePseudoClass(ast: object, node: object): boolean;
+export function matchDisabledPseudoClass(astName: string, node: object): boolean;
+export function matchReadOnlyPseudoClass(astName: string, node: object): boolean;
+export function matchAttributeSelector(ast: object, node: object, opt?: {
+    check?: boolean;
+    forgive?: boolean;
+}): boolean;
+export function matchTypeSelector(ast: object, node: object, opt?: {
+    check?: boolean;
+    forgive?: boolean;
+}): boolean;

frontend/node_modules/@asamuzakjp/dom-selector/types/js/parser.d.ts

@@ -0,0 +1,14 @@
+export function unescapeSelector(selector?: string): string;
+export function preprocess(value: string): string;
+export function parseSelector(sel: string): object;
+export function walkAST(ast?: object): {
+    branches: Array<object>;
+    info: object;
+};
+export function compareASTNodes(a: object, b: object): number;
+export function sortAST(asts: Array<object>): Array<object>;
+export function parseAstName(selector: string): {
+    prefix: string;
+    localName: string;
+};
+export { find as findAST, generate as generateCSS } from "css-tree";

frontend/node_modules/@asamuzakjp/dom-selector/types/js/utility.d.ts

@@ -0,0 +1,30 @@
+export function getType(o: object): string;
+export function verifyArray(arr: any[], type: string): any[];
+export function generateException(msg: string, name: string, globalObject?: object): DOMException;
+export function findNestedHas(leaf: object): object | null;
+export function findLogicalWithNestedHas(leaf: object): object | null;
+export function filterNodesByAnB(nodes: Array<object>, anb: {
+    a: number;
+    b: number;
+    reverse?: boolean;
+}): Array<object>;
+export function resolveContent(node: object): Array<object | boolean>;
+export function traverseNode(node: object, walker: object, force?: boolean): object | null;
+export function isCustomElement(node: object, opt?: object): boolean;
+export function getSlottedTextContent(node: object): string | null;
+export function getDirectionality(node: object): string | null;
+export function getLanguageAttribute(node: object): string | null;
+export function isContentEditable(node: object): boolean;
+export function isVisible(node: object): boolean;
+export function isFocusVisible(node: object): boolean;
+export function isFocusableArea(node: object): boolean;
+export function isFocusable(node: object): boolean;
+export function getNamespaceURI(ns: string, node: object): string | null;
+export function isNamespaceDeclared(ns?: string, node?: object): boolean;
+export function isPreceding(nodeA: object, nodeB: object): boolean;
+export function compareNodes(a: object, b: object): number;
+export function sortNodes(nodes?: Array<object> | Set<object>): Array<object>;
+export function concatNestedSelectors(selectors: Array<Array<string>>): string;
+export function extractNestedSelectors(css: string): Array<Array<string>>;
+export function initNwsapi(window: object, document: object): object;
+export function filterSelector(selector: string, target: string): boolean;

frontend/node_modules/@asamuzakjp/nwsapi/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007-2019 Diego Perini (http://www.iport.it/)
+
+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.

frontend/node_modules/@asamuzakjp/nwsapi/README.md

@@ -0,0 +1,132 @@
+# [NWSAPI](http://dperini.github.io/nwsapi/)
+
+Fast CSS Selectors API Engine
+
+![](https://img.shields.io/npm/v/nwsapi.svg?colorB=orange&style=flat) ![](https://img.shields.io/github/tag/dperini/nwsapi.svg?style=flat) ![](https://img.shields.io/npm/dw/nwsapi.svg?style=flat) ![](https://img.shields.io/github/issues/dperini/nwsapi.svg?style=flat)
+
+NWSAPI is the development progress of [NWMATCHER](https://github.com/dperini/nwmatcher) aiming at [Selectors Level 4](https://www.w3.org/TR/selectors-4/) conformance. It has been completely reworked to be easily extended and maintained. It is a right-to-left selector parser and compiler written in pure Javascript with no external dependencies. It was initially thought as a cross browser library to improve event delegation and web page scraping in various frameworks but it has become a popular replacement of the native CSS selection and matching functionality in newer browsers and headless environments.
+
+It uses [regular expressions](https://en.wikipedia.org/wiki/Regular_expression) to parse CSS selector strings and [metaprogramming](https://en.wikipedia.org/wiki/Metaprogramming) to transforms these selector strings into Javascript function resolvers. This process is executed only once for each selector string allowing memoization of the function resolvers and achieving unmatched performances.
+
+## Installation
+
+To include NWSAPI in a standard web page:
+
+```html
+<script type="text/javascript" src="nwsapi.js"></script>
+```
+
+To include NWSAPI in a standard web page and automatically replace the native QSA:
+
+```html
+<script type="text/javascript" src="nwsapi.js" onload="NW.Dom.install()"></script>
+```
+
+To use NWSAPI with Node.js:
+
+```
+$ npm install nwsapi
+```
+
+NWSAPI currently supports browsers (as a global, `NW.Dom`) and headless environments (as a CommonJS module).
+
+
+## Supported Selectors
+
+Here is a list of all the CSS2/CSS3/CSS4 [Supported selectors](https://github.com/dperini/nwsapi/wiki/CSS-supported-selectors).
+
+
+## Features and Compliance
+
+You can read more about NWSAPI [features and compliance](https://github.com/dperini/nwsapi/wiki/Features-and-compliance) on the wiki.
+
+
+## API
+
+### DOM Selection
+
+#### `ancestor( selector, context, callback )`
+
+Returns a reference to the nearest ancestor element matching `selector`, starting at `context`. Returns `null` if no element is found. If `callback` is provided, it is invoked for the matched element.
+
+#### `first( selector, context, callback )`
+
+Returns a reference to the first element matching `selector`, starting at `context`. Returns `null` if no element matches. If `callback` is provided, it is invoked for the matched element.
+
+#### `match( selector, element, callback )`
+
+Returns `true` if `element` matches `selector`, starting at `context`; returns `false` otherwise. If `callback` is provided, it is invoked for the matched element.
+
+#### `select( selector, context, callback )`
+
+Returns an array of all the elements matching `selector`, starting at `context`; returns empty `Array` otherwise. If `callback` is provided, it is invoked for each matching element.
+
+
+### DOM Helpers
+
+#### `byId( id, from )`
+
+Returns a reference to the first element with ID `id`, optionally filtered to descendants of the element `from`.
+
+#### `byTag( tag, from )`
+
+Returns an array of elements having the specified tag name `tag`, optionally filtered to descendants of the element `from`.
+
+#### `byClass( class, from )`
+
+Returns an array of elements having the specified class name `class`, optionally filtered to descendants of the element `from`.
+
+
+### Engine Configuration
+
+#### `configure( options )`
+
+The following is the list of currently available configuration options, their default values and descriptions, they are boolean flags that can be set to `true` or `false`:
+
+* `IDS_DUPES`: true  - true to allow using multiple elements having the same id, false to disallow
+* `LIVECACHE`: true  - true for caching both results and resolvers, false for caching only resolvers
+* `MIXEDCASE`: true  - true to match tag names case insensitive, false to match using case sensitive
+* `LOGERRORS`: true  - true to print errors and warnings to the console, false to mute both of them
+
+
+### Examples on extending the basic functionalities
+
+#### `configure( { <configuration-flag>: [ true | false ] } )`
+
+Disable logging errors/warnings to console, disallow duplicate ids. Example:
+
+```js
+NW.Dom.configure( { LOGERRORS: false, IDS_DUPES: false } );
+```
+NOTE: NW.Dom.configure() without parameters return the current configuration.
+
+#### `registerCombinator( symbol, resolver )`
+
+Registers a new symbol and its matching resolver in the combinators table. Example:
+
+```js
+NW.Dom.registerCombinator( '^', 'e.parentElement' );
+```
+
+#### `registerOperator( symbol, resolver )`
+
+Registers a new symbol and its matching resolver in the attribute operators table. Example:
+
+```js
+NW.Dom.registerOperator( '!=', { p1: '^', p2: '$', p3: 'false' } );
+```
+
+#### `registerSelector( name, rexp, func )`
+
+Registers a new selector, the matching RE and the resolver function, in the selectors table. Example:
+
+```js
+NW.Dom.registerSelector('Controls', /^\:(control)(.*)/i,
+  (function(global) {
+    return function(match, source, mode, callback) {
+      var status = true;
+      source = 'if(/^(button|input|select|textarea)/i.test(e.nodeName)){' + source + '}';
+      return { 'source': source, 'status': status };
+    };
+  })(this));
+```

frontend/node_modules/@asamuzakjp/nwsapi/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@asamuzakjp/nwsapi",
+  "version": "2.3.9",
+  "description": "Fast CSS Selectors API Engine",
+  "homepage": "http://javascript.nwbox.com/nwsapi/",
+  "main": "./src/nwsapi",
+  "keywords": [
+    "css",
+    "css3",
+    "css4",
+    "matcher",
+    "selector"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://javascript.nwbox.com/nwsapi/MIT-LICENSE"
+    }
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Diego Perini",
+    "email": "diego.perini@gmail.com",
+    "web": "http://www.iport.it/"
+  },
+  "maintainers": [
+    {
+      "name": "Diego Perini",
+      "email": "diego.perini@gmail.com",
+      "web": "http://www.iport.it/"
+    }
+  ],
+  "bugs": {
+    "url": "http://github.com/dperini/nwsapi/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dperini/nwsapi.git"
+  },
+  "scripts": {
+    "lint": "eslint ./src/nwsapi.js"
+  }
+}