animl 0.0.0-stage → 0.1.0

package/modules/nested/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/nested/index.ts': string;
+        'packages/core/src/modules/nested/svg.ts': string;
+        'packages/markup/src/nested.ts': string;
+        'packages/web/src/nested.ts': string;
+    };
+    exports: {
+        'core:./nested': string;
+        'markup:./nested': string;
+        'web:./nested': string;
+    };
+    tests: string[];
+    conformance: string[];
+    docs: string[];
+};
+export default _default;

package/modules/nested/manifest.js

@@ -0,0 +1,42 @@
+const after = ["components", "data", "bind", "lists", "motion"];
+var manifest_default = {
+  ...{
+    name: "nested",
+    summary: "Nested scenes: embed another scene\u2019s animation with remapped or quantized time, and read its outputs.",
+    after: [],
+    core: { entry: "core/index.ts", export: "nested", svg: "core/svg.ts", svgExport: "nestedSVG" },
+    web: [{ name: "nested", budget: 5056 }],
+    adapters: {
+      "packages/core/src/modules/nested/index.ts": "core/index.ts",
+      "packages/core/src/modules/nested/svg.ts": "core/svg.ts",
+      "packages/markup/src/nested.ts": "markup/index.ts",
+      "packages/web/src/nested.ts": "web/index.ts"
+    },
+    exports: {
+      "core:./nested": "packages/core/src/modules/nested/index.ts",
+      "markup:./nested": "packages/markup/src/nested.ts",
+      "web:./nested": "packages/web/src/nested.ts"
+    },
+    tests: [
+      "modules/nested/test/**/*.test.ts",
+      "packages/markup/test/corpus.test.ts",
+      "packages/markup/test/names.test.ts"
+    ],
+    conformance: [
+      "components-nested-remap",
+      "components-nested-quantize",
+      "components-quantize-boundary",
+      "components-leaf-fit",
+      "components-stateful-output",
+      "components-output-repeat",
+      "data-property-artboard",
+      "state-machine-literal-artboard"
+    ],
+    docs: ["modules/nested/SPEC.md"]
+  },
+  after
+};
+export {
+  after,
+  manifest_default as default
+};

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

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

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

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

package/modules/nested/web/index.js

@@ -0,0 +1,67 @@
+import { nested } from "../core/index.js";
+import { nestedSVG } from "../core/svg.js";
+import "../../../packages/web/src/index.js";
+const Icon = customElements.get("anima-icon");
+Icon.registerModule(nested);
+Icon.registerSVGBackend("nested", nestedSVG);
+let previous = Icon.orderSVG;
+const views = /* @__PURE__ */ new WeakMap();
+const hosts = /* @__PURE__ */ new WeakMap();
+const token = (el) => [el.node, el.role, el.key, el.index].join(":");
+const order = (frame, elements) => {
+  if (!Icon.modules.get("nested").dynamicTrees.has(frame.tree)) {
+    previous?.(frame, elements);
+    return;
+  }
+  const svg = elements[0]?.[1].closest("svg");
+  const icon = svg?.getRootNode() instanceof ShadowRoot ? svg.getRootNode().host : void 0;
+  if (!svg || !icon) return;
+  if (icon.player) hosts.set(icon.player, icon);
+  const signature = JSON.stringify([frame.tree.nodes, frame.tree.resources]);
+  let view = views.get(icon);
+  if (!view || view.signature !== signature) {
+    view = { signature, retained: [...elements], elements };
+    views.set(icon, view);
+    icon.attributeChangedCallback("renderer", null, icon.getAttribute("renderer"));
+    return;
+  }
+  view.elements = elements;
+  if (view.retained) {
+    const retained = view.retained;
+    view.retained = void 0;
+    const index = (records) => {
+      const nodes = new Map(records.map((r) => [r[1], r]));
+      const path = (dom) => {
+        const rec = nodes.get(dom);
+        return (dom.parentElement ? path(dom.parentElement) : "") + "/" + (rec ? token(rec[0]) : dom.localName);
+      };
+      return new Map(records.map((r) => [path(r[1]), r]));
+    };
+    const old = index(retained), fresh = index(elements);
+    const keys = new Map([...fresh].map(([key, record]) => [record[1], key]));
+    const restore = (dom) => {
+      const children = [...dom.children].map(restore);
+      const key = keys.get(dom), record = key && fresh.get(key), match = key && old.get(key);
+      if (!record || !match || match[1].localName !== dom.localName) {
+        dom.replaceChildren(...children);
+        return dom;
+      }
+      const target = match[1];
+      for (const attr of [...target.attributes])
+        if (!dom.hasAttribute(attr.name)) target.removeAttribute(attr.name);
+      for (const attr of [...dom.attributes]) target.setAttribute(attr.name, attr.value);
+      target.replaceChildren(...children);
+      record[1] = target;
+      return target;
+    };
+    svg.replaceChildren(...[...svg.children].map(restore));
+  }
+  previous?.(frame, elements);
+};
+Object.defineProperty(Icon, "orderSVG", {
+  configurable: true,
+  get: () => order,
+  set: (next) => {
+    if (next !== order) previous = next;
+  }
+});

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

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

