animl 0.0.0-stage → 0.1.1

package/modules/paint/core/sampling.js

@@ -0,0 +1,124 @@
+const wrap = { k: "str", of: ["clamp", "repeat", "mirror"] };
+const samplingEntries = [
+  {
+    target: "image",
+    shapes: {
+      wrap,
+      wrapX: { ...wrap, markup: "wrap-x" },
+      wrapY: { ...wrap, markup: "wrap-y" }
+    }
+  }
+];
+const samplingSVG = {
+  tree(draw, tree) {
+    const visit = (els) => {
+      for (const el of els) {
+        if (draw.nodes[el.node].imageWrap && (el.role === "shape" || el.role === "module:image-box")) {
+          el.tag = "svg";
+          el.role = "module:image-box";
+          el.kids = [{ tag: "rect", role: "sample:rect", node: el.node, kids: [] }];
+          tree.defs.push({
+            tag: "pattern",
+            role: "sample:pattern",
+            node: el.node,
+            kids: [0, 1, 2, 3].map((index) => ({
+              tag: "g",
+              role: "sample:flip",
+              node: el.node,
+              index,
+              kids: Array.from({ length: 9 }, (_, key) => ({
+                tag: "svg",
+                role: "sample:crop",
+                node: el.node,
+                index: key,
+                kids: [{ tag: "image", role: "sample:source", node: el.node, kids: [] }]
+              }))
+            }))
+          });
+        } else visit(el.kids);
+      }
+    };
+    visit(tree.root);
+  },
+  attrs(f, el, paint, id, a, render) {
+    if (!el.role.startsWith("sample:")) return;
+    const g = f.nodes[el.node].geometry, r = g.image;
+    if (r.sampling === "bilinear" && (r.wrapX === "repeat" || r.wrapY === "repeat"))
+      throw Object.assign(new Error("SVG patterns cannot filter across repeated texture edges"), {
+        code: "unsupported-render",
+        pointer: (f.tree.nodes[el.node].pointer ?? "/nodes/" + el.node) + (r.wrap !== void 0 ? "/wrap" : r.wrapX === "repeat" ? "/wrapX" : "/wrapY"),
+        hint: 'use sampling="nearest" or canvas; native delta 188, 36852/57600 pixels >16'
+      });
+    const image = render(f, { ...el, role: "module:image" }, paint, id);
+    const w = +image.width, h = +image.height, x = +image.x, y = +image.y;
+    if (r.sampling === "bilinear" && (r.wrapX === "clamp" && (x > 0 || x + w < g.width) || r.wrapY === "clamp" && (y > 0 || y + h < g.height)))
+      throw Object.assign(
+        new Error("SVG cannot isolate clamped edge texels before bilinear filtering"),
+        {
+          code: "unsupported-render",
+          pointer: (f.tree.nodes[el.node].pointer ?? "/nodes/" + el.node) + "/sampling",
+          hint: 'use sampling="nearest" or the canvas renderer for bilinear clamp extension'
+        }
+      );
+    if (el.role === "sample:source") {
+      Object.assign(a, image, { x: "0", y: "0" });
+      return;
+    }
+    const wx = r.wrapX, wy = r.wrapY;
+    const tx = wx === "clamp" ? 0 : x, ty = wy === "clamp" ? 0 : y;
+    const mx = wx === "mirror", my = wy === "mirror", key = `${id}tile${el.node}`;
+    if (el.role === "sample:crop") {
+      const axis = (n, pos, size, box, pixels, mode) => {
+        const edge = size / pixels;
+        return n === 1 ? [pos, size, 0, size] : n === 0 ? [0, mode === "clamp" ? Math.max(0, pos) : 0, 0, edge] : [pos + size, mode === "clamp" ? Math.max(0, box - pos - size) : 0, size - edge, edge];
+      };
+      const [dx, dw, sx, sw] = axis(
+        el.index % 3,
+        x,
+        w,
+        g.width,
+        r.pixels?.[0] ?? r.width ?? g.width,
+        wx
+      ), [dy, dh, sy, sh] = axis(
+        Math.floor(el.index / 3),
+        y,
+        h,
+        g.height,
+        r.pixels?.[1] ?? r.height ?? g.height,
+        wy
+      );
+      Object.assign(a, {
+        x: String(dx),
+        y: String(dy),
+        width: String(dw),
+        height: String(dh),
+        viewBox: `${sx} ${sy} ${sw} ${sh}`,
+        display: dw && dh ? "inline" : "none",
+        style: `width:${dw}px;height:${dh}px;overflow:hidden`,
+        preserveAspectRatio: "none",
+        overflow: "hidden"
+      });
+    } else if (el.role === "sample:rect")
+      Object.assign(a, { width: String(g.width), height: String(g.height), fill: `url(#${key})` });
+    else if (el.role === "sample:pattern")
+      Object.assign(a, {
+        id: key,
+        patternUnits: "userSpaceOnUse",
+        x: String(tx),
+        y: String(ty),
+        width: String(wx === "clamp" ? g.width : w * (mx ? 2 : 1)),
+        height: String(wy === "clamp" ? g.height : h * (my ? 2 : 1))
+      });
+    else {
+      const fx = el.index & 1, fy = el.index >> 1;
+      Object.assign(a, {
+        display: fx && !mx || fy && !my ? "none" : "inline",
+        transform: `matrix(${fx ? -1 : 1} 0 0 ${fy ? -1 : 1} ${fx ? 2 * w + tx : -tx} ${fy ? 2 * h + ty : -ty})`
+      });
+    }
+  }
+};
+export {
+  samplingEntries,
+  samplingSVG
+};

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

