@shiinasaku/github-card 4.1.0 → 5.0.0

package/dist/lib.js

@@ -1,3 +1,3428 @@
+// node_modules/culori/src/rgb/parseNumber.js
+var 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
+    };
+  }
+};
+var parseNumber_default = parseNumber;
+
+// node_modules/culori/src/colors/named.js
+var 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,
+  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
+};
+var named_default = named;
+
+// node_modules/culori/src/rgb/parseNamed.js
+var parseNamed = (color) => {
+  return parseNumber_default(named_default[color.toLowerCase()], 6);
+};
+var parseNamed_default = parseNamed;
+
+// node_modules/culori/src/rgb/parseHex.js
+var hex = /^#?([0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{4}|[0-9a-f]{3})$/i;
+var parseHex = (color) => {
+  let match;
+  return (match = color.match(hex)) ? parseNumber_default(parseInt(match[1], 16), match[1].length) : undefined;
+};
+var parseHex_default = parseHex;
+
+// node_modules/culori/src/util/regex.js
+var num = "([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)";
+var num_none = `(?:${num}|none)`;
+var per = `${num}%`;
+var per_none = `(?:${num}%|none)`;
+var num_per = `(?:${num}%|${num})`;
+var num_per_none = `(?:${num}%|${num}|none)`;
+var hue = `(?:${num}(deg|grad|rad|turn)|${num})`;
+var hue_none = `(?:${num}(deg|grad|rad|turn)|${num}|none)`;
+var c = `\\s*,\\s*`;
+var rx_num_per_none = new RegExp("^" + num_per_none + "$");
+
+// node_modules/culori/src/rgb/parseRgbLegacy.js
+var rgb_num_old = new RegExp(`^rgba?\\(\\s*${num}${c}${num}${c}${num}\\s*(?:,\\s*${num_per}\\s*)?\\)$`);
+var rgb_per_old = new RegExp(`^rgba?\\(\\s*${per}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`);
+var parseRgbLegacy = (color) => {
+  let res = { mode: "rgb" };
+  let match;
+  if (match = color.match(rgb_num_old)) {
+    if (match[1] !== undefined) {
+      res.r = match[1] / 255;
+    }
+    if (match[2] !== undefined) {
+      res.g = match[2] / 255;
+    }
+    if (match[3] !== undefined) {
+      res.b = match[3] / 255;
+    }
+  } else if (match = color.match(rgb_per_old)) {
+    if (match[1] !== undefined) {
+      res.r = match[1] / 100;
+    }
+    if (match[2] !== undefined) {
+      res.g = match[2] / 100;
+    }
+    if (match[3] !== undefined) {
+      res.b = match[3] / 100;
+    }
+  } else {
+    return;
+  }
+  if (match[4] !== undefined) {
+    res.alpha = Math.max(0, Math.min(1, match[4] / 100));
+  } else if (match[5] !== undefined) {
+    res.alpha = Math.max(0, Math.min(1, +match[5]));
+  }
+  return res;
+};
+var parseRgbLegacy_default = parseRgbLegacy;
+
+// node_modules/culori/src/_prepare.js
+var prepare = (color, mode) => color === undefined ? undefined : typeof color !== "object" ? parse_default(color) : color.mode !== undefined ? color : mode ? { ...color, mode } : undefined;
+var _prepare_default = prepare;
+
+// node_modules/culori/src/converter.js
+var converter = (target_mode = "rgb") => (color) => (color = _prepare_default(color, target_mode)) !== undefined ? color.mode === target_mode ? color : converters[color.mode][target_mode] ? converters[color.mode][target_mode](color) : target_mode === "rgb" ? converters[color.mode].rgb(color) : converters.rgb[target_mode](converters[color.mode].rgb(color)) : undefined;
+var converter_default = converter;
+
+// node_modules/culori/src/modes.js
+var converters = {};
+var modes = {};
+var parsers = [];
+var colorProfiles = {};
+var identity = (v) => v;
+var useMode = (definition) => {
+  converters[definition.mode] = {
+    ...converters[definition.mode],
+    ...definition.toMode
+  };
+  Object.keys(definition.fromMode || {}).forEach((k) => {
+    if (!converters[k]) {
+      converters[k] = {};
+    }
+    converters[k][definition.mode] = definition.fromMode[k];
+  });
+  if (!definition.ranges) {
+    definition.ranges = {};
+  }
+  if (!definition.difference) {
+    definition.difference = {};
+  }
+  definition.channels.forEach((channel) => {
+    if (definition.ranges[channel] === undefined) {
+      definition.ranges[channel] = [0, 1];
+    }
+    if (!definition.interpolate[channel]) {
+      throw new Error(`Missing interpolator for: ${channel}`);
+    }
+    if (typeof definition.interpolate[channel] === "function") {
+      definition.interpolate[channel] = {
+        use: definition.interpolate[channel]
+      };
+    }
+    if (!definition.interpolate[channel].fixup) {
+      definition.interpolate[channel].fixup = identity;
+    }
+  });
+  modes[definition.mode] = definition;
+  (definition.parse || []).forEach((parser) => {
+    useParser(parser, definition.mode);
+  });
+  return converter_default(definition.mode);
+};
+var getMode = (mode) => modes[mode];
+var 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);
+    }
+  }
+};
+
+// node_modules/culori/src/parse.js
+var IdentStartCodePoint = /[^\x00-\x7F]|[a-zA-Z_]/;
+var IdentCodePoint = /[^\x00-\x7F]|[-\w]/;
+var Tok = {
+  Function: "function",
+  Ident: "ident",
+  Number: "number",
+  Percentage: "percentage",
+  ParenClose: ")",
+  None: "none",
+  Hue: "hue",
+  Alpha: "alpha"
+};
+var _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;
+}
+var huenits = {
+  deg: 1,
+  rad: 180 / Math.PI,
+  grad: 9 / 10,
+  turn: 360
+};
+function num2(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;
+  }
+  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: undefined };
+  }
+  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 === `
+` || ch === "\t" || ch === " ") {
+      while (_i < chars.length && (chars[_i] === `
+` || chars[_i] === "\t" || chars[_i] === " ")) {
+        _i++;
+      }
+      continue;
+    }
+    if (ch === ",") {
+      return;
+    }
+    if (ch === ")") {
+      tokens.push({ type: Tok.ParenClose });
+      continue;
+    }
+    if (ch === "+") {
+      _i--;
+      if (is_num(chars)) {
+        tokens.push(num2(chars));
+        continue;
+      }
+      return;
+    }
+    if (ch === "-") {
+      _i--;
+      if (is_num(chars)) {
+        tokens.push(num2(chars));
+        continue;
+      }
+      if (is_ident(chars)) {
+        tokens.push({ type: Tok.Ident, value: ident(chars) });
+        continue;
+      }
+      return;
+    }
+    if (ch === ".") {
+      _i--;
+      if (is_num(chars)) {
+        tokens.push(num2(chars));
+        continue;
+      }
+      return;
+    }
+    if (ch === "/") {
+      while (_i < chars.length && (chars[_i] === `
+` || chars[_i] === "\t" || chars[_i] === " ")) {
+        _i++;
+      }
+      let alpha;
+      if (is_num(chars)) {
+        alpha = num2(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: undefined }
+          });
+          continue;
+        }
+      }
+      return;
+    }
+    if (/\d/.test(ch)) {
+      _i--;
+      tokens.push(num2(chars));
+      continue;
+    }
+    if (IdentStartCodePoint.test(ch)) {
+      _i--;
+      tokens.push(identlike(chars));
+      continue;
+    }
+    return;
+  }
+  return tokens;
+}
+function parseColorSyntax(tokens) {
+  tokens._i = 0;
+  let token = tokens[tokens._i++];
+  if (!token || token.type !== Tok.Function || token.value !== "color") {
+    return;
+  }
+  token = tokens[tokens._i++];
+  if (token.type !== Tok.Ident) {
+    return;
+  }
+  const mode = colorProfiles[token.value];
+  if (!mode) {
+    return;
+  }
+  const res = { mode };
+  const coords = consumeCoords(tokens, false);
+  if (!coords) {
+    return;
+  }
+  const channels = getMode(mode).channels;
+  for (let ii = 0, c, ch;ii < channels.length; ii++) {
+    c = coords[ii];
+    ch = channels[ii];
+    if (c.type !== Tok.None) {
+      res[ch] = c.type === Tok.Number ? c.value : c.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;
+      }
+      continue;
+    }
+    return;
+  }
+  if (coords.length < 3 || coords.length > 4) {
+    return;
+  }
+  if (coords.length === 4) {
+    if (coords[3].type !== Tok.Alpha) {
+      return;
+    }
+    coords[3] = coords[3].value;
+  }
+  if (coords.length === 3) {
+    coords.push({ type: Tok.None, value: undefined });
+  }
+  return coords.every((c) => c.type !== Tok.Alpha) ? coords : undefined;
+}
+function parseModernSyntax(tokens, includeHue) {
+  tokens._i = 0;
+  let token = tokens[tokens._i++];
+  if (!token || token.type !== Tok.Function) {
+    return;
+  }
+  let coords = consumeCoords(tokens, includeHue);
+  if (!coords) {
+    return;
+  }
+  coords.unshift(token.value);
+  return coords;
+}
+var parse = (color) => {
+  if (typeof color !== "string") {
+    return;
+  }
+  const tokens = tokenize(color);
+  const parsed = tokens ? parseModernSyntax(tokens, true) : undefined;
+  let result = undefined;
+  let i = 0;
+  let len = parsers.length;
+  while (i < len) {
+    if ((result = parsers[i++](color, parsed)) !== undefined) {
+      return result;
+    }
+  }
+  return tokens ? parseColorSyntax(tokens) : undefined;
+};
+var parse_default = parse;
+
+// node_modules/culori/src/rgb/parseRgb.js
+function parseRgb(color, parsed) {
+  if (!parsed || parsed[0] !== "rgb" && parsed[0] !== "rgba") {
+    return;
+  }
+  const res = { mode: "rgb" };
+  const [, r, g, b, alpha] = parsed;
+  if (r.type === Tok.Hue || g.type === Tok.Hue || b.type === Tok.Hue) {
+    return;
+  }
+  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;
+}
+var parseRgb_default = parseRgb;
+
+// node_modules/culori/src/rgb/parseTransparent.js
+var parseTransparent = (c) => c === "transparent" ? { mode: "rgb", r: 0, g: 0, b: 0, alpha: 0 } : undefined;
+var parseTransparent_default = parseTransparent;
+
+// node_modules/culori/src/interpolate/lerp.js
+var lerp = (a, b, t) => a + t * (b - a);
+
+// node_modules/culori/src/interpolate/piecewise.js
+var 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 === undefined && b === undefined) {
+      classes.push(undefined);
+    } else if (a !== undefined && b !== undefined) {
+      classes.push([a, b]);
+    } else {
+      classes.push(a !== undefined ? [a, a] : [b, b]);
+    }
+  }
+  return classes;
+};
+var 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 === undefined ? undefined : interpolator(pair[0], pair[1], cls - idx);
+  };
+};
+
+// node_modules/culori/src/interpolate/linear.js
+var interpolatorLinear = interpolatorPiecewise(lerp);
+
+// node_modules/culori/src/fixup/alpha.js
+var fixupAlpha = (arr) => {
+  let some_defined = false;
+  let res = arr.map((v) => {
+    if (v !== undefined) {
+      some_defined = true;
+      return v;
+    }
+    return 1;
+  });
+  return some_defined ? res : arr;
+};
+
+// node_modules/culori/src/rgb/definition.js
+var definition = {
+  mode: "rgb",
+  channels: ["r", "g", "b", "alpha"],
+  parse: [
+    parseRgb_default,
+    parseHex_default,
+    parseRgbLegacy_default,
+    parseNamed_default,
+    parseTransparent_default,
+    "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 }
+};
+var definition_default = definition;
+
+// node_modules/culori/src/a98/convertA98ToXyz65.js
+var linearize = (v = 0) => Math.pow(Math.abs(v), 563 / 256) * Math.sign(v);
+var convertA98ToXyz65 = (a98) => {
+  let r = linearize(a98.r);
+  let g = linearize(a98.g);
+  let b = linearize(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 !== undefined) {
+    res.alpha = a98.alpha;
+  }
+  return res;
+};
+var convertA98ToXyz65_default = convertA98ToXyz65;
+
+// node_modules/culori/src/a98/convertXyz65ToA98.js
+var gamma = (v) => Math.pow(Math.abs(v), 256 / 563) * Math.sign(v);
+var convertXyz65ToA98 = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = {
+    mode: "a98",
+    r: gamma(x * 2.0415879038107465 - y * 0.5650069742788597 - 0.3447313507783297 * z),
+    g: gamma(x * -0.9692436362808798 + y * 1.8759675015077206 + 0.0415550574071756 * z),
+    b: gamma(x * 0.0134442806320312 - y * 0.1183623922310184 + 1.0151749943912058 * z)
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToA98_default = convertXyz65ToA98;
+
+// node_modules/culori/src/lrgb/convertRgbToLrgb.js
+var fn = (c = 0) => {
+  const abs = Math.abs(c);
+  if (abs <= 0.04045) {
+    return c / 12.92;
+  }
+  return (Math.sign(c) || 1) * Math.pow((abs + 0.055) / 1.055, 2.4);
+};
+var convertRgbToLrgb = ({ r, g, b, alpha }) => {
+  let res = {
+    mode: "lrgb",
+    r: fn(r),
+    g: fn(g),
+    b: fn(b)
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertRgbToLrgb_default = convertRgbToLrgb;
+
+// node_modules/culori/src/xyz65/convertRgbToXyz65.js
+var convertRgbToXyz65 = (rgb) => {
+  let { r, g, b, alpha } = convertRgbToLrgb_default(rgb);
+  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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertRgbToXyz65_default = convertRgbToXyz65;
+
+// node_modules/culori/src/lrgb/convertLrgbToRgb.js
+var fn2 = (c = 0) => {
+  const abs = Math.abs(c);
+  if (abs > 0.0031308) {
+    return (Math.sign(c) || 1) * (1.055 * Math.pow(abs, 1 / 2.4) - 0.055);
+  }
+  return c * 12.92;
+};
+var convertLrgbToRgb = ({ r, g, b, alpha }, mode = "rgb") => {
+  let res = {
+    mode,
+    r: fn2(r),
+    g: fn2(g),
+    b: fn2(b)
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertLrgbToRgb_default = convertLrgbToRgb;
+
+// node_modules/culori/src/xyz65/convertXyz65ToRgb.js
+var convertXyz65ToRgb = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = convertLrgbToRgb_default({
+    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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToRgb_default = convertXyz65ToRgb;
+
+// node_modules/culori/src/a98/definition.js
+var definition2 = {
+  ...definition_default,
+  mode: "a98",
+  parse: ["a98-rgb"],
+  serialize: "a98-rgb",
+  fromMode: {
+    rgb: (color) => convertXyz65ToA98_default(convertRgbToXyz65_default(color)),
+    xyz65: convertXyz65ToA98_default
+  },
+  toMode: {
+    rgb: (color) => convertXyz65ToRgb_default(convertA98ToXyz65_default(color)),
+    xyz65: convertA98ToXyz65_default
+  }
+};
+var definition_default2 = definition2;
+
+// node_modules/culori/src/util/normalizeHue.js
+var normalizeHue = (hue) => (hue = hue % 360) < 0 ? hue + 360 : hue;
+var normalizeHue_default = normalizeHue;
+
+// node_modules/culori/src/fixup/hue.js
+var hue2 = (hues, fn) => {
+  return hues.map((hue, idx, arr) => {
+    if (hue === undefined) {
+      return hue;
+    }
+    let normalized = normalizeHue_default(hue);
+    if (idx === 0 || hues[idx - 1] === undefined) {
+      return normalized;
+    }
+    return fn(normalized - normalizeHue_default(arr[idx - 1]));
+  }).reduce((acc, curr) => {
+    if (!acc.length || curr === undefined || acc[acc.length - 1] === undefined) {
+      acc.push(curr);
+      return acc;
+    }
+    acc.push(curr + acc[acc.length - 1]);
+    return acc;
+  }, []);
+};
+var fixupHueShorter = (arr) => hue2(arr, (d) => Math.abs(d) <= 180 ? d : d - 360 * Math.sign(d));
+
+// node_modules/culori/src/cubehelix/constants.js
+var M = [-0.14861, 1.78277, -0.29227, -0.90649, 1.97294, 0];
+var degToRad = Math.PI / 180;
+var radToDeg = 180 / Math.PI;
+
+// node_modules/culori/src/cubehelix/convertRgbToCubehelix.js
+var DE = M[3] * M[4];
+var BE = M[1] * M[4];
+var BCAD = M[1] * M[2] - M[0] * M[3];
+var convertRgbToCubehelix = ({ r, g, b, alpha }) => {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    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 ? undefined : Math.sqrt(x * x + y * y) / (M[4] * l * (1 - l))
+  };
+  if (res.s)
+    res.h = Math.atan2(y, x) * radToDeg - 120;
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertRgbToCubehelix_default = convertRgbToCubehelix;
+
+// node_modules/culori/src/cubehelix/convertCubehelixToRgb.js
+var convertCubehelixToRgb = ({ h, s, l, alpha }) => {
+  let res = { mode: "rgb" };
+  h = (h === undefined ? 0 : h + 120) * degToRad;
+  if (l === undefined)
+    l = 0;
+  let amp = s === undefined ? 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 !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertCubehelixToRgb_default = convertCubehelixToRgb;
+
+// node_modules/culori/src/difference.js
+var differenceHueSaturation = (std, smp) => {
+  if (std.h === undefined || smp.h === undefined || !std.s || !smp.s) {
+    return 0;
+  }
+  let std_h = normalizeHue_default(std.h);
+  let smp_h = normalizeHue_default(smp.h);
+  let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
+  return 2 * Math.sqrt(std.s * smp.s) * dH;
+};
+var differenceHueNaive = (std, smp) => {
+  if (std.h === undefined || smp.h === undefined) {
+    return 0;
+  }
+  let std_h = normalizeHue_default(std.h);
+  let smp_h = normalizeHue_default(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;
+};
+var differenceHueChroma = (std, smp) => {
+  if (std.h === undefined || smp.h === undefined || !std.c || !smp.c) {
+    return 0;
+  }
+  let std_h = normalizeHue_default(std.h);
+  let smp_h = normalizeHue_default(smp.h);
+  let dH = Math.sin((smp_h - std_h + 360) / 2 * Math.PI / 180);
+  return 2 * Math.sqrt(std.c * smp.c) * dH;
+};
+
+// node_modules/culori/src/average.js
+var averageAngle = (val) => {
+  let sum = val.reduce((sum, val) => {
+    if (val !== undefined) {
+      let rad = val * Math.PI / 180;
+      sum.sin += Math.sin(rad);
+      sum.cos += Math.cos(rad);
+    }
+    return sum;
+  }, { sin: 0, cos: 0 });
+  let angle = Math.atan2(sum.sin, sum.cos) * 180 / Math.PI;
+  return angle < 0 ? 360 + angle : angle;
+};
+
+// node_modules/culori/src/cubehelix/definition.js
+var definition3 = {
+  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_default
+  },
+  toMode: {
+    rgb: convertCubehelixToRgb_default
+  },
+  interpolate: {
+    h: {
+      use: interpolatorLinear,
+      fixup: fixupHueShorter
+    },
+    s: interpolatorLinear,
+    l: interpolatorLinear,
+    alpha: {
+      use: interpolatorLinear,
+      fixup: fixupAlpha
+    }
+  },
+  difference: {
+    h: differenceHueSaturation
+  },
+  average: {
+    h: averageAngle
+  }
+};
+var definition_default3 = definition3;
+
+// node_modules/culori/src/lch/convertLabToLch.js
+var convertLabToLch = ({ l, a, b, alpha }, mode = "lch") => {
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let c = Math.sqrt(a * a + b * b);
+  let res = { mode, l, c };
+  if (c)
+    res.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertLabToLch_default = convertLabToLch;
+
+// node_modules/culori/src/lch/convertLchToLab.js
+var convertLchToLab = ({ l, c, h, alpha }, mode = "lab") => {
+  if (h === undefined)
+    h = 0;
+  let res = {
+    mode,
+    l,
+    a: c ? c * Math.cos(h / 180 * Math.PI) : 0,
+    b: c ? c * Math.sin(h / 180 * Math.PI) : 0
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertLchToLab_default = convertLchToLab;
+
+// node_modules/culori/src/xyz65/constants.js
+var k = Math.pow(29, 3) / Math.pow(3, 3);
+var e = Math.pow(6, 3) / Math.pow(29, 3);
+
+// node_modules/culori/src/constants.js
+var D50 = {
+  X: 0.3457 / 0.3585,
+  Y: 1,
+  Z: (1 - 0.3457 - 0.3585) / 0.3585
+};
+var D65 = {
+  X: 0.3127 / 0.329,
+  Y: 1,
+  Z: (1 - 0.3127 - 0.329) / 0.329
+};
+var k2 = Math.pow(29, 3) / Math.pow(3, 3);
+var e2 = Math.pow(6, 3) / Math.pow(29, 3);
+
+// node_modules/culori/src/lab65/convertLab65ToXyz65.js
+var fn3 = (v) => Math.pow(v, 3) > e ? Math.pow(v, 3) : (116 * v - 16) / k;
+var convertLab65ToXyz65 = ({ l, a, b, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let fy = (l + 16) / 116;
+  let fx = a / 500 + fy;
+  let fz = fy - b / 200;
+  let res = {
+    mode: "xyz65",
+    x: fn3(fx) * D65.X,
+    y: fn3(fy) * D65.Y,
+    z: fn3(fz) * D65.Z
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLab65ToXyz65_default = convertLab65ToXyz65;
+
+// node_modules/culori/src/lab65/convertLab65ToRgb.js
+var convertLab65ToRgb = (lab) => convertXyz65ToRgb_default(convertLab65ToXyz65_default(lab));
+var convertLab65ToRgb_default = convertLab65ToRgb;
+
+// node_modules/culori/src/lab65/convertXyz65ToLab65.js
+var f = (value) => value > e ? Math.cbrt(value) : (k * value + 16) / 116;
+var convertXyz65ToLab65 = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let f0 = f(x / D65.X);
+  let f1 = f(y / D65.Y);
+  let f2 = f(z / D65.Z);
+  let res = {
+    mode: "lab65",
+    l: 116 * f1 - 16,
+    a: 500 * (f0 - f1),
+    b: 200 * (f1 - f2)
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToLab65_default = convertXyz65ToLab65;
+
+// node_modules/culori/src/lab65/convertRgbToLab65.js
+var convertRgbToLab65 = (rgb) => {
+  let res = convertXyz65ToLab65_default(convertRgbToXyz65_default(rgb));
+  if (rgb.r === rgb.b && rgb.b === rgb.g) {
+    res.a = res.b = 0;
+  }
+  return res;
+};
+var convertRgbToLab65_default = convertRgbToLab65;
+
+// node_modules/culori/src/dlch/constants.js
+var kE = 1;
+var kCH = 1;
+var θ = 26 / 180 * Math.PI;
+var cosθ = Math.cos(θ);
+var sinθ = Math.sin(θ);
+var factor = 100 / Math.log(139 / 100);
+
+// node_modules/culori/src/dlch/convertDlchToLab65.js
+var convertDlchToLab65 = ({ l, c, h, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (c === undefined)
+    c = 0;
+  if (h === undefined)
+    h = 0;
+  let res = {
+    mode: "lab65",
+    l: (Math.exp(l * kE / factor) - 1) / 0.0039
+  };
+  let G = (Math.exp(0.0435 * c * kCH * kE) - 1) / 0.075;
+  let e = G * Math.cos(h / 180 * Math.PI - θ);
+  let f = G * Math.sin(h / 180 * Math.PI - θ);
+  res.a = e * cosθ - f / 0.83 * sinθ;
+  res.b = e * sinθ + f / 0.83 * cosθ;
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertDlchToLab65_default = convertDlchToLab65;
+
+// node_modules/culori/src/dlch/convertLab65ToDlch.js
+var convertLab65ToDlch = ({ l, a, b, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let e = a * cosθ + b * sinθ;
+  let f = 0.83 * (b * cosθ - a * sinθ);
+  let G = Math.sqrt(e * e + f * f);
+  let res = {
+    mode: "dlch",
+    l: factor / kE * Math.log(1 + 0.0039 * l),
+    c: Math.log(1 + 0.075 * G) / (0.0435 * kCH * kE)
+  };
+  if (res.c) {
+    res.h = normalizeHue_default((Math.atan2(f, e) + θ) / Math.PI * 180);
+  }
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertLab65ToDlch_default = convertLab65ToDlch;
+
+// node_modules/culori/src/dlab/definition.js
+var convertDlabToLab65 = (c) => convertDlchToLab65_default(convertLabToLch_default(c, "dlch"));
+var convertLab65ToDlab = (c) => convertLchToLab_default(convertLab65ToDlch_default(c), "dlab");
+var definition4 = {
+  mode: "dlab",
+  parse: ["--din99o-lab"],
+  serialize: "--din99o-lab",
+  toMode: {
+    lab65: convertDlabToLab65,
+    rgb: (c) => convertLab65ToRgb_default(convertDlabToLab65(c))
+  },
+  fromMode: {
+    lab65: convertLab65ToDlab,
+    rgb: (c) => convertLab65ToDlab(convertRgbToLab65_default(c))
+  },
+  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
+    }
+  }
+};
+var definition_default4 = definition4;
+
+// node_modules/culori/src/dlch/definition.js
+var definition5 = {
+  mode: "dlch",
+  parse: ["--din99o-lch"],
+  serialize: "--din99o-lch",
+  toMode: {
+    lab65: convertDlchToLab65_default,
+    dlab: (c) => convertLchToLab_default(c, "dlab"),
+    rgb: (c) => convertLab65ToRgb_default(convertDlchToLab65_default(c))
+  },
+  fromMode: {
+    lab65: convertLab65ToDlch_default,
+    dlab: (c) => convertLabToLch_default(c, "dlch"),
+    rgb: (c) => convertLab65ToDlch_default(convertRgbToLab65_default(c))
+  },
+  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
+  }
+};
+var definition_default5 = definition5;
+
+// node_modules/culori/src/hsi/convertHsiToRgb.js
+function convertHsiToRgb({ h, s, i, alpha }) {
+  h = normalizeHue_default(h !== undefined ? h : 0);
+  if (s === undefined)
+    s = 0;
+  if (i === undefined)
+    i = 0;
+  let f = Math.abs(h / 60 % 2 - 1);
+  let res;
+  switch (Math.floor(h / 60)) {
+    case 0:
+      res = {
+        r: i * (1 + s * (3 / (2 - f) - 1)),
+        g: i * (1 + s * (3 * (1 - f) / (2 - f) - 1)),
+        b: i * (1 - s)
+      };
+      break;
+    case 1:
+      res = {
+        r: i * (1 + s * (3 * (1 - f) / (2 - f) - 1)),
+        g: i * (1 + s * (3 / (2 - f) - 1)),
+        b: i * (1 - s)
+      };
+      break;
+    case 2:
+      res = {
+        r: i * (1 - s),
+        g: i * (1 + s * (3 / (2 - f) - 1)),
+        b: i * (1 + s * (3 * (1 - f) / (2 - f) - 1))
+      };
+      break;
+    case 3:
+      res = {
+        r: i * (1 - s),
+        g: i * (1 + s * (3 * (1 - f) / (2 - f) - 1)),
+        b: i * (1 + s * (3 / (2 - f) - 1))
+      };
+      break;
+    case 4:
+      res = {
+        r: i * (1 + s * (3 * (1 - f) / (2 - f) - 1)),
+        g: i * (1 - s),
+        b: i * (1 + s * (3 / (2 - f) - 1))
+      };
+      break;
+    case 5:
+      res = {
+        r: i * (1 + s * (3 / (2 - f) - 1)),
+        g: i * (1 - s),
+        b: i * (1 + s * (3 * (1 - f) / (2 - f) - 1))
+      };
+      break;
+    default:
+      res = { r: i * (1 - s), g: i * (1 - s), b: i * (1 - s) };
+  }
+  res.mode = "rgb";
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/hsi/convertRgbToHsi.js
+function convertRgbToHsi({ r, g, b, alpha }) {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    b = 0;
+  let M = 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 (M - m !== 0)
+    res.h = (M === r ? (g - b) / (M - m) + (g < b) * 6 : M === g ? (b - r) / (M - m) + 2 : (r - g) / (M - m) + 4) * 60;
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/hsi/definition.js
+var definition6 = {
+  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
+  }
+};
+var definition_default6 = definition6;
+
+// node_modules/culori/src/hsl/convertHslToRgb.js
+function convertHslToRgb({ h, s, l, alpha }) {
+  h = normalizeHue_default(h !== undefined ? h : 0);
+  if (s === undefined)
+    s = 0;
+  if (l === undefined)
+    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 !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/hsl/convertRgbToHsl.js
+function convertRgbToHsl({ r, g, b, alpha }) {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    b = 0;
+  let M = Math.max(r, g, b), m = Math.min(r, g, b);
+  let res = {
+    mode: "hsl",
+    s: M === m ? 0 : (M - m) / (1 - Math.abs(M + m - 1)),
+    l: 0.5 * (M + m)
+  };
+  if (M - m !== 0)
+    res.h = (M === r ? (g - b) / (M - m) + (g < b) * 6 : M === g ? (b - r) / (M - m) + 2 : (r - g) / (M - m) + 4) * 60;
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/util/hue.js
+var 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;
+  }
+};
+var hue_default = hueToDeg;
+
+// node_modules/culori/src/hsl/parseHslLegacy.js
+var hsl_old = new RegExp(`^hsla?\\(\\s*${hue}${c}${per}${c}${per}\\s*(?:,\\s*${num_per}\\s*)?\\)$`);
+var parseHslLegacy = (color) => {
+  let match = color.match(hsl_old);
+  if (!match)
+    return;
+  let res = { mode: "hsl" };
+  if (match[3] !== undefined) {
+    res.h = +match[3];
+  } else if (match[1] !== undefined && match[2] !== undefined) {
+    res.h = hue_default(match[1], match[2]);
+  }
+  if (match[4] !== undefined) {
+    res.s = Math.min(Math.max(0, match[4] / 100), 1);
+  }
+  if (match[5] !== undefined) {
+    res.l = Math.min(Math.max(0, match[5] / 100), 1);
+  }
+  if (match[6] !== undefined) {
+    res.alpha = Math.max(0, Math.min(1, match[6] / 100));
+  } else if (match[7] !== undefined) {
+    res.alpha = Math.max(0, Math.min(1, +match[7]));
+  }
+  return res;
+};
+var parseHslLegacy_default = parseHslLegacy;
+
+// node_modules/culori/src/hsl/parseHsl.js
+function parseHsl(color, parsed) {
+  if (!parsed || parsed[0] !== "hsl" && parsed[0] !== "hsla") {
+    return;
+  }
+  const res = { mode: "hsl" };
+  const [, h, s, l, alpha] = parsed;
+  if (h.type !== Tok.None) {
+    if (h.type === Tok.Percentage) {
+      return;
+    }
+    res.h = h.value;
+  }
+  if (s.type !== Tok.None) {
+    if (s.type === Tok.Hue) {
+      return;
+    }
+    res.s = s.value / 100;
+  }
+  if (l.type !== Tok.None) {
+    if (l.type === Tok.Hue) {
+      return;
+    }
+    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;
+}
+var parseHsl_default = parseHsl;
+
+// node_modules/culori/src/hsl/definition.js
+var definition7 = {
+  mode: "hsl",
+  toMode: {
+    rgb: convertHslToRgb
+  },
+  fromMode: {
+    rgb: convertRgbToHsl
+  },
+  channels: ["h", "s", "l", "alpha"],
+  ranges: {
+    h: [0, 360]
+  },
+  gamut: "rgb",
+  parse: [parseHsl_default, parseHslLegacy_default],
+  serialize: (c) => `hsl(${c.h !== undefined ? c.h : "none"} ${c.s !== undefined ? c.s * 100 + "%" : "none"} ${c.l !== undefined ? c.l * 100 + "%" : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`,
+  interpolate: {
+    h: { use: interpolatorLinear, fixup: fixupHueShorter },
+    s: interpolatorLinear,
+    l: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  },
+  difference: {
+    h: differenceHueSaturation
+  },
+  average: {
+    h: averageAngle
+  }
+};
+var definition_default7 = definition7;
+
+// node_modules/culori/src/hsv/convertHsvToRgb.js
+function convertHsvToRgb({ h, s, v, alpha }) {
+  h = normalizeHue_default(h !== undefined ? h : 0);
+  if (s === undefined)
+    s = 0;
+  if (v === undefined)
+    v = 0;
+  let f = Math.abs(h / 60 % 2 - 1);
+  let res;
+  switch (Math.floor(h / 60)) {
+    case 0:
+      res = { r: v, g: v * (1 - s * f), b: v * (1 - s) };
+      break;
+    case 1:
+      res = { r: v * (1 - s * f), g: v, b: v * (1 - s) };
+      break;
+    case 2:
+      res = { r: v * (1 - s), g: v, b: v * (1 - s * f) };
+      break;
+    case 3:
+      res = { r: v * (1 - s), g: v * (1 - s * f), b: v };
+      break;
+    case 4:
+      res = { r: v * (1 - s * f), g: v * (1 - s), b: v };
+      break;
+    case 5:
+      res = { r: v, g: v * (1 - s), b: v * (1 - s * f) };
+      break;
+    default:
+      res = { r: v * (1 - s), g: v * (1 - s), b: v * (1 - s) };
+  }
+  res.mode = "rgb";
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/hsv/convertRgbToHsv.js
+function convertRgbToHsv({ r, g, b, alpha }) {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    b = 0;
+  let M = Math.max(r, g, b), m = Math.min(r, g, b);
+  let res = {
+    mode: "hsv",
+    s: M === 0 ? 0 : 1 - m / M,
+    v: M
+  };
+  if (M - m !== 0)
+    res.h = (M === r ? (g - b) / (M - m) + (g < b) * 6 : M === g ? (b - r) / (M - m) + 2 : (r - g) / (M - m) + 4) * 60;
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+}
+
+// node_modules/culori/src/hsv/definition.js
+var definition8 = {
+  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
+  }
+};
+var definition_default8 = definition8;
+
+// node_modules/culori/src/hwb/convertHwbToRgb.js
+function convertHwbToRgb({ h, w, b, alpha }) {
+  if (w === undefined)
+    w = 0;
+  if (b === undefined)
+    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
+  });
+}
+
+// node_modules/culori/src/hwb/convertRgbToHwb.js
+function convertRgbToHwb(rgba) {
+  let hsv = convertRgbToHsv(rgba);
+  if (hsv === undefined)
+    return;
+  let s = hsv.s !== undefined ? hsv.s : 0;
+  let v = hsv.v !== undefined ? hsv.v : 0;
+  let res = {
+    mode: "hwb",
+    w: (1 - s) * v,
+    b: 1 - v
+  };
+  if (hsv.h !== undefined)
+    res.h = hsv.h;
+  if (hsv.alpha !== undefined)
+    res.alpha = hsv.alpha;
+  return res;
+}
+
+// node_modules/culori/src/hwb/parseHwb.js
+function ParseHwb(color, parsed) {
+  if (!parsed || parsed[0] !== "hwb") {
+    return;
+  }
+  const res = { mode: "hwb" };
+  const [, h, w, b, alpha] = parsed;
+  if (h.type !== Tok.None) {
+    if (h.type === Tok.Percentage) {
+      return;
+    }
+    res.h = h.value;
+  }
+  if (w.type !== Tok.None) {
+    if (w.type === Tok.Hue) {
+      return;
+    }
+    res.w = w.value / 100;
+  }
+  if (b.type !== Tok.None) {
+    if (b.type === Tok.Hue) {
+      return;
+    }
+    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;
+}
+var parseHwb_default = ParseHwb;
+
+// node_modules/culori/src/hwb/definition.js
+var definition9 = {
+  mode: "hwb",
+  toMode: {
+    rgb: convertHwbToRgb
+  },
+  fromMode: {
+    rgb: convertRgbToHwb
+  },
+  channels: ["h", "w", "b", "alpha"],
+  ranges: {
+    h: [0, 360]
+  },
+  gamut: "rgb",
+  parse: [parseHwb_default],
+  serialize: (c) => `hwb(${c.h !== undefined ? c.h : "none"} ${c.w !== undefined ? c.w * 100 + "%" : "none"} ${c.b !== undefined ? c.b * 100 + "%" : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`,
+  interpolate: {
+    h: { use: interpolatorLinear, fixup: fixupHueShorter },
+    w: interpolatorLinear,
+    b: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  },
+  difference: {
+    h: differenceHueNaive
+  },
+  average: {
+    h: averageAngle
+  }
+};
+var definition_default9 = definition9;
+
+// node_modules/culori/src/hdr/constants.js
+var YW = 203;
+
+// node_modules/culori/src/hdr/transfer.js
+var M1 = 0.1593017578125;
+var M2 = 78.84375;
+var C1 = 0.8359375;
+var C2 = 18.8515625;
+var C3 = 18.6875;
+function transferPqDecode(v) {
+  if (v < 0)
+    return 0;
+  const c = Math.pow(v, 1 / M2);
+  return 1e4 * Math.pow(Math.max(0, c - C1) / (C2 - C3 * c), 1 / M1);
+}
+function transferPqEncode(v) {
+  if (v < 0)
+    return 0;
+  const c = Math.pow(v / 1e4, M1);
+  return Math.pow((C1 + C2 * c) / (1 + C3 * c), M2);
+}
+
+// node_modules/culori/src/itp/convertItpToXyz65.js
+var toRel = (c) => Math.max(c / YW, 0);
+var convertItpToXyz65 = ({ i, t, p, alpha }) => {
+  if (i === undefined)
+    i = 0;
+  if (t === undefined)
+    t = 0;
+  if (p === undefined)
+    p = 0;
+  const l = transferPqDecode(i + 0.008609037037932761 * t + 0.11102962500302593 * p);
+  const m = transferPqDecode(i - 0.00860903703793275 * t - 0.11102962500302599 * p);
+  const s = transferPqDecode(i + 0.5600313357106791 * t - 0.32062717498731885 * p);
+  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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertItpToXyz65_default = convertItpToXyz65;
+
+// node_modules/culori/src/itp/convertXyz65ToItp.js
+var toAbs = (c = 0) => Math.max(c * YW, 0);
+var 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 p = 4.378173828125 * l - 4.24560546875 * m - 0.132568359375 * s;
+  const res = { mode: "itp", i, t, p };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToItp_default = convertXyz65ToItp;
+
+// node_modules/culori/src/itp/definition.js
+var definition10 = {
+  mode: "itp",
+  channels: ["i", "t", "p", "alpha"],
+  parse: ["--ictcp"],
+  serialize: "--ictcp",
+  toMode: {
+    xyz65: convertItpToXyz65_default,
+    rgb: (color) => convertXyz65ToRgb_default(convertItpToXyz65_default(color))
+  },
+  fromMode: {
+    xyz65: convertXyz65ToItp_default,
+    rgb: (color) => convertXyz65ToItp_default(convertRgbToXyz65_default(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 }
+  }
+};
+var definition_default10 = definition10;
+
+// node_modules/culori/src/jab/convertXyz65ToJab.js
+var p = 134.03437499999998;
+var d0 = 0.000000000016295499532821565;
+var jabPqEncode = (v) => {
+  if (v < 0)
+    return 0;
+  let vn = Math.pow(v / 1e4, M1);
+  return Math.pow((C1 + C2 * vn) / (1 + C3 * vn), p);
+};
+var abs = (v = 0) => Math.max(v * 203, 0);
+var 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,
+    a: 3.524 * l - 4.066708 * m + 0.542708 * s,
+    b: 0.199076 * l + 1.096799 * m - 1.295875 * s
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToJab_default = convertXyz65ToJab;
+
+// node_modules/culori/src/jab/convertJabToXyz65.js
+var p2 = 134.03437499999998;
+var d02 = 0.000000000016295499532821565;
+var jabPqDecode = (v) => {
+  if (v < 0)
+    return 0;
+  let vp = Math.pow(v, 1 / p2);
+  return 1e4 * Math.pow((C1 - vp) / (C3 * vp - C2), 1 / M1);
+};
+var rel = (v) => v / 203;
+var convertJabToXyz65 = ({ j, a, b, alpha }) => {
+  if (j === undefined)
+    j = 0;
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let i = (j + d02) / (0.44 + 0.56 * (j + d02));
+  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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertJabToXyz65_default = convertJabToXyz65;
+
+// node_modules/culori/src/jab/convertRgbToJab.js
+var convertRgbToJab = (rgb) => {
+  let res = convertXyz65ToJab_default(convertRgbToXyz65_default(rgb));
+  if (rgb.r === rgb.b && rgb.b === rgb.g) {
+    res.a = res.b = 0;
+  }
+  return res;
+};
+var convertRgbToJab_default = convertRgbToJab;
+
+// node_modules/culori/src/jab/convertJabToRgb.js
+var convertJabToRgb = (color) => convertXyz65ToRgb_default(convertJabToXyz65_default(color));
+var convertJabToRgb_default = convertJabToRgb;
+
+// node_modules/culori/src/jab/definition.js
+var definition11 = {
+  mode: "jab",
+  channels: ["j", "a", "b", "alpha"],
+  parse: ["--jzazbz"],
+  serialize: "--jzazbz",
+  fromMode: {
+    rgb: convertRgbToJab_default,
+    xyz65: convertXyz65ToJab_default
+  },
+  toMode: {
+    rgb: convertJabToRgb_default,
+    xyz65: convertJabToXyz65_default
+  },
+  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 }
+  }
+};
+var definition_default11 = definition11;
+
+// node_modules/culori/src/jch/convertJabToJch.js
+var convertJabToJch = ({ j, a, b, alpha }) => {
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let c = Math.sqrt(a * a + b * b);
+  let res = {
+    mode: "jch",
+    j,
+    c
+  };
+  if (c) {
+    res.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
+  }
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertJabToJch_default = convertJabToJch;
+
+// node_modules/culori/src/jch/convertJchToJab.js
+var convertJchToJab = ({ j, c, h, alpha }) => {
+  if (h === undefined)
+    h = 0;
+  let res = {
+    mode: "jab",
+    j,
+    a: c ? c * Math.cos(h / 180 * Math.PI) : 0,
+    b: c ? c * Math.sin(h / 180 * Math.PI) : 0
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertJchToJab_default = convertJchToJab;
+
+// node_modules/culori/src/jch/definition.js
+var definition12 = {
+  mode: "jch",
+  parse: ["--jzczhz"],
+  serialize: "--jzczhz",
+  toMode: {
+    jab: convertJchToJab_default,
+    rgb: (c) => convertJabToRgb_default(convertJchToJab_default(c))
+  },
+  fromMode: {
+    rgb: (c) => convertJabToJch_default(convertRgbToJab_default(c)),
+    jab: convertJabToJch_default
+  },
+  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
+  }
+};
+var definition_default12 = definition12;
+
+// node_modules/culori/src/xyz50/constants.js
+var k3 = Math.pow(29, 3) / Math.pow(3, 3);
+var e3 = Math.pow(6, 3) / Math.pow(29, 3);
+
+// node_modules/culori/src/lab/convertLabToXyz50.js
+var fn4 = (v) => Math.pow(v, 3) > e3 ? Math.pow(v, 3) : (116 * v - 16) / k3;
+var convertLabToXyz50 = ({ l, a, b, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let fy = (l + 16) / 116;
+  let fx = a / 500 + fy;
+  let fz = fy - b / 200;
+  let res = {
+    mode: "xyz50",
+    x: fn4(fx) * D50.X,
+    y: fn4(fy) * D50.Y,
+    z: fn4(fz) * D50.Z
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLabToXyz50_default = convertLabToXyz50;
+
+// node_modules/culori/src/xyz50/convertXyz50ToRgb.js
+var convertXyz50ToRgb = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = convertLrgbToRgb_default({
+    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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToRgb_default = convertXyz50ToRgb;
+
+// node_modules/culori/src/lab/convertLabToRgb.js
+var convertLabToRgb = (lab) => convertXyz50ToRgb_default(convertLabToXyz50_default(lab));
+var convertLabToRgb_default = convertLabToRgb;
+
+// node_modules/culori/src/xyz50/convertRgbToXyz50.js
+var convertRgbToXyz50 = (rgb) => {
+  let { r, g, b, alpha } = convertRgbToLrgb_default(rgb);
+  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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertRgbToXyz50_default = convertRgbToXyz50;
+
+// node_modules/culori/src/lab/convertXyz50ToLab.js
+var f2 = (value) => value > e3 ? Math.cbrt(value) : (k3 * value + 16) / 116;
+var convertXyz50ToLab = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let f0 = f2(x / D50.X);
+  let f1 = f2(y / D50.Y);
+  let f22 = f2(z / D50.Z);
+  let res = {
+    mode: "lab",
+    l: 116 * f1 - 16,
+    a: 500 * (f0 - f1),
+    b: 200 * (f1 - f22)
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToLab_default = convertXyz50ToLab;
+
+// node_modules/culori/src/lab/convertRgbToLab.js
+var convertRgbToLab = (rgb) => {
+  let res = convertXyz50ToLab_default(convertRgbToXyz50_default(rgb));
+  if (rgb.r === rgb.b && rgb.b === rgb.g) {
+    res.a = res.b = 0;
+  }
+  return res;
+};
+var convertRgbToLab_default = convertRgbToLab;
+
+// node_modules/culori/src/lab/parseLab.js
+function parseLab(color, parsed) {
+  if (!parsed || parsed[0] !== "lab") {
+    return;
+  }
+  const res = { mode: "lab" };
+  const [, l, a, b, alpha] = parsed;
+  if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
+    return;
+  }
+  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;
+}
+var parseLab_default = parseLab;
+
+// node_modules/culori/src/lab/definition.js
+var definition13 = {
+  mode: "lab",
+  toMode: {
+    xyz50: convertLabToXyz50_default,
+    rgb: convertLabToRgb_default
+  },
+  fromMode: {
+    xyz50: convertXyz50ToLab_default,
+    rgb: convertRgbToLab_default
+  },
+  channels: ["l", "a", "b", "alpha"],
+  ranges: {
+    l: [0, 100],
+    a: [-125, 125],
+    b: [-125, 125]
+  },
+  parse: [parseLab_default],
+  serialize: (c) => `lab(${c.l !== undefined ? c.l : "none"} ${c.a !== undefined ? c.a : "none"} ${c.b !== undefined ? c.b : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`,
+  interpolate: {
+    l: interpolatorLinear,
+    a: interpolatorLinear,
+    b: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  }
+};
+var definition_default13 = definition13;
+
+// node_modules/culori/src/lab65/definition.js
+var definition14 = {
+  ...definition_default13,
+  mode: "lab65",
+  parse: ["--lab-d65"],
+  serialize: "--lab-d65",
+  toMode: {
+    xyz65: convertLab65ToXyz65_default,
+    rgb: convertLab65ToRgb_default
+  },
+  fromMode: {
+    xyz65: convertXyz65ToLab65_default,
+    rgb: convertRgbToLab65_default
+  },
+  ranges: {
+    l: [0, 100],
+    a: [-125, 125],
+    b: [-125, 125]
+  }
+};
+var definition_default14 = definition14;
+
+// node_modules/culori/src/lch/parseLch.js
+function parseLch(color, parsed) {
+  if (!parsed || parsed[0] !== "lch") {
+    return;
+  }
+  const res = { mode: "lch" };
+  const [, l, c, h, alpha] = parsed;
+  if (l.type !== Tok.None) {
+    if (l.type === Tok.Hue) {
+      return;
+    }
+    res.l = Math.min(Math.max(0, l.value), 100);
+  }
+  if (c.type !== Tok.None) {
+    res.c = Math.max(0, c.type === Tok.Number ? c.value : c.value * 150 / 100);
+  }
+  if (h.type !== Tok.None) {
+    if (h.type === Tok.Percentage) {
+      return;
+    }
+    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;
+}
+var parseLch_default = parseLch;
+
+// node_modules/culori/src/lch/definition.js
+var definition15 = {
+  mode: "lch",
+  toMode: {
+    lab: convertLchToLab_default,
+    rgb: (c) => convertLabToRgb_default(convertLchToLab_default(c))
+  },
+  fromMode: {
+    rgb: (c) => convertLabToLch_default(convertRgbToLab_default(c)),
+    lab: convertLabToLch_default
+  },
+  channels: ["l", "c", "h", "alpha"],
+  ranges: {
+    l: [0, 100],
+    c: [0, 150],
+    h: [0, 360]
+  },
+  parse: [parseLch_default],
+  serialize: (c) => `lch(${c.l !== undefined ? c.l : "none"} ${c.c !== undefined ? c.c : "none"} ${c.h !== undefined ? c.h : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`,
+  interpolate: {
+    h: { use: interpolatorLinear, fixup: fixupHueShorter },
+    c: interpolatorLinear,
+    l: interpolatorLinear,
+    alpha: { use: interpolatorLinear, fixup: fixupAlpha }
+  },
+  difference: {
+    h: differenceHueChroma
+  },
+  average: {
+    h: averageAngle
+  }
+};
+var definition_default15 = definition15;
+
+// node_modules/culori/src/lch65/definition.js
+var definition16 = {
+  ...definition_default15,
+  mode: "lch65",
+  parse: ["--lch-d65"],
+  serialize: "--lch-d65",
+  toMode: {
+    lab65: (c) => convertLchToLab_default(c, "lab65"),
+    rgb: (c) => convertLab65ToRgb_default(convertLchToLab_default(c, "lab65"))
+  },
+  fromMode: {
+    rgb: (c) => convertLabToLch_default(convertRgbToLab65_default(c), "lch65"),
+    lab65: (c) => convertLabToLch_default(c, "lch65")
+  },
+  ranges: {
+    l: [0, 100],
+    c: [0, 150],
+    h: [0, 360]
+  }
+};
+var definition_default16 = definition16;
+
+// node_modules/culori/src/lchuv/convertLuvToLchuv.js
+var convertLuvToLchuv = ({ l, u, v, alpha }) => {
+  if (u === undefined)
+    u = 0;
+  if (v === undefined)
+    v = 0;
+  let c = Math.sqrt(u * u + v * v);
+  let res = {
+    mode: "lchuv",
+    l,
+    c
+  };
+  if (c) {
+    res.h = normalizeHue_default(Math.atan2(v, u) * 180 / Math.PI);
+  }
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLuvToLchuv_default = convertLuvToLchuv;
+
+// node_modules/culori/src/lchuv/convertLchuvToLuv.js
+var convertLchuvToLuv = ({ l, c, h, alpha }) => {
+  if (h === undefined)
+    h = 0;
+  let res = {
+    mode: "luv",
+    l,
+    u: c ? c * Math.cos(h / 180 * Math.PI) : 0,
+    v: c ? c * Math.sin(h / 180 * Math.PI) : 0
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLchuvToLuv_default = convertLchuvToLuv;
+
+// node_modules/culori/src/luv/convertXyz50ToLuv.js
+var u_fn = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
+var v_fn = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
+var un = u_fn(D50.X, D50.Y, D50.Z);
+var vn = v_fn(D50.X, D50.Y, D50.Z);
+var l_fn = (value) => value <= e3 ? k3 * value : 116 * Math.cbrt(value) - 16;
+var convertXyz50ToLuv = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let l = l_fn(y / D50.Y);
+  let u = u_fn(x, y, z);
+  let v = v_fn(x, y, z);
+  if (!isFinite(u) || !isFinite(v)) {
+    l = u = v = 0;
+  } else {
+    u = 13 * l * (u - un);
+    v = 13 * l * (v - vn);
+  }
+  let res = {
+    mode: "luv",
+    l,
+    u,
+    v
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToLuv_default = convertXyz50ToLuv;
+
+// node_modules/culori/src/luv/convertLuvToXyz50.js
+var u_fn2 = (x, y, z) => 4 * x / (x + 15 * y + 3 * z);
+var v_fn2 = (x, y, z) => 9 * y / (x + 15 * y + 3 * z);
+var un2 = u_fn2(D50.X, D50.Y, D50.Z);
+var vn2 = v_fn2(D50.X, D50.Y, D50.Z);
+var convertLuvToXyz50 = ({ l, u, v, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (l === 0) {
+    return { mode: "xyz50", x: 0, y: 0, z: 0 };
+  }
+  if (u === undefined)
+    u = 0;
+  if (v === undefined)
+    v = 0;
+  let up = u / (13 * l) + un2;
+  let vp = v / (13 * l) + vn2;
+  let y = D50.Y * (l <= 8 ? l / k3 : 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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLuvToXyz50_default = convertLuvToXyz50;
+
+// node_modules/culori/src/lchuv/definition.js
+var convertRgbToLchuv = (rgb) => convertLuvToLchuv_default(convertXyz50ToLuv_default(convertRgbToXyz50_default(rgb)));
+var convertLchuvToRgb = (lchuv) => convertXyz50ToRgb_default(convertLuvToXyz50_default(convertLchuvToLuv_default(lchuv)));
+var definition17 = {
+  mode: "lchuv",
+  toMode: {
+    luv: convertLchuvToLuv_default,
+    rgb: convertLchuvToRgb
+  },
+  fromMode: {
+    rgb: convertRgbToLchuv,
+    luv: convertLuvToLchuv_default
+  },
+  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
+  }
+};
+var definition_default17 = definition17;
+
+// node_modules/culori/src/lrgb/definition.js
+var definition18 = {
+  ...definition_default,
+  mode: "lrgb",
+  toMode: {
+    rgb: convertLrgbToRgb_default
+  },
+  fromMode: {
+    rgb: convertRgbToLrgb_default
+  },
+  parse: ["srgb-linear"],
+  serialize: "srgb-linear"
+};
+var definition_default18 = definition18;
+
+// node_modules/culori/src/luv/definition.js
+var definition19 = {
+  mode: "luv",
+  toMode: {
+    xyz50: convertLuvToXyz50_default,
+    rgb: (luv) => convertXyz50ToRgb_default(convertLuvToXyz50_default(luv))
+  },
+  fromMode: {
+    xyz50: convertXyz50ToLuv_default,
+    rgb: (rgb) => convertXyz50ToLuv_default(convertRgbToXyz50_default(rgb))
+  },
+  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 }
+  }
+};
+var definition_default19 = definition19;
+
+// node_modules/culori/src/oklab/convertLrgbToOklab.js
+var convertLrgbToOklab = ({ r, g, b, alpha }) => {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    b = 0;
+  let L = Math.cbrt(0.412221469470763 * r + 0.5363325372617348 * g + 0.0514459932675022 * b);
+  let M = 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 * M - 0.0040720430116193 * S,
+    a: 1.9779985324311684 * L - 2.42859224204858 * M + 0.450593709617411 * S,
+    b: 0.0259040424655478 * L + 0.7827717124575296 * M - 0.8086757549230774 * S
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertLrgbToOklab_default = convertLrgbToOklab;
+
+// node_modules/culori/src/oklab/convertRgbToOklab.js
+var convertRgbToOklab = (rgb) => {
+  let res = convertLrgbToOklab_default(convertRgbToLrgb_default(rgb));
+  if (rgb.r === rgb.b && rgb.b === rgb.g) {
+    res.a = res.b = 0;
+  }
+  return res;
+};
+var convertRgbToOklab_default = convertRgbToOklab;
+
+// node_modules/culori/src/oklab/convertOklabToLrgb.js
+var convertOklabToLrgb = ({ l, a, b, alpha }) => {
+  if (l === undefined)
+    l = 0;
+  if (a === undefined)
+    a = 0;
+  if (b === undefined)
+    b = 0;
+  let L = Math.pow(l + 0.3963377773761749 * a + 0.2158037573099136 * b, 3);
+  let M = 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 * M + 0.2309699031821044 * S,
+    g: -1.2684379732850317 * L + 2.6097573492876887 * M - 0.3413193760026573 * S,
+    b: -0.0041960761386756 * L - 0.7034186179359362 * M + 1.7076146940746117 * S
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertOklabToLrgb_default = convertOklabToLrgb;
+
+// node_modules/culori/src/oklab/convertOklabToRgb.js
+var convertOklabToRgb = (c) => convertLrgbToRgb_default(convertOklabToLrgb_default(c));
+var convertOklabToRgb_default = convertOklabToRgb;
+
+// node_modules/culori/src/okhsl/helpers.js
+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 = -0.00915799;
+    k2 = -1.1513021;
+    k3 = -0.50559606;
+    k4 = 0.00692167;
+    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 f = wl * l + wm * m + ws * s;
+    let f1 = wl * l_dS + wm * m_dS + ws * s_dS;
+    let f2 = wl * l_dS2 + wm * m_dS2 + ws * s_dS2;
+    S = S - f * f1 / (f1 * f1 - 0.5 * f * f2);
+  }
+  return S;
+}
+function find_cusp(a, b) {
+  let S_cusp = compute_max_saturation(a, b);
+  let rgb = convertOklabToLrgb_default({ l: 1, a: S_cusp * a, b: S_cusp * b });
+  let L_cusp = Math.cbrt(1 / Math.max(rgb.r, rgb.g, rgb.b));
+  let C_cusp = L_cusp * S_cusp;
+  return [L_cusp, C_cusp];
+}
+function find_gamut_intersection(a, b, L1, C1, L0, cusp = null) {
+  if (!cusp) {
+    cusp = find_cusp(a, b);
+  }
+  let t;
+  if ((L1 - L0) * cusp[1] - (cusp[0] - L0) * C1 <= 0) {
+    t = cusp[1] * L0 / (C1 * cusp[0] + cusp[1] * (L0 - L1));
+  } else {
+    t = cusp[1] * (L0 - 1) / (C1 * (cusp[0] - 1) + cusp[1] * (L0 - L1));
+    {
+      let dL = L1 - L0;
+      let dC = C1;
+      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 * C1;
+        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 b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s - 1;
+        let b1 = -0.0041960863 * ldt - 0.7034186147 * mdt + 1.707614701 * sdt;
+        let b2 = -0.0041960863 * ldt2 - 0.7034186147 * mdt2 + 1.707614701 * sdt2;
+        let u_b = b1 / (b1 * b1 - 0.5 * b * b2);
+        let t_b = -b * 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_ * (0.00299215 - 0.45399568 * b_ - 0.14661872 * a_))));
+  let k = 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 * k * 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];
+}
+
+// node_modules/culori/src/okhsl/convertOklabToOkhsl.js
+function convertOklabToOkhsl(lab) {
+  const l = lab.l !== undefined ? lab.l : 0;
+  const a = lab.a !== undefined ? lab.a : 0;
+  const b = lab.b !== undefined ? lab.b : 0;
+  const ret = { mode: "okhsl", l: toe(l) };
+  if (lab.alpha !== undefined) {
+    ret.alpha = lab.alpha;
+  }
+  let c = Math.sqrt(a * a + b * b);
+  if (!c) {
+    ret.s = 0;
+    return ret;
+  }
+  let [C_0, C_mid, C_max] = get_Cs(l, a / c, b / c);
+  let s;
+  if (c < C_mid) {
+    let k_0 = 0;
+    let k_1 = 0.8 * C_0;
+    let k_2 = 1 - k_1 / C_mid;
+    let t = (c - k_0) / (k_1 + k_2 * (c - 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 = (c - k_0) / (k_1 + k_2 * (c - k_0));
+    s = 0.8 + 0.2 * t;
+  }
+  if (s) {
+    ret.s = s;
+    ret.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
+  }
+  return ret;
+}
+
+// node_modules/culori/src/okhsl/convertOkhslToOklab.js
+function convertOkhslToOklab(hsl) {
+  let h = hsl.h !== undefined ? hsl.h : 0;
+  let s = hsl.s !== undefined ? hsl.s : 0;
+  let l = hsl.l !== undefined ? hsl.l : 0;
+  const ret = { mode: "oklab", l: toe_inv(l) };
+  if (hsl.alpha !== undefined) {
+    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;
+}
+
+// node_modules/culori/src/okhsl/modeOkhsl.js
+var modeOkhsl = {
+  ...definition_default7,
+  mode: "okhsl",
+  channels: ["h", "s", "l", "alpha"],
+  parse: ["--okhsl"],
+  serialize: "--okhsl",
+  fromMode: {
+    oklab: convertOklabToOkhsl,
+    rgb: (c) => convertOklabToOkhsl(convertRgbToOklab_default(c))
+  },
+  toMode: {
+    oklab: convertOkhslToOklab,
+    rgb: (c) => convertOklabToRgb_default(convertOkhslToOklab(c))
+  }
+};
+var modeOkhsl_default = modeOkhsl;
+
+// node_modules/culori/src/okhsv/convertOklabToOkhsv.js
+function convertOklabToOkhsv(lab) {
+  let l = lab.l !== undefined ? lab.l : 0;
+  let a = lab.a !== undefined ? lab.a : 0;
+  let b = lab.b !== undefined ? lab.b : 0;
+  let c = Math.sqrt(a * a + b * b);
+  let a_ = c ? a / c : 1;
+  let b_ = c ? b / c : 1;
+  let [S_max, T] = get_ST_max(a_, b_);
+  let S_0 = 0.5;
+  let k = 1 - S_0 / S_max;
+  let t = T / (c + l * T);
+  let L_v = t * l;
+  let C_v = t * c;
+  let L_vt = toe_inv(L_v);
+  let C_vt = C_v * L_vt / L_v;
+  let rgb_scale = convertOklabToLrgb_default({ 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;
+  c = c / scale_L * toe(l) / l;
+  l = toe(l);
+  const ret = {
+    mode: "okhsv",
+    s: c ? (S_0 + T) * C_v / (T * S_0 + T * k * C_v) : 0,
+    v: l ? l / L_v : 0
+  };
+  if (ret.s) {
+    ret.h = normalizeHue_default(Math.atan2(b, a) * 180 / Math.PI);
+  }
+  if (lab.alpha !== undefined) {
+    ret.alpha = lab.alpha;
+  }
+  return ret;
+}
+
+// node_modules/culori/src/okhsv/convertOkhsvToOklab.js
+function convertOkhsvToOklab(hsv) {
+  const ret = { mode: "oklab" };
+  if (hsv.alpha !== undefined) {
+    ret.alpha = hsv.alpha;
+  }
+  const h = hsv.h !== undefined ? hsv.h : 0;
+  const s = hsv.s !== undefined ? hsv.s : 0;
+  const v = hsv.v !== undefined ? 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 k = 1 - S_0 / S_max;
+  const L_v = 1 - s * S_0 / (S_0 + T - T * k * s);
+  const C_v = s * T * S_0 / (S_0 + T - T * k * s);
+  const L_vt = toe_inv(L_v);
+  const C_vt = C_v * L_vt / L_v;
+  const rgb_scale = convertOklabToLrgb_default({
+    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;
+}
+
+// node_modules/culori/src/okhsv/modeOkhsv.js
+var modeOkhsv = {
+  ...definition_default8,
+  mode: "okhsv",
+  channels: ["h", "s", "v", "alpha"],
+  parse: ["--okhsv"],
+  serialize: "--okhsv",
+  fromMode: {
+    oklab: convertOklabToOkhsv,
+    rgb: (c) => convertOklabToOkhsv(convertRgbToOklab_default(c))
+  },
+  toMode: {
+    oklab: convertOkhsvToOklab,
+    rgb: (c) => convertOklabToRgb_default(convertOkhsvToOklab(c))
+  }
+};
+var modeOkhsv_default = modeOkhsv;
+
+// node_modules/culori/src/oklab/parseOklab.js
+function parseOklab(color, parsed) {
+  if (!parsed || parsed[0] !== "oklab") {
+    return;
+  }
+  const res = { mode: "oklab" };
+  const [, l, a, b, alpha] = parsed;
+  if (l.type === Tok.Hue || a.type === Tok.Hue || b.type === Tok.Hue) {
+    return;
+  }
+  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;
+}
+var parseOklab_default = parseOklab;
+
+// node_modules/culori/src/oklab/definition.js
+var definition20 = {
+  ...definition_default13,
+  mode: "oklab",
+  toMode: {
+    lrgb: convertOklabToLrgb_default,
+    rgb: convertOklabToRgb_default
+  },
+  fromMode: {
+    lrgb: convertLrgbToOklab_default,
+    rgb: convertRgbToOklab_default
+  },
+  ranges: {
+    l: [0, 1],
+    a: [-0.4, 0.4],
+    b: [-0.4, 0.4]
+  },
+  parse: [parseOklab_default],
+  serialize: (c) => `oklab(${c.l !== undefined ? c.l : "none"} ${c.a !== undefined ? c.a : "none"} ${c.b !== undefined ? c.b : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`
+};
+var definition_default20 = definition20;
+
+// node_modules/culori/src/oklch/parseOklch.js
+function parseOklch(color, parsed) {
+  if (!parsed || parsed[0] !== "oklch") {
+    return;
+  }
+  const res = { mode: "oklch" };
+  const [, l, c, h, alpha] = parsed;
+  if (l.type !== Tok.None) {
+    if (l.type === Tok.Hue) {
+      return;
+    }
+    res.l = Math.min(Math.max(0, l.type === Tok.Number ? l.value : l.value / 100), 1);
+  }
+  if (c.type !== Tok.None) {
+    res.c = Math.max(0, c.type === Tok.Number ? c.value : c.value * 0.4 / 100);
+  }
+  if (h.type !== Tok.None) {
+    if (h.type === Tok.Percentage) {
+      return;
+    }
+    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;
+}
+var parseOklch_default = parseOklch;
+
+// node_modules/culori/src/oklch/definition.js
+var definition21 = {
+  ...definition_default15,
+  mode: "oklch",
+  toMode: {
+    oklab: (c) => convertLchToLab_default(c, "oklab"),
+    rgb: (c) => convertOklabToRgb_default(convertLchToLab_default(c, "oklab"))
+  },
+  fromMode: {
+    rgb: (c) => convertLabToLch_default(convertRgbToOklab_default(c), "oklch"),
+    oklab: (c) => convertLabToLch_default(c, "oklch")
+  },
+  parse: [parseOklch_default],
+  serialize: (c) => `oklch(${c.l !== undefined ? c.l : "none"} ${c.c !== undefined ? c.c : "none"} ${c.h !== undefined ? c.h : "none"}${c.alpha < 1 ? ` / ${c.alpha}` : ""})`,
+  ranges: {
+    l: [0, 1],
+    c: [0, 0.4],
+    h: [0, 360]
+  }
+};
+var definition_default21 = definition21;
+
+// node_modules/culori/src/p3/convertP3ToXyz65.js
+var convertP3ToXyz65 = (rgb) => {
+  let { r, g, b, alpha } = convertRgbToLrgb_default(rgb);
+  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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertP3ToXyz65_default = convertP3ToXyz65;
+
+// node_modules/culori/src/p3/convertXyz65ToP3.js
+var convertXyz65ToP3 = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = convertLrgbToRgb_default({
+    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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToP3_default = convertXyz65ToP3;
+
+// node_modules/culori/src/p3/definition.js
+var definition22 = {
+  ...definition_default,
+  mode: "p3",
+  parse: ["display-p3"],
+  serialize: "display-p3",
+  fromMode: {
+    rgb: (color) => convertXyz65ToP3_default(convertRgbToXyz65_default(color)),
+    xyz65: convertXyz65ToP3_default
+  },
+  toMode: {
+    rgb: (color) => convertXyz65ToRgb_default(convertP3ToXyz65_default(color)),
+    xyz65: convertP3ToXyz65_default
+  }
+};
+var definition_default22 = definition22;
+
+// node_modules/culori/src/prophoto/convertXyz50ToProphoto.js
+var gamma2 = (v) => {
+  let abs = Math.abs(v);
+  if (abs >= 1 / 512) {
+    return Math.sign(v) * Math.pow(abs, 1 / 1.8);
+  }
+  return 16 * v;
+};
+var convertXyz50ToProphoto = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = {
+    mode: "prophoto",
+    r: gamma2(x * 1.3457868816471585 - y * 0.2555720873797946 - 0.0511018649755453 * z),
+    g: gamma2(x * -0.5446307051249019 + y * 1.5082477428451466 + 0.0205274474364214 * z),
+    b: gamma2(x * 0 + y * 0 + 1.2119675456389452 * z)
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToProphoto_default = convertXyz50ToProphoto;
+
+// node_modules/culori/src/prophoto/convertProphotoToXyz50.js
+var linearize2 = (v = 0) => {
+  let abs = Math.abs(v);
+  if (abs >= 16 / 512) {
+    return Math.sign(v) * Math.pow(abs, 1.8);
+  }
+  return v / 16;
+};
+var convertProphotoToXyz50 = (prophoto) => {
+  let r = linearize2(prophoto.r);
+  let g = linearize2(prophoto.g);
+  let b = linearize2(prophoto.b);
+  let res = {
+    mode: "xyz50",
+    x: 0.7977666449006423 * r + 0.1351812974005331 * g + 0.0313477341283922 * b,
+    y: 0.2880748288194013 * r + 0.7118352342418731 * g + 0.0000899369387256 * b,
+    z: 0 * r + 0 * g + 0.8251046025104602 * b
+  };
+  if (prophoto.alpha !== undefined) {
+    res.alpha = prophoto.alpha;
+  }
+  return res;
+};
+var convertProphotoToXyz50_default = convertProphotoToXyz50;
+
+// node_modules/culori/src/prophoto/definition.js
+var definition23 = {
+  ...definition_default,
+  mode: "prophoto",
+  parse: ["prophoto-rgb"],
+  serialize: "prophoto-rgb",
+  fromMode: {
+    xyz50: convertXyz50ToProphoto_default,
+    rgb: (color) => convertXyz50ToProphoto_default(convertRgbToXyz50_default(color))
+  },
+  toMode: {
+    xyz50: convertProphotoToXyz50_default,
+    rgb: (color) => convertXyz50ToRgb_default(convertProphotoToXyz50_default(color))
+  }
+};
+var definition_default23 = definition23;
+
+// node_modules/culori/src/rec2020/convertXyz65ToRec2020.js
+var α = 1.09929682680944;
+var β = 0.018053968510807;
+var gamma3 = (v) => {
+  const abs = Math.abs(v);
+  if (abs > β) {
+    return (Math.sign(v) || 1) * (α * Math.pow(abs, 0.45) - (α - 1));
+  }
+  return 4.5 * v;
+};
+var convertXyz65ToRec2020 = ({ x, y, z, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    z = 0;
+  let res = {
+    mode: "rec2020",
+    r: gamma3(x * 1.7166511879712683 - y * 0.3556707837763925 - 0.2533662813736599 * z),
+    g: gamma3(x * -0.6666843518324893 + y * 1.6164812366349395 + 0.0157685458139111 * z),
+    b: gamma3(x * 0.0176398574453108 - y * 0.0427706132578085 + 0.9421031212354739 * z)
+  };
+  if (alpha !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToRec2020_default = convertXyz65ToRec2020;
+
+// node_modules/culori/src/rec2020/convertRec2020ToXyz65.js
+var α2 = 1.09929682680944;
+var β2 = 0.018053968510807;
+var linearize3 = (v = 0) => {
+  let abs = Math.abs(v);
+  if (abs < β2 * 4.5) {
+    return v / 4.5;
+  }
+  return (Math.sign(v) || 1) * Math.pow((abs + α2 - 1) / α2, 1 / 0.45);
+};
+var convertRec2020ToXyz65 = (rec2020) => {
+  let r = linearize3(rec2020.r);
+  let g = linearize3(rec2020.g);
+  let b = linearize3(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 !== undefined) {
+    res.alpha = rec2020.alpha;
+  }
+  return res;
+};
+var convertRec2020ToXyz65_default = convertRec2020ToXyz65;
+
+// node_modules/culori/src/rec2020/definition.js
+var definition24 = {
+  ...definition_default,
+  mode: "rec2020",
+  fromMode: {
+    xyz65: convertXyz65ToRec2020_default,
+    rgb: (color) => convertXyz65ToRec2020_default(convertRgbToXyz65_default(color))
+  },
+  toMode: {
+    xyz65: convertRec2020ToXyz65_default,
+    rgb: (color) => convertXyz65ToRgb_default(convertRec2020ToXyz65_default(color))
+  },
+  parse: ["rec2020"],
+  serialize: "rec2020"
+};
+var definition_default24 = definition24;
+
+// node_modules/culori/src/xyb/constants.js
+var bias = 0.0037930732552754493;
+var bias_cbrt = Math.cbrt(bias);
+
+// node_modules/culori/src/xyb/convertRgbToXyb.js
+var transfer = (v) => Math.cbrt(v) - bias_cbrt;
+var convertRgbToXyb = (color) => {
+  const { r, g, b, alpha } = convertRgbToLrgb_default(color);
+  const l = transfer(0.3 * r + 0.622 * g + 0.078 * b + bias);
+  const m = transfer(0.23 * r + 0.692 * g + 0.078 * b + bias);
+  const s = transfer(0.2434226892454782 * r + 0.2047674442449682 * g + 0.5518098665095535 * b + bias);
+  const res = {
+    mode: "xyb",
+    x: (l - m) / 2,
+    y: (l + m) / 2,
+    b: s - (l + m) / 2
+  };
+  if (alpha !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertRgbToXyb_default = convertRgbToXyb;
+
+// node_modules/culori/src/xyb/convertXybToRgb.js
+var transfer2 = (v) => Math.pow(v + bias_cbrt, 3);
+var convertXybToRgb = ({ x, y, b, alpha }) => {
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (b === undefined)
+    b = 0;
+  const l = transfer2(x + y) - bias;
+  const m = transfer2(y - x) - bias;
+  const s = transfer2(b + y) - bias;
+  const res = convertLrgbToRgb_default({
+    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 !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertXybToRgb_default = convertXybToRgb;
+
+// node_modules/culori/src/xyb/definition.js
+var definition25 = {
+  mode: "xyb",
+  channels: ["x", "y", "b", "alpha"],
+  parse: ["--xyb"],
+  serialize: "--xyb",
+  toMode: {
+    rgb: convertXybToRgb_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyb_default
+  },
+  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 }
+  }
+};
+var definition_default25 = definition25;
+
+// node_modules/culori/src/xyz50/definition.js
+var definition26 = {
+  mode: "xyz50",
+  parse: ["xyz-d50"],
+  serialize: "xyz-d50",
+  toMode: {
+    rgb: convertXyz50ToRgb_default,
+    lab: convertXyz50ToLab_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyz50_default,
+    lab: convertLabToXyz50_default
+  },
+  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 }
+  }
+};
+var definition_default26 = definition26;
+
+// node_modules/culori/src/xyz65/convertXyz65ToXyz50.js
+var convertXyz65ToXyz50 = (xyz65) => {
+  let { x, y, z, alpha } = xyz65;
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz65ToXyz50_default = convertXyz65ToXyz50;
+
+// node_modules/culori/src/xyz65/convertXyz50ToXyz65.js
+var convertXyz50ToXyz65 = (xyz50) => {
+  let { x, y, z, alpha } = xyz50;
+  if (x === undefined)
+    x = 0;
+  if (y === undefined)
+    y = 0;
+  if (z === undefined)
+    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 !== undefined) {
+    res.alpha = alpha;
+  }
+  return res;
+};
+var convertXyz50ToXyz65_default = convertXyz50ToXyz65;
+
+// node_modules/culori/src/xyz65/definition.js
+var definition27 = {
+  mode: "xyz65",
+  toMode: {
+    rgb: convertXyz65ToRgb_default,
+    xyz50: convertXyz65ToXyz50_default
+  },
+  fromMode: {
+    rgb: convertRgbToXyz65_default,
+    xyz50: convertXyz50ToXyz65_default
+  },
+  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 }
+  }
+};
+var definition_default27 = definition27;
+
+// node_modules/culori/src/yiq/convertRgbToYiq.js
+var convertRgbToYiq = ({ r, g, b, alpha }) => {
+  if (r === undefined)
+    r = 0;
+  if (g === undefined)
+    g = 0;
+  if (b === undefined)
+    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 !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertRgbToYiq_default = convertRgbToYiq;
+
+// node_modules/culori/src/yiq/convertYiqToRgb.js
+var convertYiqToRgb = ({ y, i, q, alpha }) => {
+  if (y === undefined)
+    y = 0;
+  if (i === undefined)
+    i = 0;
+  if (q === undefined)
+    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 !== undefined)
+    res.alpha = alpha;
+  return res;
+};
+var convertYiqToRgb_default = convertYiqToRgb;
+
+// node_modules/culori/src/yiq/definition.js
+var definition28 = {
+  mode: "yiq",
+  toMode: {
+    rgb: convertYiqToRgb_default
+  },
+  fromMode: {
+    rgb: convertRgbToYiq_default
+  },
+  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 }
+  }
+};
+var definition_default28 = definition28;
+
+// node_modules/culori/src/round.js
+var r = (value, precision) => Math.round(value * (precision = Math.pow(10, precision))) / precision;
+var round = (precision = 4) => (value) => typeof value === "number" ? r(value, precision) : value;
+var round_default = round;
+
+// node_modules/culori/src/formatter.js
+var twoDecimals = round_default(2);
+var clamp = (value) => Math.max(0, Math.min(1, value || 0));
+var fixup = (value) => Math.round(clamp(value) * 255);
+var rgb = converter_default("rgb");
+var hsl = converter_default("hsl");
+var serializeHex = (color) => {
+  if (color === undefined) {
+    return;
+  }
+  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);
+};
+var serializeHex8 = (color) => {
+  if (color === undefined) {
+    return;
+  }
+  let a = fixup(color.alpha !== undefined ? color.alpha : 1);
+  return serializeHex(color) + (1 << 8 | a).toString(16).slice(1);
+};
+var formatHex = (c) => serializeHex(rgb(c));
+var formatHex8 = (c) => serializeHex8(rgb(c));
+// node_modules/culori/src/index.js
+var a98 = useMode(definition_default2);
+var cubehelix = useMode(definition_default3);
+var dlab = useMode(definition_default4);
+var dlch = useMode(definition_default5);
+var hsi = useMode(definition_default6);
+var hsl2 = useMode(definition_default7);
+var hsv = useMode(definition_default8);
+var hwb = useMode(definition_default9);
+var itp = useMode(definition_default10);
+var jab = useMode(definition_default11);
+var jch = useMode(definition_default12);
+var lab = useMode(definition_default13);
+var lab65 = useMode(definition_default14);
+var lch = useMode(definition_default15);
+var lch65 = useMode(definition_default16);
+var lchuv = useMode(definition_default17);
+var lrgb = useMode(definition_default18);
+var luv = useMode(definition_default19);
+var okhsl = useMode(modeOkhsl_default);
+var okhsv = useMode(modeOkhsv_default);
+var oklab = useMode(definition_default20);
+var oklch = useMode(definition_default21);
+var p3 = useMode(definition_default22);
+var prophoto = useMode(definition_default23);
+var rec2020 = useMode(definition_default24);
+var rgb2 = useMode(definition_default);
+var xyb = useMode(definition_default25);
+var xyz50 = useMode(definition_default26);
+var xyz65 = useMode(definition_default27);
+var yiq = useMode(definition_default28);
+
 // src/utils/themes.ts
 var themes = {
   default: {
@@ -164,43 +3589,524 @@ function resolveColors(opts) {
     icon: opts.icon_color || base.icon,
     border: opts.border_color || base.border
   };
-}
-// src/utils/format.ts
-function kFormat(num) {
-  const trim = (v) => v.toFixed(1).replace(/\.0$/, "");
-  if (num >= 999950)
-    return trim(num / 1e6) + "M";
-  if (num >= 999.95)
-    return trim(num / 1000) + "k";
-  return String(Math.round(num));
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function wrapText(input, maxLen, maxLines) {
-  const words = input.split(/\s+/).filter(Boolean);
-  const lines = [];
-  let current = "";
-  for (const word of words) {
-    const next = current ? `${current} ${word}` : word;
-    if (next.length <= maxLen) {
-      current = next;
-      continue;
+}
+// src/utils/format.ts
+function kFormat(num) {
+  const sign = num < 0 ? "-" : "";
+  const abs = Math.abs(num);
+  const trim = (v) => v.toFixed(1).replace(/\.0$/, "");
+  if (abs >= 999950000)
+    return sign + trim(abs / 1e9) + "B";
+  if (abs >= 999950)
+    return sign + trim(abs / 1e6) + "M";
+  if (abs >= 999.95)
+    return sign + trim(abs / 1000) + "k";
+  return sign + String(Math.round(abs));
+}
+function measureText(text, size, weight = 400) {
+  if (!text)
+    return 0;
+  const factor = size;
+  const weightFactor = weight >= 700 ? 1.08 : weight >= 600 ? 1.04 : 1;
+  let width = 0;
+  for (const ch of text) {
+    const code = ch.codePointAt(0);
+    let w;
+    if (ch === " ")
+      w = 0.28;
+    else if (ch === "." || ch === "," || ch === ":" || ch === ";")
+      w = 0.3;
+    else if (ch === "i" || ch === "l" || ch === "I" || ch === "t" || ch === "j" || ch === "|")
+      w = 0.3;
+    else if (ch === "m" || ch === "w" || ch === "W" || ch === "M" || ch === "@")
+      w = 0.95;
+    else if (code >= 4352 && code <= 4607)
+      w = 1;
+    else if (code >= 19968 && code <= 40959)
+      w = 1;
+    else if (code >= 12352 && code <= 12543)
+      w = 1;
+    else if (code >= 44032 && code <= 55215)
+      w = 1;
+    else if (code > 127)
+      w = 0.72;
+    else
+      w = 0.58;
+    width += w;
+  }
+  return width * factor * weightFactor;
+}
+function escapeXml(str) {
+  return str.replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\ufffe\uffff\ud800-\udfff]/gu, "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function wrapText(input, maxLen, maxLines) {
+  if (maxLen < 1 || maxLines < 1)
+    return [];
+  let remaining = Array.from(input.trim().replace(/\s+/g, " "));
+  const lines = [];
+  while (remaining.length && lines.length < maxLines) {
+    if (remaining.length <= maxLen) {
+      lines.push(remaining.join(""));
+      break;
+    }
+    if (lines.length === maxLines - 1) {
+      lines.push(remaining.slice(0, maxLen - 1).join("").trimEnd() + "…");
+      break;
+    }
+    const space = remaining.lastIndexOf(" ", maxLen);
+    const end = space > 0 ? space : maxLen;
+    lines.push(remaining.slice(0, end).join(""));
+    remaining = remaining.slice(end);
+    if (remaining[0] === " ")
+      remaining.shift();
+  }
+  return lines;
+}
+// src/utils/icons.ts
+var icons = {
+  star: `<path d="M10.92 2.868a1.25 1.25 0 0 1 2.16 0l2.795 4.798l5.428 1.176a1.25 1.25 0 0 1 .667 2.054l-3.7 4.141l.56 5.525a1.25 1.25 0 0 1-1.748 1.27L12 19.592l-5.082 2.24a1.25 1.25 0 0 1-1.748-1.27l.56-5.525l-3.7-4.14a1.25 1.25 0 0 1 .667-2.055l5.428-1.176z"/>`,
+  commit: `<path fill-rule="evenodd" d="M10.5 7.75a2.5 2.5 0 11-5 0 2.5 2.5 0 015 0zm1.43.75a4.002 4.002 0 01-7.86 0H.75a.75.75 0 110-1.5h3.32a4.001 4.001 0 017.86 0h3.32a.75.75 0 110 1.5h-3.32z"/>`,
+  pr: `<path d="M4 18a2 2 0 1 0 4 0a2 2 0 1 0-4 0M4 6a2 2 0 1 0 4 0a2 2 0 1 0-4 0m12 12a2 2 0 1 0 4 0a2 2 0 1 0-4 0M6 8v8"/><path d="M11 6h5a2 2 0 0 1 2 2v8"/><path d="m14 9l-3-3l3-3"/>`,
+  issue: `<path d="M15.314 2a2 2 0 0 1 1.414.586l4.686 4.686A2 2 0 0 1 22 8.686v6.628a2 2 0 0 1-.586 1.414l-4.686 4.686a2 2 0 0 1-1.414.586H8.686a2 2 0 0 1-1.414-.586l-4.686-4.686A2 2 0 0 1 2 15.314V8.686a2 2 0 0 1 .586-1.414l4.686-4.686A2 2 0 0 1 8.686 2zm0 2H8.686L4 8.686v6.628L8.686 20h6.628L20 15.314V8.686zM12 15a1 1 0 1 1 0 2a1 1 0 0 1 0-2m0-9a1 1 0 0 1 1 1v6a1 1 0 1 1-2 0V7a1 1 0 0 1 1-1"/>`,
+  repo: `<path d="M6 19.623c-.69-.195-1.232-.491-1.682-.941C3 17.364 3 15.242 3 11s0-6.364 1.318-7.682S7.758 2 12 2s6.364 0 7.682 1.318S21 6.758 21 11s0 6.364-1.318 7.682c-.45.45-.993.746-1.682.941"/><path d="M12 20.193c-.414 0-.748.32-1.414.958c-.647.619-.97.929-1.242.831a.5.5 0 0 1-.096-.046C9 21.779 9 21.31 9 20.376v-3.125c0-1.532 0-2.299.44-2.775C9.878 14 10.585 14 12 14s2.121 0 2.56.476s.44 1.243.44 2.775v3.125c0 .935 0 1.403-.248 1.56a.5.5 0 0 1-.096.046c-.272.098-.595-.212-1.242-.831c-.666-.639-1-.958-1.414-.958M8 10h8M8 6h4"/>`,
+  x: `<path d="M4 4l11.733 16h4.267l-11.733 -16l-4.267 0" /><path d="M4 20l6.768 -6.768m2.46 -2.46l6.772 -6.772" />`
+};
+var iconMeta = {
+  star: { viewBox: "0 0 24 24", kind: "fill" },
+  commit: { viewBox: "0 0 16 16", kind: "fill" },
+  pr: { viewBox: "0 0 24 24", kind: "stroke", strokeWidth: "2" },
+  issue: { viewBox: "0 0 24 24", kind: "fill" },
+  repo: { viewBox: "0 0 24 24", kind: "stroke", strokeWidth: "1.5" },
+  x: { viewBox: "0 0 24 24", kind: "stroke", strokeWidth: "2" }
+};
+function icon(name, color, size = 16) {
+  const path = icons[name];
+  if (!path)
+    return "";
+  const meta = iconMeta[name];
+  const viewBox = meta?.viewBox ?? "0 0 16 16";
+  const colorStr = escapeXml(/^(?:[\da-f]{3}|[\da-f]{4}|[\da-f]{6}|[\da-f]{8})$/i.test(color) ? `#${color}` : color);
+  const attrs = meta?.kind === "stroke" ? `fill="none" stroke="${colorStr}" stroke-width="${meta.strokeWidth ?? "1.8"}" stroke-linecap="round" stroke-linejoin="round"` : `fill="${colorStr}"`;
+  return `<svg width="${size}" height="${size}" viewBox="${viewBox}" ${attrs} role="img">${path}</svg>`;
+}
+// src/utils/font.ts
+var FONT_FAMILY = 'ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"';
+var FONT_FACE = "";
+// src/utils/colors.ts
+var twColors = {
+  transparent: "transparent",
+  current: "currentColor",
+  white: "#ffffff",
+  black: "#000000",
+  "slate-50": "#f8fafc",
+  "slate-100": "#f1f5f9",
+  "slate-200": "#e2e8f0",
+  "slate-300": "#cbd5e1",
+  "slate-400": "#94a3b8",
+  "slate-500": "#64748b",
+  "slate-600": "#475569",
+  "slate-700": "#334155",
+  "slate-800": "#1e293b",
+  "slate-900": "#0f172a",
+  "slate-950": "#020617",
+  "neutral-800": "#262626",
+  "neutral-950": "#0a0a0a",
+  "zinc-100": "#f4f4f5",
+  "zinc-400": "#a1a1aa",
+  "zinc-800": "#27272a",
+  "zinc-900": "#18181b",
+  "stone-300": "#d6d3d1",
+  "stone-700": "#44403c",
+  "stone-800": "#292524",
+  "rose-200": "#fecdd3",
+  "rose-300": "#fda4af",
+  "rose-400": "#fb7185",
+  "rose-900": "#881337",
+  "rose-950": "#4c0519",
+  "pink-400": "#f472b6",
+  "pink-500": "#ec4899",
+  "fuchsia-400": "#e879f9",
+  "purple-400": "#c084fc",
+  "purple-900": "#581c87",
+  "purple-950": "#3b0764",
+  "indigo-300": "#a5b4fc",
+  "indigo-400": "#818cf8",
+  "indigo-500": "#6366f1",
+  "indigo-900": "#312e81",
+  "violet-300": "#c4b5fd",
+  "violet-400": "#a78bfa",
+  "blue-300": "#93c5fd",
+  "blue-400": "#60a5fa",
+  "blue-500": "#3b82f6",
+  "blue-600": "#2563eb",
+  "sky-400": "#38bdf8",
+  "sky-900": "#0c4a6e",
+  "sky-950": "#082f49",
+  "cyan-300": "#67e8f9",
+  "cyan-400": "#22d3ee",
+  "teal-400": "#2dd4bf",
+  "emerald-200": "#a7f3d0",
+  "emerald-300": "#6ee7b7",
+  "emerald-400": "#34d399",
+  "emerald-500": "#10b981",
+  "emerald-900": "#064e3b",
+  "emerald-950": "#022c22",
+  "green-400": "#4ade80",
+  "lime-300": "#bef264",
+  "lime-400": "#a3e635",
+  "yellow-300": "#fde047",
+  "yellow-400": "#facc15",
+  "amber-300": "#fcd34d",
+  "amber-400": "#fbbf24",
+  "amber-600": "#d97706",
+  "amber-700": "#b45309",
+  "amber-900": "#78350f",
+  "orange-50": "#fff7ed",
+  "orange-200": "#fed7aa",
+  "orange-400": "#fb923c",
+  "orange-500": "#f97316"
+};
+function resolveTw(token, property) {
+  const value = token.trim();
+  const hex = value.startsWith("#") ? value.slice(1) : value;
+  if (/^(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(hex)) {
+    return `${property}="#${hex}"`;
+  }
+  const colorName = value.replace(/^fill-/, "").replace(/^stroke-/, "");
+  return `${property}="${twColors[colorName] ?? value}"`;
+}
+// src/card.ts
+var STAT_DEFS = [
+  { key: "stars", iconName: "star", label: "Stars" },
+  { key: "commits", iconName: "commit", label: "Commits" },
+  { key: "issues", iconName: "issue", label: "Issues" },
+  { key: "repos", iconName: "repo", label: "Repos" },
+  { key: "prs", iconName: "pr", label: "PRs" }
+];
+function el(tag, attrs, children = "") {
+  let a = "";
+  for (const [k, v] of Object.entries(attrs)) {
+    if (v === undefined || v === null || v === "")
+      continue;
+    a += ` ${k}="${escapeXml(String(v))}"`;
+  }
+  if (!children)
+    return `<${tag}${a} />`;
+  return `<${tag}${a}>${children}</${tag}>`;
+}
+function raw(token) {
+  const value = resolveTw(token, "fill").match(/fill="([^"]+)"/)?.[1] ?? token;
+  const color = parse_default(value);
+  return color ? color.alpha === undefined || color.alpha === 1 ? formatHex(color) : formatHex8(color) : "#6b7280";
+}
+function fitText(text, width, size, weight = 400) {
+  if (measureText(text, size, weight) <= width)
+    return text;
+  const chars = Array.from(text);
+  while (chars.length && measureText(chars.join("") + "…", size, weight) > width)
+    chars.pop();
+  return chars.join("").trimEnd() + "…";
+}
+function cardId(value) {
+  let hash = 2166136261;
+  for (const char of value)
+    hash = Math.imul(hash ^ char.codePointAt(0), 16777619);
+  return `card-${(hash >>> 0).toString(36)}`;
+}
+function buildLanguageSegments(langs, totalSize, contentW) {
+  const minSegmentW = 6;
+  const visible = [];
+  let tinySize = 0;
+  for (const lang of langs) {
+    const segmentW = lang.size / totalSize * contentW;
+    if (segmentW < minSegmentW) {
+      tinySize += lang.size;
+      continue;
+    }
+    visible.push(lang);
+  }
+  if (tinySize > 0) {
+    visible.push({ name: "Other", color: "#6b7280", size: tinySize });
+  }
+  return visible;
+}
+function renderCard(user, stats, langs, opts = {}) {
+  const namespace = cardId(JSON.stringify([user, stats, langs, opts]));
+  const selector = `#${namespace}-root`;
+  const hidden = new Set((opts.hide ?? []).map((k) => k.trim().toLowerCase()));
+  const c = resolveColors(opts);
+  const compact = opts.compact ?? false;
+  const animate = opts.animate ?? false;
+  const hideBorder = opts.hide_border ?? false;
+  const hideLangs = new Set((opts.hide_langs ?? []).map((k) => k.toLowerCase().trim()));
+  const showLangs = new Set((opts.show_langs ?? []).map((k) => k.toLowerCase().trim()));
+  const bgColor = raw(c.bg);
+  const titleColor = raw(c.title);
+  const textColor = raw(c.text);
+  const iconColor = raw(c.icon);
+  const borderColor = raw(c.border);
+  const displayName = user.name?.trim() || user.login;
+  const pronouns = !compact && user.pronouns ? user.pronouns : "";
+  const bioRaw = !compact && user.bio ? user.bio : "";
+  const twitterRaw = !compact && user.twitter ? user.twitter.replace(/^@/, "") : "";
+  const avatar = user.avatarUrl || "";
+  const metaRaw = `@${user.login}${pronouns ? ` · ${pronouns}` : ""}`;
+  const visible = STAT_DEFS.filter((d) => !hidden.has(d.key));
+  const activeLangsList = langs.filter((l) => {
+    if (!Number.isFinite(l.size) || l.size <= 0)
+      return false;
+    const name = l.name.toLowerCase().trim();
+    if (showLangs.size > 0 && !showLangs.has(name))
+      return false;
+    if (hideLangs.has(name))
+      return false;
+    return true;
+  });
+  const PX = 24;
+  const PY = 22;
+  const avatarSize = 60;
+  const avatarR = avatarSize / 2;
+  const textGap = 16;
+  const nameW = measureText(displayName, 17, 700);
+  const metaW = measureText(metaRaw, 12.5, 500);
+  const profileW = PX + avatarSize + textGap + Math.max(nameW, metaW) + PX;
+  const statsW = visible.length > 0 ? visible.length * 84 + PX * 2 : 0;
+  const W = Math.round(Math.min(540, Math.max(340, profileW, statsW)));
+  const contentW = W - PX * 2;
+  const profileTextW = contentW - avatarSize - textGap;
+  const nameEsc = escapeXml(fitText(displayName, profileTextW, 17, 700));
+  const metaStr = escapeXml(fitText(metaRaw, profileTextW, 12.5, 500));
+  const bioLines = wrapText(bioRaw, 44, 2).map((line) => fitText(line, profileTextW, 11.5));
+  const twitter = escapeXml(fitText(twitterRaw ? `@${twitterRaw}` : "", profileTextW - 15, 11.5, 500));
+  const infoX = PX + avatarSize + textGap;
+  const nameY = PY + 20;
+  const loginY = nameY + 17;
+  const bioStartY = loginY + 15;
+  const twitterY = bioStartY + bioLines.length * 14 + (bioLines.length ? 4 : 0);
+  let profileH = loginY + 8 - PY;
+  if (bioLines.length)
+    profileH = bioStartY + bioLines.length * 14 - PY;
+  if (twitter)
+    profileH = twitterY + 10 - PY;
+  profileH = Math.max(profileH, avatarSize + 6);
+  const statsY = PY + profileH + 16;
+  const statW = visible.length > 0 ? contentW / visible.length : 0;
+  const statsH = visible.length > 0 ? 58 : 0;
+  const totalSize = activeLangsList.reduce((s, l) => s + l.size, 0) || 1;
+  const sorted = [...activeLangsList].sort((a, b) => b.size - a.size);
+  let visualLangs = buildLanguageSegments(sorted, totalSize, contentW);
+  if (!compact && visualLangs.length > 6) {
+    const named = visualLangs.filter((lang) => lang.name !== "Other").slice(0, 5);
+    const otherSize = totalSize - named.reduce((sum, lang) => sum + lang.size, 0);
+    visualLangs = [...named, { name: "Other", color: "#6b7280", size: otherSize }];
+  }
+  const barY = statsY + statsH + (statsH ? 18 : 14);
+  const barH = 10;
+  const legendY = barY + barH + 14;
+  const legendRowH = 17;
+  const legendCols = Math.min(3, Math.max(1, Math.floor(contentW / 150)));
+  const legendColW = contentW / legendCols;
+  const legendItems = compact ? [] : visualLangs.map((lang) => {
+    const pct = (lang.size / totalSize * 100).toFixed(1);
+    const suffixW = measureText(` ${pct}%`, 11, 500);
+    return {
+      name: fitText(lang.name, legendColW - 20 - suffixW, 11, 500),
+      color: raw(lang.color),
+      pct
+    };
+  });
+  const legendRows = compact ? 0 : Math.ceil(legendItems.length / legendCols);
+  const hasLangs = activeLangsList.length > 0;
+  const langSectionH = hasLangs ? barH + 14 + legendRows * legendRowH + 10 : 0;
+  const H = barY + (hasLangs ? langSectionH : 0) + 14 + (hasLangs ? 0 : 6);
+  const parts = [];
+  const svgAttrs = {
+    id: "root",
+    width: W,
+    height: H,
+    viewBox: `0 0 ${W} ${H}`,
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    role: "img",
+    "aria-labelledby": "cardTitle cardDesc"
+  };
+  let svgOpen = "<svg";
+  for (const [k, v] of Object.entries(svgAttrs))
+    svgOpen += ` ${k}="${escapeXml(String(v))}"`;
+  parts.push(svgOpen + ">");
+  parts.push(el("title", { id: "cardTitle" }, `${escapeXml(displayName)}'s GitHub Stats`));
+  parts.push(el("desc", { id: "cardDesc" }, escapeXml(`GitHub profile card for ${displayName}. ${visible.map(({ key, label }) => {
+    const value = stats[key];
+    return value === null ? `${label}: unavailable` : `${label}: ${kFormat(value)}`;
+  }).join(", ")}. ${activeLangsList.length} highlighted languages.`)));
+  const css = [];
+  css.push(`${selector} { font-family: ${FONT_FAMILY}; text-rendering: geometricPrecision; -webkit-font-smoothing: antialiased; -moz-osx-font-smoothing: grayscale; }`);
+  css.push(`${selector} .header { font-size: 17px; font-weight: 700; fill: ${titleColor}; letter-spacing: -0.015em; }`);
+  css.push(`${selector} .lang-name { font-size: 11px; fill: ${textColor}; opacity: 0.82; }`);
+  css.push(`${selector} .lang-progress { fill: ${textColor}; opacity: 0.07; }`);
+  css.push(`${selector} .meta { font-size: 12.5px; font-weight: 500; fill: ${textColor}; opacity: 0.72; }`);
+  css.push(`${selector} .bio { font-size: 11.5px; font-weight: 400; fill: ${textColor}; opacity: 0.68; }`);
+  css.push(`${selector} .stat-label { font-size: 10px; font-weight: 700; fill: ${textColor}; opacity: 0.68; letter-spacing: 0.06em; }`);
+  css.push(`${selector} .stat-value { font-size: 16px; font-weight: 700; fill: ${textColor}; letter-spacing: -0.015em; font-variant-numeric: tabular-nums; font-feature-settings: "tnum"; }`);
+  css.push(`${selector} .twitter-text { font-size: 11.5px; font-weight: 500; fill: ${textColor}; opacity: 0.65; }`);
+  if (animate) {
+    css.push(`@keyframes ${namespace}-fade { from { opacity: 0; } to { opacity: 1; } }`);
+    css.push(`${selector} .stagger { opacity: 0; animation: ${namespace}-fade 0.3s ease-in-out forwards; }`);
+  }
+  parts.push(el("style", {}, escapeXml(css.join(" "))));
+  parts.push(el("defs", {}, [
+    el("clipPath", { id: "av" }, el("circle", { cx: PX + avatarR, cy: PY + avatarR, r: avatarR })),
+    el("radialGradient", { id: "gl", cx: "12%", cy: "15%", r: "65%" }, el("stop", { offset: "0%", "stop-color": iconColor, "stop-opacity": "0.08" }) + el("stop", { offset: "100%", "stop-color": iconColor, "stop-opacity": "0" })),
+    el("radialGradient", { id: "gl2", cx: "92%", cy: "95%", r: "55%" }, el("stop", { offset: "0%", "stop-color": titleColor, "stop-opacity": "0.035" }) + el("stop", { offset: "100%", "stop-color": titleColor, "stop-opacity": "0" })),
+    el("linearGradient", { id: "ring", x1: "0", y1: "0", x2: "1", y2: "1" }, el("stop", { offset: "0%", "stop-color": titleColor }) + el("stop", { offset: "100%", "stop-color": iconColor })),
+    el("linearGradient", { id: "card-bg", x1: "0", y1: "0", x2: W, y2: H, gradientUnits: "userSpaceOnUse" }, el("stop", { offset: "0%", "stop-color": bgColor }) + el("stop", { offset: "82%", "stop-color": bgColor }) + el("stop", { offset: "100%", "stop-color": titleColor, "stop-opacity": "0.04" })),
+    el("linearGradient", { id: "rim", x1: "0", y1: "0", x2: W, y2: "0", gradientUnits: "userSpaceOnUse" }, el("stop", { offset: "0%", "stop-color": iconColor, "stop-opacity": "0" }) + el("stop", { offset: "45%", "stop-color": iconColor, "stop-opacity": "0.28" }) + el("stop", { offset: "100%", "stop-color": iconColor, "stop-opacity": "0" }))
+  ].join("")));
+  parts.push(el("rect", { x: "0.5", y: "0.5", width: W - 1, height: H - 1, rx: 12, fill: "url(#card-bg)" }));
+  parts.push(el("rect", { x: "0.5", y: "0.5", width: W - 1, height: H - 1, rx: 12, fill: "url(#gl)" }));
+  parts.push(el("rect", { x: "0.5", y: "0.5", width: W - 1, height: H - 1, rx: 12, fill: "url(#gl2)" }));
+  parts.push(el("line", {
+    x1: PX,
+    y1: "1.5",
+    x2: W - PX,
+    y2: "1.5",
+    stroke: "url(#rim)",
+    "stroke-width": 1
+  }));
+  if (!hideBorder) {
+    parts.push(el("rect", {
+      x: "0.5",
+      y: "0.5",
+      width: W - 1,
+      height: H - 1,
+      rx: 12,
+      fill: "none",
+      stroke: borderColor,
+      "stroke-opacity": "0.5"
+    }));
+  }
+  parts.push(el("g", {}, el("circle", {
+    cx: PX + avatarR + 1,
+    cy: PY + avatarR + 1,
+    r: avatarR + 3,
+    fill: titleColor,
+    opacity: "0.08"
+  }) + el("image", {
+    href: avatar,
+    x: PX,
+    y: PY,
+    width: avatarSize,
+    height: avatarSize,
+    "clip-path": "url(#av)",
+    preserveAspectRatio: "xMidYMid slice"
+  }) + el("circle", {
+    cx: PX + avatarR,
+    cy: PY + avatarR,
+    r: avatarR + 1.5,
+    fill: "none",
+    stroke: "url(#ring)",
+    "stroke-opacity": "0.55",
+    "stroke-width": "1.5"
+  })));
+  const textParts = [];
+  textParts.push(el("text", { x: infoX, y: nameY, class: "header" }, nameEsc));
+  textParts.push(el("text", { x: infoX, y: loginY, class: "meta" }, metaStr));
+  for (let i = 0;i < bioLines.length; i++) {
+    textParts.push(el("text", { x: infoX, y: bioStartY + i * 14, class: "bio" }, escapeXml(bioLines[i].trim())));
+  }
+  if (twitter) {
+    textParts.push(el("g", { transform: `translate(${infoX},${twitterY - 9})` }, icon("x", textColor, 11) + el("text", { x: 15, y: 9, class: "twitter-text" }, twitter)));
+  }
+  parts.push(el("g", {}, textParts.join("")));
+  if (visible.length > 0) {
+    const statParts = [];
+    for (let i = 0;i < visible.length; i++) {
+      const d = visible[i];
+      const val = stats[d.key];
+      const cx = PX + statW * i + statW / 2;
+      const iy = statsY + 4;
+      const iconSize = 15;
+      const iconY = 2;
+      const valueY = 37;
+      const labelY = 52;
+      const cellParts = [
+        el("title", {}, val === null ? `${d.label}: unavailable` : `${d.label}: ${val.toLocaleString("en-US")}`)
+      ];
+      cellParts.push(el("g", { transform: `translate(${-iconSize / 2},${iconY})` }, icon(d.iconName, iconColor, iconSize)));
+      cellParts.push(el("text", { x: 0, y: valueY, class: "stat-value", "text-anchor": "middle" }, val === null ? "—" : kFormat(val)));
+      cellParts.push(el("text", { x: 0, y: labelY, class: "stat-label", "text-anchor": "middle" }, d.label.toUpperCase()));
+      statParts.push(el("g", {
+        transform: `translate(${cx},${iy})`,
+        class: animate ? "stagger" : undefined,
+        style: animate ? `animation-delay: ${(i + 3) * 150}ms` : undefined
+      }, cellParts.join("")));
+      if (i < visible.length - 1) {
+        const dx = PX + statW * (i + 1);
+        statParts.push(el("line", {
+          x1: dx,
+          y1: statsY + 4,
+          x2: dx,
+          y2: statsY + statsH - 6,
+          stroke: textColor,
+          "stroke-opacity": "0.12"
+        }));
+      }
     }
-    if (current)
-      lines.push(current);
-    if (lines.length === maxLines)
-      break;
-    current = word.length > maxLen ? word.slice(0, maxLen) : word;
+    parts.push(el("g", {}, statParts.join("")));
   }
-  if (current && lines.length < maxLines)
-    lines.push(current);
-  const consumed = lines.join(" ").length;
-  if (lines.length > 0 && consumed < input.trim().length) {
-    const last = lines[lines.length - 1];
-    lines[lines.length - 1] = (last.length >= maxLen ? last.slice(0, Math.max(0, maxLen - 1)) : last) + "…";
+  if (hasLangs) {
+    const langParts = [];
+    langParts.push(el("line", {
+      x1: PX,
+      y1: barY - 8,
+      x2: W - PX,
+      y2: barY - 8,
+      stroke: textColor,
+      "stroke-opacity": "0.08"
+    }));
+    langParts.push(el("clipPath", { id: "lang-clip" }, el("rect", {
+      x: PX,
+      y: barY,
+      width: animate ? "0" : contentW,
+      height: barH,
+      rx: 5
+    }, animate ? el("animate", {
+      attributeName: "width",
+      from: "0",
+      to: contentW,
+      dur: "0.6s",
+      fill: "freeze"
+    }) : "")));
+    langParts.push(el("rect", { x: PX, y: barY, width: contentW, height: barH, rx: 5, class: "lang-progress" }));
+    const barParts = [];
+    let off = 0;
+    for (let i = 0;i < visualLangs.length; i++) {
+      const lang = visualLangs[i];
+      const pct = (lang.size / totalSize * 100).toFixed(1);
+      let w = i === visualLangs.length - 1 ? contentW - off : lang.size / totalSize * contentW;
+      if (w < 0)
+        w = 0;
+      const x = PX + off;
+      const tooltip = compact ? "" : el("title", {}, `${escapeXml(lang.name)} ${pct}%`);
+      barParts.push(el("rect", { x, y: barY, width: w, height: barH, fill: raw(lang.color) }, tooltip));
+      off += w;
+    }
+    langParts.push(el("g", { "clip-path": "url(#lang-clip)" }, barParts.join("")));
+    for (let i = 0;i < legendItems.length; i++) {
+      const item = legendItems[i];
+      const col = i % legendCols;
+      const row = Math.floor(i / legendCols);
+      const lx = PX + col * legendColW;
+      const ly = legendY + row * legendRowH;
+      langParts.push(el("g", {
+        class: animate ? "stagger" : undefined,
+        style: animate ? `animation-delay: ${(i + 3) * 150}ms` : undefined
+      }, el("circle", { cx: lx + 5, cy: ly, r: 4, fill: item.color }) + el("text", { x: lx + 14, y: ly + 4, class: "lang-name", "font-weight": "500" }, `${escapeXml(item.name)} ${item.pct}%`)));
+    }
+    parts.push(el("g", {}, langParts.join("")));
   }
-  return lines;
+  parts.push("</svg>");
+  return parts.join("").replace(/\bid="([^"]+)"/g, (_, id) => `id="${namespace}-${id}"`).replace(/="url\(#([^)]+)\)"/g, (_, id) => `="url(#${namespace}-${id})"`).replace('aria-labelledby="cardTitle cardDesc"', `aria-labelledby="${namespace}-cardTitle ${namespace}-cardDesc"`);
 }
 // src/utils/languages.ts
 var langColors = {
@@ -858,352 +4764,17 @@ var langColors = {
 function getLangColor(lang) {
   return langColors[lang] || langColors.default;
 }
-// src/utils/icons.ts
-var icons = {
-  star: `<path fill-rule="evenodd" d="M8 .25a.75.75 0 01.673.418l1.882 3.815 4.21.612a.75.75 0 01.416 1.279l-3.046 2.97.719 4.192a.75.75 0 01-1.088.791L8 12.347l-3.766 1.98a.75.75 0 01-1.088-.79l.72-4.194L.818 6.374a.75.75 0 01.416-1.28l4.21-.611L7.327.668A.75.75 0 018 .25zm0 2.445L6.615 5.5a.75.75 0 01-.564.41l-3.097.45 2.24 2.184a.75.75 0 01.216.664l-.528 3.084 2.769-1.456a.75.75 0 01.698 0l2.77 1.456-.53-3.084a.75.75 0 01.216-.664l2.24-2.183-3.096-.45a.75.75 0 01-.564-.41L8 2.694v.001z"/>`,
-  commit: `<path fill-rule="evenodd" d="M10.5 7.75a2.5 2.5 0 11-5 0 2.5 2.5 0 015 0zm1.43.75a4.002 4.002 0 01-7.86 0H.75a.75.75 0 110-1.5h3.32a4.001 4.001 0 017.86 0h3.32a.75.75 0 110 1.5h-3.32z"/>`,
-  pr: `<path fill-rule="evenodd" d="M7.177 3.073L9.573.677A.25.25 0 0110 .854v4.792a.25.25 0 01-.427.177L7.177 3.427a.25.25 0 010-.354zM3.75 2.5a.75.75 0 100 1.5.75.75 0 000-1.5zm-2.25.75a2.25 2.25 0 113 2.122v5.256a2.251 2.251 0 11-1.5 0V5.372A2.25 2.25 0 011.5 3.25zM11 2.5h-1V4h1a1 1 0 011 1v5.628a2.251 2.251 0 101.5 0V5A2.5 2.5 0 0011 2.5zm1 10.25a.75.75 0 111.5 0 .75.75 0 01-1.5 0zM3.75 12a.75.75 0 100 1.5.75.75 0 000-1.5z"/>`,
-  issue: `<path fill-rule="evenodd" d="M8 1.5a6.5 6.5 0 100 13 6.5 6.5 0 000-13zM0 8a8 8 0 1116 0A8 8 0 010 8zm9 3a1 1 0 11-2 0 1 1 0 012 0zm-.25-6.25a.75.75 0 00-1.5 0v3.5a.75.75 0 001.5 0v-3.5z"/>`,
-  repo: `<path fill-rule="evenodd" d="M5 3.25a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm0 2.122a2.25 2.25 0 10-1.5 0v.878A2.25 2.25 0 005.75 8.5h1.5v2.128a2.251 2.251 0 101.5 0V8.5h1.5a2.25 2.25 0 002.25-2.25v-.878a2.25 2.25 0 10-1.5 0v.878a.75.75 0 01-.75.75h-4.5A.75.75 0 015 6.25v-.878zm3.75 7.378a.75.75 0 11-1.5 0 .75.75 0 011.5 0zm3-8.75a.75.75 0 100-1.5.75.75 0 000 1.5z"></path>`,
-  x: `<path d="M4 4l11.733 16h4.267l-11.733 -16l-4.267 0" /><path d="M4 20l6.768 -6.768m2.46 -2.46l6.772 -6.772" />`
-};
-function icon(name, color, size = 16) {
-  const path = icons[name];
-  if (!path)
-    return "";
-  const viewBox = name === "x" ? "0 0 24 24" : "0 0 16 16";
-  const colorStr = color.startsWith("#") ? color : `#${color}`;
-  const fill = name === "x" ? `stroke="${colorStr}" stroke-width="2" fill="none"` : `fill="${colorStr}"`;
-  return `<svg width="${size}" height="${size}" viewBox="${viewBox}" ${fill} role="img">${path}</svg>`;
-}
-// src/utils/font.ts
-var FONT_FAMILY = 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"';
-var FONT_FACE = "";
-// src/utils/colors.ts
-var twColors = {
-  transparent: "transparent",
-  current: "currentColor",
-  white: "#ffffff",
-  black: "#000000",
-  "slate-50": "#f8fafc",
-  "slate-100": "#f1f5f9",
-  "slate-200": "#e2e8f0",
-  "slate-300": "#cbd5e1",
-  "slate-400": "#94a3b8",
-  "slate-500": "#64748b",
-  "slate-600": "#475569",
-  "slate-700": "#334155",
-  "slate-800": "#1e293b",
-  "slate-900": "#0f172a",
-  "slate-950": "#020617",
-  "neutral-800": "#262626",
-  "neutral-950": "#0a0a0a",
-  "zinc-100": "#f4f4f5",
-  "zinc-400": "#a1a1aa",
-  "zinc-800": "#27272a",
-  "zinc-900": "#18181b",
-  "stone-300": "#d6d3d1",
-  "stone-700": "#44403c",
-  "stone-800": "#292524",
-  "rose-200": "#fecdd3",
-  "rose-300": "#fda4af",
-  "rose-400": "#fb7185",
-  "rose-900": "#881337",
-  "rose-950": "#4c0519",
-  "pink-400": "#f472b6",
-  "pink-500": "#ec4899",
-  "fuchsia-400": "#e879f9",
-  "purple-400": "#c084fc",
-  "purple-900": "#581c87",
-  "purple-950": "#3b0764",
-  "indigo-300": "#a5b4fc",
-  "indigo-400": "#818cf8",
-  "indigo-500": "#6366f1",
-  "indigo-900": "#312e81",
-  "violet-300": "#c4b5fd",
-  "violet-400": "#a78bfa",
-  "blue-300": "#93c5fd",
-  "blue-400": "#60a5fa",
-  "blue-500": "#3b82f6",
-  "blue-600": "#2563eb",
-  "sky-400": "#38bdf8",
-  "sky-900": "#0c4a6e",
-  "sky-950": "#082f49",
-  "cyan-300": "#67e8f9",
-  "cyan-400": "#22d3ee",
-  "teal-400": "#2dd4bf",
-  "emerald-200": "#a7f3d0",
-  "emerald-300": "#6ee7b7",
-  "emerald-400": "#34d399",
-  "emerald-500": "#10b981",
-  "emerald-900": "#064e3b",
-  "emerald-950": "#022c22",
-  "green-400": "#4ade80",
-  "lime-300": "#bef264",
-  "lime-400": "#a3e635",
-  "yellow-300": "#fde047",
-  "yellow-400": "#facc15",
-  "amber-300": "#fcd34d",
-  "amber-400": "#fbbf24",
-  "amber-600": "#d97706",
-  "amber-700": "#b45309",
-  "amber-900": "#78350f",
-  "orange-50": "#fff7ed",
-  "orange-200": "#fed7aa",
-  "orange-400": "#fb923c",
-  "orange-500": "#f97316"
-};
-function resolveTw(token, property) {
-  const value = token.trim();
-  const hex = value.startsWith("#") ? value.slice(1) : value;
-  if (/^(?:[0-9A-Fa-f]{3}|[0-9A-Fa-f]{4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(hex)) {
-    return `${property}="#${hex}"`;
-  }
-  const colorName = value.replace(/^fill-/, "").replace(/^stroke-/, "");
-  return `${property}="${twColors[colorName] ?? value}"`;
-}
-// src/card.ts
-var STAT_DEFS = [
-  { key: "stars", iconName: "star", label: "Stars" },
-  { key: "commits", iconName: "commit", label: "Commits" },
-  { key: "issues", iconName: "issue", label: "Issues" },
-  { key: "repos", iconName: "repo", label: "Repos" },
-  { key: "prs", iconName: "pr", label: "PRs" }
-];
-function raw(token) {
-  const m = resolveTw(token, "fill").match(/fill="([^"]+)"/);
-  return m?.[1] ?? token;
-}
-function clamp(s, n) {
-  return s.length <= n ? s : s.slice(0, n - 1).trimEnd() + "…";
-}
-function buildLanguageSegments(langs, totalSize, contentW) {
-  const minSegmentW = 6;
-  const visible = [];
-  let tinySize = 0;
-  for (const lang of langs) {
-    const segmentW = lang.size / totalSize * contentW;
-    if (segmentW < minSegmentW) {
-      tinySize += lang.size;
-      continue;
-    }
-    visible.push(lang);
-  }
-  if (tinySize > 0) {
-    visible.push({ name: "Other", color: "#6b7280", size: tinySize });
-  }
-  return visible.length > 0 ? visible : langs;
-}
-function renderCard(user, stats, langs, opts = {}) {
-  const hidden = new Set((opts.hide ?? []).map((k) => k.toLowerCase()));
-  const c = resolveColors(opts);
-  const compact = opts.compact ?? false;
-  const animate = opts.animate ?? false;
-  const hideBorder = opts.hide_border ?? false;
-  const hideLangs = new Set((opts.hide_langs ?? []).map((k) => k.toLowerCase().trim()));
-  const showLangs = new Set((opts.show_langs ?? []).map((k) => k.toLowerCase().trim()));
-  const bgColor = raw(c.bg);
-  const titleColor = raw(c.title);
-  const textColor = raw(c.text);
-  const iconColor = raw(c.icon);
-  const borderColor = raw(c.border);
-  const fontFamily = FONT_FAMILY.replace(/"/g, "&apos;");
-  const displayName = user.name || user.login;
-  const nameEsc = escapeXml(clamp(displayName, 28));
-  const loginEsc = escapeXml(clamp(user.login, 24));
-  const pronouns = !compact && user.pronouns ? escapeXml(clamp(user.pronouns, 16)) : "";
-  const bioRaw = !compact && user.bio ? user.bio : "";
-  const bioLines = bioRaw ? wrapText(bioRaw, 44, 2) : [];
-  const twitter = !compact && user.twitter ? escapeXml(clamp(user.twitter, 22)) : "";
-  const avatar = (user.avatarUrl || "").replace(/&/g, "&amp;");
-  const visible = STAT_DEFS.filter((d) => !hidden.has(d.key));
-  const activeLangsList = langs.filter((l) => {
-    const name = l.name.toLowerCase().trim();
-    if (showLangs.size > 0 && !showLangs.has(name))
-      return false;
-    if (hideLangs.has(name))
-      return false;
-    return true;
-  });
-  const PX = 25;
-  const PY = 25;
-  const avatarSize = 64;
-  const avatarR = avatarSize / 2;
-  const metaLen = user.login.length + (pronouns ? pronouns.length + 3 : 0);
-  const maxBioLen = bioLines.length ? Math.max(...bioLines.map((l) => l.length)) : 0;
-  const profileTextW = Math.max(displayName.length * 11, metaLen * 7.5, maxBioLen * 6.5, twitter.length * 7 + 20);
-  const profileW = PX + avatarSize + 16 + profileTextW + PX;
-  const statsW = visible.length > 0 ? visible.length * 85 + PX * 2 : 0;
-  const langsW = activeLangsList.length > 0 ? 300 : 0;
-  const W = Math.round(Math.min(540, Math.max(340, profileW, statsW, langsW)));
-  const contentW = W - PX * 2;
-  const infoX = PX + avatarSize + 14;
-  const nameY = PY + 22;
-  const loginY = nameY + 18;
-  const bioStartY = loginY + 16;
-  const twitterY = bioStartY + bioLines.length * 14 + (bioLines.length ? 4 : 0);
-  let profileH = loginY + 10 - PY;
-  if (bioLines.length)
-    profileH = bioStartY + bioLines.length * 14 - PY;
-  if (twitter)
-    profileH = twitterY + 10 - PY;
-  profileH = Math.max(profileH, avatarSize + 4);
-  const statsY = PY + profileH + 14;
-  const statW = visible.length > 0 ? contentW / visible.length : 0;
-  const statsH = visible.length > 0 ? 50 : 0;
-  const totalSize = activeLangsList.reduce((s, l) => s + l.size, 0) || 1;
-  const sorted = [...activeLangsList].sort((a, b) => b.size - a.size);
-  const visualLangs = buildLanguageSegments(sorted, totalSize, contentW);
-  const barY = statsY + statsH + (statsH ? 16 : 12);
-  const barH = 10;
-  const maxLegend = compact ? 0 : 6;
-  const legendLangs = visualLangs.slice(0, maxLegend);
-  const otherSize = visualLangs.slice(maxLegend).reduce((s, l) => s + l.size, 0);
-  const legendY = barY + barH + 12;
-  const legendRowH = 16;
-  const legendCols = 3;
-  const legendColW = contentW / legendCols;
-  const legendItems = legendLangs.map((l) => ({
-    name: clamp(l.name, 14),
-    color: l.color,
-    pct: (l.size / totalSize * 100).toFixed(1)
-  }));
-  if (otherSize > 0 && legendItems.length > 0) {
-    const existingOther = legendItems.find((item) => item.name === "Other");
-    if (existingOther) {
-      existingOther.pct = ((Number(existingOther.pct) / 100 * totalSize + otherSize) / totalSize * 100).toFixed(1);
-    } else {
-      legendItems.push({
-        name: "Other",
-        color: "#6b7280",
-        pct: (otherSize / totalSize * 100).toFixed(1)
-      });
-    }
-  }
-  const legendRows = compact ? 0 : Math.ceil(legendItems.length / legendCols);
-  const hasLangs = activeLangsList.length > 0;
-  const langSectionH = hasLangs ? barH + 12 + legendRows * legendRowH + 8 : 0;
-  const H = barY + (hasLangs ? langSectionH : 0) + 12 + (hasLangs ? 0 : 4);
-  const parts = [];
-  parts.push('<svg width="' + W + '" height="' + H + '" viewBox="0 0 ' + W + " " + H + '" fill="none" xmlns="http://www.w3.org/2000/svg" role="img" aria-labelledby="cardTitle cardDesc">');
-  parts.push('<title id="cardTitle">' + escapeXml(displayName + "'s GitHub Stats") + "</title>");
-  parts.push('<desc id="cardDesc">GitHub profile card for ' + escapeXml(displayName) + " with " + kFormat(stats.stars) + " stars, " + kFormat(stats.commits) + " commits, and " + activeLangsList.length + " highlighted languages.</desc>");
-  const cssLines = [];
-  cssLines.push("* { font-family: " + fontFamily + "; }");
-  cssLines.push(".header { font-size: 18px; font-weight: 700; fill: " + titleColor + "; }");
-  cssLines.push(".stat { font-size: 14px; font-weight: 600; fill: " + textColor + "; }");
-  cssLines.push(".bold { font-weight: 700; }");
-  cssLines.push(".icon { fill: " + iconColor + "; }");
-  cssLines.push(".lang-name { font-size: 11px; fill: " + textColor + "; opacity: 0.8; }");
-  cssLines.push(".lang-progress { fill: " + textColor + "; opacity: 0.08; }");
-  cssLines.push(".meta { font-size: 12px; font-weight: 500; fill: " + textColor + "; opacity: 0.7; }");
-  cssLines.push(".bio { font-size: 11px; font-weight: 400; fill: " + textColor + "; opacity: 0.68; }");
-  cssLines.push(".stat-label { font-size: 9px; font-weight: 600; fill: " + textColor + "; opacity: 0.5; letter-spacing: 0.08em; }");
-  cssLines.push(".stat-value { font-size: 15px; font-weight: 800; fill: " + textColor + "; }");
-  cssLines.push(".twitter-text { font-size: 11px; font-weight: 500; fill: " + textColor + "; opacity: 0.65; }");
-  if (animate) {
-    cssLines.push("@keyframes fadeInAnimation { from { opacity: 0; } to { opacity: 1; } }");
-    cssLines.push(".stagger { opacity: 0; animation: fadeInAnimation 0.3s ease-in-out forwards; }");
-  }
-  parts.push("<style>" + cssLines.join(" ") + "</style>");
-  parts.push("<defs>");
-  parts.push('<clipPath id="av"><circle cx="' + (PX + avatarR) + '" cy="' + (PY + avatarR) + '" r="' + avatarR + '"/></clipPath>');
-  parts.push('<radialGradient id="gl" cx="12%" cy="15%" r="65%">' + '<stop offset="0%" stop-color="' + iconColor + '" stop-opacity="0.08"/>' + '<stop offset="100%" stop-color="' + iconColor + '" stop-opacity="0"/>' + "</radialGradient>");
-  parts.push('<radialGradient id="gl2" cx="92%" cy="95%" r="55%">' + '<stop offset="0%" stop-color="' + titleColor + '" stop-opacity="0.035"/>' + '<stop offset="100%" stop-color="' + titleColor + '" stop-opacity="0"/>' + "</radialGradient>");
-  parts.push('<linearGradient id="ring" x1="0" y1="0" x2="1" y2="1">' + '<stop offset="0%" stop-color="' + titleColor + '"/>' + '<stop offset="100%" stop-color="' + iconColor + '"/>' + "</linearGradient>");
-  parts.push('<linearGradient id="card-bg" x1="0" y1="0" x2="' + W + '" y2="' + H + '" gradientUnits="userSpaceOnUse">' + '<stop offset="0%" stop-color="' + bgColor + '"/>' + '<stop offset="82%" stop-color="' + bgColor + '"/>' + '<stop offset="100%" stop-color="' + titleColor + '" stop-opacity="0.04"/>' + "</linearGradient>");
-  parts.push('<linearGradient id="rim" x1="0" y1="0" x2="' + W + '" y2="0" gradientUnits="userSpaceOnUse">' + '<stop offset="0%" stop-color="' + iconColor + '" stop-opacity="0"/>' + '<stop offset="45%" stop-color="' + iconColor + '" stop-opacity="0.28"/>' + '<stop offset="100%" stop-color="' + iconColor + '" stop-opacity="0"/>' + "</linearGradient>");
-  parts.push("</defs>");
-  parts.push('<rect x="0.5" y="0.5" width="' + (W - 1) + '" height="' + (H - 1) + '" rx="10" fill="' + "url(#card-bg)" + '" stroke-opacity="1"/>');
-  parts.push('<rect x="0.5" y="0.5" width="' + (W - 1) + '" height="' + (H - 1) + '" rx="10" fill="url(#gl)"/>');
-  parts.push('<rect x="0.5" y="0.5" width="' + (W - 1) + '" height="' + (H - 1) + '" rx="10" fill="url(#gl2)"/>');
-  parts.push('<line x1="' + PX + '" y1="1.5" x2="' + (W - PX) + '" y2="1.5" stroke="url(#rim)" stroke-width="1"/>');
-  if (!hideBorder) {
-    parts.push('<rect x="0.5" y="0.5" width="' + (W - 1) + '" height="' + (H - 1) + '" rx="10" fill="none" stroke="' + borderColor + '" stroke-opacity="0.5"/>');
-  }
-  parts.push('<g transform="translate(0,0)">' + '<circle cx="' + (PX + avatarR + 1) + '" cy="' + (PY + avatarR + 1) + '" r="' + (avatarR + 3) + '" fill="' + titleColor + '" opacity="0.08"/>' + '<image href="' + avatar + '" x="' + PX + '" y="' + PY + '" width="' + avatarSize + '" height="' + avatarSize + '" clip-path="url(#av)" preserveAspectRatio="xMidYMid slice"/>' + '<circle cx="' + (PX + avatarR) + '" cy="' + (PY + avatarR) + '" r="' + (avatarR + 1.5) + '" fill="none" stroke="url(#ring)" stroke-opacity="0.55" stroke-width="1.5"/>' + "</g>");
-  parts.push('<g transform="translate(0,0)">');
-  parts.push('<text x="' + infoX + '" y="' + nameY + '" class="header">' + nameEsc + "</text>");
-  const metaStr = pronouns ? "@" + loginEsc + " · " + pronouns : "@" + loginEsc;
-  parts.push('<text x="' + infoX + '" y="' + loginY + '" class="meta">' + metaStr + "</text>");
-  for (let i = 0;i < bioLines.length; i++) {
-    parts.push('<text x="' + infoX + '" y="' + (bioStartY + i * 14) + '" class="bio">' + escapeXml(bioLines[i].trim()) + "</text>");
-  }
-  if (twitter) {
-    parts.push('<g transform="translate(' + infoX + "," + (twitterY - 9) + ')">' + icon("x", textColor, 11) + '<text x="15" y="9" class="twitter-text">@' + twitter + "</text></g>");
-  }
-  parts.push("</g>");
-  if (visible.length > 0) {
-    parts.push('<rect x="' + PX + '" y="' + (statsY - 8) + '" width="' + contentW + '" height="' + (statsH + 8) + '" rx="8" fill="' + textColor + '" opacity="0.035"/>');
-    parts.push('<g transform="translate(0,0)">');
-    for (let i = 0;i < visible.length; i++) {
-      const d = visible[i];
-      const val = stats[d.key];
-      const cx = PX + statW * i + statW / 2;
-      const cellX = PX + statW * i + 4;
-      const iy = statsY + 2;
-      const staggerStyle = animate ? ' style="animation-delay: ' + (i + 3) * 150 + 'ms"' : "";
-      const staggerClass = animate ? " stagger" : "";
-      parts.push('<rect x="' + cellX + '" y="' + (statsY - 4) + '" width="' + Math.max(0, statW - 8) + '" height="' + (statsH - 2) + '" rx="8" fill="' + textColor + '" opacity="0.028"/>');
-      parts.push('<g transform="translate(' + cx + "," + iy + ')" class="stat' + staggerClass + '"' + staggerStyle + ">");
-      parts.push('<text x="0" y="26" class="stat-value" text-anchor="middle">' + kFormat(val) + "</text>");
-      const labelText = d.label.toUpperCase();
-      const labelW = labelText.length * 6.8;
-      const rowW = 10 + 4 + labelW;
-      parts.push('<g transform="translate(' + -rowW / 2 + ',31.5)">' + icon(d.iconName, iconColor, 10) + "</g>");
-      parts.push('<text x="' + (-rowW / 2 + 14) + '" y="40" class="stat-label">' + labelText + "</text>");
-      parts.push("</g>");
-    }
-    parts.push("</g>");
-  }
-  if (hasLangs) {
-    parts.push('<line x1="' + PX + '" y1="' + (barY - 8) + '" x2="' + (W - PX) + '" y2="' + (barY - 8) + '" stroke="' + textColor + '" stroke-opacity="0.08"/>');
-    parts.push('<g transform="translate(0,0)">');
-    parts.push('<clipPath id="lang-clip"><rect x="' + PX + '" y="' + barY + '" width="' + (animate ? "0" : contentW) + '" height="' + barH + '" rx="5">' + (animate ? '<animate attributeName="width" from="0" to="' + contentW + '" dur="0.6s" fill="freeze"/>' : "") + "</rect></clipPath>");
-    parts.push('<rect x="' + PX + '" y="' + barY + '" width="' + contentW + '" height="' + barH + '" rx="5" class="lang-progress"/>');
-    parts.push('<g clip-path="url(#lang-clip)">');
-    const activeLangs = visualLangs;
-    let off = 0;
-    for (let i = 0;i < activeLangs.length; i++) {
-      const lang = activeLangs[i];
-      const pct = (lang.size / totalSize * 100).toFixed(1);
-      let w = i === activeLangs.length - 1 ? contentW - off : lang.size / totalSize * contentW;
-      if (w < 0)
-        w = 0;
-      const x = PX + off;
-      const tooltip = compact ? "" : "<title>" + escapeXml(lang.name) + " " + pct + "%</title>";
-      parts.push('<rect x="' + x + '" y="' + barY + '" width="' + w + '" height="' + barH + '" fill="' + lang.color + '">' + tooltip + "</rect>");
-      off += w;
-    }
-    parts.push("</g>");
-    for (let i = 0;i < legendItems.length; i++) {
-      const item = legendItems[i];
-      const col = i % legendCols;
-      const row = Math.floor(i / legendCols);
-      const lx = PX + col * legendColW;
-      const ly = legendY + row * legendRowH;
-      const staggerStyle = animate ? ' style="animation-delay: ' + (i + 3) * 150 + 'ms"' : "";
-      const staggerClass = animate ? ' class="stagger"' : "";
-      parts.push("<g" + staggerClass + staggerStyle + ">");
-      parts.push('<circle cx="' + (lx + 5) + '" cy="' + ly + '" r="4" fill="' + item.color + '"/>');
-      parts.push('<text x="' + (lx + 14) + '" y="' + (ly + 4) + '" class="lang-name" font-weight="500">' + escapeXml(item.name) + " " + item.pct + "%</text>");
-      parts.push("</g>");
-    }
-    parts.push("</g>");
-  }
-  parts.push("</svg>");
-  return parts.join("");
-}
 export {
-  wrapText,
-  themes,
-  resolveColors,
-  renderCard,
-  kFormat,
-  icons,
-  icon,
-  getLangColor,
-  escapeXml,
+  FONT_FACE,
   FONT_FAMILY,
-  FONT_FACE
+  escapeXml,
+  getLangColor,
+  icon,
+  icons,
+  kFormat,
+  measureText,
+  renderCard,
+  resolveColors,
+  themes,
+  wrapText
 };