animl 0.0.0-stage → 0.1.0

package/modules/composite/core/svg.js

@@ -0,0 +1,249 @@
+import { fmt } from "../../../packages/core/src/draw.js";
+import { IDENTITY, invert, mul, apply } from "../../../packages/core/src/geom.js";
+import { parsePath } from "../../../packages/core/src/path.js";
+const matrix = (m) => `matrix(${m.map(fmt).join(" ")})`;
+const element = (tag, node, key, kids = []) => ({
+  tag,
+  node,
+  key,
+  role: "module:composite",
+  kids
+});
+const cp = (el) => ({ ...el, kids: el.kids.map(cp) });
+const compositeSVG = {
+  tree(m, tree) {
+    const originals = /* @__PURE__ */ new Map();
+    const collect = (els) => els.forEach((el) => {
+      if (el.role === "node") originals.set(el.node, cp(el));
+      collect(el.kids);
+    });
+    collect(tree.root);
+    const sources = /* @__PURE__ */ new Set();
+    const process = (els) => {
+      for (let j = 0; j < els.length; j++) {
+        const el = els[j];
+        if (el.role !== "node") {
+          process(el.kids);
+          continue;
+        }
+        process(el.kids);
+        const r = m.nodes[el.node];
+        if (r.paints) {
+          el.kids = r.paints.map((_v, index) => ({
+            ...el.kids[0],
+            role: "module:composite",
+            key: "paint",
+            index
+          }));
+        }
+        for (const key of ["mask", "clip"])
+          if (r[key]) {
+            const source = r[key].source;
+            if (key === "mask" && !sources.has(source)) {
+              sources.add(source);
+              const drawing = [cp(originals.get(source))];
+              process(drawing);
+              tree.defs.push(element("g", source, "source", drawing));
+            }
+            const relative = element("g", source, `relative:${el.node}`, [
+              element("use", source, "use")
+            ]);
+            if (key === "mask" && r.mask.mode.startsWith("inverted-"))
+              tree.defs.push(
+                element("filter", el.node, "invert", [
+                  ...r.mask.mode.endsWith("luminance") ? [
+                    element("feColorMatrix", el.node, "luminance"),
+                    element("feComposite", el.node, "coverage")
+                  ] : [],
+                  element("feComponentTransfer", el.node, "transfer", [
+                    element("feFuncA", el.node, "invert-alpha")
+                  ])
+                ])
+              );
+            if (key === "mask" && r.mask.mode.startsWith("inverted-"))
+              relative.key = `inverted:${el.node}`;
+            tree.defs.push(
+              element(
+                key === "mask" ? "mask" : "clipPath",
+                el.node,
+                key,
+                key === "clip" ? [element("path", source, `clip-outline:${el.node}`)] : [relative]
+              )
+            );
+            els[j] = element("g", el.node, key + "-wrap", [els[j]]);
+          }
+        if (r.position && r.position !== "center") {
+          const outside = r.position === "outside";
+          tree.defs.push(
+            element(outside ? "mask" : "clipPath", el.node, "position", [
+              ...outside ? [element("rect", el.node, "white")] : [],
+              {
+                ...cp(originals.get(el.node).kids[0]),
+                role: "module:composite",
+                key: outside ? "black" : "outline"
+              }
+            ])
+          );
+          const shape = el.kids[0];
+          el.kids = [
+            { ...cp(shape), role: "module:composite", key: "fill-only" },
+            element("g", el.node, "position-wrap", [
+              { ...shape, role: "module:composite", key: "stroke-only" }
+            ])
+          ];
+        }
+      }
+    };
+    process(tree.root);
+    const definitions = /* @__PURE__ */ new Set();
+    tree.defs = tree.defs.filter((el) => {
+      const key = `${el.node}:${el.key}:${el.role}`;
+      if (definitions.has(key)) return false;
+      definitions.add(key);
+      return true;
+    });
+    const hidden = new Set(
+      m.nodes.flatMap((n) => n.mask?.sourceDraws === false ? [n.mask.source] : [])
+    );
+    const hide = (els) => els.forEach((el) => {
+      if (el.role === "node" && hidden.has(el.node)) el.key = "hidden";
+      hide(el.kids);
+    });
+    hide(tree.root);
+  },
+  attrs(p, el, paint, id, a, render) {
+    const i = el.node, r = p.nodes[i];
+    const ref = (key2) => `url(#${id}c${i}-${key2})`;
+    if (el.role === "node") {
+      if (r.blend) a.style = `mix-blend-mode:${r.blend}`;
+      if (el.key === "hidden") a.display = "none";
+    }
+    if (el.role === "shape") {
+      for (const kind of ["fill", "stroke"])
+        if (r.paints.find((p2) => p2.kind === kind)?.visible === false) a[kind] = "none";
+    }
+    if (el.role !== "module:composite") return;
+    const key = el.key;
+    if (key === "source") {
+      a.id = `${id}c${i}-source`;
+      return;
+    }
+    if (key === "use") {
+      a.href = `#${id}c${i}-source`;
+      return;
+    }
+    if (key.endsWith("-wrap")) {
+      a["data-anima-wrap"] = "true";
+      a[key === "mask-wrap" || key === "position-wrap" && r.paints.find((p2) => p2.kind === "stroke")?.position === "outside" ? "mask" : "clip-path"] = ref(key.slice(0, -5));
+      return;
+    }
+    const [x, y, w, h] = p.viewBox;
+    const box = { x: fmt(x - w), y: fmt(y - h), width: fmt(w * 3), height: fmt(h * 3) };
+    if (key === "mask" || key === "clip" || key === "position") {
+      a.id = `${id}c${i}-${key}`;
+      if (el.tag === "mask")
+        Object.assign(a, box, {
+          maskUnits: "userSpaceOnUse",
+          "mask-type": key === "mask" && (r.mask.mode.endsWith("alpha") || r.mask.mode.startsWith("inverted-")) ? "alpha" : "luminance"
+        });
+      return;
+    }
+    if (key.startsWith("clip-outline:")) {
+      const target = +key.split(":")[1];
+      const parent = p.tree.nodes[target].parent;
+      const inv = invert(parent < 0 ? IDENTITY : p.nodes[parent].world);
+      const geom = shapeAttrs(render, p, el, paint, id);
+      let d = geom.d;
+      if (!d && geom.r) {
+        const x2 = +geom.cx, y2 = +geom.cy, r2 = +geom.r;
+        d = `M${x2 - r2} ${y2}a${r2} ${r2} 0 1 0 ${2 * r2} 0a${r2} ${r2} 0 1 0 ${-2 * r2} 0Z`;
+      }
+      if (!d) {
+        const x2 = +geom.x, y2 = +geom.y, w2 = +geom.width, h2 = +geom.height, r2 = Math.min(+(geom.rx ?? 0), w2 / 2), q = Math.min(+(geom.rx ?? 0), h2 / 2);
+        d = `M${x2 + r2} ${y2}h${w2 - 2 * r2}a${r2} ${q} 0 0 1 ${r2} ${q}v${h2 - 2 * q}a${r2} ${q} 0 0 1 ${-r2} ${q}h${-w2 + 2 * r2}a${r2} ${q} 0 0 1 ${-r2} ${-q}v${-h2 + 2 * q}a${r2} ${q} 0 0 1 ${r2} ${-q}Z`;
+      }
+      const transform = inv ? mul(inv, p.nodes[i].world) : IDENTITY;
+      a.d = inv ? parsePath(d).map((path) => {
+        let out = "";
+        for (let j = 0; j < path.segs.length; ) {
+          const op = path.segs[j++];
+          out += ["M", "L", "C", "Z"][op];
+          for (let k = 0; k < (op === 2 ? 3 : op === 3 ? 0 : 1); k++) {
+            const pt = apply(transform, path.segs[j++], path.segs[j++]);
+            out += pt.map(fmt).join(" ") + " ";
+          }
+        }
+        return out;
+      }).join("") : "";
+      a["clip-rule"] = p.nodes[target].clip.rule;
+      return;
+    }
+    if (key === "invert") {
+      Object.assign(a, box, {
+        id: `${id}c${i}-invert`,
+        filterUnits: "userSpaceOnUse",
+        "color-interpolation-filters": "sRGB"
+      });
+      return;
+    }
+    if (key === "luminance") {
+      a.type = "luminanceToAlpha";
+      return;
+    }
+    if (key === "coverage") {
+      Object.assign(a, { operator: "in", in2: "SourceGraphic" });
+      return;
+    }
+    if (key === "transfer") return;
+    if (key === "invert-alpha") {
+      Object.assign(a, { type: "table", tableValues: "1 0" });
+      return;
+    }
+    if (key.startsWith("relative:") || key.startsWith("inverted:")) {
+      const target = +key.split(":")[1];
+      if (key.startsWith("inverted:")) a.filter = `url(#${id}c${target}-invert)`;
+      const parent = p.tree.nodes[target].parent, sourceParent = p.tree.nodes[i].parent;
+      const inv = invert(parent < 0 ? IDENTITY : p.nodes[parent].world);
+      a.transform = matrix(
+        inv ? mul(inv, sourceParent < 0 ? IDENTITY : p.nodes[sourceParent].world) : IDENTITY
+      );
+      a.opacity = "1";
+      a.display = inv ? "inline" : "none";
+      return;
+    }
+    if (key === "white") {
+      Object.assign(a, box, { fill: "#fff" });
+      return;
+    }
+    if (key === "paint") {
+      const selected = r.paints[el.index];
+      Object.assign(a, shapeAttrs(render, p, el, paint, `${id}m${el.index}-`, [selected]));
+      a.display = selected.visible ? "inline" : "none";
+      return;
+    }
+    Object.assign(a, shapeAttrs(render, p, el, paint, id));
+    if (["outline", "black"].includes(key)) {
+      a.fill = key === "black" ? "#000" : "#fff";
+      a.stroke = "none";
+      a["clip-rule"] = el.index === void 0 ? r.paints.find((p2) => p2.kind === "fill")?.rule ?? "nonzero" : p.nodes[el.index].clip.rule;
+      return;
+    }
+    if (key === "fill-only") {
+      a.stroke = "none";
+      return;
+    }
+    if (key === "stroke-only") {
+      a.fill = "none";
+      a["stroke-width"] = fmt(2 * r.paints.find((p2) => p2.kind === "stroke").width);
+      return;
+    }
+  }
+};
+function shapeAttrs(render, f, el, paint, id, paints = f.nodes[el.node].paints) {
+  const nodes = [...f.nodes];
+  nodes[el.node] = { ...nodes[el.node], paints };
+  return render({ ...f, nodes }, { ...el, role: "shape" }, paint, id);
+}
+export {
+  compositeSVG
+};

