@kitlangton/knobs 0.0.0-stage → 0.1.0

package/dist/dev/chunk-qtt698hp.js

@@ -0,0 +1,1118 @@
+var __chunkGraphs, __chunkSeen, __chunkNonce, __preload = (id, seenOnly) => {
+  for (var [base, graph, ids] of __chunkGraphs || [])
+    for (var stack = [id], g = globalThis, d = g.document, head, j, node, k, link;j = stack.pop(); )
+      if (!__chunkSeen[j] && (node = graph[j])) {
+        __chunkSeen[j] = 1;
+        for (k = 1;k < node.length; k++)
+          stack.push(ids[node[k]]);
+        if (!seenOnly && j !== id && (head = d && d.head)) {
+          if (__chunkNonce === void 0)
+            __chunkNonce = (k = d.querySelector("meta[property=csp-nonce]")) && (k.nonce || k.getAttribute("nonce")) || "";
+          if (link = d.createElement("link"), link.rel = "modulepreload", link.crossOrigin = "", __chunkNonce)
+            link.nonce = __chunkNonce;
+          link.href = new g.URL(node[0], base), head.appendChild(link);
+        }
+      }
+}, __chunks = (base, ids, nodes, entry) => {
+  for (var graph = {}, i = 0;i < ids.length; i++)
+    graph[ids[i]] = nodes[i];
+  (__chunkGraphs ||= []).push([base, graph, ids]), __chunkSeen ||= {}, __preload(ids[entry], 1);
+};
+
+// src/core/color.ts
+var round = (n, places) => Number(n.toFixed(places)), clamp01 = (n) => Math.min(1, Math.max(0, n)), gamma = (c) => c <= 0.0031308 ? 12.92 * c : 1.055 * c ** 0.4166666666666667 - 0.055, linear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function oklchToLinear({ l, c, h }) {
+  let a = c * Math.cos(h * Math.PI / 180), b = c * Math.sin(h * Math.PI / 180), l_ = (l + 0.3963377774 * a + 0.2158037573 * b) ** 3, m_ = (l - 0.1055613458 * a - 0.0638541728 * b) ** 3, s_ = (l - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    4.0767416621 * l_ - 3.3077115913 * m_ + 0.2309699292 * s_,
+    -1.2684380046 * l_ + 2.6097574011 * m_ - 0.3413193965 * s_,
+    -0.0041960863 * l_ - 0.7034186147 * m_ + 1.707614701 * s_
+  ];
+}
+var inGamut = (rgb) => rgb.every((v) => v >= -0.0001 && v <= 1.0001);
+function maxChroma(l, h) {
+  if (l <= 0 || l >= 1)
+    return 0;
+  let lo = 0, hi = 0.37;
+  if (inGamut(oklchToLinear({ l, c: hi, h })))
+    return hi;
+  for (let i = 0;i < 18; i++) {
+    let mid = (lo + hi) / 2;
+    if (inGamut(oklchToLinear({ l, c: mid, h })))
+      lo = mid;
+    else
+      hi = mid;
+  }
+  return lo;
+}
+function oklchToRgb(color) {
+  let rgb = oklchToLinear(color);
+  if (!inGamut(rgb))
+    rgb = oklchToLinear({ ...color, c: Math.min(color.c, maxChroma(color.l, color.h)) });
+  let [r, g, b] = rgb;
+  return [clamp01(gamma(r)), clamp01(gamma(g)), clamp01(gamma(b))];
+}
+function rgbToOklch(r, g, b) {
+  let [lr, lg, lb] = [linear(r), linear(g), linear(b)], l_ = Math.cbrt(0.4122214708 * lr + 0.5363377612 * lg + 0.0514459929 * lb), m_ = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb), s_ = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb), L = 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_, a = 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_, bb = 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_, c = Math.hypot(a, bb), h = c < 0.0001 ? 0 : (Math.atan2(bb, a) * 180 / Math.PI + 360) % 360;
+  return { l: L, c, h };
+}
+function parseColor2(input) {
+  if (typeof input === "object" && input !== null) {
+    let { l, c, h } = input;
+    return [l, c, h].every((n) => typeof n === "number" && Number.isFinite(n)) ? { l, c, h } : void 0;
+  }
+  if (typeof input !== "string")
+    return;
+  let s = input.trim().toLowerCase(), hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/.exec(s)?.[1];
+  if (hex) {
+    let full = hex.length === 3 ? [...hex].map((d) => d + d).join("") : hex, [r, g, b] = [0, 2, 4].map((i) => parseInt(full.slice(i, i + 2), 16) / 255);
+    return rgbToOklch(r, g, b);
+  }
+  let m = /^oklch\(\s*([\d.]+)(%?)\s+([\d.]+)\s+([\d.]+)(?:deg)?\s*\)$/.exec(s);
+  if (!m)
+    return;
+  let parts = [Number(m[1]) / (m[2] ? 100 : 1), Number(m[3]), Number(m[4])];
+  return parts.every(Number.isFinite) ? { l: parts[0], c: parts[1], h: parts[2] } : void 0;
+}
+function fitColor({ l, c, h }) {
+  let L = round(clamp01(l), 5), H = round((h % 360 + 360) % 360, 3) % 360, C0 = round(Math.min(0.37, Math.max(0, c)), 5);
+  if (inGamut(oklchToLinear({ l: L, c: C0, h: H })))
+    return { l: L, c: C0, h: H };
+  let max = Math.min(0.37, maxChroma(L, H));
+  return { l: L, c: Math.min(C0, Math.floor(max * 1e5) / 1e5), h: H };
+}
+function formatColor({ l, c, h }) {
+  return `oklch(${round(l, 5)} ${round(c, 5)} ${round(h, 3)})`;
+}
+function colorHex2(value) {
+  let color = parseColor2(value);
+  if (!color)
+    return "#000000";
+  return `#${oklchToRgb(color).map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+
+// src/core/easing.ts
+var EASINGS2 = {
+  ease: [0.25, 0.1, 0.25, 1],
+  in: [0.42, 0, 1, 1],
+  out: [0, 0, 0.58, 1],
+  "in-out": [0.42, 0, 0.58, 1],
+  linear: [0, 0, 1, 1],
+  smooth: [0.65, 0, 0.35, 1],
+  snappy: [0.32, 0.72, 0, 1],
+  back: [0.34, 1.56, 0.64, 1]
+}, EASING_Y = [-0.6, 1.6];
+function namedEasing(name) {
+  let key = name.replace(/^ease-(?=in|out)/, "");
+  return Object.hasOwn(EASINGS2, key) ? EASINGS2[key] : void 0;
+}
+function easingName(value) {
+  return Object.entries(EASINGS2).find(([, b]) => b.every((n, i) => n === value[i]))?.[0];
+}
+function bezierPoint2([x1, y1, x2, y2], t) {
+  let u = 1 - t, a = 3 * u * u * t, b = 3 * u * t * t, c = t * t * t;
+  return [a * x1 + b * x2 + c, a * y1 + b * y2 + c];
+}
+var bezierCss2 = (b) => `cubic-bezier(${b.join(", ")})`;
+
+// src/core/keys.ts
+var MODS = ["Ctrl", "Alt", "Shift", "Meta"], ALIASES = {
+  ctrl: "Ctrl",
+  control: "Ctrl",
+  "⌃": "Ctrl",
+  alt: "Alt",
+  option: "Alt",
+  opt: "Alt",
+  "⌥": "Alt",
+  shift: "Shift",
+  "⇧": "Shift",
+  meta: "Meta",
+  cmd: "Meta",
+  command: "Meta",
+  "⌘": "Meta",
+  mod: "Mod"
+}, NAMED = {
+  " ": "Space",
+  space: "Space",
+  spacebar: "Space",
+  esc: "Escape",
+  escape: "Escape",
+  enter: "Enter",
+  return: "Enter",
+  tab: "Tab",
+  backspace: "Backspace",
+  delete: "Delete",
+  del: "Delete",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  arrowup: "ArrowUp",
+  arrowdown: "ArrowDown",
+  arrowleft: "ArrowLeft",
+  arrowright: "ArrowRight",
+  home: "Home",
+  end: "End",
+  pageup: "PageUp",
+  pagedown: "PageDown"
+}, isApple = () => typeof navigator < "u" && /mac|iphone|ipad|ipod/i.test(navigator.userAgentData?.platform ?? navigator.platform ?? ""), keyName = (raw) => {
+  if (!raw)
+    return "";
+  let named = NAMED[raw.toLowerCase()];
+  if (named)
+    return named;
+  if (raw.length === 1)
+    return raw.toUpperCase();
+  if (/^f\d{1,2}$/i.test(raw))
+    return raw.toUpperCase();
+  return raw.charAt(0).toUpperCase() + raw.slice(1);
+};
+function normalizeCombo2(combo) {
+  let trimmed = combo.trim();
+  if (!trimmed)
+    return "";
+  let parts = trimmed === "+" ? ["+"] : trimmed.replace(/\+\+$/, "+plus").split("+"), mods = /* @__PURE__ */ new Set, key = "";
+  for (let part of parts) {
+    let alias = ALIASES[part.trim().toLowerCase()] ?? ALIASES[part.trim()];
+    if (alias === "Mod")
+      mods.add(isApple() ? "Meta" : "Ctrl");
+    else if (alias)
+      mods.add(alias);
+    else
+      key = part === "plus" ? "+" : keyName(part.trim() || part);
+  }
+  if (!key)
+    return "";
+  return [...MODS.filter((m) => mods.has(m)), key].join("+");
+}
+var layout = null, layoutAsked = !1;
+function askLayout() {
+  if (layoutAsked)
+    return;
+  layoutAsked = !0, globalThis.navigator?.keyboard?.getLayoutMap?.().then((map) => {
+    layout = map;
+  }).catch(() => {});
+}
+function letterOf2(event) {
+  askLayout();
+  let code = event.code ?? "";
+  if (/^[a-z]$/i.test(event.key) && !event.altKey)
+    return event.key.toUpperCase();
+  let mapped = layout?.get(code);
+  if (mapped && /^[a-z]$/i.test(mapped))
+    return mapped.toUpperCase();
+  return /^Key[A-Z]$/.test(code) ? code.slice(3) : "";
+}
+function comboFromEvent2(event) {
+  if (["Shift", "Alt", "Meta", "Control", "CapsLock", "Fn", "OS"].includes(event.key))
+    return "";
+  let code = event.code ?? "", letter = letterOf2(event), key = letter ? letter : /^Digit\d$/.test(code) ? code.slice(5) : code === "Space" ? "Space" : keyName(event.key);
+  return [
+    event.ctrlKey ? "Ctrl" : "",
+    event.altKey ? "Alt" : "",
+    event.shiftKey ? "Shift" : "",
+    event.metaKey ? "Meta" : "",
+    key
+  ].filter(Boolean).join("+");
+}
+function heldMods(event) {
+  return MODS.filter((m) => m === "Ctrl" ? event.ctrlKey : m === "Alt" ? event.altKey : m === "Shift" ? event.shiftKey : event.metaKey);
+}
+function matchesCombo2(combo, event) {
+  let want = normalizeCombo2(combo);
+  return want !== "" && want === comboFromEvent2(event);
+}
+var GLYPHS = { Ctrl: "⌃", Alt: "⌥", Shift: "⇧", Meta: "⌘" }, WORDS = { Ctrl: "Ctrl", Alt: "Alt", Shift: "Shift", Meta: "Meta" }, KEY_GLYPHS = {
+  ArrowUp: "↑",
+  ArrowDown: "↓",
+  ArrowLeft: "←",
+  ArrowRight: "→",
+  Backspace: "⌫",
+  Delete: "⌦",
+  Enter: "↩",
+  Escape: "Esc",
+  Tab: "⇥",
+  PageUp: "PgUp",
+  PageDown: "PgDn"
+};
+function comboParts2(combo, apple = isApple()) {
+  let norm = normalizeCombo2(combo);
+  if (!norm)
+    return [];
+  let parts = norm === "+" ? ["+"] : norm.split("+");
+  if (norm.endsWith("++"))
+    parts.splice(-2, 2, "+");
+  let key = parts.pop(), mods = parts, shown = KEY_GLYPHS[key] ?? key;
+  return apple ? [...mods.map((m) => GLYPHS[m]), shown] : [...mods.map((m) => WORDS[m]), shown];
+}
+function comboLabel2(combo, apple = isApple()) {
+  return comboParts2(combo, apple).join(apple ? "" : "+");
+}
+
+// src/core/ramp.ts
+var MAX_STOPS = 32, MAX_POINTS = 64, GRADIENT_SAMPLES = 64, CURVE_SAMPLES = 129, clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v)), finite = (v) => typeof v === "number" && Number.isFinite(v), round4 = (v) => Math.round(v * 1e4) / 1e4 || 0;
+function normalizeStops(input) {
+  if (!Array.isArray(input))
+    return;
+  let stops = [];
+  for (let s of input.slice(0, MAX_STOPS)) {
+    if (typeof s !== "object" || s === null)
+      continue;
+    let { at, color } = s, parsed = parseColor2(color);
+    if (!finite(at) || !parsed)
+      continue;
+    stops.push(Object.freeze({ at: round4(clamp(at, 0, 1)), color: formatColor(fitColor(parsed)) }));
+  }
+  if (stops.length < 2)
+    return;
+  return Object.freeze(stops.map((s, i) => [s, i]).sort((a, b) => a[0].at - b[0].at || a[1] - b[1]).map(([s]) => s));
+}
+function normalizePoints(input, range) {
+  if (!Array.isArray(input))
+    return;
+  let pts = [], span = range[1] - range[0], roundY = (y) => span > 0 ? Number((range[0] + Math.round((y - range[0]) / span * 1e5) / 1e5 * span).toPrecision(12)) : range[0];
+  for (let p of input.slice(0, MAX_POINTS)) {
+    if (typeof p !== "object" || p === null)
+      continue;
+    let { x, y } = p;
+    if (!finite(x) || !finite(y))
+      continue;
+    pts.push({ x: round4(clamp(x, 0, 1)), y: roundY(clamp(y, range[0], range[1])) });
+  }
+  if (pts.length < 2)
+    return;
+  let sorted = pts.map((p, i) => [p, i]).sort((a, b) => a[0].x - b[0].x || a[1] - b[1]).map(([p]) => p);
+  return sorted[0] = { ...sorted[0], x: 0 }, sorted[sorted.length - 1] = { ...sorted[sorted.length - 1], x: 1 }, Object.freeze(sorted.map((p) => Object.freeze(p)));
+}
+var toLab = ({ l, c, h }) => [
+  l,
+  c * Math.cos(h * Math.PI / 180),
+  c * Math.sin(h * Math.PI / 180)
+], fromLab = ([l, a, b]) => {
+  let c = Math.hypot(a, b);
+  return { l, c, h: c < 0.00001 ? 0 : (Math.atan2(b, a) * 180 / Math.PI + 360) % 360 };
+}, linearOf = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function prepare(stops, space) {
+  let at = stops.map((s) => s.at), ok = stops.map((s) => parseColor2(s.color) ?? { l: 0, c: 0, h: 0 }), lab = ok.map(toLab), rgb = ok.map((c) => oklchToRgb(c));
+  return (t) => {
+    let n = at.length, i = 0;
+    while (i < n && at[i] <= t)
+      i++;
+    if (i === 0)
+      return [...rgb[0]];
+    if (i === n)
+      return [...rgb[n - 1]];
+    let a = i - 1, span = at[i] - at[a], f = span > 0 ? (t - at[a]) / span : 1;
+    if (space === "srgb") {
+      let p = rgb[a], q = rgb[i];
+      return [p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f, p[2] + (q[2] - p[2]) * f];
+    }
+    let p = lab[a], q = lab[i];
+    return oklchToRgb(fromLab([p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f, p[2] + (q[2] - p[2]) * f]));
+  };
+}
+function sampleGradient2(stops, t, options = {}) {
+  let valid = normalizeStops(stops) ?? stops;
+  if (!valid.length)
+    return options.as === "rgb" || options.as === "linear" ? [0, 0, 0] : "#000000";
+  let rgb = prepare(valid, options.space ?? "oklab")(clamp(Number.isFinite(t) ? t : 0, 0, 1));
+  if (options.as === "rgb")
+    return rgb;
+  if (options.as === "linear")
+    return [linearOf(rgb[0]), linearOf(rgb[1]), linearOf(rgb[2])];
+  let color = formatColor(fitColor(rgbToOklch(...rgb)));
+  return options.as === "hex" ? colorHex2(color) : color;
+}
+function gradientSamples(stops, space, n = GRADIENT_SAMPLES) {
+  let at = prepare(stops, space), out = [];
+  for (let i = 0;i < n; i++)
+    out.push(...at(i / (n - 1)));
+  return out;
+}
+function gradientCss2(stops, options = {}) {
+  let valid = normalizeStops(stops) ?? stops, s = gradientSamples(valid, options.space ?? "oklab", 17), parts = [];
+  for (let i = 0;i < 17; i++) {
+    let [r, g, b] = [s[i * 3], s[i * 3 + 1], s[i * 3 + 2]].map((v) => Math.round(v * 255));
+    parts.push(`rgb(${r} ${g} ${b}) ${round4(i / 16 * 100)}%`);
+  }
+  return `linear-gradient(${options.direction ?? "to right"},${parts.join(",")})`;
+}
+function stopColorAt(stops, space, t) {
+  return formatColor(fitColor(rgbToOklch(...prepare(stops, space)(clamp(t, 0, 1)))));
+}
+function tangents(xs, ys) {
+  let n = xs.length, h = [], s = [];
+  for (let i = 0;i < n - 1; i++)
+    h.push(xs[i + 1] - xs[i]), s.push(h[i] > 0 ? (ys[i + 1] - ys[i]) / h[i] : 0);
+  let m = Array(n).fill(0);
+  if (n === 2)
+    return m[0] = m[1] = s[0], m;
+  let sign = Math.sign;
+  for (let i = 1;i < n - 1; i++) {
+    let h0 = h[i - 1], h1 = h[i];
+    if (h0 <= 0 || h1 <= 0)
+      continue;
+    let p = (s[i - 1] * h1 + s[i] * h0) / (h0 + h1);
+    m[i] = (sign(s[i - 1]) + sign(s[i])) * Math.min(Math.abs(s[i - 1]), Math.abs(s[i]), 0.5 * Math.abs(p));
+  }
+  let end = (a, b, ha, hb) => {
+    if (ha <= 0)
+      return 0;
+    let p = a * (1 + ha / (ha + hb)) - b * ha / (ha + hb);
+    if (sign(p) !== sign(a))
+      return 0;
+    return Math.abs(p) > 2 * Math.abs(a) ? 2 * a : p;
+  };
+  return m[0] = end(s[0], s[1], h[0], h[1]), m[n - 1] = end(s[n - 2], s[n - 3], h[n - 2], h[n - 3]), m;
+}
+function prepareCurve(points, interp) {
+  let xs = points.map((p) => p.x), ys = points.map((p) => p.y), m = interp === "smooth" ? tangents(xs, ys) : [], n = xs.length;
+  return (x) => {
+    if (!n)
+      return 0;
+    if (x <= xs[0])
+      return ys[0];
+    if (x >= xs[n - 1])
+      return ys[n - 1];
+    let i = 0;
+    while (i < n - 2 && xs[i + 1] <= x)
+      i++;
+    let x0 = xs[i], span = xs[i + 1] - x0;
+    if (interp === "step" || span <= 0)
+      return ys[i];
+    let t = (x - x0) / span;
+    if (interp === "linear")
+      return ys[i] + (ys[i + 1] - ys[i]) * t;
+    let t2 = t * t, t3 = t2 * t;
+    return (2 * t3 - 3 * t2 + 1) * ys[i] + (t3 - 2 * t2 + t) * span * m[i] + (-2 * t3 + 3 * t2) * ys[i + 1] + (t3 - t2) * span * m[i + 1];
+  };
+}
+function sampleCurve2(points, x, options = {}) {
+  return prepareCurve(points, options.interp ?? "smooth")(Number.isFinite(x) ? x : 0);
+}
+function curveSamples(points, interp, n = CURVE_SAMPLES) {
+  let at = prepareCurve(points, interp), xs = Array.from({ length: n }, (_, i) => i / (n - 1));
+  for (let p of points) {
+    let j = Math.round(p.x * (n - 1));
+    if (xs[j] = p.x, interp === "step" && j > 0 && p.x > 0)
+      xs[j - 1] = p.x;
+  }
+  xs.sort((a, b) => a - b);
+  let out = [];
+  for (let i = 0;i < n; i++) {
+    let x = xs[i], rising = interp === "step" && xs[i + 1] === x && xs[i - 1] !== x;
+    out.push(x, at(rising ? x - 0.000000001 : x));
+  }
+  return out;
+}
+var CURVE_SHAPES2 = {
+  linear: [
+    { x: 0, y: 0 },
+    { x: 1, y: 1 }
+  ],
+  "ease-out": [
+    { x: 0, y: 0 },
+    { x: 0.35, y: 0.62 },
+    { x: 1, y: 1 }
+  ],
+  "inverse²": [
+    { x: 0, y: 1 },
+    { x: 0.1, y: 0.85 },
+    { x: 0.25, y: 0.47 },
+    { x: 0.5, y: 0.15 },
+    { x: 1, y: 0 }
+  ],
+  smoothstep: [
+    { x: 0, y: 0 },
+    { x: 0.25, y: 0.156 },
+    { x: 0.5, y: 0.5 },
+    { x: 0.75, y: 0.844 },
+    { x: 1, y: 1 }
+  ],
+  bell: [
+    { x: 0, y: 0 },
+    { x: 0.25, y: 0.25 },
+    { x: 0.5, y: 1 },
+    { x: 0.75, y: 0.25 },
+    { x: 1, y: 0 }
+  ]
+}, inRange = (shape, range) => shape.map((p) => ({ x: p.x, y: range[0] + p.y * (range[1] - range[0]) }));
+function sameRamp(a, b) {
+  if (a.length !== b.length)
+    return !1;
+  return a.every((p, i) => {
+    let q = b[i];
+    if ("at" in p && "at" in q)
+      return Math.abs(p.at - q.at) < 0.0001 && p.color === q.color;
+    if ("x" in p && "x" in q)
+      return Math.abs(p.x - q.x) < 0.0001 && Math.abs(p.y - q.y) < 0.000001;
+    return !1;
+  });
+}
+var between = (min, max, r) => min + (max - min) * r, signed = (random) => random() < 0.5 ? -1 : 1;
+function randomStops(count, random) {
+  let n = Math.max(2, count), hue = random() * 360, turn = signed(random) * between(20, 70, random()), rising = random() < 0.5, [l0, l1] = [between(0.2, 0.4, random()), between(0.75, 0.95, random())], vivid = between(0.3, 0.9, random());
+  return Array.from({ length: n }, (_, i) => {
+    let t = i / (n - 1), jitter = i === 0 || i === n - 1 ? 0 : (random() - 0.5) * (0.5 / (n - 1)), at = clamp(t + jitter, 0, 1), l = rising ? l0 + (l1 - l0) * t : l1 + (l0 - l1) * t, h = (hue + turn * t + 360) % 360, c = vivid * maxChroma(l, h) * between(0.7, 1, random());
+    return { at, color: formatColor(fitColor({ l, c, h })) };
+  });
+}
+function mutateStops(stops, random, hue, lightness) {
+  let out = stops.map((s) => ({ ...s }));
+  for (let [i, s] of out.entries()) {
+    let c = parseColor2(s.color) ?? { l: 0.5, c: 0, h: 0 }, max0 = maxChroma(c.l, c.h), rel = max0 > 0.0001 ? clamp(c.c / max0, 0, 1) : 0.5, h = (c.h + signed(random) * between(hue[0], hue[1], random()) + 360) % 360, l = clamp(c.l + signed(random) * between(lightness[0], lightness[1], random()), 0, 1), r = clamp(rel + signed(random) * between(0.04, 0.1, random()), 0, 1);
+    s.color = formatColor(fitColor({ l, c: r * maxChroma(l, h), h }));
+    let lo = i > 0 ? out[i - 1].at : 0, hi = i < out.length - 1 ? stops[i + 1].at : 1;
+    s.at = round4(clamp(s.at + signed(random) * between(0.02, 0.05, random()), lo, hi));
+  }
+  return out;
+}
+function randomPoints(range, random) {
+  let shapes = Object.values(CURVE_SHAPES2), shape = shapes[Math.floor(Math.min(0.999999, random()) * shapes.length)], flip = random() < 0.3;
+  return inRange(shape.map((p, i) => ({
+    x: p.x,
+    y: i === 0 || i === shape.length - 1 ? flip ? 1 - p.y : p.y : clamp((flip ? 1 - p.y : p.y) + (random() - 0.5) * 0.12, 0, 1)
+  })), range);
+}
+function mutatePoints(points, range, random, share) {
+  let span = range[1] - range[0], out = points.map((p) => ({ ...p }));
+  for (let [i, p] of out.entries()) {
+    let by = span * between(share[0], share[1], random()) * 0.6, y = p.y + signed(random) * by;
+    if (y > range[1] || y < range[0])
+      y = p.y - (y - p.y);
+    if (p.y = clamp(y, range[0], range[1]), i === 0 || i === out.length - 1)
+      continue;
+    let lo = out[i - 1].x + 0.01, hi = points[i + 1].x - 0.01;
+    if (hi > lo)
+      p.x = round4(clamp(p.x + signed(random) * between(0.02, 0.05, random()), lo, hi));
+  }
+  return out;
+}
+
+// src/core/schema.ts
+var META_KEYS = [
+  "label",
+  "group",
+  "groupLabel",
+  "section",
+  "sectionLabel",
+  "groupDescription",
+  "sectionDescription",
+  "shortcut",
+  "random",
+  "disabled",
+  "readOnly",
+  "folded",
+  "sectionFolded",
+  "tab",
+  "subsection"
+];
+function pickMeta(source, skip = []) {
+  let out = {};
+  if (source) {
+    for (let k of META_KEYS)
+      if (source[k] !== void 0 && !skip.includes(k))
+        out[k] = source[k];
+  }
+  return out;
+}
+var READOUT_KINDS = /* @__PURE__ */ new Set(["watch", "sparkline", "graph", "meter", "table", "log"]), isReadout2 = (field) => READOUT_KINDS.has(field.kind), hasValue2 = (field) => field.kind !== "action" && field.kind !== "toolbar" && !READOUT_KINDS.has(field.kind), SPRING2 = {
+  duration: { min: 0.05, max: 2, step: 0.01 },
+  bounce: { min: -0.5, max: 1, step: 0.01 }
+};
+function checkShortcut(shortcut) {
+  if (shortcut !== void 0 && !/^[a-z]$/i.test(shortcut))
+    throw Error("Shortcut must be a letter.");
+}
+function valueKeys(schema) {
+  return Object.keys(schema).filter((k) => hasValue2(schema[k]));
+}
+function withMeta(base, meta) {
+  return checkShortcut(meta?.shortcut), Object.freeze({ ...base, ...pickMeta(meta) });
+}
+function knob2(value, options) {
+  let step = options.step ?? ((options.max - options.min) / 100 || 1);
+  if (![value, options.min, options.max, step].every(Number.isFinite) || options.max < options.min || step <= 0)
+    throw Error("A knob needs finite bounds and a positive step.");
+  if (options.decimals !== void 0 && !(Number.isInteger(options.decimals) && options.decimals >= 0))
+    throw Error("A knob's decimals must be a whole number.");
+  checkShortcut(options.shortcut);
+  let field = { ...options, kind: "knob", value, step };
+  return Object.freeze({ ...field, value: normalizeField(field, value) });
+}
+function choice2(value, options, meta) {
+  if (!options.includes(value) || new Set(options).size !== options.length)
+    throw Error("Invalid choice options/default.");
+  let labels = meta?.labels ? Object.freeze(Object.fromEntries(Object.entries(meta.labels).filter(([k, v]) => options.includes(k) && typeof v === "string" && v !== k))) : void 0;
+  return withMeta({
+    kind: "choice",
+    value,
+    options: Object.freeze([...options]),
+    ...labels && Object.keys(labels).length ? { labels } : {},
+    ...meta?.display ? { display: meta.display } : {}
+  }, meta);
+}
+function action2(label, meta) {
+  return withMeta({ kind: "action", ...meta?.run ? { run: meta.run } : {} }, { ...meta, ...label !== void 0 ? { label } : {} });
+}
+function flatSpring2(parts = {}, meta = {}) {
+  let id = meta.id ?? meta.label ?? `spring-${++springIds}`, half = (part, input, fallback) => {
+    let base = typeof input === "object" ? input : knob2(input ?? fallback, {
+      ...SPRING2[part],
+      ...part === "duration" ? { unit: "s" } : {}
+    });
+    return Object.freeze({
+      ...base,
+      ...base.label === void 0 ? { label: part === "duration" ? "Duration" : "Bounce" } : {},
+      ...pickMeta(meta, ["label", "shortcut"]),
+      spring: Object.freeze({
+        id,
+        part,
+        ...meta.label !== void 0 ? { label: meta.label } : {}
+      })
+    });
+  };
+  return {
+    duration: half("duration", parts.duration, 0.5),
+    bounce: half("bounce", parts.bounce, 0)
+  };
+}
+var springIds = 0;
+function toggle2(value, meta) {
+  return withMeta({ kind: "toggle", value }, meta);
+}
+function spring2(value = {}, meta) {
+  let field = { kind: "spring", value: { duration: 0.5, bounce: 0 } };
+  return withMeta({ ...field, value: normalizeField(field, value) }, meta);
+}
+function color2(value, meta) {
+  let parsed = parseColor2(value);
+  if (!parsed)
+    throw Error("A color needs #rgb, #rrggbb, oklch(L C H) or { l, c, h }.");
+  return withMeta({ kind: "color", value: formatColor(fitColor(parsed)) }, meta);
+}
+var axes = (v) => typeof v === "number" ? { x: v, y: v } : v;
+function point2(value, options) {
+  let min = axes(options.min), max = axes(options.max), step = options.step === void 0 ? void 0 : axes(options.step), field = {
+    kind: "point",
+    value,
+    min: Object.freeze({ ...min }),
+    max: Object.freeze({ ...max }),
+    step: Object.freeze({
+      x: step?.x ?? ((max.x - min.x) / 100 || 1),
+      y: step?.y ?? ((max.y - min.y) / 100 || 1)
+    })
+  };
+  if (![value.x, value.y, min.x, min.y, max.x, max.y, field.step.x, field.step.y].every(Number.isFinite) || max.x < min.x || max.y < min.y || field.step.x <= 0 || field.step.y <= 0)
+    throw Error("A point needs finite bounds and positive steps.");
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function easing2(value, meta) {
+  let curve = typeof value === "string" ? namedEasing(value) : value;
+  if (!curve || curve.length !== 4 || !curve.every(Number.isFinite))
+    throw Error("An easing needs four finite numbers or a known name.");
+  let field = { kind: "easing", value: curve };
+  return withMeta({ ...field, value: normalizeField(field, curve) }, meta);
+}
+function bounds(o, what) {
+  let step = o.step ?? ((o.max - o.min) / 100 || 1);
+  if (![o.min, o.max, step].every(Number.isFinite) || o.max < o.min || step <= 0)
+    throw Error(`${what} needs finite bounds and a positive step.`);
+  if (o.decimals !== void 0 && !(Number.isInteger(o.decimals) && o.decimals >= 0))
+    throw Error(`${what}'s decimals must be a whole number.`);
+  return step;
+}
+var numberMeta = (o) => ({
+  ...o.unit !== void 0 ? { unit: o.unit } : {},
+  ...o.decimals !== void 0 ? { decimals: o.decimals } : {}
+});
+function vec(axes, value, options) {
+  let step = bounds(options, "A vector"), names = options.axes;
+  if (names && (names.length !== axes || names.some((n) => typeof n !== "string" || !n.trim())))
+    throw Error(`A vector's axes need ${axes} names.`);
+  let field = {
+    kind: "vec",
+    axes,
+    value,
+    min: options.min,
+    max: options.max,
+    step,
+    ...numberMeta(options),
+    ...options.link || options.linked ? { link: !0 } : {},
+    ...options.linked ? { linked: !0 } : {},
+    ...names ? { axisLabels: Object.freeze(names.map((n) => n.trim())) } : {}
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function vec22(value, options) {
+  return vec(2, value, options);
+}
+function vec32(value, options) {
+  return vec(3, value, options);
+}
+function range2(value, options) {
+  let step = bounds(options, "A range"), field = {
+    kind: "range",
+    value,
+    min: options.min,
+    max: options.max,
+    step,
+    ...numberMeta(options)
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function angle2(value, options = {}) {
+  let min = options.min ?? 0, max = options.max ?? 360, step = options.step ?? 1;
+  bounds({ min, max, step }, "An angle");
+  let field = {
+    kind: "angle",
+    value,
+    min,
+    max,
+    step,
+    wrap: options.wrap ?? max - min === 360
+  };
+  return withMeta({ ...field, value: normalizeField(field, value) }, options);
+}
+function seed2(value, options = {}) {
+  let field = {
+    kind: "seed",
+    value,
+    min: Math.ceil(options.min ?? 0),
+    max: Math.floor(options.max ?? 999999)
+  };
+  return bounds({ min: field.min, max: field.max, step: 1 }, "A seed"), withMeta({ ...field, value: normalizeField(field, value) }, { random: !1, ...options });
+}
+function keybind2(value = "", meta) {
+  let field = { kind: "keybind", value: normalizeCombo2(value) };
+  return withMeta(field, { random: !1, ...meta });
+}
+function gradient2(stops, options = {}) {
+  let value = normalizeStops(stops);
+  if (!value)
+    throw Error("A gradient needs at least two stops with a position and a colour.");
+  let presets = options.presets ? Object.freeze(Object.fromEntries(Object.entries(options.presets).flatMap(([name, p]) => {
+    let s = normalizeStops(p);
+    return s ? [[name, s]] : [];
+  }))) : void 0;
+  return withMeta({
+    kind: "gradient",
+    value,
+    space: options.space ?? "oklab",
+    ...presets && Object.keys(presets).length ? { presets } : {}
+  }, options);
+}
+function curve2(points, options = {}) {
+  let range = options.range ?? [0, 1];
+  if (!(Number.isFinite(range[0]) && Number.isFinite(range[1]) && range[1] > range[0]))
+    throw Error("A curve's range needs finite bounds, max above min.");
+  let given = typeof points === "string" ? inRange(CURVE_SHAPES2[points], range) : points, value = normalizePoints(given, range);
+  if (!value)
+    throw Error("A curve needs at least two points.");
+  let presets = options.presets ? Object.freeze(Object.fromEntries(Object.entries(options.presets).flatMap(([name, p]) => {
+    let s = normalizePoints(p, range);
+    return s ? [[name, s]] : [];
+  }))) : void 0;
+  return withMeta({
+    kind: "curve",
+    value,
+    range: Object.freeze([range[0], range[1]]),
+    interp: options.interp ?? "smooth",
+    shapes: options.shapes ?? !0,
+    ...presets && Object.keys(presets).length ? { presets } : {}
+  }, options);
+}
+function toolbarShortcut2(item) {
+  let s = item.shortcut;
+  if (!s)
+    return;
+  if (typeof s === "string")
+    return { key: s, scope: item.global ? "page" : "panel" };
+  return s.key ? { key: s.key, scope: s.scope ?? (item.global ? "page" : "panel") } : void 0;
+}
+function toolbar2(items, meta) {
+  if (!items.length)
+    throw Error("A toolbar needs at least one item.");
+  return withMeta({
+    kind: "toolbar",
+    items: Object.freeze(items.map((item) => Object.freeze({ ...item })))
+  }, meta);
+}
+var readoutMeta = (o) => {
+  if (o.decimals !== void 0 && !(Number.isInteger(o.decimals) && o.decimals >= 0))
+    throw Error("A readout's decimals must be a whole number.");
+  if (o.hz !== void 0 && !(o.hz > 0))
+    throw Error("A readout's hz must be above 0.");
+  return {
+    ...pickMeta(o),
+    ...o.get ? { get: o.get } : {},
+    ...o.unit !== void 0 ? { unit: o.unit } : {},
+    ...o.decimals !== void 0 ? { decimals: o.decimals } : {},
+    ...o.format ? { format: o.format } : {},
+    ...o.hz !== void 0 ? { hz: o.hz } : {}
+  };
+}, whole = (n, fallback, what) => {
+  let v = n ?? fallback;
+  if (!(Number.isInteger(v) && v > 0))
+    throw Error(`${what} must be a whole number above 0.`);
+  return v;
+};
+function watch2(options = {}) {
+  return Object.freeze({ kind: "watch", ...readoutMeta(options) });
+}
+function sparkline2(options = {}) {
+  return Object.freeze({
+    kind: "sparkline",
+    ...readoutMeta(options),
+    history: whole(options.history, 60, "A sparkline's history"),
+    ...options.min !== void 0 ? { min: options.min } : {},
+    ...options.max !== void 0 ? { max: options.max } : {},
+    ...options.color ? { color: options.color } : {}
+  });
+}
+function graph2(options = {}) {
+  let series = (options.series ?? [{ id: "value" }]).map((s) => Object.freeze(typeof s === "string" ? { id: s } : { ...s }));
+  if (!series.length || new Set(series.map((s) => s.id)).size !== series.length)
+    throw Error("A graph needs series with distinct ids.");
+  return Object.freeze({
+    kind: "graph",
+    ...readoutMeta(options),
+    series: Object.freeze(series),
+    history: whole(options.history, 120, "A graph's history"),
+    height: whole(options.height, 64, "A graph's height"),
+    ...options.min !== void 0 ? { min: options.min } : {},
+    ...options.max !== void 0 ? { max: options.max } : {},
+    thresholds: Object.freeze((options.thresholds ?? []).map((t) => Object.freeze(typeof t === "number" ? { value: t } : t)))
+  });
+}
+function meter2(options = {}) {
+  let min = options.min ?? 0, max = options.max ?? 1;
+  if (!(Number.isFinite(min) && Number.isFinite(max) && max > min))
+    throw Error("A meter needs finite bounds, max above min.");
+  return Object.freeze({
+    kind: "meter",
+    ...readoutMeta(options),
+    min,
+    max,
+    ...options.segments !== void 0 ? { segments: whole(options.segments, 1, "A meter's segments") } : {},
+    ...options.warn !== void 0 ? { warn: options.warn } : {},
+    ...options.critical !== void 0 ? { critical: options.critical } : {}
+  });
+}
+function table2(options = {}) {
+  if (options.columns && (options.columns.length < 1 || options.columns.length > 6))
+    throw Error("A table takes 1–6 columns.");
+  return Object.freeze({
+    kind: "table",
+    ...readoutMeta(options),
+    ...options.columns ? { columns: Object.freeze([...options.columns]) } : {}
+  });
+}
+function log2(options = {}) {
+  return Object.freeze({
+    kind: "log",
+    ...readoutMeta(options),
+    lines: whole(options.lines, 8, "A log's lines"),
+    max: whole(options.max, 1000, "A log's max")
+  });
+}
+var keep = (v, min, max, step) => {
+  let clamped = Math.min(max, Math.max(min, v));
+  return Number.isInteger(step) && Number.isInteger(min) ? Math.round(clamped) : Number(clamped.toPrecision(14));
+}, wrapAngle2 = (v, min, max) => {
+  let span = max - min;
+  return span > 0 ? ((v - min) % span + span) % span + min : min;
+}, snap = (v, min, max, step) => {
+  let bounded = Math.max(min, Math.min(max, v)), steps = Math.min(Math.floor((max - min) / step + 0.000000001), Math.round((bounded - min) / step));
+  return Number((min + steps * step).toPrecision(14));
+}, num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+function normalizeField(field, input) {
+  switch (field.kind) {
+    case "knob":
+      if (typeof input !== "number" || !Number.isFinite(input))
+        return field.value;
+      {
+        let clamped = Math.min(field.max, Math.max(field.min, input));
+        return Number.isInteger(field.step) && Number.isInteger(field.min) ? Math.round(clamped) : Number(clamped.toPrecision(14));
+      }
+    case "choice":
+      return typeof input === "string" && field.options.includes(input) ? input : field.value;
+    case "toggle":
+      return typeof input === "boolean" ? input : field.value;
+    case "spring": {
+      let v = isRecord(input) ? input : {}, { duration: d, bounce: b } = SPRING2;
+      return Object.freeze({
+        duration: snap(num(v.duration, field.value.duration), d.min, d.max, d.step),
+        bounce: snap(num(v.bounce, field.value.bounce), b.min, b.max, b.step)
+      });
+    }
+    case "color": {
+      let parsed = parseColor2(input);
+      return parsed ? formatColor(fitColor(parsed)) : field.value;
+    }
+    case "point": {
+      let v = isRecord(input) ? input : {};
+      return Object.freeze({
+        x: snap(num(v.x, field.value.x), field.min.x, field.max.x, field.step.x),
+        y: snap(num(v.y, field.value.y), field.min.y, field.max.y, field.step.y)
+      });
+    }
+    case "easing": {
+      let v = Array.isArray(input) && input.length === 4 ? input : field.value;
+      return Object.freeze([0, 1, 2, 3].map((i) => i % 2 === 0 ? snap(num(v[i], field.value[i]), 0, 1, 0.01) : snap(num(v[i], field.value[i]), EASING_Y[0], EASING_Y[1], 0.01)));
+    }
+    case "vec": {
+      let v = isRecord(input) ? input : {}, base = field.value, axis = (k) => keep(num(v[k], base[k] ?? 0), field.min, field.max, field.step);
+      return Object.freeze(field.axes === 3 ? { x: axis("x"), y: axis("y"), z: axis("z") } : { x: axis("x"), y: axis("y") });
+    }
+    case "range": {
+      let v = Array.isArray(input) && input.length === 2 ? input : field.value, a = keep(num(v[0], field.value[0]), field.min, field.max, field.step), b = keep(num(v[1], field.value[1]), field.min, field.max, field.step);
+      return Object.freeze([Math.min(a, b), Math.max(a, b)]);
+    }
+    case "angle": {
+      if (typeof input !== "number" || !Number.isFinite(input))
+        return field.value;
+      let v = field.wrap ? wrapAngle2(input, field.min, field.max) : input, kept = keep(v, field.min, field.max, field.step);
+      return field.wrap && kept >= field.max ? field.min : kept;
+    }
+    case "seed":
+      return typeof input === "number" && Number.isFinite(input) ? Math.round(Math.min(field.max, Math.max(field.min, input))) : field.value;
+    case "keybind":
+      return typeof input === "string" ? normalizeCombo2(input) : field.value;
+    case "gradient":
+      return normalizeStops(input) ?? field.value;
+    case "curve":
+      return normalizePoints(input, field.range) ?? field.value;
+  }
+}
+function normalize(schema, input) {
+  let record = isRecord(input) ? input : {};
+  return Object.freeze(Object.fromEntries(Object.entries(schema).flatMap(([key, field]) => hasValue2(field) ? [[key, normalizeField(field, record[key])]] : [])));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function same(a, b) {
+  if (a === b)
+    return !0;
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null)
+    return !1;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return !1;
+  let ka = Object.keys(a);
+  return ka.length === Object.keys(b).length && ka.every((k) => same(a[k], b[k]));
+}
+function equal(a, b) {
+  return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((key) => same(a[key], b[key]));
+}
+
+// src/core/spring.ts
+class Spring {
+  x;
+  omega;
+  zeta;
+  eps;
+  v = 0;
+  target;
+  next;
+  constructor(x, omega = 24, zeta = 0.86, eps = 0.005) {
+    this.x = x;
+    this.omega = omega;
+    this.zeta = zeta;
+    this.eps = eps;
+    this.target = x;
+  }
+  set(target, delay = 0) {
+    if (delay > 0) {
+      if (target !== (this.next?.target ?? this.target))
+        this.next = { target, at: performance.now() + delay };
+      return this;
+    }
+    return this.next = void 0, this.target = target, this;
+  }
+  snap(x) {
+    return this.next = void 0, this.x = this.target = x, this.v = 0, this;
+  }
+  step(dt) {
+    if (this.next && performance.now() >= this.next.at)
+      this.target = this.next.target, this.next = void 0;
+    if (this.x === this.target && this.v === 0)
+      return this.x;
+    let clampedDt = Math.min(dt, 0.1), h = 0.0020833333333333333;
+    for (let t = 0;t < clampedDt; t += h) {
+      let k = Math.min(h, clampedDt - t), a = -this.omega * this.omega * (this.x - this.target) - 2 * this.zeta * this.omega * this.v;
+      this.v += a * k, this.x += this.v * k;
+    }
+    if (this.resting)
+      this.x = this.target, this.v = 0;
+    return this.x;
+  }
+  get resting() {
+    return !this.next && Math.abs(this.x - this.target) < this.eps && Math.abs(this.v) < this.eps * 4;
+  }
+}
+function springMotion2({ duration, bounce }) {
+  return {
+    omega: 2 * Math.PI / Math.max(0.01, duration),
+    zeta: bounce >= 0 ? 1 - bounce : 1 / (1 + bounce)
+  };
+}
+function springResponse(omega, zeta, seconds, dt = 0.016666666666666666) {
+  let s = new Spring(0, omega, zeta).set(1), out = [0];
+  for (let t = dt;t < seconds + dt / 2; t += dt)
+    out.push(s.step(dt));
+  return out;
+}
+function springEasing(omega, zeta) {
+  let s = new Spring(0, omega, zeta).set(1), points = ["0"], dt = 0.016666666666666666, t = 0;
+  while (t < 4 && !(Math.abs(s.x - 1) < 0.002 && Math.abs(s.v) < 0.05))
+    s.step(0.016666666666666666), t += 0.016666666666666666, points.push(String(Math.round(s.x * 1000) / 1000));
+  return points[points.length - 1] = "1", { easing: `linear(${points.join(",")})`, ms: Math.round(t * 1000) };
+}
+function springCss2(value) {
+  let { omega, zeta } = springMotion2(value), { easing, ms } = springEasing(omega, zeta);
+  return { easing, duration: ms };
+}
+
+// src/core/internal.ts
+var RESHAPE = Symbol.for("knobs.reshape"), RESET_KEYS = Symbol.for("knobs.resetKeys"), REFRESHES = Symbol.for("knobs.refreshes");
+
+// src/core/readout.ts
+class Ring {
+  capacity;
+  data;
+  start = 0;
+  length = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.data = new Float64Array(Math.max(1, capacity));
+  }
+  push(v) {
+    let cap = this.data.length;
+    if (this.length < cap)
+      this.data[(this.start + this.length++) % cap] = v;
+    else
+      this.data[this.start] = v, this.start = (this.start + 1) % cap;
+  }
+  at(i) {
+    return this.data[(this.start + i) % this.data.length];
+  }
+  last() {
+    return this.length ? this.at(this.length - 1) : Number.NaN;
+  }
+  clear() {
+    this.start = this.length = 0;
+  }
+  extent() {
+    let lo = 1 / 0, hi = -1 / 0;
+    for (let i = 0;i < this.length; i++) {
+      let v = this.at(i);
+      if (!Number.isFinite(v))
+        continue;
+      if (v < lo)
+        lo = v;
+      if (v > hi)
+        hi = v;
+    }
+    return lo <= hi ? [lo, hi] : [Number.NaN, Number.NaN];
+  }
+  toArray() {
+    return Array.from({ length: this.length }, (_, i) => this.at(i));
+  }
+}
+
+class EntryLog {
+  max;
+  entries = [];
+  total = 0;
+  constructor(max) {
+    this.max = max;
+  }
+  push(entry) {
+    let time = entry.time ?? Date.now();
+    if (this.entries.push({ ...entry, level: entry.level ?? "info", time, seq: this.total++ }), this.entries.length > this.max)
+      this.entries.splice(0, this.entries.length - this.max);
+  }
+  clear() {
+    this.entries = [];
+  }
+}
+function readoutState(field) {
+  if (field.kind === "sparkline")
+    return { seq: 0, value: null, series: /* @__PURE__ */ new Map([["", new Ring(field.history ?? 60)]]) };
+  if (field.kind === "graph")
+    return {
+      seq: 0,
+      value: null,
+      series: new Map((field.series ?? []).map((s) => [s.id, new Ring(field.history ?? 120)]))
+    };
+  if (field.kind === "log")
+    return { seq: 0, value: null, log: new EntryLog(field.max ?? 1000) };
+  return { seq: 0, value: null };
+}
+var levels = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]), asEntry = (v) => typeof v === "string" ? { text: v } : v && typeof v === "object" && typeof v.text === "string" ? {
+  text: v.text,
+  ...levels.has(v.level) ? { level: v.level } : {},
+  ...typeof v.time === "number" ? { time: v.time } : {}
+} : void 0;
+function pushReadout(field, state, value) {
+  if (state.seq++, value === null || value === void 0) {
+    state.value = null;
+    for (let ring of state.series?.values() ?? [])
+      ring.clear();
+    state.log?.clear();
+    return;
+  }
+  if (field.kind === "sparkline") {
+    let ring = state.series.get("");
+    if (Array.isArray(value)) {
+      ring.clear();
+      for (let v of value)
+        ring.push(Number(v));
+    } else
+      ring.push(Number(value));
+    state.value = ring.last();
+    return;
+  }
+  if (field.kind === "graph") {
+    let record = typeof value === "number" ? { [field.series?.[0]?.id ?? ""]: value } : value;
+    for (let [id, ring] of state.series) {
+      let v = record[id];
+      ring.push(typeof v === "number" ? v : Number.NaN);
+    }
+    state.value = record;
+    return;
+  }
+  if (field.kind === "log") {
+    let list = Array.isArray(value) ? value : [value];
+    for (let item of list) {
+      let entry = asEntry(item);
+      if (entry)
+        state.log.push(entry);
+    }
+    state.value = state.log.entries.at(-1) ?? null;
+    return;
+  }
+  state.value = value;
+}
+var READOUT = Symbol.for("knobs.readout");
+
+// src/core/storage.ts
+function memoryStorage2() {
+  let data = /* @__PURE__ */ new Map;
+  return {
+    getItem: (key) => data.get(key) ?? null,
+    setItem: (key, value) => {
+      data.set(key, value);
+    }
+  };
+}
+function browserStorage() {
+  return typeof window > "u" ? null : window.localStorage;
+}
+function urlFlag2(name) {
+  return () => typeof location < "u" && new URLSearchParams(location.search).has(name);
+}
+var storageKey = (id, part) => `knobs:${encodeURIComponent(id)}:${part}:v1`;
+
+export { __preload, __chunks, maxChroma, oklchToRgb, parseColor2, fitColor, formatColor, colorHex2, EASINGS2, EASING_Y, easingName, bezierPoint2, bezierCss2, normalizeCombo2, letterOf2, comboFromEvent2, heldMods, matchesCombo2, comboParts2, comboLabel2, GRADIENT_SAMPLES, sampleGradient2, gradientSamples, gradientCss2, stopColorAt, sampleCurve2, curveSamples, CURVE_SHAPES2, inRange, sameRamp, randomStops, mutateStops, randomPoints, mutatePoints, pickMeta, isReadout2, hasValue2, SPRING2, valueKeys, knob2, choice2, action2, flatSpring2, toggle2, spring2, color2, point2, easing2, vec22, vec32, range2, angle2, seed2, keybind2, gradient2, curve2, toolbarShortcut2, toolbar2, watch2, sparkline2, graph2, meter2, table2, log2, wrapAngle2, normalizeField, normalize, isRecord, same, equal, Spring, springMotion2, springResponse, springEasing, springCss2, RESHAPE, RESET_KEYS, REFRESHES, readoutState, pushReadout, READOUT, memoryStorage2, browserStorage, urlFlag2, storageKey };