animl 0.0.0-stage → 0.1.0

package/modules/contour/core/index.js

@@ -0,0 +1,160 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { flatten, parsePath } from "../../../packages/core/src/path.js";
+import { fmt } from "../../../packages/core/src/draw.js";
+import { winding } from "./winding.js";
+import { effects } from "./effects.js";
+import { after } from "../manifest.js";
+const number = { k: "num" };
+const point = { k: "tup", of: [number, number], min: 2 };
+const vertex = {
+  k: "obj",
+  p: {
+    point,
+    kind: { k: "str", of: ["straight", "mirrored", "asymmetric", "detached", "rounded"] },
+    handle: point,
+    incoming: point,
+    outgoing: point,
+    radius: { k: "num", min: 0 }
+  },
+  req: ["point", "kind"]
+};
+const compiled = /* @__PURE__ */ new WeakMap();
+const add = (a, b) => [a[0] + b[0], a[1] + b[1]];
+const text = (a) => a.map(fmt).join(" ");
+function compileVertices(vertices, closed = false, origin = [0, 0]) {
+  const points = vertices.map((v) => add(v.point, [-origin[0], -origin[1]]));
+  const handles = vertices.map((v) => {
+    let incoming = [0, 0], outgoing = [0, 0];
+    if (v.kind === "mirrored") {
+      outgoing = v.handle ?? [0, 0];
+      incoming = [-outgoing[0], -outgoing[1]];
+    } else if (v.kind === "asymmetric") {
+      outgoing = v.outgoing ?? [0, 0];
+      const length = Math.hypot(...outgoing);
+      const magnitude = Math.hypot(...v.incoming ?? [0, 0]);
+      incoming = length ? [-outgoing[0] * magnitude / length, -outgoing[1] * magnitude / length] : [0, 0];
+    } else if (v.kind === "detached") {
+      incoming = v.incoming ?? [0, 0];
+      outgoing = v.outgoing ?? [0, 0];
+    }
+    return { incoming, outgoing };
+  });
+  const contours = vertices.map((v, i) => {
+    const p = points[i];
+    const rounded = v.kind === "rounded" && (closed || i > 0 && i < vertices.length - 1);
+    let a = p, b = p, c1 = p, c2 = p;
+    if (rounded) {
+      const previous = (i + points.length - 1) % points.length;
+      const next = (i + 1) % points.length;
+      const u = add(add(points[previous], handles[previous].outgoing), [-p[0], -p[1]]);
+      const v2 = add(add(points[next], handles[next].incoming), [-p[0], -p[1]]);
+      const ul = Math.hypot(...u), vl = Math.hypot(...v2);
+      const radius = Math.min(vertices[i].radius ?? 0, ul / 2, vl / 2);
+      if (ul && vl) {
+        const angle = Math.atan2(Math.abs(u[0] * v2[1] - u[1] * v2[0]), u[0] * v2[0] + u[1] * v2[1]);
+        const fraction = Math.min(
+          1,
+          4 / 3 * Math.tan(angle / 4) * (angle < Math.PI / 2 ? 1 + Math.cos(angle) : 2 - Math.sin(angle))
+        );
+        a = add(p, [radius * u[0] / ul, radius * u[1] / ul]);
+        b = add(p, [radius * v2[0] / vl, radius * v2[1] / vl]);
+        c1 = add(a, [(p[0] - a[0]) * fraction, (p[1] - a[1]) * fraction]);
+        c2 = add(b, [(p[0] - b[0]) * fraction, (p[1] - b[1]) * fraction]);
+      }
+    }
+    return { p, a, b, c1, c2, ...handles[i], rounded };
+  });
+  let d = "M" + text(contours[0].a);
+  const edge = (i, j) => {
+    const a = contours[i], b = contours[j];
+    const curved = [...a.outgoing, ...b.incoming].some(Boolean);
+    return curved ? "C" + text(add(a.b, a.outgoing)) + " " + text(add(b.a, b.incoming)) + " " + text(b.a) : "L" + text(b.a);
+  };
+  for (let i = 0; i < contours.length; i++) {
+    const v = contours[i];
+    if (v.rounded) d += "C" + text(v.c1) + " " + text(v.c2) + " " + text(v.b);
+    if (i + 1 < contours.length) d += edge(i, i + 1);
+    else if (closed) d += edge(i, 0) + "Z";
+  }
+  return d;
+}
+const contour = {
+  // seam(P8-9): expose the pure bounds reader through the active module registry.
+  undashed: effects.undashed,
+  name: "contour",
+  after,
+  entries: [
+    ...effects.entries,
+    ...winding.entries,
+    {
+      target: "contour",
+      node: { painted: true },
+      shapes: {
+        vertices: { k: "alt", of: [{ k: "arr", of: vertex, min: 2 }] },
+        closed: { k: "bool" },
+        geometryOrigin: { ...point, markup: "geometry-origin" }
+      },
+      required: ["id", "type", "vertices"]
+    }
+  ],
+  load(model, _raw, d) {
+    effects.load?.(model, _raw, d);
+    const paths = [], counts = /* @__PURE__ */ new Map();
+    model.nodes.forEach((n, i) => {
+      const index = counts.get(n.parent) ?? 0;
+      counts.set(n.parent, index + 1);
+      const pointer = paths[i] = (n.parent < 0 ? "/nodes" : paths[n.parent] + "/children") + "/" + index;
+      if (String(n.type) !== "contour") return;
+      n.raw.vertices.forEach((v, j) => {
+        const permitted = v.kind === "mirrored" ? ["handle"] : v.kind === "asymmetric" || v.kind === "detached" ? ["incoming", "outgoing"] : v.kind === "rounded" ? ["radius"] : [];
+        for (const key of ["handle", "incoming", "outgoing", "radius"])
+          if (key in v && !permitted.includes(key))
+            d.err(
+              "bad-value",
+              `${pointer}/vertices/${j}/${key}`,
+              V && `${key} does not belong to ${v.kind} vertices`,
+              V && `use ${permitted.join(", ") || "only point and kind"}`
+            );
+        if (v.kind === "asymmetric" && !v.outgoing?.some(Boolean) && v.incoming?.some(Boolean))
+          d.err(
+            "bad-value",
+            `${pointer}/vertices/${j}/outgoing`,
+            V && "asymmetric incoming length needs an outgoing direction",
+            V && "supply a nonzero outgoing handle"
+          );
+      });
+      compiled.set(n.raw, compileVertices(n.raw.vertices, n.raw.closed, n.raw.geometryOrigin));
+    });
+  },
+  // seam(P8-3): expose exact compiled local path data so path following uses shared outline subdivision.
+  pathfollowPath(p, i) {
+    return compiled.get(p.model.nodes[i].raw);
+  },
+  outline(p, i) {
+    if (p.model.nodes[i].raw.skin) return;
+    const d = compiled.get(p.model.nodes[i].raw);
+    if (d !== void 0) return flatten(parsePath(d));
+  },
+  fillContains: winding.fillContains,
+  draw: {
+    tree(model, tree) {
+      model.nodes.forEach((n, i) => {
+        if (String(n.type) === "contour") tree.nodes[i].kind = "path";
+        if (n.raw.fill?.winding || n.raw.paints?.some((p) => p.fill?.winding) || n.raw.stroke?.trim || n.raw.stroke?.effects || n.raw.paints?.some(
+          (p) => p.stroke?.trim || p.stroke?.effects
+        ))
+          tree.resources.push({ node: i, kind: "contour-effects" });
+      });
+    },
+    frame(p, i, data, entry, frame) {
+      const d = compiled.get(p.model.nodes[i].raw);
+      if (d !== void 0) data.geometry = { kind: "path", d };
+      effects.draw?.frame?.(p, i, data, entry, frame);
+      winding.draw?.frame?.(p, i, data, entry, frame);
+    }
+  }
+};
+export {
+  compileVertices,
+  contour
+};

