@styleframe/figma 1.0.0

package/dist/plugin/code.js

@@ -0,0 +1,3803 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+(function() {
+  "use strict";
+  function styleframeToFigmaName(name) {
+    return name.replace(/\./g, "/");
+  }
+  function figmaToStyleframeName(name) {
+    return name.replace(/\//g, ".");
+  }
+  function isDTCGAlias(value) {
+    return typeof value === "string" && value.startsWith("{") && value.endsWith("}");
+  }
+  function isDTCGToken(value) {
+    return typeof value === "object" && value !== null && "$value" in value;
+  }
+  function isDTCGGroup(value) {
+    return typeof value === "object" && value !== null && !("$value" in value) && !Array.isArray(value);
+  }
+  function figmaTypeToDTCG(figmaType) {
+    switch (figmaType) {
+      case "COLOR":
+        return "color";
+      case "FLOAT":
+        return "dimension";
+      case "STRING":
+        return "string";
+      case "BOOLEAN":
+        return "string";
+      // DTCG has no boolean type
+      default:
+        return "string";
+    }
+  }
+  function dtcgTypeToFigma(dtcgType) {
+    switch (dtcgType) {
+      case "color":
+        return "COLOR";
+      case "dimension":
+      case "number":
+      case "fontWeight":
+      case "duration":
+        return "FLOAT";
+      case "fontFamily":
+      case "string":
+        return "STRING";
+      case "cubicBezier":
+        return "STRING";
+      // Serialize as string
+      default:
+        return "STRING";
+    }
+  }
+  function parseAlias(alias) {
+    return alias.slice(1, -1);
+  }
+  function createAlias(path) {
+    const dotPath = path.replace(/\//g, ".");
+    return `{${dotPath}}`;
+  }
+  function figmaPathToDTCG(figmaPath) {
+    return figmaPath.replace(/\//g, ".");
+  }
+  function dtcgPathToFigma(dtcgPath) {
+    return dtcgPath.replace(/\./g, "/");
+  }
+  function getPathSegments(path) {
+    return path.split(/[./]/);
+  }
+  const parseNumber = (color, len) => {
+    if (typeof color !== "number") return;
+    if (len === 3) {
+      return {
+        mode: "rgb",
+        r: (color >> 8 & 15 | color >> 4 & 240) / 255,
+        g: (color >> 4 & 15 | color & 240) / 255,
+        b: (color & 15 | color << 4 & 240) / 255
+      };
+    }
+    if (len === 4) {
+      return {
+        mode: "rgb",
+        r: (color >> 12 & 15 | color >> 8 & 240) / 255,
+        g: (color >> 8 & 15 | color >> 4 & 240) / 255,
+        b: (color >> 4 & 15 | color & 240) / 255,
+        alpha: (color & 15 | color << 4 & 240) / 255
+      };
+    }
+    if (len === 6) {
+      return {
+        mode: "rgb",
+        r: (color >> 16 & 255) / 255,
+        g: (color >> 8 & 255) / 255,
+        b: (color & 255) / 255
+      };
+    }
+    if (len === 8) {
+      return {
+        mode: "rgb",
+        r: (color >> 24 & 255) / 255,
+        g: (color >> 16 & 255) / 255,
+        b: (color >> 8 & 255) / 255,
+        alpha: (color & 255) / 255
+      };
+    }
+  };
+  const named = {
+    aliceblue: 15792383,
+    antiquewhite: 16444375,
+    aqua: 65535,
+    aquamarine: 8388564,
+    azure: 15794175,
+    beige: 16119260,
+    bisque: 16770244,
+    black: 0,
+    blanchedalmond: 16772045,
+    blue: 255,
+    blueviolet: 9055202,
+    brown: 10824234,
+    burlywood: 14596231,
+    cadetblue: 6266528,
+    chartreuse: 8388352,
+    chocolate: 13789470,
+    coral: 16744272,
+    cornflowerblue: 6591981,
+    cornsilk: 16775388,
+    crimson: 14423100,
+    cyan: 65535,
+    darkblue: 139,
+    darkcyan: 35723,
+    darkgoldenrod: 12092939,
+    darkgray: 11119017,
+    darkgreen: 25600,
+    darkgrey: 11119017,
+    darkkhaki: 12433259,
+    darkmagenta: 9109643,
+    darkolivegreen: 5597999,
+    darkorange: 16747520,
+    darkorchid: 10040012,
+    darkred: 9109504,
+    darksalmon: 15308410,
+    darkseagreen: 9419919,
+    darkslateblue: 4734347,
+    darkslategray: 3100495,
+    darkslategrey: 3100495,
+    darkturquoise: 52945,
+    darkviolet: 9699539,
+    deeppink: 16716947,
+    deepskyblue: 49151,
+    dimgray: 6908265,
+    dimgrey: 6908265,
+    dodgerblue: 2003199,
+    firebrick: 11674146,
+    floralwhite: 16775920,
+    forestgreen: 2263842,
+    fuchsia: 16711935,
+    gainsboro: 14474460,
+    ghostwhite: 16316671,
+    gold: 16766720,
+    goldenrod: 14329120,
+    gray: 8421504,
+    green: 32768,
+    greenyellow: 11403055,
+    grey: 8421504,
+    honeydew: 15794160,
+    hotpink: 16738740,
+    indianred: 13458524,
+    indigo: 4915330,
+    ivory: 16777200,
+    khaki: 15787660,
+    lavender: 15132410,
+    lavenderblush: 16773365,
+    lawngreen: 8190976,
+    lemonchiffon: 16775885,
+    lightblue: 11393254,
+    lightcoral: 15761536,
+    lightcyan: 14745599,
+    lightgoldenrodyellow: 16448210,
+    lightgray: 13882323,
+    lightgreen: 9498256,
+    lightgrey: 13882323,
+    lightpink: 16758465,
+    lightsalmon: 16752762,
+    lightseagreen: 2142890,
+    lightskyblue: 8900346,
+    lightslategray: 7833753,
+    lightslategrey: 7833753,
+    lightsteelblue: 11584734,
+    lightyellow: 16777184,
+    lime: 65280,
+    limegreen: 3329330,
+    linen: 16445670,
+    magenta: 16711935,
+    maroon: 8388608,
+    mediumaquamarine: 6737322,
+    mediumblue: 205,
+    mediumorchid: 12211667,
+    mediumpurple: 9662683,
+    mediumseagreen: 3978097,
+    mediumslateblue: 8087790,
+    mediumspringgreen: 64154,
+    mediumturquoise: 4772300,
+    mediumvioletred: 13047173,
+    midnightblue: 1644912,
+    mintcream: 16121850,
+    mistyrose: 16770273,
+    moccasin: 16770229,
+    navajowhite: 16768685,
+    navy: 128,
+    oldlace: 16643558,
+    olive: 8421376,
+    olivedrab: 7048739,
+    orange: 16753920,
+    orangered: 16729344,
+    orchid: 14315734,
+    palegoldenrod: 15657130,
+    palegreen: 10025880,
+    paleturquoise: 11529966,
+    palevioletred: 14381203,
+    papayawhip: 16773077,
+    peachpuff: 16767673,
+    peru: 13468991,
+    pink: 16761035,
+    plum: 14524637,
+    powderblue: 11591910,
+    purple: 8388736,
+    // Added in CSS Colors Level 4:
+    // https://drafts.csswg.org/css-color/#changes-from-3
+    rebeccapurple: 6697881,
+    red: 16711680,
+    rosybrown: 12357519,
+    royalblue: 4286945,
+    saddlebrown: 9127187,
+    salmon: 16416882,
+    sandybrown: 16032864,
+    seagreen: 3050327,
+    seashell: 16774638,
+    sienna: 10506797,
+    silver: 12632256,
+    skyblue: 8900331,
+    slateblue: 6970061,
+    slategray: 7372944,
+    slategrey: 7372944,
+    snow: 16775930,
+    springgreen: 65407,
+    steelblue: 4620980,
+    tan: 13808780,
+    teal: 32896,
+    thistle: 14204888,
+    tomato: 16737095,
+    turquoise: 4251856,
+    violet: 15631086,
+    wheat: 16113331,
+    white: 16777215,
+    whitesmoke: 16119285,
+    yellow: 16776960,
+    yellowgreen: 10145074
+  };
+  const parseNamed = (color) => {
+    return parseNumber(named[color.toLowerCase()], 6);
+  };
+  const hex = /^#?([0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{4}|[0-9a-f]{3})$/i;
+  const parseHex = (color) => {
+    let match;
+    return (match = color.match(hex)) ? parseNumber(parseInt(match[1], 16), match[1].length) : void 0;
+  };
+  const num$1 = "([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)";
+  const per = `${num$1}%`;
+  const num_per = `(?:${num$1}%|${num$1})`;
+  const hue$1 = `(?:${num$1}(deg|grad|rad|turn)|${num$1})`;
+  const c = `\\s*,\\s*`;
+  const rgb_num_old = new RegExp(
+    `^rgba?\\(\\s*${num$1}${c}${num$1}${c}${num$1}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
+  );
+  const rgb_per_old = new RegExp(
+    `^rgba?\\(\\s*${per}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
+  );
+  const parseRgbLegacy = (color) => {
+    let res = { mode: "rgb" };
+    let match;
+    if (match = color.match(rgb_num_old)) {
+      if (match[1] !== void 0) {
+        res.r = match[1] / 255;
+      }
+      if (match[2] !== void 0) {
+        res.g = match[2] / 255;
+      }
+      if (match[3] !== void 0) {
+        res.b = match[3] / 255;
+      }
+    } else if (match = color.match(rgb_per_old)) {
+      if (match[1] !== void 0) {
+        res.r = match[1] / 100;
+      }
+      if (match[2] !== void 0) {
+        res.g = match[2] / 100;
+      }
+      if (match[3] !== void 0) {
+        res.b = match[3] / 100;
+      }
+    } else {
+      return void 0;
+    }
+    if (match[4] !== void 0) {
+      res.alpha = Math.max(0, Math.min(1, match[4] / 100));
+    } else if (match[5] !== void 0) {
+      res.alpha = Math.max(0, Math.min(1, +match[5]));
+    }
+    return res;
+  };
+  const prepare = (color, mode) => color === void 0 ? void 0 : typeof color !== "object" ? parse(color) : color.mode !== void 0 ? color : mode ? __spreadProps(__spreadValues({}, color), { mode }) : void 0;
+  const converter = (target_mode = "rgb") => (color) => (color = prepare(color, target_mode)) !== void 0 ? (
+    // if the color's mode corresponds to our target mode
+    color.mode === target_mode ? (
+      // then just return the color
+      color
+    ) : (
+      // otherwise check to see if we have a dedicated
+      // converter for the target mode
+      converters[color.mode][target_mode] ? (
+        // and return its result...
+        converters[color.mode][target_mode](color)
+      ) : (
+        // ...otherwise pass through RGB as an intermediary step.
+        // if the target mode is RGB...
+        target_mode === "rgb" ? (
+          // just return the RGB
+          converters[color.mode].rgb(color)
+        ) : (
+          // otherwise convert color.mode -> RGB -> target_mode
+          converters.rgb[target_mode](converters[color.mode].rgb(color))
+        )
+      )
+    )
+  ) : void 0;
+  const converters = {};
+  const modes = {};
+  const parsers = [];
+  const colorProfiles = {};
+  const identity = (v) => v;
+  const useMode = (definition2) => {
+    converters[definition2.mode] = __spreadValues(__spreadValues({}, converters[definition2.mode]), definition2.toMode);
+    Object.keys(definition2.fromMode || {}).forEach((k2) => {
+      if (!converters[k2]) {
+        converters[k2] = {};
+      }
+      converters[k2][definition2.mode] = definition2.fromMode[k2];
+    });
+    if (!definition2.ranges) {
+      definition2.ranges = {};
+    }
+    if (!definition2.difference) {
+      definition2.difference = {};
+    }
+    definition2.channels.forEach((channel) => {
+      if (definition2.ranges[channel] === void 0) {
+        definition2.ranges[channel] = [0, 1];
+      }
+      if (!definition2.interpolate[channel]) {
+        throw new Error(`Missing interpolator for: ${channel}`);
+      }
+      if (typeof definition2.interpolate[channel] === "function") {
+        definition2.interpolate[channel] = {
+          use: definition2.interpolate[channel]
+        };
+      }
+      if (!definition2.interpolate[channel].fixup) {
+        definition2.interpolate[channel].fixup = identity;
+      }
+    });
+    modes[definition2.mode] = definition2;
+    (definition2.parse || []).forEach((parser) => {
+      useParser(parser, definition2.mode);
+    });
+    return converter(definition2.mode);
+  };
+  const getMode = (mode) => modes[mode];
+  const useParser = (parser, mode) => {
+    if (typeof parser === "string") {
+      if (!mode) {
+        throw new Error(`'mode' required when 'parser' is a string`);
+      }
+      colorProfiles[parser] = mode;
+    } else if (typeof parser === "function") {
+      if (parsers.indexOf(parser) < 0) {
+        parsers.push(parser);
+      }
+    }
+  };
+  const IdentStartCodePoint = /[^\x00-\x7F]|[a-zA-Z_]/;
+  const IdentCodePoint = /[^\x00-\x7F]|[-\w]/;
+  const Tok = {
+    Function: "function",
+    Ident: "ident",
+    Number: "number",
+    Percentage: "percentage",
+    ParenClose: ")",
+    None: "none",
+    Hue: "hue",
+    Alpha: "alpha"
+  };
+  let _i = 0;
+  function is_num(chars) {
+    let ch = chars[_i];
+    let ch1 = chars[_i + 1];
+    if (ch === "-" || ch === "+") {
+      return /\d/.test(ch1) || ch1 === "." && /\d/.test(chars[_i + 2]);
+    }
+    if (ch === ".") {
+      return /\d/.test(ch1);
+    }
+    return /\d/.test(ch);
+  }
+  function is_ident(chars) {
+    if (_i >= chars.length) {
+      return false;
+    }
+    let ch = chars[_i];
+    if (IdentStartCodePoint.test(ch)) {
+      return true;
+    }
+    if (ch === "-") {
+      if (chars.length - _i < 2) {
+        return false;
+      }
+      let ch1 = chars[_i + 1];
+      if (ch1 === "-" || IdentStartCodePoint.test(ch1)) {
+        return true;
+      }
+      return false;
+    }
+    return false;
+  }
+  const huenits = {
+    deg: 1,
+    rad: 180 / Math.PI,
+    grad: 9 / 10,
+    turn: 360
+  };
+  function num(chars) {
+    let value = "";
+    if (chars[_i] === "-" || chars[_i] === "+") {
+      value += chars[_i++];
+    }
+    value += digits(chars);
+    if (chars[_i] === "." && /\d/.test(chars[_i + 1])) {
+      value += chars[_i++] + digits(chars);
+    }
+    if (chars[_i] === "e" || chars[_i] === "E") {
+      if ((chars[_i + 1] === "-" || chars[_i + 1] === "+") && /\d/.test(chars[_i + 2])) {
+        value += chars[_i++] + chars[_i++] + digits(chars);
+      } else if (/\d/.test(chars[_i + 1])) {
+        value += chars[_i++] + digits(chars);
+      }
+    }
+    if (is_ident(chars)) {
+      let id = ident(chars);
+      if (id === "deg" || id === "rad" || id === "turn" || id === "grad") {
+        return { type: Tok.Hue, value: value * huenits[id] };
+      }
+      return void 0;
+    }
+    if (chars[_i] === "%") {
+      _i++;
+      return { type: Tok.Percentage, value: +value };
+    }
+    return { type: Tok.Number, value: +value };
+  }
+  function digits(chars) {
+    let v = "";
+    while (/\d/.test(chars[_i])) {
+      v += chars[_i++];
+    }
+    return v;
+  }
+  function ident(chars) {
+    let v = "";
+    while (_i < chars.length && IdentCodePoint.test(chars[_i])) {
+      v += chars[_i++];
+    }
+    return v;
+  }
+  function identlike(chars) {
+    let v = ident(chars);
+    if (chars[_i] === "(") {
+      _i++;
+      return { type: Tok.Function, value: v };
+    }
+    if (v === "none") {
+      return { type: Tok.None, value: void 0 };
+    }
+    return { type: Tok.Ident, value: v };
+  }
+  function tokenize(str = "") {
+    let chars = str.trim();
+    let tokens = [];
+    let ch;
+    _i = 0;
+    while (_i < chars.length) {
+      ch = chars[_i++];
+      if (ch === "\n" || ch === "	" || ch === " ") {
+        while (_i < chars.length && (chars[_i] === "\n" || chars[_i] === "	" || chars[_i] === " ")) {
+          _i++;
+        }
+        continue;
+      }
+      if (ch === ",") {
+        return void 0;
+      }
+      if (ch === ")") {
+        tokens.push({ type: Tok.ParenClose });
+        continue;
+      }
+      if (ch === "+") {
+        _i--;
+        if (is_num(chars)) {
+          tokens.push(num(chars));
+          continue;
+        }
+        return void 0;
+      }
+      if (ch === "-") {
+        _i--;
+        if (is_num(chars)) {
+          tokens.push(num(chars));
+          continue;
+        }
+        if (is_ident(chars)) {
+          tokens.push({ type: Tok.Ident, value: ident(chars) });
+          continue;
+        }
+        return void 0;
+      }
+      if (ch === ".") {
+        _i--;
+        if (is_num(chars)) {
+          tokens.push(num(chars));
+          continue;
+        }
+        return void 0;
+      }
+      if (ch === "/") {
+        while (_i < chars.length && (chars[_i] === "\n" || chars[_i] === "	" || chars[_i] === " ")) {
+          _i++;
+        }
+        let alpha;
+        if (is_num(chars)) {
+          alpha = num(chars);
+          if (alpha.type !== Tok.Hue) {
+            tokens.push({ type: Tok.Alpha, value: alpha });
+            continue;
+          }
+        }
+        if (is_ident(chars)) {
+          if (ident(chars) === "none") {
+            tokens.push({
+              type: Tok.Alpha,
+              value: { type: Tok.None, value: void 0 }
+            });
+            continue;
+          }
+        }
+        return void 0;
+      }
+      if (/\d/.test(ch)) {
+        _i--;
+        tokens.push(num(chars));
+        continue;
+      }
+      if (IdentStartCodePoint.test(ch)) {
+        _i--;
+        tokens.push(identlike(chars));
+        continue;
+      }
+      return void 0;
+    }
+    return tokens;
+  }
+  function parseColorSyntax(tokens) {
+    tokens._i = 0;
+    let token = tokens[tokens._i++];
+    if (!token || token.type !== Tok.Function || token.value !== "color") {
+      return void 0;
+    }
+    token = tokens[tokens._i++];
+    if (token.type !== Tok.Ident) {
+      return void 0;
+    }
+    const mode = colorProfiles[token.value];
+    if (!mode) {
+      return void 0;
+    }
+    const res = { mode };
+    const coords = consumeCoords(tokens, false);
+    if (!coords) {
+      return void 0;
+    }
+    const channels = getMode(mode).channels;
+    for (let ii = 0, c2, ch; ii < channels.length; ii++) {
+      c2 = coords[ii];
+      ch = channels[ii];
+      if (c2.type !== Tok.None) {
+        res[ch] = c2.type === Tok.Number ? c2.value : c2.value / 100;
+        if (ch === "alpha") {
+          res[ch] = Math.max(0, Math.min(1, res[ch]));
+        }
+      }
+    }
+    return res;
+  }
+  function consumeCoords(tokens, includeHue) {
+    const coords = [];
+    let token;
+    while (tokens._i < tokens.length) {
+      token = tokens[tokens._i++];
+      if (token.type === Tok.None || token.type === Tok.Number || token.type === Tok.Alpha || token.type === Tok.Percentage || includeHue && token.type === Tok.Hue) {
+        coords.push(token);
+        continue;
+      }
+      if (token.type === Tok.ParenClose) {
+        if (tokens._i < tokens.length) {
+          return void 0;
+        }
+        continue;
+      }
+      return void 0;
+    }
+    if (coords.length < 3 || coords.length > 4) {
+      return void 0;
+    }
+    if (coords.length === 4) {
+      if (coords[3].type !== Tok.Alpha) {
+        return void 0;
+      }
+      coords[3] = coords[3].value;
+    }
+    if (coords.length === 3) {
+      coords.push({ type: Tok.None, value: void 0 });
+    }
+    return coords.every((c2) => c2.type !== Tok.Alpha) ? coords : void 0;
+  }
+  function parseModernSyntax(tokens, includeHue) {
+    tokens._i = 0;
+    let token = tokens[tokens._i++];
+    if (!token || token.type !== Tok.Function) {
+      return void 0;
+    }
+    let coords = consumeCoords(tokens, includeHue);
+    if (!coords) {
+      return void 0;
+    }
+    coords.unshift(token.value);
+    return coords;
+  }
+  const parse = (color) => {
+    if (typeof color !== "string") {
+      return void 0;
+    }
+    const tokens = tokenize(color);
+    const parsed = tokens ? parseModernSyntax(tokens, true) : void 0;
+    let result = void 0;
+    let i = 0;
+    let len = parsers.length;
+    while (i < len) {
+      if ((result = parsers[i++](color, parsed)) !== void 0) {
+        return result;
+      }
+    }
+    return tokens ? parseColorSyntax(tokens) : void 0;
+  };
+  function parseRgb(color, parsed) {
+    if (!parsed || parsed[0] !== "rgb" && parsed[0] !== "rgba") {
+      return void 0;
+    }
+    const res = { mode: "rgb" };
+    const [, r, g, b, alpha] = parsed;
+    if (r.type === Tok.Hue || g.type === Tok.Hue || b.type === Tok.Hue) {
+      return void 0;
+    }
+    if (r.type !== Tok.None) {
+      res.r = r.type === Tok.Number ? r.value / 255 : r.value / 100;
+    }
+    if (g.type !== Tok.None) {
+      res.g = g.type === Tok.Number ? g.value / 255 : g.value / 100;
+    }
+    if (b.type !== Tok.None) {
+      res.b = b.type === Tok.Number ? b.value / 255 : b.value / 100;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const parseTransparent = (c2) => c2 === "transparent" ? { mode: "rgb", r: 0, g: 0, b: 0, alpha: 0 } : void 0;
+  const lerp = (a, b, t) => a + t * (b - a);
+  const get_classes = (arr) => {
+    let classes = [];
+    for (let i = 0; i < arr.length - 1; i++) {
+      let a = arr[i];
+      let b = arr[i + 1];
+      if (a === void 0 && b === void 0) {
+        classes.push(void 0);
+      } else if (a !== void 0 && b !== void 0) {
+        classes.push([a, b]);
+      } else {
+        classes.push(a !== void 0 ? [a, a] : [b, b]);
+      }
+    }
+    return classes;
+  };
+  const interpolatorPiecewise = (interpolator) => (arr) => {
+    let classes = get_classes(arr);
+    return (t) => {
+      let cls = t * classes.length;
+      let idx = t >= 1 ? classes.length - 1 : Math.max(Math.floor(cls), 0);
+      let pair = classes[idx];
+      return pair === void 0 ? void 0 : interpolator(pair[0], pair[1], cls - idx);
+    };
+  };
+  const interpolatorLinear = interpolatorPiecewise(lerp);
+  const fixupAlpha = (arr) => {
+    let some_defined = false;
+    let res = arr.map((v) => {
+      if (v !== void 0) {
+        some_defined = true;
+        return v;
+      }
+      return 1;
+    });
+    return some_defined ? res : arr;
+  };
+  const definition$r = {
+    mode: "rgb",
+    channels: ["r", "g", "b", "alpha"],
+    parse: [
+      parseRgb,
+      parseHex,
+      parseRgbLegacy,
+      parseNamed,
+      parseTransparent,
+      "srgb"
+    ],
+    serialize: "srgb",
+    interpolate: {
+      r: interpolatorLinear,
+      g: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    gamut: true,
+    white: { r: 1, g: 1, b: 1 },
+    black: { r: 0, g: 0, b: 0 }
+  };
+  const linearize$2 = (v = 0) => Math.pow(Math.abs(v), 563 / 256) * Math.sign(v);
+  const convertA98ToXyz65 = (a98) => {
+    let r = linearize$2(a98.r);
+    let g = linearize$2(a98.g);
+    let b = linearize$2(a98.b);
+    let res = {
+      mode: "xyz65",
+      x: 0.5766690429101305 * r + 0.1855582379065463 * g + 0.1882286462349947 * b,
+      y: 0.297344975250536 * r + 0.6273635662554661 * g + 0.0752914584939979 * b,
+      z: 0.0270313613864123 * r + 0.0706888525358272 * g + 0.9913375368376386 * b
+    };
+    if (a98.alpha !== void 0) {
+      res.alpha = a98.alpha;
+    }
+    return res;
+  };
+  const gamma$2 = (v) => Math.pow(Math.abs(v), 256 / 563) * Math.sign(v);
+  const convertXyz65ToA98 = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = {
+      mode: "a98",
+      r: gamma$2(
+        x * 2.0415879038107465 - y * 0.5650069742788597 - 0.3447313507783297 * z
+      ),
+      g: gamma$2(
+        x * -0.9692436362808798 + y * 1.8759675015077206 + 0.0415550574071756 * z
+      ),
+      b: gamma$2(
+        x * 0.0134442806320312 - y * 0.1183623922310184 + 1.0151749943912058 * z
+      )
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const fn$3 = (c2 = 0) => {
+    const abs2 = Math.abs(c2);
+    if (abs2 <= 0.04045) {
+      return c2 / 12.92;
+    }
+    return (Math.sign(c2) || 1) * Math.pow((abs2 + 0.055) / 1.055, 2.4);
+  };
+  const convertRgbToLrgb = ({ r, g, b, alpha }) => {
+    let res = {
+      mode: "lrgb",
+      r: fn$3(r),
+      g: fn$3(g),
+      b: fn$3(b)
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertRgbToXyz65 = (rgb2) => {
+    let { r, g, b, alpha } = convertRgbToLrgb(rgb2);
+    let res = {
+      mode: "xyz65",
+      x: 0.4123907992659593 * r + 0.357584339383878 * g + 0.1804807884018343 * b,
+      y: 0.2126390058715102 * r + 0.715168678767756 * g + 0.0721923153607337 * b,
+      z: 0.0193308187155918 * r + 0.119194779794626 * g + 0.9505321522496607 * b
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const fn$2 = (c2 = 0) => {
+    const abs2 = Math.abs(c2);
+    if (abs2 > 31308e-7) {
+      return (Math.sign(c2) || 1) * (1.055 * Math.pow(abs2, 1 / 2.4) - 0.055);
+    }
+    return c2 * 12.92;
+  };
+  const convertLrgbToRgb = ({ r, g, b, alpha }, mode = "rgb") => {
+    let res = {
+      mode,
+      r: fn$2(r),
+      g: fn$2(g),
+      b: fn$2(b)
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertXyz65ToRgb = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = convertLrgbToRgb({
+      r: x * 3.2409699419045226 - y * 1.537383177570094 - 0.4986107602930034 * z,
+      g: x * -0.9692436362808796 + y * 1.8759675015077204 + 0.0415550574071756 * z,
+      b: x * 0.0556300796969936 - y * 0.2039769588889765 + 1.0569715142428784 * z
+    });
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const definition$q = __spreadProps(__spreadValues({}, definition$r), {
+    mode: "a98",
+    parse: ["a98-rgb"],
+    serialize: "a98-rgb",
+    fromMode: {
+      rgb: (color) => convertXyz65ToA98(convertRgbToXyz65(color)),
+      xyz65: convertXyz65ToA98
+    },
+    toMode: {
+      rgb: (color) => convertXyz65ToRgb(convertA98ToXyz65(color)),
+      xyz65: convertA98ToXyz65
+    }
+  });
+  const normalizeHue = (hue2) => (hue2 = hue2 % 360) < 0 ? hue2 + 360 : hue2;
+  const hue = (hues, fn2) => {
+    return hues.map((hue2, idx, arr) => {
+      if (hue2 === void 0) {
+        return hue2;
+      }
+      let normalized = normalizeHue(hue2);
+      if (idx === 0 || hues[idx - 1] === void 0) {
+        return normalized;
+      }
+      return fn2(normalized - normalizeHue(arr[idx - 1]));
+    }).reduce((acc, curr) => {
+      if (!acc.length || curr === void 0 || acc[acc.length - 1] === void 0) {
+        acc.push(curr);
+        return acc;
+      }
+      acc.push(curr + acc[acc.length - 1]);
+      return acc;
+    }, []);
+  };
+  const fixupHueShorter = (arr) => hue(arr, (d) => Math.abs(d) <= 180 ? d : d - 360 * Math.sign(d));
+  const M = [-0.14861, 1.78277, -0.29227, -0.90649, 1.97294, 0];
+  const degToRad = Math.PI / 180;
+  const radToDeg = 180 / Math.PI;
+  let DE = M[3] * M[4];
+  let BE = M[1] * M[4];
+  let BCAD = M[1] * M[2] - M[0] * M[3];
+  const convertRgbToCubehelix = ({ r, g, b, alpha }) => {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    let l = (BCAD * b + r * DE - g * BE) / (BCAD + DE - BE);
+    let x = b - l;
+    let y = (M[4] * (g - l) - M[2] * x) / M[3];
+    let res = {
+      mode: "cubehelix",
+      l,
+      s: l === 0 || l === 1 ? void 0 : Math.sqrt(x * x + y * y) / (M[4] * l * (1 - l))
+    };
+    if (res.s) res.h = Math.atan2(y, x) * radToDeg - 120;
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertCubehelixToRgb = ({ h, s, l, alpha }) => {
+    let res = { mode: "rgb" };
+    h = (h === void 0 ? 0 : h + 120) * degToRad;
+    if (l === void 0) l = 0;
+    let amp = s === void 0 ? 0 : s * l * (1 - l);
+    let cosh = Math.cos(h);
+    let sinh = Math.sin(h);
+    res.r = l + amp * (M[0] * cosh + M[1] * sinh);
+    res.g = l + amp * (M[2] * cosh + M[3] * sinh);
+    res.b = l + amp * (M[4] * cosh + M[5] * sinh);
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const differenceHueSaturation = (std, smp) => {
+    if (std.h === void 0 || smp.h === void 0 || !std.s || !smp.s) {
+      return 0;
+    }
+    let std_h = normalizeHue(std.h);
+    let smp_h = normalizeHue(smp.h);
+    let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
+    return 2 * Math.sqrt(std.s * smp.s) * dH;
+  };
+  const differenceHueNaive = (std, smp) => {
+    if (std.h === void 0 || smp.h === void 0) {
+      return 0;
+    }
+    let std_h = normalizeHue(std.h);
+    let smp_h = normalizeHue(smp.h);
+    if (Math.abs(smp_h - std_h) > 180) {
+      return std_h - (smp_h - 360 * Math.sign(smp_h - std_h));
+    }
+    return smp_h - std_h;
+  };
+  const differenceHueChroma = (std, smp) => {
+    if (std.h === void 0 || smp.h === void 0 || !std.c || !smp.c) {
+      return 0;
+    }
+    let std_h = normalizeHue(std.h);
+    let smp_h = normalizeHue(smp.h);
+    let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
+    return 2 * Math.sqrt(std.c * smp.c) * dH;
+  };
+  const averageAngle = (val) => {
+    let sum = val.reduce(
+      (sum2, val2) => {
+        if (val2 !== void 0) {
+          let rad = val2 * Math.PI / 180;
+          sum2.sin += Math.sin(rad);
+          sum2.cos += Math.cos(rad);
+        }
+        return sum2;
+      },
+      { sin: 0, cos: 0 }
+    );
+    let angle = Math.atan2(sum.sin, sum.cos) * 180 / Math.PI;
+    return angle < 0 ? 360 + angle : angle;
+  };
+  const definition$p = {
+    mode: "cubehelix",
+    channels: ["h", "s", "l", "alpha"],
+    parse: ["--cubehelix"],
+    serialize: "--cubehelix",
+    ranges: {
+      h: [0, 360],
+      s: [0, 4.614],
+      l: [0, 1]
+    },
+    fromMode: {
+      rgb: convertRgbToCubehelix
+    },
+    toMode: {
+      rgb: convertCubehelixToRgb
+    },
+    interpolate: {
+      h: {
+        use: interpolatorLinear,
+        fixup: fixupHueShorter
+      },
+      s: interpolatorLinear,
+      l: interpolatorLinear,
+      alpha: {
+        use: interpolatorLinear,
+        fixup: fixupAlpha
+      }
+    },
+    difference: {
+      h: differenceHueSaturation
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  const convertLabToLch = ({ l, a, b, alpha }, mode = "lch") => {
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let c2 = Math.sqrt(a * a + b * b);
+    let res = { mode, l, c: c2 };
+    if (c2) res.h = normalizeHue(Math.atan2(b, a) * 180 / Math.PI);
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertLchToLab = ({ l, c: c2, h, alpha }, mode = "lab") => {
+    if (h === void 0) h = 0;
+    let res = {
+      mode,
+      l,
+      a: c2 ? c2 * Math.cos(h / 180 * Math.PI) : 0,
+      b: c2 ? c2 * Math.sin(h / 180 * Math.PI) : 0
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const k$1 = Math.pow(29, 3) / Math.pow(3, 3);
+  const e$1 = Math.pow(6, 3) / Math.pow(29, 3);
+  const D50 = {
+    X: 0.3457 / 0.3585,
+    Y: 1,
+    Z: (1 - 0.3457 - 0.3585) / 0.3585
+  };
+  const D65 = {
+    X: 0.3127 / 0.329,
+    Y: 1,
+    Z: (1 - 0.3127 - 0.329) / 0.329
+  };
+  let fn$1 = (v) => Math.pow(v, 3) > e$1 ? Math.pow(v, 3) : (116 * v - 16) / k$1;
+  const convertLab65ToXyz65 = ({ l, a, b, alpha }) => {
+    if (l === void 0) l = 0;
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let fy = (l + 16) / 116;
+    let fx = a / 500 + fy;
+    let fz = fy - b / 200;
+    let res = {
+      mode: "xyz65",
+      x: fn$1(fx) * D65.X,
+      y: fn$1(fy) * D65.Y,
+      z: fn$1(fz) * D65.Z
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertLab65ToRgb = (lab) => convertXyz65ToRgb(convertLab65ToXyz65(lab));
+  const f$1 = (value) => value > e$1 ? Math.cbrt(value) : (k$1 * value + 16) / 116;
+  const convertXyz65ToLab65 = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let f0 = f$1(x / D65.X);
+    let f1 = f$1(y / D65.Y);
+    let f2 = f$1(z / D65.Z);
+    let res = {
+      mode: "lab65",
+      l: 116 * f1 - 16,
+      a: 500 * (f0 - f1),
+      b: 200 * (f1 - f2)
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertRgbToLab65 = (rgb2) => {
+    let res = convertXyz65ToLab65(convertRgbToXyz65(rgb2));
+    if (rgb2.r === rgb2.b && rgb2.b === rgb2.g) {
+      res.a = res.b = 0;
+    }
+    return res;
+  };
+  const kE = 1;
+  const kCH = 1;
+  const θ = 26 / 180 * Math.PI;
+  const cosθ = Math.cos(θ);
+  const sinθ = Math.sin(θ);
+  const factor = 100 / Math.log(139 / 100);
+  const convertDlchToLab65 = ({ l, c: c2, h, alpha }) => {
+    if (l === void 0) l = 0;
+    if (c2 === void 0) c2 = 0;
+    if (h === void 0) h = 0;
+    let res = {
+      mode: "lab65",
+      l: (Math.exp(l * kE / factor) - 1) / 39e-4
+    };
+    let G = (Math.exp(0.0435 * c2 * kCH * kE) - 1) / 0.075;
+    let e2 = G * Math.cos(h / 180 * Math.PI - θ);
+    let f2 = G * Math.sin(h / 180 * Math.PI - θ);
+    res.a = e2 * cosθ - f2 / 0.83 * sinθ;
+    res.b = e2 * sinθ + f2 / 0.83 * cosθ;
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertLab65ToDlch = ({ l, a, b, alpha }) => {
+    if (l === void 0) l = 0;
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let e2 = a * cosθ + b * sinθ;
+    let f2 = 0.83 * (b * cosθ - a * sinθ);
+    let G = Math.sqrt(e2 * e2 + f2 * f2);
+    let res = {
+      mode: "dlch",
+      l: factor / kE * Math.log(1 + 39e-4 * l),
+      c: Math.log(1 + 0.075 * G) / (0.0435 * kCH * kE)
+    };
+    if (res.c) {
+      res.h = normalizeHue((Math.atan2(f2, e2) + θ) / Math.PI * 180);
+    }
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertDlabToLab65 = (c2) => convertDlchToLab65(convertLabToLch(c2, "dlch"));
+  const convertLab65ToDlab = (c2) => convertLchToLab(convertLab65ToDlch(c2), "dlab");
+  const definition$o = {
+    mode: "dlab",
+    parse: ["--din99o-lab"],
+    serialize: "--din99o-lab",
+    toMode: {
+      lab65: convertDlabToLab65,
+      rgb: (c2) => convertLab65ToRgb(convertDlabToLab65(c2))
+    },
+    fromMode: {
+      lab65: convertLab65ToDlab,
+      rgb: (c2) => convertLab65ToDlab(convertRgbToLab65(c2))
+    },
+    channels: ["l", "a", "b", "alpha"],
+    ranges: {
+      l: [0, 100],
+      a: [-40.09, 45.501],
+      b: [-40.469, 44.344]
+    },
+    interpolate: {
+      l: interpolatorLinear,
+      a: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: {
+        use: interpolatorLinear,
+        fixup: fixupAlpha
+      }
+    }
+  };
+  const definition$n = {
+    mode: "dlch",
+    parse: ["--din99o-lch"],
+    serialize: "--din99o-lch",
+    toMode: {
+      lab65: convertDlchToLab65,
+      dlab: (c2) => convertLchToLab(c2, "dlab"),
+      rgb: (c2) => convertLab65ToRgb(convertDlchToLab65(c2))
+    },
+    fromMode: {
+      lab65: convertLab65ToDlch,
+      dlab: (c2) => convertLabToLch(c2, "dlch"),
+      rgb: (c2) => convertLab65ToDlch(convertRgbToLab65(c2))
+    },
+    channels: ["l", "c", "h", "alpha"],
+    ranges: {
+      l: [0, 100],
+      c: [0, 51.484],
+      h: [0, 360]
+    },
+    interpolate: {
+      l: interpolatorLinear,
+      c: interpolatorLinear,
+      h: {
+        use: interpolatorLinear,
+        fixup: fixupHueShorter
+      },
+      alpha: {
+        use: interpolatorLinear,
+        fixup: fixupAlpha
+      }
+    },
+    difference: {
+      h: differenceHueChroma
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  function convertHsiToRgb({ h, s, i, alpha }) {
+    h = normalizeHue(h !== void 0 ? h : 0);
+    if (s === void 0) s = 0;
+    if (i === void 0) i = 0;
+    let f2 = Math.abs(h / 60 % 2 - 1);
+    let res;
+    switch (Math.floor(h / 60)) {
+      case 0:
+        res = {
+          r: i * (1 + s * (3 / (2 - f2) - 1)),
+          g: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1)),
+          b: i * (1 - s)
+        };
+        break;
+      case 1:
+        res = {
+          r: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1)),
+          g: i * (1 + s * (3 / (2 - f2) - 1)),
+          b: i * (1 - s)
+        };
+        break;
+      case 2:
+        res = {
+          r: i * (1 - s),
+          g: i * (1 + s * (3 / (2 - f2) - 1)),
+          b: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1))
+        };
+        break;
+      case 3:
+        res = {
+          r: i * (1 - s),
+          g: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1)),
+          b: i * (1 + s * (3 / (2 - f2) - 1))
+        };
+        break;
+      case 4:
+        res = {
+          r: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1)),
+          g: i * (1 - s),
+          b: i * (1 + s * (3 / (2 - f2) - 1))
+        };
+        break;
+      case 5:
+        res = {
+          r: i * (1 + s * (3 / (2 - f2) - 1)),
+          g: i * (1 - s),
+          b: i * (1 + s * (3 * (1 - f2) / (2 - f2) - 1))
+        };
+        break;
+      default:
+        res = { r: i * (1 - s), g: i * (1 - s), b: i * (1 - s) };
+    }
+    res.mode = "rgb";
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  function convertRgbToHsi({ r, g, b, alpha }) {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    let M3 = Math.max(r, g, b), m = Math.min(r, g, b);
+    let res = {
+      mode: "hsi",
+      s: r + g + b === 0 ? 0 : 1 - 3 * m / (r + g + b),
+      i: (r + g + b) / 3
+    };
+    if (M3 - m !== 0)
+      res.h = (M3 === r ? (g - b) / (M3 - m) + (g < b) * 6 : M3 === g ? (b - r) / (M3 - m) + 2 : (r - g) / (M3 - m) + 4) * 60;
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  const definition$m = {
+    mode: "hsi",
+    toMode: {
+      rgb: convertHsiToRgb
+    },
+    parse: ["--hsi"],
+    serialize: "--hsi",
+    fromMode: {
+      rgb: convertRgbToHsi
+    },
+    channels: ["h", "s", "i", "alpha"],
+    ranges: {
+      h: [0, 360]
+    },
+    gamut: "rgb",
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      s: interpolatorLinear,
+      i: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueSaturation
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  function convertHslToRgb({ h, s, l, alpha }) {
+    h = normalizeHue(h !== void 0 ? h : 0);
+    if (s === void 0) s = 0;
+    if (l === void 0) l = 0;
+    let m1 = l + s * (l < 0.5 ? l : 1 - l);
+    let m2 = m1 - (m1 - l) * 2 * Math.abs(h / 60 % 2 - 1);
+    let res;
+    switch (Math.floor(h / 60)) {
+      case 0:
+        res = { r: m1, g: m2, b: 2 * l - m1 };
+        break;
+      case 1:
+        res = { r: m2, g: m1, b: 2 * l - m1 };
+        break;
+      case 2:
+        res = { r: 2 * l - m1, g: m1, b: m2 };
+        break;
+      case 3:
+        res = { r: 2 * l - m1, g: m2, b: m1 };
+        break;
+      case 4:
+        res = { r: m2, g: 2 * l - m1, b: m1 };
+        break;
+      case 5:
+        res = { r: m1, g: 2 * l - m1, b: m2 };
+        break;
+      default:
+        res = { r: 2 * l - m1, g: 2 * l - m1, b: 2 * l - m1 };
+    }
+    res.mode = "rgb";
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  function convertRgbToHsl({ r, g, b, alpha }) {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    let M3 = Math.max(r, g, b), m = Math.min(r, g, b);
+    let res = {
+      mode: "hsl",
+      s: M3 === m ? 0 : (M3 - m) / (1 - Math.abs(M3 + m - 1)),
+      l: 0.5 * (M3 + m)
+    };
+    if (M3 - m !== 0)
+      res.h = (M3 === r ? (g - b) / (M3 - m) + (g < b) * 6 : M3 === g ? (b - r) / (M3 - m) + 2 : (r - g) / (M3 - m) + 4) * 60;
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  const hueToDeg = (val, unit) => {
+    switch (unit) {
+      case "deg":
+        return +val;
+      case "rad":
+        return val / Math.PI * 180;
+      case "grad":
+        return val / 10 * 9;
+      case "turn":
+        return val * 360;
+    }
+  };
+  const hsl_old = new RegExp(
+    `^hsla?\\(\\s*${hue$1}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`
+  );
+  const parseHslLegacy = (color) => {
+    let match = color.match(hsl_old);
+    if (!match) return;
+    let res = { mode: "hsl" };
+    if (match[3] !== void 0) {
+      res.h = +match[3];
+    } else if (match[1] !== void 0 && match[2] !== void 0) {
+      res.h = hueToDeg(match[1], match[2]);
+    }
+    if (match[4] !== void 0) {
+      res.s = Math.min(Math.max(0, match[4] / 100), 1);
+    }
+    if (match[5] !== void 0) {
+      res.l = Math.min(Math.max(0, match[5] / 100), 1);
+    }
+    if (match[6] !== void 0) {
+      res.alpha = Math.max(0, Math.min(1, match[6] / 100));
+    } else if (match[7] !== void 0) {
+      res.alpha = Math.max(0, Math.min(1, +match[7]));
+    }
+    return res;
+  };
+  function parseHsl(color, parsed) {
+    if (!parsed || parsed[0] !== "hsl" && parsed[0] !== "hsla") {
+      return void 0;
+    }
+    const res = { mode: "hsl" };
+    const [, h, s, l, alpha] = parsed;
+    if (h.type !== Tok.None) {
+      if (h.type === Tok.Percentage) {
+        return void 0;
+      }
+      res.h = h.value;
+    }
+    if (s.type !== Tok.None) {
+      if (s.type === Tok.Hue) {
+        return void 0;
+      }
+      res.s = s.value / 100;
+    }
+    if (l.type !== Tok.None) {
+      if (l.type === Tok.Hue) {
+        return void 0;
+      }
+      res.l = l.value / 100;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$l = {
+    mode: "hsl",
+    toMode: {
+      rgb: convertHslToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToHsl
+    },
+    channels: ["h", "s", "l", "alpha"],
+    ranges: {
+      h: [0, 360]
+    },
+    gamut: "rgb",
+    parse: [parseHsl, parseHslLegacy],
+    serialize: (c2) => `hsl(${c2.h !== void 0 ? c2.h : "none"} ${c2.s !== void 0 ? c2.s * 100 + "%" : "none"} ${c2.l !== void 0 ? c2.l * 100 + "%" : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`,
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      s: interpolatorLinear,
+      l: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueSaturation
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  function convertHsvToRgb({ h, s, v, alpha }) {
+    h = normalizeHue(h !== void 0 ? h : 0);
+    if (s === void 0) s = 0;
+    if (v === void 0) v = 0;
+    let f2 = Math.abs(h / 60 % 2 - 1);
+    let res;
+    switch (Math.floor(h / 60)) {
+      case 0:
+        res = { r: v, g: v * (1 - s * f2), b: v * (1 - s) };
+        break;
+      case 1:
+        res = { r: v * (1 - s * f2), g: v, b: v * (1 - s) };
+        break;
+      case 2:
+        res = { r: v * (1 - s), g: v, b: v * (1 - s * f2) };
+        break;
+      case 3:
+        res = { r: v * (1 - s), g: v * (1 - s * f2), b: v };
+        break;
+      case 4:
+        res = { r: v * (1 - s * f2), g: v * (1 - s), b: v };
+        break;
+      case 5:
+        res = { r: v, g: v * (1 - s), b: v * (1 - s * f2) };
+        break;
+      default:
+        res = { r: v * (1 - s), g: v * (1 - s), b: v * (1 - s) };
+    }
+    res.mode = "rgb";
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  function convertRgbToHsv({ r, g, b, alpha }) {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    let M3 = Math.max(r, g, b), m = Math.min(r, g, b);
+    let res = {
+      mode: "hsv",
+      s: M3 === 0 ? 0 : 1 - m / M3,
+      v: M3
+    };
+    if (M3 - m !== 0)
+      res.h = (M3 === r ? (g - b) / (M3 - m) + (g < b) * 6 : M3 === g ? (b - r) / (M3 - m) + 2 : (r - g) / (M3 - m) + 4) * 60;
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  }
+  const definition$k = {
+    mode: "hsv",
+    toMode: {
+      rgb: convertHsvToRgb
+    },
+    parse: ["--hsv"],
+    serialize: "--hsv",
+    fromMode: {
+      rgb: convertRgbToHsv
+    },
+    channels: ["h", "s", "v", "alpha"],
+    ranges: {
+      h: [0, 360]
+    },
+    gamut: "rgb",
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      s: interpolatorLinear,
+      v: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueSaturation
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  function convertHwbToRgb({ h, w, b, alpha }) {
+    if (w === void 0) w = 0;
+    if (b === void 0) b = 0;
+    if (w + b > 1) {
+      let s = w + b;
+      w /= s;
+      b /= s;
+    }
+    return convertHsvToRgb({
+      h,
+      s: b === 1 ? 1 : 1 - w / (1 - b),
+      v: 1 - b,
+      alpha
+    });
+  }
+  function convertRgbToHwb(rgba) {
+    let hsv = convertRgbToHsv(rgba);
+    if (hsv === void 0) return void 0;
+    let s = hsv.s !== void 0 ? hsv.s : 0;
+    let v = hsv.v !== void 0 ? hsv.v : 0;
+    let res = {
+      mode: "hwb",
+      w: (1 - s) * v,
+      b: 1 - v
+    };
+    if (hsv.h !== void 0) res.h = hsv.h;
+    if (hsv.alpha !== void 0) res.alpha = hsv.alpha;
+    return res;
+  }
+  function ParseHwb(color, parsed) {
+    if (!parsed || parsed[0] !== "hwb") {
+      return void 0;
+    }
+    const res = { mode: "hwb" };
+    const [, h, w, b, alpha] = parsed;
+    if (h.type !== Tok.None) {
+      if (h.type === Tok.Percentage) {
+        return void 0;
+      }
+      res.h = h.value;
+    }
+    if (w.type !== Tok.None) {
+      if (w.type === Tok.Hue) {
+        return void 0;
+      }
+      res.w = w.value / 100;
+    }
+    if (b.type !== Tok.None) {
+      if (b.type === Tok.Hue) {
+        return void 0;
+      }
+      res.b = b.value / 100;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$j = {
+    mode: "hwb",
+    toMode: {
+      rgb: convertHwbToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToHwb
+    },
+    channels: ["h", "w", "b", "alpha"],
+    ranges: {
+      h: [0, 360]
+    },
+    gamut: "rgb",
+    parse: [ParseHwb],
+    serialize: (c2) => `hwb(${c2.h !== void 0 ? c2.h : "none"} ${c2.w !== void 0 ? c2.w * 100 + "%" : "none"} ${c2.b !== void 0 ? c2.b * 100 + "%" : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`,
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      w: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueNaive
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  const YW = 203;
+  const M1 = 0.1593017578125;
+  const M2 = 78.84375;
+  const C1 = 0.8359375;
+  const C2 = 18.8515625;
+  const C3 = 18.6875;
+  function transferPqDecode(v) {
+    if (v < 0) return 0;
+    const c2 = Math.pow(v, 1 / M2);
+    return 1e4 * Math.pow(Math.max(0, c2 - C1) / (C2 - C3 * c2), 1 / M1);
+  }
+  function transferPqEncode(v) {
+    if (v < 0) return 0;
+    const c2 = Math.pow(v / 1e4, M1);
+    return Math.pow((C1 + C2 * c2) / (1 + C3 * c2), M2);
+  }
+  const toRel = (c2) => Math.max(c2 / YW, 0);
+  const convertItpToXyz65 = ({ i, t, p: p2, alpha }) => {
+    if (i === void 0) i = 0;
+    if (t === void 0) t = 0;
+    if (p2 === void 0) p2 = 0;
+    const l = transferPqDecode(
+      i + 0.008609037037932761 * t + 0.11102962500302593 * p2
+    );
+    const m = transferPqDecode(
+      i - 0.00860903703793275 * t - 0.11102962500302599 * p2
+    );
+    const s = transferPqDecode(
+      i + 0.5600313357106791 * t - 0.32062717498731885 * p2
+    );
+    const res = {
+      mode: "xyz65",
+      x: toRel(
+        2.070152218389422 * l - 1.3263473389671556 * m + 0.2066510476294051 * s
+      ),
+      y: toRel(
+        0.3647385209748074 * l + 0.680566024947227 * m - 0.0453045459220346 * s
+      ),
+      z: toRel(
+        -0.049747207535812 * l - 0.0492609666966138 * m + 1.1880659249923042 * s
+      )
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const toAbs = (c2 = 0) => Math.max(c2 * YW, 0);
+  const convertXyz65ToItp = ({ x, y, z, alpha }) => {
+    const absX = toAbs(x);
+    const absY = toAbs(y);
+    const absZ = toAbs(z);
+    const l = transferPqEncode(
+      0.3592832590121217 * absX + 0.6976051147779502 * absY - 0.0358915932320289 * absZ
+    );
+    const m = transferPqEncode(
+      -0.1920808463704995 * absX + 1.1004767970374323 * absY + 0.0753748658519118 * absZ
+    );
+    const s = transferPqEncode(
+      0.0070797844607477 * absX + 0.0748396662186366 * absY + 0.8433265453898765 * absZ
+    );
+    const i = 0.5 * l + 0.5 * m;
+    const t = 1.61376953125 * l - 3.323486328125 * m + 1.709716796875 * s;
+    const p2 = 4.378173828125 * l - 4.24560546875 * m - 0.132568359375 * s;
+    const res = { mode: "itp", i, t, p: p2 };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const definition$i = {
+    mode: "itp",
+    channels: ["i", "t", "p", "alpha"],
+    parse: ["--ictcp"],
+    serialize: "--ictcp",
+    toMode: {
+      xyz65: convertItpToXyz65,
+      rgb: (color) => convertXyz65ToRgb(convertItpToXyz65(color))
+    },
+    fromMode: {
+      xyz65: convertXyz65ToItp,
+      rgb: (color) => convertXyz65ToItp(convertRgbToXyz65(color))
+    },
+    ranges: {
+      i: [0, 0.581],
+      t: [-0.369, 0.272],
+      p: [-0.164, 0.331]
+    },
+    interpolate: {
+      i: interpolatorLinear,
+      t: interpolatorLinear,
+      p: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const p$1 = 134.03437499999998;
+  const d0$1 = 16295499532821565e-27;
+  const jabPqEncode = (v) => {
+    if (v < 0) return 0;
+    let vn2 = Math.pow(v / 1e4, M1);
+    return Math.pow((C1 + C2 * vn2) / (1 + C3 * vn2), p$1);
+  };
+  const abs = (v = 0) => Math.max(v * 203, 0);
+  const convertXyz65ToJab = ({ x, y, z, alpha }) => {
+    x = abs(x);
+    y = abs(y);
+    z = abs(z);
+    let xp = 1.15 * x - 0.15 * z;
+    let yp = 0.66 * y + 0.34 * x;
+    let l = jabPqEncode(0.41478972 * xp + 0.579999 * yp + 0.014648 * z);
+    let m = jabPqEncode(-0.20151 * xp + 1.120649 * yp + 0.0531008 * z);
+    let s = jabPqEncode(-0.0166008 * xp + 0.2648 * yp + 0.6684799 * z);
+    let i = (l + m) / 2;
+    let res = {
+      mode: "jab",
+      j: 0.44 * i / (1 - 0.56 * i) - d0$1,
+      a: 3.524 * l - 4.066708 * m + 0.542708 * s,
+      b: 0.199076 * l + 1.096799 * m - 1.295875 * s
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const p = 134.03437499999998;
+  const d0 = 16295499532821565e-27;
+  const jabPqDecode = (v) => {
+    if (v < 0) return 0;
+    let vp = Math.pow(v, 1 / p);
+    return 1e4 * Math.pow((C1 - vp) / (C3 * vp - C2), 1 / M1);
+  };
+  const rel = (v) => v / 203;
+  const convertJabToXyz65 = ({ j, a, b, alpha }) => {
+    if (j === void 0) j = 0;
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let i = (j + d0) / (0.44 + 0.56 * (j + d0));
+    let l = jabPqDecode(i + 0.13860504 * a + 0.058047316 * b);
+    let m = jabPqDecode(i - 0.13860504 * a - 0.058047316 * b);
+    let s = jabPqDecode(i - 0.096019242 * a - 0.8118919 * b);
+    let res = {
+      mode: "xyz65",
+      x: rel(
+        1.661373024652174 * l - 0.914523081304348 * m + 0.23136208173913045 * s
+      ),
+      y: rel(
+        -0.3250758611844533 * l + 1.571847026732543 * m - 0.21825383453227928 * s
+      ),
+      z: rel(-0.090982811 * l - 0.31272829 * m + 1.5227666 * s)
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertRgbToJab = (rgb2) => {
+    let res = convertXyz65ToJab(convertRgbToXyz65(rgb2));
+    if (rgb2.r === rgb2.b && rgb2.b === rgb2.g) {
+      res.a = res.b = 0;
+    }
+    return res;
+  };
+  const convertJabToRgb = (color) => convertXyz65ToRgb(convertJabToXyz65(color));
+  const definition$h = {
+    mode: "jab",
+    channels: ["j", "a", "b", "alpha"],
+    parse: ["--jzazbz"],
+    serialize: "--jzazbz",
+    fromMode: {
+      rgb: convertRgbToJab,
+      xyz65: convertXyz65ToJab
+    },
+    toMode: {
+      rgb: convertJabToRgb,
+      xyz65: convertJabToXyz65
+    },
+    ranges: {
+      j: [0, 0.222],
+      a: [-0.109, 0.129],
+      b: [-0.185, 0.134]
+    },
+    interpolate: {
+      j: interpolatorLinear,
+      a: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const convertJabToJch = ({ j, a, b, alpha }) => {
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let c2 = Math.sqrt(a * a + b * b);
+    let res = {
+      mode: "jch",
+      j,
+      c: c2
+    };
+    if (c2) {
+      res.h = normalizeHue(Math.atan2(b, a) * 180 / Math.PI);
+    }
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertJchToJab = ({ j, c: c2, h, alpha }) => {
+    if (h === void 0) h = 0;
+    let res = {
+      mode: "jab",
+      j,
+      a: c2 ? c2 * Math.cos(h / 180 * Math.PI) : 0,
+      b: c2 ? c2 * Math.sin(h / 180 * Math.PI) : 0
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const definition$g = {
+    mode: "jch",
+    parse: ["--jzczhz"],
+    serialize: "--jzczhz",
+    toMode: {
+      jab: convertJchToJab,
+      rgb: (c2) => convertJabToRgb(convertJchToJab(c2))
+    },
+    fromMode: {
+      rgb: (c2) => convertJabToJch(convertRgbToJab(c2)),
+      jab: convertJabToJch
+    },
+    channels: ["j", "c", "h", "alpha"],
+    ranges: {
+      j: [0, 0.221],
+      c: [0, 0.19],
+      h: [0, 360]
+    },
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      c: interpolatorLinear,
+      j: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueChroma
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  const k = Math.pow(29, 3) / Math.pow(3, 3);
+  const e = Math.pow(6, 3) / Math.pow(29, 3);
+  let fn = (v) => Math.pow(v, 3) > e ? Math.pow(v, 3) : (116 * v - 16) / k;
+  const convertLabToXyz50 = ({ l, a, b, alpha }) => {
+    if (l === void 0) l = 0;
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let fy = (l + 16) / 116;
+    let fx = a / 500 + fy;
+    let fz = fy - b / 200;
+    let res = {
+      mode: "xyz50",
+      x: fn(fx) * D50.X,
+      y: fn(fy) * D50.Y,
+      z: fn(fz) * D50.Z
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertXyz50ToRgb = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = convertLrgbToRgb({
+      r: x * 3.1341359569958707 - y * 1.6173863321612538 - 0.4906619460083532 * z,
+      g: x * -0.978795502912089 + y * 1.916254567259524 + 0.03344273116131949 * z,
+      b: x * 0.07195537988411677 - y * 0.2289768264158322 + 1.405386058324125 * z
+    });
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertLabToRgb = (lab) => convertXyz50ToRgb(convertLabToXyz50(lab));
+  const convertRgbToXyz50 = (rgb2) => {
+    let { r, g, b, alpha } = convertRgbToLrgb(rgb2);
+    let res = {
+      mode: "xyz50",
+      x: 0.436065742824811 * r + 0.3851514688337912 * g + 0.14307845442264197 * b,
+      y: 0.22249319175623702 * r + 0.7168870538238823 * g + 0.06061979053616537 * b,
+      z: 0.013923904500943465 * r + 0.09708128566574634 * g + 0.7140993584005155 * b
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const f = (value) => value > e ? Math.cbrt(value) : (k * value + 16) / 116;
+  const convertXyz50ToLab = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let f0 = f(x / D50.X);
+    let f1 = f(y / D50.Y);
+    let f2 = f(z / D50.Z);
+    let res = {
+      mode: "lab",
+      l: 116 * f1 - 16,
+      a: 500 * (f0 - f1),
+      b: 200 * (f1 - f2)
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertRgbToLab = (rgb2) => {
+    let res = convertXyz50ToLab(convertRgbToXyz50(rgb2));
+    if (rgb2.r === rgb2.b && rgb2.b === rgb2.g) {
+      res.a = res.b = 0;
+    }
+    return res;
+  };
+  function parseLab(color, parsed) {
+    if (!parsed || parsed[0] !== "lab") {
+      return void 0;
+    }
+    const res = { mode: "lab" };
+    const [, l, a, b, alpha] = parsed;
+    if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
+      return void 0;
+    }
+    if (l.type !== Tok.None) {
+      res.l = Math.min(Math.max(0, l.value), 100);
+    }
+    if (a.type !== Tok.None) {
+      res.a = a.type === Tok.Number ? a.value : a.value * 125 / 100;
+    }
+    if (b.type !== Tok.None) {
+      res.b = b.type === Tok.Number ? b.value : b.value * 125 / 100;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$f = {
+    mode: "lab",
+    toMode: {
+      xyz50: convertLabToXyz50,
+      rgb: convertLabToRgb
+    },
+    fromMode: {
+      xyz50: convertXyz50ToLab,
+      rgb: convertRgbToLab
+    },
+    channels: ["l", "a", "b", "alpha"],
+    ranges: {
+      l: [0, 100],
+      a: [-125, 125],
+      b: [-125, 125]
+    },
+    parse: [parseLab],
+    serialize: (c2) => `lab(${c2.l !== void 0 ? c2.l : "none"} ${c2.a !== void 0 ? c2.a : "none"} ${c2.b !== void 0 ? c2.b : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`,
+    interpolate: {
+      l: interpolatorLinear,
+      a: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const definition$e = __spreadProps(__spreadValues({}, definition$f), {
+    mode: "lab65",
+    parse: ["--lab-d65"],
+    serialize: "--lab-d65",
+    toMode: {
+      xyz65: convertLab65ToXyz65,
+      rgb: convertLab65ToRgb
+    },
+    fromMode: {
+      xyz65: convertXyz65ToLab65,
+      rgb: convertRgbToLab65
+    },
+    ranges: {
+      l: [0, 100],
+      a: [-125, 125],
+      b: [-125, 125]
+    }
+  });
+  function parseLch(color, parsed) {
+    if (!parsed || parsed[0] !== "lch") {
+      return void 0;
+    }
+    const res = { mode: "lch" };
+    const [, l, c2, h, alpha] = parsed;
+    if (l.type !== Tok.None) {
+      if (l.type === Tok.Hue) {
+        return void 0;
+      }
+      res.l = Math.min(Math.max(0, l.value), 100);
+    }
+    if (c2.type !== Tok.None) {
+      res.c = Math.max(
+        0,
+        c2.type === Tok.Number ? c2.value : c2.value * 150 / 100
+      );
+    }
+    if (h.type !== Tok.None) {
+      if (h.type === Tok.Percentage) {
+        return void 0;
+      }
+      res.h = h.value;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$d = {
+    mode: "lch",
+    toMode: {
+      lab: convertLchToLab,
+      rgb: (c2) => convertLabToRgb(convertLchToLab(c2))
+    },
+    fromMode: {
+      rgb: (c2) => convertLabToLch(convertRgbToLab(c2)),
+      lab: convertLabToLch
+    },
+    channels: ["l", "c", "h", "alpha"],
+    ranges: {
+      l: [0, 100],
+      c: [0, 150],
+      h: [0, 360]
+    },
+    parse: [parseLch],
+    serialize: (c2) => `lch(${c2.l !== void 0 ? c2.l : "none"} ${c2.c !== void 0 ? c2.c : "none"} ${c2.h !== void 0 ? c2.h : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`,
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      c: interpolatorLinear,
+      l: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueChroma
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  const definition$c = __spreadProps(__spreadValues({}, definition$d), {
+    mode: "lch65",
+    parse: ["--lch-d65"],
+    serialize: "--lch-d65",
+    toMode: {
+      lab65: (c2) => convertLchToLab(c2, "lab65"),
+      rgb: (c2) => convertLab65ToRgb(convertLchToLab(c2, "lab65"))
+    },
+    fromMode: {
+      rgb: (c2) => convertLabToLch(convertRgbToLab65(c2), "lch65"),
+      lab65: (c2) => convertLabToLch(c2, "lch65")
+    },
+    ranges: {
+      l: [0, 100],
+      c: [0, 150],
+      h: [0, 360]
+    }
+  });
+  const convertLuvToLchuv = ({ l, u, v, alpha }) => {
+    if (u === void 0) u = 0;
+    if (v === void 0) v = 0;
+    let c2 = Math.sqrt(u * u + v * v);
+    let res = {
+      mode: "lchuv",
+      l,
+      c: c2
+    };
+    if (c2) {
+      res.h = normalizeHue(Math.atan2(v, u) * 180 / Math.PI);
+    }
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertLchuvToLuv = ({ l, c: c2, h, alpha }) => {
+    if (h === void 0) h = 0;
+    let res = {
+      mode: "luv",
+      l,
+      u: c2 ? c2 * Math.cos(h / 180 * Math.PI) : 0,
+      v: c2 ? c2 * Math.sin(h / 180 * Math.PI) : 0
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const u_fn$1 = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
+  const v_fn$1 = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
+  const un$1 = u_fn$1(D50.X, D50.Y, D50.Z);
+  const vn$1 = v_fn$1(D50.X, D50.Y, D50.Z);
+  const l_fn = (value) => value <= e ? k * value : 116 * Math.cbrt(value) - 16;
+  const convertXyz50ToLuv = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let l = l_fn(y / D50.Y);
+    let u = u_fn$1(x, y, z);
+    let v = v_fn$1(x, y, z);
+    if (!isFinite(u) || !isFinite(v)) {
+      l = u = v = 0;
+    } else {
+      u = 13 * l * (u - un$1);
+      v = 13 * l * (v - vn$1);
+    }
+    let res = {
+      mode: "luv",
+      l,
+      u,
+      v
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const u_fn = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
+  const v_fn = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
+  const un = u_fn(D50.X, D50.Y, D50.Z);
+  const vn = v_fn(D50.X, D50.Y, D50.Z);
+  const convertLuvToXyz50 = ({ l, u, v, alpha }) => {
+    if (l === void 0) l = 0;
+    if (l === 0) {
+      return { mode: "xyz50", x: 0, y: 0, z: 0 };
+    }
+    if (u === void 0) u = 0;
+    if (v === void 0) v = 0;
+    let up = u / (13 * l) + un;
+    let vp = v / (13 * l) + vn;
+    let y = D50.Y * (l <= 8 ? l / k : Math.pow((l + 16) / 116, 3));
+    let x = y * (9 * up) / (4 * vp);
+    let z = y * (12 - 3 * up - 20 * vp) / (4 * vp);
+    let res = { mode: "xyz50", x, y, z };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertRgbToLchuv = (rgb2) => convertLuvToLchuv(convertXyz50ToLuv(convertRgbToXyz50(rgb2)));
+  const convertLchuvToRgb = (lchuv) => convertXyz50ToRgb(convertLuvToXyz50(convertLchuvToLuv(lchuv)));
+  const definition$b = {
+    mode: "lchuv",
+    toMode: {
+      luv: convertLchuvToLuv,
+      rgb: convertLchuvToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToLchuv,
+      luv: convertLuvToLchuv
+    },
+    channels: ["l", "c", "h", "alpha"],
+    parse: ["--lchuv"],
+    serialize: "--lchuv",
+    ranges: {
+      l: [0, 100],
+      c: [0, 176.956],
+      h: [0, 360]
+    },
+    interpolate: {
+      h: { use: interpolatorLinear, fixup: fixupHueShorter },
+      c: interpolatorLinear,
+      l: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    },
+    difference: {
+      h: differenceHueChroma
+    },
+    average: {
+      h: averageAngle
+    }
+  };
+  const definition$a = __spreadProps(__spreadValues({}, definition$r), {
+    mode: "lrgb",
+    toMode: {
+      rgb: convertLrgbToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToLrgb
+    },
+    parse: ["srgb-linear"],
+    serialize: "srgb-linear"
+  });
+  const definition$9 = {
+    mode: "luv",
+    toMode: {
+      xyz50: convertLuvToXyz50,
+      rgb: (luv) => convertXyz50ToRgb(convertLuvToXyz50(luv))
+    },
+    fromMode: {
+      xyz50: convertXyz50ToLuv,
+      rgb: (rgb2) => convertXyz50ToLuv(convertRgbToXyz50(rgb2))
+    },
+    channels: ["l", "u", "v", "alpha"],
+    parse: ["--luv"],
+    serialize: "--luv",
+    ranges: {
+      l: [0, 100],
+      u: [-84.936, 175.042],
+      v: [-125.882, 87.243]
+    },
+    interpolate: {
+      l: interpolatorLinear,
+      u: interpolatorLinear,
+      v: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const convertLrgbToOklab = ({ r, g, b, alpha }) => {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    let L = Math.cbrt(
+      0.412221469470763 * r + 0.5363325372617348 * g + 0.0514459932675022 * b
+    );
+    let M3 = Math.cbrt(
+      0.2119034958178252 * r + 0.6806995506452344 * g + 0.1073969535369406 * b
+    );
+    let S = Math.cbrt(
+      0.0883024591900564 * r + 0.2817188391361215 * g + 0.6299787016738222 * b
+    );
+    let res = {
+      mode: "oklab",
+      l: 0.210454268309314 * L + 0.7936177747023054 * M3 - 0.0040720430116193 * S,
+      a: 1.9779985324311684 * L - 2.42859224204858 * M3 + 0.450593709617411 * S,
+      b: 0.0259040424655478 * L + 0.7827717124575296 * M3 - 0.8086757549230774 * S
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertRgbToOklab = (rgb2) => {
+    let res = convertLrgbToOklab(convertRgbToLrgb(rgb2));
+    if (rgb2.r === rgb2.b && rgb2.b === rgb2.g) {
+      res.a = res.b = 0;
+    }
+    return res;
+  };
+  const convertOklabToLrgb = ({ l, a, b, alpha }) => {
+    if (l === void 0) l = 0;
+    if (a === void 0) a = 0;
+    if (b === void 0) b = 0;
+    let L = Math.pow(l + 0.3963377773761749 * a + 0.2158037573099136 * b, 3);
+    let M3 = Math.pow(l - 0.1055613458156586 * a - 0.0638541728258133 * b, 3);
+    let S = Math.pow(l - 0.0894841775298119 * a - 1.2914855480194092 * b, 3);
+    let res = {
+      mode: "lrgb",
+      r: 4.076741636075957 * L - 3.3077115392580616 * M3 + 0.2309699031821044 * S,
+      g: -1.2684379732850317 * L + 2.6097573492876887 * M3 - 0.3413193760026573 * S,
+      b: -0.0041960761386756 * L - 0.7034186179359362 * M3 + 1.7076146940746117 * S
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertOklabToRgb = (c2) => convertLrgbToRgb(convertOklabToLrgb(c2));
+  function toe(x) {
+    const k_1 = 0.206;
+    const k_2 = 0.03;
+    const k_3 = (1 + k_1) / (1 + k_2);
+    return 0.5 * (k_3 * x - k_1 + Math.sqrt((k_3 * x - k_1) * (k_3 * x - k_1) + 4 * k_2 * k_3 * x));
+  }
+  function toe_inv(x) {
+    const k_1 = 0.206;
+    const k_2 = 0.03;
+    const k_3 = (1 + k_1) / (1 + k_2);
+    return (x * x + k_1 * x) / (k_3 * (x + k_2));
+  }
+  function compute_max_saturation(a, b) {
+    let k0, k1, k2, k3, k4, wl, wm, ws;
+    if (-1.88170328 * a - 0.80936493 * b > 1) {
+      k0 = 1.19086277;
+      k1 = 1.76576728;
+      k2 = 0.59662641;
+      k3 = 0.75515197;
+      k4 = 0.56771245;
+      wl = 4.0767416621;
+      wm = -3.3077115913;
+      ws = 0.2309699292;
+    } else if (1.81444104 * a - 1.19445276 * b > 1) {
+      k0 = 0.73956515;
+      k1 = -0.45954404;
+      k2 = 0.08285427;
+      k3 = 0.1254107;
+      k4 = 0.14503204;
+      wl = -1.2684380046;
+      wm = 2.6097574011;
+      ws = -0.3413193965;
+    } else {
+      k0 = 1.35733652;
+      k1 = -915799e-8;
+      k2 = -1.1513021;
+      k3 = -0.50559606;
+      k4 = 692167e-8;
+      wl = -0.0041960863;
+      wm = -0.7034186147;
+      ws = 1.707614701;
+    }
+    let S = k0 + k1 * a + k2 * b + k3 * a * a + k4 * a * b;
+    let k_l = 0.3963377774 * a + 0.2158037573 * b;
+    let k_m = -0.1055613458 * a - 0.0638541728 * b;
+    let k_s = -0.0894841775 * a - 1.291485548 * b;
+    {
+      let l_ = 1 + S * k_l;
+      let m_ = 1 + S * k_m;
+      let s_ = 1 + S * k_s;
+      let l = l_ * l_ * l_;
+      let m = m_ * m_ * m_;
+      let s = s_ * s_ * s_;
+      let l_dS = 3 * k_l * l_ * l_;
+      let m_dS = 3 * k_m * m_ * m_;
+      let s_dS = 3 * k_s * s_ * s_;
+      let l_dS2 = 6 * k_l * k_l * l_;
+      let m_dS2 = 6 * k_m * k_m * m_;
+      let s_dS2 = 6 * k_s * k_s * s_;
+      let f2 = wl * l + wm * m + ws * s;
+      let f1 = wl * l_dS + wm * m_dS + ws * s_dS;
+      let f22 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
+      S = S - f2 * f1 / (f1 * f1 - 0.5 * f2 * f22);
+    }
+    return S;
+  }
+  function find_cusp(a, b) {
+    let S_cusp = compute_max_saturation(a, b);
+    let rgb2 = convertOklabToLrgb({ l: 1, a: S_cusp * a, b: S_cusp * b });
+    let L_cusp = Math.cbrt(1 / Math.max(rgb2.r, rgb2.g, rgb2.b));
+    let C_cusp = L_cusp * S_cusp;
+    return [L_cusp, C_cusp];
+  }
+  function find_gamut_intersection(a, b, L1, C12, L0, cusp = null) {
+    if (!cusp) {
+      cusp = find_cusp(a, b);
+    }
+    let t;
+    if ((L1 - L0) * cusp[1] - (cusp[0] - L0) * C12 <= 0) {
+      t = cusp[1] * L0 / (C12 * cusp[0] + cusp[1] * (L0 - L1));
+    } else {
+      t = cusp[1] * (L0 - 1) / (C12 * (cusp[0] - 1) + cusp[1] * (L0 - L1));
+      {
+        let dL = L1 - L0;
+        let dC = C12;
+        let k_l = 0.3963377774 * a + 0.2158037573 * b;
+        let k_m = -0.1055613458 * a - 0.0638541728 * b;
+        let k_s = -0.0894841775 * a - 1.291485548 * b;
+        let l_dt = dL + dC * k_l;
+        let m_dt = dL + dC * k_m;
+        let s_dt = dL + dC * k_s;
+        {
+          let L = L0 * (1 - t) + t * L1;
+          let C = t * C12;
+          let l_ = L + C * k_l;
+          let m_ = L + C * k_m;
+          let s_ = L + C * k_s;
+          let l = l_ * l_ * l_;
+          let m = m_ * m_ * m_;
+          let s = s_ * s_ * s_;
+          let ldt = 3 * l_dt * l_ * l_;
+          let mdt = 3 * m_dt * m_ * m_;
+          let sdt = 3 * s_dt * s_ * s_;
+          let ldt2 = 6 * l_dt * l_dt * l_;
+          let mdt2 = 6 * m_dt * m_dt * m_;
+          let sdt2 = 6 * s_dt * s_dt * s_;
+          let r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s - 1;
+          let r1 = 4.0767416621 * ldt - 3.3077115913 * mdt + 0.2309699292 * sdt;
+          let r2 = 4.0767416621 * ldt2 - 3.3077115913 * mdt2 + 0.2309699292 * sdt2;
+          let u_r = r1 / (r1 * r1 - 0.5 * r * r2);
+          let t_r = -r * u_r;
+          let g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s - 1;
+          let g1 = -1.2684380046 * ldt + 2.6097574011 * mdt - 0.3413193965 * sdt;
+          let g2 = -1.2684380046 * ldt2 + 2.6097574011 * mdt2 - 0.3413193965 * sdt2;
+          let u_g = g1 / (g1 * g1 - 0.5 * g * g2);
+          let t_g = -g * u_g;
+          let b2 = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s - 1;
+          let b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.707614701 * sdt;
+          let b22 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.707614701 * sdt2;
+          let u_b = b1 / (b1 * b1 - 0.5 * b2 * b22);
+          let t_b = -b2 * u_b;
+          t_r = u_r >= 0 ? t_r : 1e6;
+          t_g = u_g >= 0 ? t_g : 1e6;
+          t_b = u_b >= 0 ? t_b : 1e6;
+          t += Math.min(t_r, Math.min(t_g, t_b));
+        }
+      }
+    }
+    return t;
+  }
+  function get_ST_max(a_, b_, cusp = null) {
+    if (!cusp) {
+      cusp = find_cusp(a_, b_);
+    }
+    let L = cusp[0];
+    let C = cusp[1];
+    return [C / L, C / (1 - L)];
+  }
+  function get_Cs(L, a_, b_) {
+    let cusp = find_cusp(a_, b_);
+    let C_max = find_gamut_intersection(a_, b_, L, 1, L, cusp);
+    let ST_max = get_ST_max(a_, b_, cusp);
+    let S_mid = 0.11516993 + 1 / (7.4477897 + 4.1590124 * b_ + a_ * (-2.19557347 + 1.75198401 * b_ + a_ * (-2.13704948 - 10.02301043 * b_ + a_ * (-4.24894561 + 5.38770819 * b_ + 4.69891013 * a_))));
+    let T_mid = 0.11239642 + 1 / (1.6132032 - 0.68124379 * b_ + a_ * (0.40370612 + 0.90148123 * b_ + a_ * (-0.27087943 + 0.6122399 * b_ + a_ * (299215e-8 - 0.45399568 * b_ - 0.14661872 * a_))));
+    let k2 = C_max / Math.min(L * ST_max[0], (1 - L) * ST_max[1]);
+    let C_a = L * S_mid;
+    let C_b = (1 - L) * T_mid;
+    let C_mid = 0.9 * k2 * Math.sqrt(
+      Math.sqrt(
+        1 / (1 / (C_a * C_a * C_a * C_a) + 1 / (C_b * C_b * C_b * C_b))
+      )
+    );
+    C_a = L * 0.4;
+    C_b = (1 - L) * 0.8;
+    let C_0 = Math.sqrt(1 / (1 / (C_a * C_a) + 1 / (C_b * C_b)));
+    return [C_0, C_mid, C_max];
+  }
+  function convertOklabToOkhsl(lab) {
+    const l = lab.l !== void 0 ? lab.l : 0;
+    const a = lab.a !== void 0 ? lab.a : 0;
+    const b = lab.b !== void 0 ? lab.b : 0;
+    const ret = { mode: "okhsl", l: toe(l) };
+    if (lab.alpha !== void 0) {
+      ret.alpha = lab.alpha;
+    }
+    let c2 = Math.sqrt(a * a + b * b);
+    if (!c2) {
+      ret.s = 0;
+      return ret;
+    }
+    let [C_0, C_mid, C_max] = get_Cs(l, a / c2, b / c2);
+    let s;
+    if (c2 < C_mid) {
+      let k_0 = 0;
+      let k_1 = 0.8 * C_0;
+      let k_2 = 1 - k_1 / C_mid;
+      let t = (c2 - k_0) / (k_1 + k_2 * (c2 - k_0));
+      s = t * 0.8;
+    } else {
+      let k_0 = C_mid;
+      let k_1 = 0.2 * C_mid * C_mid * 1.25 * 1.25 / C_0;
+      let k_2 = 1 - k_1 / (C_max - C_mid);
+      let t = (c2 - k_0) / (k_1 + k_2 * (c2 - k_0));
+      s = 0.8 + 0.2 * t;
+    }
+    if (s) {
+      ret.s = s;
+      ret.h = normalizeHue(Math.atan2(b, a) * 180 / Math.PI);
+    }
+    return ret;
+  }
+  function convertOkhslToOklab(hsl) {
+    let h = hsl.h !== void 0 ? hsl.h : 0;
+    let s = hsl.s !== void 0 ? hsl.s : 0;
+    let l = hsl.l !== void 0 ? hsl.l : 0;
+    const ret = { mode: "oklab", l: toe_inv(l) };
+    if (hsl.alpha !== void 0) {
+      ret.alpha = hsl.alpha;
+    }
+    if (!s || l === 1) {
+      ret.a = ret.b = 0;
+      return ret;
+    }
+    let a_ = Math.cos(h / 180 * Math.PI);
+    let b_ = Math.sin(h / 180 * Math.PI);
+    let [C_0, C_mid, C_max] = get_Cs(ret.l, a_, b_);
+    let t, k_0, k_1, k_2;
+    if (s < 0.8) {
+      t = 1.25 * s;
+      k_0 = 0;
+      k_1 = 0.8 * C_0;
+      k_2 = 1 - k_1 / C_mid;
+    } else {
+      t = 5 * (s - 0.8);
+      k_0 = C_mid;
+      k_1 = 0.2 * C_mid * C_mid * 1.25 * 1.25 / C_0;
+      k_2 = 1 - k_1 / (C_max - C_mid);
+    }
+    let C = k_0 + t * k_1 / (1 - k_2 * t);
+    ret.a = C * a_;
+    ret.b = C * b_;
+    return ret;
+  }
+  const modeOkhsl = __spreadProps(__spreadValues({}, definition$l), {
+    mode: "okhsl",
+    channels: ["h", "s", "l", "alpha"],
+    parse: ["--okhsl"],
+    serialize: "--okhsl",
+    fromMode: {
+      oklab: convertOklabToOkhsl,
+      rgb: (c2) => convertOklabToOkhsl(convertRgbToOklab(c2))
+    },
+    toMode: {
+      oklab: convertOkhslToOklab,
+      rgb: (c2) => convertOklabToRgb(convertOkhslToOklab(c2))
+    }
+  });
+  function convertOklabToOkhsv(lab) {
+    let l = lab.l !== void 0 ? lab.l : 0;
+    let a = lab.a !== void 0 ? lab.a : 0;
+    let b = lab.b !== void 0 ? lab.b : 0;
+    let c2 = Math.sqrt(a * a + b * b);
+    let a_ = c2 ? a / c2 : 1;
+    let b_ = c2 ? b / c2 : 1;
+    let [S_max, T] = get_ST_max(a_, b_);
+    let S_0 = 0.5;
+    let k2 = 1 - S_0 / S_max;
+    let t = T / (c2 + l * T);
+    let L_v = t * l;
+    let C_v = t * c2;
+    let L_vt = toe_inv(L_v);
+    let C_vt = C_v * L_vt / L_v;
+    let rgb_scale = convertOklabToLrgb({ l: L_vt, a: a_ * C_vt, b: b_ * C_vt });
+    let scale_L = Math.cbrt(
+      1 / Math.max(rgb_scale.r, rgb_scale.g, rgb_scale.b, 0)
+    );
+    l = l / scale_L;
+    c2 = c2 / scale_L * toe(l) / l;
+    l = toe(l);
+    const ret = {
+      mode: "okhsv",
+      s: c2 ? (S_0 + T) * C_v / (T * S_0 + T * k2 * C_v) : 0,
+      v: l ? l / L_v : 0
+    };
+    if (ret.s) {
+      ret.h = normalizeHue(Math.atan2(b, a) * 180 / Math.PI);
+    }
+    if (lab.alpha !== void 0) {
+      ret.alpha = lab.alpha;
+    }
+    return ret;
+  }
+  function convertOkhsvToOklab(hsv) {
+    const ret = { mode: "oklab" };
+    if (hsv.alpha !== void 0) {
+      ret.alpha = hsv.alpha;
+    }
+    const h = hsv.h !== void 0 ? hsv.h : 0;
+    const s = hsv.s !== void 0 ? hsv.s : 0;
+    const v = hsv.v !== void 0 ? hsv.v : 0;
+    const a_ = Math.cos(h / 180 * Math.PI);
+    const b_ = Math.sin(h / 180 * Math.PI);
+    const [S_max, T] = get_ST_max(a_, b_);
+    const S_0 = 0.5;
+    const k2 = 1 - S_0 / S_max;
+    const L_v = 1 - s * S_0 / (S_0 + T - T * k2 * s);
+    const C_v = s * T * S_0 / (S_0 + T - T * k2 * s);
+    const L_vt = toe_inv(L_v);
+    const C_vt = C_v * L_vt / L_v;
+    const rgb_scale = convertOklabToLrgb({
+      l: L_vt,
+      a: a_ * C_vt,
+      b: b_ * C_vt
+    });
+    const scale_L = Math.cbrt(
+      1 / Math.max(rgb_scale.r, rgb_scale.g, rgb_scale.b, 0)
+    );
+    const L_new = toe_inv(v * L_v);
+    const C = C_v * L_new / L_v;
+    ret.l = L_new * scale_L;
+    ret.a = C * a_ * scale_L;
+    ret.b = C * b_ * scale_L;
+    return ret;
+  }
+  const modeOkhsv = __spreadProps(__spreadValues({}, definition$k), {
+    mode: "okhsv",
+    channels: ["h", "s", "v", "alpha"],
+    parse: ["--okhsv"],
+    serialize: "--okhsv",
+    fromMode: {
+      oklab: convertOklabToOkhsv,
+      rgb: (c2) => convertOklabToOkhsv(convertRgbToOklab(c2))
+    },
+    toMode: {
+      oklab: convertOkhsvToOklab,
+      rgb: (c2) => convertOklabToRgb(convertOkhsvToOklab(c2))
+    }
+  });
+  function parseOklab(color, parsed) {
+    if (!parsed || parsed[0] !== "oklab") {
+      return void 0;
+    }
+    const res = { mode: "oklab" };
+    const [, l, a, b, alpha] = parsed;
+    if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
+      return void 0;
+    }
+    if (l.type !== Tok.None) {
+      res.l = Math.min(
+        Math.max(0, l.type === Tok.Number ? l.value : l.value / 100),
+        1
+      );
+    }
+    if (a.type !== Tok.None) {
+      res.a = a.type === Tok.Number ? a.value : a.value * 0.4 / 100;
+    }
+    if (b.type !== Tok.None) {
+      res.b = b.type === Tok.Number ? b.value : b.value * 0.4 / 100;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$8 = __spreadProps(__spreadValues({}, definition$f), {
+    mode: "oklab",
+    toMode: {
+      lrgb: convertOklabToLrgb,
+      rgb: convertOklabToRgb
+    },
+    fromMode: {
+      lrgb: convertLrgbToOklab,
+      rgb: convertRgbToOklab
+    },
+    ranges: {
+      l: [0, 1],
+      a: [-0.4, 0.4],
+      b: [-0.4, 0.4]
+    },
+    parse: [parseOklab],
+    serialize: (c2) => `oklab(${c2.l !== void 0 ? c2.l : "none"} ${c2.a !== void 0 ? c2.a : "none"} ${c2.b !== void 0 ? c2.b : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`
+  });
+  function parseOklch(color, parsed) {
+    if (!parsed || parsed[0] !== "oklch") {
+      return void 0;
+    }
+    const res = { mode: "oklch" };
+    const [, l, c2, h, alpha] = parsed;
+    if (l.type !== Tok.None) {
+      if (l.type === Tok.Hue) {
+        return void 0;
+      }
+      res.l = Math.min(
+        Math.max(0, l.type === Tok.Number ? l.value : l.value / 100),
+        1
+      );
+    }
+    if (c2.type !== Tok.None) {
+      res.c = Math.max(
+        0,
+        c2.type === Tok.Number ? c2.value : c2.value * 0.4 / 100
+      );
+    }
+    if (h.type !== Tok.None) {
+      if (h.type === Tok.Percentage) {
+        return void 0;
+      }
+      res.h = h.value;
+    }
+    if (alpha.type !== Tok.None) {
+      res.alpha = Math.min(
+        1,
+        Math.max(
+          0,
+          alpha.type === Tok.Number ? alpha.value : alpha.value / 100
+        )
+      );
+    }
+    return res;
+  }
+  const definition$7 = __spreadProps(__spreadValues({}, definition$d), {
+    mode: "oklch",
+    toMode: {
+      oklab: (c2) => convertLchToLab(c2, "oklab"),
+      rgb: (c2) => convertOklabToRgb(convertLchToLab(c2, "oklab"))
+    },
+    fromMode: {
+      rgb: (c2) => convertLabToLch(convertRgbToOklab(c2), "oklch"),
+      oklab: (c2) => convertLabToLch(c2, "oklch")
+    },
+    parse: [parseOklch],
+    serialize: (c2) => `oklch(${c2.l !== void 0 ? c2.l : "none"} ${c2.c !== void 0 ? c2.c : "none"} ${c2.h !== void 0 ? c2.h : "none"}${c2.alpha < 1 ? ` / ${c2.alpha}` : ""})`,
+    ranges: {
+      l: [0, 1],
+      c: [0, 0.4],
+      h: [0, 360]
+    }
+  });
+  const convertP3ToXyz65 = (rgb2) => {
+    let { r, g, b, alpha } = convertRgbToLrgb(rgb2);
+    let res = {
+      mode: "xyz65",
+      x: 0.486570948648216 * r + 0.265667693169093 * g + 0.1982172852343625 * b,
+      y: 0.2289745640697487 * r + 0.6917385218365062 * g + 0.079286914093745 * b,
+      z: 0 * r + 0.0451133818589026 * g + 1.043944368900976 * b
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertXyz65ToP3 = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = convertLrgbToRgb(
+      {
+        r: x * 2.4934969119414263 - y * 0.9313836179191242 - 0.402710784450717 * z,
+        g: x * -0.8294889695615749 + y * 1.7626640603183465 + 0.0236246858419436 * z,
+        b: x * 0.0358458302437845 - y * 0.0761723892680418 + 0.9568845240076871 * z
+      },
+      "p3"
+    );
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const definition$6 = __spreadProps(__spreadValues({}, definition$r), {
+    mode: "p3",
+    parse: ["display-p3"],
+    serialize: "display-p3",
+    fromMode: {
+      rgb: (color) => convertXyz65ToP3(convertRgbToXyz65(color)),
+      xyz65: convertXyz65ToP3
+    },
+    toMode: {
+      rgb: (color) => convertXyz65ToRgb(convertP3ToXyz65(color)),
+      xyz65: convertP3ToXyz65
+    }
+  });
+  const gamma$1 = (v) => {
+    let abs2 = Math.abs(v);
+    if (abs2 >= 1 / 512) {
+      return Math.sign(v) * Math.pow(abs2, 1 / 1.8);
+    }
+    return 16 * v;
+  };
+  const convertXyz50ToProphoto = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = {
+      mode: "prophoto",
+      r: gamma$1(
+        x * 1.3457868816471585 - y * 0.2555720873797946 - 0.0511018649755453 * z
+      ),
+      g: gamma$1(
+        x * -0.5446307051249019 + y * 1.5082477428451466 + 0.0205274474364214 * z
+      ),
+      b: gamma$1(x * 0 + y * 0 + 1.2119675456389452 * z)
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const linearize$1 = (v = 0) => {
+    let abs2 = Math.abs(v);
+    if (abs2 >= 16 / 512) {
+      return Math.sign(v) * Math.pow(abs2, 1.8);
+    }
+    return v / 16;
+  };
+  const convertProphotoToXyz50 = (prophoto) => {
+    let r = linearize$1(prophoto.r);
+    let g = linearize$1(prophoto.g);
+    let b = linearize$1(prophoto.b);
+    let res = {
+      mode: "xyz50",
+      x: 0.7977666449006423 * r + 0.1351812974005331 * g + 0.0313477341283922 * b,
+      y: 0.2880748288194013 * r + 0.7118352342418731 * g + 899369387256e-16 * b,
+      z: 0 * r + 0 * g + 0.8251046025104602 * b
+    };
+    if (prophoto.alpha !== void 0) {
+      res.alpha = prophoto.alpha;
+    }
+    return res;
+  };
+  const definition$5 = __spreadProps(__spreadValues({}, definition$r), {
+    mode: "prophoto",
+    parse: ["prophoto-rgb"],
+    serialize: "prophoto-rgb",
+    fromMode: {
+      xyz50: convertXyz50ToProphoto,
+      rgb: (color) => convertXyz50ToProphoto(convertRgbToXyz50(color))
+    },
+    toMode: {
+      xyz50: convertProphotoToXyz50,
+      rgb: (color) => convertXyz50ToRgb(convertProphotoToXyz50(color))
+    }
+  });
+  const α$1 = 1.09929682680944;
+  const β$1 = 0.018053968510807;
+  const gamma = (v) => {
+    const abs2 = Math.abs(v);
+    if (abs2 > β$1) {
+      return (Math.sign(v) || 1) * (α$1 * Math.pow(abs2, 0.45) - (α$1 - 1));
+    }
+    return 4.5 * v;
+  };
+  const convertXyz65ToRec2020 = ({ x, y, z, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = {
+      mode: "rec2020",
+      r: gamma(
+        x * 1.7166511879712683 - y * 0.3556707837763925 - 0.2533662813736599 * z
+      ),
+      g: gamma(
+        x * -0.6666843518324893 + y * 1.6164812366349395 + 0.0157685458139111 * z
+      ),
+      b: gamma(
+        x * 0.0176398574453108 - y * 0.0427706132578085 + 0.9421031212354739 * z
+      )
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const α = 1.09929682680944;
+  const β = 0.018053968510807;
+  const linearize = (v = 0) => {
+    let abs2 = Math.abs(v);
+    if (abs2 < β * 4.5) {
+      return v / 4.5;
+    }
+    return (Math.sign(v) || 1) * Math.pow((abs2 + α - 1) / α, 1 / 0.45);
+  };
+  const convertRec2020ToXyz65 = (rec2020) => {
+    let r = linearize(rec2020.r);
+    let g = linearize(rec2020.g);
+    let b = linearize(rec2020.b);
+    let res = {
+      mode: "xyz65",
+      x: 0.6369580483012911 * r + 0.1446169035862083 * g + 0.1688809751641721 * b,
+      y: 0.262700212011267 * r + 0.6779980715188708 * g + 0.059301716469862 * b,
+      z: 0 * r + 0.0280726930490874 * g + 1.0609850577107909 * b
+    };
+    if (rec2020.alpha !== void 0) {
+      res.alpha = rec2020.alpha;
+    }
+    return res;
+  };
+  const definition$4 = __spreadProps(__spreadValues({}, definition$r), {
+    mode: "rec2020",
+    fromMode: {
+      xyz65: convertXyz65ToRec2020,
+      rgb: (color) => convertXyz65ToRec2020(convertRgbToXyz65(color))
+    },
+    toMode: {
+      xyz65: convertRec2020ToXyz65,
+      rgb: (color) => convertXyz65ToRgb(convertRec2020ToXyz65(color))
+    },
+    parse: ["rec2020"],
+    serialize: "rec2020"
+  });
+  const bias = 0.0037930732552754493;
+  const bias_cbrt = Math.cbrt(bias);
+  const transfer$1 = (v) => Math.cbrt(v) - bias_cbrt;
+  const convertRgbToXyb = (color) => {
+    const { r, g, b, alpha } = convertRgbToLrgb(color);
+    const l = transfer$1(0.3 * r + 0.622 * g + 0.078 * b + bias);
+    const m = transfer$1(0.23 * r + 0.692 * g + 0.078 * b + bias);
+    const s = transfer$1(
+      0.2434226892454782 * r + 0.2047674442449682 * g + 0.5518098665095535 * b + bias
+    );
+    const res = {
+      mode: "xyb",
+      x: (l - m) / 2,
+      y: (l + m) / 2,
+      /* Apply default chroma from luma (subtract Y from B) */
+      b: s - (l + m) / 2
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const transfer = (v) => Math.pow(v + bias_cbrt, 3);
+  const convertXybToRgb = ({ x, y, b, alpha }) => {
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (b === void 0) b = 0;
+    const l = transfer(x + y) - bias;
+    const m = transfer(y - x) - bias;
+    const s = transfer(b + y) - bias;
+    const res = convertLrgbToRgb({
+      r: 11.031566904639861 * l - 9.866943908131562 * m - 0.16462299650829934 * s,
+      g: -3.2541473810744237 * l + 4.418770377582723 * m - 0.16462299650829934 * s,
+      b: -3.6588512867136815 * l + 2.7129230459360922 * m + 1.9459282407775895 * s
+    });
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const definition$3 = {
+    mode: "xyb",
+    channels: ["x", "y", "b", "alpha"],
+    parse: ["--xyb"],
+    serialize: "--xyb",
+    toMode: {
+      rgb: convertXybToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToXyb
+    },
+    ranges: {
+      x: [-0.0154, 0.0281],
+      y: [0, 0.8453],
+      b: [-0.2778, 0.388]
+    },
+    interpolate: {
+      x: interpolatorLinear,
+      y: interpolatorLinear,
+      b: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const definition$2 = {
+    mode: "xyz50",
+    parse: ["xyz-d50"],
+    serialize: "xyz-d50",
+    toMode: {
+      rgb: convertXyz50ToRgb,
+      lab: convertXyz50ToLab
+    },
+    fromMode: {
+      rgb: convertRgbToXyz50,
+      lab: convertLabToXyz50
+    },
+    channels: ["x", "y", "z", "alpha"],
+    ranges: {
+      x: [0, 0.964],
+      y: [0, 0.999],
+      z: [0, 0.825]
+    },
+    interpolate: {
+      x: interpolatorLinear,
+      y: interpolatorLinear,
+      z: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const convertXyz65ToXyz50 = (xyz65) => {
+    let { x, y, z, alpha } = xyz65;
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = {
+      mode: "xyz50",
+      x: 1.0479298208405488 * x + 0.0229467933410191 * y - 0.0501922295431356 * z,
+      y: 0.0296278156881593 * x + 0.990434484573249 * y - 0.0170738250293851 * z,
+      z: -0.0092430581525912 * x + 0.0150551448965779 * y + 0.7518742899580008 * z
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const convertXyz50ToXyz65 = (xyz50) => {
+    let { x, y, z, alpha } = xyz50;
+    if (x === void 0) x = 0;
+    if (y === void 0) y = 0;
+    if (z === void 0) z = 0;
+    let res = {
+      mode: "xyz65",
+      x: 0.9554734527042182 * x - 0.0230985368742614 * y + 0.0632593086610217 * z,
+      y: -0.0283697069632081 * x + 1.0099954580058226 * y + 0.021041398966943 * z,
+      z: 0.0123140016883199 * x - 0.0205076964334779 * y + 1.3303659366080753 * z
+    };
+    if (alpha !== void 0) {
+      res.alpha = alpha;
+    }
+    return res;
+  };
+  const definition$1 = {
+    mode: "xyz65",
+    toMode: {
+      rgb: convertXyz65ToRgb,
+      xyz50: convertXyz65ToXyz50
+    },
+    fromMode: {
+      rgb: convertRgbToXyz65,
+      xyz50: convertXyz50ToXyz65
+    },
+    ranges: {
+      x: [0, 0.95],
+      y: [0, 1],
+      z: [0, 1.088]
+    },
+    channels: ["x", "y", "z", "alpha"],
+    parse: ["xyz", "xyz-d65"],
+    serialize: "xyz-d65",
+    interpolate: {
+      x: interpolatorLinear,
+      y: interpolatorLinear,
+      z: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const convertRgbToYiq = ({ r, g, b, alpha }) => {
+    if (r === void 0) r = 0;
+    if (g === void 0) g = 0;
+    if (b === void 0) b = 0;
+    const res = {
+      mode: "yiq",
+      y: 0.29889531 * r + 0.58662247 * g + 0.11448223 * b,
+      i: 0.59597799 * r - 0.2741761 * g - 0.32180189 * b,
+      q: 0.21147017 * r - 0.52261711 * g + 0.31114694 * b
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const convertYiqToRgb = ({ y, i, q, alpha }) => {
+    if (y === void 0) y = 0;
+    if (i === void 0) i = 0;
+    if (q === void 0) q = 0;
+    const res = {
+      mode: "rgb",
+      r: y + 0.95608445 * i + 0.6208885 * q,
+      g: y - 0.27137664 * i - 0.6486059 * q,
+      b: y - 1.10561724 * i + 1.70250126 * q
+    };
+    if (alpha !== void 0) res.alpha = alpha;
+    return res;
+  };
+  const definition = {
+    mode: "yiq",
+    toMode: {
+      rgb: convertYiqToRgb
+    },
+    fromMode: {
+      rgb: convertRgbToYiq
+    },
+    channels: ["y", "i", "q", "alpha"],
+    parse: ["--yiq"],
+    serialize: "--yiq",
+    ranges: {
+      i: [-0.595, 0.595],
+      q: [-0.522, 0.522]
+    },
+    interpolate: {
+      y: interpolatorLinear,
+      i: interpolatorLinear,
+      q: interpolatorLinear,
+      alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+    }
+  };
+  const clamp = (value) => Math.max(0, Math.min(1, value || 0));
+  const fixup = (value) => Math.round(clamp(value) * 255);
+  const rgb = converter("rgb");
+  const serializeHex = (color) => {
+    if (color === void 0) {
+      return void 0;
+    }
+    let r = fixup(color.r);
+    let g = fixup(color.g);
+    let b = fixup(color.b);
+    return "#" + (1 << 24 | r << 16 | g << 8 | b).toString(16).slice(1);
+  };
+  const serializeHex8 = (color) => {
+    if (color === void 0) {
+      return void 0;
+    }
+    let a = fixup(color.alpha !== void 0 ? color.alpha : 1);
+    return serializeHex(color) + (1 << 8 | a).toString(16).slice(1);
+  };
+  const formatHex = (c2) => serializeHex(rgb(c2));
+  const formatHex8 = (c2) => serializeHex8(rgb(c2));
+  useMode(definition$q);
+  useMode(definition$p);
+  useMode(definition$o);
+  useMode(definition$n);
+  useMode(definition$m);
+  useMode(definition$l);
+  useMode(definition$k);
+  useMode(definition$j);
+  useMode(definition$i);
+  useMode(definition$h);
+  useMode(definition$g);
+  useMode(definition$f);
+  useMode(definition$e);
+  useMode(definition$d);
+  useMode(definition$c);
+  useMode(definition$b);
+  useMode(definition$a);
+  useMode(definition$9);
+  useMode(modeOkhsl);
+  useMode(modeOkhsv);
+  useMode(definition$8);
+  useMode(definition$7);
+  useMode(definition$6);
+  useMode(definition$5);
+  useMode(definition$4);
+  useMode(definition$r);
+  useMode(definition$3);
+  useMode(definition$2);
+  useMode(definition$1);
+  useMode(definition);
+  function cssColorToFigma(value) {
+    var _a, _b, _c, _d;
+    const parsed = parse(value);
+    if (!parsed) return null;
+    const rgb2 = parsed;
+    return {
+      r: (_a = rgb2.r) != null ? _a : 0,
+      g: (_b = rgb2.g) != null ? _b : 0,
+      b: (_c = rgb2.b) != null ? _c : 0,
+      a: (_d = rgb2.alpha) != null ? _d : 1
+    };
+  }
+  function figmaColorToCss(rgba) {
+    var _a, _b, _c;
+    const color = {
+      mode: "rgb",
+      r: rgba.r,
+      g: rgba.g,
+      b: rgba.b,
+      alpha: (_a = rgba.a) != null ? _a : 1
+    };
+    if (rgba.a !== void 0 && rgba.a < 1) {
+      return (_b = formatHex8(color)) != null ? _b : "#000000";
+    }
+    return (_c = formatHex(color)) != null ? _c : "#000000";
+  }
+  function parseDimension(value) {
+    var _a, _b;
+    const match = value.match(/^(-?\d*\.?\d+)(px|rem|em|%|vh|vw|vmin|vmax|ch)?$/);
+    if (!match) return null;
+    return {
+      value: Number.parseFloat((_a = match[1]) != null ? _a : "0"),
+      unit: (_b = match[2]) != null ? _b : ""
+    };
+  }
+  function dimensionToPixels(value, baseFontSize = 16) {
+    const parsed = parseDimension(value);
+    if (!parsed) return null;
+    switch (parsed.unit) {
+      case "px":
+      case "":
+        return parsed.value;
+      case "rem":
+      case "em":
+        return parsed.value * baseFontSize;
+      case "%":
+        return parsed.value;
+      // Keep percentage as-is for Figma
+      default:
+        return null;
+    }
+  }
+  function fromDTCG(doc, options = {}) {
+    var _a;
+    const {
+      defaultModeName = "Default",
+      collectionName,
+      preferredModifier = "theme"
+    } = options;
+    const { modes: modes2 } = extractModes(doc, defaultModeName, preferredModifier);
+    const sfExtension = (_a = doc.$extensions) == null ? void 0 : _a["dev.styleframe"];
+    const collection = collectionName || (sfExtension == null ? void 0 : sfExtension.collection) || "Design Tokens";
+    const variables = [];
+    const modifierOverrides = extractModifierOverrides(doc, preferredModifier);
+    walkTokens(
+      doc,
+      "",
+      modes2[0] || defaultModeName,
+      (path, token, inheritedType) => {
+        const variable = tokenToVariableWithModifiers(
+          path,
+          token,
+          inheritedType,
+          modes2,
+          modes2[0] || defaultModeName,
+          modifierOverrides
+        );
+        if (variable) {
+          variables.push(variable);
+        }
+      }
+    );
+    return {
+      collection,
+      modes: modes2,
+      variables
+    };
+  }
+  function walkTokens(node, parentPath, defaultModeName, callback, inheritedType) {
+    const currentType = node.$type || inheritedType;
+    for (const [key, value] of Object.entries(node)) {
+      if (key.startsWith("$")) continue;
+      const path = parentPath ? `${parentPath}/${key}` : key;
+      if (isDTCGToken(value)) {
+        callback(path, value, currentType);
+      } else if (isDTCGGroup(value)) {
+        walkTokens(value, path, defaultModeName, callback, currentType);
+      }
+    }
+  }
+  function extractModes(doc, defaultModeName, preferredModifier) {
+    var _a, _b, _c, _d;
+    const modifier = (_a = doc.$modifiers) == null ? void 0 : _a[preferredModifier];
+    if (modifier && modifier.contexts) {
+      const contextNames = Object.keys(modifier.contexts);
+      if (contextNames.length > 0) {
+        const sfExtension2 = (_b = doc.$extensions) == null ? void 0 : _b["dev.styleframe"];
+        const defaultMode = modifier.$default || ((_c = sfExtension2 == null ? void 0 : sfExtension2.modes) == null ? void 0 : _c[0]) || defaultModeName;
+        const allModes = [
+          defaultMode,
+          ...contextNames.filter((n) => n !== defaultMode)
+        ];
+        return { modes: allModes, modeSource: "modifier" };
+      }
+    }
+    const sfExtension = (_d = doc.$extensions) == null ? void 0 : _d["dev.styleframe"];
+    if ((sfExtension == null ? void 0 : sfExtension.modes) && sfExtension.modes.length > 0) {
+      return { modes: sfExtension.modes, modeSource: "extension" };
+    }
+    return { modes: [defaultModeName], modeSource: "default" };
+  }
+  function extractModifierOverrides(doc, preferredModifier) {
+    var _a;
+    const overrides = /* @__PURE__ */ new Map();
+    const modifier = (_a = doc.$modifiers) == null ? void 0 : _a[preferredModifier];
+    if (!(modifier == null ? void 0 : modifier.contexts)) return overrides;
+    for (const [contextName, context] of Object.entries(modifier.contexts)) {
+      walkModifierContext(context, "", (tokenPath, value) => {
+        if (!overrides.has(tokenPath)) {
+          overrides.set(tokenPath, /* @__PURE__ */ new Map());
+        }
+        overrides.get(tokenPath).set(contextName, value);
+      });
+    }
+    return overrides;
+  }
+  function walkModifierContext(context, parentPath, callback) {
+    for (const [key, value] of Object.entries(context)) {
+      const path = parentPath ? `${parentPath}.${key}` : key;
+      if (value && typeof value === "object" && "$value" in value) {
+        callback(path, value.$value);
+      } else if (value && typeof value === "object") {
+        walkModifierContext(value, path, callback);
+      }
+    }
+  }
+  function tokenToVariableWithModifiers(path, token, inheritedType, modes2, defaultModeName, modifierOverrides) {
+    var _a, _b;
+    const type = token.$type || inheritedType || "string";
+    const figmaType = dtcgTypeToFigma(type);
+    const isAlias = isDTCGAlias(token.$value);
+    let aliasTo;
+    const values = {};
+    if (isAlias) {
+      aliasTo = parseAlias(token.$value);
+      values[defaultModeName] = {
+        type: "VARIABLE_ALIAS",
+        id: dtcgPathToFigma(aliasTo)
+      };
+    } else {
+      const defaultValue = convertValueToFigma(token.$value, figmaType);
+      values[defaultModeName] = defaultValue;
+      const tokenPath = path.replace(/\//g, ".");
+      const pathOverrides = modifierOverrides.get(tokenPath);
+      if (pathOverrides) {
+        for (const [modeName, modeValue] of pathOverrides) {
+          if (isDTCGAlias(modeValue)) {
+            values[modeName] = {
+              type: "VARIABLE_ALIAS",
+              id: dtcgPathToFigma(parseAlias(modeValue))
+            };
+          } else {
+            values[modeName] = convertValueToFigma(modeValue, figmaType);
+          }
+        }
+      }
+      if (!pathOverrides || pathOverrides.size === 0) {
+        const legacyModeOverrides = (_b = (_a = token.$extensions) == null ? void 0 : _a["dev.styleframe"]) == null ? void 0 : _b.modes;
+        if (legacyModeOverrides) {
+          for (const [modeName, modeValue] of Object.entries(
+            legacyModeOverrides
+          )) {
+            if (isDTCGAlias(modeValue)) {
+              values[modeName] = {
+                type: "VARIABLE_ALIAS",
+                id: dtcgPathToFigma(parseAlias(modeValue))
+              };
+            } else {
+              values[modeName] = convertValueToFigma(modeValue, figmaType);
+            }
+          }
+        }
+      }
+    }
+    const styleframeName = path.replace(/\//g, ".");
+    return {
+      name: path,
+      // Keep slash notation for Figma
+      styleframeName,
+      type: figmaType,
+      values,
+      aliasTo,
+      description: token.$description
+    };
+  }
+  function convertValueToFigma(value, figmaType) {
+    if (figmaType === "COLOR" && typeof value === "string") {
+      const rgba = cssColorToFigma(value);
+      if (rgba) return rgba;
+    }
+    if (figmaType === "FLOAT") {
+      if (typeof value === "number") return value;
+      if (typeof value === "string") {
+        const pixels = dimensionToPixels(value);
+        if (pixels !== null) return pixels;
+        const num2 = Number.parseFloat(value);
+        if (!Number.isNaN(num2)) return num2;
+      }
+    }
+    if (figmaType === "BOOLEAN") {
+      if (typeof value === "boolean") return value;
+      if (value === "true") return true;
+      if (value === "false") return false;
+    }
+    return String(value);
+  }
+  const DTCG_SCHEMA_URL = "https://design-tokens.github.io/community-group/format/";
+  function toDTCG(data, options = {}) {
+    const {
+      includeSchema = true,
+      schemaUrl = DTCG_SCHEMA_URL,
+      useModifiers = true,
+      themeNames
+    } = options;
+    const doc = {};
+    if (includeSchema) {
+      doc.$schema = schemaUrl;
+    }
+    doc.$extensions = {
+      "dev.styleframe": {
+        collection: data.collection,
+        modes: data.modes
+      }
+    };
+    const defaultMode = data.modes[0] || "Default";
+    const themeModes = themeNames ? data.modes.filter((m) => themeNames.includes(m) && m !== defaultMode) : data.modes.slice(1);
+    const modeOverrides = /* @__PURE__ */ new Map();
+    for (const mode of themeModes) {
+      modeOverrides.set(mode, /* @__PURE__ */ new Map());
+    }
+    for (const variable of data.variables) {
+      const { token, overrides } = variableToTokenWithOverrides(
+        variable,
+        data.modes,
+        useModifiers,
+        themeModes
+      );
+      setNestedToken(doc, variable.name, token);
+      if (useModifiers) {
+        for (const [modeName, value] of overrides) {
+          const modeMap = modeOverrides.get(modeName);
+          if (modeMap) {
+            const tokenPath = figmaPathToDTCG(variable.name);
+            modeMap.set(tokenPath, value);
+          }
+        }
+      }
+    }
+    if (useModifiers && themeModes.length > 0 && hasAnyOverrides(modeOverrides)) {
+      doc.$modifiers = {
+        theme: {
+          $type: "modifier",
+          contexts: buildModifierContexts(modeOverrides)
+        }
+      };
+    }
+    return doc;
+  }
+  function variableToTokenWithOverrides(variable, modes2, useModifiers, themeModes) {
+    const defaultMode = modes2[0] || "Default";
+    const defaultValue = variable.values[defaultMode];
+    const dtcgType = figmaTypeToDTCG(variable.type);
+    const overrides = /* @__PURE__ */ new Map();
+    if (variable.aliasTo) {
+      const token2 = {
+        $value: createAlias(variable.aliasTo),
+        $type: dtcgType
+      };
+      if (variable.description) {
+        token2.$description = variable.description;
+      }
+      return { token: token2, overrides };
+    }
+    const $value = convertValueToDTCG(defaultValue, variable.type);
+    const token = {
+      $value,
+      $type: dtcgType
+    };
+    if (variable.description) {
+      token.$description = variable.description;
+    }
+    if (modes2.length > 1) {
+      const modeValues = {};
+      let hasModeOverrides = false;
+      for (const mode of modes2) {
+        if (mode === defaultMode) continue;
+        const modeValue = variable.values[mode];
+        if (modeValue !== void 0) {
+          const convertedValue = convertValueToDTCG(modeValue, variable.type);
+          if (convertedValue !== $value) {
+            const isThemeMode = themeModes.includes(mode);
+            if (useModifiers && isThemeMode) {
+              overrides.set(mode, convertedValue);
+            } else if (!useModifiers || !isThemeMode) {
+              modeValues[mode] = convertedValue;
+              hasModeOverrides = true;
+            }
+          }
+        }
+      }
+      if (hasModeOverrides) {
+        token.$extensions = {
+          "dev.styleframe": {
+            modes: modeValues
+          }
+        };
+      }
+    }
+    return { token, overrides };
+  }
+  function convertValueToDTCG(value, type) {
+    if (type === "COLOR" && typeof value === "object" && value !== null && "r" in value) {
+      return figmaColorToCss(value);
+    }
+    if (type === "FLOAT" && typeof value === "number") {
+      return `${value}px`;
+    }
+    if (typeof value === "boolean") {
+      return value.toString();
+    }
+    return String(value);
+  }
+  function setNestedToken(doc, path, token) {
+    const segments = getPathSegments(path);
+    let current = doc;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const segment = segments[i];
+      if (!current[segment] || typeof current[segment] !== "object") {
+        current[segment] = {};
+      }
+      current = current[segment];
+    }
+    const leafKey = segments[segments.length - 1];
+    current[leafKey] = token;
+  }
+  function hasAnyOverrides(modeOverrides) {
+    for (const overrides of modeOverrides.values()) {
+      if (overrides.size > 0) return true;
+    }
+    return false;
+  }
+  function buildModifierContexts(modeOverrides) {
+    const contexts = {};
+    for (const [modeName, tokenOverrides] of modeOverrides) {
+      if (tokenOverrides.size === 0) continue;
+      const context = {};
+      for (const [tokenPath, value] of tokenOverrides) {
+        setNestedValue(context, tokenPath, { $value: value });
+      }
+      contexts[modeName] = context;
+    }
+    return contexts;
+  }
+  function setNestedValue(obj, path, value) {
+    const segments = path.split(".");
+    let current = obj;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const segment = segments[i];
+      if (!current[segment] || typeof current[segment] !== "object" || "$value" in current[segment]) {
+        current[segment] = {};
+      }
+      current = current[segment];
+    }
+    current[segments[segments.length - 1]] = value;
+  }
+  function isDTCGFormat(data) {
+    if (typeof data !== "object" || data === null) return false;
+    const obj = data;
+    if ("collection" in obj && "modes" in obj && "variables" in obj) {
+      return false;
+    }
+    if ("$modifiers" in obj) return true;
+    for (const [key, value] of Object.entries(obj)) {
+      if (key.startsWith("$")) continue;
+      if (typeof value === "object" && value !== null) {
+        if ("$value" in value) return true;
+        for (const [, nested] of Object.entries(
+          value
+        )) {
+          if (typeof nested === "object" && nested !== null && "$value" in nested) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  figma.showUI(__html__, {
+    width: 520,
+    height: 640,
+    themeColors: true
+  });
+  figma.on("run", ({ command }) => {
+    figma.ui.postMessage({ type: "set-mode", mode: command });
+  });
+  figma.ui.onmessage = async (msg) => {
+    try {
+      switch (msg.type) {
+        case "import":
+          await handleImport(msg.data);
+          break;
+        case "export":
+          await handleExport(msg.collectionId);
+          break;
+        case "get-collections":
+          await sendCollections();
+          break;
+        case "close":
+          figma.closePlugin();
+          break;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      figma.ui.postMessage({ type: "error", message: errorMessage });
+    }
+  };
+  async function sendCollections() {
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+    const collectionData = collections.map((c2) => ({
+      id: c2.id,
+      name: c2.name,
+      modes: c2.modes.map((m) => ({ id: m.modeId, name: m.name })),
+      variableCount: c2.variableIds.length
+    }));
+    figma.ui.postMessage({ type: "collections", collections: collectionData });
+  }
+  async function handleImport(rawData) {
+    var _a, _b, _c;
+    const data = isDTCGFormat(rawData) ? fromDTCG(rawData) : rawData;
+    const { collection: collectionName, modes: modes2, variables } = data;
+    const existingCollections = await figma.variables.getLocalVariableCollectionsAsync();
+    let collection = existingCollections.find((c2) => c2.name === collectionName);
+    if (!collection) {
+      collection = figma.variables.createVariableCollection(collectionName);
+    }
+    const modeIdMap = /* @__PURE__ */ new Map();
+    const existingModes = collection.modes;
+    if (modes2.length > 0) {
+      const defaultMode = existingModes[0];
+      if (defaultMode) {
+        collection.renameMode(defaultMode.modeId, (_a = modes2[0]) != null ? _a : "Default");
+        modeIdMap.set((_b = modes2[0]) != null ? _b : "Default", defaultMode.modeId);
+      }
+    }
+    for (let i = 1; i < modes2.length; i++) {
+      const modeName = modes2[i];
+      if (!modeName) continue;
+      const existingMode = existingModes.find((m) => m.name === modeName);
+      if (existingMode) {
+        modeIdMap.set(modeName, existingMode.modeId);
+      } else {
+        const newModeId = collection.addMode(modeName);
+        modeIdMap.set(modeName, newModeId);
+      }
+    }
+    const variableMap = /* @__PURE__ */ new Map();
+    const existingVariables = await figma.variables.getLocalVariablesAsync();
+    for (const v of variables) {
+      if (v.aliasTo) continue;
+      const existing = existingVariables.find(
+        (fv) => fv.name === v.name && fv.variableCollectionId === collection.id
+      );
+      let figmaVar;
+      if (existing) {
+        figmaVar = existing;
+      } else {
+        figmaVar = figma.variables.createVariable(
+          v.name,
+          collection,
+          getResolvedType(v.type)
+        );
+      }
+      for (const [modeName, value] of Object.entries(v.values)) {
+        const modeId = modeIdMap.get(modeName);
+        if (!modeId) continue;
+        const figmaValue = convertToFigmaValue(value, v.type);
+        if (figmaValue !== null) {
+          figmaVar.setValueForMode(modeId, figmaValue);
+        }
+      }
+      variableMap.set(v.name, figmaVar);
+    }
+    for (const v of variables) {
+      if (!v.aliasTo) continue;
+      const targetVar = variableMap.get(styleframeToFigmaName(v.aliasTo));
+      if (!targetVar) {
+        console.warn(`Alias target not found: ${v.aliasTo}`);
+        continue;
+      }
+      const existing = existingVariables.find(
+        (fv) => fv.name === v.name && fv.variableCollectionId === collection.id
+      );
+      let figmaVar;
+      if (existing) {
+        figmaVar = existing;
+      } else {
+        figmaVar = figma.variables.createVariable(
+          v.name,
+          collection,
+          targetVar.resolvedType
+        );
+      }
+      const defaultModeId = modeIdMap.get((_c = modes2[0]) != null ? _c : "Default");
+      if (defaultModeId) {
+        figmaVar.setValueForMode(defaultModeId, {
+          type: "VARIABLE_ALIAS",
+          id: targetVar.id
+        });
+      }
+    }
+    figma.ui.postMessage({
+      type: "import-complete",
+      result: {
+        collection: collectionName,
+        variablesCreated: variables.length
+      }
+    });
+    figma.notify(`Imported ${variables.length} variables to "${collectionName}"`);
+  }
+  async function handleExport(collectionId) {
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+    let collection;
+    if (collectionId) {
+      collection = collections.find((c2) => c2.id === collectionId);
+    } else {
+      collection = collections[0];
+    }
+    if (!collection) {
+      throw new Error("No variable collection found");
+    }
+    const modes2 = collection.modes.map((m) => m.name);
+    const modeIdToName = new Map(collection.modes.map((m) => [m.modeId, m.name]));
+    const variables = [];
+    const variableIdToName = /* @__PURE__ */ new Map();
+    for (const varId of collection.variableIds) {
+      const figmaVar = await figma.variables.getVariableByIdAsync(varId);
+      if (!figmaVar) continue;
+      variableIdToName.set(figmaVar.id, figmaVar.name);
+    }
+    for (const varId of collection.variableIds) {
+      const figmaVar = await figma.variables.getVariableByIdAsync(varId);
+      if (!figmaVar) continue;
+      const values = {};
+      let aliasTo;
+      for (const [modeId, value] of Object.entries(figmaVar.valuesByMode)) {
+        const modeName = modeIdToName.get(modeId);
+        if (!modeName) continue;
+        if (isVariableAlias(value)) {
+          const targetName = variableIdToName.get(value.id);
+          if (targetName) {
+            aliasTo = figmaToStyleframeName(targetName);
+          }
+          values[modeName] = value;
+        } else {
+          values[modeName] = convertFromFigmaValue(value, figmaVar.resolvedType);
+        }
+      }
+      variables.push({
+        name: figmaVar.name,
+        styleframeName: figmaToStyleframeName(figmaVar.name),
+        type: figmaVar.resolvedType,
+        values,
+        aliasTo,
+        description: figmaVar.description || void 0
+      });
+    }
+    const intermediateData = {
+      collection: collection.name,
+      modes: modes2,
+      variables
+    };
+    const exportData = toDTCG(intermediateData);
+    figma.ui.postMessage({
+      type: "export-complete",
+      result: exportData
+    });
+  }
+  function getResolvedType(type) {
+    switch (type) {
+      case "COLOR":
+        return "COLOR";
+      case "FLOAT":
+        return "FLOAT";
+      case "STRING":
+        return "STRING";
+      case "BOOLEAN":
+        return "BOOLEAN";
+      default:
+        return "STRING";
+    }
+  }
+  function isVariableAlias(value) {
+    return typeof value === "object" && value !== null && "type" in value && value.type === "VARIABLE_ALIAS";
+  }
+  function convertToFigmaValue(value, type) {
+    var _a;
+    if (value === null || value === void 0) return null;
+    switch (type) {
+      case "COLOR": {
+        if (typeof value === "object" && "r" in value) {
+          const rgba = value;
+          return {
+            r: rgba.r,
+            g: rgba.g,
+            b: rgba.b,
+            a: (_a = rgba.a) != null ? _a : 1
+          };
+        }
+        return null;
+      }
+      case "FLOAT": {
+        return typeof value === "number" ? value : null;
+      }
+      case "BOOLEAN": {
+        return typeof value === "boolean" ? value : null;
+      }
+      case "STRING":
+      default: {
+        return String(value);
+      }
+    }
+  }
+  function convertFromFigmaValue(value, type) {
+    switch (type) {
+      case "COLOR": {
+        const rgba = value;
+        return {
+          r: rgba.r,
+          g: rgba.g,
+          b: rgba.b,
+          a: rgba.a
+        };
+      }
+      case "FLOAT": {
+        return value;
+      }
+      case "BOOLEAN": {
+        return value;
+      }
+      case "STRING":
+      default: {
+        return String(value);
+      }
+    }
+  }
+})();