package/modules/paint/core/geometry.js

@@ -0,0 +1,182 @@
+import { cornerPath, cornerEntries, cornerModel } from "../../corners/core/index.js";
+import { outline } from "../../corners/core/outline.js";
+import { flatten, parsePath } from "../../../packages/core/src/path.js";
+import { fmt } from "../../../packages/core/src/draw.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+const num = (min) => ({ k: "num", min });
+const shape = (target, fields, positive, defaults = {}) => ({
+  target,
+  node: { painted: true },
+  shapes: Object.fromEntries(fields.map((k) => [k, num(positive.includes(k) ? 0 : void 0)])),
+  props: Object.fromEntries(
+    fields.map((k) => [
+      k,
+      { type: "number", min: positive.includes(k) ? 0 : void 0, def: defaults[k] }
+    ])
+  ),
+  required: ["id", "type", ...fields.filter((k) => defaults[k] === void 0)]
+});
+const entries = [
+  { target: "path", shapes: {}, props: { d: { type: "path" } }, required: ["id", "type"] },
+  shape("ellipse", ["cx", "cy", "rx", "ry"], ["rx", "ry"]),
+  shape(
+    "polygon",
+    ["cx", "cy", "sides", "radius", "rotation", "cornerRadius"],
+    ["radius", "cornerRadius"],
+    { rotation: 0, cornerRadius: 0 }
+  ),
+  shape(
+    "star",
+    ["cx", "cy", "points", "radius", "innerRadius", "cornerRadius"],
+    ["radius", "innerRadius", "cornerRadius"],
+    { cornerRadius: 0 }
+  ),
+  shape("triangle", ["x0", "y0", "width", "height"], ["width", "height"]),
+  ...cornerEntries,
+  {
+    target: "stroke",
+    shapes: { scale: { k: "str", of: ["normal", "fixed"], markup: "stroke-scale" } }
+  }
+];
+for (const e of entries) {
+  const k = e.target === "polygon" ? "sides" : e.target === "star" ? "points" : "";
+  if (k) {
+    e.shapes[k] = { k: "num", min: k === "sides" ? 3 : 2, max: 1024, int: true };
+    Object.assign(e.props[k], { min: k === "sides" ? 3 : 2, max: 1024 });
+  }
+}
+function segments(d) {
+  const out = [];
+  let i = 0, command = "";
+  const arity = {
+    m: 2,
+    l: 2,
+    h: 1,
+    v: 1,
+    c: 6,
+    s: 4,
+    q: 4,
+    t: 2,
+    a: 7,
+    z: 0
+  };
+  while (i < d.length) {
+    while (/[\s,]/.test(d[i] ?? "") && i < d.length) i++;
+    if (i === d.length) break;
+    if (/[a-z]/i.test(d[i])) command = d[i++];
+    const values = [];
+    const lc = command.toLowerCase();
+    for (let k = 0; k < arity[lc]; k++) {
+      while (/[\s,]/.test(d[i] ?? "") && i < d.length) i++;
+      const token = lc === "a" && (k === 3 || k === 4) ? d[i] : /^[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?/.exec(d.slice(i))[0];
+      values.push(+token);
+      i += token.length;
+    }
+    out.push({ command, values });
+    if (lc === "m") command = command === "m" ? "l" : "L";
+  }
+  return out;
+}
+const geometry = {
+  name: "paint",
+  entries,
+  model(n, key) {
+    if (key === "d" && n.type === "path" && n.d !== void 0)
+      return { prop: { type: "path", feature: "paint" }, rest: n.d };
+    return cornerModel(n, key);
+  },
+  value(addr, value, pointer, diag) {
+    if (typeof value !== "string")
+      return diag.err(
+        "value-type",
+        pointer,
+        V && "expected path data",
+        V && "use an SVG path string"
+      );
+    try {
+      parsePath(value);
+    } catch {
+      return diag.err(
+        "bad-path",
+        pointer,
+        V && "invalid morph path",
+        V && "use valid SVG path data"
+      );
+    }
+    const a = segments(addr.rest), b = segments(value);
+    const different = Array.from({ length: Math.max(a.length, b.length) }, (_, i) => i).find(
+      (i) => a[i]?.command !== b[i]?.command
+    );
+    if (different !== void 0)
+      return diag.err(
+        "morph-mismatch",
+        pointer,
+        V && "path command structures differ",
+        V && `match segment ${different}: expected ${a[different]?.command ?? "end"}, got ${b[different]?.command ?? "end"}`
+      );
+    return value;
+  },
+  interpolate(a, b, w) {
+    if (typeof a !== "string" || typeof b !== "string" || !/^\s*[mM]/.test(a) || !/^\s*[mM]/.test(b))
+      return;
+    const aa = segments(a), bb = segments(b);
+    return aa.map(
+      (s, i) => s.command + s.values.map((v, j) => {
+        const n = v + (bb[i].values[j] - v) * w;
+        return fmt(
+          s.command.toLowerCase() === "a" && (j === 3 || j === 4) ? n < 0.5 ? 0 : 1 : n
+        );
+      }).join(" ")
+    ).join("");
+  },
+  outline(p, i) {
+    const n = p.model.nodes[i];
+    if (n.raw.skin) {
+      const d = p.hitFrame?.().nodes[i]?.geometry?.d;
+      return d ? flatten(parsePath(d)) : void 0;
+    }
+    if (!entries.some((e) => e.node && e.target === n.type) && // seam(P7-2): another module may own corners on its own node type.
+    !(n.type === "rect" && n.raw.corners) && !(n.type === "path" && p.addrs.includes(n.id + ".d")))
+      return;
+    return flatten(parsePath(cornerPath(p, i) ?? sampledPath(p, i)));
+  },
+  draw: {
+    tree(model, tree) {
+      model.nodes.forEach((n, i) => {
+        if (entries.some((e) => e.node && e.target === n.type) || n.raw.corners)
+          tree.nodes[i].kind = "path";
+      });
+    },
+    frame(p, i, data) {
+      const d = cornerPath(p, i) ?? sampledPath(p, i);
+      if (d !== void 0) data.geometry = { kind: "path", d };
+    }
+  }
+};
+function sampledPath(p, i) {
+  const n = p.model.nodes[i];
+  const v = (k, def = 0) => p.num(i, k, def);
+  const type = n.type;
+  if (type === "path") return p.value(n.id + ".d") ?? n.d;
+  else if (type === "ellipse") {
+    const cx = v("cx"), cy = v("cy"), rx = v("rx"), ry = v("ry");
+    return `M${fmt(cx - rx)} ${fmt(cy)}a${fmt(rx)} ${fmt(ry)} 0 1 0 ${fmt(2 * rx)} 0a${fmt(rx)} ${fmt(ry)} 0 1 0 ${fmt(-2 * rx)} 0Z`;
+  } else if (type === "polygon" || type === "star") {
+    const star = type === "star", count = Math.round(v(star ? "points" : "sides")) * (star ? 2 : 1);
+    return outline(
+      Array.from({ length: count }, (_, j) => {
+        const angle = (star ? -90 : v("rotation") - 90) * Math.PI / 180 + j * Math.PI * 2 / count;
+        const radius = v(star && j % 2 ? "innerRadius" : "radius");
+        return [v("cx") + radius * Math.cos(angle), v("cy") + radius * Math.sin(angle)];
+      }),
+      [v("cornerRadius")]
+    );
+  } else if (type === "triangle") {
+    const x = v("x0"), y = v("y0"), w = v("width"), h = v("height");
+    return `M${fmt(x + w / 2)} ${fmt(y)}L${fmt(x + w)} ${fmt(y + h)}L${fmt(x)} ${fmt(y + h)}Z`;
+  }
+  return void 0;
+}
+export {
+  geometry
+};

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

@@ -0,0 +1,3 @@
+import type { Module } from '../../../packages/core/src/modules.js';
+export declare function enhancePaint(p: import('../../../packages/core/src/player.js').Player, i: number, paint: import('../../../packages/core/src/draw.js').DrawPaint, key: string, geometry: import('../../../packages/core/src/draw.js').Geometry | undefined): void;
+export declare const paint: Module;

package/modules/paint/core/index.js

@@ -0,0 +1,279 @@
+import { after } from "../manifest.js";
+import { samplingEntries } from "./sampling.js";
+import { geometry } from "./geometry.js";
+import { parseHex } from "../../../packages/core/src/color.js";
+import { drawColor, geometryLength } from "../../../packages/core/src/draw.js";
+import { VERBOSE as V } from "../../../packages/core/src/flags.js";
+const number = (min, max) => ({ k: "num", min, max });
+const line = ["x1", "y1", "x2", "y2"];
+const coords = [...line, "cx", "cy", "r", "fx", "fy"];
+const stop = {
+  k: "obj",
+  p: { position: { ...number(0, 1), markup: "offset" }, color: { k: "str", markup: "stop-color" } },
+  req: ["position", "color"]
+};
+const shapes = {
+  type: { k: "str", of: ["linear", "radial", "angular"] },
+  ...Object.fromEntries(coords.map((k) => [k, number(k === "r" ? 0 : void 0)])),
+  gradientTransform: {
+    k: "tup",
+    of: Array.from({ length: 6 }, () => number()),
+    min: 6,
+    markup: "gradient-transform"
+  },
+  stops: { k: "arr", of: { ...stop, element: "stop" }, min: 2 }
+};
+for (const s of Object.values(shapes)) s.element = "gradient";
+const gradientForm = (type, fields, required = fields) => ({
+  shape: {
+    k: "obj",
+    p: Object.fromEntries([...fields, "stops", "gradientTransform"].map((k) => [k, shapes[k]])),
+    req: [...required, "stops"]
+  },
+  values: { type },
+  target: { attribute: "paint", default: "fill", choices: ["fill", "stroke"] }
+});
+const props = Object.fromEntries(
+  coords.map((k) => [k, { type: "number", ...k === "r" ? { min: 0 } : {} }])
+);
+const stopProps = {
+  position: { type: "number", min: 0, max: 1, feature: "paint" },
+  color: { type: "color", feature: "paint" }
+};
+const base = {
+  name: "paint",
+  after,
+  entries: [
+    {
+      target: "fill",
+      shapes,
+      props,
+      required: [],
+      elements: {
+        angularGradient: gradientForm("angular", line),
+        linearGradient: gradientForm("linear", line),
+        radialGradient: gradientForm("radial", ["cx", "cy", "r", "fx", "fy"], ["cx", "cy", "r"]),
+        stop: { shape: stop }
+      }
+    },
+    {
+      target: "stroke",
+      shapes: {
+        ...shapes,
+        dash: {
+          k: "arr",
+          min: 1,
+          of: { k: "alt", of: [number(0), { k: "str", re: /^(?:0|[1-9][0-9]*)(?:\.[0-9]+)?%$/ }] },
+          markup: "stroke-dasharray"
+        },
+        dashOffset: { ...number(), markup: "stroke-dashoffset" }
+      },
+      props: { ...props, dashOffset: { type: "number", def: 0, markup: "stroke-dashoffset" } },
+      required: []
+    }
+  ],
+  load(model, _raw, d) {
+    const pointers = [];
+    const counts = /* @__PURE__ */ new Map();
+    model.nodes.forEach((n, i) => {
+      const index = counts.get(n.parent) ?? 0;
+      counts.set(n.parent, index + 1);
+      pointers[i] = (n.parent < 0 ? "/nodes" : pointers[n.parent] + "/children") + "/" + index;
+      for (const key of ["fill", "stroke"]) {
+        const p = n.raw[key];
+        if (!p) continue;
+        const base2 = pointers[i] + "/" + key;
+        const bad = (field, message, hint) => d.err("bad-value", base2 + (field ? "/" + field : ""), message, hint);
+        if (p.type === "image" && !model.doc.requires?.includes("surface"))
+          d.err(
+            "undeclared-feature",
+            base2 + "/type",
+            V && "image paints need surface",
+            V && "add surface to requires"
+          );
+        if (p.type === void 0) {
+          if (p.color === void 0 && p.paint === void 0 && p.mix === void 0)
+            d.err(
+              "missing-key",
+              base2,
+              V && "paint needs a color or gradient type",
+              V && "add color or type with gradient coordinates and stops"
+            );
+          for (const k of [...coords, "stops", "gradientTransform"])
+            if (k in p)
+              bad(
+                k,
+                V && "gradient fields need a gradient type",
+                V && "add type: linear or radial"
+              );
+        } else if (p.type !== "image") {
+          if (p.color !== void 0)
+            bad("color", V && "a gradient cannot also have a flat color", V && "remove color");
+          const fields = p.type !== "radial" ? line : ["cx", "cy", "r"];
+          for (const k of [...fields, "stops"])
+            if (!(k in p)) d.err("missing-key", base2, V && `gradient needs ${k}`, V && `add ${k}`);
+          for (const k of coords)
+            if (k in p && !fields.includes(k) && !(p.type === "radial" && ["fx", "fy"].includes(k)))
+              bad(k, V && `not a ${p.type} gradient coordinate`);
+          p.stops?.forEach((s, j) => {
+            if (j && s.position < p.stops[j - 1].position)
+              bad(
+                `stops/${j}/position`,
+                V && "stop positions must be nondecreasing",
+                V && "order stops by position"
+              );
+            if (!parseHex(s.color) && s.color !== "currentColor" && !Object.hasOwn(model.colors, s.color)) {
+              const slot = /^[a-z][a-zA-Z0-9-]*$/.test(s.color);
+              d.err(
+                slot ? "unknown-color-slot" : "bad-color",
+                `${base2}/stops/${j}/color`,
+                V && `unknown stop colour "${s.color}"`,
+                V && (slot ? 'declare it in "colors"' : "use a hex colour, currentColor or a declared slot")
+              );
+            }
+          });
+        }
+        if (p.gradientTransform && p.gradientTransform[0] * p.gradientTransform[3] === p.gradientTransform[1] * p.gradientTransform[2])
+          bad(
+            "gradientTransform",
+            V && "gradient transform must be invertible",
+            V && "use a nonsingular affine matrix"
+          );
+        if (p.dash) {
+          if (p.dash.some((x) => typeof x !== typeof p.dash[0]))
+            bad(
+              "dash",
+              V && "dash lengths must use one unit",
+              V && "use all grid lengths or all percentages"
+            );
+          if (p.dash.every((x) => parseFloat(String(x)) === 0))
+            bad("dash", V && "dash pattern cannot be all zero", V && "include a positive length");
+        }
+      }
+    });
+  },
+  model(n, key) {
+    const focal = /^(fill|stroke)\.(fx|fy)$/.exec(key);
+    if (focal && n.raw[focal[1]]?.type === "radial") {
+      const raw = n.raw[focal[1]];
+      return {
+        prop: { type: "number", feature: "paint" },
+        rest: raw[focal[2]] ?? raw[focal[2] === "fx" ? "cx" : "cy"]
+      };
+    }
+    const m = /^(fill|stroke)\.stops\.(0|[1-9][0-9]*)\.(position|color)$/.exec(key);
+    if (!m) return;
+    const s = n.raw[m[1]]?.stops?.[+m[2]];
+    if (!s) return;
+    const value = s[m[3]];
+    return { prop: stopProps[m[3]], rest: m[3] === "color" ? parseHex(value) ?? value : value };
+  },
+  draw: {
+    tree(model, tree) {
+      const paths = [], counts = /* @__PURE__ */ new Map();
+      model.nodes.forEach((n, node) => {
+        const j = counts.get(n.parent) ?? 0;
+        counts.set(n.parent, j + 1);
+        paths[node] = (n.parent < 0 ? "/nodes" : paths[n.parent] + "/children") + "/" + j;
+        tree.nodes[node].pointer = paths[node];
+        for (const key of ["fill", "stroke"])
+          if (n.raw[key]?.type && n.raw[key].type !== "image")
+            tree.resources.push({
+              node,
+              kind: "gradient",
+              key,
+              paint: {
+                kind: key,
+                type: n.raw[key].type,
+                visible: true,
+                stops: n.raw[key].stops
+              }
+            });
+      });
+    },
+    frame(p, i, data) {
+      for (const paint2 of data.paints)
+        enhancePaint(p, i, paint2, paint2.key ?? paint2.kind, data.geometry);
+    }
+  }
+};
+function enhancePaint(p, i, paint2, key, geometry2) {
+  const raw = key.split(".").reduce((o, k) => o?.[k], p.model.nodes[i].raw);
+  if (!raw) return;
+  if (raw.type && raw.type !== "image") {
+    paint2.gradientTransform = raw.gradientTransform;
+    paint2.color = void 0;
+    paint2.type = raw.type;
+    paint2.coordinates = {};
+    for (const k of raw.type !== "radial" ? line : ["cx", "cy", "r", "fx", "fy"])
+      paint2.coordinates[k] = p.num(
+        i,
+        `${key}.${k}`,
+        k === "fx" ? p.num(i, `${key}.cx`, 0) : k === "fy" ? p.num(i, `${key}.cy`, 0) : 0
+      );
+    let position = 0;
+    paint2.stops = raw.stops.map((_s, j) => ({
+      position: Math.min(
+        1,
+        position = Math.max(position, p.num(i, `${key}.stops.${j}.position`, 0))
+      ),
+      color: drawColor(p, p.prop(i, `${key}.stops.${j}.color`))
+    }));
+  }
+  if (raw.scale === "fixed") paint2.scale = "fixed";
+  if (raw.dash) {
+    const relative = typeof raw.dash[0] === "string";
+    const array = raw.dash.map(
+      (x) => relative ? parseFloat(String(x)) / 100 : +x
+    );
+    const offset = p.num(i, key + ".dashOffset", 0);
+    const length = relative ? geometryLength(geometry2, p.model.draw.nodes[i]) : 1;
+    paint2.dash = array.map((v) => v * length);
+    paint2.dashOffset = offset * length;
+    if (relative) {
+      paint2.dashNormalized = array;
+      paint2.dashOffsetNormalized = offset;
+    }
+  }
+}
+const paint = {
+  ...base,
+  init(registry) {
+    return {
+      ...this,
+      entries: this.entries.filter((e) => e.target !== "image" || registry.has("assets"))
+    };
+  },
+  entries: [...base.entries, ...geometry.entries, ...samplingEntries],
+  outline: geometry.outline,
+  value: geometry.value,
+  interpolate: geometry.interpolate,
+  model: (n, k) => geometry.model?.(n, k) ?? base.model?.(n, k),
+  draw: {
+    tree(m, t) {
+      m.nodes.forEach((n, i) => {
+        if (String(n.type) !== "image") return;
+        const r = n.raw;
+        t.nodes[i].imageWrap = [r.wrapX ?? r.wrap, r.wrapY ?? r.wrap].some((v) => v !== void 0);
+      });
+      base.draw?.tree?.(m, t);
+      geometry.draw?.tree?.(m, t);
+    },
+    frame(p, i, d, e, f) {
+      geometry.draw?.frame?.(p, i, d, e, f);
+      base.draw?.frame?.(p, i, d, e, f);
+      if (d.geometry?.image) {
+        const r = p.model.nodes[i].raw;
+        Object.assign(d.geometry.image, {
+          wrap: r.wrap,
+          wrapX: r.wrapX ?? r.wrap ?? "clamp",
+          wrapY: r.wrapY ?? r.wrap ?? "clamp"
+        });
+      }
+    }
+  }
+};
+export {
+  enhancePaint,
+  paint
+};

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

@@ -0,0 +1,4 @@
+import type { ModuleEntry } from '../../../packages/core/src/modules.js';
+import type { SVGBackend } from '../../../packages/core/src/svg.js';
+export declare const samplingEntries: ModuleEntry[];
+export declare const samplingSVG: SVGBackend;