package/modules/contour/core/svg.d.ts

@@ -0,0 +1,2 @@
+import type { SVGBackend } from '../../../packages/core/src/svg.js';
+export declare const contourSVG: SVGBackend;

package/modules/contour/core/svg.js

@@ -0,0 +1,47 @@
+import { geometryPath } from "./effects.js";
+const contourSVG = {
+  tree(draw, tree) {
+    const affected = new Set(
+      draw.resources.filter((r) => r.kind === "contour-effects").map((r) => r.node)
+    );
+    const visit = (el) => {
+      el.kids.forEach(visit);
+      if (!affected.has(el.node)) return;
+      if (el.role === "shape") {
+        el.tag = "g";
+        el.kids = ["fill", "stroke"].map((key) => ({
+          tag: "path",
+          role: "module:contour",
+          node: el.node,
+          key,
+          kids: []
+        }));
+      } else if (el.role === "module:composite" && ["paint", "stroke-only", "fill-only"].includes(el.key))
+        el.tag = "path";
+    };
+    tree.root.forEach(visit);
+    tree.defs.forEach(visit);
+  },
+  attrs(frame, el, paint, id, attrs, render) {
+    const node = frame.nodes[el.node];
+    if (el.role === "shape" && el.tag === "g" && frame.tree.resources.some((r) => r.node === el.node && r.kind === "contour-effects")) {
+      attrs.fill = "none";
+      attrs.stroke = "none";
+    }
+    if (el.role === "module:contour") {
+      const selected = node.paints.find((p) => p.kind === el.key);
+      const nodes = frame.nodes.slice();
+      nodes[el.node] = { ...node, paints: selected ? [selected] : [] };
+      Object.assign(attrs, render({ ...frame, nodes }, { ...el, role: "shape" }, paint, id));
+      if (!selected) attrs.display = "none";
+      attrs[selected?.kind === "fill" ? "stroke" : "fill"] = "none";
+      if (node.geometry) attrs.d = selected?.geometry?.d ?? geometryPath(node.geometry);
+    } else if (frame.tree.resources.some((r) => r.node === el.node && r.kind === "contour-effects") && el.role === "module:composite" && ["paint", "stroke-only", "fill-only"].includes(el.key)) {
+      const selected = el.key === "paint" ? node.paints[el.index] : node.paints.find((p) => p.kind === (el.key === "fill-only" ? "fill" : "stroke"));
+      if (node.geometry) attrs.d = selected?.geometry?.d ?? geometryPath(node.geometry);
+    }
+  }
+};
+export {
+  contourSVG
+};

