@weasel-js/theme 1.5.2 → 1.6.0

package/dist/chunk-GI7ZAXIB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dtcg/axesExtension.ts","../src/dtcg/types.ts"],"names":[],"mappings":";AAGO,IAAM,QAAA,GAAW;AAwBjB,SAAS,WAAA,CAAY,MAAgB,SAAA,EAA8B;AACxE,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,CACpB,MAAA,CAAO,CAAC,CAAA,KAAM,SAAA,CAAU,CAAC,CAAA,KAAM,MAAA,IAAa,SAAA,CAAU,CAAC,CAAA,KAAM,IAAA,CAAK,CAAC,CAAA,CAAE,OAAO,CAAA,CAC5E,GAAA,CAAI,CAAC,MAAM,CAAA,EAAG,CAAC,CAAA,CAAA,EAAI,SAAA,CAAU,CAAC,CAAC,CAAA,CAAE,CAAA,CACjC,KAAK,GAAG,CAAA;AACb;;;AC/BO,IAAM,SAAA,GAAY","file":"chunk-GI7ZAXIB.js","sourcesContent":["import type { AxisDefs, Selection } from '../axes';\n\n/** The `$extensions` key on a DTCG export's root that carries every axis besides mode. */\nexport const AXES_EXT = 'com.weasel.axes';\n\n/** The token groups of one layer: plain values, and values per mode. */\nexport interface DtcgLayer {\n  readonly primitives: Record<string, Record<string, unknown>>;\n  readonly modes: Record<string, Record<string, Record<string, unknown>>>;\n}\n\n/**\n * What `toDTCG` writes under `$extensions[\"com.weasel.axes\"]`.\n *\n * - `axes`: every axis the theme resolves with, mode included.\n * - `varies`: token name → the non-mode axes its value depends on.\n * - `overrides`: a layer per combination of non-default values, keyed like\n *   `selectionKey` but naming only the axes off their default\n *   (`density=compact`, `contrast=high,density=roomy` in axis order).\n */\nexport interface DtcgAxesExtension {\n  readonly axes: AxisDefs;\n  readonly varies: Record<string, readonly string[]>;\n  readonly overrides: Record<string, DtcgLayer>;\n}\n\n/** The override key for a selection: its non-default values, axes in declaration order. `''` is the plain groups. */\nexport function overrideKey(axes: AxisDefs, selection: Selection): string {\n  return Object.keys(axes)\n    .filter((a) => selection[a] !== undefined && selection[a] !== axes[a].default)\n    .map((a) => `${a}=${selection[a]}`)\n    .join(',');\n}\n","/** The one `$extensions` key this kit defines. */\nexport const ALPHA_EXT = 'com.weasel.alpha';\n\nexport type TokenValue = string | number | readonly (string | number)[];\n\n/**\n * A single design token as authored, before aliases are resolved: a DTCG-shaped\n * `{ type, value }` pair where `value` may still be a `{ref}` to another token.\n */\nexport interface RawToken {\n  readonly type: string;\n  readonly value: TokenValue;\n  /** Render the referenced color at this alpha, 0–1. */\n  readonly alpha?: number | undefined;\n  readonly description?: string | undefined;\n}\n\n/** A token graph flattened to one level, keyed by token name (no `--wzl-`\n *  prefix). Still unresolved — see `ResolvedTokenMap` for the output side. */\nexport type FlatTokens = Record<string, RawToken>;\n\n/** A resolved theme: every token name mapped to its final CSS-ready string.\n *  Named ...Map, not ...Tokens, to stay distinct from hud's public `ResolvedTokens`. */\nexport type ResolvedTokenMap = Record<string, string>;\n"]}

package/dist/chunk-QKRFHBRB.js