@@ -0,0 +1,26 @@
+import { type DrawPaint } from '../../../packages/core/src/draw.js';
+import { type SVGBackend, type Attrs, type Paint } from '../../../packages/core/src/svg.js';
+export declare class UnsupportedPaintRenderError extends Error {
+    readonly code = "unsupported-render";
+    readonly hint = "use the canvas renderer for angular gradients";
+    readonly pointer: string;
+    constructor(pointer: string, key: string);
+}
+export declare function gradientTree(node: number, key: string, paint: DrawPaint, pointer?: string): {
+    tag: string;
+    role: string;
+    node: number;
+    key: string;
+    kids: {
+        tag: string;
+        role: string;
+        node: number;
+        key: string;
+        index: number;
+        kids: never[];
+    }[];
+};
+export declare function gradientAttrs(p: DrawPaint, node: number, key: string, index: number | undefined, paint: Paint, id: string, a: Attrs): void;
+export declare function paintExtras(paints: DrawPaint[], node: number, _paint: Paint, id: string, a: Attrs): void;
+export declare const paintSVGBase: SVGBackend;
+export declare const paintSVG: SVGBackend;

package/modules/paint/core/svg.js

@@ -0,0 +1,120 @@
+import { samplingSVG } from "./sampling.js";
+import { fmt } from "../../../packages/core/src/draw.js";
+import {
+  paintColor
+} from "../../../packages/core/src/svg.js";
+class UnsupportedPaintRenderError extends Error {
+  code = "unsupported-render";
+  hint = "use the canvas renderer for angular gradients";
+  pointer;
+  constructor(pointer, key) {
+    super("SVG cannot faithfully render angular gradients");
+    this.pointer = `${pointer}/${key.replaceAll(".", "/")}/type`;
+  }
+}
+function gradientTree(node, key, paint, pointer = `/nodes/${node}`) {
+  if (paint.type === "angular") throw new UnsupportedPaintRenderError(pointer, key);
+  return {
+    tag: paint.type + "Gradient",
+    role: "module:paint",
+    node,
+    key,
+    kids: paint.stops.map((_s, index) => ({
+      tag: "stop",
+      role: "module:paint",
+      node,
+      key,
+      index,
+      kids: []
+    }))
+  };
+}
+function gradientAttrs(p, node, key, index, paint, id, a) {
+  if (index !== void 0)
+    Object.assign(a, {
+      offset: fmt(p.stops[index].position),
+      "stop-color": paintColor(p.stops[index].color, paint)
+    });
+  else {
+    Object.assign(a, {
+      id: `${id}p${node}-${key}`,
+      gradientUnits: "userSpaceOnUse",
+      "color-interpolation": "sRGB"
+    });
+    if (p.gradientTransform)
+      a.gradientTransform = `matrix(${p.gradientTransform.map(fmt).join(" ")})`;
+    for (const k in p.coordinates) a[k] = fmt(p.coordinates[k]);
+  }
+}
+function paintExtras(paints, node, _paint, id, a) {
+  for (const p of paints) {
+    const key = p.kind;
+    if (p.type && a[key] !== "none") a[key] = `url(#${id}p${node}-${key})`;
+    if (p.kind === "stroke") {
+      if (p.dash && !a["stroke-dasharray"]) {
+        a.pathLength = null;
+        a["stroke-dasharray"] = p.dash.map(fmt).join(" ");
+        a["stroke-dashoffset"] = fmt(p.dashOffset);
+      }
+      if (p.scale === "fixed") a["vector-effect"] = "non-scaling-stroke";
+    }
+  }
+}
+const gradientsSVG = {
+  tree(draw, tree) {
+    for (const resource of draw.resources)
+      if (resource.kind === "gradient") {
+        const p = resource;
+        tree.defs.push(gradientTree(p.node, p.key, p.paint, draw.nodes[p.node].pointer));
+      }
+  },
+  attrs(f, el, paint, id, a) {
+    if (el.role === "module:paint") {
+      const parts = el.key.split(".");
+      const nested = parts.length > 1;
+      const key = nested ? parts[2] : el.key;
+      const selected = nested ? f.nodes[el.node].paints[+parts[1]] : f.nodes[el.node].paints.find((p) => p.kind === key);
+      gradientAttrs(selected, el.node, key, el.index, paint, nested ? `${id}m${parts[1]}-` : id, a);
+    } else if (el.role === "shape") paintExtras(f.nodes[el.node].paints, el.node, paint, id, a);
+  }
+};
+function imageBox(f, el, a) {
+  if (el.role === "module:image-box" && f.nodes[el.node].geometry) {
+    const g = f.nodes[el.node].geometry;
+    a.style = `width:${fmt(g.width)}px;height:${fmt(g.height)}px;overflow:hidden`;
+  }
+}
+const paintSVGBase = {
+  ...gradientsSVG,
+  attrs(f, el, paint, id, a, render) {
+    imageBox(f, el, a);
+    const image = f.nodes[el.node].geometry?.image;
+    if (el.role === "module:image" && image && f.tree.nodes[el.node].imageWrap) {
+      throw Object.assign(new Error("image wrapping needs the optional SVG sampling backend"), {
+        code: "unsupported-render",
+        pointer: f.tree.nodes[el.node].pointer ?? "/nodes/" + el.node,
+        hint: "import @anima-format/web/paint-sampling"
+      });
+    }
+    gradientsSVG.attrs?.(f, el, paint, id, a, render);
+  }
+};
+const paintSVG = {
+  tree(draw, tree) {
+    gradientsSVG.tree?.(draw, tree);
+    samplingSVG.tree?.(draw, tree);
+  },
+  attrs(f, el, paint, id, a, render) {
+    imageBox(f, el, a);
+    gradientsSVG.attrs?.(f, el, paint, id, a, render);
+    samplingSVG.attrs?.(f, el, paint, id, a, render);
+  }
+};
+export {
+  UnsupportedPaintRenderError,
+  gradientAttrs,
+  gradientTree,
+  paintExtras,
+  paintSVG,
+  paintSVGBase
+};