package/modules/contour/core/winding.d.ts

@@ -0,0 +1,3 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare function clockwisePath(d: string): string;
+export declare const winding: Module;

package/modules/contour/core/winding.js

@@ -0,0 +1,95 @@
+import { polylines, geometryPath } from "./effects.js";
+import { inside } from "../../../packages/core/src/geom.js";
+import { fmt } from "../../../packages/core/src/draw.js";
+function clockwisePath(d) {
+  const edges = [], ys = [];
+  for (const line of polylines(d)) {
+    for (let i = 0; i < line.length; i++) {
+      const a = line[i], b = line[(i + 1) % line.length];
+      ys.push(a[1]);
+      if (a[1] === b[1]) continue;
+      edges.push({ x: a[0], y: a[1], dx: b[0] - a[0], dy: b[1] - a[1] });
+    }
+  }
+  const at = (e, y) => e.x + (y - e.y) * e.dx / e.dy;
+  const active = (e, y) => y > Math.min(e.y, e.y + e.dy) && y < Math.max(e.y, e.y + e.dy);
+  for (let i = 0; i < edges.length; i++)
+    for (let j = i + 1; j < edges.length; j++) {
+      const a = edges[i], b = edges[j], slope = a.dx / a.dy - b.dx / b.dy;
+      if (!slope) continue;
+      const y = (b.x - b.y * b.dx / b.dy - a.x + a.y * a.dx / a.dy) / slope;
+      if (active(a, y) && active(b, y)) ys.push(y);
+    }
+  const levels = [...new Set(ys)].sort((a, b) => a - b);
+  let out = "";
+  for (let i = 1; i < levels.length; i++) {
+    const low = levels[i - 1], high = levels[i], mid = (low + high) / 2;
+    const crossings = edges.filter((e) => active(e, mid)).sort((a, b) => at(a, mid) - at(b, mid));
+    let wind = 0, left;
+    for (const e of crossings) {
+      const before = wind;
+      wind -= Math.sign(e.dy);
+      if (before <= 0 && wind > 0) left = e;
+      if (before > 0 && wind <= 0 && left) {
+        const coords = [
+          [at(left, low), low],
+          [at(e, low), low],
+          [at(e, high), high],
+          [at(left, high), high]
+        ];
+        out += coords.map((p, j) => (j ? "L" : "M") + p.map(fmt).join(" ")).join("") + "Z";
+        left = void 0;
+      }
+    }
+  }
+  return out;
+}
+const winding = {
+  name: "contour",
+  entries: [
+    {
+      target: "fill",
+      shapes: { winding: { k: "str", of: ["clockwise"], markup: "fill-winding" } }
+    }
+  ],
+  fillContains(p, i, outline, x, y) {
+    const raw = p.model.nodes[i].raw;
+    const fills = (raw.paints ?? [raw]).map(
+      (paint, j) => p.prop(i, (raw.paints ? `paints.${j}.` : "") + "fill.visible") !== false && paint.fill
+    );
+    if (!fills.some((fill) => fill?.winding === "clockwise"))
+      return;
+    let wind = 0;
+    for (const { pts } of outline)
+      for (let j = 0; j < pts.length; j += 2) {
+        const x0 = pts[j], y0 = pts[j + 1], x1 = pts[(j + 2) % pts.length], y1 = pts[(j + 3) % pts.length];
+        if ((y0 <= y ? y1 > y : y1 <= y) && x0 + (y - y0) / (y1 - y0) * (x1 - x0) > x)
+          wind += y1 > y0 ? 1 : -1;
+      }
+    return fills.some(
+      (fill) => fill && (fill.winding === "clockwise" ? wind > 0 : inside(
+        outline.filter((p2) => p2.closed).map((p2) => p2.pts),
+        x,
+        y,
+        fill.rule === "evenodd"
+      ))
+    );
+  },
+  draw: {
+    frame(p, i, data) {
+      if (!data.geometry) return;
+      for (const paint of data.paints) {
+        if (paint.kind !== "fill") continue;
+        const raw = (paint.key ?? paint.kind).split(".").reduce((o, k) => o?.[k], p.model.nodes[i].raw);
+        if (raw?.winding === "clockwise") {
+          paint.geometry = { kind: "path", d: clockwisePath(geometryPath(data.geometry)) };
+          paint.rule = "nonzero";
+        }
+      }
+    }
+  }
+};
+export {
+  clockwisePath,
+  winding
+};

