@luzmo/analytics-components-kit 1.0.1-alpha.47 → 1.0.1-alpha.48

package/components/color-DuJ4-73S.js

@@ -0,0 +1,2867 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2025 Luzmo
+ * All rights reserved.
+ * Luzmo web components (“Luzmo Web Components”)
+ * must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account
+ * to use the Luzmo Web Components. This license terminates
+ * automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+var tr = Object.defineProperty;
+var rr = (t, e, r) => e in t ? tr(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var ve = (t, e, r) => rr(t, typeof e != "symbol" ? e + "" : e, r);
+function L(t, e) {
+  let r = t.length;
+  Array.isArray(t[0]) || (t = [t]), Array.isArray(e[0]) || (e = e.map((i) => [i]));
+  let n = e[0].length, a = e[0].map((i, o) => e.map((l) => l[o])), s = t.map((i) => a.map((o) => {
+    let l = 0;
+    if (!Array.isArray(i)) {
+      for (let c of o)
+        l += i * c;
+      return l;
+    }
+    for (let c = 0; c < i.length; c++)
+      l += i[c] * (o[c] || 0);
+    return l;
+  }));
+  return r === 1 && (s = s[0]), n === 1 ? s.map((i) => i[0]) : s;
+}
+function ue(t) {
+  return D(t) === "string";
+}
+function D(t) {
+  return (Object.prototype.toString.call(t).match(/^\[object\s+(.*?)\]$/)[1] || "").toLowerCase();
+}
+function Re(t, { precision: e, unit: r }) {
+  return X(t) ? "none" : d0(t, e) + (r ?? "");
+}
+function X(t) {
+  return Number.isNaN(t) || t instanceof Number && (t == null ? void 0 : t.none);
+}
+function R(t) {
+  return X(t) ? 0 : t;
+}
+function d0(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;
+}
+const nr = {
+  deg: 1,
+  grad: 0.9,
+  rad: 180 / Math.PI,
+  turn: 360
+};
+function m0(t) {
+  if (!t)
+    return;
+  t = t.trim();
+  const e = /^([a-z]+)\((.+?)\)$/i, r = /^-?[\d.]+$/, n = /%|deg|g?rad|turn$/, a = /\/?\s*(none|[-\w.]+(?:%|deg|g?rad|turn)?)/g;
+  let s = t.match(e);
+  if (s) {
+    let i = [];
+    return s[2].replace(a, (o, l) => {
+      let c = l.match(n), u = l;
+      if (c) {
+        let f = c[0], h = u.slice(0, -f.length);
+        f === "%" ? (u = new Number(h / 100), u.type = "<percentage>") : (u = new Number(h * nr[f]), u.type = "<angle>", u.unit = f);
+      } else r.test(u) ? (u = new Number(u), u.type = "<number>") : u === "none" && (u = new Number(NaN), u.none = !0);
+      o.startsWith("/") && (u = u instanceof Number ? u : new Number(u), u.alpha = !0), typeof u == "object" && u instanceof Number && (u.raw = l), i.push(u);
+    }), {
+      name: s[1].toLowerCase(),
+      rawName: s[1],
+      rawArgs: s[2],
+      // An argument could be (as of css-color-4):
+      // a number, percentage, degrees (hue), ident (in color())
+      args: i
+    };
+  }
+}
+function g0(t) {
+  return t[t.length - 1];
+}
+function oe(t, e, r) {
+  return isNaN(t) ? e : isNaN(e) ? t : t + (e - t) * r;
+}
+function p0(t, e, r) {
+  return (r - t) / (e - t);
+}
+function Ve(t, e, r) {
+  return oe(e[0], e[1], p0(t[0], t[1], r));
+}
+function b0(t) {
+  return t.map((e) => e.split("|").map((r) => {
+    r = r.trim();
+    let n = r.match(/^(<[a-z]+>)\[(-?[.\d]+),\s*(-?[.\d]+)\]?$/);
+    if (n) {
+      let a = new String(n[1]);
+      return a.range = [+n[2], +n[3]], a;
+    }
+    return r;
+  }));
+}
+function M0(t, e, r) {
+  return Math.max(Math.min(r, e), t);
+}
+function Ie(t, e) {
+  return Math.sign(t) === Math.sign(e) ? t : -t;
+}
+function k(t, e) {
+  return Ie(Math.abs(t) ** e, t);
+}
+function et(t, e) {
+  return e === 0 ? 0 : t / e;
+}
+function w0(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;
+}
+var ar = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  bisectLeft: w0,
+  clamp: M0,
+  copySign: Ie,
+  interpolate: oe,
+  interpolateInv: p0,
+  isNone: X,
+  isString: ue,
+  last: g0,
+  mapRange: Ve,
+  multiplyMatrices: L,
+  parseCoordGrammar: b0,
+  parseFunction: m0,
+  serializeNumber: Re,
+  skipNone: R,
+  spow: k,
+  toPrecision: d0,
+  type: D,
+  zdiv: et
+});
+class sr {
+  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 j = new sr();
+var u0, f0, h0, v = {
+  gamut_mapping: "css",
+  precision: 5,
+  deltaE: "76",
+  // Default deltaE method
+  verbose: ((h0 = (f0 = (u0 = globalThis == null ? void 0 : globalThis.process) == null ? void 0 : u0.env) == null ? void 0 : f0.NODE_ENV) == null ? void 0 : h0.toLowerCase()) !== "test",
+  warn: function(e) {
+    var r, n;
+    this.verbose && ((n = (r = globalThis == null ? void 0 : globalThis.console) == null ? void 0 : r.warn) == null || n.call(r, e));
+  }
+};
+const B = {
+  // 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 Ze(t) {
+  return Array.isArray(t) ? t : B[t];
+}
+function xe(t, e, r, n = {}) {
+  if (t = Ze(t), e = Ze(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 (j.run("chromatic-adaptation-start", a), a.M || (a.W1 === B.D65 && a.W2 === B.D50 ? a.M = [
+    [1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
+    [0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
+    [-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
+  ] : a.W1 === B.D50 && a.W2 === B.D65 && (a.M = [
+    [0.955473421488075, -0.02309845494876471, 0.06325924320057072],
+    [-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
+    [0.012314014864481998, -0.020507649298898964, 1.330365926242124]
+  ])), j.run("chromatic-adaptation-end", a), a.M)
+    return L(a.M, a.XYZ);
+  throw new TypeError("Only Bradford CAT with white points D50 and D65 supported for now.");
+}
+const ir = /* @__PURE__ */ new Set(["<number>", "<percentage>", "<angle>"]);
+function dt(t, e, r, n) {
+  return Object.entries(t.coords).map(([s, i], o) => {
+    let l = e.coordGrammar[o], c = n[o], u = c == null ? void 0 : c.type, f;
+    if (c.none ? f = l.find((d) => ir.has(d)) : f = l.find((d) => d == u), !f) {
+      let d = i.name || s;
+      throw new TypeError(`${u ?? c.raw} not allowed for ${d} in ${r}()`);
+    }
+    let h = f.range;
+    u === "<percentage>" && (h || (h = [0, 1]));
+    let p = i.range || i.refRange;
+    return h && p && (n[o] = Ve(h, p, n[o])), f;
+  });
+}
+function y0(t, { meta: e } = {}) {
+  var n, a, s, i;
+  let r = { str: (n = String(t)) == null ? void 0 : n.trim() };
+  if (j.run("parse-start", r), r.color)
+    return r.color;
+  if (r.parsed = m0(r.str), r.parsed) {
+    let o = r.parsed.name;
+    if (o === "color") {
+      let l = r.parsed.args.shift(), c = l.startsWith("--") ? l.substring(2) : `--${l}`, u = [l, c], f = r.parsed.rawArgs.indexOf("/") > 0 ? r.parsed.args.pop() : 1;
+      for (let d of m.all) {
+        let g = d.getFormat("color");
+        if (g && (u.includes(g.id) || (a = g.ids) != null && a.filter((M) => u.includes(M)).length)) {
+          const M = Object.keys(d.coords).map((S, y) => r.parsed.args[y] || 0);
+          let _;
+          return g.coordGrammar && (_ = dt(d, g, "color", M)), e && Object.assign(e, { formatId: "color", types: _ }), g.id.startsWith("--") && !l.startsWith("--") && v.warn(`${d.name} is a non-standard space and not currently supported in the CSS spec. Use prefixed color(${g.id}) instead of color(${l}).`), l.startsWith("--") && !g.id.startsWith("--") && v.warn(`${d.name} is a standard space and supported in the CSS spec. Use color(${g.id}) instead of prefixed color(${l}).`), { spaceId: d.id, coords: M, alpha: f };
+        }
+      }
+      let h = "", p = l in m.registry ? l : c;
+      if (p in m.registry) {
+        let d = (i = (s = m.registry[p].formats) == null ? void 0 : s.color) == null ? void 0 : i.id;
+        d && (h = `Did you mean color(${d})?`);
+      }
+      throw new TypeError(`Cannot parse color(${l}). ` + (h || "Missing a plugin?"));
+    } else
+      for (let l of m.all) {
+        let c = l.getFormat(o);
+        if (c && c.type === "function") {
+          let u = 1;
+          (c.lastAlpha || g0(r.parsed.args).alpha) && (u = r.parsed.args.pop());
+          let f = r.parsed.args, h;
+          return c.coordGrammar && (h = dt(l, c, o, f)), e && Object.assign(e, { formatId: c.name, types: h }), {
+            spaceId: l.id,
+            coords: f,
+            alpha: u
+          };
+        }
+      }
+  } else
+    for (let o of m.all)
+      for (let l in o.formats) {
+        let c = o.formats[l];
+        if (c.type !== "custom" || c.test && !c.test(r.str))
+          continue;
+        let u = c.parse(r.str);
+        if (u)
+          return u.alpha ?? (u.alpha = 1), e && (e.formatId = l), u;
+      }
+  throw new TypeError(`Could not parse ${t} as a color. Missing a plugin?`);
+}
+function b(t) {
+  if (Array.isArray(t))
+    return t.map(b);
+  if (!t)
+    throw new TypeError("Empty color reference");
+  ue(t) && (t = y0(t));
+  let e = t.space || t.spaceId;
+  return e instanceof m || (t.space = m.get(e)), t.alpha === void 0 && (t.alpha = 1), t;
+}
+const or = 75e-6, I = class I {
+  constructor(e) {
+    var a;
+    this.id = e.id, this.name = e.name, this.base = e.base ? I.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 s in r)
+      "name" in r[s] || (r[s].name = s);
+    this.coords = r;
+    let n = e.white ?? this.base.white ?? "D65";
+    this.white = Ze(n), this.formats = e.formats ?? {};
+    for (let s in this.formats) {
+      let i = this.formats[s];
+      i.type || (i.type = "function"), i.name || (i.name = s);
+    }
+    (a = this.formats.color) != null && a.id || (this.formats.color = {
+      ...this.formats.color ?? {},
+      id: e.cssId || this.id
+    }), e.gamutSpace ? this.gamutSpace = e.gamutSpace === "self" ? this : I.get(e.gamutSpace) : this.isPolar ? this.gamutSpace = this.base : this.gamutSpace = this, this.gamutSpace.isUnbounded && (this.inGamut = (s, i) => !0), this.referred = e.referred, Object.defineProperty(this, "path", {
+      value: lr(this).reverse(),
+      writable: !1,
+      enumerable: !0,
+      configurable: !0
+    }), j.run("colorspace-init-end", this);
+  }
+  inGamut(e, { epsilon: r = or } = {}) {
+    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 (Number.isNaN(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() {
+    var e, r;
+    return ((r = (e = this.formats) == null ? void 0 : e.color) == null ? void 0 : r.id) || this.id;
+  }
+  get isPolar() {
+    for (let e in this.coords)
+      if (this.coords[e].type === "angle")
+        return !0;
+    return !1;
+  }
+  getFormat(e) {
+    if (typeof e == "object")
+      return e = mt(e, this), e;
+    let r;
+    return e === "default" ? r = Object.values(this.formats)[0] : r = this.formats[e], r ? (r = mt(r, this), r) : null;
+  }
+  /**
+   * 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 = b(e);
+      [e, r] = [o.space, o.coords];
+    }
+    if (e = I.get(e), this.equals(e))
+      return r;
+    r = r.map((o) => Number.isNaN(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 = b(e);
+      [e, r] = [n.space, n.coords];
+    }
+    return e = I.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 == null ? void 0 : a.min) ?? 0);
+    }
+    return e;
+  }
+  // Returns array of unique color spaces
+  static get all() {
+    return [...new Set(Object.values(I.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 || e instanceof I)
+      return e;
+    if (D(e) === "string") {
+      let a = I.registry[e.toLowerCase()];
+      if (!a)
+        throw new TypeError(`No color space found with id = "${e}"`);
+      return a;
+    }
+    if (r.length)
+      return I.get(...r);
+    throw new TypeError(`${e} is not a valid color space`);
+  }
+  /**
+   * Get metadata about a coordinate of a color space
+   *
+   * @static
+   * @param {Array | string} ref
+   * @param {ColorSpace | string} [workingSpace]
+   * @return {Object}
+   */
+  static resolveCoord(e, r) {
+    var l;
+    let n = D(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 = I.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 = D(s), n === "number" || n === "string" && s >= 0) {
+      let c = Object.entries(a.coords)[s];
+      if (c)
+        return { space: a, id: c[0], index: s, ...c[1] };
+    }
+    a = I.get(a);
+    let i = s.toLowerCase(), o = 0;
+    for (let c in a.coords) {
+      let u = a.coords[c];
+      if (c.toLowerCase() === i || ((l = u.name) == null ? void 0 : l.toLowerCase()) === i)
+        return { space: a, id: c, index: o, ...u };
+      o++;
+    }
+    throw new TypeError(`No "${s}" coordinate found in ${a.name}. Its coordinates are: ${Object.keys(a.coords).join(", ")}`);
+  }
+};
+ve(I, "registry", {}), ve(I, "DEFAULT_FORMAT", {
+  type: "functions",
+  name: "color"
+});
+let m = I;
+function lr(t) {
+  let e = [t];
+  for (let r = t; r = r.base; )
+    e.push(r);
+  return e;
+}
+function mt(t, { coords: e } = {}) {
+  if (t.coords && !t.coordGrammar) {
+    t.type || (t.type = "function"), t.name || (t.name = "color"), t.coordGrammar = b0(t.coords);
+    let r = Object.entries(e).map(([n, a], s) => {
+      let i = t.coordGrammar[s][0], o = a.range || a.refRange, l = i.range, c = "";
+      return i == "<percentage>" ? (l = [0, 100], c = "%") : i == "<angle>" && (c = "deg"), { fromRange: o, toRange: l, suffix: c };
+    });
+    t.serializeCoords = (n, a) => n.map((s, i) => {
+      let { fromRange: o, toRange: l, suffix: c } = r[i];
+      return o && l && (s = Ve(o, l, s)), s = Re(s, { precision: a, unit: c }), s;
+    });
+  }
+  return t;
+}
+var N = new m({
+  id: "xyz-d65",
+  name: "XYZ D65",
+  coords: {
+    x: { name: "X" },
+    y: { name: "Y" },
+    z: { name: "Z" }
+  },
+  white: "D65",
+  formats: {
+    color: {
+      ids: ["xyz-d65", "xyz"]
+    }
+  },
+  aliases: ["xyz"]
+});
+class z extends m {
+  /**
+   * 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 {*} options - Same options as {@link ColorSpace} plus:
+   * @param {number[][]} options.toXYZ_M - Matrix to convert to XYZ
+   * @param {number[][]} options.fromXYZ_M - Matrix to convert from XYZ
+   */
+  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 = N), e.toXYZ_M && e.fromXYZ_M && (e.toBase ?? (e.toBase = (r) => {
+      let n = L(e.toXYZ_M, r);
+      return this.white !== this.base.white && (n = xe(this.white, this.base.white, n)), n;
+    }), e.fromBase ?? (e.fromBase = (r) => (r = xe(this.base.white, this.white, r), L(e.fromXYZ_M, r)))), e.referred ?? (e.referred = "display"), super(e);
+  }
+}
+function fe(t, e) {
+  return t = b(t), !e || t.space.equals(e) ? t.coords.slice() : (e = m.get(e), e.from(t));
+}
+function P(t, e) {
+  t = b(t);
+  let { space: r, index: n } = m.resolveCoord(e, t.space);
+  return fe(t, r)[n];
+}
+function tt(t, e, r) {
+  return t = b(t), e = m.get(e), t.coords = e.to(t.space, r), t;
+}
+tt.returns = "color";
+function O(t, e, r) {
+  if (t = b(t), arguments.length === 2 && D(arguments[1]) === "object") {
+    let n = arguments[1];
+    for (let a in n)
+      O(t, a, n[a]);
+  } else {
+    typeof r == "function" && (r = r(P(t, e)));
+    let { space: n, index: a } = m.resolveCoord(e, t.space), s = fe(t, n);
+    s[a] = r, tt(t, n, s);
+  }
+  return t;
+}
+O.returns = "color";
+var rt = new m({
+  id: "xyz-d50",
+  name: "XYZ D50",
+  white: "D50",
+  base: N,
+  fromBase: (t) => xe(N.white, "D50", t),
+  toBase: (t) => xe("D50", N.white, t)
+});
+const cr = 216 / 24389, gt = 24 / 116, pe = 24389 / 27;
+let Ae = B.D50;
+var E = new m({
+  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: Ae,
+  base: rt,
+  // Convert D50-adapted XYX to Lab
+  //  CIE 15.3:2004 section 8.2.1.1
+  fromBase(t) {
+    let r = t.map((n, a) => n / Ae[a]).map((n) => n > cr ? Math.cbrt(n) : (pe * n + 16) / 116);
+    return [
+      116 * r[1] - 16,
+      // L
+      500 * (r[0] - r[1]),
+      // a
+      200 * (r[1] - r[2])
+      // b
+    ];
+  },
+  // 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 = [];
+    return e[1] = (t[0] + 16) / 116, e[0] = t[1] / 500 + e[1], e[2] = e[1] - t[2] / 200, [
+      e[0] > gt ? Math.pow(e[0], 3) : (116 * e[0] - 16) / pe,
+      t[0] > 8 ? Math.pow((t[0] + 16) / 116, 3) : t[0] / pe,
+      e[2] > gt ? Math.pow(e[2], 3) : (116 * e[2] - 16) / pe
+    ].map((n, a) => n * Ae[a]);
+  },
+  formats: {
+    lab: {
+      coords: ["<number> | <percentage>", "<number> | <percentage>[-1,1]", "<number> | <percentage>[-1,1]"]
+    }
+  }
+});
+function H(t) {
+  return (t % 360 + 360) % 360;
+}
+function ur(t, e) {
+  if (t === "raw")
+    return e;
+  let [r, n] = e.map(H), a = n - r;
+  return t === "increasing" ? a < 0 && (n += 360) : t === "decreasing" ? a > 0 && (r += 360) : t === "longer" ? -180 < a && a < 180 && (a > 0 ? r += 360 : n += 360) : t === "shorter" && (a > 180 ? r += 360 : a < -180 && (n += 360)), [r, n];
+}
+var le = new m({
+  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: E,
+  fromBase(t) {
+    let [e, r, n] = t, a;
+    const s = 0.02;
+    return Math.abs(r) < s && Math.abs(n) < s ? a = NaN : a = Math.atan2(n, r) * 180 / Math.PI, [
+      e,
+      // L is still L
+      Math.sqrt(r ** 2 + n ** 2),
+      // Chroma
+      H(a)
+      // Hue, in degrees [0 to 360)
+    ];
+  },
+  toBase(t) {
+    let [e, r, n] = t;
+    return r < 0 && (r = 0), isNaN(n) && (n = 0), [
+      e,
+      // L is still L
+      r * Math.cos(n * Math.PI / 180),
+      // a
+      r * Math.sin(n * Math.PI / 180)
+      // b
+    ];
+  },
+  formats: {
+    lch: {
+      coords: ["<number> | <percentage>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+const pt = 25 ** 7, Ne = Math.PI, bt = 180 / Ne, F = Ne / 180;
+function Mt(t) {
+  const e = t * t;
+  return e * e * e * t;
+}
+function C0(t, e, { kL: r = 1, kC: n = 1, kH: a = 1 } = {}) {
+  [t, e] = b([t, e]);
+  let [s, i, o] = E.from(t), l = le.from(E, [s, i, o])[1], [c, u, f] = E.from(e), h = le.from(E, [c, u, f])[1];
+  l < 0 && (l = 0), h < 0 && (h = 0);
+  let p = (l + h) / 2, d = Mt(p), g = 0.5 * (1 - Math.sqrt(d / (d + pt))), M = (1 + g) * i, _ = (1 + g) * u, S = Math.sqrt(M ** 2 + o ** 2), y = Math.sqrt(_ ** 2 + f ** 2), $ = M === 0 && o === 0 ? 0 : Math.atan2(o, M), Y = _ === 0 && f === 0 ? 0 : Math.atan2(f, _);
+  $ < 0 && ($ += 2 * Ne), Y < 0 && (Y += 2 * Ne), $ *= bt, Y *= bt;
+  let de = c - s, me = y - S, A = Y - $, re = $ + Y, ot = Math.abs(A), ne;
+  S * y === 0 ? ne = 0 : ot <= 180 ? ne = A : A > 180 ? ne = A - 360 : A < -180 ? ne = A + 360 : v.warn("the unthinkable has happened");
+  let lt = 2 * Math.sqrt(y * S) * Math.sin(ne * F / 2), Q0 = (s + c) / 2, Ee = (S + y) / 2, ct = Mt(Ee), T;
+  S * y === 0 ? T = re : ot <= 180 ? T = re / 2 : re < 360 ? T = (re + 360) / 2 : T = (re - 360) / 2;
+  let ut = (Q0 - 50) ** 2, U0 = 1 + 0.015 * ut / Math.sqrt(20 + ut), ft = 1 + 0.045 * Ee, ae = 1;
+  ae -= 0.17 * Math.cos((T - 30) * F), ae += 0.24 * Math.cos(2 * T * F), ae += 0.32 * Math.cos((3 * T + 6) * F), ae -= 0.2 * Math.cos((4 * T - 63) * F);
+  let ht = 1 + 0.015 * Ee * ae, K0 = 30 * Math.exp(-1 * ((T - 275) / 25) ** 2), V0 = 2 * Math.sqrt(ct / (ct + pt)), er = -1 * Math.sin(2 * K0 * F) * V0, ge = (de / (r * U0)) ** 2;
+  return ge += (me / (n * ft)) ** 2, ge += (lt / (a * ht)) ** 2, ge += er * (me / (n * ft)) * (lt / (a * ht)), Math.sqrt(ge);
+}
+const fr = [
+  [0.819022437996703, 0.3619062600528904, -0.1288737815209879],
+  [0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
+  [0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
+], hr = [
+  [1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
+  [-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
+  [-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
+], dr = [
+  [0.210454268309314, 0.7936177747023054, -0.0040720430116193],
+  [1.9779985324311684, -2.42859224204858, 0.450593709617411],
+  [0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
+], mr = [
+  [1, 0.3963377773761749, 0.2158037573099136],
+  [1, -0.1055613458156586, -0.0638541728258133],
+  [1, -0.0894841775298119, -1.2914855480194092]
+];
+var K = new m({
+  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: N,
+  fromBase(t) {
+    let r = L(fr, t).map((n) => Math.cbrt(n));
+    return L(dr, r);
+  },
+  toBase(t) {
+    let r = L(mr, t).map((n) => n ** 3);
+    return L(hr, r);
+  },
+  formats: {
+    oklab: {
+      coords: ["<percentage> | <number>", "<number> | <percentage>[-1,1]", "<number> | <percentage>[-1,1]"]
+    }
+  }
+});
+function Ge(t, e) {
+  [t, e] = b([t, e]);
+  let [r, n, a] = K.from(t), [s, i, o] = K.from(e), l = r - s, c = n - i, u = a - o;
+  return Math.sqrt(l ** 2 + c ** 2 + u ** 2);
+}
+const gr = 75e-6;
+function J(t, e, { epsilon: r = gr } = {}) {
+  t = b(t), e || (e = t.space), e = m.get(e);
+  let n = t.coords;
+  return e !== t.space && (n = e.from(t)), e.inGamut(n, { epsilon: r });
+}
+function V(t) {
+  return {
+    space: t.space,
+    coords: t.coords.slice(),
+    alpha: t.alpha
+  };
+}
+function L0(t, e, r = "lab") {
+  r = m.get(r);
+  let n = r.from(t), a = r.from(e);
+  return Math.sqrt(n.reduce((s, i, o) => {
+    let l = a[o];
+    return isNaN(i) || isNaN(l) ? s : s + (l - i) ** 2;
+  }, 0));
+}
+function pr(t, e) {
+  return L0(t, e, "lab");
+}
+const br = Math.PI, wt = br / 180;
+function Mr(t, e, { l: r = 2, c: n = 1 } = {}) {
+  [t, e] = b([t, e]);
+  let [a, s, i] = E.from(t), [, o, l] = le.from(E, [a, s, i]), [c, u, f] = E.from(e), h = le.from(E, [c, u, f])[1];
+  o < 0 && (o = 0), h < 0 && (h = 0);
+  let p = a - c, d = o - h, g = s - u, M = i - f, _ = g ** 2 + M ** 2 - d ** 2, S = 0.511;
+  a >= 16 && (S = 0.040975 * a / (1 + 0.01765 * a));
+  let y = 0.0638 * o / (1 + 0.0131 * o) + 0.638, $;
+  Number.isNaN(l) && (l = 0), l >= 164 && l <= 345 ? $ = 0.56 + Math.abs(0.2 * Math.cos((l + 168) * wt)) : $ = 0.36 + Math.abs(0.4 * Math.cos((l + 35) * wt));
+  let Y = Math.pow(o, 4), de = Math.sqrt(Y / (Y + 1900)), me = y * (de * $ + 1 - de), A = (p / (r * S)) ** 2;
+  return A += (d / (n * y)) ** 2, A += _ / me ** 2, Math.sqrt(A);
+}
+const yt = 203;
+var nt = new m({
+  // 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: N,
+  fromBase(t) {
+    return t.map((e) => Math.max(e * yt, 0));
+  },
+  toBase(t) {
+    return t.map((e) => Math.max(e / yt, 0));
+  }
+});
+const be = 1.15, Me = 0.66, Ct = 2610 / 2 ** 14, wr = 2 ** 14 / 2610, Lt = 3424 / 2 ** 12, St = 2413 / 2 ** 7, _t = 2392 / 2 ** 7, yr = 1.7 * 2523 / 2 ** 5, Rt = 2 ** 5 / (1.7 * 2523), we = -0.56, ke = 16295499532821565e-27, Cr = [
+  [0.41478972, 0.579999, 0.014648],
+  [-0.20151, 1.120649, 0.0531008],
+  [-0.0166008, 0.2648, 0.6684799]
+], Lr = [
+  [1.9242264357876067, -1.0047923125953657, 0.037651404030618],
+  [0.35031676209499907, 0.7264811939316552, -0.06538442294808501],
+  [-0.09098281098284752, -0.3127282905230739, 1.5227665613052603]
+], Sr = [
+  [0.5, 0.5, 0],
+  [3.524, -4.066708, 0.542708],
+  [0.199076, 1.096799, -1.295875]
+], _r = [
+  [1, 0.1386050432715393, 0.05804731615611886],
+  [0.9999999999999999, -0.1386050432715393, -0.05804731615611886],
+  [0.9999999999999998, -0.09601924202631895, -0.8118918960560388]
+];
+var S0 = new m({
+  id: "jzazbz",
+  name: "Jzazbz",
+  coords: {
+    jz: {
+      refRange: [0, 1],
+      name: "Jz"
+    },
+    az: {
+      refRange: [-0.5, 0.5]
+    },
+    bz: {
+      refRange: [-0.5, 0.5]
+    }
+  },
+  base: nt,
+  fromBase(t) {
+    let [e, r, n] = t, a = be * e - (be - 1) * n, s = Me * r - (Me - 1) * e, o = L(Cr, [a, s, n]).map(function(h) {
+      let p = Lt + St * (h / 1e4) ** Ct, d = 1 + _t * (h / 1e4) ** Ct;
+      return (p / d) ** yr;
+    }), [l, c, u] = L(Sr, o);
+    return [(1 + we) * l / (1 + we * l) - ke, c, u];
+  },
+  toBase(t) {
+    let [e, r, n] = t, a = (e + ke) / (1 + we - we * (e + ke)), i = L(_r, [a, r, n]).map(function(h) {
+      let p = Lt - h ** Rt, d = _t * h ** Rt - St;
+      return 1e4 * (p / d) ** wr;
+    }), [o, l, c] = L(Lr, i), u = (o + (be - 1) * c) / be, f = (l + (Me - 1) * u) / Me;
+    return [u, f, c];
+  },
+  formats: {
+    // https://drafts.csswg.org/css-color-hdr/#Jzazbz
+    color: {
+      coords: ["<number> | <percentage>", "<number> | <percentage>[-1,1]", "<number> | <percentage>[-1,1]"]
+    }
+  }
+}), Je = new m({
+  id: "jzczhz",
+  name: "JzCzHz",
+  coords: {
+    jz: {
+      refRange: [0, 1],
+      name: "Jz"
+    },
+    cz: {
+      refRange: [0, 1],
+      name: "Chroma"
+    },
+    hz: {
+      refRange: [0, 360],
+      type: "angle",
+      name: "Hue"
+    }
+  },
+  base: S0,
+  fromBase(t) {
+    let [e, r, n] = t, a;
+    const s = 2e-4;
+    return Math.abs(r) < s && Math.abs(n) < s ? a = NaN : a = Math.atan2(n, r) * 180 / Math.PI, [
+      e,
+      // Jz is still Jz
+      Math.sqrt(r ** 2 + n ** 2),
+      // Chroma
+      H(a)
+      // Hue, in degrees [0 to 360)
+    ];
+  },
+  toBase(t) {
+    return [
+      t[0],
+      // Jz is still Jz
+      t[1] * Math.cos(t[2] * Math.PI / 180),
+      // az
+      t[1] * Math.sin(t[2] * Math.PI / 180)
+      // bz
+    ];
+  }
+});
+function Rr(t, e) {
+  [t, e] = b([t, e]);
+  let [r, n, a] = Je.from(t), [s, i, o] = Je.from(e), l = r - s, c = n - i;
+  Number.isNaN(a) && Number.isNaN(o) ? (a = 0, o = 0) : Number.isNaN(a) ? a = o : Number.isNaN(o) && (o = a);
+  let u = a - o, f = 2 * Math.sqrt(n * i) * Math.sin(u / 2 * (Math.PI / 180));
+  return Math.sqrt(l ** 2 + c ** 2 + f ** 2);
+}
+const _0 = 3424 / 4096, R0 = 2413 / 128, x0 = 2392 / 128, xt = 2610 / 16384, xr = 2523 / 32, Nr = 16384 / 2610, Nt = 32 / 2523, Br = [
+  [0.3592832590121217, 0.6976051147779502, -0.035891593232029],
+  [-0.1920808463704993, 1.100476797037432, 0.0753748658519118],
+  [0.0070797844607479, 0.0748396662186362, 0.8433265453898765]
+], Ir = [
+  [2048 / 4096, 2048 / 4096, 0],
+  [6610 / 4096, -13613 / 4096, 7003 / 4096],
+  [17933 / 4096, -17390 / 4096, -543 / 4096]
+], zr = [
+  [0.9999999999999998, 0.0086090370379328, 0.111029625003026],
+  [0.9999999999999998, -0.0086090370379328, -0.1110296250030259],
+  [0.9999999999999998, 0.5600313357106791, -0.3206271749873188]
+], $r = [
+  [2.0701522183894223, -1.3263473389671563, 0.2066510476294053],
+  [0.3647385209748072, 0.6805660249472273, -0.0453045459220347],
+  [-0.0497472075358123, -0.0492609666966131, 1.1880659249923042]
+];
+var Fe = new m({
+  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: nt,
+  fromBase(t) {
+    let e = L(Br, t);
+    return Pr(e);
+  },
+  toBase(t) {
+    let e = Er(t);
+    return L($r, e);
+  }
+});
+function Pr(t) {
+  let e = t.map(function(r) {
+    let n = _0 + R0 * (r / 1e4) ** xt, a = 1 + x0 * (r / 1e4) ** xt;
+    return (n / a) ** xr;
+  });
+  return L(Ir, e);
+}
+function Er(t) {
+  return L(zr, t).map(function(n) {
+    let a = Math.max(n ** Nt - _0, 0), s = R0 - x0 * n ** Nt;
+    return 1e4 * (a / s) ** Nr;
+  });
+}
+function vr(t, e) {
+  [t, e] = b([t, e]);
+  let [r, n, a] = Fe.from(t), [s, i, o] = Fe.from(e);
+  return 720 * Math.sqrt((r - s) ** 2 + 0.25 * (n - i) ** 2 + (a - o) ** 2);
+}
+const Ar = B.D65, N0 = 0.42, Bt = 1 / N0, He = 2 * Math.PI, B0 = [
+  [0.401288, 0.650173, -0.051461],
+  [-0.250268, 1.204414, 0.045854],
+  [-2079e-6, 0.048952, 0.953127]
+], kr = [
+  [1.8620678550872327, -1.0112546305316843, 0.14918677544445175],
+  [0.38752654323613717, 0.6214474419314753, -0.008973985167612518],
+  [-0.015841498849333856, -0.03412293802851557, 1.0499644368778496]
+], Hr = [
+  [460, 451, 288],
+  [460, -891, -261],
+  [460, -220, -6300]
+], Tr = {
+  dark: [0.8, 0.525, 0.8],
+  dim: [0.9, 0.59, 0.9],
+  average: [1, 0.69, 1]
+}, G = {
+  // 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]
+}, Or = 180 / Math.PI, It = Math.PI / 180;
+function I0(t, e) {
+  return t.map((n) => {
+    const a = k(e * Math.abs(n) * 0.01, N0);
+    return 400 * Ie(a, n) / (a + 27.13);
+  });
+}
+function Yr(t, e) {
+  const r = 100 / e * 27.13 ** Bt;
+  return t.map((n) => {
+    const a = Math.abs(n);
+    return Ie(r * k(a / (400 - a), Bt), n);
+  });
+}
+function Dr(t) {
+  let e = H(t);
+  e <= G.h[0] && (e += 360);
+  const r = w0(G.h, e) - 1, [n, a] = G.h.slice(r, r + 2), [s, i] = G.e.slice(r, r + 2), o = G.H[r], l = (e - n) / s;
+  return o + 100 * l / (l + (a - e) / i);
+}
+function Xr(t) {
+  let e = (t % 400 + 400) % 400;
+  const r = Math.floor(0.01 * e);
+  e = e % 100;
+  const [n, a] = G.h.slice(r, r + 2), [s, i] = G.e.slice(r, r + 2);
+  return H(
+    (e * (i * n - s * a) - 100 * n * i) / (e * (i - s) - 100 * i)
+  );
+}
+function z0(t, e, r, n, a) {
+  const s = {};
+  s.discounting = a, s.refWhite = t, s.surround = n;
+  const i = t.map((g) => g * 100);
+  s.la = e, s.yb = r;
+  const o = i[1], l = L(B0, i);
+  n = Tr[s.surround];
+  const c = n[0];
+  s.c = n[1], s.nc = n[2];
+  const f = (1 / (5 * s.la + 1)) ** 4;
+  s.fl = f * s.la + 0.1 * (1 - f) * (1 - f) * 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 h = Math.max(
+    Math.min(c * (1 - 1 / 3.6 * Math.exp((-s.la - 42) / 92)), 1),
+    0
+  );
+  s.dRgb = l.map((g) => oe(1, o / g, h)), s.dRgbInv = s.dRgb.map((g) => 1 / g);
+  const p = l.map((g, M) => g * s.dRgb[M]), d = I0(p, s.fl);
+  return s.aW = s.nbb * (2 * d[0] + d[1] + 0.05 * d[2]), s;
+}
+const zt = z0(
+  Ar,
+  64 / Math.PI * 0.2,
+  20,
+  "average",
+  !1
+);
+function We(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 = H(t.h) * It : r = Xr(t.H) * It;
+  const n = Math.cos(r), a = Math.sin(r);
+  let s = 0;
+  t.J !== void 0 ? s = k(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 = k(
+    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 * k(s, 2 / e.c / e.z), u = 5e4 / 13 * e.nc * e.ncb * l, f = c / e.nbb, h = 23 * (f + 0.305) * et(o, 23 * u + o * (11 * n + 108 * a)), p = h * n, d = h * a, g = Yr(
+    L(Hr, [f, p, d]).map((M) => M * 1 / 1403),
+    e.fl
+  );
+  return L(
+    kr,
+    g.map((M, _) => M * e.dRgbInv[_])
+  ).map((M) => M / 100);
+}
+function $0(t, e) {
+  const r = t.map((y) => y * 100), n = I0(
+    L(B0, r).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) % He + He) % He, o = 0.25 * (Math.cos(i + 2) + 3.8), l = 5e4 / 13 * e.nc * e.ncb * et(
+    o * Math.sqrt(a ** 2 + s ** 2),
+    n[0] + n[1] + 1.05 * n[2] + 0.305
+  ), c = k(l, 0.9) * Math.pow(1.64 - Math.pow(0.29, e.n), 0.73), u = e.nbb * (2 * n[0] + n[1] + 0.05 * n[2]), f = k(u / e.aW, 0.5 * e.c * e.z), h = 100 * k(f, 2), p = 4 / e.c * f * (e.aW + 4) * e.flRoot, d = c * f, g = d * e.flRoot, M = H(i * Or), _ = Dr(M), S = 50 * k(e.c * c / (e.aW + 4), 1 / 2);
+  return { J: h, C: d, h: M, s: S, Q: p, M: g, H: _ };
+}
+var jr = new m({
+  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: N,
+  fromBase(t) {
+    const e = $0(t, zt);
+    return [e.J, e.M, e.h];
+  },
+  toBase(t) {
+    return We(
+      { J: t[0], M: t[1], h: t[2] },
+      zt
+    );
+  }
+});
+const qr = B.D65, Zr = 216 / 24389, P0 = 24389 / 27;
+function Gr(t) {
+  return 116 * (t > Zr ? Math.cbrt(t) : (P0 * t + 16) / 116) - 16;
+}
+function Qe(t) {
+  return t > 8 ? Math.pow((t + 16) / 116, 3) : t / P0;
+}
+function Jr(t, e) {
+  let [r, n, a] = t, s = [], i = 0;
+  if (a === 0)
+    return [0, 0, 0];
+  let o = Qe(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 u = 0, f = 1 / 0;
+  for (; u <= c; ) {
+    s = We({ J: i, C: n, h: r }, e);
+    const h = Math.abs(s[1] - o);
+    if (h < f) {
+      if (h <= l)
+        return s;
+      f = h;
+    }
+    i = i - (s[1] - o) * i / (2 * s[1]), u += 1;
+  }
+  return We({ J: i, C: n, h: r }, e);
+}
+function Fr(t, e) {
+  const r = Gr(t[1]);
+  if (r === 0)
+    return [0, 0, 0];
+  const n = $0(t, at);
+  return [H(n.h), n.C, r];
+}
+const at = z0(
+  qr,
+  200 / Math.PI * Qe(50),
+  Qe(50) * 100,
+  "average",
+  !1
+);
+var ce = new m({
+  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: N,
+  fromBase(t) {
+    return Fr(t);
+  },
+  toBase(t) {
+    return Jr(t, at);
+  },
+  formats: {
+    color: {
+      id: "--hct",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+const Wr = Math.PI / 180, $t = [1, 7e-3, 0.0228];
+function Pt(t) {
+  t[1] < 0 && (t = ce.fromBase(ce.toBase(t)));
+  const e = Math.log(Math.max(1 + $t[2] * t[1] * at.flRoot, 1)) / $t[2], r = t[0] * Wr, n = e * Math.cos(r), a = e * Math.sin(r);
+  return [t[2], n, a];
+}
+function Qr(t, e) {
+  [t, e] = b([t, e]);
+  let [r, n, a] = Pt(ce.from(t)), [s, i, o] = Pt(ce.from(e));
+  return Math.sqrt((r - s) ** 2 + (n - i) ** 2 + (a - o) ** 2);
+}
+var ee = {
+  deltaE76: pr,
+  deltaECMC: Mr,
+  deltaE2000: C0,
+  deltaEJz: Rr,
+  deltaEITP: vr,
+  deltaEOK: Ge,
+  deltaEHCT: Qr
+};
+function Ur(t) {
+  const e = t ? Math.floor(Math.log10(Math.abs(t))) : 0;
+  return Math.max(parseFloat(`1e${e - 2}`), 1e-6);
+}
+const Et = {
+  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 q(t, {
+  method: e = v.gamut_mapping,
+  space: r = void 0,
+  deltaEMethod: n = "",
+  jnd: a = 2,
+  blackWhiteClamp: s = {}
+} = {}) {
+  if (t = b(t), ue(arguments[1]) ? r = arguments[1] : r || (r = t.space), r = m.get(r), J(t, r, { epsilon: 0 }))
+    return t;
+  let i;
+  if (e === "css")
+    i = Kr(t, { space: r });
+  else {
+    if (e !== "clip" && !J(t, r)) {
+      Object.prototype.hasOwnProperty.call(Et, e) && ({ method: e, jnd: a, deltaEMethod: n, blackWhiteClamp: s } = Et[e]);
+      let o = C0;
+      if (n !== "") {
+        for (let c in ee)
+          if ("deltae" + n.toLowerCase() === c.toLowerCase()) {
+            o = ee[c];
+            break;
+          }
+      }
+      let l = q(C(t, r), { method: "clip", space: r });
+      if (o(t, l) > a) {
+        if (Object.keys(s).length === 3) {
+          let S = m.resolveCoord(s.channel), y = P(C(t, S.space), S.id);
+          if (X(y) && (y = 0), y >= s.max)
+            return C({ space: "xyz-d65", coords: B.D65 }, t.space);
+          if (y <= s.min)
+            return C({ space: "xyz-d65", coords: [0, 0, 0] }, t.space);
+        }
+        let c = m.resolveCoord(e), u = c.space, f = c.id, h = C(t, u);
+        h.coords.forEach((S, y) => {
+          X(S) && (h.coords[y] = 0);
+        });
+        let d = (c.range || c.refRange)[0], g = Ur(a), M = d, _ = P(h, f);
+        for (; _ - M > g; ) {
+          let S = V(h);
+          S = q(S, { space: r, method: "clip" }), o(h, S) - a < g ? M = P(h, f) : _ = P(h, f), O(h, f, (M + _) / 2);
+        }
+        i = C(h, r);
+      } else
+        i = l;
+    } else
+      i = C(t, r);
+    if (e === "clip" || !J(i, r, { epsilon: 0 })) {
+      let o = Object.values(r.coords).map((l) => l.range || []);
+      i.coords = i.coords.map((l, c) => {
+        let [u, f] = o[c];
+        return u !== void 0 && (l = Math.max(u, l)), f !== void 0 && (l = Math.min(l, f)), l;
+      });
+    }
+  }
+  return r !== t.space && (i = C(i, t.space)), t.coords = i.coords, t;
+}
+q.returns = "color";
+const vt = {
+  WHITE: { space: K, coords: [1, 0, 0] },
+  BLACK: { space: K, coords: [0, 0, 0] }
+};
+function Kr(t, { space: e } = {}) {
+  t = b(t), e || (e = t.space), e = m.get(e);
+  const a = m.get("oklch");
+  if (e.isUnbounded)
+    return C(t, e);
+  const s = C(t, a);
+  let i = s.coords[0];
+  if (i >= 1) {
+    const d = C(vt.WHITE, e);
+    return d.alpha = t.alpha, C(d, e);
+  }
+  if (i <= 0) {
+    const d = C(vt.BLACK, e);
+    return d.alpha = t.alpha, C(d, e);
+  }
+  if (J(s, e, { epsilon: 0 }))
+    return C(s, e);
+  function o(d) {
+    const g = C(d, e), M = Object.values(e.coords);
+    return g.coords = g.coords.map((_, S) => {
+      if ("range" in M[S]) {
+        const [y, $] = M[S].range;
+        return M0(y, _, $);
+      }
+      return _;
+    }), g;
+  }
+  let l = 0, c = s.coords[1], u = !0, f = V(s), h = o(f), p = Ge(h, f);
+  if (p < 0.02)
+    return h;
+  for (; c - l > 1e-4; ) {
+    const d = (l + c) / 2;
+    if (f.coords[1] = d, u && J(f, e, { epsilon: 0 }))
+      l = d;
+    else if (h = o(f), p = Ge(h, f), p < 0.02) {
+      if (0.02 - p < 1e-4)
+        break;
+      u = !1, l = d;
+    } else
+      c = d;
+  }
+  return h;
+}
+function C(t, e, { inGamut: r } = {}) {
+  t = b(t), e = m.get(e);
+  let n = e.from(t), a = { space: e, coords: n, alpha: t.alpha };
+  return r && (a = q(a, r === !0 ? void 0 : r)), a;
+}
+C.returns = "color";
+function ie(t, {
+  precision: e = v.precision,
+  format: r = "default",
+  inGamut: n = !0,
+  ...a
+} = {}) {
+  var l;
+  let s;
+  t = b(t);
+  let i = r;
+  r = t.space.getFormat(r) ?? t.space.getFormat("default") ?? m.DEFAULT_FORMAT;
+  let o = t.coords.slice();
+  if (n || (n = r.toGamut), n && !J(t) && (o = q(V(t), n === !0 ? void 0 : n).coords), r.type === "custom")
+    if (a.precision = e, r.serialize)
+      s = r.serialize(o, t.alpha, a);
+    else
+      throw new TypeError(`format ${i} can only be used to parse colors, not for serialization`);
+  else {
+    let c = r.name || "color";
+    r.serializeCoords ? o = r.serializeCoords(o, e) : e !== null && (o = o.map((p) => Re(p, { precision: e })));
+    let u = [...o];
+    if (c === "color") {
+      let p = r.id || ((l = r.ids) == null ? void 0 : l[0]) || t.space.id;
+      u.unshift(p);
+    }
+    let f = t.alpha;
+    e !== null && (f = Re(f, { precision: e }));
+    let h = t.alpha >= 1 || r.noAlpha ? "" : `${r.commas ? "," : " /"} ${f}`;
+    s = `${c}(${u.join(r.commas ? ", " : " ")}${h})`;
+  }
+  return s;
+}
+const Vr = [
+  [0.6369580483012914, 0.14461690358620832, 0.1688809751641721],
+  [0.2627002120112671, 0.6779980715188708, 0.05930171646986196],
+  [0, 0.028072693049087428, 1.060985057710791]
+], en = [
+  [1.716651187971268, -0.355670783776392, -0.25336628137366],
+  [-0.666684351832489, 1.616481236634939, 0.0157685458139111],
+  [0.017639857445311, -0.042770613257809, 0.942103121235474]
+];
+var ze = new z({
+  id: "rec2020-linear",
+  cssId: "--rec2020-linear",
+  name: "Linear REC.2020",
+  white: "D65",
+  toXYZ_M: Vr,
+  fromXYZ_M: en
+});
+const ye = 1.09929682680944, At = 0.018053968510807;
+var E0 = new z({
+  id: "rec2020",
+  name: "REC.2020",
+  base: ze,
+  // Non-linear transfer function from Rec. ITU-R BT.2020-2 table 4
+  toBase(t) {
+    return t.map(function(e) {
+      return e < At * 4.5 ? e / 4.5 : Math.pow((e + ye - 1) / ye, 1 / 0.45);
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      return e >= At ? ye * Math.pow(e, 0.45) - (ye - 1) : 4.5 * e;
+    });
+  }
+});
+const tn = [
+  [0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
+  [0.2289745640697488, 0.6917385218365064, 0.079286914093745],
+  [0, 0.04511338185890264, 1.043944368900976]
+], rn = [
+  [2.493496911941425, -0.9313836179191239, -0.40271078445071684],
+  [-0.8294889695615747, 1.7626640603183463, 0.023624685841943577],
+  [0.03584583024378447, -0.07617238926804182, 0.9568845240076872]
+];
+var v0 = new z({
+  id: "p3-linear",
+  cssId: "--display-p3-linear",
+  name: "Linear P3",
+  white: "D65",
+  toXYZ_M: tn,
+  fromXYZ_M: rn
+});
+const nn = [
+  [0.41239079926595934, 0.357584339383878, 0.1804807884018343],
+  [0.21263900587151027, 0.715168678767756, 0.07219231536073371],
+  [0.01933081871559182, 0.11919477979462598, 0.9505321522496607]
+], x = [
+  [3.2409699419045226, -1.537383177570094, -0.4986107602930034],
+  [-0.9692436362808796, 1.8759675015077202, 0.04155505740717559],
+  [0.05563007969699366, -0.20397695888897652, 1.0569715142428786]
+];
+var A0 = new z({
+  id: "srgb-linear",
+  name: "Linear sRGB",
+  white: "D65",
+  toXYZ_M: nn,
+  fromXYZ_M: x
+}), kt = {
+  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 Ht = Array(3).fill("<percentage> | <number>[0, 255]"), Tt = Array(3).fill("<number>[0, 255]");
+var te = new z({
+  id: "srgb",
+  name: "sRGB",
+  base: A0,
+  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: Ht
+    },
+    rgb_number: {
+      name: "rgb",
+      commas: !0,
+      coords: Tt,
+      noAlpha: !0
+    },
+    color: {
+      /* use defaults */
+    },
+    rgba: {
+      coords: Ht,
+      commas: !0,
+      lastAlpha: !0
+    },
+    rgba_number: {
+      name: "rgba",
+      commas: !0,
+      coords: Tt
+    },
+    hex: {
+      type: "custom",
+      toGamut: !0,
+      test: (t) => /^#([a-f0-9]{3,4}){1,2}$/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: e.slice(0, 3),
+          alpha: e.slice(3)[0]
+        };
+      },
+      serialize: (t, e, {
+        collapse: r = !0
+        // collapse to 3-4 digit hex when possible?
+      } = {}) => {
+        e < 1 && t.push(e), t = t.map((s) => Math.round(s * 255));
+        let n = r && t.every((s) => s % 17 === 0);
+        return "#" + t.map((s) => n ? (s / 17).toString(16) : s.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 = kt.black, e.alpha = 0) : e.coords = kt[t], e.coords)
+          return e;
+      }
+    }
+  }
+}), k0 = new z({
+  id: "p3",
+  cssId: "display-p3",
+  name: "P3",
+  base: v0,
+  // Gamma encoding/decoding is the same as sRGB
+  fromBase: te.fromBase,
+  toBase: te.toBase
+});
+v.display_space = te;
+let an;
+if (typeof CSS < "u" && CSS.supports)
+  for (let t of [E, E0, k0]) {
+    let e = t.getMinCoords(), n = ie({ space: t, coords: e, alpha: 1 });
+    if (CSS.supports("color", n)) {
+      v.display_space = t;
+      break;
+    }
+  }
+function sn(t, { space: e = v.display_space, ...r } = {}) {
+  let n = ie(t, r);
+  if (typeof CSS > "u" || CSS.supports("color", n) || !v.display_space)
+    n = new String(n), n.color = t;
+  else {
+    let a = t;
+    if ((t.coords.some(X) || X(t.alpha)) && !(an ?? (an = CSS.supports("color", "hsl(none 50% 50%)"))) && (a = V(t), a.coords = a.coords.map(R), a.alpha = R(a.alpha), n = ie(a, r), CSS.supports("color", n)))
+      return n = new String(n), n.color = a, n;
+    a = C(a, e), n = new String(ie(a, r)), n.color = a;
+  }
+  return n;
+}
+function on(t, e) {
+  return t = b(t), e = b(e), t.space === e.space && t.alpha === e.alpha && t.coords.every((r, n) => r === e.coords[n]);
+}
+function Z(t) {
+  return P(t, [N, "y"]);
+}
+function H0(t, e) {
+  O(t, [N, "y"], e);
+}
+function ln(t) {
+  Object.defineProperty(t.prototype, "luminance", {
+    get() {
+      return Z(this);
+    },
+    set(e) {
+      H0(this, e);
+    }
+  });
+}
+var cn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  getLuminance: Z,
+  register: ln,
+  setLuminance: H0
+});
+function un(t, e) {
+  t = b(t), e = b(e);
+  let r = Math.max(Z(t), 0), n = Math.max(Z(e), 0);
+  return n > r && ([r, n] = [n, r]), (r + 0.05) / (n + 0.05);
+}
+const fn = 0.56, hn = 0.57, dn = 0.62, mn = 0.65, Ot = 0.022, gn = 1.414, pn = 0.1, bn = 5e-4, Mn = 1.14, Yt = 0.027, wn = 1.14;
+function Dt(t) {
+  return t >= Ot ? t : t + (Ot - t) ** gn;
+}
+function W(t) {
+  let e = t < 0 ? -1 : 1, r = Math.abs(t);
+  return e * Math.pow(r, 2.4);
+}
+function yn(t, e) {
+  e = b(e), t = b(t);
+  let r, n, a, s, i, o;
+  e = C(e, "srgb"), [s, i, o] = e.coords;
+  let l = W(s) * 0.2126729 + W(i) * 0.7151522 + W(o) * 0.072175;
+  t = C(t, "srgb"), [s, i, o] = t.coords;
+  let c = W(s) * 0.2126729 + W(i) * 0.7151522 + W(o) * 0.072175, u = Dt(l), f = Dt(c), h = f > u;
+  return Math.abs(f - u) < bn ? n = 0 : h ? (r = f ** fn - u ** hn, n = r * Mn) : (r = f ** mn - u ** dn, n = r * wn), Math.abs(n) < pn ? a = 0 : n > 0 ? a = n - Yt : a = n + Yt, a * 100;
+}
+function Cn(t, e) {
+  t = b(t), e = b(e);
+  let r = Math.max(Z(t), 0), n = Math.max(Z(e), 0);
+  n > r && ([r, n] = [n, r]);
+  let a = r + n;
+  return a === 0 ? 0 : (r - n) / a;
+}
+const Ln = 5e4;
+function Sn(t, e) {
+  t = b(t), e = b(e);
+  let r = Math.max(Z(t), 0), n = Math.max(Z(e), 0);
+  return n > r && ([r, n] = [n, r]), n === 0 ? Ln : (r - n) / n;
+}
+function _n(t, e) {
+  t = b(t), e = b(e);
+  let r = P(t, [E, "l"]), n = P(e, [E, "l"]);
+  return Math.abs(r - n);
+}
+const Rn = 216 / 24389, Xt = 24 / 116, Ce = 24389 / 27;
+let Te = B.D65;
+var Ue = new m({
+  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: Te,
+  base: N,
+  // Convert D65-adapted XYZ to Lab
+  //  CIE 15.3:2004 section 8.2.1.1
+  fromBase(t) {
+    let r = t.map((n, a) => n / Te[a]).map((n) => n > Rn ? Math.cbrt(n) : (Ce * 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] > Xt ? Math.pow(e[0], 3) : (116 * e[0] - 16) / Ce,
+      t[0] > 8 ? Math.pow((t[0] + 16) / 116, 3) : t[0] / Ce,
+      e[2] > Xt ? Math.pow(e[2], 3) : (116 * e[2] - 16) / Ce
+    ].map((n, a) => n * Te[a]);
+  },
+  formats: {
+    "lab-d65": {
+      coords: ["<number> | <percentage>", "<number> | <percentage>[-1,1]", "<number> | <percentage>[-1,1]"]
+    }
+  }
+});
+const Oe = Math.pow(5, 0.5) * 0.5 + 0.5;
+function xn(t, e) {
+  t = b(t), e = b(e);
+  let r = P(t, [Ue, "l"]), n = P(e, [Ue, "l"]), a = Math.abs(Math.pow(r, Oe) - Math.pow(n, Oe)), s = Math.pow(a, 1 / Oe) * Math.SQRT2 - 40;
+  return s < 7.5 ? 0 : s;
+}
+var _e = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  contrastAPCA: yn,
+  contrastDeltaPhi: xn,
+  contrastLstar: _n,
+  contrastMichelson: Cn,
+  contrastWCAG21: un,
+  contrastWeber: Sn
+});
+function Nn(t, e, r = {}) {
+  ue(r) && (r = { algorithm: r });
+  let { algorithm: n, ...a } = r;
+  if (!n) {
+    let s = Object.keys(_e).map((i) => i.replace(/^contrast/, "")).join(", ");
+    throw new TypeError(`contrast() function needs a contrast algorithm. Please specify one of: ${s}`);
+  }
+  t = b(t), e = b(e);
+  for (let s in _e)
+    if ("contrast" + n.toLowerCase() === s.toLowerCase())
+      return _e[s](t, e, a);
+  throw new TypeError(`Unknown contrast algorithm: ${n}`);
+}
+function $e(t) {
+  let [e, r, n] = fe(t, N), a = e + 15 * r + 3 * n;
+  return [4 * e / a, 9 * r / a];
+}
+function T0(t) {
+  let [e, r, n] = fe(t, N), a = e + r + n;
+  return [e / a, r / a];
+}
+function Bn(t) {
+  Object.defineProperty(t.prototype, "uv", {
+    get() {
+      return $e(this);
+    }
+  }), Object.defineProperty(t.prototype, "xy", {
+    get() {
+      return T0(this);
+    }
+  });
+}
+var In = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  register: Bn,
+  uv: $e,
+  xy: T0
+});
+function se(t, e, r = {}) {
+  ue(r) && (r = { method: r });
+  let { method: n = v.deltaE, ...a } = r;
+  for (let s in ee)
+    if ("deltae" + n.toLowerCase() === s.toLowerCase())
+      return ee[s](t, e, a);
+  throw new TypeError(`Unknown deltaE method: ${n}`);
+}
+function zn(t, e = 0.25) {
+  let n = [m.get("oklch", "lch"), "l"];
+  return O(t, n, (a) => a * (1 + e));
+}
+function $n(t, e = 0.25) {
+  let n = [m.get("oklch", "lch"), "l"];
+  return O(t, n, (a) => a * (1 - e));
+}
+var Pn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  darken: $n,
+  lighten: zn
+});
+function O0(t, e, r = 0.5, n = {}) {
+  return [t, e] = [b(t), b(e)], D(r) === "object" && ([r, n] = [0.5, r]), he(t, e, n)(r);
+}
+function Y0(t, e, r = {}) {
+  let n;
+  st(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] = [b(t), b(e)], n = he(t, e, l));
+  let c = se(t, e), u = a > 0 ? Math.max(i, Math.ceil(c / a) + 1) : i, f = [];
+  if (o !== void 0 && (u = Math.min(u, o)), u === 1)
+    f = [{ p: 0.5, color: n(0.5) }];
+  else {
+    let h = 1 / (u - 1);
+    f = Array.from({ length: u }, (p, d) => {
+      let g = d * h;
+      return { p: g, color: n(g) };
+    });
+  }
+  if (a > 0) {
+    let h = f.reduce((p, d, g) => {
+      if (g === 0)
+        return 0;
+      let M = se(d.color, f[g - 1].color, s);
+      return Math.max(p, M);
+    }, 0);
+    for (; h > a; ) {
+      h = 0;
+      for (let p = 1; p < f.length && f.length < o; p++) {
+        let d = f[p - 1], g = f[p], M = (g.p + d.p) / 2, _ = n(M);
+        h = Math.max(h, se(_, d.color), se(_, g.color)), f.splice(p, 0, { p: M, color: n(M) }), p++;
+      }
+    }
+  }
+  return f = f.map((h) => h.color), f;
+}
+function he(t, e, r = {}) {
+  if (st(t)) {
+    let [l, c] = [t, e];
+    return he(...l.rangeArgs.colors, { ...l.rangeArgs.options, ...c });
+  }
+  let { space: n, outputSpace: a, progression: s, premultiplied: i } = r;
+  t = b(t), e = b(e), t = V(t), e = V(e);
+  let o = { colors: [t, e], options: r };
+  if (n ? n = m.get(n) : n = m.registry[v.interpolationSpace] || t.space, a = a ? m.get(a) : n, t = C(t, n), e = C(e, n), t = q(t), e = q(e), n.coords.h && n.coords.h.type === "angle") {
+    let l = r.hue = r.hue || "shorter", c = [n, "h"], [u, f] = [P(t, c), P(e, c)];
+    isNaN(u) && !isNaN(f) ? u = f : isNaN(f) && !isNaN(u) && (f = u), [u, f] = ur(l, [u, f]), O(t, c, u), O(e, c, f);
+  }
+  return i && (t.coords = t.coords.map((l) => l * t.alpha), e.coords = e.coords.map((l) => l * e.alpha)), Object.assign((l) => {
+    l = s ? s(l) : l;
+    let c = t.coords.map((h, p) => {
+      let d = e.coords[p];
+      return oe(h, d, l);
+    }), u = oe(t.alpha, e.alpha, l), f = { space: n, coords: c, alpha: u };
+    return i && (f.coords = f.coords.map((h) => h / u)), a !== n && (f = C(f, a)), f;
+  }, {
+    rangeArgs: o
+  });
+}
+function st(t) {
+  return D(t) === "function" && !!t.rangeArgs;
+}
+v.interpolationSpace = "lab";
+function En(t) {
+  t.defineFunction("mix", O0, { returns: "color" }), t.defineFunction("range", he, { returns: "function<color>" }), t.defineFunction("steps", Y0, { returns: "array<color>" });
+}
+var vn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  isRange: st,
+  mix: O0,
+  range: he,
+  register: En,
+  steps: Y0
+}), D0 = new m({
+  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: te,
+  // 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] = [NaN, 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>", "<percentage>"]
+    },
+    hsla: {
+      coords: ["<number> | <angle>", "<percentage>", "<percentage>"],
+      commas: !0,
+      lastAlpha: !0
+    }
+  }
+}), X0 = new m({
+  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: D0,
+  // https://en.wikipedia.org/wiki/HSL_and_HSV#Interconversion
+  fromBase(t) {
+    let [e, r, n] = t;
+    r /= 100, n /= 100;
+    let a = n + r * Math.min(n, 1 - n);
+    return [
+      e,
+      // h is the same
+      a === 0 ? 0 : 200 * (1 - n / a),
+      // s
+      100 * a
+    ];
+  },
+  // https://en.wikipedia.org/wiki/HSL_and_HSV#Interconversion
+  toBase(t) {
+    let [e, r, n] = t;
+    r /= 100, n /= 100;
+    let a = n * (1 - r / 2);
+    return [
+      e,
+      // h is the same
+      a === 0 || a === 1 ? 0 : (n - a) / Math.min(a, 1 - a) * 100,
+      a * 100
+    ];
+  },
+  formats: {
+    color: {
+      id: "--hsv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+}), An = new m({
+  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: X0,
+  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 kn = [
+  [0.5766690429101305, 0.1855582379065463, 0.1882286462349947],
+  [0.29734497525053605, 0.6273635662554661, 0.07529145849399788],
+  [0.02703136138641234, 0.07068885253582723, 0.9913375368376388]
+], Hn = [
+  [2.0415879038107465, -0.5650069742788596, -0.34473135077832956],
+  [-0.9692436362808795, 1.8759675015077202, 0.04155505740717557],
+  [0.013444280632031142, -0.11836239223101838, 1.0151749943912054]
+];
+var j0 = new z({
+  id: "a98rgb-linear",
+  cssId: "--a98-rgb-linear",
+  name: "Linear Adobe® 98 RGB compatible",
+  white: "D65",
+  toXYZ_M: kn,
+  fromXYZ_M: Hn
+}), Tn = new z({
+  id: "a98rgb",
+  cssId: "a98-rgb",
+  name: "Adobe® 98 RGB compatible",
+  base: j0,
+  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 On = [
+  [0.7977666449006423, 0.13518129740053308, 0.0313477341283922],
+  [0.2880748288194013, 0.711835234241873, 8993693872564e-17],
+  [0, 0, 0.8251046025104602]
+], Yn = [
+  [1.3457868816471583, -0.25557208737979464, -0.05110186497554526],
+  [-0.5446307051249019, 1.5082477428451468, 0.02052744743642139],
+  [0, 0, 1.2119675456389452]
+];
+var q0 = new z({
+  id: "prophoto-linear",
+  cssId: "--prophoto-rgb-linear",
+  name: "Linear ProPhoto",
+  white: "D50",
+  base: rt,
+  toXYZ_M: On,
+  fromXYZ_M: Yn
+});
+const Dn = 1 / 512, Xn = 16 / 512;
+var jn = new z({
+  id: "prophoto",
+  cssId: "prophoto-rgb",
+  name: "ProPhoto",
+  base: q0,
+  toBase(t) {
+    return t.map((e) => e < Xn ? e / 16 : e ** 1.8);
+  },
+  fromBase(t) {
+    return t.map((e) => e >= Dn ? e ** (1 / 1.8) : 16 * e);
+  }
+}), qn = new m({
+  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: K,
+  fromBase(t) {
+    let [e, r, n] = t, a;
+    const s = 2e-4;
+    return Math.abs(r) < s && Math.abs(n) < s ? a = NaN : a = Math.atan2(n, r) * 180 / Math.PI, [
+      e,
+      // OKLab L is still L
+      Math.sqrt(r ** 2 + n ** 2),
+      // Chroma
+      H(a)
+      // Hue, in degrees [0 to 360)
+    ];
+  },
+  // Convert from polar form
+  toBase(t) {
+    let [e, r, n] = t, a, s;
+    return isNaN(n) ? (a = 0, s = 0) : (a = r * Math.cos(n * Math.PI / 180), s = r * Math.sin(n * Math.PI / 180)), [e, a, s];
+  },
+  formats: {
+    oklch: {
+      coords: ["<percentage> | <number>", "<number> | <percentage>[0,1]", "<number> | <angle>"]
+    }
+  }
+});
+let Z0 = B.D65;
+const Zn = 216 / 24389, jt = 24389 / 27, [qt, Zt] = $e({ space: N, coords: Z0 });
+var G0 = new m({
+  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: Z0,
+  base: N,
+  // Convert D65-adapted XYZ to Luv
+  // https://en.wikipedia.org/wiki/CIELUV#The_forward_transformation
+  fromBase(t) {
+    let e = [R(t[0]), R(t[1]), R(t[2])], r = e[1], [n, a] = $e({ space: N, coords: e });
+    if (!Number.isFinite(n) || !Number.isFinite(a))
+      return [0, 0, 0];
+    let s = r <= Zn ? jt * r : 116 * Math.cbrt(r) - 16;
+    return [
+      s,
+      13 * s * (n - qt),
+      13 * s * (a - Zt)
+    ];
+  },
+  // 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 || X(e))
+      return [0, 0, 0];
+    r = R(r), n = R(n);
+    let a = r / (13 * e) + qt, s = n / (13 * e) + Zt, i = e <= 8 ? e / jt : 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>[-1,1]", "<number> | <percentage>[-1,1]"]
+    }
+  }
+}), it = new m({
+  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: G0,
+  fromBase(t) {
+    let [e, r, n] = t, a;
+    const s = 0.02;
+    return Math.abs(r) < s && Math.abs(n) < s ? a = NaN : a = Math.atan2(n, r) * 180 / Math.PI, [
+      e,
+      // L is still L
+      Math.sqrt(r ** 2 + n ** 2),
+      // Chroma
+      H(a)
+      // Hue, in degrees [0 to 360)
+    ];
+  },
+  toBase(t) {
+    let [e, r, n] = t;
+    return r < 0 && (r = 0), isNaN(n) && (n = 0), [
+      e,
+      // L is still L
+      r * Math.cos(n * Math.PI / 180),
+      // u
+      r * Math.sin(n * Math.PI / 180)
+      // v
+    ];
+  },
+  formats: {
+    color: {
+      id: "--lchuv",
+      coords: ["<number> | <percentage>", "<number> | <percentage>", "<number> | <angle>"]
+    }
+  }
+});
+const Gn = 216 / 24389, Jn = 24389 / 27, Gt = x[0][0], Jt = x[0][1], Ye = x[0][2], Ft = x[1][0], Wt = x[1][1], De = x[1][2], Qt = x[2][0], Ut = x[2][1], Xe = x[2][2];
+function Q(t, e, r) {
+  const n = e / (Math.sin(r) - t * Math.cos(r));
+  return n < 0 ? 1 / 0 : n;
+}
+function Be(t) {
+  const e = Math.pow(t + 16, 3) / 1560896, r = e > Gn ? e : t / Jn, n = r * (284517 * Gt - 94839 * Ye), a = r * (838422 * Ye + 769860 * Jt + 731718 * Gt), s = r * (632260 * Ye - 126452 * Jt), i = r * (284517 * Ft - 94839 * De), o = r * (838422 * De + 769860 * Wt + 731718 * Ft), l = r * (632260 * De - 126452 * Wt), c = r * (284517 * Qt - 94839 * Xe), u = r * (838422 * Xe + 769860 * Ut + 731718 * Qt), f = r * (632260 * Xe - 126452 * Ut);
+  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 / f,
+    b0i: u * t / f,
+    b1s: c / (f + 126452),
+    b1i: (u - 769860) * t / (f + 126452)
+  };
+}
+function Kt(t, e) {
+  const r = e / 360 * Math.PI * 2, n = Q(t.r0s, t.r0i, r), a = Q(t.r1s, t.r1i, r), s = Q(t.g0s, t.g0i, r), i = Q(t.g1s, t.g1i, r), o = Q(t.b0s, t.b0i, r), l = Q(t.b1s, t.b1i, r);
+  return Math.min(n, a, s, i, o, l);
+}
+var Fn = new m({
+  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: it,
+  gamutSpace: te,
+  // Convert LCHuv to HSLuv
+  fromBase(t) {
+    let [e, r, n] = [R(t[0]), R(t[1]), R(t[2])], a;
+    if (e > 99.9999999)
+      a = 0, e = 100;
+    else if (e < 1e-8)
+      a = 0, e = 0;
+    else {
+      let s = Be(e), i = Kt(s, n);
+      a = r / i * 100;
+    }
+    return [n, a, e];
+  },
+  // Convert HSLuv to LCHuv
+  toBase(t) {
+    let [e, r, n] = [R(t[0]), R(t[1]), R(t[2])], a;
+    if (n > 99.9999999)
+      n = 100, a = 0;
+    else if (n < 1e-8)
+      n = 0, a = 0;
+    else {
+      let s = Be(n);
+      a = Kt(s, e) / 100 * r;
+    }
+    return [n, a, e];
+  },
+  formats: {
+    color: {
+      id: "--hsluv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+x[0][0];
+x[0][1];
+x[0][2];
+x[1][0];
+x[1][1];
+x[1][2];
+x[2][0];
+x[2][1];
+x[2][2];
+function U(t, e) {
+  return Math.abs(e) / Math.sqrt(Math.pow(t, 2) + 1);
+}
+function Vt(t) {
+  let e = U(t.r0s, t.r0i), r = U(t.r1s, t.r1i), n = U(t.g0s, t.g0i), a = U(t.g1s, t.g1i), s = U(t.b0s, t.b0i), i = U(t.b1s, t.b1i);
+  return Math.min(e, r, n, a, s, i);
+}
+var Wn = new m({
+  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: it,
+  gamutSpace: "self",
+  // Convert LCHuv to HPLuv
+  fromBase(t) {
+    let [e, r, n] = [R(t[0]), R(t[1]), R(t[2])], a;
+    if (e > 99.9999999)
+      a = 0, e = 100;
+    else if (e < 1e-8)
+      a = 0, e = 0;
+    else {
+      let s = Be(e), i = Vt(s);
+      a = r / i * 100;
+    }
+    return [n, a, e];
+  },
+  // Convert HPLuv to LCHuv
+  toBase(t) {
+    let [e, r, n] = [R(t[0]), R(t[1]), R(t[2])], a;
+    if (n > 99.9999999)
+      n = 100, a = 0;
+    else if (n < 1e-8)
+      n = 0, a = 0;
+    else {
+      let s = Be(n);
+      a = Vt(s) / 100 * r;
+    }
+    return [n, a, e];
+  },
+  formats: {
+    color: {
+      id: "--hpluv",
+      coords: ["<number> | <angle>", "<percentage> | <number>", "<percentage> | <number>"]
+    }
+  }
+});
+const e0 = 203, t0 = 2610 / 2 ** 14, Qn = 2 ** 14 / 2610, Un = 2523 / 2 ** 5, r0 = 2 ** 5 / 2523, n0 = 3424 / 2 ** 12, a0 = 2413 / 2 ** 7, s0 = 2392 / 2 ** 7;
+var Kn = new z({
+  id: "rec2100pq",
+  cssId: "rec2100-pq",
+  name: "REC.2100-PQ",
+  base: ze,
+  toBase(t) {
+    return t.map(function(e) {
+      return (Math.max(e ** r0 - n0, 0) / (a0 - s0 * e ** r0)) ** Qn * 1e4 / e0;
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      let r = Math.max(e * e0 / 1e4, 0), n = n0 + a0 * r ** t0, a = 1 + s0 * r ** t0;
+      return (n / a) ** Un;
+    });
+  }
+});
+const i0 = 0.17883277, o0 = 0.28466892, l0 = 0.55991073, je = 3.7743;
+var Vn = new z({
+  id: "rec2100hlg",
+  cssId: "rec2100-hlg",
+  name: "REC.2100-HLG",
+  referred: "scene",
+  base: ze,
+  toBase(t) {
+    return t.map(function(e) {
+      return e <= 0.5 ? e ** 2 / 3 * je : (Math.exp((e - l0) / i0) + o0) / 12 * je;
+    });
+  },
+  fromBase(t) {
+    return t.map(function(e) {
+      return e /= je, e <= 1 / 12 ? Math.sqrt(3 * e) : i0 * Math.log(12 * e - o0) + l0;
+    });
+  }
+});
+const J0 = {};
+j.add("chromatic-adaptation-start", (t) => {
+  t.options.method && (t.M = F0(t.W1, t.W2, t.options.method));
+});
+j.add("chromatic-adaptation-end", (t) => {
+  t.M || (t.M = F0(t.W1, t.W2, t.options.method));
+});
+function Pe({ id: t, toCone_M: e, fromCone_M: r }) {
+  J0[t] = arguments[0];
+}
+function F0(t, e, r = "Bradford") {
+  let n = J0[r], [a, s, i] = L(n.toCone_M, t), [o, l, c] = L(n.toCone_M, e), u = [
+    [o / a, 0, 0],
+    [0, l / s, 0],
+    [0, 0, c / i]
+  ], f = L(u, n.toCone_M);
+  return L(n.fromCone_M, f);
+}
+Pe({
+  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]
+  ]
+});
+Pe({
+  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]
+  ]
+});
+Pe({
+  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]
+  ]
+});
+Pe({
+  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(B, {
+  // 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]
+});
+B.ACES = [0.32168 / 0.33767, 1, (1 - 0.32168 - 0.33767) / 0.33767];
+const ea = [
+  [0.6624541811085053, 0.13400420645643313, 0.1561876870049078],
+  [0.27222871678091454, 0.6740817658111484, 0.05368951740793705],
+  [-0.005574649490394108, 0.004060733528982826, 1.0103391003129971]
+], ta = [
+  [1.6410233796943257, -0.32480329418479, -0.23642469523761225],
+  [-0.6636628587229829, 1.6153315916573379, 0.016756347685530137],
+  [0.011721894328375376, -0.008284441996237409, 0.9883948585390215]
+];
+var W0 = new z({
+  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: B.ACES,
+  toXYZ_M: ea,
+  fromXYZ_M: ta
+});
+const Le = 2 ** -16, qe = -0.35828683, Se = (Math.log2(65504) + 9.72) / 17.52;
+var ra = new z({
+  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: [qe, Se],
+      name: "Red"
+    },
+    g: {
+      range: [qe, Se],
+      name: "Green"
+    },
+    b: {
+      range: [qe, Se],
+      name: "Blue"
+    }
+  },
+  referred: "scene",
+  base: W0,
+  // 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) - Le) * 2 : r < Se ? 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(Le) + 9.72) / 17.52 : e < Le ? (Math.log2(Le + 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]
+}), c0 = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  A98RGB: Tn,
+  A98RGB_Linear: j0,
+  ACEScc: ra,
+  ACEScg: W0,
+  CAM16_JMh: jr,
+  HCT: ce,
+  HPLuv: Wn,
+  HSL: D0,
+  HSLuv: Fn,
+  HSV: X0,
+  HWB: An,
+  ICTCP: Fe,
+  JzCzHz: Je,
+  Jzazbz: S0,
+  LCH: le,
+  LCHuv: it,
+  Lab: E,
+  Lab_D65: Ue,
+  Luv: G0,
+  OKLCH: qn,
+  OKLab: K,
+  P3: k0,
+  P3_Linear: v0,
+  ProPhoto: jn,
+  ProPhoto_Linear: q0,
+  REC_2020: E0,
+  REC_2020_Linear: ze,
+  REC_2100_HLG: Vn,
+  REC_2100_PQ: Kn,
+  XYZ_ABS_D65: nt,
+  XYZ_D50: rt,
+  XYZ_D65: N,
+  sRGB: te,
+  sRGB_Linear: A0
+});
+class w {
+  /**
+   * 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;
+    e.length === 1 && (r = b(e[0]));
+    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: m.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 = s > 1 || s === void 0 ? 1 : s < 0 ? 0 : s;
+    for (let i = 0; i < this.coords.length; i++)
+      this.coords[i] === "NaN" && (this.coords[i] = NaN);
+    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 w(this.space, this.coords, this.alpha);
+  }
+  toJSON() {
+    return {
+      spaceId: this.spaceId,
+      coords: this.coords,
+      alpha: this.alpha
+    };
+  }
+  display(...e) {
+    let r = sn(this, ...e);
+    return r.color = new w(r.color), r;
+  }
+  /**
+   * Get a color from the argument passed
+   * Basically gets us the same result as new Color(color) but doesn't clone an existing color object
+   */
+  static get(e, ...r) {
+    return e instanceof w ? e : new w(e, ...r);
+  }
+  static defineFunction(e, r, n = r) {
+    let { instance: a = !0, returns: s } = n, i = function(...o) {
+      let l = r(...o);
+      if (s === "color")
+        l = w.get(l);
+      else if (s === "function<color>") {
+        let c = l;
+        l = function(...u) {
+          let f = c(...u);
+          return w.get(f);
+        }, Object.assign(l, c);
+      } else s === "array<color>" && (l = l.map((c) => w.get(c)));
+      return l;
+    };
+    e in w || (w[e] = i), a && (w.prototype[e] = function(...o) {
+      return i(this, ...o);
+    });
+  }
+  static defineFunctions(e) {
+    for (let r in e)
+      w.defineFunction(r, e[r], e[r]);
+  }
+  static extend(e) {
+    if (e.register)
+      e.register(w);
+    else
+      for (let r in e)
+        w.defineFunction(r, e[r]);
+  }
+}
+w.defineFunctions({
+  get: P,
+  getAll: fe,
+  set: O,
+  setAll: tt,
+  to: C,
+  equals: on,
+  inGamut: J,
+  toGamut: q,
+  distance: L0,
+  toString: ie
+});
+Object.assign(w, {
+  util: ar,
+  hooks: j,
+  WHITES: B,
+  Space: m,
+  spaces: m.registry,
+  parse: y0,
+  // Global defaults one may want to configure
+  defaults: v
+});
+for (let t of Object.keys(c0))
+  m.register(c0[t]);
+for (let t in m.registry)
+  Ke(t, m.registry[t]);
+j.add("colorspace-init-end", (t) => {
+  var e;
+  Ke(t.id, t), (e = t.aliases) == null || e.forEach((r) => {
+    Ke(r, t);
+  });
+});
+function Ke(t, e) {
+  let r = t.replace(/-/g, "_");
+  Object.defineProperty(w.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);
+      return typeof Proxy > "u" ? n : new Proxy(n, {
+        has: (a, s) => {
+          try {
+            return m.resolveCoord([e, s]), !0;
+          } catch {
+          }
+          return Reflect.has(a, s);
+        },
+        get: (a, s, i) => {
+          if (s && typeof s != "symbol" && !(s in a)) {
+            let { index: o } = m.resolveCoord([e, s]);
+            if (o >= 0)
+              return a[o];
+          }
+          return Reflect.get(a, s, i);
+        },
+        set: (a, s, i, o) => {
+          if (s && typeof s != "symbol" && !(s in a) || s >= 0) {
+            let { index: l } = m.resolveCoord([e, s]);
+            if (l >= 0)
+              return a[l] = i, this.setAll(t, a), !0;
+          }
+          return Reflect.set(a, s, i, o);
+        }
+      });
+    },
+    // 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
+  });
+}
+w.extend(ee);
+w.extend({ deltaE: se });
+Object.assign(w, { deltaEMethods: ee });
+w.extend(Pn);
+w.extend({ contrast: Nn });
+w.extend(In);
+w.extend(cn);
+w.extend(vn);
+w.extend(_e);
+export {
+  w as C
+};