package/modules/composite/manifest.d.ts

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

package/modules/composite/manifest.js

@@ -0,0 +1,53 @@
+const after = ["paint"];
+var manifest_default = {
+  name: "composite",
+  summary: "Compositing: blend modes, masks, clips, knockout and draw order.",
+  after,
+  core: {
+    entry: "core/index.ts",
+    export: "composite",
+    svg: "core/svg.ts",
+    svgExport: "compositeSVG"
+  },
+  web: [
+    {
+      name: "composite",
+      buildOrder: 4,
+      sizeOrder: 7,
+      budget: 4160
+    }
+  ],
+  adapters: {
+    "packages/core/src/modules/composite/index.ts": "core/index.ts",
+    "packages/core/src/modules/composite/svg.ts": "core/svg.ts",
+    "packages/web/src/composite.ts": "web/index.ts"
+  },
+  exports: {
+    "core:./composite": "packages/core/src/modules/composite/index.ts",
+    "core:./composite-svg": "packages/core/src/modules/composite/svg.ts",
+    "web:./composite": "packages/web/src/composite.ts"
+  },
+  markupHook: null,
+  tests: [
+    "modules/composite/test/**/*.test.ts",
+    "packages/markup/test/compile.test.ts",
+    "packages/markup/test/corpus.test.ts",
+    "packages/markup/test/decompile.test.ts",
+    "packages/markup/test/format.test.ts",
+    "packages/markup/test/invalid.test.ts",
+    "packages/markup/test/names.test.ts"
+  ],
+  conformance: [
+    "paint-blend",
+    "paint-clip",
+    "paint-draw-order",
+    "paint-mask-",
+    "input-hit-draw-order",
+    "input-focus-pointer-draw-order"
+  ],
+  docs: ["spec/SPEC.md", "spec/ANIML.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

package/modules/composite/web/index.js

@@ -0,0 +1,17 @@
+import { composite } from "animl/composite";
+import { compositeSVG } from "animl/composite-svg";
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(composite);
+Icon.registerSVGBackend("composite", compositeSVG);
+Icon.orderSVG = (f, elements) => {
+  const previous = /* @__PURE__ */ new Map();
+  const sorted = elements.filter(([el]) => el.role === "node").sort(([a], [b]) => (f.order?.[a.node] ?? a.node) - (f.order?.[b.node] ?? b.node));
+  for (const [, dom] of sorted) {
+    let top = dom;
+    while (top.parentElement?.getAttribute("data-anima-wrap") === "true") top = top.parentElement;
+    const parent = top.parentElement, prev = previous.get(parent);
+    if (prev && !(prev.compareDocumentPosition(top) & 4)) parent.append(top);
+    previous.set(parent, top);
+  }
+};

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

@@ -0,0 +1,23 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Shape } from '../../../packages/core/src/registry.js';
+import type { Geometry } from '../../../packages/core/src/draw.js';
+type Point = [number, number];
+type Line = Point[];
+export interface Effect {
+    type: 'trim' | 'dash';
+    start?: number;
+    end?: number;
+    offset?: number;
+    mode?: string;
+    dash?: number[];
+}
+export declare const trimShape: Shape;
+export declare function polylines(d: string): Line[];
+export declare function applyEffects(d: string, effects: Effect[]): string;
+export declare function geometryPath(g: Geometry): string;
+export declare const effects: Module & {
+    undashed(g: Geometry, raw: {
+        effects?: (Effect | string)[];
+    } | undefined, shared: unknown): Geometry | undefined;
+};
+export {};

package/modules/contour/core/effects.js

@@ -0,0 +1,242 @@
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+import { fmt } from "../../../packages/core/src/draw.js";
+import { parsePath, M, C, Z } from "../../../packages/core/src/path.js";
+const num = { k: "num" };
+const trimShape = {
+  k: "obj",
+  p: {
+    start: { k: "num", min: 0, max: 1 },
+    end: { k: "num", min: 0, max: 1 },
+    offset: num,
+    mode: { k: "str", of: ["sequential", "synchronized"] }
+  },
+  req: []
+};
+const effectShape = {
+  k: "obj",
+  p: {
+    ...trimShape.p,
+    type: { k: "str", of: ["trim", "dash"] },
+    dash: { k: "arr", min: 1, of: { k: "num", min: 0 } }
+  },
+  req: ["type"]
+};
+const stack = { k: "arr", of: effectShape };
+const dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+const lerp = (a, b, t) => [
+  a[0] + (b[0] - a[0]) * t,
+  a[1] + (b[1] - a[1]) * t
+];
+function polylines(d) {
+  return parsePath(d).map((sp) => {
+    const out = [];
+    let at = [0, 0];
+    const cubic = (a, b, c, e, depth = 0) => {
+      if (depth === 20 || dist(a, b) + dist(b, c) + dist(c, e) - dist(a, e) <= 1e-4) {
+        out.push(e);
+        return;
+      }
+      const ab = lerp(a, b, 0.5), bc = lerp(b, c, 0.5), ce = lerp(c, e, 0.5), abc = lerp(ab, bc, 0.5), bce = lerp(bc, ce, 0.5), m = lerp(abc, bce, 0.5);
+      cubic(a, ab, abc, m, depth + 1);
+      cubic(m, bce, ce, e, depth + 1);
+    };
+    for (let i = 0; i < sp.segs.length; ) {
+      const op = sp.segs[i++];
+      if (op === Z) {
+        if (out.length) out.push(out[0]);
+        continue;
+      }
+      const p = sp.segs.slice(i, i + 2);
+      i += 2;
+      if (op === C) {
+        const c = sp.segs.slice(i, i + 2), e = sp.segs.slice(i + 2, i + 4);
+        i += 4;
+        cubic(at, p, c, e);
+        at = e;
+      } else {
+        out.push(p);
+        at = p;
+        if (op === M) at = p;
+      }
+    }
+    return out;
+  });
+}
+const length = (line) => line.slice(1).reduce((sum, p, i) => sum + dist(line[i], p), 0);
+function slice(line, start, end) {
+  const out = [];
+  let at = 0;
+  for (let i = 1; i < line.length; i++) {
+    const a = line[i - 1], b = line[i], len = dist(a, b);
+    if (len && at < end && at + len > start) {
+      const p = lerp(a, b, Math.max(0, (start - at) / len)), q = lerp(a, b, Math.min(1, (end - at) / len));
+      if (!out.length) out.push(p);
+      out.push(q);
+    }
+    at += len;
+  }
+  return out;
+}
+function applyEffects(d, effects2) {
+  let paths = polylines(d);
+  for (const effect of effects2) {
+    if (effect.type === "trim") {
+      const fraction = Math.max(0, Math.min(1, (effect.end ?? 1) - (effect.start ?? 0)));
+      if (fraction === 1) continue;
+      if (!fraction) {
+        paths = [];
+        continue;
+      }
+      const start = (((effect.start ?? 0) + (effect.offset ?? 0)) % 1 + 1) % 1;
+      const ranges = start + fraction > 1 ? [
+        [start, 1],
+        [0, start + fraction - 1]
+      ] : [[start, start + fraction]];
+      const total = paths.reduce((s, p) => s + length(p), 0);
+      let base = 0;
+      paths = paths.flatMap((p) => {
+        const len = length(p), synchronized = effect.mode === "synchronized";
+        const scale = synchronized ? len : total, offset = synchronized ? 0 : base;
+        base += len;
+        return ranges.map(([a, b]) => slice(p, a * scale - offset, b * scale - offset)).filter((p2) => p2.length > 1);
+      });
+    } else {
+      let dash = effect.dash;
+      if (dash.length % 2) dash = [...dash, ...dash];
+      const period = dash.reduce((a, b) => a + b, 0);
+      paths = paths.flatMap((p) => {
+        const out = [], len = length(p);
+        let offset = ((effect.offset ?? 0) % period + period) % period, index = 0;
+        while (offset >= dash[index]) {
+          offset -= dash[index];
+          index = (index + 1) % dash.length;
+        }
+        let at = -offset;
+        while (at < len) {
+          const end = at + dash[index];
+          if (index % 2 === 0) {
+            const part = slice(p, Math.max(0, at), Math.min(len, end));
+            if (part.length > 1) out.push(part);
+          }
+          at = end;
+          index = (index + 1) % dash.length;
+        }
+        return out;
+      });
+    }
+  }
+  return paths.map((p) => p.map((v, i) => (i ? "L" : "M") + v.map(fmt).join(" ")).join("")).join("");
+}
+function geometryPath(g) {
+  if (g.d !== void 0) return g.d;
+  if (g.kind === "circle")
+    return `M${g.cx + g.r} ${g.cy}A${g.r} ${g.r} 0 1 0 ${g.cx - g.r} ${g.cy}A${g.r} ${g.r} 0 1 0 ${g.cx + g.r} ${g.cy}Z`;
+  const x = g.x, y = g.y, w = g.width, h = g.height, r = Math.min(g.rx ?? 0, w / 2, h / 2);
+  return r ? `M${x + r} ${y}H${x + w - r}Q${x + w} ${y} ${x + w} ${y + r}V${y + h - r}Q${x + w} ${y + h} ${x + w - r} ${y + h}H${x + r}Q${x} ${y + h} ${x} ${y + h - r}V${y + r}Q${x} ${y} ${x + r} ${y}Z` : `M${x} ${y}h${w}v${h}h${-w}Z`;
+}
+const effects = {
+  undashed(g, raw, shared) {
+    if (!g || !raw?.effects) return;
+    const stack2 = raw.effects.flatMap(
+      (e) => typeof e === "string" ? shared[e] : [e]
+    );
+    const firstDash = stack2.findIndex((e) => e.type === "dash");
+    if (firstDash < 0) return;
+    return firstDash ? { kind: "path", d: applyEffects(geometryPath(g), stack2.slice(0, firstDash)) } : g;
+  },
+  name: "contour",
+  entries: [
+    {
+      target: "stroke",
+      shapes: {
+        trim: trimShape,
+        effects: {
+          k: "alt",
+          of: [{ k: "arr", of: { k: "alt", of: [effectShape, { k: "str" }] } }]
+        }
+      }
+    },
+    { target: "document", shapes: { effects: { k: "map", of: stack, markup: "effects" } } }
+  ],
+  load(model, _raw, d) {
+    const shared = model.doc.effects;
+    const validate = (e, pointer) => {
+      if (e.type === "dash" && (!e.dash?.length || !e.dash.some(Boolean)))
+        d.err(
+          "bad-value",
+          pointer + "/dash",
+          V && "dash effect needs a positive pattern length",
+          V && "include at least one positive dash length"
+        );
+      for (const k of e.type === "trim" ? ["dash"] : ["start", "end", "mode"])
+        if (k in e)
+          d.err(
+            "bad-value",
+            pointer + "/" + k,
+            V && `${k} does not belong to ${e.type} effects`,
+            V && "remove this field"
+          );
+    };
+    for (const [id, stack2] of Object.entries(shared ?? {}))
+      stack2.forEach(
+        (e, j) => validate(e, `/effects/${id.replaceAll("~", "~0").replaceAll("/", "~1")}/${j}`)
+      );
+    const paths = [], counts = /* @__PURE__ */ new Map();
+    model.nodes.forEach((n, i) => {
+      const j = counts.get(n.parent) ?? 0;
+      counts.set(n.parent, j + 1);
+      const pointer = paths[i] = (n.parent < 0 ? "/nodes" : paths[n.parent] + "/children") + "/" + j;
+      const paints = n.raw.paints ? n.raw.paints.map((r, j2) => [
+        r.stroke,
+        `${pointer}/paints/${j2}/stroke`
+      ]) : [[n.raw.stroke, pointer + "/stroke"]];
+      for (const [raw, base] of paints) {
+        if (!raw) continue;
+        if (raw.effects && raw.trim)
+          d.err(
+            "paint-conflict",
+            base + "/effects",
+            V && "use either trim or an effect stack",
+            V && "put the trim into effects"
+          );
+        if ((raw.effects || raw.trim) && ["dash", "trimStart", "trimEnd", "trimOffset"].some((k) => k in raw))
+          d.err(
+            "paint-conflict",
+            base,
+            V && "effect stacks cannot combine with legacy dash or trim",
+            V && "move all stroke effects into the ordered stack"
+          );
+        raw.effects?.forEach((e, j2) => {
+          if (typeof e === "string") {
+            if (!Object.hasOwn(shared ?? {}, e))
+              d.err(
+                "unknown-source",
+                `${base}/effects/${j2}`,
+                V && "unknown shared effect stack",
+                V && "declare it in document.effects"
+              );
+          } else validate(e, `${base}/effects/${j2}`);
+        });
+      }
+    });
+  },
+  draw: {
+    frame(p, i, data) {
+      if (!data.geometry) return;
+      for (const paint of data.paints) {
+        const raw = (paint.key ?? paint.kind).split(".").reduce((o, k) => o?.[k], p.model.nodes[i].raw);
+        if (!raw?.effects && !raw?.trim) continue;
+        const shared = p.model.doc.effects;
+        const stack2 = raw.trim ? [{ type: "trim", ...raw.trim }] : raw.effects.flatMap((e) => typeof e === "string" ? shared[e] : [e]);
+        paint.geometry = { kind: "path", d: applyEffects(geometryPath(data.geometry), stack2) };
+      }
+    }
+  }
+};
+export {
+  applyEffects,
+  effects,
+  geometryPath,
+  polylines,
+  trimShape
+};

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

@@ -0,0 +1,17 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+import type { Player } from '../../../packages/core/src/player.js';
+import { effects } from './effects.js';
+type Point = [number, number];
+export interface Vertex {
+    point: Point;
+    kind: 'straight' | 'mirrored' | 'asymmetric' | 'detached' | 'rounded';
+    handle?: Point;
+    incoming?: Point;
+    outgoing?: Point;
+    radius?: number;
+}
+export declare function compileVertices(vertices: Vertex[], closed?: boolean, origin?: Point): string;
+export declare const contour: Module & Pick<typeof effects, 'undashed'> & {
+    pathfollowPath(player: Player, node: number): string | undefined;
+};
+export {};