package/modules/contour/manifest.d.ts

@@ -0,0 +1,31 @@
+export declare const after: string[];
+declare const _default: {
+    after: string[];
+    name: string;
+    summary: string;
+    core: {
+        entry: string;
+        export: string;
+        svg: string;
+        svgExport: string;
+    };
+    web: {
+        name: string;
+        budget: number;
+    }[];
+    adapters: {
+        'packages/core/src/modules/contour/index.ts': string;
+        'packages/core/src/modules/contour/svg.ts': string;
+        'packages/markup/src/contour.ts': string;
+        'packages/web/src/contour.ts': string;
+    };
+    exports: {
+        'core:./contour': string;
+        'markup:./contour': string;
+        'web:./contour': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/contour/manifest.js

@@ -0,0 +1,50 @@
+const after = ["paint", "composite"];
+var manifest_default = {
+  ...{
+    name: "contour",
+    summary: "Contours: shapes built from straight, smooth and rounded vertices, with path operations.",
+    after: [],
+    core: {
+      entry: "core/index.ts",
+      export: "contour",
+      svg: "core/svg.ts",
+      svgExport: "contourSVG"
+    },
+    web: [{ name: "contour", budget: 3840 }],
+    adapters: {
+      "packages/core/src/modules/contour/index.ts": "core/index.ts",
+      "packages/core/src/modules/contour/svg.ts": "core/svg.ts",
+      "packages/markup/src/contour.ts": "markup/index.ts",
+      "packages/web/src/contour.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./contour": "packages/core/src/modules/contour/index.ts",
+      "markup:./contour": "packages/markup/src/contour.ts",
+      "web:./contour": "packages/web/src/contour.ts"
+    },
+    tests: [
+      "modules/contour/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts"
+    ],
+    conformance: [
+      "drawing-paint-straight-vertex",
+      "drawing-paint-mirrored-vertex",
+      "drawing-paint-asymmetric-vertex",
+      "drawing-paint-detached-vertex",
+      "drawing-paint-rounded-vertex",
+      "drawing-paint-geometry-origin",
+      "drawing-paint-trim-sequential",
+      "drawing-paint-trim-synchronized",
+      "drawing-paint-effect-order",
+      "drawing-paint-shared-effects",
+      "drawing-paint-fill-rule-clockwise"
+    ],
+    docs: ["spec/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

package/modules/contour/markup/index.d.ts

@@ -0,0 +1 @@
+export {};

package/modules/contour/web/index.d.ts

@@ -0,0 +1 @@
+import '../../../packages/web/src/index.js';

package/modules/contour/web/index.js

@@ -0,0 +1,5 @@
+import { contour } from "../core/index.js";
+import { contourSVG } from "../core/svg.js";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerModule(contour);
+customElements.get("anima-icon").registerSVGBackend("contour", contourSVG);

package/modules/convert/core/converters.d.ts

@@ -0,0 +1,4 @@
+import type { Converter, ConverterContext, ConverterOptions, ConverterValue } from './types.js';
+export declare const converterRegistry: Map<string, Converter>;
+export declare function registerConverter(name: string, converter: Converter): void;
+export declare function convertValue(type: string, value: ConverterValue, options?: ConverterOptions, ctx?: ConverterContext): ConverterValue;

package/modules/convert/core/converters.js

@@ -0,0 +1,253 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { parseEase } from "../../../packages/core/src/ease.js";
+import { parseHex, lerpColor } from "../../../packages/core/src/color.js";
+import { formula, seededRandom, mathFunctions } from "./math.js";
+import {
+  bad,
+  choice,
+  numeric,
+  string,
+  numberOption as opt,
+  mismatch,
+  ConverterError
+} from "./types.js";
+const converterRegistry = /* @__PURE__ */ new Map();
+function registerConverter(name, converter) {
+  converterRegistry.set(name, converter);
+}
+function pair(o, key, fallback) {
+  const v = o[key] ?? fallback;
+  if (!Array.isArray(v) || v.length !== 2 || v.some((n) => typeof n !== "number" || !Number.isFinite(n)))
+    bad(V ? "expected two finite numbers" : "", key);
+  return v;
+}
+function integer(o, key, fallback, max = 1e4) {
+  const n = opt(o, key, fallback);
+  if (!Number.isInteger(n) || n < 0 || n > max) bad(V ? `expected integer 0..${max}` : "", key);
+  return n;
+}
+function format(value, o) {
+  const decimals = integer(o, "decimals", 0, 100);
+  const [integerPart, fraction] = numeric(value).toFixed(decimals).split(".");
+  let whole = integerPart;
+  if (o.grouping) whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return whole + (fraction === void 0 ? "" : "." + fraction);
+}
+function color(value) {
+  const c = typeof value === "string" ? parseHex(value) : Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 255) ? value : void 0;
+  return c ?? mismatch(V ? "hex colour or RGBA tuple" : "");
+}
+const eases = /* @__PURE__ */ new Map();
+function ease(o, t) {
+  const name = o.ease ?? "linear";
+  if (typeof name !== "string") bad(V ? "expected easing string" : "", "ease");
+  let fn = eases.get(name);
+  if (!fn) {
+    const parsed = parseEase(name);
+    if (typeof parsed === "string") bad(V ? parsed : "", "ease");
+    fn = parsed;
+    if (eases.size > 256) eases.clear();
+    eases.set(name, fn);
+  }
+  return fn(t);
+}
+const interpolation = {};
+const formulaCache = /* @__PURE__ */ new Map();
+const implementations = {
+  range: (v, o) => {
+    const [a, b] = pair(o, "from", [0, 1]), [c, d] = pair(o, "to", [0, 1]);
+    if (a === b) bad(V ? "source range must have nonzero width" : "", "from");
+    let t = (numeric(v) - a) / (b - a);
+    if (o.modulo) t = (t % 1 + 1) % 1;
+    if (o.clamp) t = Math.max(0, Math.min(1, t));
+    if (o.reverse) t = 1 - t;
+    return c + (d - c) * ease(o, t);
+  },
+  round: (v, o) => {
+    const f = 10 ** integer(o, "decimals", 0, 100);
+    const n = numeric(v) * f;
+    return (choice(o, "mode", ["round", "floor", "ceil"], "round") === "floor" ? Math.floor(n) : o.mode === "ceil" ? Math.ceil(n) : Math.round(n)) / f;
+  },
+  negate: (v) => typeof v === "boolean" ? !v : mismatch(V ? "boolean" : ""),
+  "to-number": (v) => {
+    if (typeof v !== "string" && typeof v !== "boolean" && typeof v !== "number")
+      mismatch(V ? "number, boolean or numeric string" : "");
+    const n = Number(v);
+    return Number.isFinite(n) ? n : 0;
+  },
+  "to-string": (v) => String(v),
+  "number-format": format,
+  "color-format": (v, o) => {
+    const c = color(v).map(Math.round);
+    if (o.pattern !== void 0) {
+      if (typeof o.pattern !== "string") bad(V ? "pattern must be a string" : "", "pattern");
+      const [r, g, b, a] = c;
+      const [x, y, z] = [r / 255, g / 255, b / 255];
+      const hi = Math.max(x, y, z), lo = Math.min(x, y, z), delta = hi - lo;
+      const l = (hi + lo) / 2;
+      const h = !delta ? 0 : 60 * (hi === x ? ((y - z) / delta + 6) % 6 : hi === y ? (z - x) / delta + 2 : (x - y) / delta + 4);
+      const markers = {
+        r,
+        g,
+        b,
+        a,
+        h: Math.round(h),
+        s: Math.round((delta ? delta / (1 - Math.abs(2 * l - 1)) : 0) * 100),
+        l: Math.round(l * 100),
+        hex: "#" + c.slice(0, 3).map((n) => n.toString(16).padStart(2, "0")).join("")
+      };
+      return o.pattern.replace(/\{([^{}]*)\}/g, (_token, name) => {
+        if (!Object.hasOwn(markers, name)) bad(V ? "unknown colour marker " + name : "", "pattern");
+        return String(markers[name]);
+      });
+    }
+    return choice(o, "format", ["hex", "hexa", "rgb", "rgba"], "hex").startsWith("hex") ? "#" + c.slice(0, o.format === "hexa" ? 4 : 3).map((n) => n.toString(16).padStart(2, "0")).join("") : o.format === "rgba" ? `rgba(${c[0]}, ${c[1]}, ${c[2]}, ${c[3] / 255})` : `rgb(${c[0]}, ${c[1]}, ${c[2]})`;
+  },
+  pad: (v, o) => {
+    const text = string(v), length = integer(o, "length", 0), fill = o.fill ?? " ";
+    if (typeof fill !== "string" || !fill.length)
+      bad(V ? "fill must be a nonempty string" : "", "fill");
+    return choice(o, "side", ["start", "end"], "start") === "start" ? text.padStart(length, fill) : text.padEnd(length, fill);
+  },
+  trim: (v, o) => {
+    const t = string(v), mode = choice(o, "mode", ["start", "end", "all", "none"], "all");
+    return mode === "none" ? t : mode === "start" ? t.trimStart() : mode === "end" ? t.trimEnd() : t.trim();
+  },
+  template: (v, o) => {
+    if (typeof o.text !== "string") bad(V ? "text is required" : "", "text");
+    const open = o.open ?? "{", close = o.close ?? "}";
+    if (typeof open !== "string" || typeof close !== "string" || !open || !close)
+      bad(V ? "delimiters must be nonempty strings" : "");
+    const args = o.args ?? (Array.isArray(v) ? v : [v]);
+    if (!args || typeof args !== "object") bad(V ? "args must be an array or object" : "", "args");
+    let position = 0;
+    let result = "", rest = o.text;
+    while (rest.includes(open)) {
+      const i = rest.indexOf(open);
+      result += rest.slice(0, i);
+      rest = rest.slice(i + open.length);
+      const j = rest.indexOf(close);
+      if (j < 0) {
+        result += open + rest;
+        rest = "";
+        break;
+      }
+      const token = rest.slice(0, j), match = /^([\w-]*)(?::(\d+))?(?::(\d+))?$/.exec(token);
+      if (!match) bad(V ? "expected positional argument, optionally :decimals" : "", "text");
+      const arg = args[match[1] || String(position++)];
+      if (arg === void 0) mismatch(V ? "template argument" : "");
+      const replacement = match[2] === void 0 ? String(arg) : format(arg, { decimals: Number(match[2]), grouping: o.grouping });
+      const width = Number(match[3] ?? 0);
+      if (width > 1e4) bad(V ? "template width exceeds 10000" : "", "text");
+      result += replacement.padStart(width, " ");
+      rest = rest.slice(j + close.length);
+    }
+    return result + rest;
+  },
+  "remove-zeros": (v) => string(v).replace(/(\.\d*?[1-9])0+(?=$|[^\d])|\.0+(?=$|[^\d])/g, "$1"),
+  "enum-to-index": (v, o) => {
+    if (!Array.isArray(o.values)) bad(V ? "values array is required" : "", "values");
+    const index = o.values.indexOf(v);
+    return index < 0 ? mismatch(V ? "declared enum value" : "") : index;
+  },
+  "list-length": (v) => Array.isArray(v) ? v.length : mismatch(V ? "list" : ""),
+  "number-to-list": (v, o) => {
+    const n = numeric(v);
+    if (!Number.isInteger(n) || n < 0 || n > 1e4) mismatch(V ? "list length 0..10000" : "");
+    return Array.from(
+      { length: n },
+      (_, i) => o.item === void 0 ? i : o.item
+    );
+  },
+  trigger: (v) => typeof v === "boolean" ? v : Math.trunc(numeric(v)),
+  "degrees-to-radians": (v, _o, ctx) => ctx.direction === "reverse" ? numeric(v) * 180 / Math.PI : numeric(v) * Math.PI / 180,
+  normalize: (v, o, ctx) => {
+    const [a, b] = pair(o, "from", [0, 1]);
+    if (a === b) bad(V ? "source range must have nonzero width" : "", "from");
+    return ctx.direction === "reverse" ? a + numeric(v) * (b - a) : (numeric(v) - a) / (b - a);
+  },
+  formula: (v, o, ctx) => {
+    if (typeof o.expression !== "string") bad(V ? "expression is required" : "", "expression");
+    const mode = choice(o, "random", ["always", "once", "on-change"], "always");
+    const scope = new Map(ctx.values);
+    for (const path of o.expression.match(
+      /\$[a-zA-Z][\w-]*(?::[a-zA-Z][\w-]*)?(?:\.[\w-]+)*/g
+    ) ?? [])
+      scope.set(path, ctx.get?.(path));
+    scope.set("value", numeric(v));
+    const types = new Map(
+      [...scope].map(([name, value]) => [name, typeof value === "boolean" ? "bool" : "number"])
+    );
+    const key = JSON.stringify([o.expression, [...types]]);
+    let run = formulaCache.get(key);
+    if (!run) {
+      run = formula(o.expression, types);
+      if (formulaCache.size > 256) formulaCache.clear();
+      formulaCache.set(key, run);
+    }
+    if (mode === "always" && /\brandom\s*\(/.test(o.expression)) ctx.active?.();
+    return run(scope, ctx, mode, v);
+  },
+  calculate: (v, o, ctx) => {
+    const n = numeric(v), operand = opt(o, "operand", 1), operation = o.operation;
+    if (operation === "add") return n + operand;
+    if (operation === "subtract") return n - operand;
+    if (operation === "multiply") return n * operand;
+    if (operation === "divide") return operand === 0 ? 0 : n / operand;
+    if (operation === "modulo") return operand === 0 ? 0 : n - operand * Math.floor(n / operand);
+    if (operation === "random") {
+      const mode = choice(o, "random", ["always", "once", "on-change"], "always");
+      if (mode === "always") ctx.active?.();
+      return seededRandom(ctx, mode, v);
+    }
+    const fn = mathFunctions.get(String(operation));
+    if (!fn) bad(V ? "unknown calculation" : "", "operation");
+    return fn.evaluate(n, ...fn.arity === 2 ? [operand] : []);
+  },
+  interpolate: (v, o, ctx) => {
+    const duration = opt(o, "duration", 0);
+    if (duration < 0) bad(V ? "duration must be nonnegative" : "", "duration");
+    ease(o, 0);
+    const target = typeof v === "number" ? numeric(v) : [...color(v)];
+    let states = ctx.state.get(interpolation);
+    if (!states) ctx.state.set(interpolation, states = /* @__PURE__ */ new Map());
+    const key = ctx.key ?? "default";
+    let s = states.get(key);
+    const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    const sample = (state) => {
+      const progress = duration === 0 ? 1 : Math.max(0, Math.min(1, (ctx.time - state.start) / duration));
+      const t = progress === 1 ? 1 : ease(o, progress);
+      return typeof state.from === "number" && typeof state.target === "number" ? state.from + (state.target - state.from) * t : lerpColor(color(state.from), color(state.target), t);
+    };
+    if (!s) {
+      s = { from: target, target, value: target, start: ctx.time };
+      states.set(key, s);
+    } else if (!equal(target, s.target)) {
+      const from = sample(s);
+      if (typeof from === "number" !== (typeof target === "number"))
+        mismatch(V ? "same interpolation type" : "");
+      s.from = from;
+      s.target = target;
+      s.start = ctx.time;
+    }
+    if (duration > 0 && ctx.time < s.start + duration && !equal(s.from, s.target)) ctx.active?.();
+    return s.value = sample(s);
+  }
+};
+for (const [name, fn] of Object.entries(implementations)) registerConverter(name, fn);
+function convertValue(type, value, options = {}, ctx = { player: {}, time: 0, state: /* @__PURE__ */ new Map() }) {
+  const fn = converterRegistry.get(type);
+  if (!fn)
+    throw new ConverterError(
+      "convert-unknown-type",
+      V ? `unknown converter type ${type}` : "",
+      "type"
+    );
+  const result = fn(value, options, ctx);
+  return typeof result === "number" && !Number.isFinite(result) ? 0 : result;
+}
+export {
+  convertValue,
+  converterRegistry,
+  registerConverter
+};