@nl-design-system-community/clippy-components 1.0.0 → 1.2.0

package/dist/index-CtreqNZ6.js

@@ -0,0 +1,3602 @@
+import { s as Er } from "./decorators-BGpMqJ7V.js";
+import { L as kr } from "./index-CaVpiaBC.js";
+import { css as $r, html as Ar, unsafeCSS as Or } from "lit";
+import { property as Pr } from "lit/decorators.js";
+import { styleMap as Ir } from "lit/directives/style-map.js";
+import { C as Y0 } from "./index-CmKtM5nD.js";
+const Hr = (t, e, r) => {
+  const n = t[e];
+  return n ? typeof n == "function" ? n() : Promise.resolve(n) : new Promise((a, s) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(s.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + e + (e.split("/").length !== r ? ". Note that variables only represent file names one level deep." : ""))));
+  });
+}, jr = ".nl-color-sample{background-image:repeating-conic-gradient(var(--nl-color-sample-background-color, hsl(0, 0%, 90%)) 0% 25%,#fff 0% 50%);background-size:.5rem .5rem;block-size:var(--nl-color-sample-block-size);border-color:var(--nl-color-sample-border-color);border-radius:var(--nl-color-sample-border-radius);border-style:solid;border-width:var(--nl-color-sample-border-width);display:inline-block;forced-color-adjust:none;inline-size:var(--nl-color-sample-inline-size);pointer-events:none}";
+function _e(t, e) {
+  let r = t.length, n, a, s = !1, i = !1;
+  Array.isArray(t[0]) ? n = /** @type {number[][]} */
+  t : (n = [
+    /** @type {number[]} */
+    t
+  ], r = n.length, s = !0), Array.isArray(e[0]) ? a = /** @type {number[][]} */
+  e : (a = e.length > 0 ? e.map((f) => [f]) : [[]], i = !0);
+  let o = a[0].length, l = a[0].map((f, u) => a.map((h) => h[u])), c = n.map((f) => l.map((u) => {
+    let h = 0;
+    if (!Array.isArray(f)) {
+      for (let m of u)
+        h += f * m;
+      return h;
+    }
+    for (let m = 0; m < f.length; m++)
+      h += f[m] * (u[m] || 0);
+    return h;
+  }));
+  return r === 1 && s && (c = c[0]), o === 1 && i ? r === 1 && s ? c[0] : c.map((f) => f[0]) : c;
+}
+function lt(t, e) {
+  return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
+}
+function x(t, e, r = [0, 0, 0]) {
+  const n = lt(t, e[0]), a = lt(t, e[1]), s = lt(t, e[2]);
+  return r[0] = n, r[1] = a, r[2] = s, r;
+}
+function ye(t) {
+  return K(t) === "string";
+}
+function K(t) {
+  return (Object.prototype.toString.call(t).match(/^\[object\s+(.*?)\]$/)[1] || "").toLowerCase();
+}
+function Et(t, { precision: e = 16, unit: r }) {
+  return L(t) ? "none" : (t = +kt(t, e), t + (r ?? ""));
+}
+function L(t) {
+  return t === null;
+}
+function z(t) {
+  return L(t) ? 0 : t;
+}
+function kt(t, e) {
+  if (t === 0)
+    return 0;
+  let r = ~~t, n = 0;
+  r && e && (n = ~~Math.log10(Math.abs(r)) + 1);
+  const a = 10 ** (e - n);
+  return Math.floor(t * a + 0.5) / a;
+}
+function Be(t, e, r) {
+  return isNaN(t) ? e : isNaN(e) ? t : t + (e - t) * r;
+}
+function N0(t, e, r) {
+  return (r - t) / (e - t);
+}
+function Ct(t, e, r) {
+  return !t || !e || t === e || t[0] === e[0] && t[1] === e[1] || isNaN(r) || r === null ? r : Be(e[0], e[1], N0(t[0], t[1], r));
+}
+function et(t, e, r) {
+  return Math.max(Math.min(r, e), t);
+}
+function tt(t, e) {
+  return Math.sign(t) === Math.sign(e) ? t : -t;
+}
+function E(t, e) {
+  return tt(Math.abs(t) ** e, t);
+}
+function $t(t, e) {
+  return e === 0 ? 0 : t / e;
+}
+function q0(t, e, r = 0, n = t.length) {
+  for (; r < n; ) {
+    const a = r + n >> 1;
+    t[a] < e ? r = a + 1 : n = a;
+  }
+  return r;
+}
+function ge(t, e) {
+  if (t instanceof e)
+    return !0;
+  const r = e.name;
+  for (; t; ) {
+    const n = Object.getPrototypeOf(t), a = n?.constructor?.name;
+    if (a === r)
+      return !0;
+    if (!a || a === "Object")
+      return !1;
+    t = n;
+  }
+  return !1;
+}
+var Dr = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  bisectLeft: q0,
+  clamp: et,
+  copySign: tt,
+  interpolate: Be,
+  interpolateInv: N0,
+  isInstance: ge,
+  isNone: L,
+  isString: ye,
+  mapRange: Ct,
+  multiplyMatrices: _e,
+  multiply_v3_m3x3: x,
+  serializeNumber: Et,
+  skipNone: z,
+  spow: E,
+  toPrecision: kt,
+  type: K,
+  zdiv: $t
+});
+class Tr {
+  add(e, r, n) {
+    if (typeof arguments[0] != "string") {
+      for (var e in arguments[0])
+        this.add(e, arguments[0][e], arguments[1]);
+      return;
+    }
+    (Array.isArray(e) ? e : [e]).forEach(function(a) {
+      this[a] = this[a] || [], r && this[a][n ? "unshift" : "push"](r);
+    }, this);
+  }
+  run(e, r) {
+    this[e] = this[e] || [], this[e].forEach(function(n) {
+      n.call(r && r.context ? r.context : r, r);
+    });
+  }
+}
+const te = new Tr();
+var N = {
+  gamut_mapping: "css",
+  precision: 5,
+  deltaE: "76",
+  // Default deltaE method
+  verbose: globalThis?.process?.env?.NODE_ENV?.toLowerCase() !== "test",
+  warn: function(e) {
+    this.verbose && globalThis?.console?.warn?.(e);
+  }
+};
+class Xt {
+  // Class properties - declared here so that type inference works
+  type;
+  coordMeta;
+  coordRange;
+  /** @type {[number, number]} */
+  range;
+  /**
+   * @param {any} type
+   * @param {import("./types.js").CoordMeta} coordMeta
+   */
+  constructor(e, r) {
+    if (typeof e == "object" && (this.coordMeta = e), r && (this.coordMeta = r, this.coordRange = r.range ?? r.refRange), typeof e == "string") {
+      let n = e.trim().match(/^(?<type><[a-z]+>)(\[(?<min>-?[.\d]+),\s*(?<max>-?[.\d]+)\])?$/);
+      if (!n)
+        throw new TypeError(`Cannot parse ${e} as a type definition.`);
+      this.type = n.groups.type;
+      let { min: a, max: s } = n.groups;
+      (a || s) && (this.range = [+a, +s]);
+    }
+  }
+  /** @returns {[number, number]} */
+  get computedRange() {
+    return this.range ? this.range : this.type === "<percentage>" ? this.percentageRange() : this.type === "<angle>" ? [0, 360] : null;
+  }
+  get unit() {
+    return this.type === "<percentage>" ? "%" : this.type === "<angle>" ? "deg" : "";
+  }
+  /**
+   * Map a number to the internal representation
+   * @param {number} number
+   */
+  resolve(e) {
+    if (this.type === "<angle>")
+      return e;
+    let r = this.computedRange, n = this.coordRange;
+    return this.type === "<percentage>" && (n ??= this.percentageRange()), Ct(r, n, e);
+  }
+  /**
+   * Serialize a number from the internal representation to a string
+   * @param {number} number
+   * @param {number} [precision]
+   */
+  serialize(e, r) {
+    let n = this.type === "<percentage>" ? this.percentageRange(100) : this.computedRange, a = this.unit;
+    return e = Ct(this.coordRange, n, e), Et(e, { unit: a, precision: r });
+  }
+  toString() {
+    let e = this.type;
+    if (this.range) {
+      let [r = "", n = ""] = this.range;
+      e += `[${r},${n}]`;
+    }
+    return e;
+  }
+  /**
+   * Returns a percentage range for values of this type
+   * @param {number} scale
+   * @returns {[number, number]}
+   */
+  percentageRange(e = 1) {
+    let r;
+    return this.coordMeta && this.coordMeta.range || this.coordRange && this.coordRange[0] >= 0 ? r = [0, 1] : r = [-1, 1], [r[0] * e, r[1] * e];
+  }
+  static get(e, r) {
+    return ge(e, this) ? e : new this(e, r);
+  }
+}
+const ct = /* @__PURE__ */ Symbol("instance");
+class Ze {
+  // Class properties - declared here so that type inference works
+  type;
+  name;
+  spaceCoords;
+  /** @type {Type[][]} */
+  coords;
+  /** @type {string | undefined} */
+  id;
+  /** @type {boolean | undefined} */
+  alpha;
+  /**
+   * @param {FormatInterface} format
+   * @param {ColorSpace} space
+   */
+  constructor(e, r = e.space) {
+    e[ct] = this, this.type = "function", this.name = "color", Object.assign(this, e), this.space = r, this.type !== "custom" && (this.spaceCoords = Object.values(r.coords), this.coords || (this.coords = this.spaceCoords.map((n) => {
+      let a = ["<number>", "<percentage>"];
+      return n.type === "angle" && a.push("<angle>"), a;
+    })), this.coords = this.coords.map(
+      /** @param {string | string[] | Type[]} types */
+      (n, a) => {
+        let s = this.spaceCoords[a];
+        return typeof n == "string" && (n = n.trim().split(/\s*\|\s*/)), n.map((i) => Xt.get(i, s));
+      }
+    ));
+  }
+  /**
+   * @param {Coords} coords
+   * @param {number} precision
+   * @param {Type[]} types
+   */
+  serializeCoords(e, r, n) {
+    return n = e.map((a, s) => Xt.get(n?.[s] ?? this.coords[s][0], this.spaceCoords[s])), e.map((a, s) => n[s].serialize(a, r));
+  }
+  /**
+   * Validates the coordinates of a color against a format's coord grammar and
+   * maps the coordinates to the range or refRange of the coordinates.
+   * @param {Coords} coords
+   * @param {[string, string, string]} types
+   */
+  coerceCoords(e, r) {
+    return Object.entries(this.space.coords).map(([n, a], s) => {
+      let i = e[s];
+      if (L(i) || isNaN(i))
+        return i;
+      let o = r[s], l = this.coords[s].find((c) => c.type == o);
+      if (!l) {
+        let c = a.name || n;
+        throw new TypeError(
+          `${o ?? /** @type {any} */
+          i?.raw ?? i} not allowed for ${c} in ${this.name}()`
+        );
+      }
+      return i = l.resolve(i), l.range && (r[s] = l.toString()), i;
+    });
+  }
+  /**
+   * @returns {boolean | Required<FormatInterface>["serialize"]}
+   */
+  canSerialize() {
+    return this.type === "function" || /** @type {any} */
+    this.serialize;
+  }
+  /**
+   * @param {string} str
+   * @returns {(import("./types.js").ColorConstructor) | undefined | null}
+   */
+  parse(e) {
+    return null;
+  }
+  /**
+   * @param {Format | FormatInterface} format
+   * @param {RemoveFirstElement<ConstructorParameters<typeof Format>>} args
+   * @returns {Format}
+   */
+  static get(e, ...r) {
+    return !e || ge(e, this) ? (
+      /** @type {Format} */
+      e
+    ) : e[ct] ? e[ct] : new Ze(e, ...r);
+  }
+}
+const P = {
+  // for compatibility, the four-digit chromaticity-derived ones everyone else uses
+  D50: [0.3457 / 0.3585, 1, (1 - 0.3457 - 0.3585) / 0.3585],
+  D65: [0.3127 / 0.329, 1, (1 - 0.3127 - 0.329) / 0.329]
+};
+function _t(t) {
+  return Array.isArray(t) ? t : P[t];
+}
+function Je(t, e, r, n = {}) {
+  if (t = _t(t), e = _t(e), !t || !e)
+    throw new TypeError(
+      `Missing white point to convert ${t ? "" : "from"}${!t && !e ? "/" : ""}${e ? "" : "to"}`
+    );
+  if (t === e)
+    return r;
+  let a = { W1: t, W2: e, XYZ: r, options: n };
+  if (te.run("chromatic-adaptation-start", a), a.M || (a.W1 === P.D65 && a.W2 === P.D50 ? a.M = [
+    [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
+    [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
+    [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
+  ] : a.W1 === P.D50 && a.W2 === P.D65 && (a.M = [
+    [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
+    [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
+    [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
+  ])), te.run("chromatic-adaptation-end", a), a.M)
+    return x(a.XYZ, a.M);
+  throw new TypeError("Only Bradford CAT with white points D50 and D65 supported for now.");
+}
+function X0(t, e) {
+  let r = {
+    str: String(t)?.trim(),
+    options: e
+  };
+  if (te.run("parse-start", r), r.color)
+    return r.color;
+  r.parsed = Nr(r.str);
+  let n, a = r.options ? r.options.parseMeta ?? r.options.meta : null;
+  if (r.parsed) {
+    let s = r.parsed.name, i, o, l = r.parsed.args, c = l.map((h, m) => r.parsed.argMeta[m]?.type);
+    if (s === "color") {
+      let h = l.shift();
+      c.shift();
+      let m = h.startsWith("--") ? h.substring(2) : `--${h}`, d = [h, m];
+      if (i = g.findFormat({ name: s, id: d, type: "function" }), !i) {
+        let M, p = h in g.registry ? h : m;
+        if (p in g.registry) {
+          let w = g.registry[p].formats?.color?.id;
+          w && (M = `Did you mean ${t.replace("color(" + h, "color(" + w)}?`);
+        }
+        throw new TypeError(
+          `Cannot parse ${r.str}. ` + (M ?? "Missing a plugin?")
+        );
+      }
+      o = i.space, i.id.startsWith("--") && !h.startsWith("--") && N.warn(
+        `${o.name} is a non-standard space and not currently supported in the CSS spec. Use prefixed color(${i.id}) instead of color(${h}).`
+      ), h.startsWith("--") && !i.id.startsWith("--") && N.warn(
+        `${o.name} is a standard space and supported in the CSS spec. Use color(${i.id}) instead of prefixed color(${h}).`
+      );
+    } else
+      i = g.findFormat({ name: s, type: "function" }), o = i.space;
+    a && Object.assign(a, {
+      format: i,
+      formatId: i.name,
+      types: c,
+      commas: r.parsed.commas
+    });
+    let f = 1;
+    r.parsed.lastAlpha && (f = r.parsed.args.pop(), a && (a.alphaType = c.pop()));
+    let u = i.coords.length;
+    if (l.length !== u)
+      throw new TypeError(
+        `Expected ${u} coordinates for ${o.id} in ${r.str}), got ${l.length}`
+      );
+    l = i.coerceCoords(l, c), n = { spaceId: o.id, coords: l, alpha: f };
+  } else
+    e: for (let s of g.all)
+      for (let i in s.formats) {
+        let o = s.formats[i];
+        if (o.type !== "custom" || o.test && !o.test(r.str))
+          continue;
+        let l = s.getFormat(o), c = l.parse(r.str);
+        if (c) {
+          a && Object.assign(a, { format: l, formatId: i }), n = c;
+          break e;
+        }
+      }
+  if (!n)
+    throw new TypeError(`Could not parse ${t} as a color. Missing a plugin?`);
+  return n.alpha = L(n.alpha) ? n.alpha : n.alpha === void 0 ? 1 : et(0, n.alpha, 1), n;
+}
+const G0 = {
+  "%": 0.01,
+  deg: 1,
+  grad: 0.9,
+  rad: 180 / Math.PI,
+  turn: 360
+}, We = {
+  // Need to list calc(NaN) explicitly as otherwise its ending paren would terminate the function call
+  function: /^([a-z]+)\(((?:calc\(NaN\)|.)+?)\)$/i,
+  number: /^([-+]?(?:[0-9]*\.)?[0-9]+(e[-+]?[0-9]+)?)$/i,
+  unitValue: RegExp(`(${Object.keys(G0).join("|")})$`),
+  // NOTE The -+ are not just for prefix, but also for idents, and e+N notation!
+  singleArgument: /\/?\s*(none|NaN|calc\(NaN\)|[-+\w.]+(?:%|deg|g?rad|turn)?)/g
+};
+function Yr(t) {
+  let e = {}, r = t.match(We.unitValue)?.[0], n = e.raw = t;
+  return r ? (e.type = r === "%" ? "<percentage>" : "<angle>", e.unit = r, e.unitless = Number(n.slice(0, -r.length)), n = e.unitless * G0[r]) : We.number.test(n) ? (n = Number(n), e.type = "<number>") : n === "none" ? n = null : n === "NaN" || n === "calc(NaN)" ? (n = NaN, e.type = "<number>") : e.type = "<ident>", { value: (
+    /** @type {number} */
+    n
+  ), meta: (
+    /** @type {ArgumentMeta} */
+    e
+  ) };
+}
+function Nr(t) {
+  if (!t)
+    return;
+  t = t.trim();
+  let e = t.match(We.function);
+  if (e) {
+    let r = [], n = [], a = !1, s = e[1].toLowerCase(), i = e[2].replace(We.singleArgument, (o, l) => {
+      let { value: c, meta: f } = Yr(l);
+      return (
+        // If there's a slash here, it's modern syntax
+        (o.startsWith("/") || // If there's still elements to process after there's already 3 in `args` (and the we're not dealing with "color()"), it's likely to be a legacy color like "hsl(0, 0%, 0%, 0.5)"
+        s !== "color" && r.length === 3) && (a = !0), r.push(c), n.push(f), ""
+      );
+    });
+    return {
+      name: s,
+      args: r,
+      argMeta: n,
+      lastAlpha: a,
+      commas: i.includes(","),
+      rawName: e[1],
+      rawArgs: e[2]
+    };
+  }
+}
+function C(t, e) {
+  if (Array.isArray(t))
+    return t.map((n) => C(n, e));
+  if (!t)
+    throw new TypeError("Empty color reference");
+  ye(t) && (t = X0(t, e));
+  let r = t.space || t.spaceId;
+  return typeof r == "string" && (t.space = g.get(r)), t.alpha === void 0 && (t.alpha = 1), t;
+}
+const qr = 75e-6;
+class g {
+  constructor(e) {
+    this.id = e.id, this.name = e.name, this.base = e.base ? g.get(e.base) : null, this.aliases = e.aliases, this.base && (this.fromBase = e.fromBase, this.toBase = e.toBase);
+    let r = e.coords ?? this.base.coords;
+    for (let a in r)
+      "name" in r[a] || (r[a].name = a);
+    this.coords = r;
+    let n = e.white ?? this.base.white ?? "D65";
+    this.white = _t(n), this.formats = e.formats ?? {};
+    for (let a in this.formats) {
+      let s = this.formats[a];
+      s.type ||= "function", s.name ||= a;
+    }
+    this.formats.color?.id || (this.formats.color = {
+      ...this.formats.color ?? {},
+      id: e.cssId || this.id
+    }), e.gamutSpace ? this.gamutSpace = e.gamutSpace === "self" ? this : g.get(e.gamutSpace) : this.isPolar ? this.gamutSpace = this.base : this.gamutSpace = this, this.gamutSpace.isUnbounded && (this.inGamut = (a, s) => !0), this.referred = e.referred, Object.defineProperty(this, "path", {
+      value: Xr(this).reverse(),
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    }), te.run("colorspace-init-end", this);
+  }
+  inGamut(e, { epsilon: r = qr } = {}) {
+    if (!this.equals(this.gamutSpace))
+      return e = this.to(this.gamutSpace, e), this.gamutSpace.inGamut(e, { epsilon: r });
+    let n = Object.values(this.coords);
+    return e.every((a, s) => {
+      let i = n[s];
+      if (i.type !== "angle" && i.range) {
+        if (L(a))
+          return !0;
+        let [o, l] = i.range;
+        return (o === void 0 || a >= o - r) && (l === void 0 || a <= l + r);
+      }
+      return !0;
+    });
+  }
+  get isUnbounded() {
+    return Object.values(this.coords).every((e) => !("range" in e));
+  }
+  get cssId() {
+    return this.formats?.color?.id || this.id;
+  }
+  get isPolar() {
+    for (let e in this.coords)
+      if (this.coords[e].type === "angle")
+        return !0;
+    return !1;
+  }
+  /**
+   * Lookup a format in this color space
+   * @param {string | object | Format} format - Format id if string. If object, it's converted to a `Format` object and returned.
+   * @returns {Format}
+   */
+  getFormat(e) {
+    if (!e)
+      return null;
+    e === "default" ? e = Object.values(this.formats)[0] : typeof e == "string" && (e = this.formats[e]);
+    let r = Ze.get(e, this);
+    return r !== e && e.name in this.formats && (this.formats[e.name] = r), r;
+  }
+  /**
+   * Check if this color space is the same as another color space reference.
+   * Allows proxying color space objects and comparing color spaces with ids.
+   * @param {string | ColorSpace} space ColorSpace object or id to compare to
+   * @returns {boolean}
+   */
+  equals(e) {
+    return e ? this === e || this.id === e || this.id === e.id : !1;
+  }
+  to(e, r) {
+    if (arguments.length === 1) {
+      const o = C(e);
+      [e, r] = [o.space, o.coords];
+    }
+    if (e = g.get(e), this.equals(e))
+      return r;
+    r = r.map((o) => L(o) ? 0 : o);
+    let n = this.path, a = e.path, s, i;
+    for (let o = 0; o < n.length && n[o].equals(a[o]); o++)
+      s = n[o], i = o;
+    if (!s)
+      throw new Error(
+        `Cannot convert between color spaces ${this} and ${e}: no connection space was found`
+      );
+    for (let o = n.length - 1; o > i; o--)
+      r = n[o].toBase(r);
+    for (let o = i + 1; o < a.length; o++)
+      r = a[o].fromBase(r);
+    return r;
+  }
+  from(e, r) {
+    if (arguments.length === 1) {
+      const n = C(e);
+      [e, r] = [n.space, n.coords];
+    }
+    return e = g.get(e), e.to(this, r);
+  }
+  toString() {
+    return `${this.name} (${this.id})`;
+  }
+  getMinCoords() {
+    let e = [];
+    for (let r in this.coords) {
+      let n = this.coords[r], a = n.range || n.refRange;
+      e.push(a?.min ?? 0);
+    }
+    return e;
+  }
+  static registry = {};
+  // Returns array of unique color spaces
+  static get all() {
+    return [...new Set(Object.values(g.registry))];
+  }
+  static register(e, r) {
+    if (arguments.length === 1 && (r = arguments[0], e = r.id), r = this.get(r), this.registry[e] && this.registry[e] !== r)
+      throw new Error(`Duplicate color space registration: '${e}'`);
+    if (this.registry[e] = r, arguments.length === 1 && r.aliases)
+      for (let n of r.aliases)
+        this.register(n, r);
+    return r;
+  }
+  /**
+   * Lookup ColorSpace object by name
+   * @param {ColorSpace | string} name
+   */
+  static get(e, ...r) {
+    if (!e || ge(e, this))
+      return e;
+    if (K(e) === "string") {
+      let a = g.registry[e.toLowerCase()];
+      if (!a)
+        throw new TypeError(`No color space found with id = "${e}"`);
+      return a;
+    }
+    if (r.length)
+      return g.get(...r);
+    throw new TypeError(`${e} is not a valid color space`);
+  }
+  /**
+   * Look up all color spaces for a format that matches certain criteria
+   * @param {object | string} filters
+   * @param {Array<ColorSpace>} [spaces=ColorSpace.all]
+   * @returns {Format | null}
+   */
+  static findFormat(e, r = g.all) {
+    if (!e)
+      return null;
+    typeof e == "string" && (e = { name: e });
+    for (let n of r)
+      for (let [a, s] of Object.entries(n.formats)) {
+        s.name ??= a, s.type ??= "function";
+        let i = (!e.name || s.name === e.name) && (!e.type || s.type === e.type);
+        if (e.id) {
+          let o = s.ids || [s.id], l = Array.isArray(e.id) ? e.id : [e.id];
+          i &&= l.some((c) => o.includes(c));
+        }
+        if (i) {
+          let o = Ze.get(s, n);
+          return o !== s && (n.formats[s.name] = o), o;
+        }
+      }
+    return null;
+  }
+  /**
+   * Get metadata about a coordinate of a color space
+   *
+   * @static
+   * @param {Array | string} ref
+   * @param {ColorSpace | string} [workingSpace]
+   * @return {Object}
+   */
+  static resolveCoord(e, r) {
+    let n = K(e), a, s;
+    if (n === "string" ? e.includes(".") ? [a, s] = e.split(".") : [a, s] = [, e] : Array.isArray(e) ? [a, s] = e : (a = e.space, s = e.coordId), a = g.get(a), a || (a = r), !a)
+      throw new TypeError(
+        `Cannot resolve coordinate reference ${e}: No color space specified and relative references are not allowed here`
+      );
+    if (n = K(s), n === "number" || n === "string" && s >= 0) {
+      let l = Object.entries(a.coords)[s];
+      if (l)
+        return { space: a, id: l[0], index: s, ...l[1] };
+    }
+    a = g.get(a);
+    let i = s.toLowerCase(), o = 0;
+    for (let l in a.coords) {
+      let c = a.coords[l];
+      if (l.toLowerCase() === i || c.name?.toLowerCase() === i)
+        return { space: a, id: l, index: o, ...c };
+      o++;
+    }
+    throw new TypeError(
+      `No "${s}" coordinate found in ${a.name}. Its coordinates are: ${Object.keys(a.coords).join(", ")}`
+    );
+  }
+  static DEFAULT_FORMAT = {
+    type: "functions",
+    name: "color"
+  };
+}
+function Xr(t) {
+  let e = [t];
+  for (let r = t; r = r.base; )
+    e.push(r);
+  return e;
+}
+var A = new g({
+  id: "xyz-d65",
+  name: "XYZ D65",
+  coords: {
+    x: {
+      refRange: [0, 1],
+      name: "X"
+    },
+    y: {
+      refRange: [0, 1],
+      name: "Y"
+    },
+    z: {
+      refRange: [0, 1],
+      name: "Z"
+    }
+  },
+  white: "D65",
+  formats: {
+    color: {
+      ids: ["xyz-d65", "xyz"]
+    }
+  },
+  aliases: ["xyz"]
+});
+class O extends g {
+  /**
+   * Creates a new RGB ColorSpace.
+   * If coords are not specified, they will use the default RGB coords.
+   * Instead of `fromBase()` and `toBase()` functions,
+   * you can specify to/from XYZ matrices and have `toBase()` and `fromBase()` automatically generated.
+   * @param {RGBOptions} options
+   */
+  constructor(e) {
+    e.coords || (e.coords = {
+      r: {
+        range: [0, 1],
+        name: "Red"
+      },
+      g: {
+        range: [0, 1],
+        name: "Green"
+      },
+      b: {
+        range: [0, 1],
+        name: "Blue"
+      }
+    }), e.base || (e.base = A), e.toXYZ_M && e.fromXYZ_M && (e.toBase ??= (r) => {
+      let n = x(r, e.toXYZ_M);
+      return this.white !== this.base.white && (n = Je(this.white, this.base.white, n)), n;
+    }, e.fromBase ??= (r) => (r = Je(this.base.white, this.white, r), x(r, e.fromXYZ_M))), e.referred ??= "display", super(e);
+  }
+}
+function Z0(t, e = {}) {
+  if (Array.isArray(t))
+    return t.map((l) => Z0(l, e));
+  let { cssProperty: r = "background-color", element: n, ...a } = e, s = null;
+  try {
+    return C(t, a);
+  } catch (l) {
+    s = l;
+  }
+  let { CSS: i, getComputedStyle: o } = globalThis;
+  if (ye(t) && n && i && o && i.supports(r, t)) {
+    let l = n.style[r];
+    t !== l && (n.style[r] = t);
+    let c = o(n).getPropertyValue(r);
+    if (t !== l && (n.style[r] = l), c !== t)
+      try {
+        return C(c, a);
+      } catch (f) {
+        s = f;
+      }
+    else
+      s = {
+        message: "Color value is a valid CSS color, but it could not be resolved :("
+      };
+  }
+  return e.errorMeta && (e.errorMeta.error = s), null;
+}
+function ke(t, e) {
+  t = C(t);
+  let r = g.get(e, e?.space), n = e?.precision, a;
+  return !r || t.space.equals(r) ? a = t.coords.slice() : a = r.from(t), n === void 0 ? a : a.map((s) => kt(s, n));
+}
+function T(t, e) {
+  if (t = C(t), e === "alpha")
+    return t.alpha ?? 1;
+  let { space: r, index: n } = g.resolveCoord(e, t.space);
+  return ke(t, r)[n];
+}
+function At(t, e, r, n) {
+  return t = C(t), Array.isArray(e) && ([e, r, n] = [t.space, e, r]), e = g.get(e), t.coords = e === t.space ? r.slice() : e.to(t.space, r), n !== void 0 && (t.alpha = n), t;
+}
+At.returns = "color";
+function F(t, e, r) {
+  if (t = C(t), arguments.length === 2 && K(arguments[1]) === "object") {
+    let n = arguments[1];
+    for (let a in n)
+      F(t, a, n[a]);
+  } else if (typeof r == "function" && (r = r(T(t, e))), e === "alpha")
+    t.alpha = r;
+  else {
+    let { space: n, index: a } = g.resolveCoord(e, t.space), s = ke(t, n);
+    s[a] = r, At(t, n, s);
+  }
+  return t;
+}
+F.returns = "color";
+var Ot = new g({
+  id: "xyz-d50",
+  name: "XYZ D50",
+  white: "D50",
+  base: A,
+  fromBase: (t) => Je(A.white, "D50", t),
+  toBase: (t) => Je("D50", A.white, t)
+});
+const Gr = 216 / 24389, Gt = 24 / 116, Ie = 24389 / 27;
+let ut = P.D50;
+var Y = new g({
+  id: "lab",
+  name: "Lab",
+  coords: {
+    l: {
+      refRange: [0, 100],
+      name: "Lightness"
+    },
+    a: {
+      refRange: [-125, 125]
+    },
+    b: {
+      refRange: [-125, 125]
+    }
+  },
+  // Assuming XYZ is relative to D50, convert to CIE Lab
+  // from CIE standard, which now defines these as a rational fraction
+  white: ut,
+  base: Ot,
+  // Convert D50-adapted XYX to Lab
+  // CIE 15.3:2004 section 8.2.1.1
+  fromBase(t) {
+    let r = t.map((i, o) => i / ut[o]).map((i) => i > Gr ? Math.cbrt(i) : (Ie * i + 16) / 116), n = 116 * r[1] - 16, a = 500 * (r[0] - r[1]), s = 200 * (r[1] - r[2]);
+    return [n, a, s];
+  },
+  // Convert Lab to D50-adapted XYZ
+  // Same result as CIE 15.3:2004 Appendix D although the derivation is different
+  // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+  toBase(t) {
+    let [e, r, n] = t, a = [];
+    return a[1] = (e + 16) / 116, a[0] = r / 500 + a[1], a[2] = a[1] - n / 200, [
+      a[0] > Gt ? Math.pow(a[0], 3) : (116 * a[0] - 16) / Ie,
+      t[0] > 8 ? Math.pow((t[0] + 16) / 116, 3) : t[0] / Ie,
+      a[2] > Gt ? Math.pow(a[2], 3) : (116 * a[2] - 16) / Ie
+    ].map((i, o) => i * ut[o]);
+  },
+  formats: {
+    lab: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+});
+function X(t) {
+  return typeof t != "number" ? t : (t % 360 + 360) % 360;
+}
+function J0(t, e) {
+  let [r, n] = e, a = L(r), s = L(n);
+  if (a && s)
+    return [r, n];
+  if (a ? r = n : s && (n = r), t === "raw")
+    return e;
+  r = X(r), n = X(n);
+  let i = n - r;
+  return t === "increasing" ? i < 0 && (n += 360) : t === "decreasing" ? i > 0 && (r += 360) : t === "longer" ? -180 < i && i < 180 && (i > 0 ? r += 360 : n += 360) : t === "shorter" && (i > 180 ? r += 360 : i < -180 && (n += 360)), [r, n];
+}
+var q = new g({
+  id: "lch",
+  name: "LCH",
+  coords: {
+    l: {
+      refRange: [0, 100],
+      name: "Lightness"
+    },
+    c: {
+      refRange: [0, 150],
+      name: "Chroma"
+    },
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  base: Y,
+  fromBase(t) {
+    if (this.ε === void 0) {
+      let o = Object.values(this.base.coords)[1].refRange, l = o[1] - o[0];
+      this.ε = l / 1e5;
+    }
+    let [e, r, n] = t, a = Math.abs(r) < this.ε && Math.abs(n) < this.ε, s = a ? null : X(Math.atan2(n, r) * 180 / Math.PI), i = a ? 0 : Math.sqrt(r ** 2 + n ** 2);
+    return [e, i, s];
+  },
+  toBase(t) {
+    let [e, r, n] = t, a = null, s = null;
+    return L(n) || (r = r < 0 ? 0 : r, a = r * Math.cos(n * Math.PI / 180), s = r * Math.sin(n * Math.PI / 180)), [e, a, s];
+  },
+  formats: {
+    lch: {
+      coords: ["<percentage> | <number>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+const Zt = 25 ** 7, Fe = Math.PI, Jt = 180 / Fe, ue = Fe / 180;
+function Wt(t) {
+  const e = t * t;
+  return e * e * e * t;
+}
+function W0(t, e, { kL: r = 1, kC: n = 1, kH: a = 1 } = {}) {
+  [t, e] = C([t, e]);
+  let [s, i, o] = Y.from(t), l = q.from(Y, [s, i, o])[1], [c, f, u] = Y.from(e), h = q.from(Y, [c, f, u])[1];
+  l < 0 && (l = 0), h < 0 && (h = 0);
+  let m = (l + h) / 2, d = Wt(m), M = 0.5 * (1 - Math.sqrt(d / (d + Zt))), p = (1 + M) * i, w = (1 + M) * f, b = Math.sqrt(p ** 2 + o ** 2), y = Math.sqrt(w ** 2 + u ** 2), _ = p === 0 && o === 0 ? 0 : Math.atan2(o, p), S = w === 0 && u === 0 ? 0 : Math.atan2(u, w);
+  _ < 0 && (_ += 2 * Fe), S < 0 && (S += 2 * Fe), _ *= Jt, S *= Jt;
+  let I = c - s, H = y - b, B = S - _, j = _ + S, Q = Math.abs(B), G;
+  b * y === 0 ? G = 0 : Q <= 180 ? G = B : B > 180 ? G = B - 360 : B < -180 ? G = B + 360 : N.warn("the unthinkable has happened");
+  let J = 2 * Math.sqrt(y * b) * Math.sin(G * ue / 2), U = (s + c) / 2, W = (b + y) / 2, we = Wt(W), D;
+  b * y === 0 ? D = j : Q <= 180 ? D = j / 2 : j < 360 ? D = (j + 360) / 2 : D = (j - 360) / 2;
+  let Ae = (U - 50) ** 2, Oe = 1 + 0.015 * Ae / Math.sqrt(20 + Ae), le = 1 + 0.045 * W, V = 1;
+  V -= 0.17 * Math.cos((D - 30) * ue), V += 0.24 * Math.cos(2 * D * ue), V += 0.32 * Math.cos((3 * D + 6) * ue), V -= 0.2 * Math.cos((4 * D - 63) * ue);
+  let ce = 1 + 0.015 * W * V, st = 30 * Math.exp(-1 * ((D - 275) / 25) ** 2), Pe = 2 * Math.sqrt(we / (we + Zt)), Ce = -1 * Math.sin(2 * st * ue) * Pe, ae = (I / (r * Oe)) ** 2;
+  return ae += (H / (n * le)) ** 2, ae += (J / (a * ce)) ** 2, ae += Ce * (H / (n * le)) * (J / (a * ce)), Math.sqrt(ae);
+}
+const Zr = [
+  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
+  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
+  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
+], Jr = [
+  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
+  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+], Wr = [
+  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
+  [1.9779985324311684, -2.42859224204858, 0.450593709617411],
+  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
+], ee = [
+  [1, 0.3963377773761749, 0.2158037573099136],
+  [1, -0.1055613458156586, -0.0638541728258133],
+  [1, -0.0894841775298119, -1.2914855480194092]
+];
+var Z = new g({
+  id: "oklab",
+  name: "Oklab",
+  coords: {
+    l: {
+      refRange: [0, 1],
+      name: "Lightness"
+    },
+    a: {
+      refRange: [-0.4, 0.4]
+    },
+    b: {
+      refRange: [-0.4, 0.4]
+    }
+  },
+  // Note that XYZ is relative to D65
+  white: "D65",
+  base: A,
+  fromBase(t) {
+    let e = x(t, Zr);
+    return e[0] = Math.cbrt(e[0]), e[1] = Math.cbrt(e[1]), e[2] = Math.cbrt(e[2]), x(e, Wr, e);
+  },
+  toBase(t) {
+    let e = x(t, ee);
+    return e[0] = e[0] ** 3, e[1] = e[1] ** 3, e[2] = e[2] ** 3, x(e, Jr, e);
+  },
+  formats: {
+    oklab: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+});
+function Lt(t, e) {
+  [t, e] = C([t, e]);
+  let [r, n, a] = Z.from(t), [s, i, o] = Z.from(e), l = r - s, c = n - i, f = a - o;
+  return Math.sqrt(l ** 2 + c ** 2 + f ** 2);
+}
+const Fr = 75e-6;
+function ie(t, e, { epsilon: r = Fr } = {}) {
+  t = C(t), e || (e = t.space), e = g.get(e);
+  let n = t.coords;
+  return e !== t.space && (n = e.from(t)), e.inGamut(n, { epsilon: r });
+}
+function pe(t) {
+  return {
+    space: t.space,
+    coords: (
+      /** @type {Coords} */
+      t.coords.slice()
+    ),
+    alpha: t.alpha
+  };
+}
+function F0(t, e, r = "lab") {
+  r = g.get(r);
+  let n = r.from(t), a = r.from(e);
+  return Math.sqrt(
+    n.reduce((s, i, o) => {
+      let l = a[o];
+      return L(i) || L(l) ? s : s + (l - i) ** 2;
+    }, 0)
+  );
+}
+function Qr(t, e) {
+  return F0(t, e, "lab");
+}
+const Ur = Math.PI, Ft = Ur / 180;
+function Vr(t, e, { l: r = 2, c: n = 1 } = {}) {
+  [t, e] = C([t, e]);
+  let [a, s, i] = Y.from(t), [, o, l] = q.from(Y, [a, s, i]), [c, f, u] = Y.from(e), h = q.from(Y, [c, f, u])[1];
+  o < 0 && (o = 0), h < 0 && (h = 0);
+  let m = a - c, d = o - h, M = s - f, p = i - u, w = M ** 2 + p ** 2 - d ** 2, b = 0.511;
+  a >= 16 && (b = 0.040975 * a / (1 + 0.01765 * a));
+  let y = 0.0638 * o / (1 + 0.0131 * o) + 0.638, _;
+  L(l) && (l = 0), l >= 164 && l <= 345 ? _ = 0.56 + Math.abs(0.2 * Math.cos((l + 168) * Ft)) : _ = 0.36 + Math.abs(0.4 * Math.cos((l + 35) * Ft));
+  let S = Math.pow(o, 4), I = Math.sqrt(S / (S + 1900)), H = y * (I * _ + 1 - I), B = (m / (r * b)) ** 2;
+  return B += (d / (n * y)) ** 2, B += w / H ** 2, Math.sqrt(B);
+}
+const Qt = 203;
+var Pt = new g({
+  // Absolute CIE XYZ, with a D65 whitepoint,
+  // as used in most HDR colorspaces as a starting point.
+  // SDR spaces are converted per BT.2048
+  // so that diffuse, media white is 203 cd/m²
+  id: "xyz-abs-d65",
+  cssId: "--xyz-abs-d65",
+  name: "Absolute XYZ D65",
+  coords: {
+    x: {
+      refRange: [0, 9504.7],
+      name: "Xa"
+    },
+    y: {
+      refRange: [0, 1e4],
+      name: "Ya"
+    },
+    z: {
+      refRange: [0, 10888.3],
+      name: "Za"
+    }
+  },
+  base: A,
+  fromBase(t) {
+    return t.map((e) => e * Qt);
+  },
+  toBase(t) {
+    return t.map((e) => e / Qt);
+  }
+});
+const He = 1.15, je = 0.66, Ut = 2610 / 2 ** 14, Kr = 2 ** 14 / 2610, Vt = 3424 / 2 ** 12, Kt = 2413 / 2 ** 7, e0 = 2392 / 2 ** 7, en = 1.7 * 2523 / 2 ** 5, t0 = 2 ** 5 / (1.7 * 2523), De = -0.56, ft = 16295499532821565e-27, tn = [
+  [0.41478972, 0.579999, 0.014648],
+  [-0.20151, 1.120649, 0.0531008],
+  [-0.0166008, 0.2648, 0.6684799]
+], rn = [
+  [1.9242264357876067, -1.0047923125953657, 0.037651404030618],
+  [0.35031676209499907, 0.7264811939316552, -0.06538442294808501],
+  [-0.09098281098284752, -0.3127282905230739, 1.5227665613052603]
+], nn = [
+  [0.5, 0.5, 0],
+  [3.524, -4.066708, 0.542708],
+  [0.199076, 1.096799, -1.295875]
+], an = [
+  [1, 0.13860504327153927, 0.05804731615611883],
+  [1, -0.1386050432715393, -0.058047316156118904],
+  [1, -0.09601924202631895, -0.811891896056039]
+];
+var Q0 = new g({
+  id: "jzazbz",
+  name: "Jzazbz",
+  coords: {
+    jz: {
+      refRange: [0, 1],
+      name: "Jz"
+    },
+    az: {
+      refRange: [-0.21, 0.21]
+    },
+    bz: {
+      refRange: [-0.21, 0.21]
+    }
+  },
+  base: Pt,
+  fromBase(t) {
+    let [e, r, n] = t, a = He * e - (He - 1) * n, s = je * r - (je - 1) * e, o = (
+      /** @type {Vector3} } */
+      x([a, s, n], tn).map(function(h) {
+        let m = Vt + Kt * E(h / 1e4, Ut), d = 1 + e0 * E(h / 1e4, Ut);
+        return E(m / d, en);
+      })
+    ), [l, c, f] = x(o, nn);
+    return [(1 + De) * l / (1 + De * l) - ft, c, f];
+  },
+  toBase(t) {
+    let [e, r, n] = t, a = (e + ft) / (1 + De - De * (e + ft)), i = (
+      /** @type {Vector3} } */
+      x([a, r, n], an).map(function(h) {
+        let m = Vt - E(h, t0), d = e0 * E(h, t0) - Kt;
+        return 1e4 * E(m / d, Kr);
+      })
+    ), [o, l, c] = x(i, rn), f = (o + (He - 1) * c) / He, u = (l + (je - 1) * f) / je;
+    return [f, u, c];
+  },
+  formats: {
+    // https://drafts.csswg.org/css-color-hdr/#Jzazbz
+    jzazbz: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+}), Rt = new g({
+  id: "jzczhz",
+  name: "JzCzHz",
+  coords: {
+    jz: {
+      refRange: [0, 1],
+      name: "Jz"
+    },
+    cz: {
+      refRange: [0, 0.26],
+      name: "Chroma"
+    },
+    hz: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  base: Q0,
+  fromBase: q.fromBase,
+  toBase: q.toBase,
+  formats: {
+    // https://drafts.csswg.org/css-color-hdr/#JzCzhz
+    jzczhz: {
+      coords: ["<percentage> | <number>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+function sn(t, e) {
+  [t, e] = C([t, e]);
+  let [r, n, a] = Rt.from(t), [s, i, o] = Rt.from(e), l = r - s, c = n - i;
+  L(a) && L(o) ? (a = 0, o = 0) : L(a) ? a = o : L(o) && (o = a);
+  let f = a - o, u = 2 * Math.sqrt(n * i) * Math.sin(f / 2 * (Math.PI / 180));
+  return Math.sqrt(l ** 2 + c ** 2 + u ** 2);
+}
+const U0 = 3424 / 4096, V0 = 2413 / 128, K0 = 2392 / 128, r0 = 2610 / 16384, on = 2523 / 32, ln = 16384 / 2610, n0 = 32 / 2523, cn = [
+  [0.3592832590121217, 0.6976051147779502, -0.035891593232029],
+  [-0.1920808463704993, 1.100476797037432, 0.0753748658519118],
+  [0.0070797844607479, 0.0748396662186362, 0.8433265453898765]
+], un = [
+  [2048 / 4096, 2048 / 4096, 0],
+  [6610 / 4096, -13613 / 4096, 7003 / 4096],
+  [17933 / 4096, -17390 / 4096, -543 / 4096]
+], fn = [
+  [0.9999999999999998, 0.0086090370379328, 0.111029625003026],
+  [0.9999999999999998, -0.0086090370379328, -0.1110296250030259],
+  [0.9999999999999998, 0.5600313357106791, -0.3206271749873188]
+], hn = [
+  [2.0701522183894223, -1.3263473389671563, 0.2066510476294053],
+  [0.3647385209748072, 0.6805660249472273, -0.0453045459220347],
+  [-0.0497472075358123, -0.0492609666966131, 1.1880659249923042]
+];
+var vt = new g({
+  id: "ictcp",
+  name: "ICTCP",
+  // From BT.2100-2 page 7:
+  // During production, signal values are expected to exceed the
+  // range E′ = [0.0 : 1.0]. This provides processing headroom and avoids
+  // signal degradation during cascaded processing. Such values of E′,
+  // below 0.0 or exceeding 1.0, should not be clipped during production
+  // and exchange.
+  // Values below 0.0 should not be clipped in reference displays (even
+  // though they represent “negative” light) to allow the black level of
+  // the signal (LB) to be properly set using test signals known as “PLUGE”
+  coords: {
+    i: {
+      refRange: [0, 1],
+      // Constant luminance,
+      name: "I"
+    },
+    ct: {
+      refRange: [-0.5, 0.5],
+      // Full BT.2020 gamut in range [-0.5, 0.5]
+      name: "CT"
+    },
+    cp: {
+      refRange: [-0.5, 0.5],
+      name: "CP"
+    }
+  },
+  base: Pt,
+  fromBase(t) {
+    let e = x(t, cn);
+    return mn(e);
+  },
+  toBase(t) {
+    let e = dn(t);
+    return x(e, hn);
+  },
+  formats: {
+    ictcp: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+});
+function mn(t) {
+  let e = (
+    /** @type {Vector3} */
+    t.map(function(r) {
+      let n = U0 + V0 * (r / 1e4) ** r0, a = 1 + K0 * (r / 1e4) ** r0;
+      return (n / a) ** on;
+    })
+  );
+  return x(e, un);
+}
+function dn(t) {
+  return (
+    /** @type {Vector3} */
+    x(t, fn).map(function(n) {
+      let a = Math.max(n ** n0 - U0, 0), s = V0 - K0 * n ** n0;
+      return 1e4 * (a / s) ** ln;
+    })
+  );
+}
+function gn(t, e) {
+  [t, e] = C([t, e]);
+  let [r, n, a] = vt.from(t), [s, i, o] = vt.from(e);
+  return 720 * Math.sqrt((r - s) ** 2 + 0.25 * (n - i) ** 2 + (a - o) ** 2);
+}
+function pn(t, e) {
+  [t, e] = C([t, e]);
+  let r = 2, [n, a, s] = Z.from(t), [i, o, l] = Z.from(e), c = n - i, f = r * (a - o), u = r * (s - l);
+  return Math.sqrt(c ** 2 + f ** 2 + u ** 2);
+}
+const bn = P.D65, er = 0.42, a0 = 1 / er, ht = 2 * Math.PI, tr = [
+  [0.401288, 0.650173, -0.051461],
+  [-0.250268, 1.204414, 0.045854],
+  [-2079e-6, 0.048952, 0.953127]
+], Mn = [
+  [1.8620678550872327, -1.0112546305316843, 0.14918677544445175],
+  [0.38752654323613717, 0.6214474419314753, -0.008973985167612518],
+  [-0.015841498849333856, -0.03412293802851557, 1.0499644368778496]
+], yn = [
+  [460, 451, 288],
+  [460, -891, -261],
+  [460, -220, -6300]
+], wn = {
+  dark: [0.8, 0.525, 0.8],
+  dim: [0.9, 0.59, 0.9],
+  average: [1, 0.69, 1]
+}, se = {
+  // Red, Yellow, Green, Blue, Red
+  h: [20.14, 90, 164.25, 237.53, 380.14],
+  e: [0.8, 0.7, 1, 1.2, 0.8],
+  H: [0, 100, 200, 300, 400]
+}, Cn = 180 / Math.PI, s0 = Math.PI / 180;
+function rr(t, e) {
+  return (
+    /** @type {[number, number, number]} */
+    t.map((n) => {
+      const a = E(e * Math.abs(n) * 0.01, er);
+      return 400 * tt(a, n) / (a + 27.13);
+    })
+  );
+}
+function _n(t, e) {
+  const r = 100 / e * 27.13 ** a0;
+  return (
+    /** @type {[number, number, number]} */
+    t.map((n) => {
+      const a = Math.abs(n);
+      return tt(r * E(a / (400 - a), a0), n);
+    })
+  );
+}
+function Ln(t) {
+  let e = X(t);
+  e <= se.h[0] && (e += 360);
+  const r = q0(se.h, e) - 1, [n, a] = se.h.slice(r, r + 2), [s, i] = se.e.slice(r, r + 2), o = se.H[r], l = (e - n) / s;
+  return o + 100 * l / (l + (a - e) / i);
+}
+function Rn(t) {
+  let e = (t % 400 + 400) % 400;
+  const r = Math.floor(0.01 * e);
+  e = e % 100;
+  const [n, a] = se.h.slice(r, r + 2), [s, i] = se.e.slice(r, r + 2);
+  return X((e * (i * n - s * a) - 100 * n * i) / (e * (i - s) - 100 * i));
+}
+function nr(t, e, r, n, a) {
+  const s = {};
+  s.discounting = a, s.refWhite = t, s.surround = n;
+  const i = (
+    /** @type {Vector3} */
+    t.map((p) => p * 100)
+  );
+  s.la = e, s.yb = r;
+  const o = i[1], l = x(i, tr);
+  let c = wn[s.surround];
+  const f = c[0];
+  s.c = c[1], s.nc = c[2];
+  const h = (1 / (5 * s.la + 1)) ** 4;
+  s.fl = h * s.la + 0.1 * (1 - h) * (1 - h) * Math.cbrt(5 * s.la), s.flRoot = s.fl ** 0.25, s.n = s.yb / o, s.z = 1.48 + Math.sqrt(s.n), s.nbb = 0.725 * s.n ** -0.2, s.ncb = s.nbb;
+  const m = Math.max(Math.min(f * (1 - 1 / 3.6 * Math.exp((-s.la - 42) / 92)), 1), 0);
+  s.dRgb = /** @type {[number, number, number]} */
+  l.map((p) => Be(1, o / p, m)), s.dRgbInv = /** @type {[number, number, number]} */
+  s.dRgb.map((p) => 1 / p);
+  const d = (
+    /** @type {[number, number, number]} */
+    l.map((p, w) => p * s.dRgb[w])
+  ), M = rr(d, s.fl);
+  return s.aW = s.nbb * (2 * M[0] + M[1] + 0.05 * M[2]), s;
+}
+const i0 = nr(bn, 64 / Math.PI * 0.2, 20, "average", !1);
+function St(t, e) {
+  if (!(t.J !== void 0 ^ t.Q !== void 0))
+    throw new Error("Conversion requires one and only one: 'J' or 'Q'");
+  if (!(t.C !== void 0 ^ t.M !== void 0 ^ t.s !== void 0))
+    throw new Error("Conversion requires one and only one: 'C', 'M' or 's'");
+  if (!(t.h !== void 0 ^ t.H !== void 0))
+    throw new Error("Conversion requires one and only one: 'h' or 'H'");
+  if (t.J === 0 || t.Q === 0)
+    return [0, 0, 0];
+  let r = 0;
+  t.h !== void 0 ? r = X(t.h) * s0 : r = Rn(t.H) * s0;
+  const n = Math.cos(r), a = Math.sin(r);
+  let s = 0;
+  t.J !== void 0 ? s = E(t.J, 1 / 2) * 0.1 : t.Q !== void 0 && (s = 0.25 * e.c * t.Q / ((e.aW + 4) * e.flRoot));
+  let i = 0;
+  t.C !== void 0 ? i = t.C / s : t.M !== void 0 ? i = t.M / e.flRoot / s : t.s !== void 0 && (i = 4e-4 * t.s ** 2 * (e.aW + 4) / e.c);
+  const o = E(i * Math.pow(1.64 - Math.pow(0.29, e.n), -0.73), 10 / 9), l = 0.25 * (Math.cos(r + 2) + 3.8), c = e.aW * E(s, 2 / e.c / e.z), f = 5e4 / 13 * e.nc * e.ncb * l, u = c / e.nbb, h = 23 * (u + 0.305) * $t(o, 23 * f + o * (11 * n + 108 * a)), m = h * n, d = h * a, M = _n(
+    /** @type {Vector3} */
+    x([u, m, d], yn).map((p) => p * 1 / 1403),
+    e.fl
+  );
+  return (
+    /** @type {Vector3} */
+    x(
+      /** @type {Vector3} */
+      M.map((p, w) => p * e.dRgbInv[w]),
+      Mn
+    ).map((p) => p / 100)
+  );
+}
+function ar(t, e) {
+  const r = (
+    /** @type {Vector3} */
+    t.map((y) => y * 100)
+  ), n = rr(
+    /** @type {[number, number, number]} */
+    x(r, tr).map((y, _) => y * e.dRgb[_]),
+    e.fl
+  ), a = n[0] + (-12 * n[1] + n[2]) / 11, s = (n[0] + n[1] - 2 * n[2]) / 9, i = (Math.atan2(s, a) % ht + ht) % ht, o = 0.25 * (Math.cos(i + 2) + 3.8), l = 5e4 / 13 * e.nc * e.ncb * $t(o * Math.sqrt(a ** 2 + s ** 2), n[0] + n[1] + 1.05 * n[2] + 0.305), c = E(l, 0.9) * Math.pow(1.64 - Math.pow(0.29, e.n), 0.73), f = e.nbb * (2 * n[0] + n[1] + 0.05 * n[2]), u = E(f / e.aW, 0.5 * e.c * e.z), h = 100 * E(u, 2), m = 4 / e.c * u * (e.aW + 4) * e.flRoot, d = c * u, M = d * e.flRoot, p = X(i * Cn), w = Ln(p), b = 50 * E(e.c * c / (e.aW + 4), 1 / 2);
+  return { J: h, C: d, h: p, s: b, Q: m, M, H: w };
+}
+var vn = new g({
+  id: "cam16-jmh",
+  cssId: "--cam16-jmh",
+  name: "CAM16-JMh",
+  coords: {
+    j: {
+      refRange: [0, 100],
+      name: "J"
+    },
+    m: {
+      refRange: [0, 105],
+      name: "Colorfulness"
+    },
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  base: A,
+  fromBase(t) {
+    this.ε === void 0 && (this.ε = Object.values(this.coords)[1].refRange[1] / 1e5);
+    const e = ar(t, i0), r = Math.abs(e.M) < this.ε;
+    return [e.J, r ? 0 : e.M, r ? null : e.h];
+  },
+  toBase(t) {
+    return St({ J: t[0], M: t[1], h: t[2] }, i0);
+  }
+});
+const Sn = P.D65, xn = 216 / 24389, sr = 24389 / 27;
+function Bn(t) {
+  return 116 * (t > xn ? Math.cbrt(t) : (sr * t + 16) / 116) - 16;
+}
+function xt(t) {
+  return t > 8 ? Math.pow((t + 16) / 116, 3) : t / sr;
+}
+function zn(t, e) {
+  let [r, n, a] = t, s = [], i = 0;
+  if (a === 0)
+    return [0, 0, 0];
+  let o = xt(a);
+  a > 0 ? i = 0.00379058511492914 * a ** 2 + 0.608983189401032 * a + 0.9155088574762233 : i = 9514440756550361e-21 * a ** 2 + 0.08693057439788597 * a - 21.928975842194614;
+  const l = 2e-12, c = 15;
+  let f = 0, u = 1 / 0;
+  for (; f <= c; ) {
+    s = St({ J: i, C: n, h: r }, e);
+    const h = Math.abs(s[1] - o);
+    if (h < u) {
+      if (h <= l)
+        return s;
+      u = h;
+    }
+    i = i - (s[1] - o) * i / (2 * s[1]), f += 1;
+  }
+  return St({ J: i, C: n, h: r }, e);
+}
+function En(t, e) {
+  const r = Bn(t[1]);
+  if (r === 0)
+    return [0, 0, 0];
+  const n = ar(t, It);
+  return [X(n.h), n.C, r];
+}
+const It = nr(
+  Sn,
+  200 / Math.PI * xt(50),
+  xt(50) * 100,
+  "average",
+  !1
+);
+var ze = new g({
+  id: "hct",
+  name: "HCT",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    c: {
+      refRange: [0, 145],
+      name: "Colorfulness"
+    },
+    t: {
+      refRange: [0, 100],
+      name: "Tone"
+    }
+  },
+  base: A,
+  fromBase(t) {
+    this.ε === void 0 && (this.ε = Object.values(this.coords)[1].refRange[1] / 1e5);
+    let e = En(t);
+    return e[1] < this.ε && (e[1] = 0, e[0] = null), e;
+  },
+  toBase(t) {
+    return zn(t, It);
+  },
+  formats: {
+    color: {
+      id: "--hct",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+const kn = Math.PI / 180, o0 = [1, 7e-3, 0.0228];
+function l0(t) {
+  t[1] < 0 && (t = ze.fromBase(ze.toBase(t)));
+  const e = Math.log(Math.max(1 + o0[2] * t[1] * It.flRoot, 1)) / o0[2], r = t[0] * kn, n = e * Math.cos(r), a = e * Math.sin(r);
+  return [t[2], n, a];
+}
+function $n(t, e) {
+  [t, e] = C([t, e]);
+  let [r, n, a] = l0(ze.from(t)), [s, i, o] = l0(ze.from(e));
+  return Math.sqrt((r - s) ** 2 + (n - i) ** 2 + (a - o) ** 2);
+}
+var be = {
+  deltaE76: Qr,
+  deltaECMC: Vr,
+  deltaE2000: W0,
+  deltaEJz: sn,
+  deltaEITP: gn,
+  deltaEOK: Lt,
+  deltaEOK2: pn,
+  deltaEHCT: $n
+};
+function An(t) {
+  const e = t ? Math.floor(Math.log10(Math.abs(t))) : 0;
+  return Math.max(parseFloat(`1e${e - 2}`), 1e-6);
+}
+const c0 = {
+  hct: {
+    method: "hct.c",
+    jnd: 2,
+    deltaEMethod: "hct",
+    blackWhiteClamp: {}
+  },
+  "hct-tonal": {
+    method: "hct.c",
+    jnd: 0,
+    deltaEMethod: "hct",
+    blackWhiteClamp: { channel: "hct.t", min: 0, max: 100 }
+  }
+};
+function re(t, {
+  method: e = N.gamut_mapping,
+  space: r = void 0,
+  deltaEMethod: n = "",
+  jnd: a = 2,
+  blackWhiteClamp: s = void 0
+} = {}) {
+  if (t = C(t), ye(arguments[1]) ? r = arguments[1] : r || (r = t.space), r = g.get(r), ie(t, r, { epsilon: 0 }))
+    return (
+      /** @type {PlainColorObject} */
+      t
+    );
+  let i;
+  if (e === "css")
+    i = On(t, { space: r });
+  else {
+    if (e !== "clip" && !ie(t, r)) {
+      Object.prototype.hasOwnProperty.call(c0, e) && ({ method: e, jnd: a, deltaEMethod: n, blackWhiteClamp: s } = c0[e]);
+      let o = W0;
+      if (n !== "") {
+        for (let c in be)
+          if ("deltae" + n.toLowerCase() === c.toLowerCase()) {
+            o = be[c];
+            break;
+          }
+      }
+      a === 0 && (a = 1e-16);
+      let l = re(v(t, r), { method: "clip", space: r });
+      if (o(t, l) > a) {
+        if (s && Object.keys(s).length === 3) {
+          let b = g.resolveCoord(s.channel), y = T(v(t, b.space), b.id);
+          if (L(y) && (y = 0), y >= s.max)
+            return v({ space: "xyz-d65", coords: P.D65 }, t.space);
+          if (y <= s.min)
+            return v({ space: "xyz-d65", coords: [0, 0, 0] }, t.space);
+        }
+        let c = g.resolveCoord(e), f = c.space, u = c.id, h = v(t, f);
+        h.coords.forEach((b, y) => {
+          L(b) && (h.coords[y] = 0);
+        });
+        let d = (c.range || c.refRange)[0], M = An(a), p = d, w = T(h, u);
+        for (; w - p > M; ) {
+          let b = pe(h);
+          b = re(b, { space: r, method: "clip" }), o(h, b) - a < M ? p = T(h, u) : w = T(h, u), F(h, u, (p + w) / 2);
+        }
+        i = v(h, r);
+      } else
+        i = l;
+    } else
+      i = v(t, r);
+    if (e === "clip" || // Dumb coord clipping
+    // finish off smarter gamut mapping with clip to get rid of ε, see #17
+    !ie(i, r, { epsilon: 0 })) {
+      let o = Object.values(r.coords).map((l) => l.range || []);
+      i.coords = /** @type {[number, number, number]} */
+      i.coords.map((l, c) => {
+        let [f, u] = o[c];
+        return f !== void 0 && (l = Math.max(f, l)), u !== void 0 && (l = Math.min(l, u)), l;
+      });
+    }
+  }
+  return r !== t.space && (i = v(i, t.space)), t.coords = i.coords, /** @type {PlainColorObject} */
+  t;
+}
+re.returns = "color";
+const u0 = {
+  WHITE: { space: Z, coords: [1, 0, 0], alpha: 1 },
+  BLACK: { space: Z, coords: [0, 0, 0], alpha: 1 }
+};
+function On(t, { space: e } = {}) {
+  t = C(t), e || (e = t.space), e = g.get(e);
+  const a = g.get("oklch");
+  if (e.isUnbounded)
+    return v(t, e);
+  const s = v(t, a);
+  let i = s.coords[0];
+  if (i >= 1) {
+    const d = v(u0.WHITE, e);
+    return d.alpha = t.alpha, v(d, e);
+  }
+  if (i <= 0) {
+    const d = v(u0.BLACK, e);
+    return d.alpha = t.alpha, v(d, e);
+  }
+  if (ie(s, e, { epsilon: 0 }))
+    return v(s, e);
+  function o(d) {
+    const M = v(d, e), p = Object.values(
+      /** @type {ColorSpace} */
+      e.coords
+    );
+    return M.coords = /** @type {[number, number, number]} */
+    M.coords.map((w, b) => {
+      if ("range" in p[b]) {
+        const [y, _] = p[b].range;
+        return et(y, w, _);
+      }
+      return w;
+    }), M;
+  }
+  let l = 0, c = s.coords[1], f = !0, u = pe(s), h = o(u), m = Lt(h, u);
+  if (m < 0.02)
+    return h;
+  for (; c - l > 1e-4; ) {
+    const d = (l + c) / 2;
+    if (u.coords[1] = d, f && ie(u, e, { epsilon: 0 }))
+      l = d;
+    else if (h = o(u), m = Lt(h, u), m < 0.02) {
+      if (0.02 - m < 1e-4)
+        break;
+      f = !1, l = d;
+    } else
+      c = d;
+  }
+  return h;
+}
+function v(t, e, { inGamut: r } = {}) {
+  t = C(t), e = g.get(e);
+  let n = e.from(t), a = { space: e, coords: n, alpha: t.alpha };
+  return r && (a = re(a, r === !0 ? void 0 : r)), a;
+}
+v.returns = "color";
+function ve(t, e = {}) {
+  let {
+    precision: r = N.precision,
+    format: n,
+    inGamut: a = !0,
+    coords: s,
+    alpha: i,
+    commas: o
+  } = e, l, c = (
+    /** @type {PlainColorObject & ParseOptions} */
+    C(t)
+  ), f = n, u = c.parseMeta;
+  u && !n && (u.format.canSerialize() && (n = u.format, f = u.formatId), s ??= u.types, i ??= u.alphaType, o ??= u.commas), f && (n = c.space.getFormat(n) ?? g.findFormat(f)), n || (n = c.space.getFormat("default") ?? g.DEFAULT_FORMAT, f = n.name), n && n.space && n.space !== c.space && (c = v(c, n.space));
+  let h = c.coords.slice();
+  if (a ||= n.toGamut, a && !ie(c) && (h = re(pe(c), a === !0 ? void 0 : a).coords), n.type === "custom")
+    if (n.serialize)
+      l = n.serialize(h, c.alpha, e);
+    else
+      throw new TypeError(
+        `format ${f} can only be used to parse colors, not for serialization`
+      );
+  else {
+    let m = n.name || "color", d = n.serializeCoords(h, r, s);
+    if (m === "color") {
+      let y = n.id || n.ids?.[0] || c.space.cssId || c.space.id;
+      d.unshift(y);
+    }
+    let M = c.alpha;
+    i !== void 0 && typeof i != "object" && (i = typeof i == "string" ? { type: i } : { include: i });
+    let p = i?.type ?? "<number>", w = i?.include === !0 || n.alpha === !0 || i?.include !== !1 && n.alpha !== !1 && M < 1, b = "";
+    if (o ??= n.commas, w) {
+      if (r !== null) {
+        let y;
+        p === "<percentage>" && (y = "%", M *= 100), M = Et(M, { precision: r, unit: y });
+      }
+      b = `${o ? "," : " /"} ${M}`;
+    }
+    l = `${m}(${d.join(o ? ", " : " ")}${b})`;
+  }
+  return l;
+}
+const Pn = [
+  [0.6369580483012914, 0.14461690358620832, 0.1688809751641721],
+  [0.2627002120112671, 0.6779980715188708, 0.05930171646986196],
+  [0, 0.028072693049087428, 1.060985057710791]
+], In = [
+  [1.716651187971268, -0.355670783776392, -0.25336628137366],
+  [-0.666684351832489, 1.616481236634939, 0.0157685458139111],
+  [0.017639857445311, -0.042770613257809, 0.942103121235474]
+];
+var Ee = new O({
+  id: "rec2020-linear",
+  cssId: "--rec2020-linear",
+  name: "Linear REC.2020",
+  white: "D65",
+  toXYZ_M: Pn,
+  fromXYZ_M: In
+}), ir = new O({
+  id: "rec2020",
+  name: "REC.2020",
+  base: Ee,
+  //  Reference electro-optical transfer function from Rec. ITU-R BT.1886 Annex 1
+  //  with b (black lift) = 0 and a (user gain) = 1
+  //  defined over the extended range, not clamped
+  toBase(t) {
+    return t.map(function(e) {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return r * Math.pow(n, 2.4);
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return r * Math.pow(n, 1 / 2.4);
+    });
+  }
+});
+const Hn = [
+  [0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
+  [0.2289745640697488, 0.6917385218365064, 0.079286914093745],
+  [0, 0.04511338185890264, 1.043944368900976]
+], jn = [
+  [2.493496911941425, -0.9313836179191239, -0.40271078445071684],
+  [-0.8294889695615747, 1.7626640603183463, 0.023624685841943577],
+  [0.03584583024378447, -0.07617238926804182, 0.9568845240076872]
+];
+var or = new O({
+  id: "p3-linear",
+  cssId: "display-p3-linear",
+  name: "Linear P3",
+  white: "D65",
+  toXYZ_M: Hn,
+  fromXYZ_M: jn
+});
+const Dn = [
+  [0.41239079926595934, 0.357584339383878, 0.1804807884018343],
+  [0.21263900587151027, 0.715168678767756, 0.07219231536073371],
+  [0.01933081871559182, 0.11919477979462598, 0.9505321522496607]
+], k = [
+  [3.2409699419045226, -1.537383177570094, -0.4986107602930034],
+  [-0.9692436362808796, 1.8759675015077202, 0.04155505740717559],
+  [0.05563007969699366, -0.20397695888897652, 1.0569715142428786]
+];
+var lr = new O({
+  id: "srgb-linear",
+  name: "Linear sRGB",
+  white: "D65",
+  toXYZ_M: Dn,
+  fromXYZ_M: k
+}), f0 = {
+  aliceblue: [240 / 255, 248 / 255, 1],
+  antiquewhite: [250 / 255, 235 / 255, 215 / 255],
+  aqua: [0, 1, 1],
+  aquamarine: [127 / 255, 1, 212 / 255],
+  azure: [240 / 255, 1, 1],
+  beige: [245 / 255, 245 / 255, 220 / 255],
+  bisque: [1, 228 / 255, 196 / 255],
+  black: [0, 0, 0],
+  blanchedalmond: [1, 235 / 255, 205 / 255],
+  blue: [0, 0, 1],
+  blueviolet: [138 / 255, 43 / 255, 226 / 255],
+  brown: [165 / 255, 42 / 255, 42 / 255],
+  burlywood: [222 / 255, 184 / 255, 135 / 255],
+  cadetblue: [95 / 255, 158 / 255, 160 / 255],
+  chartreuse: [127 / 255, 1, 0],
+  chocolate: [210 / 255, 105 / 255, 30 / 255],
+  coral: [1, 127 / 255, 80 / 255],
+  cornflowerblue: [100 / 255, 149 / 255, 237 / 255],
+  cornsilk: [1, 248 / 255, 220 / 255],
+  crimson: [220 / 255, 20 / 255, 60 / 255],
+  cyan: [0, 1, 1],
+  darkblue: [0, 0, 139 / 255],
+  darkcyan: [0, 139 / 255, 139 / 255],
+  darkgoldenrod: [184 / 255, 134 / 255, 11 / 255],
+  darkgray: [169 / 255, 169 / 255, 169 / 255],
+  darkgreen: [0, 100 / 255, 0],
+  darkgrey: [169 / 255, 169 / 255, 169 / 255],
+  darkkhaki: [189 / 255, 183 / 255, 107 / 255],
+  darkmagenta: [139 / 255, 0, 139 / 255],
+  darkolivegreen: [85 / 255, 107 / 255, 47 / 255],
+  darkorange: [1, 140 / 255, 0],
+  darkorchid: [153 / 255, 50 / 255, 204 / 255],
+  darkred: [139 / 255, 0, 0],
+  darksalmon: [233 / 255, 150 / 255, 122 / 255],
+  darkseagreen: [143 / 255, 188 / 255, 143 / 255],
+  darkslateblue: [72 / 255, 61 / 255, 139 / 255],
+  darkslategray: [47 / 255, 79 / 255, 79 / 255],
+  darkslategrey: [47 / 255, 79 / 255, 79 / 255],
+  darkturquoise: [0, 206 / 255, 209 / 255],
+  darkviolet: [148 / 255, 0, 211 / 255],
+  deeppink: [1, 20 / 255, 147 / 255],
+  deepskyblue: [0, 191 / 255, 1],
+  dimgray: [105 / 255, 105 / 255, 105 / 255],
+  dimgrey: [105 / 255, 105 / 255, 105 / 255],
+  dodgerblue: [30 / 255, 144 / 255, 1],
+  firebrick: [178 / 255, 34 / 255, 34 / 255],
+  floralwhite: [1, 250 / 255, 240 / 255],
+  forestgreen: [34 / 255, 139 / 255, 34 / 255],
+  fuchsia: [1, 0, 1],
+  gainsboro: [220 / 255, 220 / 255, 220 / 255],
+  ghostwhite: [248 / 255, 248 / 255, 1],
+  gold: [1, 215 / 255, 0],
+  goldenrod: [218 / 255, 165 / 255, 32 / 255],
+  gray: [128 / 255, 128 / 255, 128 / 255],
+  green: [0, 128 / 255, 0],
+  greenyellow: [173 / 255, 1, 47 / 255],
+  grey: [128 / 255, 128 / 255, 128 / 255],
+  honeydew: [240 / 255, 1, 240 / 255],
+  hotpink: [1, 105 / 255, 180 / 255],
+  indianred: [205 / 255, 92 / 255, 92 / 255],
+  indigo: [75 / 255, 0, 130 / 255],
+  ivory: [1, 1, 240 / 255],
+  khaki: [240 / 255, 230 / 255, 140 / 255],
+  lavender: [230 / 255, 230 / 255, 250 / 255],
+  lavenderblush: [1, 240 / 255, 245 / 255],
+  lawngreen: [124 / 255, 252 / 255, 0],
+  lemonchiffon: [1, 250 / 255, 205 / 255],
+  lightblue: [173 / 255, 216 / 255, 230 / 255],
+  lightcoral: [240 / 255, 128 / 255, 128 / 255],
+  lightcyan: [224 / 255, 1, 1],
+  lightgoldenrodyellow: [250 / 255, 250 / 255, 210 / 255],
+  lightgray: [211 / 255, 211 / 255, 211 / 255],
+  lightgreen: [144 / 255, 238 / 255, 144 / 255],
+  lightgrey: [211 / 255, 211 / 255, 211 / 255],
+  lightpink: [1, 182 / 255, 193 / 255],
+  lightsalmon: [1, 160 / 255, 122 / 255],
+  lightseagreen: [32 / 255, 178 / 255, 170 / 255],
+  lightskyblue: [135 / 255, 206 / 255, 250 / 255],
+  lightslategray: [119 / 255, 136 / 255, 153 / 255],
+  lightslategrey: [119 / 255, 136 / 255, 153 / 255],
+  lightsteelblue: [176 / 255, 196 / 255, 222 / 255],
+  lightyellow: [1, 1, 224 / 255],
+  lime: [0, 1, 0],
+  limegreen: [50 / 255, 205 / 255, 50 / 255],
+  linen: [250 / 255, 240 / 255, 230 / 255],
+  magenta: [1, 0, 1],
+  maroon: [128 / 255, 0, 0],
+  mediumaquamarine: [102 / 255, 205 / 255, 170 / 255],
+  mediumblue: [0, 0, 205 / 255],
+  mediumorchid: [186 / 255, 85 / 255, 211 / 255],
+  mediumpurple: [147 / 255, 112 / 255, 219 / 255],
+  mediumseagreen: [60 / 255, 179 / 255, 113 / 255],
+  mediumslateblue: [123 / 255, 104 / 255, 238 / 255],
+  mediumspringgreen: [0, 250 / 255, 154 / 255],
+  mediumturquoise: [72 / 255, 209 / 255, 204 / 255],
+  mediumvioletred: [199 / 255, 21 / 255, 133 / 255],
+  midnightblue: [25 / 255, 25 / 255, 112 / 255],
+  mintcream: [245 / 255, 1, 250 / 255],
+  mistyrose: [1, 228 / 255, 225 / 255],
+  moccasin: [1, 228 / 255, 181 / 255],
+  navajowhite: [1, 222 / 255, 173 / 255],
+  navy: [0, 0, 128 / 255],
+  oldlace: [253 / 255, 245 / 255, 230 / 255],
+  olive: [128 / 255, 128 / 255, 0],
+  olivedrab: [107 / 255, 142 / 255, 35 / 255],
+  orange: [1, 165 / 255, 0],
+  orangered: [1, 69 / 255, 0],
+  orchid: [218 / 255, 112 / 255, 214 / 255],
+  palegoldenrod: [238 / 255, 232 / 255, 170 / 255],
+  palegreen: [152 / 255, 251 / 255, 152 / 255],
+  paleturquoise: [175 / 255, 238 / 255, 238 / 255],
+  palevioletred: [219 / 255, 112 / 255, 147 / 255],
+  papayawhip: [1, 239 / 255, 213 / 255],
+  peachpuff: [1, 218 / 255, 185 / 255],
+  peru: [205 / 255, 133 / 255, 63 / 255],
+  pink: [1, 192 / 255, 203 / 255],
+  plum: [221 / 255, 160 / 255, 221 / 255],
+  powderblue: [176 / 255, 224 / 255, 230 / 255],
+  purple: [128 / 255, 0, 128 / 255],
+  rebeccapurple: [102 / 255, 51 / 255, 153 / 255],
+  red: [1, 0, 0],
+  rosybrown: [188 / 255, 143 / 255, 143 / 255],
+  royalblue: [65 / 255, 105 / 255, 225 / 255],
+  saddlebrown: [139 / 255, 69 / 255, 19 / 255],
+  salmon: [250 / 255, 128 / 255, 114 / 255],
+  sandybrown: [244 / 255, 164 / 255, 96 / 255],
+  seagreen: [46 / 255, 139 / 255, 87 / 255],
+  seashell: [1, 245 / 255, 238 / 255],
+  sienna: [160 / 255, 82 / 255, 45 / 255],
+  silver: [192 / 255, 192 / 255, 192 / 255],
+  skyblue: [135 / 255, 206 / 255, 235 / 255],
+  slateblue: [106 / 255, 90 / 255, 205 / 255],
+  slategray: [112 / 255, 128 / 255, 144 / 255],
+  slategrey: [112 / 255, 128 / 255, 144 / 255],
+  snow: [1, 250 / 255, 250 / 255],
+  springgreen: [0, 1, 127 / 255],
+  steelblue: [70 / 255, 130 / 255, 180 / 255],
+  tan: [210 / 255, 180 / 255, 140 / 255],
+  teal: [0, 128 / 255, 128 / 255],
+  thistle: [216 / 255, 191 / 255, 216 / 255],
+  tomato: [1, 99 / 255, 71 / 255],
+  turquoise: [64 / 255, 224 / 255, 208 / 255],
+  violet: [238 / 255, 130 / 255, 238 / 255],
+  wheat: [245 / 255, 222 / 255, 179 / 255],
+  white: [1, 1, 1],
+  whitesmoke: [245 / 255, 245 / 255, 245 / 255],
+  yellow: [1, 1, 0],
+  yellowgreen: [154 / 255, 205 / 255, 50 / 255]
+};
+let h0 = Array(3).fill("<percentage> | <number>[0, 255]"), m0 = Array(3).fill("<number>[0, 255]");
+var oe = new O({
+  id: "srgb",
+  name: "sRGB",
+  base: lr,
+  fromBase: (t) => t.map((e) => {
+    let r = e < 0 ? -1 : 1, n = e * r;
+    return n > 31308e-7 ? r * (1.055 * n ** (1 / 2.4) - 0.055) : 12.92 * e;
+  }),
+  toBase: (t) => t.map((e) => {
+    let r = e < 0 ? -1 : 1, n = e * r;
+    return n <= 0.04045 ? e / 12.92 : r * ((n + 0.055) / 1.055) ** 2.4;
+  }),
+  formats: {
+    rgb: {
+      coords: h0
+    },
+    rgb_number: {
+      name: "rgb",
+      commas: !0,
+      coords: m0,
+      alpha: !1
+    },
+    color: {
+      /* use defaults */
+    },
+    rgba: {
+      coords: h0,
+      commas: !0,
+      alpha: !0
+    },
+    rgba_number: {
+      name: "rgba",
+      commas: !0,
+      coords: m0
+    },
+    hex: {
+      type: "custom",
+      toGamut: !0,
+      test: (t) => /^#(([a-f0-9]{2}){3,4}|[a-f0-9]{3,4})$/i.test(t),
+      parse(t) {
+        t.length <= 5 && (t = t.replace(/[a-f0-9]/gi, "$&$&"));
+        let e = [];
+        return t.replace(/[a-f0-9]{2}/gi, (r) => {
+          e.push(parseInt(r, 16) / 255);
+        }), {
+          spaceId: "srgb",
+          coords: (
+            /** @type {Coords} */
+            e.slice(0, 3)
+          ),
+          alpha: (
+            /** @type {number} */
+            e.slice(3)[0]
+          )
+        };
+      },
+      serialize: (t, e, {
+        collapse: r = !0,
+        // collapse to 3-4 digit hex when possible?
+        alpha: n
+      } = {}) => {
+        (n !== !1 && e < 1 || n === !0) && t.push(e), t = /** @type {[number, number, number]} */
+        t.map((i) => Math.round(i * 255));
+        let a = r && t.every((i) => i % 17 === 0);
+        return "#" + t.map((i) => a ? (i / 17).toString(16) : i.toString(16).padStart(2, "0")).join("");
+      }
+    },
+    keyword: {
+      type: "custom",
+      test: (t) => /^[a-z]+$/i.test(t),
+      parse(t) {
+        t = t.toLowerCase();
+        let e = { spaceId: "srgb", coords: null, alpha: 1 };
+        if (t === "transparent" ? (e.coords = f0.black, e.alpha = 0) : e.coords = f0[t], e.coords)
+          return e;
+      }
+    }
+  }
+}), cr = new O({
+  id: "p3",
+  cssId: "display-p3",
+  name: "P3",
+  base: or,
+  // Gamma encoding/decoding is the same as sRGB
+  fromBase: oe.fromBase,
+  toBase: oe.toBase
+});
+N.display_space = oe;
+let Tn;
+if (typeof CSS < "u" && CSS.supports)
+  for (let t of [Y, ir, cr]) {
+    let e = t.getMinCoords(), n = ve({ space: t, coords: e, alpha: 1 });
+    if (CSS.supports("color", n)) {
+      N.display_space = t;
+      break;
+    }
+  }
+function Yn(t, { space: e = N.display_space, ...r } = {}) {
+  t = C(t);
+  let n = (
+    /** @type {Display} */
+    ve(t, r)
+  );
+  if (typeof CSS > "u" || CSS.supports(
+    "color",
+    /** @type {string} */
+    n
+  ) || !N.display_space)
+    n = /** @type {Display} */
+    new String(n), n.color = /** @type {PlainColorObject} */
+    t;
+  else {
+    let a = (
+      /** @type {PlainColorObject} */
+      t
+    );
+    if ((t.coords.some(L) || L(t.alpha)) && !(Tn ??= CSS.supports("color", "hsl(none 50% 50%)")) && (a = pe(
+      /** @type {PlainColorObject} */
+      t
+    ), a.coords = /** @type {[number, number, number]} */
+    a.coords.map(z), a.alpha = z(a.alpha), n = ve(a, r), CSS.supports(
+      "color",
+      /** @type {string} */
+      n
+    )))
+      return n = /** @type {Display} */
+      new String(n), n.color = a, n;
+    a = v(a, e), n = /** @type {Display} */
+    new String(ve(a, r)), n.color = a;
+  }
+  return n;
+}
+function Nn(t, e, { space: r, hue: n = "shorter" } = {}) {
+  t = C(t), r ||= t.space, r = g.get(r);
+  let a = Object.values(r.coords);
+  [t, e] = [t, e].map((c) => v(c, r));
+  let [s, i] = [t, e].map((c) => c.coords), o = (
+    /** @type {[number, number, number]} */
+    s.map((c, f) => {
+      let u = a[f], h = i[f];
+      return u.type === "angle" && ([c, h] = J0(n, [c, h])), d0(c, h);
+    })
+  ), l = d0(t.alpha, e.alpha);
+  return { space: (
+    /** @type {ColorSpace} */
+    r
+  ), coords: o, alpha: l };
+}
+function d0(t, e) {
+  return L(t) || L(e) ? t === e ? null : 0 : t - e;
+}
+function qn(t, e) {
+  return t = C(t), e = C(e), t.space === e.space && t.alpha === e.alpha && t.coords.every((r, n) => r === e.coords[n]);
+}
+function ne(t) {
+  return T(t, [A, "y"]);
+}
+function ur(t, e) {
+  F(t, [A, "y"], e);
+}
+function Xn(t) {
+  Object.defineProperty(t.prototype, "luminance", {
+    get() {
+      return ne(this);
+    },
+    set(e) {
+      ur(this, e);
+    }
+  });
+}
+var Gn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getLuminance: ne,
+  register: Xn,
+  setLuminance: ur
+});
+function Zn(t, e) {
+  t = C(t), e = C(e);
+  let r = Math.max(ne(t), 0), n = Math.max(ne(e), 0);
+  return n > r && ([r, n] = [n, r]), (r + 0.05) / (n + 0.05);
+}
+const Jn = 0.56, Wn = 0.57, Fn = 0.62, Qn = 0.65, g0 = 0.022, Un = 1.414, Vn = 0.1, Kn = 5e-4, ea = 1.14, p0 = 0.027, ta = 1.14;
+function b0(t) {
+  return t >= g0 ? t : t + (g0 - t) ** Un;
+}
+function fe(t) {
+  let e = t < 0 ? -1 : 1, r = Math.abs(t);
+  return e * Math.pow(r, 2.4);
+}
+function ra(t, e) {
+  e = C(e), t = C(t);
+  let r, n, a, s, i, o;
+  e = v(e, "srgb"), [s, i, o] = e.coords.map((m) => L(m) ? 0 : m);
+  let l = fe(s) * 0.2126729 + fe(i) * 0.7151522 + fe(o) * 0.072175;
+  t = v(t, "srgb"), [s, i, o] = t.coords.map((m) => L(m) ? 0 : m);
+  let c = fe(s) * 0.2126729 + fe(i) * 0.7151522 + fe(o) * 0.072175, f = b0(l), u = b0(c), h = u > f;
+  return Math.abs(u - f) < Kn ? n = 0 : h ? (r = u ** Jn - f ** Wn, n = r * ea) : (r = u ** Qn - f ** Fn, n = r * ta), Math.abs(n) < Vn ? a = 0 : n > 0 ? a = n - p0 : a = n + p0, a * 100;
+}
+function na(t, e) {
+  t = C(t), e = C(e);
+  let r = Math.max(ne(t), 0), n = Math.max(ne(e), 0);
+  n > r && ([r, n] = [n, r]);
+  let a = r + n;
+  return a === 0 ? 0 : (r - n) / a;
+}
+const aa = 5e4;
+function sa(t, e) {
+  t = C(t), e = C(e);
+  let r = Math.max(ne(t), 0), n = Math.max(ne(e), 0);
+  return n > r && ([r, n] = [n, r]), n === 0 ? aa : (r - n) / n;
+}
+function ia(t, e) {
+  t = C(t), e = C(e);
+  let r = T(t, [Y, "l"]), n = T(e, [Y, "l"]);
+  return Math.abs(r - n);
+}
+const oa = 216 / 24389, M0 = 24 / 116, Te = 24389 / 27;
+let mt = P.D65;
+var Bt = new g({
+  id: "lab-d65",
+  name: "Lab D65",
+  coords: {
+    l: {
+      refRange: [0, 100],
+      name: "Lightness"
+    },
+    a: {
+      refRange: [-125, 125]
+    },
+    b: {
+      refRange: [-125, 125]
+    }
+  },
+  // Assuming XYZ is relative to D65, convert to CIE Lab
+  // from CIE standard, which now defines these as a rational fraction
+  white: mt,
+  base: A,
+  // Convert D65-adapted XYZ to Lab
+  //  CIE 15.3:2004 section 8.2.1.1
+  fromBase(t) {
+    let r = t.map((n, a) => n / mt[a]).map((n) => n > oa ? Math.cbrt(n) : (Te * n + 16) / 116);
+    return [
+      116 * r[1] - 16,
+      // L
+      500 * (r[0] - r[1]),
+      // a
+      200 * (r[1] - r[2])
+      // b
+    ];
+  },
+  // Convert Lab to D65-adapted XYZ
+  // Same result as CIE 15.3:2004 Appendix D although the derivation is different
+  // http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+  toBase(t) {
+    let e = [];
+    return e[1] = (t[0] + 16) / 116, e[0] = t[1] / 500 + e[1], e[2] = e[1] - t[2] / 200, [
+      e[0] > M0 ? Math.pow(e[0], 3) : (116 * e[0] - 16) / Te,
+      t[0] > 8 ? Math.pow((t[0] + 16) / 116, 3) : t[0] / Te,
+      e[2] > M0 ? Math.pow(e[2], 3) : (116 * e[2] - 16) / Te
+    ].map((n, a) => n * mt[a]);
+  },
+  formats: {
+    "lab-d65": {
+      coords: [
+        "<number> | <percentage>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+});
+const dt = Math.pow(5, 0.5) * 0.5 + 0.5;
+function la(t, e) {
+  t = C(t), e = C(e);
+  let r = T(t, [Bt, "l"]), n = T(e, [Bt, "l"]), a = Math.abs(Math.pow(r, dt) - Math.pow(n, dt)), s = Math.pow(a, 1 / dt) * Math.SQRT2 - 40;
+  return s < 7.5 ? 0 : s;
+}
+var Xe = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  contrastAPCA: ra,
+  contrastDeltaPhi: la,
+  contrastLstar: ia,
+  contrastMichelson: na,
+  contrastWCAG21: Zn,
+  contrastWeber: sa
+});
+function ca(t, e, r) {
+  ye(r) && (r = { algorithm: r });
+  let { algorithm: n, ...a } = r || {};
+  if (!n) {
+    let s = Object.keys(Xe).map((i) => i.replace(/^contrast/, "")).join(", ");
+    throw new TypeError(
+      `contrast() function needs a contrast algorithm. Please specify one of: ${s}`
+    );
+  }
+  t = C(t), e = C(e);
+  for (let s in Xe)
+    if ("contrast" + n.toLowerCase() === s.toLowerCase())
+      return Xe[s](t, e, a);
+  throw new TypeError(`Unknown contrast algorithm: ${n}`);
+}
+function rt(t) {
+  let [e, r, n] = ke(t, A), a = e + 15 * r + 3 * n;
+  return [4 * e / a, 9 * r / a];
+}
+function fr(t) {
+  let [e, r, n] = ke(t, A), a = e + r + n;
+  return [e / a, r / a];
+}
+function ua(t) {
+  Object.defineProperty(t.prototype, "uv", {
+    get() {
+      return rt(this);
+    }
+  }), Object.defineProperty(t.prototype, "xy", {
+    get() {
+      return fr(this);
+    }
+  });
+}
+var fa = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  register: ua,
+  uv: rt,
+  xy: fr
+});
+function Le(t, e, r = {}) {
+  ye(r) && (r = { method: r });
+  let { method: n = N.deltaE, ...a } = r;
+  for (let s in be)
+    if ("deltae" + n.toLowerCase() === s.toLowerCase())
+      return be[s](t, e, a);
+  throw new TypeError(`Unknown deltaE method: ${n}`);
+}
+function hr(t, e = 0.25) {
+  let n = [g.get("oklch", "lch"), "l"];
+  return F(t, n, (a) => a * (1 + e));
+}
+function mr(t, e = 0.25) {
+  let n = [g.get("oklch", "lch"), "l"];
+  return F(t, n, (a) => a * (1 - e));
+}
+hr.returns = "color";
+mr.returns = "color";
+var ha = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  darken: mr,
+  lighten: hr
+});
+function dr(t, e, r, n = {}) {
+  return [t, e] = [C(t), C(e)], K(r) === "object" && ([r, n] = [0.5, r]), $e(t, e, n)(r ?? 0.5);
+}
+function gr(t, e, r = {}) {
+  let n;
+  Ht(t) && ([n, r] = [t, e], [t, e] = n.rangeArgs.colors);
+  let { maxDeltaE: a, deltaEMethod: s, steps: i = 2, maxSteps: o = 1e3, ...l } = r;
+  n || ([t, e] = [C(t), C(e)], n = $e(t, e, l));
+  let c = Le(t, e), f = a > 0 ? Math.max(i, Math.ceil(c / a) + 1) : i, u = [];
+  if (o !== void 0 && (f = Math.min(f, o)), f === 1)
+    u = [{ p: 0.5, color: n(0.5) }];
+  else {
+    let h = 1 / (f - 1);
+    u = Array.from({ length: f }, (m, d) => {
+      let M = d * h;
+      return { p: M, color: n(M) };
+    });
+  }
+  if (a > 0) {
+    let h = u.reduce((m, d, M) => {
+      if (M === 0)
+        return 0;
+      let p = Le(d.color, u[M - 1].color, s);
+      return Math.max(m, p);
+    }, 0);
+    for (; h > a; ) {
+      h = 0;
+      for (let m = 1; m < u.length && u.length < o; m++) {
+        let d = u[m - 1], M = u[m], p = (M.p + d.p) / 2, w = n(p);
+        h = Math.max(h, Le(w, d.color), Le(w, M.color)), u.splice(m, 0, { p, color: n(p) }), m++;
+      }
+    }
+  }
+  return u = u.map((h) => h.color), u;
+}
+function $e(t, e, r = {}) {
+  if (Ht(t)) {
+    let [l, c] = [t, e];
+    return $e(...l.rangeArgs.colors, { ...l.rangeArgs.options, ...c });
+  }
+  let { space: n, outputSpace: a, progression: s, premultiplied: i } = r;
+  t = C(t), e = C(e), t = pe(t), e = pe(e);
+  let o = { colors: [t, e], options: r };
+  if (n ? n = g.get(n) : n = g.registry[N.interpolationSpace] || t.space, a = a ? g.get(a) : n, t = v(t, n), e = v(e, n), t = re(t), e = re(e), n.coords.h && n.coords.h.type === "angle") {
+    let l = r.hue = r.hue || "shorter", c = [n, "h"], [f, u] = [T(t, c), T(e, c)];
+    L(f) && !L(u) ? f = u : L(u) && !L(f) && (u = f), [f, u] = J0(l, [f, u]), F(t, c, f), F(e, c, u);
+  }
+  return i && (t.coords = /** @type {[number, number, number]} */
+  t.coords.map((l) => l * t.alpha), e.coords = /** @type {[number, number, number]} */
+  e.coords.map((l) => l * e.alpha)), Object.assign(
+    (l) => {
+      l = s ? s(l) : l;
+      let c = t.coords.map((h, m) => {
+        let d = e.coords[m];
+        return Be(h, d, l);
+      }), f = Be(t.alpha, e.alpha, l), u = { space: n, coords: c, alpha: f };
+      return i && (u.coords = u.coords.map((h) => h / f)), a !== n && (u = v(u, a)), u;
+    },
+    {
+      rangeArgs: o
+    }
+  );
+}
+function Ht(t) {
+  return K(t) === "function" && !!t.rangeArgs;
+}
+N.interpolationSpace = "lab";
+function ma(t) {
+  t.defineFunction("mix", dr, { returns: "color" }), t.defineFunction("range", $e, { returns: "function<color>" }), t.defineFunction("steps", gr, { returns: "array<color>" });
+}
+var da = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  isRange: Ht,
+  mix: dr,
+  range: $e,
+  register: ma,
+  steps: gr
+}), ga = new g({
+  id: "hsl",
+  name: "HSL",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 100],
+      name: "Saturation"
+    },
+    l: {
+      range: [0, 100],
+      name: "Lightness"
+    }
+  },
+  base: oe,
+  // Adapted from https://drafts.csswg.org/css-color-4/better-rgbToHsl.js
+  fromBase: (t) => {
+    let e = Math.max(...t), r = Math.min(...t), [n, a, s] = t, [i, o, l] = [null, 0, (r + e) / 2], c = e - r;
+    if (c !== 0) {
+      switch (o = l === 0 || l === 1 ? 0 : (e - l) / Math.min(l, 1 - l), e) {
+        case n:
+          i = (a - s) / c + (a < s ? 6 : 0);
+          break;
+        case a:
+          i = (s - n) / c + 2;
+          break;
+        case s:
+          i = (n - a) / c + 4;
+      }
+      i = i * 60;
+    }
+    return o < 0 && (i += 180, o = Math.abs(o)), i >= 360 && (i -= 360), [i, o * 100, l * 100];
+  },
+  // Adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB_alternative
+  toBase: (t) => {
+    let [e, r, n] = t;
+    e = e % 360, e < 0 && (e += 360), r /= 100, n /= 100;
+    function a(s) {
+      let i = (s + e / 30) % 12, o = r * Math.min(n, 1 - n);
+      return n - o * Math.max(-1, Math.min(i - 3, 9 - i, 1));
+    }
+    return [a(0), a(8), a(4)];
+  },
+  formats: {
+    hsl: {
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    },
+    hsla: {
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"],
+      commas: !0,
+      alpha: !0
+    }
+  }
+}), pr = new g({
+  id: "hsv",
+  name: "HSV",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 100],
+      name: "Saturation"
+    },
+    v: {
+      range: [0, 100],
+      name: "Value"
+    }
+  },
+  base: oe,
+  // https://en.wikipedia.org/wiki/HSL_and_HSV#Formal_derivation
+  fromBase(t) {
+    let e = Math.max(...t), r = Math.min(...t), [n, a, s] = t, [i, o, l] = [null, 0, e], c = e - r;
+    if (c !== 0) {
+      switch (e) {
+        case n:
+          i = (a - s) / c + (a < s ? 6 : 0);
+          break;
+        case a:
+          i = (s - n) / c + 2;
+          break;
+        case s:
+          i = (n - a) / c + 4;
+      }
+      i = i * 60;
+    }
+    return l && (o = c / l), i >= 360 && (i -= 360), [i, o * 100, l * 100];
+  },
+  // Adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSV_to_RGB_alternative
+  toBase(t) {
+    let [e, r, n] = t;
+    e = e % 360, e < 0 && (e += 360), r /= 100, n /= 100;
+    function a(s) {
+      let i = (s + e / 60) % 6;
+      return n - n * r * Math.max(0, Math.min(i, 4 - i, 1));
+    }
+    return [a(5), a(3), a(1)];
+  },
+  formats: {
+    color: {
+      id: "--hsv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+}), pa = new g({
+  id: "hwb",
+  name: "HWB",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    w: {
+      range: [0, 100],
+      name: "Whiteness"
+    },
+    b: {
+      range: [0, 100],
+      name: "Blackness"
+    }
+  },
+  base: pr,
+  fromBase(t) {
+    let [e, r, n] = t;
+    return [e, n * (100 - r) / 100, 100 - n];
+  },
+  toBase(t) {
+    let [e, r, n] = t;
+    r /= 100, n /= 100;
+    let a = r + n;
+    if (a >= 1) {
+      let o = r / a;
+      return [e, 0, o * 100];
+    }
+    let s = 1 - n, i = s === 0 ? 0 : 1 - r / s;
+    return [e, i * 100, s * 100];
+  },
+  formats: {
+    hwb: {
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+const ba = [
+  [0.5766690429101305, 0.1855582379065463, 0.1882286462349947],
+  [0.29734497525053605, 0.6273635662554661, 0.07529145849399788],
+  [0.02703136138641234, 0.07068885253582723, 0.9913375368376388]
+], Ma = [
+  [2.0415879038107465, -0.5650069742788596, -0.34473135077832956],
+  [-0.9692436362808795, 1.8759675015077202, 0.04155505740717557],
+  [0.013444280632031142, -0.11836239223101838, 1.0151749943912054]
+];
+var br = new O({
+  id: "a98rgb-linear",
+  cssId: "--a98-rgb-linear",
+  name: "Linear Adobe® 98 RGB compatible",
+  white: "D65",
+  toXYZ_M: ba,
+  fromXYZ_M: Ma
+}), ya = new O({
+  id: "a98rgb",
+  cssId: "a98-rgb",
+  name: "Adobe® 98 RGB compatible",
+  base: br,
+  toBase: (t) => t.map((e) => Math.pow(Math.abs(e), 563 / 256) * Math.sign(e)),
+  fromBase: (t) => t.map((e) => Math.pow(Math.abs(e), 256 / 563) * Math.sign(e))
+});
+const wa = [
+  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
+  [0.2880748288194013, 0.711835234241873, 8993693872564e-17],
+  [0, 0, 0.8251046025104602]
+], Ca = [
+  [1.3457868816471583, -0.25557208737979464, -0.05110186497554526],
+  [-0.5446307051249019, 1.5082477428451468, 0.02052744743642139],
+  [0, 0, 1.2119675456389452]
+];
+var Mr = new O({
+  id: "prophoto-linear",
+  cssId: "--prophoto-rgb-linear",
+  name: "Linear ProPhoto",
+  white: "D50",
+  base: Ot,
+  toXYZ_M: wa,
+  fromXYZ_M: Ca
+});
+const _a = 1 / 512, La = 16 / 512;
+var Ra = new O({
+  id: "prophoto",
+  cssId: "prophoto-rgb",
+  name: "ProPhoto",
+  base: Mr,
+  toBase(t) {
+    return t.map((e) => {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return n < La ? e / 16 : r * n ** 1.8;
+    });
+  },
+  fromBase(t) {
+    return t.map((e) => {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return n >= _a ? r * n ** (1 / 1.8) : 16 * e;
+    });
+  }
+});
+const Ye = 1.09929682680944, y0 = 0.018053968510807;
+var va = new O({
+  id: "--rec2020-oetf",
+  name: "REC.2020_Scene_Referred",
+  base: Ee,
+  referred: "scene",
+  // Non-linear transfer function from Rec. ITU-R BT.2020-2 table 4
+  toBase(t) {
+    return t.map(function(e) {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return n < y0 * 4.5 ? e / 4.5 : r * Math.pow((n + Ye - 1) / Ye, 1 / 0.45);
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      let r = e < 0 ? -1 : 1, n = e * r;
+      return n >= y0 ? r * (Ye * Math.pow(n, 0.45) - (Ye - 1)) : 4.5 * e;
+    });
+  }
+}), Sa = new g({
+  id: "oklch",
+  name: "OkLCh",
+  coords: {
+    l: {
+      refRange: [0, 1],
+      name: "Lightness"
+    },
+    c: {
+      refRange: [0, 0.4],
+      name: "Chroma"
+    },
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  white: "D65",
+  base: Z,
+  fromBase: q.fromBase,
+  toBase: q.toBase,
+  formats: {
+    oklch: {
+      coords: ["<percentage> | <number>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+const Me = 2 * Math.PI, Qe = [
+  [4.076741636075958, -3.307711539258063, 0.2309699031821043],
+  [-1.2684379732850315, 2.609757349287688, -0.341319376002657],
+  [-0.0041960761386756, -0.7034186179359362, 1.7076146940746117]
+], Ue = [
+  // Red
+  [
+    // Limit
+    [-1.8817031, -0.80936501],
+    // `Kn` coefficients
+    [1.19086277, 1.76576728, 0.59662641, 0.75515197, 0.56771245]
+  ],
+  // Green
+  [
+    // Limit
+    [1.8144408, -1.19445267],
+    // `Kn` coefficients
+    [0.73956515, -0.45954404, 0.08285427, 0.12541073, -0.14503204]
+  ],
+  // Blue
+  [
+    // Limit
+    [0.13110758, 1.81333971],
+    // `Kn` coefficients
+    [1.35733652, -915799e-8, -1.1513021, -0.50559606, 692167e-8]
+  ]
+], gt = Number.MAX_VALUE, Se = 0.206, jt = 0.03, Re = (1 + Se) / (1 + jt);
+function $(t, e) {
+  let r = t.length;
+  if (r !== e.length)
+    throw new Error(`Vectors of size ${r} and ${e.length} are not aligned`);
+  let n = 0;
+  return t.forEach((a, s) => {
+    n += a * e[s];
+  }), n;
+}
+function xe(t) {
+  return 0.5 * (Re * t - Se + Math.sqrt((Re * t - Se) * (Re * t - Se) + 4 * jt * Re * t));
+}
+function de(t) {
+  return (t ** 2 + Se * t) / (Re * (t + jt));
+}
+function Dt(t) {
+  let [e, r] = t;
+  return [r / e, r / (1 - e)];
+}
+function xa(t, e) {
+  let r = 0.11516993 + 1 / (7.4477897 + 4.1590124 * e + t * (-2.19557347 + 1.75198401 * e + t * (-2.13704948 - 10.02301043 * e + t * (-4.24894561 + 5.38770819 * e + 4.69891013 * t)))), n = 0.11239642 + 1 / (1.6132032 - 0.68124379 * e + t * (0.40370612 + 0.90148123 * e + t * (-0.27087943 + 0.6122399 * e + t * (299215e-8 - 0.45399568 * e - 0.14661872 * t))));
+  return [r, n];
+}
+function Tt(t, e) {
+  let r = x(t, ee);
+  return r[0] = r[0] ** 3, r[1] = r[1] ** 3, r[2] = r[2] ** 3, x(r, e, r);
+}
+function nt(t, e, r, n) {
+  let a = za(t, e, r, n), s = Tt([1, a * t, a * e], r), i = E(1 / Math.max(...s), 1 / 3), o = i * a;
+  return [i, o];
+}
+function Ba(t, e, r, n, a, s, i, o) {
+  let l;
+  if (o === void 0 && (o = nt(t, e, s, i)), (r - a) * o[1] - (o[0] - a) * n <= 0)
+    l = o[1] * a / (n * o[0] + o[1] * (a - r));
+  else {
+    l = o[1] * (a - 1) / (n * (o[0] - 1) + o[1] * (a - r));
+    let c = r - a, f = n, u = $(ee[0].slice(1), [t, e]), h = $(ee[1].slice(1), [t, e]), m = $(ee[2].slice(1), [t, e]), d = c + f * u, M = c + f * h, p = c + f * m, w = a * (1 - l) + l * r, b = l * n, y = w + b * u, _ = w + b * h, S = w + b * m, I = y ** 3, H = _ ** 3, B = S ** 3, j = 3 * d * y ** 2, Q = 3 * M * _ ** 2, G = 3 * p * S ** 2, J = 6 * d ** 2 * y, U = 6 * M ** 2 * _, W = 6 * p ** 2 * S, we = $(s[0], [I, H, B]) - 1, D = $(s[0], [j, Q, G]), Ae = $(s[0], [J, U, W]), Oe = D / (D * D - 0.5 * we * Ae), le = -we * Oe, V = $(s[1], [I, H, B]) - 1, ce = $(s[1], [j, Q, G]), st = $(s[1], [J, U, W]), Pe = ce / (ce * ce - 0.5 * V * st), Ce = -V * Pe, ae = $(s[2], [I, H, B]) - 1, it = $(s[2], [j, Q, G]), zr = $(s[2], [J, U, W]), qt = it / (it * it - 0.5 * ae * zr), ot = -ae * qt;
+    le = Oe >= 0 ? le : gt, Ce = Pe >= 0 ? Ce : gt, ot = qt >= 0 ? ot : gt, l += Math.min(le, Math.min(Ce, ot));
+  }
+  return l;
+}
+function yr(t, e, r) {
+  let [n, a, s] = t, i = nt(a, s, e, r), o = Ba(a, s, n, 1, n, e, r, i), l = Dt(i), c = o / Math.min(n * l[0], (1 - n) * l[1]), f = xa(a, s), u = n * f[0], h = (1 - n) * f[1], m = 0.9 * c * Math.sqrt(Math.sqrt(1 / (1 / u ** 4 + 1 / h ** 4)));
+  return u = n * 0.4, h = (1 - n) * 0.8, [Math.sqrt(1 / (1 / u ** 2 + 1 / h ** 2)), m, o];
+}
+function za(t, e, r, n) {
+  let a, s, i, o, l, c, f, u;
+  $(n[0][0], [t, e]) > 1 ? ([a, s, i, o, l] = n[0][1], [c, f, u] = r[0]) : $(n[1][0], [t, e]) > 1 ? ([a, s, i, o, l] = n[1][1], [c, f, u] = r[1]) : ([a, s, i, o, l] = n[2][1], [c, f, u] = r[2]);
+  let h = a + s * t + i * e + o * t ** 2 + l * t * e, m = $(ee[0].slice(1), [t, e]), d = $(ee[1].slice(1), [t, e]), M = $(ee[2].slice(1), [t, e]), p = 1 + h * m, w = 1 + h * d, b = 1 + h * M, y = p ** 3, _ = w ** 3, S = b ** 3, I = 3 * m * p ** 2, H = 3 * d * w ** 2, B = 3 * M * b ** 2, j = 6 * m ** 2 * p, Q = 6 * d ** 2 * w, G = 6 * M ** 2 * b, J = c * y + f * _ + u * S, U = c * I + f * H + u * B, W = c * j + f * Q + u * G;
+  return h = h - J * U / (U ** 2 - 0.5 * J * W), h;
+}
+function Ea(t, e, r) {
+  let [n, a, s] = t, i = de(s), o = null, l = null;
+  if (n = X(n) / 360, i !== 0 && i !== 1 && a !== 0) {
+    let c = Math.cos(Me * n), f = Math.sin(Me * n), [u, h, m] = yr([i, c, f], e, r), d = 0.8, M = 1.25, p, w, b, y;
+    a < d ? (p = M * a, w = 0, b = d * u, y = 1 - b / h) : (p = 5 * (a - 0.8), w = h, b = 0.2 * h ** 2 * 1.25 ** 2 / u, y = 1 - b / (m - h));
+    let _ = w + p * b / (1 - y * p);
+    o = _ * c, l = _ * f;
+  }
+  return [i, o, l];
+}
+function ka(t, e, r) {
+  let n = 1e-7, a = 1e-4, s = t[0], i = 0, o = xe(s), l = Math.sqrt(t[1] ** 2 + t[2] ** 2), c = 0.5 + Math.atan2(-t[2], -t[1]) / Me;
+  if (o !== 0 && o !== 1 && l !== 0) {
+    let u = t[1] / l, h = t[2] / l, [m, d, M] = yr([s, u, h], e, r), p = 0.8, w = 1.25, b, y, _, S;
+    l < d ? (y = p * m, _ = 1 - y / d, S = l / (y + _ * l), i = S * p) : (b = d, y = 0.2 * d ** 2 * w ** 2 / m, _ = 1 - y / (M - d), S = (l - b) / (y + _ * (l - b)), i = p + 0.2 * S);
+  }
+  const f = Math.abs(i) < a;
+  return f || o === 0 || Math.abs(1 - o) < n ? (c = null, f || (i = 0)) : c = X(c * 360), [c, i, o];
+}
+var $a = new g({
+  id: "okhsl",
+  name: "Okhsl",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 1],
+      name: "Saturation"
+    },
+    l: {
+      range: [0, 1],
+      name: "Lightness"
+    }
+  },
+  base: Z,
+  gamutSpace: "self",
+  // Convert Oklab to Okhsl
+  fromBase(t) {
+    return ka(t, Qe, Ue);
+  },
+  // Convert Okhsl to Oklab
+  toBase(t) {
+    return Ea(t, Qe, Ue);
+  },
+  formats: {
+    color: {
+      id: "--okhsl",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+}), wr = new g({
+  id: "oklrab",
+  name: "Oklrab",
+  coords: {
+    l: {
+      refRange: [0, 1],
+      name: "Lightness"
+    },
+    a: {
+      refRange: [-0.4, 0.4]
+    },
+    b: {
+      refRange: [-0.4, 0.4]
+    }
+  },
+  // Note that XYZ is relative to D65
+  white: "D65",
+  base: Z,
+  fromBase(t) {
+    return [xe(t[0]), t[1], t[2]];
+  },
+  toBase(t) {
+    return [de(t[0]), t[1], t[2]];
+  },
+  formats: {
+    color: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>[-1,1]",
+        "<number> | <percentage>[-1,1]"
+      ]
+    }
+  }
+}), Aa = new g({
+  id: "oklrch",
+  name: "Oklrch",
+  coords: {
+    l: {
+      refRange: [0, 1],
+      name: "Lightness"
+    },
+    c: {
+      refRange: [0, 0.4],
+      name: "Chroma"
+    },
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  white: "D65",
+  base: wr,
+  fromBase: q.fromBase,
+  toBase: q.toBase,
+  formats: {
+    color: {
+      coords: [
+        "<percentage> | <number>",
+        "<number> | <percentage>[0,1]",
+        "<number> | <angle>"
+      ]
+    }
+  }
+});
+function Oa(t, e, r) {
+  let [n, a, s] = t;
+  n = X(n) / 360;
+  let i = de(s), o = null, l = null;
+  if (i !== 0 && a !== 0) {
+    let c = Math.cos(Me * n), f = Math.sin(Me * n), u = nt(c, f, e, r), [h, m] = Dt(u), d = 0.5, M = 1 - d / h, p = 1 - a * d / (d + m - m * M * a), w = a * m * d / (d + m - m * M * a);
+    i = s * p;
+    let b = s * w, y = de(p), _ = w * y / p, S = de(i);
+    b = b * S / i, i = S;
+    let [I, H, B] = Tt([y, c * _, f * _], e), j = E(1 / Math.max(Math.max(I, H), Math.max(B, 0)), 1 / 3);
+    i = i * j, b = b * j, o = b * c, l = b * f;
+  }
+  return [i, o, l];
+}
+function Pa(t, e, r) {
+  let n = 1e-4, a = t[0], s = 0, i = xe(a), o = Math.sqrt(t[1] ** 2 + t[2] ** 2), l = 0.5 + Math.atan2(-t[2], -t[1]) / Me;
+  if (a !== 0 && a !== 1 && o !== 0) {
+    let c = t[1] / o, f = t[2] / o, u = nt(c, f, e, r), [h, m] = Dt(u), d = 0.5, M = 1 - d / h, p = m / (o + a * m), w = p * a, b = p * o, y = de(w), _ = b * y / w, [S, I, H] = Tt([y, c * _, f * _], e), B = E(1 / Math.max(Math.max(S, I), Math.max(H, 0)), 1 / 3);
+    a = a / B, o = o / B, o = o * xe(a) / a, a = xe(a), i = a / w, s = (d + m) * b / (m * d + m * M * b);
+  }
+  return Math.abs(s) < n || i === 0 ? l = null : l = X(l * 360), [l, s, i];
+}
+var Ia = new g({
+  id: "okhsv",
+  name: "Okhsv",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 1],
+      name: "Saturation"
+    },
+    v: {
+      range: [0, 1],
+      name: "Value"
+    }
+  },
+  base: Z,
+  gamutSpace: "self",
+  // Convert Oklab to Okhsl
+  fromBase(t) {
+    return Pa(t, Qe, Ue);
+  },
+  // Convert Okhsl to Oklab
+  toBase(t) {
+    return Oa(t, Qe, Ue);
+  },
+  formats: {
+    color: {
+      id: "--okhsv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+let Cr = P.D65;
+const Ha = 216 / 24389, w0 = 24389 / 27, [C0, _0] = rt({ space: A, coords: Cr });
+var _r = new g({
+  id: "luv",
+  name: "Luv",
+  coords: {
+    l: {
+      refRange: [0, 100],
+      name: "Lightness"
+    },
+    // Reference ranges from https://facelessuser.github.io/coloraide/colors/luv/
+    u: {
+      refRange: [-215, 215]
+    },
+    v: {
+      refRange: [-215, 215]
+    }
+  },
+  white: Cr,
+  base: A,
+  // Convert D65-adapted XYZ to Luv
+  // https://en.wikipedia.org/wiki/CIELUV#The_forward_transformation
+  fromBase(t) {
+    let e = (
+      /** @type {[number, number, number]} */
+      [
+        z(t[0]),
+        z(t[1]),
+        z(t[2])
+      ]
+    ), r = e[1], [n, a] = rt({ space: A, coords: e });
+    if (!Number.isFinite(n) || !Number.isFinite(a))
+      return [0, 0, 0];
+    let s = r <= Ha ? w0 * r : 116 * Math.cbrt(r) - 16;
+    return [s, 13 * s * (n - C0), 13 * s * (a - _0)];
+  },
+  // Convert Luv to D65-adapted XYZ
+  // https://en.wikipedia.org/wiki/CIELUV#The_reverse_transformation
+  toBase(t) {
+    let [e, r, n] = t;
+    if (e === 0 || L(e))
+      return [0, 0, 0];
+    r = z(r), n = z(n);
+    let a = r / (13 * e) + C0, s = n / (13 * e) + _0, i = e <= 8 ? e / w0 : Math.pow((e + 16) / 116, 3);
+    return [i * (9 * a / (4 * s)), i, i * ((12 - 3 * a - 20 * s) / (4 * s))];
+  },
+  formats: {
+    color: {
+      id: "--luv",
+      coords: [
+        "<number> | <percentage>",
+        "<number> | <percentage>",
+        "<number> | <percentage>"
+      ]
+    }
+  }
+}), Yt = new g({
+  id: "lchuv",
+  name: "LChuv",
+  coords: {
+    l: {
+      refRange: [0, 100],
+      name: "Lightness"
+    },
+    c: {
+      refRange: [0, 220],
+      name: "Chroma"
+    },
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  base: _r,
+  fromBase: q.fromBase,
+  toBase: q.toBase,
+  formats: {
+    color: {
+      id: "--lchuv",
+      coords: ["<number> | <percentage>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+const ja = 216 / 24389, Da = 24389 / 27, L0 = k[0][0], R0 = k[0][1], pt = k[0][2], v0 = k[1][0], S0 = k[1][1], bt = k[1][2], x0 = k[2][0], B0 = k[2][1], Mt = k[2][2];
+function he(t, e, r) {
+  const n = e / (Math.sin(r) - t * Math.cos(r));
+  return n < 0 ? 1 / 0 : n;
+}
+function Ve(t) {
+  const e = Math.pow(t + 16, 3) / 1560896, r = e > ja ? e : t / Da, n = r * (284517 * L0 - 94839 * pt), a = r * (838422 * pt + 769860 * R0 + 731718 * L0), s = r * (632260 * pt - 126452 * R0), i = r * (284517 * v0 - 94839 * bt), o = r * (838422 * bt + 769860 * S0 + 731718 * v0), l = r * (632260 * bt - 126452 * S0), c = r * (284517 * x0 - 94839 * Mt), f = r * (838422 * Mt + 769860 * B0 + 731718 * x0), u = r * (632260 * Mt - 126452 * B0);
+  return {
+    r0s: n / s,
+    r0i: a * t / s,
+    r1s: n / (s + 126452),
+    r1i: (a - 769860) * t / (s + 126452),
+    g0s: i / l,
+    g0i: o * t / l,
+    g1s: i / (l + 126452),
+    g1i: (o - 769860) * t / (l + 126452),
+    b0s: c / u,
+    b0i: f * t / u,
+    b1s: c / (u + 126452),
+    b1i: (f - 769860) * t / (u + 126452)
+  };
+}
+function z0(t, e) {
+  const r = e / 360 * Math.PI * 2, n = he(t.r0s, t.r0i, r), a = he(t.r1s, t.r1i, r), s = he(t.g0s, t.g0i, r), i = he(t.g1s, t.g1i, r), o = he(t.b0s, t.b0i, r), l = he(t.b1s, t.b1i, r);
+  return Math.min(n, a, s, i, o, l);
+}
+var Ta = new g({
+  id: "hsluv",
+  name: "HSLuv",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 100],
+      name: "Saturation"
+    },
+    l: {
+      range: [0, 100],
+      name: "Lightness"
+    }
+  },
+  base: Yt,
+  gamutSpace: oe,
+  // Convert LCHuv to HSLuv
+  fromBase(t) {
+    let [e, r, n] = [z(t[0]), z(t[1]), z(t[2])], a;
+    if (e > 99.9999999)
+      a = 0, e = 100;
+    else if (e < 1e-8)
+      a = 0, e = 0;
+    else {
+      let s = Ve(e), i = z0(s, n);
+      a = r / i * 100;
+    }
+    return [n, a, e];
+  },
+  // Convert HSLuv to LCHuv
+  toBase(t) {
+    let [e, r, n] = [z(t[0]), z(t[1]), z(t[2])], a;
+    if (n > 99.9999999)
+      n = 100, a = 0;
+    else if (n < 1e-8)
+      n = 0, a = 0;
+    else {
+      let s = Ve(n);
+      a = z0(s, e) / 100 * r;
+    }
+    return [n, a, e];
+  },
+  formats: {
+    color: {
+      id: "--hsluv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+k[0][0];
+k[0][1];
+k[0][2];
+k[1][0];
+k[1][1];
+k[1][2];
+k[2][0];
+k[2][1];
+k[2][2];
+function me(t, e) {
+  return Math.abs(e) / Math.sqrt(Math.pow(t, 2) + 1);
+}
+function E0(t) {
+  let e = me(t.r0s, t.r0i), r = me(t.r1s, t.r1i), n = me(t.g0s, t.g0i), a = me(t.g1s, t.g1i), s = me(t.b0s, t.b0i), i = me(t.b1s, t.b1i);
+  return Math.min(e, r, n, a, s, i);
+}
+var Ya = new g({
+  id: "hpluv",
+  name: "HPLuv",
+  coords: {
+    h: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    },
+    s: {
+      range: [0, 100],
+      name: "Saturation"
+    },
+    l: {
+      range: [0, 100],
+      name: "Lightness"
+    }
+  },
+  base: Yt,
+  gamutSpace: "self",
+  // Convert LCHuv to HPLuv
+  fromBase(t) {
+    let [e, r, n] = [z(t[0]), z(t[1]), z(t[2])], a;
+    if (e > 99.9999999)
+      a = 0, e = 100;
+    else if (e < 1e-8)
+      a = 0, e = 0;
+    else {
+      let s = Ve(e), i = E0(s);
+      a = r / i * 100;
+    }
+    return [n, a, e];
+  },
+  // Convert HPLuv to LCHuv
+  toBase(t) {
+    let [e, r, n] = [z(t[0]), z(t[1]), z(t[2])], a;
+    if (n > 99.9999999)
+      n = 100, a = 0;
+    else if (n < 1e-8)
+      n = 0, a = 0;
+    else {
+      let s = Ve(n);
+      a = E0(s) / 100 * r;
+    }
+    return [n, a, e];
+  },
+  formats: {
+    color: {
+      id: "--hpluv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+}), Nt = new O({
+  id: "rec2100-linear",
+  name: "Linear REC.2100",
+  white: "D65",
+  toBase: Ee.toBase,
+  fromBase: Ee.fromBase
+});
+const k0 = 203, $0 = 2610 / 2 ** 14, Na = 2 ** 14 / 2610, qa = 2523 / 2 ** 5, A0 = 2 ** 5 / 2523, O0 = 3424 / 2 ** 12, P0 = 2413 / 2 ** 7, I0 = 2392 / 2 ** 7;
+var Xa = new O({
+  id: "rec2100pq",
+  cssId: "rec2100-pq",
+  name: "REC.2100-PQ",
+  base: Nt,
+  toBase(t) {
+    return t.map(function(e) {
+      return (Math.max(e ** A0 - O0, 0) / (P0 - I0 * e ** A0)) ** Na * 1e4 / k0;
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      let r = Math.max(e * k0 / 1e4, 0), n = O0 + P0 * r ** $0, a = 1 + I0 * r ** $0;
+      return (n / a) ** qa;
+    });
+  }
+});
+const H0 = 0.17883277, j0 = 0.28466892, D0 = 0.55991073, yt = 3.7743;
+var Ga = new O({
+  id: "rec2100hlg",
+  cssId: "rec2100-hlg",
+  name: "REC.2100-HLG",
+  referred: "scene",
+  base: Nt,
+  toBase(t) {
+    return t.map(function(e) {
+      return e <= 0.5 ? e ** 2 / 3 * yt : (Math.exp((e - D0) / H0) + j0) / 12 * yt;
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      return e /= yt, e <= 1 / 12 ? E(3 * e, 0.5) : H0 * Math.log(12 * e - j0) + D0;
+    });
+  }
+});
+const Lr = {};
+te.add("chromatic-adaptation-start", (t) => {
+  t.options.method && (t.M = Rr(t.W1, t.W2, t.options.method));
+});
+te.add("chromatic-adaptation-end", (t) => {
+  t.M || (t.M = Rr(t.W1, t.W2, t.options.method));
+});
+function at({ id: t, toCone_M: e, fromCone_M: r }) {
+  Lr[t] = arguments[0];
+}
+function Rr(t, e, r = "Bradford") {
+  let n = Lr[r], [a, s, i] = _e(n.toCone_M, t), [o, l, c] = _e(n.toCone_M, e), f = [
+    [o / a, 0, 0],
+    [0, l / s, 0],
+    [0, 0, c / i]
+  ], u = _e(f, n.toCone_M);
+  return _e(n.fromCone_M, u);
+}
+at({
+  id: "von Kries",
+  toCone_M: [
+    [0.40024, 0.7076, -0.08081],
+    [-0.2263, 1.16532, 0.0457],
+    [0, 0, 0.91822]
+  ],
+  fromCone_M: [
+    [1.8599363874558397, -1.1293816185800916, 0.21989740959619328],
+    [0.3611914362417676, 0.6388124632850422, -6370596838649899e-21],
+    [0, 0, 1.0890636230968613]
+  ]
+});
+at({
+  id: "Bradford",
+  // Convert an array of XYZ values in the range 0.0 - 1.0
+  // to cone fundamentals
+  toCone_M: [
+    [0.8951, 0.2664, -0.1614],
+    [-0.7502, 1.7135, 0.0367],
+    [0.0389, -0.0685, 1.0296]
+  ],
+  // and back
+  fromCone_M: [
+    [0.9869929054667121, -0.14705425642099013, 0.15996265166373122],
+    [0.4323052697233945, 0.5183602715367774, 0.049291228212855594],
+    [-0.00852866457517732, 0.04004282165408486, 0.96848669578755]
+  ]
+});
+at({
+  id: "CAT02",
+  // with complete chromatic adaptation to W2, so D = 1.0
+  toCone_M: [
+    [0.7328, 0.4296, -0.1624],
+    [-0.7036, 1.6975, 61e-4],
+    [3e-3, 0.0136, 0.9834]
+  ],
+  fromCone_M: [
+    [1.0961238208355142, -0.27886900021828726, 0.18274517938277307],
+    [0.4543690419753592, 0.4735331543074117, 0.07209780371722911],
+    [-0.009627608738429355, -0.00569803121611342, 1.0153256399545427]
+  ]
+});
+at({
+  id: "CAT16",
+  toCone_M: [
+    [0.401288, 0.650173, -0.051461],
+    [-0.250268, 1.204414, 0.045854],
+    [-2079e-6, 0.048952, 0.953127]
+  ],
+  // the extra precision is needed to avoid roundtripping errors
+  fromCone_M: [
+    [1.862067855087233, -1.0112546305316845, 0.14918677544445172],
+    [0.3875265432361372, 0.6214474419314753, -0.008973985167612521],
+    [-0.01584149884933386, -0.03412293802851557, 1.0499644368778496]
+  ]
+});
+Object.assign(P, {
+  // whitepoint values from ASTM E308-01 with 10nm spacing, 1931 2 degree observer
+  // all normalized to Y (luminance) = 1.00000
+  // Illuminant A is a tungsten electric light, giving a very warm, orange light.
+  A: [1.0985, 1, 0.35585],
+  // Illuminant C was an early approximation to daylight: illuminant A with a blue filter.
+  C: [0.98074, 1, 1.18232],
+  // The daylight series of illuminants simulate natural daylight.
+  // The color temperature (in degrees Kelvin/100) ranges from
+  // cool, overcast daylight (D50) to bright, direct sunlight (D65).
+  D55: [0.95682, 1, 0.92149],
+  D75: [0.94972, 1, 1.22638],
+  // Equal-energy illuminant, used in two-stage CAT16
+  E: [1, 1, 1],
+  // The F series of illuminants represent fluorescent lights
+  F2: [0.99186, 1, 0.67393],
+  F7: [0.95041, 1, 1.08747],
+  F11: [1.00962, 1, 0.6435]
+});
+P.ACES = [0.32168 / 0.33767, 1, (1 - 0.32168 - 0.33767) / 0.33767];
+const Za = [
+  [0.6624541811085053, 0.13400420645643313, 0.1561876870049078],
+  [0.27222871678091454, 0.6740817658111484, 0.05368951740793705],
+  [-0.005574649490394108, 0.004060733528982826, 1.0103391003129971]
+], Ja = [
+  [1.6410233796943257, -0.32480329418479, -0.23642469523761225],
+  [-0.6636628587229829, 1.6153315916573379, 0.016756347685530137],
+  [0.011721894328375376, -0.008284441996237409, 0.9883948585390215]
+];
+var vr = new O({
+  id: "acescg",
+  cssId: "--acescg",
+  name: "ACEScg",
+  // ACEScg – A scene-referred, linear-light encoding of ACES Data
+  // https://docs.acescentral.com/specifications/acescg/
+  // uses the AP1 primaries, see section 4.3.1 Color primaries
+  coords: {
+    r: {
+      range: [0, 65504],
+      name: "Red"
+    },
+    g: {
+      range: [0, 65504],
+      name: "Green"
+    },
+    b: {
+      range: [0, 65504],
+      name: "Blue"
+    }
+  },
+  referred: "scene",
+  white: P.ACES,
+  toXYZ_M: Za,
+  fromXYZ_M: Ja
+});
+const Ne = 2 ** -16, wt = -0.35828683, qe = (Math.log2(65504) + 9.72) / 17.52;
+var Wa = new O({
+  id: "acescc",
+  cssId: "--acescc",
+  name: "ACEScc",
+  // see S-2014-003 ACEScc – A Logarithmic Encoding of ACES Data
+  // https://docs.acescentral.com/specifications/acescc/
+  // uses the AP1 primaries, see section 4.3.1 Color primaries
+  // Appendix A: "Very small ACES scene referred values below 7 1/4 stops
+  // below 18% middle gray are encoded as negative ACEScc values.
+  // These values should be preserved per the encoding in Section 4.4
+  // so that all positive ACES values are maintained."
+  coords: {
+    r: {
+      range: [wt, qe],
+      name: "Red"
+    },
+    g: {
+      range: [wt, qe],
+      name: "Green"
+    },
+    b: {
+      range: [wt, qe],
+      name: "Blue"
+    }
+  },
+  referred: "scene",
+  base: vr,
+  // from section 4.4.2 Decoding Function
+  toBase(t) {
+    const e = -0.3013698630136986;
+    return t.map(function(r) {
+      return r <= e ? (2 ** (r * 17.52 - 9.72) - Ne) * 2 : r < qe ? 2 ** (r * 17.52 - 9.72) : 65504;
+    });
+  },
+  // Non-linear encoding function from S-2014-003, section 4.4.1 Encoding Function
+  fromBase(t) {
+    return t.map(function(e) {
+      return e <= 0 ? (Math.log2(Ne) + 9.72) / 17.52 : e < Ne ? (Math.log2(Ne + e * 0.5) + 9.72) / 17.52 : (Math.log2(e) + 9.72) / 17.52;
+    });
+  }
+  // encoded media white (rgb 1,1,1) => linear  [ 222.861, 222.861, 222.861 ]
+  // encoded media black (rgb 0,0,0) => linear [ 0.0011857, 0.0011857, 0.0011857]
+}), T0 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  A98RGB: ya,
+  A98RGB_Linear: br,
+  ACEScc: Wa,
+  ACEScg: vr,
+  CAM16_JMh: vn,
+  HCT: ze,
+  HPLuv: Ya,
+  HSL: ga,
+  HSLuv: Ta,
+  HSV: pr,
+  HWB: pa,
+  ICTCP: vt,
+  JzCzHz: Rt,
+  Jzazbz: Q0,
+  LCH: q,
+  LCHuv: Yt,
+  Lab: Y,
+  Lab_D65: Bt,
+  Luv: _r,
+  OKLCH: Sa,
+  OKLab: Z,
+  OKLrCH: Aa,
+  OKLrab: wr,
+  Okhsl: $a,
+  Okhsv: Ia,
+  P3: cr,
+  P3_Linear: or,
+  ProPhoto: Ra,
+  ProPhoto_Linear: Mr,
+  REC_2020: ir,
+  REC_2020_Linear: Ee,
+  REC_2020_Scene_Referred: va,
+  REC_2100_HLG: Ga,
+  REC_2100_Linear: Nt,
+  REC_2100_PQ: Xa,
+  XYZ_ABS_D65: Pt,
+  XYZ_D50: Ot,
+  XYZ_D65: A,
+  sRGB: oe,
+  sRGB_Linear: lr
+});
+class R {
+  /**
+   * Creates an instance of Color.
+   * Signatures:
+   * - `new Color(stringToParse)`
+   * - `new Color(otherColor)`
+   * - `new Color({space, coords, alpha})`
+   * - `new Color(space, coords, alpha)`
+   * - `new Color(spaceId, coords, alpha)`
+   */
+  constructor(...e) {
+    let r;
+    if (e.length === 1) {
+      let i = {};
+      typeof e[0] == "object" && Object.getPrototypeOf(e[0]).constructor === Object && (e[0] = { ...e[0] }), r = C(e[0], { parseMeta: i }), i.format && (this.parseMeta = i);
+    }
+    let n, a, s;
+    r ? (n = r.space || r.spaceId, a = r.coords, s = r.alpha) : [n, a, s] = e, Object.defineProperty(this, "space", {
+      value: g.get(n),
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+      // see note in https://262.ecma-international.org/8.0/#sec-proxy-object-internal-methods-and-internal-slots-get-p-receiver
+    }), this.coords = a ? a.slice() : [0, 0, 0], this.alpha = L(s) ? s : s === void 0 ? 1 : et(0, s, 1);
+    for (let i in this.space.coords)
+      Object.defineProperty(this, i, {
+        get: () => this.get(i),
+        set: (o) => this.set(i, o)
+      });
+  }
+  get spaceId() {
+    return this.space.id;
+  }
+  clone() {
+    return new R(this.space, this.coords, this.alpha);
+  }
+  toJSON() {
+    return {
+      spaceId: this.spaceId,
+      coords: this.coords,
+      alpha: this.alpha
+    };
+  }
+  display(...e) {
+    let r = Yn(this, ...e);
+    return r.color = new R(r.color), r;
+  }
+  /**
+   * Get a color from the argument(s) passed
+   * Basically gets us the same result as new Color(color) but doesn't clone an existing color object
+   */
+  static get(e, ...r) {
+    return ge(e, this) ? e : new R(e, ...r);
+  }
+  /**
+   * Get a color instance from the argument passed or `null` if resolution fails (instead of throwing an error).
+   * Additionally, it supports passing an element to resolve complex CSS colors through the DOM (slow).
+   * @see {@link tryColor} for more details
+   */
+  static try(e, r) {
+    if (ge(e, this))
+      return e;
+    let n = Z0(e, r);
+    return n ? new R(n) : null;
+  }
+  static defineFunction(e, r, n = r) {
+    let { instance: a = !0, returns: s } = n, i = function(...o) {
+      let l = r(...o);
+      if (s === "color")
+        l = R.get(l);
+      else if (s === "function<color>") {
+        let c = l;
+        l = function(...f) {
+          let u = c(...f);
+          return R.get(u);
+        }, Object.assign(l, c);
+      } else s === "array<color>" && (l = l.map((c) => R.get(c)));
+      return l;
+    };
+    e in R || (R[e] = i), a && (R.prototype[e] = function(...o) {
+      return i(this, ...o);
+    });
+  }
+  static defineFunctions(e) {
+    for (let r in e)
+      R.defineFunction(r, e[r], e[r]);
+  }
+  static extend(e) {
+    if (e.register)
+      e.register(R);
+    else
+      for (let r in e)
+        R.defineFunction(r, e[r]);
+  }
+}
+R.defineFunctions({
+  get: T,
+  getAll: ke,
+  set: F,
+  setAll: At,
+  to: v,
+  equals: qn,
+  inGamut: ie,
+  toGamut: re,
+  distance: F0,
+  deltas: Nn,
+  toString: ve
+});
+Object.assign(R, {
+  util: Dr,
+  hooks: te,
+  WHITES: P,
+  Space: g,
+  spaces: g.registry,
+  parse: X0,
+  // Global defaults one may want to configure
+  defaults: N
+});
+for (let t of Object.keys(T0))
+  g.register(T0[t]);
+for (let t in g.registry)
+  zt(t, g.registry[t]);
+te.add("colorspace-init-end", (t) => {
+  zt(t.id, t), t.aliases?.forEach((e) => {
+    zt(e, t);
+  });
+});
+function zt(t, e) {
+  let r = t.replace(/-/g, "_");
+  Object.defineProperty(R.prototype, r, {
+    // Convert coords to coords in another colorspace and return them
+    // Source colorspace: this.spaceId
+    // Target colorspace: id
+    get() {
+      let n = this.getAll(t);
+      if (typeof Proxy > "u")
+        return n;
+      let a = new Proxy(n, {
+        has: (
+          /** @param {string} property */
+          (s, i) => {
+            try {
+              return g.resolveCoord([e, i]), !0;
+            } catch {
+            }
+            return Reflect.has(s, i);
+          }
+        ),
+        get: (s, i, o) => {
+          if (i && typeof i != "symbol" && !(i in s) && i in a) {
+            let { index: l } = g.resolveCoord([e, i]);
+            if (l >= 0)
+              return s[l];
+          }
+          return Reflect.get(s, i, o);
+        },
+        set: (s, i, o, l) => {
+          if (i && typeof i != "symbol" && !(i in s) || Number(i) >= 0) {
+            let { index: c } = g.resolveCoord([
+              e,
+              /** @type {string} */
+              i
+            ]);
+            if (c >= 0)
+              return s[c] = o, this.setAll(t, s), !0;
+          }
+          return Reflect.set(s, i, o, l);
+        }
+      });
+      return a;
+    },
+    // Convert coords in another colorspace to internal coords and set them
+    // Target colorspace: this.spaceId
+    // Source colorspace: id
+    set(n) {
+      this.setAll(t, n);
+    },
+    configurable: !0,
+    enumerable: !0
+  });
+}
+R.extend(be);
+R.extend({ deltaE: Le });
+Object.assign(R, { deltaEMethods: be });
+R.extend(ha);
+R.extend({ contrast: ca });
+R.extend(fa);
+R.extend(Gn);
+R.extend(da);
+R.extend(Xe);
+const Fa = {
+  RED: "red",
+  ORANGE: "orange",
+  YELLOW: "yellow",
+  GREEN: "green",
+  BLUE: "blue",
+  PURPLE: "purple"
+}, Qa = [
+  {
+    name: "RED",
+    hue: (t) => t < 30 || t > 315,
+    rgb: ([t, e, r]) => t >= e + r
+  },
+  {
+    name: "ORANGE",
+    hue: (t) => t >= 30 && t <= 60,
+    rgb: ([t, e, r]) => t > e && e > r && t > r
+  },
+  {
+    name: "YELLOW",
+    hue: (t) => t > 45 && t <= 75,
+    rgb: ([t, e, r]) => t >= e && e >= r && Math.abs(t - e) < 100
+  },
+  {
+    name: "GREEN",
+    hue: (t) => t > 75 && t <= 180,
+    rgb: ([t, e, r]) => e > t && e > r
+  },
+  {
+    name: "BLUE",
+    hue: (t) => t > 180 && t <= 270,
+    rgb: ([t, e, r]) => r > t && r > e
+  },
+  {
+    name: "PURPLE",
+    hue: (t) => t > 270 && t <= 315,
+    rgb: ([t, e, r]) => t > e && r > e
+  }
+], Ua = $r`
+  .clippy-color-combobox__option {
+    align-items: center;
+    display: flex;
+  }
+`;
+var Va = Object.defineProperty, Ka = Object.getOwnPropertyDescriptor, Sr = (t) => {
+  throw TypeError(t);
+}, xr = (t, e, r, n) => {
+  for (var a = n > 1 ? void 0 : n ? Ka(e, r) : e, s = t.length - 1, i; s >= 0; s--)
+    (i = t[s]) && (a = (n ? i(e, r, a) : i(a)) || a);
+  return n && a && Va(e, r, a), a;
+}, Br = (t, e, r) => e.has(t) || Sr("Cannot " + r), es = (t, e, r) => (Br(t, e, "read from private field"), r ? r.call(t) : e.get(t)), ts = (t, e, r) => e.has(t) ? Sr("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), rs = (t, e, r, n) => (Br(t, e, "write to private field"), e.set(t, r), r), Ge;
+const ns = "clippy-color-combobox";
+class as extends Y0 {
+}
+let Ke = class extends kr(as) {
+  constructor() {
+    super(...arguments), this.translations = Fa, ts(this, Ge, []), this.filter = (t) => {
+      const e = t.toLowerCase();
+      return (r) => {
+        const n = r.label.toLowerCase(), a = r.names;
+        return n.includes(e) || a.some((s) => this.translations[s]?.includes(e));
+      };
+    };
+  }
+  set lang(t) {
+    this.loadLocalizations(t).then(() => {
+      super.lang = t;
+    });
+  }
+  async loadLocalizations(t) {
+    const r = t.split("-");
+    let n;
+    for (let a = r.length; a > 0; a--) {
+      const s = r.slice(0, a).join("-");
+      try {
+        n = await Hr(/* @__PURE__ */ Object.assign({ "./messages/en.ts": () => import("./en-B-D8DBsf.js"), "./messages/nl.ts": () => import("./nl-CJG2-yS5.js") }), `./messages/${s}.ts`, 3).then((i) => i.default), this.translations = n || this.translations, this.lang = s;
+        break;
+      } catch {
+      }
+    }
+  }
+  get options() {
+    return es(this, Ge);
+  }
+  set options(t) {
+    rs(this, Ge, t.map(({ label: e, value: r }) => {
+      const n = new R(r), a = Qa.filter(({ hue: s, rgb: i }) => n.h ? s(n.h) : i([n.r || 0, n.g || 0, n.b || 0])).map(({ name: s }) => s);
+      return {
+        color: n,
+        label: e,
+        names: a,
+        value: r
+      };
+    }));
+  }
+  valueToQuery(t) {
+    return Array.isArray(t) ? t[0] : t.split(",")[0];
+  }
+  renderEntry(t) {
+    const e = t.color?.toString();
+    return Ar`
+      <span class="clippy-color-combobox__option">
+        <svg role="img" xmlns="http://www.w3.org/2000/svg" class="nl-color-sample" style=${Ir({ color: e })}>
+          <path d="M0 0H32V32H0Z" fill="currentcolor" />
+        </svg>
+        <span>${t.label}</span>
+      </span>
+    `;
+  }
+};
+Ge = /* @__PURE__ */ new WeakMap();
+Ke.styles = [...Y0.styles, Ua, Or(jr)];
+xr([
+  Pr({ type: Array })
+], Ke.prototype, "options", 1);
+Ke = xr([
+  Er(ns)
+], Ke);
+export {
+  Fa as C,
+  Ke as a
+};