animl-cli 0.0.0-stage → 0.1.0

package/packages/cli/src/import-lottie.js

@@ -0,0 +1,274 @@
+function importLottie(source, name) {
+  const root = JSON.parse(source);
+  if (!root || typeof root !== "object" || !Array.isArray(root.layers))
+    throw Error("expected a Lottie animation with layers");
+  const diagnostics = [];
+  const warn = (pointer, message) => diagnostics.push({
+    code: "import-unsupported",
+    severity: "warning",
+    pointer,
+    message,
+    hint: "simplify this Lottie feature or author it directly in AniML"
+  });
+  const keys = (o, allowed, path) => {
+    for (const k of Object.keys(o))
+      if (!allowed.includes(k)) warn(path + "/" + k, "unsupported Lottie field " + k);
+  };
+  const fr = Number(root.fr), ip = Number(root.ip ?? 0), op = Number(root.op);
+  if (!Number.isFinite(fr) || fr <= 0 || !Number.isFinite(op) || op <= ip)
+    throw Error("Lottie needs fr > 0 and op > ip");
+  const duration = (op - ip) / fr, tracks = {};
+  const doc = {
+    anima: "0.1",
+    name,
+    grid: Math.max(Number(root.w), Number(root.h)),
+    viewBox: [0, 0, Number(root.w), Number(root.h)],
+    requires: ["paint"],
+    nodes: []
+  };
+  keys(root, ["v", "fr", "ip", "op", "w", "h", "nm", "ddd", "layers", "assets", "markers"], "");
+  if (root.ddd) warn("/ddd", "3D composition unsupported");
+  for (const key of ["assets", "markers"])
+    if (root[key]?.length) warn("/" + key, "composition " + key + " unsupported");
+  let serial = 0;
+  const point = (v) => Array.isArray(v) ? v : [v];
+  function ease(k, index) {
+    if (k.h === 1) return "hold";
+    if (!k.o || !k.i) return;
+    const n = (v) => Number(Array.isArray(v) ? v[index] ?? v[0] : v);
+    return `cubic(${n(k.o.x)},${n(k.o.y)},${n(k.i.x)},${n(k.i.y)})`;
+  }
+  function property(node, fields, property2, path, convert = point) {
+    if (!property2) return;
+    if (property2.k === void 0) {
+      warn(path, "unsupported property representation");
+      return;
+    }
+    keys(property2, ["a", "k", "ix", "l"], path);
+    if (property2.x !== void 0) warn(path + "/x", "expressions unsupported");
+    const list = property2.a === 1 ? property2.k : void 0;
+    const first = list ? list[0]?.s : property2.k;
+    const values = convert(first);
+    fields.forEach((key, i) => {
+      node[key] = values[i];
+    });
+    if (!list) return;
+    fields.forEach((field, i) => {
+      const out = [];
+      for (const [j, k] of list.entries()) {
+        keys(k, ["t", "s", "e", "i", "o", "h"], path + "/k/" + j);
+        if (k.to || k.ti) warn(path + "/k/" + j, "spatial Bezier interpolation unsupported");
+        const value = k.s ?? list[j - 1]?.e;
+        if (value === void 0) {
+          warn(path + "/k/" + j, "keyframe has no value");
+          continue;
+        }
+        const t = (Number(k.t) - ip) / fr;
+        if (t < 0 || t > duration) {
+          warn(path + "/k/" + j + "/t", "keyframe outside composition interval");
+          continue;
+        }
+        const e = ease(k, i);
+        out.push(e ? [t, convert(value)[i], e] : [t, convert(value)[i]]);
+      }
+      if (out.length) tracks[node.id + "." + field] = out;
+    });
+  }
+  function transform(node, ks, path) {
+    keys(ks, ["ty", "nm", "mn", "ix", "a", "p", "s", "r", "rz", "o", "sk", "sa", "hd"], path);
+    const anchor = ks.a?.k;
+    if (ks.a?.a === 1) warn(path + "/a", "animated anchor unsupported");
+    const a = Array.isArray(anchor) ? anchor : [0, 0];
+    node.pivot = [a[0], a[1]];
+    property(node, ["x", "y"], ks.p, path + "/p", (v) => [
+      point(v)[0] - a[0],
+      point(v)[1] - a[1]
+    ]);
+    if (ks.p?.s) warn(path + "/p/s", "separated position unsupported");
+    property(node, ["scaleX", "scaleY"], ks.s, path + "/s", (v) => point(v).map((n) => n / 100));
+    property(node, ["rotate"], ks.r ?? ks.rz, path + "/r");
+    property(node, ["opacity"], ks.o, path + "/o", (v) => point(v).map((n) => n / 100));
+    if (ks.sk?.k || ks.sa?.k) warn(path + "/sk", "skew transform unsupported");
+  }
+  const hex = (value) => "#" + [...point(value).slice(0, 3), point(value)[3] ?? 1].map(
+    (n) => Math.round(Math.min(1, Math.max(0, n)) * 255).toString(16).padStart(2, "0")
+  ).join("");
+  function pathData(value) {
+    const p = Array.isArray(value) ? value[0] : value;
+    if (!p || !Array.isArray(p.v) || !p.v.length) throw Error("invalid Lottie shape path");
+    let d = `M${p.v[0][0]} ${p.v[0][1]}`;
+    for (let n = 1; n < p.v.length + (p.c ? 1 : 0); n++) {
+      const i = n % p.v.length, j = (n - 1) % p.v.length;
+      d += `C${p.v[j][0] + p.o[j][0]} ${p.v[j][1] + p.o[j][1]} ${p.v[i][0] + p.i[i][0]} ${p.v[i][1] + p.i[i][1]} ${p.v[i][0]} ${p.v[i][1]}`;
+    }
+    return d + (p.c ? "Z" : "");
+  }
+  function shapes(items, path) {
+    const out = [];
+    const fills = items.filter((s) => s.ty === "fl"), strokes = items.filter((s) => s.ty === "st");
+    if (fills.length > 1 || strokes.length > 1)
+      warn(
+        path,
+        "multiple fills/strokes unsupported; only the final paint of each kind is imported"
+      );
+    for (const [index, s] of items.entries()) {
+      const p = path + "/" + index, node = { id: "lottie-" + serial++, type: "path" };
+      if (s.bm) warn(p + "/bm", "shape blend mode unsupported");
+      if (s.hd) {
+        warn(p + "/hd", "hidden shape omitted");
+        continue;
+      }
+      if (s.ty === "gr") {
+        keys(s, ["ty", "nm", "mn", "ix", "it", "np", "cix", "bm", "hd"], p);
+        node.type = "group";
+        node.children = shapes(s.it ?? [], p + "/it");
+        const tr = s.it?.find((v) => v.ty === "tr");
+        if (tr) transform(node, tr, p + "/it/" + s.it.indexOf(tr));
+      } else if (s.ty === "rc" || s.ty === "el") {
+        keys(s, ["ty", "nm", "mn", "ix", "p", "s", "r", "d", "hd"], p);
+        const size = point(s.s?.k), pos = point(s.p?.k);
+        if (s.s?.a || s.p?.a) {
+          warn(p, "animated primitive size/position unsupported; initial values imported");
+        }
+        if (!size.every(Number.isFinite) || !pos.every(Number.isFinite)) {
+          warn(p, "animated primitive omitted");
+          continue;
+        }
+        if (s.r?.a === 1)
+          warn(p + "/r", "animated primitive rounding unsupported; initial value imported");
+        if (s.ty === "rc")
+          Object.assign(node, {
+            type: "rect",
+            x0: pos[0] - size[0] / 2,
+            y0: pos[1] - size[1] / 2,
+            w: size[0],
+            h: size[1],
+            rx: s.r?.a === 1 ? Number(s.r.k?.[0]?.s?.[0] ?? 0) : s.r?.k ?? 0
+          });
+        else
+          Object.assign(node, {
+            type: "ellipse",
+            cx: pos[0],
+            cy: pos[1],
+            rx: size[0] / 2,
+            ry: size[1] / 2
+          });
+      } else if (s.ty === "sh") {
+        keys(s, ["ty", "nm", "mn", "ix", "ks", "ind", "hd"], p);
+        property(node, ["d"], s.ks, p + "/ks", (v) => [pathData(v)]);
+      } else if (["fl", "st", "tm", "tr"].includes(s.ty)) continue;
+      else {
+        warn(p, "unsupported Lottie shape " + s.ty);
+        continue;
+      }
+      if (node.type !== "group") {
+        for (const [kind, list] of [
+          ["fill", fills],
+          ["stroke", strokes]
+        ]) {
+          const paint = list.at(-1);
+          if (!paint) continue;
+          const pp = path + "/" + items.indexOf(paint);
+          keys(
+            paint,
+            ["ty", "nm", "mn", "ix", "c", "o", "r", "w", "lc", "lj", "ml", "bm", "d", "hd"],
+            pp
+          );
+          const target = { id: node.id };
+          property(target, [kind + ".color"], paint.c, pp + "/c", (v) => [hex(v)]);
+          const c = target[kind + ".color"];
+          node[kind] = { color: c };
+          if (paint.o?.a || (paint.o?.k ?? 100) !== 100)
+            warn(pp + "/o", "paint opacity unsupported");
+          if (kind === "fill") node.fill.rule = paint.r === 2 ? "evenodd" : "nonzero";
+          else {
+            property(target, ["stroke.width"], paint.w, pp + "/w");
+            node.stroke.width = target["stroke.width"] ?? 1;
+            node.stroke.cap = ["butt", "round", "square"][(paint.lc ?? 1) - 1];
+            node.stroke.join = ["miter", "round", "bevel"][(paint.lj ?? 1) - 1];
+            if (paint.d?.length) warn(pp + "/d", "stroke dashes unsupported");
+          }
+        }
+        const trim = items.find((v) => v.ty === "tm");
+        if (trim) {
+          const pp = path + "/" + items.indexOf(trim);
+          keys(trim, ["ty", "nm", "mn", "ix", "s", "e", "o", "m", "hd"], pp);
+          if (!node.stroke) warn(pp, "trim paths on filled geometry unsupported");
+          else {
+            const t = { id: node.id };
+            for (const [key, field, div] of [
+              ["s", "trimStart", 100],
+              ["e", "trimEnd", 100],
+              ["o", "trimOffset", 360]
+            ]) {
+              property(
+                t,
+                ["stroke." + field],
+                trim[key],
+                pp + "/" + key,
+                (v) => point(v).map((n) => n / div)
+              );
+              node.stroke[field] = t["stroke." + field] ?? (key === "e" ? 1 : 0);
+            }
+          }
+          if (trim.m === 2) warn(pp + "/m", "individual trim paths unsupported");
+        }
+      }
+      out.push(node);
+    }
+    return out;
+  }
+  root.layers.forEach((layer, index) => {
+    const p = "/layers/" + index;
+    keys(
+      layer,
+      [
+        "ddd",
+        "ind",
+        "ty",
+        "nm",
+        "sr",
+        "ks",
+        "ao",
+        "shapes",
+        "ip",
+        "op",
+        "st",
+        "bm",
+        "parent",
+        "hd"
+      ],
+      p
+    );
+    if (layer.ty !== 4) {
+      warn(p + "/ty", "only shape layers are supported");
+      return;
+    }
+    for (const key of ["parent", "ao", "bm", "ddd"])
+      if (key === "parent" ? layer[key] !== void 0 : layer[key])
+        warn(p + "/" + key, "unsupported layer " + key);
+    if ((layer.sr ?? 1) !== 1 || (layer.st ?? 0) !== 0)
+      warn(p + ((layer.sr ?? 1) !== 1 ? "/sr" : "/st"), "layer time remapping unsupported");
+    if ((layer.ip ?? ip) !== ip || (layer.op ?? op) !== op)
+      warn(
+        p + ((layer.ip ?? ip) !== ip ? "/ip" : "/op"),
+        "partial layer visibility interval unsupported"
+      );
+    const node = {
+      id: "layer-" + index,
+      type: "group",
+      children: shapes(layer.shapes ?? [], p + "/shapes")
+    };
+    if (layer.hd) node.visible = false;
+    transform(node, layer.ks ?? {}, p + "/ks");
+    doc.nodes.unshift(node);
+  });
+  if (Object.keys(tracks).length) {
+    doc.timelines = { imported: { duration, tracks } };
+    doc.machine = { layers: { main: { initial: "play", states: { play: { play: "imported" } } } } };
+  }
+  return { doc, diagnostics };
+}
+export {
+  importLottie
+};