@@ -0,0 +1,557 @@
+import { hexToOklchDeg, oklchDegToHex, srgbU8ToOklab } from '@weasel-js/paint';
+
+// src/axes.ts
+function isByAxis(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && typeof v.by === "string";
+}
+function fullSelection(axes, selection = {}) {
+  const out = {};
+  for (const [name, def] of Object.entries(axes)) {
+    const v = selection[name];
+    out[name] = v !== void 0 && v in def.values ? v : def.default;
+  }
+  return out;
+}
+function mergeAxes(parent, child) {
+  const out = { ...parent };
+  for (const [name, def] of Object.entries(child)) {
+    out[name] = { ...def, values: { ...parent[name]?.values, ...def.values } };
+  }
+  return out;
+}
+function enumerateSelections(axes) {
+  let out = [{}];
+  for (const [name, def] of Object.entries(axes)) {
+    out = out.flatMap((s) => Object.keys(def.values).map((v) => ({ ...s, [name]: v })));
+  }
+  return out;
+}
+function selectionKey(axes, selection) {
+  const full = fullSelection(axes, selection);
+  return Object.keys(axes).map((a) => `${a}=${full[a]}`).join(",");
+}
+function pick(v, selection) {
+  let cur = v;
+  while (isByAxis(cur)) {
+    const axis = cur.by;
+    const value = selection[axis];
+    if (value === void 0 || value === "by" || !(value in cur)) return { ok: false, axis, value: value ?? "" };
+    cur = cur[value];
+  }
+  return { ok: true, value: cur };
+}
+function pickAll(record, selection) {
+  const out = {};
+  for (const [name, v] of Object.entries(record)) {
+    const picked = pick(v, selection);
+    if (picked.ok) out[name] = picked.value;
+  }
+  return out;
+}
+
+// src/dtcg/value.ts
+function fontStack(value) {
+  return value.map((f) => typeof f === "string" && /\s/.test(f) ? `'${f}'` : String(f)).join(", ");
+}
+function serializeTokenValue(type, value) {
+  if (Array.isArray(value)) {
+    if (type === "cubicBezier") return `cubic-bezier(${value.join(", ")})`;
+    if (type === "fontFamily") return fontStack(value);
+    return value.join(", ");
+  }
+  return String(value);
+}
+var BEZIER = /^cubic-bezier\(\s*([^)]*)\)$/i;
+function parseTokenValue(type, text) {
+  const raw = text.trim();
+  if (type === "cubicBezier") {
+    const inner = BEZIER.exec(raw)?.[1] ?? raw;
+    const parts = inner.split(",").map((p) => Number(p.trim()));
+    return parts.length === 4 && parts.every((n) => Number.isFinite(n)) ? parts : raw;
+  }
+  if (type === "fontFamily") {
+    const families = raw.split(",").map((f) => f.trim().replace(/^['"]|['"]$/g, "").trim()).filter((f) => f !== "");
+    return families.length > 0 ? families : raw;
+  }
+  return raw;
+}
+
+// src/dtcg/color.ts
+function withAlpha(color, alpha) {
+  const rgba = parseRgba(color.trim());
+  if (!rgba) return `color-mix(in srgb, ${color.trim()} ${round(alpha * 100, 4)}%, transparent)`;
+  const [r, g, b, a] = rgba;
+  return `rgba(${r}, ${g}, ${b}, ${round(a * alpha, 3)})`;
+}
+function round(n, places) {
+  return Number(n.toFixed(places));
+}
+function parseRgba(s) {
+  if (s.toLowerCase() === "transparent") return [0, 0, 0, 0];
+  return parseHex(s) ?? parseRgbFn(s);
+}
+function parseHex(s) {
+  const m = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(s);
+  if (!m) return null;
+  const body = m[1];
+  const full = body.length <= 4 ? body.replace(/./g, (c) => c + c) : body;
+  const byte = (i) => Number.parseInt(full.slice(i, i + 2), 16);
+  return [byte(0), byte(2), byte(4), full.length === 8 ? byte(6) / 255 : 1];
+}
+function parseRgbFn(s) {
+  const m = /^rgba?\(([^()]*)\)$/i.exec(s);
+  if (!m) return null;
+  const [channels, alphaPart, extra] = m[1].split("/");
+  if (extra !== void 0) return null;
+  const parts = channels.trim().split(/\s*,\s*|\s+/);
+  if (alphaPart !== void 0) parts.push(alphaPart.trim());
+  if (parts.length !== 3 && parts.length !== 4) return null;
+  const channel = (p) => p.endsWith("%") ? Number.parseFloat(p) / 100 * 255 : Number(p);
+  const alpha = (p) => p.endsWith("%") ? Number.parseFloat(p) / 100 : Number(p);
+  const [r, g, b] = parts.slice(0, 3).map(channel);
+  const a = parts[3] === void 0 ? 1 : alpha(parts[3]);
+  if (![r, g, b, a].every(Number.isFinite)) return null;
+  return [Math.round(r), Math.round(g), Math.round(b), a];
+}
+
+// src/dtcg/resolve.ts
+var REF = /^\{([^}]+)\}$/;
+function refTarget(value) {
+  if (typeof value !== "string") return null;
+  const m = REF.exec(value.trim());
+  if (!m) return null;
+  const path = m[1];
+  const dot = path.indexOf(".");
+  return dot === -1 ? path : path.slice(dot + 1);
+}
+function resolveTokens(tokens) {
+  const out = {};
+  const inProgress = /* @__PURE__ */ new Set();
+  const resolveOne = (name) => {
+    const cached = out[name];
+    if (cached !== void 0) return cached;
+    const token = tokens[name];
+    if (!token) throw new Error(`Unknown token "${name}"`);
+    if (inProgress.has(name)) {
+      throw new Error(`Reference cycle at token "${name}" (${[...inProgress].join(" \u2192 ")})`);
+    }
+    inProgress.add(name);
+    const target = refTarget(token.value);
+    let value;
+    if (target === null) {
+      value = serializeTokenValue(token.type, token.value);
+    } else if (!tokens[target]) {
+      throw new Error(`Token "${name}" references "${target}", which is not defined`);
+    } else {
+      value = resolveOne(target);
+    }
+    if (token.alpha !== void 0) value = withAlpha(value, token.alpha);
+    inProgress.delete(name);
+    out[name] = value;
+    return value;
+  };
+  for (const name of Object.keys(tokens)) resolveOne(name);
+  return out;
+}
+
+// src/resolveTheme.ts
+function themeChain(theme) {
+  const out = [];
+  for (let t = theme; t; t = t.extends) out.unshift(t);
+  return out;
+}
+function themeAxes(theme) {
+  return themeChain(theme).reduce((axes, t) => mergeAxes(axes, t.axes), {});
+}
+function resolveTheme(theme, selection = {}) {
+  const sel = fullSelection(themeAxes(theme), selection);
+  let merged = {};
+  for (const t of themeChain(theme)) merged = { ...merged, ...pickAll(t.tokens, sel) };
+  const out = {};
+  for (const [name, value] of Object.entries(resolveTokens(merged))) out[`--wzl-${name}`] = value;
+  return out;
+}
+function hexToRgb(hex) {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+var toHex = oklchDegToHex;
+var toLch = hexToOklchDeg;
+function chromaCap(L, H) {
+  return toLch(toHex(L, 0.5, H)).C;
+}
+function luminance(hex) {
+  const [r, g, b] = hexToRgb(hex).map((v) => v / 255);
+  const f = (u) => u <= 0.04045 ? u / 12.92 : ((u + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * f(r) + 0.7152 * f(g) + 0.0722 * f(b);
+}
+function contrast(a, b) {
+  const [hi, lo] = [luminance(a), luminance(b)].sort((p, q) => q - p);
+  return (hi + 0.05) / (lo + 0.05);
+}
+function hueGap(a, b) {
+  const d = Math.abs(a - b) % 360;
+  return Math.min(d, 360 - d);
+}
+function toLab(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return srgbU8ToOklab(r, g, b);
+}
+var CHROMA_WEIGHT = 3;
+function deltaE(a, b) {
+  const [l1, a1, b1] = toLab(a);
+  const [l2, a2, b2] = toLab(b);
+  return Math.hypot(l1 - l2, CHROMA_WEIGHT * (a1 - a2), CHROMA_WEIGHT * (b1 - b2));
+}
+function vividAt(L, H) {
+  return toHex(L, chromaCap(L, H), H);
+}
+
+// src/engine/color/generate.ts
+function peakLightness(H) {
+  let bestL = 0.5;
+  let bestC = -1;
+  for (let L = 0.32; L <= 0.96; L += 0.01) {
+    const c = chromaCap(L, H);
+    if (c > bestC) {
+      bestC = c;
+      bestL = L;
+    }
+  }
+  return bestL;
+}
+var PEAK = [];
+for (let H = 0; H < 360; H += 1) PEAK.push(peakLightness(H));
+var peakAt = (H) => PEAK[(Math.round(H) % 360 + 360) % 360];
+function place(H, c) {
+  const L = peakAt(H) + (c.lightnessTarget - peakAt(H)) * c.lightnessPull;
+  return toHex(L, chromaCap(L, H) * c.chromaFraction, H);
+}
+var HUE_NAMES = [
+  [15, "rose"],
+  [45, "red"],
+  [62, "orange"],
+  [85, "amber"],
+  [100, "gold"],
+  [122, "yellow"],
+  [138, "lime"],
+  [165, "green"],
+  [195, "teal"],
+  [218, "cyan"],
+  [245, "sky"],
+  [275, "blue"],
+  [310, "violet"],
+  [345, "fuchsia"]
+];
+function hueName(H) {
+  for (const [ceil, name] of HUE_NAMES) if (H < ceil) return name;
+  return "rose";
+}
+function uniqueNames(hues) {
+  const seen = /* @__PURE__ */ new Map();
+  return hues.map((h) => {
+    const base = hueName(h);
+    const n = (seen.get(base) ?? 0) + 1;
+    seen.set(base, n);
+    return n === 1 ? base : `${base}-${n}`;
+  });
+}
+function equalizeChroma(hexes, k, anchored) {
+  if (k <= 0) return hexes;
+  const lch = hexes.map(toLch);
+  const target = lch.reduce((sum, x) => sum + x.C, 0) / lch.length;
+  return lch.map((x, i) => {
+    const wanted = x.C + (target - x.C) * k;
+    if (anchored[i]) return toHex(x.L, Math.min(wanted, chromaCap(x.L, x.H)), x.H);
+    if (chromaCap(x.L, x.H) >= wanted) return toHex(x.L, wanted, x.H);
+    let bestL = x.L;
+    let bestDistance = Infinity;
+    for (let L = 0.3; L <= 0.96; L += 5e-3) {
+      if (chromaCap(L, x.H) >= wanted) {
+        const d = Math.abs(L - x.L);
+        if (d < bestDistance) {
+          bestDistance = d;
+          bestL = L;
+        }
+      }
+    }
+    if (bestDistance === Infinity) {
+      const pk = peakAt(x.H);
+      return toHex(pk, chromaCap(pk, x.H), x.H);
+    }
+    return toHex(bestL, wanted, x.H);
+  });
+}
+function farthestFirst(hues) {
+  const order = [0];
+  while (order.length < hues.length) {
+    let best = -1;
+    let bestGap = -1;
+    for (let i = 0; i < hues.length; i += 1) {
+      if (order.includes(i)) continue;
+      const gap = Math.min(...order.map((j) => hueGap(hues[i], hues[j])));
+      if (gap > bestGap) {
+        bestGap = gap;
+        best = i;
+      }
+    }
+    order.push(best);
+  }
+  return order;
+}
+function floorDegrees(c) {
+  return c.hueFloor <= 0 ? 0 : c.hueFloor * 360 / Math.max(1, c.count);
+}
+function searchHues(c) {
+  const minGapDeg = floorDegrees(c);
+  const anchorHues = c.anchors.map((a) => a.hue);
+  const anchorHexes = c.anchors.map(toHexPreview);
+  const freeCount = c.count - c.anchors.length;
+  if (freeCount < 0) return null;
+  if (freeCount === 0) return [];
+  const weighted = (hex) => {
+    const [L, a, b] = toLab(hex);
+    return [L, CHROMA_WEIGHT * a, CHROMA_WEIGHT * b];
+  };
+  const between = (p, q) => Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+  const placed = /* @__PURE__ */ new Map();
+  const at = (H) => {
+    const key = (Math.round(H) % 360 + 360) % 360;
+    let v = placed.get(key);
+    if (!v) {
+      const hex = place(key, c);
+      const lch = toLch(hex);
+      v = {
+        hex,
+        hue: lch.H,
+        contrast: contrast(hex, c.surface),
+        chroma: lch.C,
+        surfaceDistance: deltaE(hex, c.surface),
+        lab: weighted(hex)
+      };
+      placed.set(key, v);
+    }
+    return v;
+  };
+  const anchorMeta = anchorHexes.map((hex) => {
+    const lch = toLch(hex);
+    return {
+      hex,
+      hue: lch.H,
+      contrast: contrast(hex, c.surface),
+      chroma: lch.C,
+      surfaceDistance: deltaE(hex, c.surface),
+      lab: weighted(hex)
+    };
+  });
+  const metaFor = (free) => [...anchorMeta, ...free.map(at)];
+  const penalty = (free) => {
+    const m = metaFor(free);
+    let p = 0;
+    if (minGapDeg > 0) {
+      for (let i = 0; i < m.length; i += 1) {
+        for (let j = i + 1; j < m.length; j += 1) {
+          const short = minGapDeg - hueGap(m[i].hue, m[j].hue);
+          if (short > 0) p += short;
+        }
+      }
+    }
+    if (c.minContrast > 0) {
+      for (const x of m) {
+        const short = c.minContrast - x.contrast;
+        if (short > 0) p += short * 40;
+      }
+    }
+    if (c.minSurfaceDistance > 0) {
+      for (const x of m) {
+        const short = c.minSurfaceDistance - x.surfaceDistance;
+        if (short > 0) p += short * 400;
+      }
+    }
+    if (c.minDistance > 0) {
+      for (let i = 0; i < m.length; i += 1) {
+        for (let j = i + 1; j < m.length; j += 1) {
+          const short = c.minDistance - between(m[i].lab, m[j].lab);
+          if (short > 0) p += short * 400;
+        }
+      }
+    }
+    return p;
+  };
+  const score = (free) => {
+    const m = metaFor(free);
+    return m.reduce((sum, x) => sum + x.chroma, 0) / m.length;
+  };
+  const seeds = [];
+  const seedStep = Math.max(6, Math.round(freeCount * 1.6));
+  for (let start = 0; start < 360; start += seedStep) {
+    seeds.push(Array.from({ length: freeCount }, (_, i) => Math.round((start + i * 360 / freeCount) % 360)));
+  }
+  if (anchorHues.length > 0) {
+    const base = anchorHues[0];
+    const span = 360 - 2 * Math.max(minGapDeg, 1);
+    for (let jitter = -8; jitter <= 8; jitter += 2) {
+      for (const divisor of [Math.max(1, freeCount - 1), freeCount]) {
+        seeds.push(
+          Array.from(
+            { length: freeCount },
+            (_, i) => Math.round(((base + minGapDeg + jitter + i * span / divisor) % 360 + 360) % 360)
+          )
+        );
+      }
+    }
+  }
+  const STEPS = [-16, -8, -4, -2, -1, 1, 2, 4, 8, 16];
+  const penaltyAt = (m, i) => {
+    let p = 0;
+    const x = m[i];
+    if (c.minContrast > 0) {
+      const short = c.minContrast - x.contrast;
+      if (short > 0) p += short * 40;
+    }
+    if (c.minSurfaceDistance > 0) {
+      const short = c.minSurfaceDistance - x.surfaceDistance;
+      if (short > 0) p += short * 400;
+    }
+    for (let j = 0; j < m.length; j += 1) {
+      if (j === i) continue;
+      if (minGapDeg > 0) {
+        const short = minGapDeg - hueGap(x.hue, m[j].hue);
+        if (short > 0) p += short;
+      }
+      if (c.minDistance > 0) {
+        const short = c.minDistance - between(x.lab, m[j].lab);
+        if (short > 0) p += short * 400;
+      }
+    }
+    return p;
+  };
+  const descend = (hues, useChroma, keepLegal) => {
+    const current = [...hues];
+    let meta = metaFor(current);
+    const offset = anchorMeta.length;
+    for (let iteration = 0; iteration < 120; iteration += 1) {
+      let improved = false;
+      for (let i = 0; i < freeCount; i += 1) {
+        const slot = offset + i;
+        const beforeP = penaltyAt(meta, slot);
+        const beforeC = meta[slot].chroma;
+        for (const delta of STEPS) {
+          const next = ((current[i] + delta) % 360 + 360) % 360;
+          if (next === current[i]) continue;
+          const candidate = at(next);
+          const trialMeta = meta.slice();
+          trialMeta[slot] = candidate;
+          const afterP = penaltyAt(trialMeta, slot);
+          const better = useChroma ? (keepLegal ? afterP <= beforeP : true) && candidate.chroma > beforeC : afterP < beforeP;
+          if (!better) continue;
+          if (keepLegal && afterP > beforeP) continue;
+          current[i] = next;
+          meta = trialMeta;
+          improved = true;
+          break;
+        }
+      }
+      if (!improved) break;
+    }
+    return current;
+  };
+  let best = null;
+  let bestScore = -1;
+  for (const seed of seeds) {
+    const repaired = penalty(seed) > 0 ? descend(seed, false, false) : seed;
+    if (penalty(repaired) > 0) continue;
+    const tuned = descend(repaired, true, true);
+    if (penalty(tuned) > 0) continue;
+    const s = score(tuned);
+    if (s > bestScore) {
+      bestScore = s;
+      best = tuned;
+    }
+  }
+  return best;
+}
+function pairwiseMin(hexes) {
+  if (hexes.length < 2) return 1;
+  let min = Infinity;
+  for (let i = 0; i < hexes.length; i += 1) {
+    for (let j = i + 1; j < hexes.length; j += 1) min = Math.min(min, deltaE(hexes[i], hexes[j]));
+  }
+  return min;
+}
+function summarize(swatches, surface) {
+  const cs = swatches.map((s) => s.lch.C);
+  const ls = swatches.map((s) => s.lch.L);
+  let gap = 360;
+  for (let i = 0; i < swatches.length; i += 1) {
+    for (let j = i + 1; j < swatches.length; j += 1) {
+      gap = Math.min(gap, hueGap(swatches[i].lch.H, swatches[j].lch.H));
+    }
+  }
+  return {
+    meanChroma: cs.reduce((a, b) => a + b, 0) / (cs.length || 1),
+    chromaSpread: Math.max(...cs) - Math.min(...cs),
+    lightnessSpread: Math.max(...ls) - Math.min(...ls),
+    minHueGap: swatches.length > 1 ? gap : 360,
+    hueFloorShare: swatches.length > 1 ? gap * swatches.length / 360 : 1,
+    minContrast: Math.min(...swatches.map((s) => contrast(s.hex, surface))),
+    minSurfaceDistance: Math.min(...swatches.map((s) => deltaE(s.hex, surface))),
+    minDistance: pairwiseMin(swatches.map((s) => s.hex))
+  };
+}
+function generate(c) {
+  const found = searchHues(c);
+  const feasible = found !== null;
+  const free = found ?? Array.from(
+    { length: Math.max(0, c.count - c.anchors.length) },
+    (_, i) => Math.round(i * 360 / Math.max(1, c.count - c.anchors.length))
+  );
+  const hues = [...c.anchors.map((a) => a.hue), ...free];
+  const anchoredFlags = [...c.anchors.map(() => true), ...free.map(() => false)];
+  const raw = [
+    ...c.anchors.map(toHexPreview),
+    ...free.map((h) => place(h, c))
+  ];
+  const hexes = equalizeChroma(raw, c.equalize, anchoredFlags);
+  const order = c.order === "farthest" ? farthestFirst(hues) : [...hues.keys()].sort((a, b) => hues[a] - hues[b]);
+  const names = uniqueNames(order.map((i) => toLch(hexes[i]).H));
+  const swatches = order.map((i, position) => ({
+    name: c.anchors[i]?.name ?? names[position],
+    hex: hexes[i],
+    lch: toLch(hexes[i]),
+    anchored: anchoredFlags[i],
+    contrast: contrast(hexes[i], c.surface)
+  }));
+  return { swatches, stats: summarize(swatches, c.surface), feasible };
+}
+var DEFAULT_CONSTRAINTS = {
+  count: 10,
+  hueFloor: 0.9,
+  minContrast: 4,
+  surface: "#181a1e",
+  lightnessTarget: 0.72,
+  lightnessPull: 0.4,
+  chromaFraction: 0.95,
+  equalize: 0,
+  minSurfaceDistance: 0.25,
+  minDistance: 0.22,
+  anchors: [],
+  order: "farthest"
+};
+function toHexPreview(a) {
+  const cap = chromaCap(a.lightness, a.hue);
+  return toHex(a.lightness, a.chroma === void 0 ? cap : Math.min(a.chroma, cap), a.hue);
+}
+function anchorFromHex(hex, name) {
+  const { L, C, H } = toLch(hex);
+  return {
+    name: name ?? hueName(H),
+    hue: Math.round(H),
+    lightness: Number(L.toFixed(3)),
+    chroma: Number(C.toFixed(4))
+  };
+}
+
+export { CHROMA_WEIGHT, DEFAULT_CONSTRAINTS, anchorFromHex, chromaCap, contrast, deltaE, enumerateSelections, floorDegrees, fullSelection, generate, hexToRgb, hueGap, hueName, isByAxis, luminance, mergeAxes, parseTokenValue, pick, pickAll, resolveTheme, resolveTokens, selectionKey, serializeTokenValue, themeAxes, themeChain, toHex, toHexPreview, toLab, toLch, vividAt };
+//# sourceMappingURL=chunk-QKRFHBRB.js.map
+//# sourceMappingURL=chunk-QKRFHBRB.js.map