package/modules/paint/manifest.d.ts

@@ -0,0 +1,62 @@
+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;
+        budget: number;
+        over: string;
+        buildOrder?: undefined;
+        sizeOrder?: undefined;
+        authoring?: undefined;
+    } | {
+        name: string;
+        buildOrder: number;
+        sizeOrder: number;
+        budget: number;
+        over?: undefined;
+        authoring?: undefined;
+    } | {
+        name: string;
+        buildOrder: number;
+        sizeOrder: number;
+        budget: number;
+        over: string;
+        authoring: boolean;
+    })[];
+    adapters: {
+        'packages/web/src/paint-sampling.ts': string;
+        'packages/core/src/modules/paint/index.ts': string;
+        'packages/core/src/modules/paint/svg.ts': string;
+        'packages/core/src/modules/paint/geometry.ts': string;
+        'packages/web/src/paint.ts': string;
+        'packages/web/src/markup-paint.ts': string;
+        'packages/markup/src/modules.ts': string;
+    };
+    exports: {
+        'web:./paint-sampling': string;
+        'core:./paint': string;
+        'core:./paint-svg': string;
+        'web:./paint': string;
+        'web:./markup-paint': string;
+        'markup:./modules': string;
+    };
+    markupHook: {
+        browserName: string;
+        browserBase: string;
+        slot: string;
+        type: string;
+        value: string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/paint/manifest.js

@@ -0,0 +1,80 @@
+const after = ["assets", "corners"];
+var manifest_default = {
+  name: "paint",
+  summary: "Paint: solid and gradient fills, strokes (width, caps, joins, dashes, trims) and ordered paints.",
+  after,
+  core: {
+    entry: "core/index.ts",
+    export: "paint",
+    svg: "core/svg.ts",
+    svgExport: "paintSVG"
+  },
+  web: [
+    { name: "paint-sampling", budget: 1216, over: "paint" },
+    {
+      name: "paint",
+      buildOrder: 3,
+      sizeOrder: 6,
+      budget: 4416
+    },
+    {
+      name: "markup-paint",
+      buildOrder: 10,
+      sizeOrder: 3,
+      budget: 448,
+      over: "index",
+      authoring: true
+    }
+  ],
+  adapters: {
+    "packages/web/src/paint-sampling.ts": "web/sampling.ts",
+    "packages/core/src/modules/paint/index.ts": "core/index.ts",
+    "packages/core/src/modules/paint/svg.ts": "core/svg.ts",
+    "packages/core/src/modules/paint/geometry.ts": "core/geometry.ts",
+    "packages/web/src/paint.ts": "web/index.ts",
+    "packages/web/src/markup-paint.ts": "web/markup.ts",
+    "packages/markup/src/modules.ts": "markup/index.ts"
+  },
+  exports: {
+    "web:./paint-sampling": "packages/web/src/paint-sampling.ts",
+    "core:./paint": "packages/core/src/modules/paint/index.ts",
+    "core:./paint-svg": "packages/core/src/modules/paint/svg.ts",
+    "web:./paint": "packages/web/src/paint.ts",
+    "web:./markup-paint": "packages/web/src/markup-paint.ts",
+    "markup:./modules": "packages/markup/src/modules.ts"
+  },
+  markupHook: {
+    browserName: "paint",
+    browserBase: "structuralForms",
+    slot: "moduleCompiler",
+    type: "structuralMarkup",
+    value: "structuralMarkup"
+  },
+  tests: [
+    "modules/paint/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-gradient",
+    "paint-dash",
+    "paint-morph",
+    "paint-pose-morph",
+    "paint-shape-",
+    "drawing-paint-gradient-transform",
+    "drawing-paint-gradient-angular",
+    "drawing-paint-image-fit-resize",
+    "drawing-paint-image-wrap-clamp",
+    "drawing-paint-image-wrap-mirror",
+    "drawing-paint-image-wrap-repeat"
+  ],
+  docs: ["spec/SPEC.md", "spec/ANIML.md"]
+};
+export {
+  after,
+  manifest_default as default
+};

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

@@ -0,0 +1,20 @@
+import type { Compiler, Form } from '../../../packages/markup/src/compile.js';
+import type { Element, Attr } from '../../../packages/markup/src/xml.js';
+export declare const paintMarkup: {
+    nodes(compiler: Compiler): string[];
+    lengths(compiler: Compiler, s: string): (string | number)[];
+    hasPaint(compiler: Compiler, el: Element, paint: string): boolean;
+    node(compiler: Compiler, _el: Element, children: Element[], o: Record<string, unknown>, p: string): void;
+};
+export declare const structuralForms: {
+    form(compiler: Compiler, el: Element): Form | undefined;
+    build(compiler: Compiler, el: Element, a: Map<string, Attr>, children: Element[], o: Record<string, unknown>, p: string): void;
+};
+export declare const structuralMarkup: {
+    form(compiler: Compiler, el: Element): Form | undefined;
+    build(compiler: Compiler, el: Element, a: Map<string, Attr>, children: Element[], o: Record<string, unknown>, p: string): void;
+    nodes(compiler: Compiler): string[];
+    lengths(compiler: Compiler, s: string): (string | number)[];
+    hasPaint(compiler: Compiler, el: Element, paint: string): boolean;
+    node(compiler: Compiler, _el: Element, children: Element[], o: Record<string, unknown>, p: string): void;
+};

package/modules/paint/markup/index.js

@@ -0,0 +1,172 @@
+import { NAME, VERBOSE, markupName, ptr } from "animl";
+const kind = (s) => s.k === "alt" && s.of.some((s2) => s2.k === "bool") && s.of.some((s2) => s2.k === "str") ? "string" : ["obj", "map", "any", "alt"].includes(s.k) ? "json" : s.k === "num" ? "number" : s.k === "bool" ? "boolean" : s.k === "str" && s.re === NAME ? "name" : "string";
+function readShape(compiler, a, shape, p) {
+  if (shape.k === "alt" && shape.of.some((s) => s.k === "bool") && shape.of.some((s) => s.k === "str"))
+    return a.value === "true" || a.value === "false" ? a.value === "true" : a.value;
+  if (shape.k === "arr" && shape.of.k === "alt") return compiler.read(a, "lengths", p);
+  if (shape.k === "arr" || shape.k === "tup") {
+    const text = a.value.trim();
+    const parts = text ? text.split(/\s*,\s*|\s+/) : [];
+    if (parts.some((value) => !value))
+      compiler.error(
+        "bad-attribute",
+        p,
+        a.valueAt,
+        VERBOSE ? "expected scalar tokens separated by whitespace or single commas" : "",
+        VERBOSE ? "remove empty list items" : ""
+      );
+    return parts.map(
+      (value, i) => readShape(
+        compiler,
+        { ...a, value },
+        shape.k === "arr" ? shape.of : shape.of[i] ?? shape.of[0],
+        ptr(p, i)
+      )
+    );
+  }
+  return compiler.read(a, kind(shape), p);
+}
+const paintMarkup = {
+  nodes(compiler) {
+    return Object.keys(compiler.elements).filter((k) => compiler.elements[k].target);
+  },
+  lengths(compiler, s) {
+    return s.split(/\s*,\s*|\s+/).map((x) => x.endsWith("%") ? x : compiler.num(x));
+  },
+  hasPaint(compiler, el, paint) {
+    if (compiler.nodeAttrs(el.name).some(
+      (a) => a.path[0] === paint && a.path[1] === "paint" && el.attrs.some((v) => v.name === a.attr)
+    ))
+      return true;
+    return el.children.some(
+      (c) => c.kind === "element" && compiler.elements[c.name]?.target && (c.attrs.find((x) => x.name === compiler.elements[c.name].target.attribute)?.value ?? compiler.elements[c.name].target.default) === paint
+    );
+  },
+  node(compiler, _el, children, o, p) {
+    for (const c of children) {
+      const form = compiler.elements[c.name];
+      if (!form?.target) continue;
+      const selector = c.attrs.find((x) => x.name === form.target.attribute);
+      const key = selector?.value ?? form.target.default;
+      if (!form.target.choices.includes(key)) {
+        compiler.error(
+          "bad-attribute",
+          p,
+          selector?.valueAt ?? c.at,
+          VERBOSE ? "invalid structural target" : "",
+          VERBOSE ? `choose ${form.target.choices.join(" or ")}` : ""
+        );
+        continue;
+      }
+      if (form.target.array) {
+        const list = o[key] ??= [];
+        list.push({
+          [form.target.wrapper]: compiler.build(
+            c,
+            ptr(ptr(p, key), list.length) + "/" + form.target.wrapper
+          )
+        });
+        continue;
+      }
+      let parent = o;
+      let pointer = p;
+      let present = false;
+      for (const part of [key, ...form.target.path ?? []]) {
+        present = Object.hasOwn(parent, part);
+        parent = compiler.container(parent, part, pointer, c.at);
+        pointer = ptr(pointer, part);
+      }
+      if (!form.values && present)
+        compiler.error(
+          "duplicate-name",
+          pointer,
+          c.at,
+          VERBOSE ? "object declared twice" : "",
+          VERBOSE ? "keep one child per target" : ""
+        );
+      if (!form.target.path && (parent.color !== void 0 || parent.type !== void 0))
+        compiler.error(
+          "paint-attribute",
+          ptr(p, key),
+          c.at,
+          VERBOSE ? "paint already has a colour or gradient" : ""
+        );
+      Object.assign(parent, compiler.build(c, pointer));
+    }
+  }
+};
+const structuralForms = {
+  form(compiler, el) {
+    const form = compiler.elements[el.name];
+    if (form) {
+      const attrs = {};
+      const children = [];
+      for (const [k, s] of Object.entries(form.shape.p)) {
+        if (s.k === "arr" && s.of.element) children.push(s.of.element);
+        else if (s.k === "obj" && s.element) children.push(s.element);
+        else
+          attrs[markupName(s, k)] = k === "color" || ["fill", "stroke"].includes(k) && s.k === "obj" ? "color" : kind(s);
+      }
+      if (form.target) attrs[form.target.attribute] = "string";
+      return {
+        attrs,
+        children,
+        required: form.shape.req?.filter(
+          (k) => !children.includes(form.shape.p[k]?.element ?? "") && !(form.shape.p[k]?.k === "arr" && form.shape.p[k].of.element)
+        ).map((k) => markupName(form.shape.p[k], k))
+      };
+    }
+    return void 0;
+  },
+  build(compiler, el, a, children, o, p) {
+    const form = compiler.elements[el.name];
+    for (const [k, v] of Object.entries(form.values ?? {})) compiler.put(o, k, v, p, el.at);
+    for (const [k, s] of Object.entries(form.shape.p)) {
+      if (s.k === "arr" && s.of.element) {
+        const list = children.filter((c) => c.name === s.of.element);
+        if (!list.length && !form.shape.req?.includes(k)) continue;
+        compiler.put(o, k, [], p, el.at);
+        list.forEach((c, i) => o[k].push(compiler.build(c, ptr(ptr(p, k), i))));
+      } else if (s.k === "obj" && s.element) {
+        const list = children.filter((c) => c.name === s.element);
+        for (const c of list) {
+          const target = compiler.elements[c.name]?.target;
+          const selector = c.attrs.find((a2) => a2.name === target?.attribute);
+          if (selector && selector.value !== form.target?.wrapper)
+            compiler.error(
+              "bad-attribute",
+              ptr(p, k),
+              selector.valueAt,
+              VERBOSE ? "nested paint target must match its wrapper" : "",
+              VERBOSE ? "omit paint or use the enclosing paint kind" : ""
+            );
+          if (Object.hasOwn(o, k))
+            compiler.error(
+              "duplicate-name",
+              ptr(p, k),
+              c.at,
+              VERBOSE ? "object declared twice" : "",
+              VERBOSE ? "keep one child per target" : ""
+            );
+          else o[k] = compiler.build(c, ptr(p, k));
+        }
+      } else {
+        const attr = a.get(markupName(s, k));
+        if (attr)
+          compiler.put(
+            o,
+            k,
+            ["fill", "stroke"].includes(k) && s.k === "obj" ? attr.value.trim().startsWith("{") ? compiler.read(attr, "json", ptr(p, k)) : { color: compiler.read(attr, "color", ptr(p, k) + "/color") } : k === "color" ? compiler.read(attr, "color", ptr(p, k)) : readShape(compiler, attr, s, ptr(p, k)),
+            p,
+            attr.valueAt
+          );
+      }
+    }
+  }
+};
+const structuralMarkup = { ...paintMarkup, ...structuralForms };
+export {
+  paintMarkup,
+  structuralForms,
+  structuralMarkup
+};

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

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

package/modules/paint/web/index.js

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

package/modules/paint/web/markup.d.ts

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

package/modules/paint/web/markup.js

@@ -0,0 +1,3 @@
+import { paintMarkup } from "animl/markup/modules";
+import "../../../packages/web/src/index.js";
+customElements.get("anima-icon").registerMarkup("paint", paintMarkup);

package/modules/paint/web/sampling.d.ts

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

package/modules/paint/web/sampling.js

@@ -0,0 +1,3 @@
+import "./index.js";
+import { paintSVG } from "animl/paint-svg";
+customElements.get("anima-icon").registerSVGBackend("paint", paintSVG);

package/modules/pathfollow/capabilities/rigging-follow-path/registry.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleEntry } from '../../../../packages/core/src/modules.js';
+export declare const entries: ModuleEntry[];

package/modules/pathfollow/capabilities/rigging-follow-path/registry.js

@@ -0,0 +1,4 @@
+const entries = [];
+export {
+  entries
+};

package/modules/pathfollow/capabilities/rigging-list-follow-path/registry.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleEntry } from '../../../../packages/core/src/modules.js';
+export declare const entries: ModuleEntry[];

package/modules/pathfollow/capabilities/rigging-list-follow-path/registry.js

@@ -0,0 +1,4 @@
+const entries = [];
+export {
+  entries
+};

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

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