package/packages/cli/src/import-svg.d.ts

@@ -0,0 +1,8 @@
+import type { Diagnostic } from 'animl';
+type RecordValue = Record<string, any>;
+export interface Imported {
+    doc: RecordValue;
+    diagnostics: Diagnostic[];
+}
+export declare function importSVG(source: string, name: string): Imported;
+export {};

package/packages/cli/src/import-svg.js

@@ -0,0 +1,300 @@
+import { parseXml } from "animl/internal/packages/markup/src/xml.js";
+function importSVG(source, name) {
+  const diagnostics = [];
+  const warn = (pointer, message) => diagnostics.push({
+    code: "import-unsupported",
+    severity: "warning",
+    pointer,
+    message,
+    hint: "simplify this SVG feature or author it directly in AniML"
+  });
+  const parsed = parseXml(source);
+  if (!parsed.doc.root || parsed.errors.length)
+    throw Error("invalid SVG XML: " + parsed.errors[0]?.message);
+  const root = parsed.doc.root;
+  if (root.name !== "svg") throw Error("expected an svg root");
+  const attrs = (el) => Object.fromEntries(el.attrs.map((a) => [a.name, a.value]));
+  const ra = attrs(root), vb = (ra.viewBox ?? `0 0 ${ra.width ?? 24} ${ra.height ?? 24}`).trim().split(/[ ,]+/).map(Number);
+  if (vb.length !== 4 || vb.some((v) => !Number.isFinite(v)) || vb[2] <= 0 || vb[3] <= 0)
+    throw Error("SVG needs a numeric positive viewBox");
+  const doc = {
+    anima: "0.1",
+    name,
+    grid: Math.max(vb[2], vb[3]),
+    viewBox: vb,
+    requires: ["paint"],
+    nodes: []
+  };
+  const defs = /* @__PURE__ */ new Map();
+  const locations = /* @__PURE__ */ new Map();
+  const scan = (el, pointer) => {
+    locations.set(el, pointer);
+    const a = attrs(el);
+    if (a.id) defs.set(a.id, el);
+    el.children.forEach((c, i) => {
+      if (c.kind === "element") scan(c, pointer + "/" + i);
+    });
+  };
+  scan(root, "/svg");
+  let serial = 0;
+  const color = (v, pointer) => {
+    const colors = {
+      black: "#000000",
+      white: "#ffffff",
+      red: "#ff0000",
+      green: "#008000",
+      blue: "#0000ff",
+      transparent: "#00000000",
+      lime: "#00ff00",
+      yellow: "#ffff00",
+      aqua: "#00ffff",
+      cyan: "#00ffff",
+      fuchsia: "#ff00ff",
+      magenta: "#ff00ff",
+      gray: "#808080",
+      grey: "#808080",
+      silver: "#c0c0c0",
+      maroon: "#800000",
+      olive: "#808000",
+      purple: "#800080",
+      teal: "#008080",
+      navy: "#000080",
+      orange: "#ffa500"
+    };
+    v = v.trim();
+    if (v.toLowerCase() === "currentcolor") return "currentColor";
+    if (/^#[0-9a-f]{4}$/i.test(v)) return "#" + [...v.slice(1)].map((c) => c + c).join("");
+    if (/^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v)) return v;
+    if (Object.hasOwn(colors, v.toLowerCase())) return colors[v.toLowerCase()];
+    const rgb = /^rgba?\((.*)\)$/i.exec(v);
+    if (rgb) {
+      const parts = rgb[1].trim().split(/[,\s/]+/);
+      if ((parts.length === 3 || parts.length === 4) && parts.every((p) => /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?%?$/i.test(p))) {
+        const channel = (p, max) => Math.min(
+          max,
+          Math.max(0, p.endsWith("%") ? Number(p.slice(0, -1)) * max / 100 : Number(p))
+        );
+        return "#" + [
+          ...parts.slice(0, 3).map((p) => Math.round(channel(p, 255))),
+          Math.round(channel(parts[3] ?? "1", 1) * 255)
+        ].map((n) => n.toString(16).padStart(2, "0")).join("");
+      }
+    }
+    warn(pointer, "unsupported SVG colour " + v + "; substituted black");
+    return "#000000";
+  };
+  function paint(value, pointer) {
+    if (value === "none") return;
+    const ref = /^url\(#([^)]+)\)$/.exec(value);
+    if (!ref) return { color: color(value, pointer) };
+    const el = defs.get(ref[1]);
+    if (!el || !["linearGradient", "radialGradient"].includes(el.name)) {
+      warn(pointer, "unknown or unsupported paint server " + value);
+      return;
+    }
+    const a = attrs(el), location = locations.get(el);
+    if (a.gradientUnits !== "userSpaceOnUse") {
+      warn(location, "objectBoundingBox gradient coordinates are unsupported");
+      return;
+    }
+    const p = { type: el.name === "linearGradient" ? "linear" : "radial" };
+    for (const k of el.name === "linearGradient" ? ["x1", "y1", "x2", "y2"] : ["cx", "cy", "r", "fx", "fy"]) {
+      if (a[k] !== void 0 && Number.isFinite(Number(a[k]))) p[k] = Number(a[k]);
+    }
+    if (p.type === "linear")
+      Object.assign(p, { x1: p.x1 ?? 0, y1: p.y1 ?? 0, x2: p.x2 ?? 1, y2: p.y2 ?? 0 });
+    else Object.assign(p, { cx: p.cx ?? 0, cy: p.cy ?? 0, r: p.r ?? 1 });
+    p.stops = el.children.filter((c) => c.kind === "element" && c.name === "stop").map((c) => {
+      const s = attrs(c);
+      for (const attr of c.attrs)
+        if (!["offset", "stop-color"].includes(attr.name))
+          warn(locations.get(c) + "/@" + attr.name, "unsupported gradient stop attribute");
+      return {
+        position: s.offset?.endsWith("%") ? parseFloat(s.offset) / 100 : Number(s.offset ?? 0),
+        color: color(s["stop-color"] ?? "#000000", locations.get(c) + "/@stop-color")
+      };
+    });
+    for (const key of Object.keys(a))
+      if (!["id", "gradientUnits", "x1", "y1", "x2", "y2", "cx", "cy", "r", "fx", "fy"].includes(key))
+        warn(location + "/@" + key, "unsupported gradient attribute");
+    return p;
+  }
+  function transform(node, text, pointer) {
+    const matches = [...text.matchAll(/([a-zA-Z]+)\s*\(([^)]*)\)/g)];
+    if (text.replace(/([a-zA-Z]+)\s*\(([^)]*)\)/g, "").trim())
+      warn(pointer, "unparsed transform syntax");
+    for (const [i, m] of matches.entries()) {
+      const v = m[2].trim().split(/[ ,]+/).map(Number), t = {};
+      if (v.some((n) => !Number.isFinite(n))) {
+        warn(pointer, "nonnumeric transform");
+        continue;
+      }
+      if (m[1] === "translate") Object.assign(t, { x: v[0], y: v[1] ?? 0 });
+      else if (m[1] === "scale") Object.assign(t, { scaleX: v[0], scaleY: v[1] ?? v[0] });
+      else if (m[1] === "rotate") Object.assign(t, { rotate: v[0], pivot: [v[1] ?? 0, v[2] ?? 0] });
+      else if (m[1] === "matrix" && v.length === 6) {
+        const [a, b, c, d, e, f] = v;
+        const sx = Math.hypot(a, b);
+        if (Math.abs(a * c + b * d) > 1e-9 || !sx) {
+          warn(pointer, "skew/singular matrix cannot be represented by Anima transforms");
+          continue;
+        }
+        Object.assign(t, {
+          x: e,
+          y: f,
+          rotate: Math.atan2(b, a) * 180 / Math.PI,
+          scaleX: sx,
+          scaleY: (a * d - b * c) / sx
+        });
+      } else {
+        warn(pointer, "unsupported transform " + m[1]);
+        continue;
+      }
+      matches[i] = Object.assign(m, { compiled: t });
+    }
+    for (let i = matches.length - 1; i >= 0; i--) {
+      const t = matches[i].compiled;
+      if (t) node = { id: "svg-transform-" + serial++, type: "group", ...t, children: [node] };
+    }
+    return node;
+  }
+  function visit(el, pointer, inherited) {
+    if (el.name === "defs") {
+      el.children.forEach((child, i) => {
+        if (child.kind === "element" && !["linearGradient", "radialGradient"].includes(child.name))
+          warn(pointer + "/" + i, "unsupported SVG definition " + child.name);
+      });
+      return [];
+    }
+    if (["title", "desc", "metadata"].includes(el.name)) {
+      warn(pointer, "SVG descriptive metadata is not imported");
+      return [];
+    }
+    const a = attrs(el), style = { ...inherited };
+    const known = /* @__PURE__ */ new Set([
+      "id",
+      "transform",
+      "opacity",
+      "display",
+      "visibility",
+      "fill",
+      "fill-rule",
+      "stroke",
+      "stroke-width",
+      "stroke-linecap",
+      "stroke-linejoin",
+      "stroke-dasharray",
+      "stroke-dashoffset"
+    ]);
+    for (const k of [
+      "fill",
+      "fill-rule",
+      "stroke",
+      "stroke-width",
+      "stroke-linecap",
+      "stroke-linejoin",
+      "stroke-dasharray",
+      "stroke-dashoffset"
+    ])
+      if (a[k] !== void 0) style[k] = a[k];
+    const node = { id: "svg-" + serial++, type: el.name };
+    const coordinate = (key, fallback = 0) => {
+      known.add(key);
+      const value = a[key] === void 0 ? fallback : Number(a[key].replace(/px$/i, ""));
+      if (!Number.isFinite(value)) warn(pointer + "/@" + key, "unsupported SVG coordinate/unit");
+      return Number.isFinite(value) ? value : fallback;
+    };
+    const numeric = (target, key, fallback = 0) => {
+      node[target] = coordinate(key, fallback);
+    };
+    if (el.name === "g" || el.name === "svg") {
+      node.type = "group";
+      node.children = el.children.flatMap(
+        (c, i) => c.kind === "element" ? visit(c, pointer + "/" + i, style) : []
+      );
+    } else {
+      if (el.name === "path") {
+        known.add("d");
+        node.d = a.d;
+      } else if (el.name === "rect") {
+        numeric("x0", "x");
+        numeric("y0", "y");
+        numeric("w", "width");
+        numeric("h", "height");
+        if (a.rx) numeric("rx", "rx");
+      } else if (el.name === "circle") {
+        known.add("cx");
+        known.add("cy");
+        node.center = [coordinate("cx"), coordinate("cy")];
+        numeric("r", "r");
+      } else if (el.name === "ellipse") {
+        node.cx = coordinate("cx");
+        node.cy = coordinate("cy");
+        numeric("rx", "rx");
+        numeric("ry", "ry");
+      } else if (["line", "polyline", "polygon"].includes(el.name)) {
+        node.type = "path";
+        if (el.name === "line") {
+          for (const k of ["x1", "y1", "x2", "y2"]) known.add(k);
+          node.d = `M${coordinate("x1")} ${coordinate("y1")}L${coordinate("x2")} ${coordinate("y2")}`;
+        } else {
+          known.add("points");
+          const points = (a.points ?? "").trim().split(/[ ,]+/).map(Number);
+          node.d = "M" + points.slice(0, 2).join(" ") + "L" + points.slice(2).join(" ") + (el.name === "polygon" ? "Z" : "");
+        }
+      } else {
+        warn(pointer, "unsupported SVG element " + el.name);
+        return [];
+      }
+      const fill = paint(style.fill ?? "#000000", pointer + "/@fill");
+      if (fill && el.name !== "line")
+        node.fill = { ...fill, rule: style["fill-rule"] ?? "nonzero" };
+      const stroke = paint(style.stroke ?? "none", pointer + "/@stroke");
+      if (stroke)
+        node.stroke = {
+          ...stroke,
+          width: Number(String(style["stroke-width"] ?? 1).replace(/px$/i, "")),
+          cap: style["stroke-linecap"] ?? "butt",
+          join: style["stroke-linejoin"] ?? "miter",
+          ...style["stroke-dasharray"] && style["stroke-dasharray"] !== "none" ? { dash: style["stroke-dasharray"].split(/[ ,]+/).map(Number) } : {},
+          ...style["stroke-dashoffset"] ? { dashOffset: Number(style["stroke-dashoffset"]) } : {}
+        };
+      if (node.stroke) {
+        for (const [key, allowed, fallback] of [
+          ["cap", ["butt", "round", "square"], "butt"],
+          ["join", ["miter", "round", "bevel"], "miter"]
+        ])
+          if (!allowed.includes(node.stroke[key])) {
+            warn(pointer + "/@stroke-line" + key, "unsupported SVG stroke " + key);
+            node.stroke[key] = fallback;
+          }
+        if (!Number.isFinite(node.stroke.width)) {
+          warn(pointer + "/@stroke-width", "unsupported SVG stroke width");
+          node.stroke.width = 1;
+        }
+        if (node.stroke.dash?.some((v) => !Number.isFinite(v))) {
+          warn(pointer + "/@stroke-dasharray", "unsupported SVG dash units");
+          delete node.stroke.dash;
+        }
+      }
+      for (const [i, c] of el.children.entries())
+        if (c.kind === "element") warn(pointer + "/" + i, "unsupported SVG child " + c.name);
+    }
+    if (a.opacity !== void 0) {
+      const opacity = a.opacity.endsWith("%") ? Number(a.opacity.slice(0, -1)) / 100 : Number(a.opacity);
+      if (!Number.isFinite(opacity)) warn(pointer + "/@opacity", "unsupported SVG opacity");
+      node.opacity = Number.isFinite(opacity) ? opacity : 1;
+    }
+    if (a.display === "none" || a.visibility === "hidden") node.visible = false;
+    if (el === root)
+      for (const k of ["xmlns", "viewBox", "width", "height", "version"]) known.add(k);
+    for (const key of Object.keys(a))
+      if (!known.has(key)) warn(pointer + "/@" + key, "unsupported SVG attribute " + key);
+    return [a.transform ? transform(node, a.transform, pointer + "/@transform") : node];
+  }
+  doc.nodes = visit(root, "/svg", {});
+  return { doc, diagnostics };
+}
+export {
+  importSVG
+};

package/packages/cli/src/index.d.ts

@@ -0,0 +1 @@
+export { run, type IO } from './cli.js';

package/packages/cli/src/index.js

@@ -0,0 +1,4 @@
+import { run } from "./cli.js";
+export {
+  run
+};

package/packages/cli/src/inspect-summary.d.ts

@@ -0,0 +1,7 @@
+import { type Diagnostic, type Model } from 'animl';
+export declare function wiringSummary(model: Model, diagnostics?: Diagnostic[]): {
+    code: string;
+    pointer: string;
+    message: string;
+    hint: string;
+}[];