hextimator 0.1.0

package/dist/cli.js

@@ -0,0 +1,2395 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { parseArgs } from "util";
+
+// src/convert/matrices.ts
+var M1 = [
+  [0.4122214708, 0.5363325363, 0.0514459929],
+  [0.2119034982, 0.6806995451, 0.1073969566],
+  [0.0883024619, 0.2817188376, 0.6299787005]
+];
+var M2 = [
+  [0.2104542553, 0.793617785, -0.0040720468],
+  [1.9779984951, -2.428592205, 0.4505937099],
+  [0.0259040371, 0.7827717662, -0.808675766]
+];
+var M1_INV = [
+  [4.0767416621, -3.3077115913, 0.2309699292],
+  [-1.2684380046, 2.6097574011, -0.3413193965],
+  [-0.0041960863, -0.7034186147, 1.707614701]
+];
+var M2_INV = [
+  [1, 0.3963377774, 0.2158037573],
+  [1, -0.1055613458, -0.0638541728],
+  [1, -0.0894841775, -1.291485548]
+];
+function multiplyMatrix3(m, v) {
+  return [
+    m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2],
+    m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2],
+    m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2]
+  ];
+}
+
+// src/convert/p3-matrices.ts
+var LINEAR_SRGB_TO_P3 = [
+  [0.8224619688, 0.1775380313, 0],
+  [0.0331941989, 0.9668058012, 0],
+  [0.0170826307, 0.0723974407, 0.9105199286]
+];
+var LINEAR_P3_TO_SRGB = [
+  [1.2249401762, -0.2249401763, 0],
+  [-0.0420569547, 1.0420569547, 0],
+  [-0.0196375546, -0.0786360456, 1.0982736002]
+];
+
+// src/convert/gamut.ts
+var DEG_TO_RAD = Math.PI / 180;
+var EPSILON = 1e-4;
+var MAX_ITERATIONS = 16;
+function oklchToLinearRgbRaw(l, c, h) {
+  const hRad = h * DEG_TO_RAD;
+  const a = c * Math.cos(hRad);
+  const b = c * Math.sin(hRad);
+  const lms_ = multiplyMatrix3(M2_INV, [l, a, b]);
+  const lms = lms_.map((v) => v * v * v);
+  return multiplyMatrix3(M1_INV, lms);
+}
+function isInGamut(r, g, b) {
+  return r >= -EPSILON && r <= 1 + EPSILON && g >= -EPSILON && g <= 1 + EPSILON && b >= -EPSILON && b <= 1 + EPSILON;
+}
+function gamutMapOklch(color) {
+  if (color.c <= EPSILON) {
+    return { ...color, c: 0 };
+  }
+  const [r, g, b] = oklchToLinearRgbRaw(color.l, color.c, color.h);
+  if (isInGamut(r, g, b)) {
+    return color;
+  }
+  let lo = 0;
+  let hi = color.c;
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const mid = (lo + hi) / 2;
+    const [rm, gm, bm] = oklchToLinearRgbRaw(color.l, mid, color.h);
+    if (isInGamut(rm, gm, bm)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return { ...color, c: lo };
+}
+function gamutMapOklchToP3(color) {
+  if (color.c <= EPSILON) {
+    return { ...color, c: 0 };
+  }
+  const [rSrgb, gSrgb, bSrgb] = oklchToLinearRgbRaw(color.l, color.c, color.h);
+  const [rP3, gP3, bP3] = multiplyMatrix3(LINEAR_SRGB_TO_P3, [
+    rSrgb,
+    gSrgb,
+    bSrgb
+  ]);
+  if (isInGamut(rP3, gP3, bP3)) {
+    return color;
+  }
+  let lo = 0;
+  let hi = color.c;
+  for (let i = 0; i < MAX_ITERATIONS; i++) {
+    const mid = (lo + hi) / 2;
+    const [rm, gm, bm] = oklchToLinearRgbRaw(color.l, mid, color.h);
+    const [rP3m, gP3m, bP3m] = multiplyMatrix3(LINEAR_SRGB_TO_P3, [rm, gm, bm]);
+    if (isInGamut(rP3m, gP3m, bP3m)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return { ...color, c: lo };
+}
+
+// src/convert/linear-oklab.ts
+function linearRgbToOklab(color) {
+  const lms = multiplyMatrix3(M1, [color.r, color.g, color.b]);
+  const lms_ = lms.map((v) => Math.cbrt(v));
+  const [l, a, b] = multiplyMatrix3(M2, lms_);
+  return { space: "oklab", l, a, b, alpha: color.alpha };
+}
+function oklabToLinearRgb(color) {
+  const lms_ = multiplyMatrix3(M2_INV, [color.l, color.a, color.b]);
+  const lms = lms_.map((v) => v * v * v);
+  const [r, g, b] = multiplyMatrix3(M1_INV, lms);
+  return { space: "linear-rgb", r, g, b, alpha: color.alpha };
+}
+
+// src/convert/oklab-oklch.ts
+var RAD_TO_DEG = 180 / Math.PI;
+var DEG_TO_RAD2 = Math.PI / 180;
+function oklabToOklch(color) {
+  const c = Math.sqrt(color.a * color.a + color.b * color.b);
+  let h = Math.atan2(color.b, color.a) * RAD_TO_DEG;
+  if (h < 0) h += 360;
+  return { space: "oklch", l: color.l, c, h, alpha: color.alpha };
+}
+function oklchToOklab(color) {
+  const hRad = color.h * DEG_TO_RAD2;
+  return {
+    space: "oklab",
+    l: color.l,
+    a: color.c * Math.cos(hRad),
+    b: color.c * Math.sin(hRad),
+    alpha: color.alpha
+  };
+}
+
+// src/convert/srgb-hsl.ts
+function srgbToHsl(color) {
+  const r = color.r / 255;
+  const g = color.g / 255;
+  const b = color.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  const l = (max + min) / 2;
+  if (d === 0) {
+    return { space: "hsl", h: 0, s: 0, l: l * 100, alpha: color.alpha };
+  }
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === r) {
+    h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  } else if (max === g) {
+    h = ((b - r) / d + 2) / 6;
+  } else {
+    h = ((r - g) / d + 4) / 6;
+  }
+  return {
+    space: "hsl",
+    h: h * 360,
+    s: s * 100,
+    l: l * 100,
+    alpha: color.alpha
+  };
+}
+function hslToSrgb(color) {
+  const h = color.h / 360;
+  const s = color.s / 100;
+  const l = color.l / 100;
+  if (s === 0) {
+    const v = Math.round(l * 255);
+    return { space: "srgb", r: v, g: v, b: v, alpha: color.alpha };
+  }
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return {
+    space: "srgb",
+    r: Math.round(hueToRgb(p, q, h + 1 / 3) * 255),
+    g: Math.round(hueToRgb(p, q, h) * 255),
+    b: Math.round(hueToRgb(p, q, h - 1 / 3) * 255),
+    alpha: color.alpha
+  };
+}
+function hueToRgb(p, q, t) {
+  if (t < 0) t += 1;
+  if (t > 1) t -= 1;
+  if (t < 1 / 6) return p + (q - p) * 6 * t;
+  if (t < 1 / 2) return q;
+  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+  return p;
+}
+
+// src/convert/srgb-linear.ts
+function gammaDecodeChannel(c) {
+  const s = c / 255;
+  return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+}
+function gammaEncodeChannel(c) {
+  const s = c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+  return Math.round(Math.min(255, Math.max(0, s * 255)));
+}
+function srgbToLinear(color) {
+  return {
+    space: "linear-rgb",
+    r: gammaDecodeChannel(color.r),
+    g: gammaDecodeChannel(color.g),
+    b: gammaDecodeChannel(color.b),
+    alpha: color.alpha
+  };
+}
+function linearToSrgb(color) {
+  return {
+    space: "srgb",
+    r: gammaEncodeChannel(color.r),
+    g: gammaEncodeChannel(color.g),
+    b: gammaEncodeChannel(color.b),
+    alpha: color.alpha
+  };
+}
+
+// src/convert/srgb-p3.ts
+function gammaDecode(s) {
+  return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+}
+function gammaEncode(c) {
+  return c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+}
+function displayP3ToLinearSrgb(color) {
+  const linP3 = [
+    gammaDecode(color.r),
+    gammaDecode(color.g),
+    gammaDecode(color.b)
+  ];
+  const [r, g, b] = multiplyMatrix3(LINEAR_P3_TO_SRGB, linP3);
+  return { space: "linear-rgb", r, g, b, alpha: color.alpha };
+}
+function linearSrgbToDisplayP3(color) {
+  const [rLin, gLin, bLin] = multiplyMatrix3(LINEAR_SRGB_TO_P3, [
+    color.r,
+    color.g,
+    color.b
+  ]);
+  return {
+    space: "display-p3",
+    r: gammaEncode(rLin),
+    g: gammaEncode(gLin),
+    b: gammaEncode(bLin),
+    alpha: color.alpha
+  };
+}
+function srgbToDisplayP3(color) {
+  const rLin = color.r <= 0.04045 * 255 ? color.r / 255 / 12.92 : ((color.r / 255 + 0.055) / 1.055) ** 2.4;
+  const gLin = color.g <= 0.04045 * 255 ? color.g / 255 / 12.92 : ((color.g / 255 + 0.055) / 1.055) ** 2.4;
+  const bLin = color.b <= 0.04045 * 255 ? color.b / 255 / 12.92 : ((color.b / 255 + 0.055) / 1.055) ** 2.4;
+  const [rP3, gP3, bP3] = multiplyMatrix3(LINEAR_SRGB_TO_P3, [
+    rLin,
+    gLin,
+    bLin
+  ]);
+  return {
+    space: "display-p3",
+    r: gammaEncode(rP3),
+    g: gammaEncode(gP3),
+    b: gammaEncode(bP3),
+    alpha: color.alpha
+  };
+}
+function displayP3ToSrgb(color) {
+  const linP3 = [
+    gammaDecode(color.r),
+    gammaDecode(color.g),
+    gammaDecode(color.b)
+  ];
+  const [rLin, gLin, bLin] = multiplyMatrix3(LINEAR_P3_TO_SRGB, linP3);
+  function encodeChannel(c) {
+    const s = c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055;
+    return Math.round(Math.min(255, Math.max(0, s * 255)));
+  }
+  return {
+    space: "srgb",
+    r: encodeChannel(rLin),
+    g: encodeChannel(gLin),
+    b: encodeChannel(bLin),
+    alpha: color.alpha
+  };
+}
+
+// src/convert/index.ts
+var gamutMap = ((color) => gamutMapOklch(color));
+var gamutMapP3 = ((color) => gamutMapOklchToP3(color));
+function chain(...fns) {
+  return (color) => fns.reduce((c, fn) => fn(c), color);
+}
+var conversions = {
+  // srgb ↔ linear-rgb
+  "srgb->linear-rgb": srgbToLinear,
+  "linear-rgb->srgb": linearToSrgb,
+  // linear-rgb ↔ oklab
+  "linear-rgb->oklab": linearRgbToOklab,
+  "oklab->linear-rgb": oklabToLinearRgb,
+  // oklab ↔ oklch
+  "oklab->oklch": oklabToOklch,
+  "oklch->oklab": oklchToOklab,
+  // srgb ↔ hsl
+  "srgb->hsl": srgbToHsl,
+  "hsl->srgb": hslToSrgb,
+  // srgb → oklab / oklch
+  "srgb->oklab": chain(srgbToLinear, linearRgbToOklab),
+  "srgb->oklch": chain(srgbToLinear, linearRgbToOklab, oklabToOklch),
+  // oklab / oklch → srgb (gamut-mapped)
+  "oklab->srgb": chain(oklabToLinearRgb, linearToSrgb),
+  "oklch->srgb": chain(gamutMap, oklchToOklab, oklabToLinearRgb, linearToSrgb),
+  // linear-rgb → oklch
+  "linear-rgb->oklch": chain(linearRgbToOklab, oklabToOklch),
+  "oklch->linear-rgb": chain(gamutMap, oklchToOklab, oklabToLinearRgb),
+  // hsl ↔ linear-rgb
+  "hsl->linear-rgb": chain(hslToSrgb, srgbToLinear),
+  "linear-rgb->hsl": chain(linearToSrgb, srgbToHsl),
+  // hsl ↔ oklab
+  "hsl->oklab": chain(hslToSrgb, srgbToLinear, linearRgbToOklab),
+  "oklab->hsl": chain(oklabToLinearRgb, linearToSrgb, srgbToHsl),
+  // hsl ↔ oklch
+  "hsl->oklch": chain(hslToSrgb, srgbToLinear, linearRgbToOklab, oklabToOklch),
+  "oklch->hsl": chain(
+    gamutMap,
+    oklchToOklab,
+    oklabToLinearRgb,
+    linearToSrgb,
+    srgbToHsl
+  ),
+  // display-p3
+  "display-p3->srgb": displayP3ToSrgb,
+  "srgb->display-p3": srgbToDisplayP3,
+  "display-p3->linear-rgb": displayP3ToLinearSrgb,
+  "linear-rgb->display-p3": linearSrgbToDisplayP3,
+  "display-p3->oklab": chain(displayP3ToLinearSrgb, linearRgbToOklab),
+  "oklab->display-p3": chain(oklabToLinearRgb, linearSrgbToDisplayP3),
+  "display-p3->oklch": chain(
+    displayP3ToLinearSrgb,
+    linearRgbToOklab,
+    oklabToOklch
+  ),
+  "oklch->display-p3": chain(
+    gamutMapP3,
+    oklchToOklab,
+    oklabToLinearRgb,
+    linearSrgbToDisplayP3
+  ),
+  "display-p3->hsl": chain(displayP3ToSrgb, srgbToHsl),
+  "hsl->display-p3": chain(hslToSrgb, srgbToDisplayP3)
+};
+function convert(color, to) {
+  if (color.space === to) {
+    return { ...color };
+  }
+  const key = `${color.space}->${to}`;
+  const fn = conversions[key];
+  if (!fn) {
+    throw new Error(`Unsupported conversion: ${color.space} \u2192 ${to}`);
+  }
+  return fn(color);
+}
+
+// src/parse/parseTuple.ts
+function tryParseTuple(t, assumeSpace = "srgb") {
+  switch (assumeSpace) {
+    case "srgb": {
+      const [r, g, b] = t;
+      return { space: "srgb", r, g, b, alpha: 1 };
+    }
+    case "hsl": {
+      const [h, s, l] = t;
+      return { space: "hsl", h, s, l, alpha: 1 };
+    }
+    case "oklch": {
+      const [l, c, h] = t;
+      return { space: "oklch", l, c, h, alpha: 1 };
+    }
+    case "oklab": {
+      const [l, a, b] = t;
+      return { space: "oklab", l, a, b, alpha: 1 };
+    }
+    case "linear-rgb": {
+      const [r, g, b] = t;
+      return { space: "linear-rgb", r, g, b, alpha: 1 };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/parse/parseCommaSeparated.ts
+function tryParseCommaSeparated(input, assumeSpace = "srgb") {
+  const parts = input.split(",").map((p) => p.trim());
+  if (parts.length < 3 || parts.length > 4) return null;
+  const numbers = parts.map(parseFloat);
+  if (numbers.some(Number.isNaN)) return null;
+  return tryParseTuple(
+    numbers.length === 4 ? [numbers[0], numbers[1], numbers[2], numbers[3]] : [numbers[0], numbers[1], numbers[2]],
+    assumeSpace
+  );
+}
+
+// src/parse/parseCSSFunction.ts
+var CSS_FUNC_REGULAR_EXPRESSION = /^(rgba?|hsla?|oklch|oklab|lab|color)\(\s*(.+?)\s*\)$/;
+function parseCSSArgs(raw) {
+  let body = raw;
+  const slashIdx = body.lastIndexOf("/");
+  if (slashIdx !== -1) {
+    body = body.slice(0, slashIdx).trim();
+  }
+  const parts = body.includes(",") ? body.split(",").map((p) => p.trim()) : body.split(/\s+/);
+  if (parts.length === 4) {
+    parts.pop();
+  }
+  if (parts.length !== 3) {
+    return null;
+  }
+  const values = parts.map((p) => parseNumericValue(p));
+  if (values.some(Number.isNaN)) {
+    return null;
+  }
+  return { values };
+}
+function parseNumericValue(raw, percentScale) {
+  const s = raw.trim();
+  if (s === "none") return 0;
+  if (s.endsWith("%")) {
+    const base = parseFloat(s);
+    return percentScale ? base / 100 * percentScale : base / 100;
+  }
+  return parseFloat(s);
+}
+function buildRGB(args) {
+  const [r, g, b] = args.values;
+  return { space: "srgb", r, g, b, alpha: 1 };
+}
+function buildHSL(args) {
+  const [h, s, l] = args.values;
+  return { space: "hsl", h, s, l, alpha: 1 };
+}
+function buildOKLCH(args) {
+  const [l, c, h] = args.values;
+  return { space: "oklch", l, c, h, alpha: 1 };
+}
+function buildOKLab(args) {
+  const [l, a, b] = args.values;
+  return { space: "oklab", l, a, b, alpha: 1 };
+}
+function tryParseColorFunction(argsRaw) {
+  const parts = argsRaw.trim().split(/\s+/);
+  if (parts.length < 4) return null;
+  const spaceId = parts[0];
+  const rest = parts.slice(1).join(" ");
+  const args = parseCSSArgs(rest);
+  if (!args) return null;
+  const [r, g, b] = args.values;
+  switch (spaceId) {
+    case "srgb-linear":
+      return { space: "linear-rgb", r, g, b, alpha: 1 };
+    case "display-p3":
+      return { space: "display-p3", r, g, b, alpha: 1 };
+    default:
+      return null;
+  }
+}
+function tryParseCSSFunction(input) {
+  const match = input.match(CSS_FUNC_REGULAR_EXPRESSION);
+  if (!match) return null;
+  const [, funcName, argsRaw] = match;
+  if (funcName === "color") {
+    return tryParseColorFunction(argsRaw);
+  }
+  const args = parseCSSArgs(argsRaw);
+  if (!args) return null;
+  switch (funcName) {
+    case "rgb":
+    case "rgba":
+      return buildRGB(args);
+    case "hsl":
+    case "hsla":
+      return buildHSL(args);
+    case "oklch":
+      return buildOKLCH(args);
+    case "oklab":
+      return buildOKLab(args);
+    default:
+      return null;
+  }
+}
+
+// src/parse/parseHex.ts
+var HEX_PATTERNS = {
+  prefixed: /^#([0-9a-f]{3,8})$/,
+  // e.g. #FF6666
+  numeric: /^0x([0-9a-f]{6}|[0-9a-f]{8})$/,
+  // e.g. 0xFF6666
+  bare: /^([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/
+  // e.g. F66, FF6666
+};
+function parseHexDigits(hex) {
+  if (hex.length === 3 || hex.length === 4) {
+    hex = [...hex].map((c) => c + c).join("");
+  }
+  if (hex.length !== 6 && hex.length !== 8) {
+    return null;
+  }
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  if ([r, g, b].some(Number.isNaN)) {
+    return null;
+  }
+  return { space: "srgb", r, g, b, alpha: 1 };
+}
+function tryParseHex(input) {
+  for (const pattern of Object.values(HEX_PATTERNS)) {
+    const match = input.match(pattern);
+    if (match) {
+      return parseHexDigits(match[1]);
+    }
+  }
+  return null;
+}
+
+// src/parse/parseNumeric.ts
+function tryParseNumeric(n) {
+  if (!Number.isInteger(n) || n < 0 || n > 4294967295) return null;
+  if (n <= 16777215) {
+    return {
+      space: "srgb",
+      r: n >> 16 & 255,
+      g: n >> 8 & 255,
+      b: n & 255,
+      alpha: 1
+    };
+  }
+  return {
+    space: "srgb",
+    r: n >> 24 & 255,
+    g: n >> 16 & 255,
+    b: n >> 8 & 255,
+    alpha: 1
+  };
+}
+
+// src/parse/parse.ts
+var ColorParseError = class extends Error {
+  constructor(input, message) {
+    super(message ?? `Failed to parse color:  ${String(input)}`);
+    this.input = input;
+    this.name = "ColorParseError";
+  }
+};
+function parse(input, assumeSpace) {
+  if (isColor(input)) return input;
+  if (typeof input === "number") {
+    const result = tryParseNumeric(input);
+    if (result) return result;
+    throw new ColorParseError(input);
+  }
+  if (Array.isArray(input)) {
+    const result = tryParseTuple(input, assumeSpace);
+    if (result) return result;
+    throw new ColorParseError(input);
+  }
+  if (typeof input === "string") {
+    const normalized = _normalizeInput(input);
+    const cssResult = tryParseCSSFunction(normalized);
+    if (cssResult) return cssResult;
+    const hexResult = tryParseHex(normalized);
+    if (hexResult) return hexResult;
+    const commaResult = tryParseCommaSeparated(normalized, assumeSpace);
+    if (commaResult) return commaResult;
+    throw new ColorParseError(input, `Unrecognized color format: ${input}`);
+  }
+  throw new ColorParseError(input);
+}
+function _normalizeInput(raw) {
+  return raw.trim().toLowerCase();
+}
+function isColor(value) {
+  return typeof value === "object" && value !== null && "space" in value && typeof value.space === "string";
+}
+
+// src/a11y/cvd/matrices.ts
+var PROTAN_A = [
+  [0.152286, 1.052583, -0.204868],
+  [0.114503, 0.786281, 0.099216],
+  [-3882e-6, -0.048116, 1.051998]
+];
+var PROTAN_B = [
+  [0.152286, 1.052583, -0.204868],
+  [0.114503, 0.786281, 0.099216],
+  [-3882e-6, -0.048116, 1.051998]
+];
+var PROTAN_SEP = [
+  48e-5,
+  393e-5,
+  -441e-5
+];
+var DEUTAN_A = [
+  [0.367322, 0.860646, -0.227968],
+  [0.280085, 0.672501, 0.047413],
+  [-0.01182, 0.04294, 0.968881]
+];
+var DEUTAN_B = [
+  [0.367322, 0.860646, -0.227968],
+  [0.280085, 0.672501, 0.047413],
+  [-0.01182, 0.04294, 0.968881]
+];
+var DEUTAN_SEP = [
+  -281e-5,
+  -611e-5,
+  892e-5
+];
+var TRITAN_A = [
+  [1.255528, -0.076749, -0.178779],
+  [-0.078411, 0.930809, 0.147602],
+  [4733e-6, 0.691367, 0.3039]
+];
+var TRITAN_B = [
+  [1.255528, -0.076749, -0.178779],
+  [-0.078411, 0.930809, 0.147602],
+  [4733e-6, 0.691367, 0.3039]
+];
+var TRITAN_SEP = [
+  0.03901,
+  -0.02788,
+  -0.01113
+];
+var BRETTEL = {
+  protanopia: { a: PROTAN_A, b: PROTAN_B, sep: PROTAN_SEP },
+  deuteranopia: { a: DEUTAN_A, b: DEUTAN_B, sep: DEUTAN_SEP },
+  tritanopia: { a: TRITAN_A, b: TRITAN_B, sep: TRITAN_SEP }
+};
+function simulateCVD(rgb, type, severity) {
+  const s = Math.max(0, Math.min(1, severity));
+  if (s === 0) return [rgb[0], rgb[1], rgb[2]];
+  let simulated;
+  if (type === "achromatopsia") {
+    const y = 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2];
+    simulated = [y, y, y];
+  } else {
+    const params = BRETTEL[type];
+    const dotSep = rgb[0] * params.sep[0] + rgb[1] * params.sep[1] + rgb[2] * params.sep[2];
+    const matrix = dotSep >= 0 ? params.a : params.b;
+    simulated = multiplyMatrix3(matrix, rgb);
+  }
+  if (s < 1) {
+    return [
+      rgb[0] + s * (simulated[0] - rgb[0]),
+      rgb[1] + s * (simulated[1] - rgb[1]),
+      rgb[2] + s * (simulated[2] - rgb[2])
+    ];
+  }
+  return simulated;
+}
+
+// src/a11y/cvd/adapt.ts
+var ERROR_REDISTRIBUTION = {
+  protanopia: [
+    [0, 0, 0],
+    [0.7, 1, 0],
+    [0.7, 0, 1]
+  ],
+  deuteranopia: [
+    [1, 0, 0],
+    [0.7, 0, 0],
+    [0, 0.7, 1]
+  ],
+  tritanopia: [
+    [1, 0, 0.7],
+    [0, 1, 0.7],
+    [0, 0, 0]
+  ]
+};
+function daltonize(rgb, type, severity) {
+  const s = Math.max(0, Math.min(1, severity));
+  if (s === 0) return [rgb[0], rgb[1], rgb[2]];
+  if (type === "achromatopsia") {
+    const y = 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2];
+    const target = y > 0.5 ? 1 : 0;
+    return [
+      rgb[0] + s * 0.3 * (target - rgb[0]),
+      rgb[1] + s * 0.3 * (target - rgb[1]),
+      rgb[2] + s * 0.3 * (target - rgb[2])
+    ];
+  }
+  const simulated = simulateCVD(rgb, type, 1);
+  const err = [
+    rgb[0] - simulated[0],
+    rgb[1] - simulated[1],
+    rgb[2] - simulated[2]
+  ];
+  const redist = ERROR_REDISTRIBUTION[type];
+  const correction = [
+    redist[0][0] * err[0] + redist[0][1] * err[1] + redist[0][2] * err[2],
+    redist[1][0] * err[0] + redist[1][1] * err[1] + redist[1][2] * err[2],
+    redist[2][0] * err[0] + redist[2][1] * err[1] + redist[2][2] * err[2]
+  ];
+  return [
+    Math.max(0, Math.min(1, rgb[0] + s * correction[0])),
+    Math.max(0, Math.min(1, rgb[1] + s * correction[1])),
+    Math.max(0, Math.min(1, rgb[2] + s * correction[2]))
+  ];
+}
+function daltonizeColor(color, type, severity = 1) {
+  const linear = convert(color, "linear-rgb");
+  const corrected = daltonize([linear.r, linear.g, linear.b], type, severity);
+  return convert(
+    {
+      space: "linear-rgb",
+      r: corrected[0],
+      g: corrected[1],
+      b: corrected[2],
+      alpha: linear.alpha
+    },
+    "oklch"
+  );
+}
+function adaptPalette(palette, type, severity = 1) {
+  const result = {};
+  for (const role of Object.keys(palette)) {
+    const scale = palette[role];
+    const newScale = {
+      DEFAULT: scale.DEFAULT,
+      strong: scale.strong,
+      weak: scale.weak,
+      foreground: scale.foreground
+    };
+    for (const variant of Object.keys(scale)) {
+      newScale[variant] = daltonizeColor(parse(scale[variant]), type, severity);
+    }
+    result[role] = newScale;
+  }
+  return result;
+}
+
+// src/a11y/cvd/simulate.ts
+function simulateColor(color, type, severity = 1) {
+  const linear = convert(color, "linear-rgb");
+  const simulated = simulateCVD([linear.r, linear.g, linear.b], type, severity);
+  const simulatedLinear = {
+    space: "linear-rgb",
+    r: Math.max(0, simulated[0]),
+    g: Math.max(0, simulated[1]),
+    b: Math.max(0, simulated[2]),
+    alpha: linear.alpha
+  };
+  return convert(simulatedLinear, "oklch");
+}
+function simulatePalette(palette, type, severity = 1) {
+  const result = {};
+  for (const role of Object.keys(palette)) {
+    const scale = palette[role];
+    const newScale = {
+      DEFAULT: scale.DEFAULT,
+      strong: scale.strong,
+      weak: scale.weak,
+      foreground: scale.foreground
+    };
+    for (const variant of Object.keys(scale)) {
+      newScale[variant] = simulateColor(parse(scale[variant]), type, severity);
+    }
+    result[role] = newScale;
+  }
+  return result;
+}
+
+// src/format/serializeColor.ts
+function round(value, decimals) {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function rgbToHex(rgb) {
+  const r = Math.round(clamp(rgb.r, 0, 255));
+  const g = Math.round(clamp(rgb.g, 0, 255));
+  const b = Math.round(clamp(rgb.b, 0, 255));
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function serializeColor(color, colorFormat = "hex") {
+  switch (colorFormat) {
+    case "hex": {
+      return rgbToHex(convert(color, "srgb"));
+    }
+    case "rgb": {
+      const rgb = convert(color, "srgb");
+      return `rgb(${Math.round(rgb.r)}, ${Math.round(rgb.g)}, ${Math.round(rgb.b)})`;
+    }
+    case "rgb-raw": {
+      const rgb = convert(color, "srgb");
+      return `${Math.round(rgb.r)} ${Math.round(rgb.g)} ${Math.round(rgb.b)}`;
+    }
+    case "hsl": {
+      const hsl = convert(color, "hsl");
+      return `hsl(${round(hsl.h, 1)}, ${round(hsl.s, 1)}%, ${round(hsl.l, 1)}%)`;
+    }
+    case "hsl-raw": {
+      const hsl = convert(color, "hsl");
+      return `${round(hsl.h, 1)} ${round(hsl.s, 1)}% ${round(hsl.l, 1)}%`;
+    }
+    case "oklch": {
+      const oklch = convert(color, "oklch");
+      return `oklch(${round(oklch.l, 4)} ${round(oklch.c, 4)} ${round(oklch.h, 1)})`;
+    }
+    case "oklch-raw": {
+      const oklch = convert(color, "oklch");
+      return `${round(oklch.l, 4)} ${round(oklch.c, 4)} ${round(oklch.h, 1)}`;
+    }
+    case "p3": {
+      const p3 = convert(color, "display-p3");
+      return `color(display-p3 ${round(clamp(p3.r, 0, 1), 5)} ${round(clamp(p3.g, 0, 1), 5)} ${round(clamp(p3.b, 0, 1), 5)})`;
+    }
+    case "p3-raw": {
+      const p3 = convert(color, "display-p3");
+      return `${round(clamp(p3.r, 0, 1), 5)} ${round(clamp(p3.g, 0, 1), 5)} ${round(clamp(p3.b, 0, 1), 5)}`;
+    }
+    default: {
+      throw new Error(`Unsupported color format: ${colorFormat}`);
+    }
+  }
+}
+
+// src/format/buildTokenEntries.ts
+function isColorObject(input) {
+  return typeof input === "object" && input !== null && "space" in input;
+}
+function buildTokenEntries(palette, options) {
+  const colorFormat = options?.colors ?? "hex";
+  const entries = [];
+  const roles = Object.keys(palette);
+  for (const role of roles) {
+    const scale = palette[role];
+    const variants = Object.keys(scale);
+    for (const variant of variants) {
+      const raw = scale[variant];
+      if (!isColorObject(raw)) continue;
+      entries.push({
+        role: options?.roleNames?.[role] ?? role,
+        variant: options?.variantNames?.[variant] ?? variant,
+        isDefault: variant === "DEFAULT",
+        value: serializeColor(raw, colorFormat)
+      });
+    }
+  }
+  return entries;
+}
+
+// src/format/formatters.ts
+function toFlatKey(entry, sep) {
+  if (entry.isDefault && entry.variant === "DEFAULT") return entry.role;
+  return `${entry.role}${sep}${entry.variant}`;
+}
+function formatObject(entries, sep) {
+  const result = {};
+  for (const entry of entries) {
+    result[toFlatKey(entry, sep)] = entry.value;
+  }
+  return result;
+}
+function formatCSS(entries, sep) {
+  const result = {};
+  for (const entry of entries) {
+    result[`--${toFlatKey(entry, sep)}`] = entry.value;
+  }
+  return result;
+}
+function formatSCSS(entries, sep) {
+  const result = {};
+  for (const entry of entries) {
+    result[`$${toFlatKey(entry, sep)}`] = entry.value;
+  }
+  return result;
+}
+function formatTailwind(entries) {
+  const result = {};
+  for (const { role, variant, value } of entries) {
+    if (!result[role]) result[role] = {};
+    result[role][variant] = value;
+  }
+  return result;
+}
+function formatTailwindCSS(entries, sep) {
+  const lines = entries.map((entry) => {
+    const key = toFlatKey(entry, sep);
+    return `  --color-${key}: ${entry.value};`;
+  });
+  return `@theme {
+${lines.join("\n")}
+}`;
+}
+function formatJSON(entries, sep) {
+  return JSON.stringify(formatObject(entries, sep), null, 2);
+}
+
+// src/format/format.ts
+function format(palette, options, standaloneTokens) {
+  const entries = buildTokenEntries(palette, options);
+  if (standaloneTokens) {
+    entries.push(...standaloneTokens);
+  }
+  const sep = options?.separator ?? "-";
+  switch (options?.as) {
+    case "css":
+      return formatCSS(entries, sep);
+    case "scss":
+      return formatSCSS(entries, sep);
+    case "tailwind":
+      return formatTailwind(entries);
+    case "tailwind-css":
+      return formatTailwindCSS(entries, sep);
+    case "json":
+      return formatJSON(entries, sep);
+    default:
+      return formatObject(entries, sep);
+  }
+}
+
+// src/generate/consts.ts
+var DEFAULT_LIGHT_THEME_LIGHTNESS = 0.7;
+var DEFAULT_DARK_THEME_LIGHTNESS = 0.6;
+
+// src/generate/utils.ts
+var FOREGROUND_DARK_L_VALUE = 0.97;
+var FOREGROUND_LIGHT_L_VALUE = 0.1;
+var FOREGROUND_MAX_CHROMA = 0.01;
+var FALLBACK_STRONG_DELTA_DARK = 0.05;
+var FALLBACK_STRONG_DELTA_LIGHT = -0.05;
+var FALLBACK_WEAK_DELTA_DARK = -0.05;
+var FALLBACK_WEAK_DELTA_LIGHT = 0.05;
+var VARIANT_DELTA = 0.1;
+var CONTRAST_MARGIN = 0.15;
+function resolveContrastRatio(value) {
+  if (value === void 0 || value === "AAA") return 7;
+  if (value === "AA") return 4.5;
+  return value;
+}
+function clampHueShift(hueShift, totalVariants) {
+  if (totalVariants <= 0) return hueShift;
+  const max = 360 / (totalVariants + 1);
+  const sign = Math.sign(hueShift);
+  return sign * Math.min(Math.abs(hueShift), max);
+}
+function wrapHue(h) {
+  return (h % 360 + 360) % 360;
+}
+function expandColorToScale(color, themeType, options) {
+  const {
+    baselineLValueDark,
+    baselineLValueLight,
+    minContrastRatio: minContrastRatioOption,
+    foregroundLValueDark = FOREGROUND_DARK_L_VALUE,
+    foregroundLValueLight = FOREGROUND_LIGHT_L_VALUE,
+    foregroundMaxChroma: foregroundMaxChromaOption = FOREGROUND_MAX_CHROMA,
+    strongDeltaDark,
+    strongDeltaLight,
+    weakDeltaDark,
+    weakDeltaLight
+  } = options ?? {};
+  const themeAdjustments = themeType === "light" ? options?.light : options?.dark;
+  const foregroundMaxChroma = themeAdjustments?.foregroundMaxChroma ?? foregroundMaxChromaOption;
+  const minContrast = resolveContrastRatio(
+    themeAdjustments?.minContrastRatio ?? minContrastRatioOption
+  );
+  const contrastTarget = minContrast + CONTRAST_MARGIN;
+  const hasExplicitDeltas = strongDeltaDark !== void 0 || strongDeltaLight !== void 0 || weakDeltaDark !== void 0 || weakDeltaLight !== void 0;
+  const themeLightness = resolveThemeLightness(themeType, options);
+  const colorOKLCH = convert(color, "oklch");
+  const maxChroma = themeType === "light" ? options?.light?.maxChroma : options?.dark?.maxChroma;
+  const normalizedColorOKLCH = {
+    ...colorOKLCH,
+    l: themeType === "light" ? baselineLValueLight ?? themeLightness : baselineLValueDark ?? themeLightness,
+    c: maxChroma !== void 0 ? Math.min(colorOKLCH.c, maxChroma) : colorOKLCH.c
+  };
+  const candidates = [foregroundLValueLight, foregroundLValueDark].map((l) => ({
+    ...normalizedColorOKLCH,
+    l,
+    c: Math.min(normalizedColorOKLCH.c, foregroundMaxChroma)
+  }));
+  const [candidateA, candidateB] = themeType === "light" ? candidates : [...candidates].reverse();
+  const contrastA = calculateContrast(normalizedColorOKLCH, candidateA);
+  const contrastB = calculateContrast(normalizedColorOKLCH, candidateB);
+  const [preferred, fallback] = contrastA >= contrastB ? [candidateA, candidateB] : [candidateB, candidateA];
+  let foregroundColorOKLCH = calculateContrast(normalizedColorOKLCH, preferred) > minContrast ? preferred : fallback;
+  if (calculateContrast(normalizedColorOKLCH, foregroundColorOKLCH) < contrastTarget) {
+    const direction = preferred.l < normalizedColorOKLCH.l ? 1 : -1;
+    let lo = direction === 1 ? normalizedColorOKLCH.l : 0;
+    let hi = direction === 1 ? 1 : normalizedColorOKLCH.l;
+    for (let i = 0; i < 20; i++) {
+      const mid = (lo + hi) / 2;
+      const testColor = { ...normalizedColorOKLCH, l: mid };
+      if (calculateContrast(testColor, preferred) > contrastTarget) {
+        if (direction === 1) hi = mid;
+        else lo = mid;
+      } else {
+        if (direction === 1) lo = mid;
+        else hi = mid;
+      }
+    }
+    normalizedColorOKLCH.l = (lo + hi) / 2;
+    foregroundColorOKLCH = preferred;
+  }
+  let strongColorOKLCH;
+  let weakColorOKLCH;
+  if (hasExplicitDeltas) {
+    const sd = themeType === "light" ? strongDeltaLight ?? FALLBACK_STRONG_DELTA_LIGHT : strongDeltaDark ?? FALLBACK_STRONG_DELTA_DARK;
+    const wd = themeType === "light" ? weakDeltaLight ?? FALLBACK_WEAK_DELTA_LIGHT : weakDeltaDark ?? FALLBACK_WEAK_DELTA_DARK;
+    strongColorOKLCH = {
+      ...normalizedColorOKLCH,
+      l: normalizedColorOKLCH.l + sd
+    };
+    weakColorOKLCH = {
+      ...normalizedColorOKLCH,
+      l: normalizedColorOKLCH.l + wd
+    };
+  } else {
+    const contrastDirection = themeType === "light" ? -1 : 1;
+    let boundaryL = findContrastBoundaryLightness(
+      normalizedColorOKLCH,
+      foregroundColorOKLCH,
+      contrastTarget
+    );
+    let distToBoundary = boundaryL !== null ? Math.abs(normalizedColorOKLCH.l - boundaryL) : 0;
+    if (distToBoundary < VARIANT_DELTA) {
+      const shift = Math.min(VARIANT_DELTA - distToBoundary, VARIANT_DELTA / 2);
+      const awayFromForeground = foregroundColorOKLCH.l < normalizedColorOKLCH.l ? 1 : -1;
+      normalizedColorOKLCH.l = Math.max(
+        0,
+        Math.min(1, normalizedColorOKLCH.l + shift * awayFromForeground)
+      );
+      boundaryL = findContrastBoundaryLightness(
+        normalizedColorOKLCH,
+        foregroundColorOKLCH,
+        contrastTarget
+      );
+      distToBoundary = boundaryL !== null ? Math.abs(normalizedColorOKLCH.l - boundaryL) : 0;
+    }
+    const strongDelta = Math.min(VARIANT_DELTA, distToBoundary);
+    const weakCandidate = normalizedColorOKLCH.l - VARIANT_DELTA * contrastDirection;
+    const weakCandidateColor = { ...normalizedColorOKLCH, l: weakCandidate };
+    const weakContrast = calculateContrast(
+      weakCandidateColor,
+      foregroundColorOKLCH
+    );
+    let weakDelta = VARIANT_DELTA;
+    if (weakContrast < contrastTarget) {
+      let lo = 0;
+      let hi = VARIANT_DELTA;
+      for (let i = 0; i < 20; i++) {
+        const mid = (lo + hi) / 2;
+        const testL = normalizedColorOKLCH.l - mid * contrastDirection;
+        const testColor = { ...normalizedColorOKLCH, l: testL };
+        if (calculateContrast(testColor, foregroundColorOKLCH) > contrastTarget) {
+          lo = mid;
+        } else {
+          hi = mid;
+        }
+      }
+      weakDelta = lo;
+    }
+    strongColorOKLCH = {
+      ...normalizedColorOKLCH,
+      l: Math.max(
+        0,
+        Math.min(1, normalizedColorOKLCH.l + strongDelta * contrastDirection)
+      )
+    };
+    weakColorOKLCH = {
+      ...normalizedColorOKLCH,
+      l: Math.max(
+        0,
+        Math.min(1, normalizedColorOKLCH.l - weakDelta * contrastDirection)
+      )
+    };
+  }
+  const rawHueShift = options?.hueShift ?? 0;
+  if (rawHueShift !== 0) {
+    const clamped = clampHueShift(rawHueShift, 2);
+    strongColorOKLCH = {
+      ...strongColorOKLCH,
+      h: wrapHue(strongColorOKLCH.h + clamped)
+    };
+    weakColorOKLCH = {
+      ...weakColorOKLCH,
+      h: wrapHue(weakColorOKLCH.h - clamped)
+    };
+    strongColorOKLCH = ensureContrast(
+      strongColorOKLCH,
+      foregroundColorOKLCH,
+      contrastTarget
+    );
+    weakColorOKLCH = ensureContrast(
+      weakColorOKLCH,
+      foregroundColorOKLCH,
+      contrastTarget
+    );
+  }
+  return {
+    DEFAULT: { ...normalizedColorOKLCH },
+    strong: { ...strongColorOKLCH },
+    weak: { ...weakColorOKLCH },
+    foreground: { ...foregroundColorOKLCH }
+  };
+}
+var LIGHT_THEME_LIGHTNESS_RANGE = [0.4, 0.99];
+var DARK_THEME_LIGHTNESS_RANGE = [0.2, 0.8];
+function resolveThemeLightness(themeType, options) {
+  const themeAdjustments = themeType === "light" ? options?.light : options?.dark;
+  const range = themeType === "light" ? LIGHT_THEME_LIGHTNESS_RANGE : DARK_THEME_LIGHTNESS_RANGE;
+  if (themeAdjustments?.lightness !== void 0) {
+    return Math.min(Math.max(themeAdjustments.lightness, range[0]), range[1]);
+  }
+  return themeType === "light" ? DEFAULT_LIGHT_THEME_LIGHTNESS : DEFAULT_DARK_THEME_LIGHTNESS;
+}
+function findContrastBoundaryLightness(defaultColor, foregroundColor, targetContrast = 7) {
+  const defaultOKLCH = convert(defaultColor, "oklch");
+  const foregroundOKLCH = convert(foregroundColor, "oklch");
+  const defaultContrast = calculateContrast(defaultColor, foregroundColor);
+  if (defaultContrast <= targetContrast) {
+    return null;
+  }
+  const { r: fr, g: fg, b: fb } = convert(foregroundColor, "linear-rgb");
+  const foregroundLuminance = 0.2126 * fr + 0.7152 * fg + 0.0722 * fb;
+  let tLo = 0;
+  let tHi = 1;
+  for (let i = 0; i < 20; i++) {
+    const tMid = (tLo + tHi) / 2;
+    const l = defaultOKLCH.l + tMid * (foregroundOKLCH.l - defaultOKLCH.l);
+    const testColor = { ...defaultOKLCH, l };
+    const { r, g, b } = convert(testColor, "linear-rgb");
+    const testLuminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+    const lighter = Math.max(testLuminance, foregroundLuminance);
+    const darker = Math.min(testLuminance, foregroundLuminance);
+    const contrast = (lighter + 0.05) / (darker + 0.05);
+    if (contrast > targetContrast) {
+      tLo = tMid;
+    } else {
+      tHi = tMid;
+    }
+  }
+  return defaultOKLCH.l + (tLo + tHi) / 2 * (foregroundOKLCH.l - defaultOKLCH.l);
+}
+function ensureContrast(variant, foreground, target) {
+  if (calculateContrast(variant, foreground) >= target) return variant;
+  const direction = foreground.l < variant.l ? 1 : -1;
+  let lo = direction === 1 ? variant.l : 0;
+  let hi = direction === 1 ? 1 : variant.l;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const test = { ...variant, l: mid };
+    if (calculateContrast(test, foreground) >= target) {
+      if (direction === 1) hi = mid;
+      else lo = mid;
+    } else {
+      if (direction === 1) lo = mid;
+      else hi = mid;
+    }
+  }
+  return { ...variant, l: (lo + hi) / 2 };
+}
+function calculateContrast(colorA, colorB) {
+  const luminance = (color) => {
+    const { r, g, b } = convert(color, "linear-rgb");
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  };
+  const L1 = luminance(colorA);
+  const L2 = luminance(colorB);
+  const lighter = Math.max(L1, L2);
+  const darker = Math.min(L1, L2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+// src/generate/generateAccent.ts
+function generateAccent(accent, themeType, options) {
+  const invertBaseAndAccent = themeType === "dark" && options?.invertDarkModeBaseAccent;
+  if (invertBaseAndAccent) {
+    const accentOklch = convert(accent, "oklch");
+    const baseHueShift = options?.baseHueShift ?? 0;
+    let baseOklch = options?.baseColor ? convert(parse(options.baseColor), "oklch") : convert(accent, "oklch");
+    if (baseHueShift !== 0 && !options?.baseColor) {
+      baseOklch = {
+        ...baseOklch,
+        h: wrapHue(accentOklch.h + baseHueShift)
+      };
+    }
+    const maxChroma = options?.dark?.maxChroma;
+    const invertedAccent = {
+      ...baseOklch,
+      c: maxChroma !== void 0 ? Math.min(accentOklch.c, maxChroma) : accentOklch.c
+    };
+    return expandColorToScale(invertedAccent, themeType, options);
+  }
+  return expandColorToScale(accent, themeType, options);
+}
+
+// src/generate/generateBase.ts
+var BASELINE_DARK_L_VALUE = 0.2;
+var BASELINE_LIGHT_L_VALUE = 0.97;
+var BASELINE_MAX_CHROMA = 0.01;
+var STRONG_DELTA_DARK = -0.1;
+var STRONG_DELTA_LIGHT = 0.02;
+var WEAK_DELTA_DARK = 0.1;
+var WEAK_DELTA_LIGHT = -0.03;
+function generateBase(color, themeType, options) {
+  const invertBaseAndAccent = themeType === "dark" && options?.invertDarkModeBaseAccent;
+  const preferredBaseColorInput = invertBaseAndAccent ? color ?? options?.baseColor : options?.baseColor ?? color;
+  const themeAdjustments = themeType === "light" ? options?.light : options?.dark;
+  const baselineMaxChroma = themeAdjustments?.baseMaxChroma ?? options?.baseMaxChroma ?? BASELINE_MAX_CHROMA;
+  const preferredBaseColor = convert(parse(preferredBaseColorInput), "oklch");
+  let baseHue = preferredBaseColor.h;
+  const baseChroma = Math.min(preferredBaseColor.c, baselineMaxChroma);
+  const baseHueShift = options?.baseHueShift ?? 0;
+  if (baseHueShift !== 0 && !options?.baseColor && !invertBaseAndAccent) {
+    baseHue = wrapHue(convert(color, "oklch").h + baseHueShift);
+  }
+  const normalizedPreferredBaseColor = {
+    ...preferredBaseColor,
+    h: baseHue,
+    c: baseChroma,
+    l: themeType === "light" ? BASELINE_LIGHT_L_VALUE : BASELINE_DARK_L_VALUE
+  };
+  return expandColorToScale(normalizedPreferredBaseColor, themeType, {
+    baselineLValueDark: BASELINE_DARK_L_VALUE,
+    baselineLValueLight: BASELINE_LIGHT_L_VALUE,
+    strongDeltaDark: STRONG_DELTA_DARK,
+    strongDeltaLight: STRONG_DELTA_LIGHT,
+    weakDeltaDark: WEAK_DELTA_DARK,
+    weakDeltaLight: WEAK_DELTA_LIGHT,
+    minContrastRatio: options?.minContrastRatio,
+    hueShift: options?.hueShift,
+    foregroundMaxChroma: options?.foregroundMaxChroma,
+    light: options?.light,
+    dark: options?.dark
+  });
+}
+
+// src/generate/generateSemanticColors.ts
+var POSITIVE_RANGE = [135, 160];
+var NEGATIVE_RANGE = [5, 25];
+var WARNING_RANGE = [45, 65];
+function generateSemanticColors(color, themeType, options) {
+  const positiveBaseColor = parse(
+    options?.semanticColors?.positive ?? _determineBaseColorFromRange(
+      color,
+      options?.semanticColorRanges?.positive ?? POSITIVE_RANGE,
+      { includeInputAsCandidate: true }
+    )
+  );
+  const negativeBaseColor = parse(
+    options?.semanticColors?.negative ?? _determineBaseColorFromRange(
+      color,
+      options?.semanticColorRanges?.negative ?? NEGATIVE_RANGE
+    )
+  );
+  const warningBaseColor = parse(
+    options?.semanticColors?.warning ?? _determineBaseColorFromRange(
+      color,
+      options?.semanticColorRanges?.warning ?? WARNING_RANGE
+    )
+  );
+  const scaleOptions = {
+    light: options?.light,
+    dark: options?.dark,
+    minContrastRatio: options?.minContrastRatio,
+    hueShift: options?.hueShift,
+    foregroundMaxChroma: options?.foregroundMaxChroma
+  };
+  const positiveColorScale = expandColorToScale(
+    positiveBaseColor,
+    themeType,
+    scaleOptions
+  );
+  const negativeColorScale = expandColorToScale(
+    negativeBaseColor,
+    themeType,
+    scaleOptions
+  );
+  const warningColorScale = expandColorToScale(
+    warningBaseColor,
+    themeType,
+    scaleOptions
+  );
+  return {
+    positive: positiveColorScale,
+    negative: negativeColorScale,
+    warning: warningColorScale
+  };
+}
+function _determineBaseColorFromRange(color, range, options) {
+  const complementaryColor = _getComplementaryColor(color);
+  const splitComplementaryColors = _getSplitComplementaryColors(complementaryColor);
+  const targetColors = [
+    ...options?.includeInputAsCandidate ? [color] : [],
+    complementaryColor,
+    ...splitComplementaryColors
+  ];
+  for (const targetColor of targetColors) {
+    const h = convert(targetColor, "oklch").h;
+    const arc = (range[1] - range[0] + 360) % 360;
+    const dist = (h - range[0] + 360) % 360;
+    const inRange = dist <= arc;
+    if (inRange) {
+      return convert({ ...convert(color, "oklch"), l: 0.5, h }, "oklch");
+    }
+  }
+  const candidate1 = convert(
+    { ...convert(color, "oklch"), l: 0.5, h: range[0] },
+    "oklch"
+  );
+  const candidate2 = convert(
+    { ...convert(color, "oklch"), l: 0.5, h: range[1] },
+    "oklch"
+  );
+  const dist1 = Math.min(
+    ...targetColors.map((t) => _hueDistance(range[0], convert(t, "oklch").h))
+  );
+  const dist2 = Math.min(
+    ...targetColors.map((t) => _hueDistance(range[1], convert(t, "oklch").h))
+  );
+  return dist1 < dist2 ? candidate1 : candidate2;
+}
+function _hueDistance(a, b) {
+  const diff = Math.abs(a - b);
+  return Math.min(diff, 360 - diff);
+}
+function _getComplementaryColor(color) {
+  const colorOKLCH = convert(color, "oklch");
+  return convert({ ...colorOKLCH, h: (colorOKLCH.h + 180) % 360 }, "srgb");
+}
+function _getSplitComplementaryColors(color) {
+  const colorOKLCH = convert(color, "oklch");
+  return [
+    convert({ ...colorOKLCH, h: (colorOKLCH.h + 150) % 360 }, "srgb"),
+    convert({ ...colorOKLCH, h: (colorOKLCH.h + 210) % 360 }, "srgb")
+  ];
+}
+
+// src/generate/generate.ts
+function generate(color, themeType, options) {
+  return {
+    base: generateBase(color, themeType, options),
+    accent: generateAccent(color, themeType, options),
+    ...generateSemanticColors(color, themeType, options)
+  };
+}
+
+// src/HextimatePaletteBuilder.ts
+var HextimatePaletteBuilder = class _HextimatePaletteBuilder {
+  lightPalette;
+  darkPalette;
+  inputColor;
+  options;
+  operations = [];
+  standaloneTokens = [];
+  weakSideVariants = ["weak"];
+  strongSideVariants = ["strong"];
+  betweenVariants = [];
+  presetFormatDefaults;
+  constructor(color, options) {
+    this.inputColor = color;
+    this.options = options ?? {};
+    this.lightPalette = generate(color, "light", options);
+    this.darkPalette = generate(color, "dark", options);
+    this.applyToken("brand-exact", color);
+    const colorOKLCH = convert(color, "oklch");
+    const lightFg = { ...colorOKLCH, l: 0.97, c: Math.min(colorOKLCH.c, 0.01) };
+    const darkFg = { ...colorOKLCH, l: 0.1, c: Math.min(colorOKLCH.c, 0.01) };
+    const brandForeground = calculateContrast(color, lightFg) >= calculateContrast(color, darkFg) ? lightFg : darkFg;
+    this.applyToken("brand-exact-foreground", brandForeground);
+  }
+  /**
+   * Adds a custom role with given name and color.
+   * The color is expanded into a full scale and added to both light and dark palettes.
+   *
+   * The color can be a direct color value or a derived token referencing an existing role.
+   *
+   * e.g. `addRole('cta', '#ff0066')` adds a "cta" role with the specified hue as the base.
+   * `addRole('cta', { from: 'accent', hue: 180 })` adds a "cta" role with a complementary hue to accent.
+   *
+   * @param name Role name (e.g. "cta", "banner")
+   * @param color Base color or derived token for the role
+   */
+  addRole(name, color) {
+    this.operations.push({ method: "addRole", args: [name, color] });
+    this.applyRole(name, color);
+    return this;
+  }
+  /**
+   * Adds a variant to all roles, derived from an existing variant or placed between two variants.
+   *
+   * e.g. `addVariant('placeholder', { from: 'weak' })` adds a "placeholder" variant one step past "weak" across all roles and themes.
+   * `addVariant('highlight', { between: ['DEFAULT', 'strong'] })` adds a "highlight" variant that is exactly between "DEFAULT" and "strong" across all roles and themes.
+   *
+   * @param name Variant name (e.g. "placeholder", "highlight")
+   * @param placement Placement of the variant, either `{ from: 'weak' }` or `{ between: ['DEFAULT', 'strong'] }`
+   */
+  addVariant(name, placement) {
+    this.operations.push({ method: "addVariant", args: [name, placement] });
+    this.applyVariant(name, placement);
+    return this;
+  }
+  /**
+   * Adds a standalone/one-off token that doesn't fit the role+variant structure.
+   * The value can be a direct color, a derived token based on an existing role+variant, or an object specifying different values for light and dark themes.
+   *
+   * e.g. `addToken('brand', '#3a86ff')` adds a "brand" token with the specified color in both themes.
+   * `addToken('brand', { light: '#3a86ff', dark: '#ff0066' })` adds a "brand" token with different colors in light and dark themes.
+   *
+   * It can also be used to override specific tokens after generation.
+   * `addToken('base-strong', '#ff0066')` overrides the automatically generated "base-strong" variant with a custom color.
+   *
+   * @param name Token name (e.g. "brand", "logo")
+   * @param value Token value, which can be an exact color, or derived from an existing role+variant.
+   */
+  addToken(name, value) {
+    this.operations.push({ method: "addToken", args: [name, value] });
+    this.applyToken(name, value);
+    return this;
+  }
+  /**
+   * Applies a preset that configures roles, tokens, and format defaults
+   * for a specific framework or convention (e.g. shadcn/ui).
+   *
+   * Preset format defaults are used as a base in `.format()` — any options
+   * you pass to `.format()` will override the preset's defaults.
+   *
+   * @example
+   * import { hextimate, presets } from 'hextimator';
+   *
+   * const theme = hextimate('#6366F1')
+   *   .preset(presets.shadcn)
+   *   .format();
+   *
+   * // Override preset's color format:
+   * const theme = hextimate('#6366F1')
+   *   .preset(presets.shadcn)
+   *   .format({ colors: 'hsl-raw' });
+   */
+  preset(preset) {
+    this.operations.push({ method: "preset", args: [preset] });
+    if (preset.generation) {
+      const userOptions = { ...this.options };
+      Object.assign(this.options, preset.generation, userOptions);
+      this.lightPalette = generate(
+        this.inputColor,
+        "light",
+        this.resolvedOptions()
+      );
+      this.darkPalette = generate(
+        this.inputColor,
+        "dark",
+        this.resolvedOptions()
+      );
+    }
+    for (const role of preset.roles ?? []) {
+      this.applyRole(role.name, role.color);
+    }
+    for (const variant of preset.variants ?? []) {
+      this.applyVariant(variant.name, variant.placement);
+    }
+    for (const token of preset.tokens ?? []) {
+      this.applyToken(token.name, token.value);
+    }
+    if (preset.format) {
+      this.presetFormatDefaults = {
+        ...this.presetFormatDefaults,
+        ...preset.format,
+        roleNames: {
+          ...this.presetFormatDefaults?.roleNames,
+          ...preset.format.roleNames
+        },
+        variantNames: {
+          ...this.presetFormatDefaults?.variantNames,
+          ...preset.format.variantNames
+        }
+      };
+    }
+    return this;
+  }
+  /**
+   *
+   * Simulates how the palette would look for a given type and severity of CVD.
+   * This is a destructive operation that permanently alters the palette, but can be useful for testing and previewing.
+   *
+   * It should not be used to generate the final output for users with CVD. For that, use `adaptFor` instead.
+   *
+   * e.g. `simulate('deuteranopia', 0.5)` simulates moderate deuteranopia, allowing you to see how the colors would appear to users with that condition.
+   * @param type Type of CVD to simulate (e.g. "protanopia", "deuteranopia", "tritanopia")
+   * @param severity Severity of the CVD simulation, from 0 (no effect) to 1 (full simulation). Defaults to 1 for a complete simulation.
+   */
+  simulate(type, severity = 1) {
+    this.operations.push({ method: "simulate", args: [type, severity] });
+    this.lightPalette = simulatePalette(this.lightPalette, type, severity);
+    this.darkPalette = simulatePalette(this.darkPalette, type, severity);
+    return this;
+  }
+  /**
+   * Adapts the palette for a given type and severity of CVD,
+   * altering the colors to improve accessibility while maintaining as much of the original intent as possible.
+   *
+   * To preview how the original palette would appear to users with CVD, use `simulate`.
+   *
+   * A typical use case would be to generate a normal palette, then fork it and adapt the fork for CVD.
+   * Then you can also preview by chaining `adaptFor` and `simulate`
+   *
+   * e.g.
+   * ```ts
+   * const normalTheme = hextimate('#ff6600');
+   * const cvdTheme = normalTheme.fork().adaptFor('deuteranopia');
+   * const simulatedCVD = normalTheme.fork().simulate('deuteranopia');
+   * ````
+   *
+   * @param type Type of CVD to adapt for (e.g. "protanopia", "deuteranopia", "tritanopia")
+   * @param severity Severity of the CVD adaptation, from 0 (no change) to 1 (full adaptation). Defaults to 1 for a complete adaptation.
+   */
+  adaptFor(type, severity = 1) {
+    this.operations.push({ method: "adaptFor", args: [type, severity] });
+    this.lightPalette = adaptPalette(this.lightPalette, type, severity);
+    this.darkPalette = adaptPalette(this.darkPalette, type, severity);
+    return this;
+  }
+  /**
+   * Creates a new builder instance with the same operations history, allowing you to generate a related palette with a different base color or options.
+   *
+   * e.g. `fork('#ff6677')` creates a new builder with the same
+   * roles, variants, tokens, and adjustments, but based on a different input color.
+   *
+   * `fork({ light: { lightness: 0.8 } })` creates a new builder with the same color but different light theme adjustments.
+   *
+   * @param colorOrOptions Either a new base color for the palette, or an object with new generation options to override (e.g. light/dark adjustments, hue shift, contrast ratio).
+   * @param maybeOptions If the first argument is a color, this can be an optional second argument with generation options to override.
+   * @returns A new builder instance with the same operations history but different base color and/or options.
+   */
+  fork(colorOrOptions, maybeOptions) {
+    let newColor;
+    let newOptions;
+    if (maybeOptions !== void 0) {
+      newColor = parse(colorOrOptions);
+      newOptions = {
+        ...this.options,
+        ...maybeOptions
+      };
+    } else if (colorOrOptions !== void 0 && typeof colorOrOptions === "object" && !Array.isArray(colorOrOptions) && !("space" in colorOrOptions)) {
+      newColor = this.inputColor;
+      newOptions = {
+        ...this.options,
+        ...colorOrOptions
+      };
+    } else if (colorOrOptions !== void 0) {
+      newColor = parse(colorOrOptions);
+      newOptions = { ...this.options };
+    } else {
+      newColor = this.inputColor;
+      newOptions = { ...this.options };
+    }
+    const builder = new _HextimatePaletteBuilder(newColor, newOptions);
+    for (const op of this.operations) {
+      switch (op.method) {
+        case "addRole":
+          builder.addRole(...op.args);
+          break;
+        case "addVariant":
+          builder.addVariant(...op.args);
+          break;
+        case "addToken":
+          builder.addToken(...op.args);
+          break;
+        case "simulate":
+          builder.simulate(...op.args);
+          break;
+        case "adaptFor":
+          builder.adaptFor(...op.args);
+          break;
+        case "preset":
+          builder.preset(...op.args);
+          break;
+      }
+    }
+    return builder;
+  }
+  format(options) {
+    const mergedOptions = this.presetFormatDefaults ? {
+      ...this.presetFormatDefaults,
+      ...options,
+      roleNames: {
+        ...this.presetFormatDefaults.roleNames,
+        ...options?.roleNames
+      },
+      variantNames: {
+        ...this.presetFormatDefaults.variantNames,
+        ...options?.variantNames
+      }
+    } : options;
+    const colorFormat = mergedOptions?.colors ?? "hex";
+    const lightTokens = this.resolveStandaloneTokens(
+      "light",
+      this.lightPalette,
+      colorFormat
+    );
+    const darkTokens = this.resolveStandaloneTokens(
+      "dark",
+      this.darkPalette,
+      colorFormat
+    );
+    return {
+      light: format(this.lightPalette, mergedOptions, lightTokens),
+      dark: format(this.darkPalette, mergedOptions, darkTokens)
+    };
+  }
+  applyRole(name, color) {
+    const parsedColor = this.isDerivedToken(color) ? this.resolveDerivedToken(color, this.lightPalette, "light") : parse(color);
+    const opts = this.resolvedOptions();
+    this.lightPalette[name] = expandColorToScale(parsedColor, "light", {
+      light: opts.light,
+      dark: opts.dark,
+      minContrastRatio: opts.minContrastRatio,
+      hueShift: opts.hueShift
+    });
+    this.darkPalette[name] = expandColorToScale(parsedColor, "dark", {
+      light: opts.light,
+      dark: opts.dark,
+      minContrastRatio: opts.minContrastRatio,
+      hueShift: opts.hueShift
+    });
+  }
+  applyVariant(name, placement) {
+    if ("from" in placement) {
+      const edge = placement.from;
+      for (const palette of [this.lightPalette, this.darkPalette]) {
+        for (const role of Object.keys(palette)) {
+          const scale = palette[role];
+          scale[name] = this.computeBeyondVariant(scale, edge);
+        }
+      }
+      const sideVariants = this.getSideVariantsFor(edge);
+      if (sideVariants) {
+        sideVariants.push(name);
+        this.redistributeAllScales(sideVariants);
+        this.recomputeBetweenVariants();
+      }
+      if (placement.chroma || placement.hue) {
+        for (const palette of [this.lightPalette, this.darkPalette]) {
+          for (const role of Object.keys(palette)) {
+            const scale = palette[role];
+            const oklch = convert(parse(scale[name]), "oklch");
+            scale[name] = {
+              ...oklch,
+              c: Math.max(0, oklch.c + (placement.chroma ?? 0)),
+              h: wrapHue(oklch.h + (placement.hue ?? 0))
+            };
+          }
+        }
+      }
+    } else {
+      this.betweenVariants.push({ name, refs: placement.between });
+      for (const palette of [this.lightPalette, this.darkPalette]) {
+        for (const role of Object.keys(palette)) {
+          const scale = palette[role];
+          scale[name] = this.computeBetweenVariant(
+            scale,
+            placement.between[0],
+            placement.between[1]
+          );
+        }
+      }
+    }
+  }
+  applyToken(name, value) {
+    this.standaloneTokens.push({ name, value });
+  }
+  resolveStandaloneTokens(themeType, palette, colorFormat) {
+    return this.standaloneTokens.map(({ name, value }) => {
+      const color = this.resolveTokenValue(value, themeType, palette);
+      return {
+        role: name,
+        variant: "DEFAULT",
+        isDefault: true,
+        value: serializeColor(color, colorFormat ?? "hex")
+      };
+    });
+  }
+  resolveTokenValue(value, themeType, palette) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && "light" in value && "dark" in value) {
+      const themeValue = themeType === "light" ? value.light : value.dark;
+      return this.resolveTokenSingle(themeValue, palette, themeType);
+    }
+    return this.resolveTokenSingle(
+      value,
+      palette,
+      themeType
+    );
+  }
+  resolveTokenSingle(value, palette, themeType) {
+    if (this.isDerivedToken(value)) {
+      return this.resolveDerivedToken(value, palette, themeType);
+    }
+    return parse(value);
+  }
+  isDerivedToken(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && "from" in value;
+  }
+  resolveDerivedToken(token, palette, themeType, resolving) {
+    const [role, variant = "DEFAULT"] = token.from.split(".");
+    const scale = palette[role];
+    let sourceColor;
+    if (scale) {
+      sourceColor = scale[variant];
+      if (!sourceColor) {
+        throw new Error(
+          `Unknown variant "${variant}" in token reference "${token.from}"`
+        );
+      }
+    } else {
+      const standalone = this.standaloneTokens.find((t) => t.name === role);
+      if (!standalone) {
+        throw new Error(
+          `Unknown role "${role}" in token reference "${token.from}"`
+        );
+      }
+      const seen = resolving ?? /* @__PURE__ */ new Set();
+      if (seen.has(role)) {
+        throw new Error(`Circular token reference detected: "${token.from}"`);
+      }
+      seen.add(role);
+      sourceColor = this.resolveTokenValueWithChain(
+        standalone.value,
+        themeType,
+        palette,
+        seen
+      );
+    }
+    const oklch = convert(parse(sourceColor), "oklch");
+    let emphasisOffset = 0;
+    if (token.emphasis) {
+      const contrastDirection = themeType === "light" ? -1 : 1;
+      emphasisOffset = token.emphasis * contrastDirection;
+    }
+    return {
+      ...oklch,
+      l: Math.max(
+        0,
+        Math.min(1, oklch.l + (token.lightness ?? 0) + emphasisOffset)
+      ),
+      c: Math.max(0, oklch.c + (token.chroma ?? 0)),
+      h: wrapHue(oklch.h + (token.hue ?? 0))
+    };
+  }
+  resolveTokenValueWithChain(value, themeType, palette, resolving) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value) && "light" in value && "dark" in value) {
+      const themeValue = themeType === "light" ? value.light : value.dark;
+      return this.resolveTokenSingleWithChain(
+        themeValue,
+        palette,
+        themeType,
+        resolving
+      );
+    }
+    return this.resolveTokenSingleWithChain(
+      value,
+      palette,
+      themeType,
+      resolving
+    );
+  }
+  resolveTokenSingleWithChain(value, palette, themeType, resolving) {
+    if (this.isDerivedToken(value)) {
+      return this.resolveDerivedToken(value, palette, themeType, resolving);
+    }
+    return parse(value);
+  }
+  getSideVariantsFor(variantName) {
+    if (this.weakSideVariants.includes(variantName)) {
+      return this.weakSideVariants;
+    }
+    if (this.strongSideVariants.includes(variantName)) {
+      return this.strongSideVariants;
+    }
+    const sampleRole = Object.keys(this.lightPalette).find((r) => r !== "base");
+    if (!sampleRole) return null;
+    const scale = this.lightPalette[sampleRole];
+    if (!scale[variantName]) return null;
+    const defaultOKLCH = convert(parse(scale.DEFAULT), "oklch");
+    const edgeOKLCH = convert(parse(scale[variantName]), "oklch");
+    const foregroundOKLCH = convert(parse(scale.foreground), "oklch");
+    const isTowardForeground = Math.sign(edgeOKLCH.l - defaultOKLCH.l) === Math.sign(foregroundOKLCH.l - defaultOKLCH.l);
+    return isTowardForeground ? this.strongSideVariants : this.weakSideVariants;
+  }
+  redistributeAllScales(sideVariants) {
+    const isStrongSide = sideVariants === this.strongSideVariants;
+    const totalVariants = this.weakSideVariants.length + this.strongSideVariants.length;
+    const rawShift = this.options.hueShift ?? 0;
+    const clampedShift = clampHueShift(rawShift, totalVariants);
+    const hueShiftPerStep = isStrongSide ? clampedShift : -clampedShift;
+    const contrastTarget = resolveContrastRatio(this.options.minContrastRatio) + 0.15;
+    for (const role of Object.keys(this.lightPalette)) {
+      for (const [palette, themeType] of [
+        [this.lightPalette, "light"],
+        [this.darkPalette, "dark"]
+      ]) {
+        const scale = palette[role];
+        const defaultOKLCH = convert(parse(scale.DEFAULT), "oklch");
+        const foregroundOKLCH = convert(parse(scale.foreground), "oklch");
+        const existingVariant = sideVariants.find((v) => scale[v]);
+        let sideDirection;
+        if (existingVariant) {
+          const existingL = convert(parse(scale[existingVariant]), "oklch").l;
+          sideDirection = Math.sign(existingL - defaultOKLCH.l) || (themeType === "light" ? 1 : -1);
+        } else {
+          const contrastDirection = themeType === "light" ? -1 : 1;
+          sideDirection = isStrongSide ? contrastDirection : -contrastDirection;
+        }
+        const foregroundDirection = Math.sign(
+          foregroundOKLCH.l - defaultOKLCH.l
+        );
+        const isTowardForeground = sideDirection === foregroundDirection;
+        let outermostDelta = 0;
+        for (const v of sideVariants) {
+          if (!scale[v]) continue;
+          const vL = convert(parse(scale[v]), "oklch").l;
+          const d = Math.abs(vL - defaultOKLCH.l);
+          if (d > outermostDelta) outermostDelta = d;
+        }
+        let maxDelta;
+        if (isTowardForeground) {
+          const boundaryL = findContrastBoundaryLightness(
+            parse(scale.DEFAULT),
+            parse(scale.foreground),
+            contrastTarget
+          );
+          const boundaryDelta = boundaryL !== null ? Math.abs(defaultOKLCH.l - boundaryL) : 0;
+          maxDelta = Math.min(outermostDelta, boundaryDelta);
+        } else {
+          const gamutBound = sideDirection > 0 ? 1 : 0;
+          const boundaryDelta = Math.min(
+            Math.abs(gamutBound - defaultOKLCH.l),
+            0.2
+          );
+          maxDelta = Math.min(outermostDelta, boundaryDelta);
+        }
+        this.redistributeVariants(
+          scale,
+          sideVariants,
+          defaultOKLCH,
+          maxDelta * sideDirection,
+          hueShiftPerStep,
+          foregroundOKLCH,
+          contrastTarget
+        );
+      }
+    }
+  }
+  /**
+   * Distributes variants evenly between DEFAULT and the lightness boundary.
+   * Uses (i+1)/(n+1) spacing so variants never sit exactly at the boundary,
+   * preserving AAA contrast margin.
+   */
+  redistributeVariants(scale, sideVariants, defaultOKLCH, totalDelta, hueShiftPerStep = 0, foregroundOKLCH, contrastTarget) {
+    if (sideVariants.length < 1) return;
+    const sourceChroma = Math.max(
+      ...Object.entries(scale).filter(([k]) => k !== "foreground").map(([, v]) => convert(parse(v), "oklch").c)
+    );
+    const n = sideVariants.length;
+    const sorted = [...sideVariants].sort((a, b) => {
+      const aL = Math.abs(convert(parse(scale[a]), "oklch").l - defaultOKLCH.l);
+      const bL = Math.abs(convert(parse(scale[b]), "oklch").l - defaultOKLCH.l);
+      return aL - bL;
+    });
+    for (let i = 0; i < n; i++) {
+      const variantName = sorted[i];
+      let newL = defaultOKLCH.l + (i + 1) / (n + 1) * totalDelta;
+      const newH = wrapHue(defaultOKLCH.h + hueShiftPerStep * (i + 1));
+      let variant = {
+        ...defaultOKLCH,
+        l: Math.max(0, Math.min(1, newL)),
+        c: sourceChroma,
+        h: newH
+      };
+      if (hueShiftPerStep !== 0 && foregroundOKLCH && contrastTarget && calculateContrast(variant, foregroundOKLCH) < contrastTarget) {
+        const direction = foregroundOKLCH.l < variant.l ? 1 : -1;
+        let lo = direction === 1 ? variant.l : 0;
+        let hi = direction === 1 ? 1 : variant.l;
+        for (let j = 0; j < 20; j++) {
+          const mid = (lo + hi) / 2;
+          const test = { ...variant, l: mid };
+          if (calculateContrast(test, foregroundOKLCH) >= contrastTarget) {
+            if (direction === 1) hi = mid;
+            else lo = mid;
+          } else {
+            if (direction === 1) lo = mid;
+            else hi = mid;
+          }
+        }
+        newL = (lo + hi) / 2;
+        variant = { ...variant, l: Math.max(0, Math.min(1, newL)) };
+      }
+      scale[variantName] = variant;
+    }
+  }
+  recomputeBetweenVariants() {
+    for (const bv of this.betweenVariants) {
+      for (const palette of [this.lightPalette, this.darkPalette]) {
+        for (const role of Object.keys(palette)) {
+          const scale = palette[role];
+          scale[bv.name] = this.computeBetweenVariant(
+            scale,
+            bv.refs[0],
+            bv.refs[1]
+          );
+        }
+      }
+    }
+  }
+  computeBeyondVariant(scale, edge) {
+    const edgeColor = convert(parse(scale[edge]), "oklch");
+    const defaultColor = convert(parse(scale.DEFAULT), "oklch");
+    const delta = edgeColor.l - defaultColor.l;
+    const newL = Math.max(0, Math.min(1, edgeColor.l + delta));
+    return { ...edgeColor, l: newL };
+  }
+  computeBetweenVariant(scale, variantA, variantB) {
+    const colorA = convert(parse(scale[variantA]), "oklch");
+    const colorB = convert(parse(scale[variantB]), "oklch");
+    const midL = (colorA.l + colorB.l) / 2;
+    const midC = (colorA.c + colorB.c) / 2;
+    const hueDiff = (colorB.h - colorA.h + 540) % 360 - 180;
+    const midH = wrapHue(colorA.h + hueDiff / 2);
+    return { ...colorA, l: midL, c: midC, h: midH };
+  }
+  resolvedOptions() {
+    return { ...this.options };
+  }
+};
+
+// src/presets/demo.ts
+var demo = {
+  generation: {
+    minContrastRatio: "AA",
+    baseHueShift: 180,
+    baseMaxChroma: 0.025,
+    hueShift: 10,
+    light: { lightness: 0.55, maxChroma: 0.14 },
+    dark: { lightness: 0.35, maxChroma: 0.12 }
+  },
+  roles: [
+    { name: "cta", color: "#ff006e" },
+    { name: "info", color: "#3a86ff" }
+  ],
+  variants: [
+    { name: "muted", placement: { from: "weak" } },
+    { name: "vivid", placement: { from: "strong" } }
+  ],
+  tokens: [
+    { name: "surface", value: { from: "base.weak" } },
+    { name: "surface-raised", value: { from: "base", emphasis: -0.04 } },
+    { name: "border", value: { from: "base", emphasis: 0.1 } },
+    { name: "border-subtle", value: { from: "base", emphasis: 0.05 } },
+    { name: "ring", value: { from: "accent" } },
+    { name: "cta-ring", value: { from: "cta", chroma: -0.05 } }
+  ],
+  format: {
+    as: "css",
+    colors: "hex",
+    roleNames: {
+      base: "bg",
+      accent: "brand",
+      positive: "success",
+      negative: "danger"
+    },
+    variantNames: {
+      foreground: "text"
+    }
+  }
+};
+
+// src/presets/mui.ts
+var mui = {
+  roles: [
+    { name: "info", color: "#0288d1" },
+    { name: "secondary", color: { from: "accent", hue: 180 } }
+  ],
+  tokens: [
+    // background
+    { name: "background-default", value: { from: "base" } },
+    {
+      name: "background-paper",
+      value: { from: "base", emphasis: -0.025 }
+    },
+    // text
+    { name: "text-primary", value: { from: "base.foreground" } },
+    {
+      name: "text-secondary",
+      value: { from: "base.foreground", emphasis: -0.2 }
+    },
+    {
+      name: "text-disabled",
+      value: { from: "base.foreground", emphasis: -0.4 }
+    },
+    // divider
+    { name: "divider", value: { from: "base", emphasis: 0.12 } },
+    // action tokens
+    { name: "action-hover", value: { from: "base", emphasis: 0.04 } },
+    { name: "action-selected", value: { from: "base", emphasis: 0.08 } },
+    { name: "action-disabled", value: { from: "base", emphasis: 0.15 } },
+    {
+      name: "action-disabledBackground",
+      value: { from: "base", emphasis: 0.06 }
+    },
+    { name: "action-focus", value: { from: "base", emphasis: 0.06 } }
+  ],
+  format: {
+    as: "object",
+    colors: "hex",
+    separator: "-",
+    roleNames: {
+      accent: "primary",
+      negative: "error",
+      positive: "success"
+    },
+    variantNames: {
+      DEFAULT: "main",
+      weak: "light",
+      strong: "dark",
+      foreground: "contrastText"
+    }
+  }
+};
+
+// src/presets/shadcn.ts
+var shadcn = {
+  tokens: [
+    // shadcn uses bare --foreground (not --background-foreground)
+    { name: "foreground", value: { from: "base.foreground" } },
+    // card / popover — same as background
+    { name: "card", value: { from: "base" } },
+    { name: "card-foreground", value: { from: "base.foreground" } },
+    { name: "popover", value: { from: "base" } },
+    { name: "popover-foreground", value: { from: "base.foreground" } },
+    // secondary — subtle contrast from background
+    { name: "secondary", value: { from: "base" } },
+    { name: "secondary-foreground", value: { from: "base.foreground" } },
+    // muted — similar to secondary, but with dimmer foreground
+    { name: "muted", value: { from: "base" } },
+    {
+      name: "muted-foreground",
+      value: {
+        from: "base.foreground",
+        emphasis: -0.25
+      }
+    },
+    // accent (shadcn meaning: subtle hover highlight, not the brand color)
+    { name: "accent", value: { from: "base" } },
+    { name: "accent-foreground", value: { from: "base.foreground" } },
+    // border / input
+    {
+      name: "border",
+      value: { from: "base", emphasis: 0.8 }
+    },
+    {
+      name: "input",
+      value: {
+        from: "base",
+        emphasis: 0.8
+      }
+    },
+    // ring — uses the brand/primary color
+    { name: "ring", value: { from: "accent" } },
+    // chart tokens colors use brand/priamry color
+    { name: "chart-1", value: { from: "accent" } },
+    { name: "chart-2", value: { from: "chart-1", emphasis: -0.04 } },
+    { name: "chart-3", value: { from: "chart-2", emphasis: -0.04 } },
+    { name: "chart-4", value: { from: "chart-3", emphasis: -0.04 } },
+    { name: "chart-5", value: { from: "chart-4", emphasis: -0.04 } }
+  ],
+  format: {
+    as: "css",
+    colors: "oklch",
+    roleNames: {
+      base: "background",
+      accent: "primary",
+      negative: "destructive",
+      positive: "success"
+    },
+    variantNames: {
+      foreground: "foreground"
+    }
+  }
+};
+
+// src/index.ts
+var HextimateError = class extends Error {
+  constructor(input, message) {
+    super(message ?? `Failed to hextimate color:  ${String(input)}`);
+    this.input = input;
+    this.name = "HextimateError";
+  }
+};
+function hextimate(color, options) {
+  try {
+    const parsedColor = parse(color);
+    return new HextimatePaletteBuilder(parsedColor, options);
+  } catch (e) {
+    if (e instanceof HextimateError) {
+      throw e;
+    }
+    throw new HextimateError(
+      color,
+      e instanceof Error ? e.message : "Unknown error"
+    );
+  }
+}
+
+// src/cli.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_VERSION = JSON.parse(
+  readFileSync(join(__dirname, "..", "package.json"), "utf8")
+).version;
+var AVAILABLE_PRESETS = {
+  shadcn,
+  mui,
+  demo
+};
+var HELP = `
+hextimator <color> [options]
+
+Generate a perceptually uniform color palette from a single color.
+
+Arguments:
+  color                       Input color (quote hex values: '#ff6600')
+
+Presets:
+  -p, --preset <name>         Apply a preset: shadcn, mui, demo
+                              Preset format defaults can be overridden with -f, -c, etc.
+
+Format options:
+  -f, --format <type>         css | object | tailwind | tailwind-css | scss | json  (default: css)
+  -c, --colors <type>         hex | rgb | hsl | oklch | p3 and -raw variants        (default: hex)
+  -t, --theme <type>          light | dark | both                                   (default: both)
+      --separator <char>      Token separator                                       (default: -)
+
+Generation options:
+      --base-color <color>    Override base/neutral color
+      --base-hue-shift <deg>  Rotate base hue relative to accent
+      --hue-shift <deg>       Per-variant hue shift in degrees
+      --base-max-chroma <n>   Max chroma for base colors          (default: 0.01)
+      --fg-max-chroma <n>     Max chroma for foreground colors     (default: 0.01)
+      --light-lightness <n>   Light theme lightness 0-1            (default: 0.7)
+      --light-max-chroma <n>  Light theme max chroma
+      --dark-lightness <n>    Dark theme lightness 0-1             (default: 0.6)
+      --dark-max-chroma <n>   Dark theme max chroma
+      --min-contrast <value>  AAA | AA | <number>                  (default: AAA)
+      --invert-dark           Swap base/accent hues in dark mode   (requires --base-color)
+
+Semantic colors:
+      --positive <color>      Override positive/success color      (default: auto green)
+      --negative <color>      Override negative/error color        (default: auto red)
+      --warning <color>       Override warning color               (default: auto amber)
+
+CVD (color vision deficiency):
+      --simulate <type>       Simulate CVD: protanopia | deuteranopia | tritanopia | achromatopsia
+      --adapt <type>          Adapt palette for CVD type
+      --cvd-severity <n>      CVD severity 0-1                     (default: 1)
+
+Roles & variants (repeatable):
+      --role <name>=<color>   Add a custom role
+      --variant <spec>        from:    "name:from:edge"
+                              between: "name:between:a,b"
+
+Output:
+  -o, --output <path>         Write to file instead of stdout
+  -h, --help                  Show this help
+  -v, --version               Show version
+
+Examples:
+  hextimator '#ff6600'
+  hextimator '#ff6600' --format tailwind-css --colors oklch
+  hextimator '#3366cc' --format json --theme light
+  hextimator '#6366F1' --preset shadcn
+  hextimator '#6366F1' --preset shadcn --colors hsl-raw
+  hextimator '#22aa44' --role cta=#ee2244 --variant hover:from:strong -o theme.css
+  hextimator '#6A5ACD' --base-color '#FEBA5D' --invert-dark
+  hextimator '#ff6600' --simulate deuteranopia
+  hextimator '#ff6600' --adapt deuteranopia --cvd-severity 0.8
+`.trim();
+function run() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      preset: { type: "string", short: "p" },
+      format: { type: "string", short: "f" },
+      colors: { type: "string", short: "c" },
+      theme: { type: "string", short: "t", default: "both" },
+      separator: { type: "string" },
+      "base-color": { type: "string" },
+      "base-hue-shift": { type: "string" },
+      "hue-shift": { type: "string" },
+      "base-max-chroma": { type: "string" },
+      "fg-max-chroma": { type: "string" },
+      "light-lightness": { type: "string" },
+      "light-max-chroma": { type: "string" },
+      "dark-lightness": { type: "string" },
+      "dark-max-chroma": { type: "string" },
+      "min-contrast": { type: "string" },
+      "invert-dark": { type: "boolean" },
+      positive: { type: "string" },
+      negative: { type: "string" },
+      warning: { type: "string" },
+      simulate: { type: "string" },
+      adapt: { type: "string" },
+      "cvd-severity": { type: "string" },
+      role: { type: "string", multiple: true },
+      variant: { type: "string", multiple: true },
+      output: { type: "string", short: "o" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  if (values.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (values.version) {
+    console.log(PKG_VERSION);
+    process.exit(0);
+  }
+  const color = positionals[0];
+  if (!color) {
+    console.error("Error: missing color argument. Run with --help for usage.");
+    process.exit(1);
+  }
+  const generationOptions = {};
+  if (values["base-color"]) generationOptions.baseColor = values["base-color"];
+  if (values["base-hue-shift"])
+    generationOptions.baseHueShift = Number(values["base-hue-shift"]);
+  if (values["hue-shift"])
+    generationOptions.hueShift = Number(values["hue-shift"]);
+  if (values["base-max-chroma"])
+    generationOptions.baseMaxChroma = Number(values["base-max-chroma"]);
+  if (values["fg-max-chroma"])
+    generationOptions.foregroundMaxChroma = Number(values["fg-max-chroma"]);
+  if (values["light-lightness"] || values["light-max-chroma"]) {
+    generationOptions.light = {};
+    if (values["light-lightness"])
+      generationOptions.light.lightness = Number(values["light-lightness"]);
+    if (values["light-max-chroma"])
+      generationOptions.light.maxChroma = Number(values["light-max-chroma"]);
+  }
+  if (values["dark-lightness"] || values["dark-max-chroma"]) {
+    generationOptions.dark = {};
+    if (values["dark-lightness"])
+      generationOptions.dark.lightness = Number(values["dark-lightness"]);
+    if (values["dark-max-chroma"])
+      generationOptions.dark.maxChroma = Number(values["dark-max-chroma"]);
+  }
+  if (values["min-contrast"]) {
+    const mc = values["min-contrast"];
+    if (mc === "AAA" || mc === "AA") {
+      generationOptions.minContrastRatio = mc;
+    } else {
+      generationOptions.minContrastRatio = Number(mc);
+    }
+  }
+  if (values["invert-dark"]) {
+    generationOptions.invertDarkModeBaseAccent = true;
+  }
+  const semanticColors = {};
+  if (values.positive) semanticColors.positive = values.positive;
+  if (values.negative) semanticColors.negative = values.negative;
+  if (values.warning) semanticColors.warning = values.warning;
+  if (Object.keys(semanticColors).length > 0) {
+    generationOptions.semanticColors = semanticColors;
+  }
+  const builder = hextimate(color, generationOptions);
+  if (values.preset) {
+    const preset = AVAILABLE_PRESETS[values.preset];
+    if (!preset) {
+      console.error(
+        `Error: unknown preset "${values.preset}". Available: ${Object.keys(AVAILABLE_PRESETS).join(", ")}`
+      );
+      process.exit(1);
+    }
+    builder.preset(preset);
+  }
+  if (values.role) {
+    for (const r of values.role) {
+      const eq = r.indexOf("=");
+      if (eq === -1) {
+        console.error(
+          `Error: invalid --role "${r}". Expected format: name=color`
+        );
+        process.exit(1);
+      }
+      builder.addRole(r.slice(0, eq), r.slice(eq + 1));
+    }
+  }
+  if (values.variant) {
+    for (const v of values.variant) {
+      const parts = v.split(":");
+      if (parts.length < 3) {
+        console.error(
+          `Error: invalid --variant "${v}". Expected "name:from:edge" or "name:between:a,b"`
+        );
+        process.exit(1);
+      }
+      const [name, type, ref] = parts;
+      if (type === "from") {
+        builder.addVariant(name, { from: ref });
+      } else if (type === "between") {
+        const refs = ref.split(",");
+        if (refs.length !== 2) {
+          console.error(
+            `Error: invalid --variant between spec "${v}". Expected "name:between:a,b"`
+          );
+          process.exit(1);
+        }
+        builder.addVariant(name, { between: [refs[0], refs[1]] });
+      } else {
+        console.error(
+          `Error: invalid --variant type "${type}". Expected "from" or "between"`
+        );
+        process.exit(1);
+      }
+    }
+  }
+  const cvdSeverity = values["cvd-severity"] ? Number(values["cvd-severity"]) : 1;
+  if (values.simulate) {
+    builder.simulate(
+      values.simulate,
+      cvdSeverity
+    );
+  }
+  if (values.adapt) {
+    builder.adaptFor(
+      values.adapt,
+      cvdSeverity
+    );
+  }
+  const hasPreset = !!values.preset;
+  const formatOptions = {};
+  if (values.format) {
+    formatOptions.as = values.format;
+  } else if (!hasPreset) {
+    formatOptions.as = "css";
+  }
+  if (values.colors) {
+    formatOptions.colors = values.colors;
+  } else if (!hasPreset) {
+    formatOptions.colors = "hex";
+  }
+  if (values.separator) {
+    formatOptions.separator = values.separator;
+  } else if (!hasPreset) {
+    formatOptions.separator = "-";
+  }
+  const result = builder.format(formatOptions);
+  const themeFilter = values.theme;
+  let output;
+  if (themeFilter === "light") {
+    output = serialize(result.light);
+  } else if (themeFilter === "dark") {
+    output = serialize(result.dark);
+  } else {
+    output = serialize({ light: result.light, dark: result.dark });
+  }
+  if (values.output) {
+    writeFileSync(values.output, `${output}
+`);
+  } else {
+    console.log(output);
+  }
+}
+function serialize(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2);
+}
+try {
+  run();
+} catch (err) {
+  console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+}