@weasel-js/svg 0.5.0

package/dist/index.js

@@ -0,0 +1,1384 @@
+import { pathFromD, PATH_M, PATH_L, PATH_Z, boundsOfPath, dwarn, createInsertOp, PathBuilder, parseColor, rgbaToHex, PATH_C, PATH_Q } from '@weasel-js/core';
+
+// src/parse.ts
+
+// src/types.ts
+var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+
+// src/transform.ts
+function multiply(a, b) {
+  return [
+    a[0] * b[0] + a[2] * b[1],
+    a[1] * b[0] + a[3] * b[1],
+    a[0] * b[2] + a[2] * b[3],
+    a[1] * b[2] + a[3] * b[3],
+    a[0] * b[4] + a[2] * b[5] + a[4],
+    a[1] * b[4] + a[3] * b[5] + a[5]
+  ];
+}
+function applyMatrix(m, x, y) {
+  return { x: m[0] * x + m[2] * y + m[4], y: m[1] * x + m[3] * y + m[5] };
+}
+function isIdentity(m, eps = 1e-9) {
+  return Math.abs(m[0] - 1) < eps && Math.abs(m[1]) < eps && Math.abs(m[2]) < eps && Math.abs(m[3] - 1) < eps && Math.abs(m[4]) < eps && Math.abs(m[5]) < eps;
+}
+var NUM_RE = /[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g;
+function readNumbers(s) {
+  const out = [];
+  const matches = s.match(NUM_RE);
+  if (!matches) return out;
+  for (const m of matches) {
+    const n = Number(m);
+    if (Number.isFinite(n)) out.push(n);
+  }
+  return out;
+}
+function parseTransform(attr, onWarn) {
+  if (!attr) return IDENTITY_MATRIX;
+  let result = IDENTITY_MATRIX;
+  const fnRe = /([A-Za-z]+)\s*\(([^)]*)\)/g;
+  let match;
+  while ((match = fnRe.exec(attr)) !== null) {
+    const name = match[1].toLowerCase();
+    const nums = readNumbers(match[2]);
+    let local = null;
+    if (name === "matrix" && nums.length >= 6) {
+      local = [nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]];
+    } else if (name === "translate") {
+      const tx = nums[0] ?? 0;
+      const ty = nums[1] ?? 0;
+      local = [1, 0, 0, 1, tx, ty];
+    } else if (name === "scale") {
+      const sx = nums[0] ?? 1;
+      const sy = nums.length >= 2 ? nums[1] : sx;
+      local = [sx, 0, 0, sy, 0, 0];
+    } else if (name === "rotate") {
+      const ang = (nums[0] ?? 0) * Math.PI / 180;
+      const c = Math.cos(ang);
+      const s = Math.sin(ang);
+      const rot = [c, s, -s, c, 0, 0];
+      if (nums.length >= 3) {
+        const cx = nums[1];
+        const cy = nums[2];
+        local = multiply(multiply([1, 0, 0, 1, cx, cy], rot), [1, 0, 0, 1, -cx, -cy]);
+      } else {
+        local = rot;
+      }
+    } else if (name === "skewx" || name === "skewy") {
+      const ang = (nums[0] ?? 0) * Math.PI / 180;
+      const t = Math.tan(ang);
+      local = name === "skewx" ? [1, 0, t, 1, 0, 0] : [1, t, 0, 1, 0, 0];
+    } else {
+      onWarn?.(`unsupported transform function: ${name}`);
+      continue;
+    }
+    result = multiply(result, local);
+  }
+  return result;
+}
+function decomposeRotation(m, cx, cy, eps = 1e-4) {
+  const [a, b, c, d, e, f] = m;
+  if (Math.abs(a - d) > eps) return null;
+  if (Math.abs(b + c) > eps) return null;
+  const det = a * d - b * c;
+  if (Math.abs(det - 1) > eps) return null;
+  const theta = Math.atan2(b, a);
+  const expectedE = cx - cx * a + cy * b;
+  const expectedF = cy - cx * b - cy * a;
+  if (Math.abs(e - expectedE) > eps) return null;
+  if (Math.abs(f - expectedF) > eps) return null;
+  return theta;
+}
+function rotationComponent(m) {
+  return Math.atan2(m[1], m[0]);
+}
+function formatMatrix(m) {
+  if (isIdentity(m)) return null;
+  return `matrix(${m.map((n) => trimNumber(n)).join(" ")})`;
+}
+function trimNumber(n) {
+  if (!Number.isFinite(n)) return "0";
+  const r = Math.round(n * 1e6) / 1e6;
+  if (Number.isInteger(r)) return String(r);
+  return String(r);
+}
+
+// src/shapes.ts
+var KAPPA = 4 * (Math.sqrt(2) - 1) / 3;
+function isAxisAlignedScale(m, eps = 1e-9) {
+  return Math.abs(m[1]) < eps && Math.abs(m[2]) < eps;
+}
+function transformPath(path, m) {
+  if (isIdentity(m)) return path;
+  if (path.kind === "rect") {
+    if (isAxisAlignedScale(m)) {
+      const a = m[0], d = m[3], e = m[4], f = m[5];
+      let x = path.x * a + e;
+      let y = path.y * d + f;
+      let w = path.width * a;
+      let h = path.height * d;
+      if (w < 0) {
+        x += w;
+        w = -w;
+      }
+      if (h < 0) {
+        y += h;
+        h = -h;
+      }
+      return { kind: "rect", x, y, width: w, height: h };
+    }
+    return transformPath(rectToPolygon(path), m);
+  }
+  const xs = path.coords;
+  const out = new Float32Array(xs.length);
+  for (let i = 0; i < xs.length; i += 2) {
+    const p = applyMatrix(m, xs[i], xs[i + 1]);
+    out[i] = p.x;
+    out[i + 1] = p.y;
+  }
+  return {
+    kind: "polygon",
+    commands: new Uint8Array(path.commands),
+    coords: out,
+    fillRule: path.fillRule
+  };
+}
+function rectToPolygon(r) {
+  const b = new PathBuilder();
+  b.moveTo(r.x, r.y);
+  b.lineTo(r.x + r.width, r.y);
+  b.lineTo(r.x + r.width, r.y + r.height);
+  b.lineTo(r.x, r.y + r.height);
+  b.close();
+  return b.build();
+}
+function rectElementToPath(x, y, width, height, rx, ry, m = IDENTITY_MATRIX) {
+  if (rx <= 0 && ry <= 0) {
+    return transformPath({ kind: "rect", x, y, width, height }, m);
+  }
+  const r = Math.min(Math.max(rx, ry), Math.min(width, height) / 2);
+  const r2 = Math.min(rx > 0 ? rx : r, ry > 0 ? ry : r, Math.min(width, height) / 2);
+  const rad = r2;
+  const k = KAPPA * rad;
+  const x2 = x + width;
+  const y2 = y + height;
+  const b = new PathBuilder();
+  b.moveTo(x + rad, y);
+  b.lineTo(x2 - rad, y);
+  b.curveTo(x2 - rad + k, y, x2, y + rad - k, x2, y + rad);
+  b.lineTo(x2, y2 - rad);
+  b.curveTo(x2, y2 - rad + k, x2 - rad + k, y2, x2 - rad, y2);
+  b.lineTo(x + rad, y2);
+  b.curveTo(x + rad - k, y2, x, y2 - rad + k, x, y2 - rad);
+  b.lineTo(x, y + rad);
+  b.curveTo(x, y + rad - k, x + rad - k, y, x + rad, y);
+  b.close();
+  return transformPath(b.build(), m);
+}
+function ellipseToPath(cx, cy, rx, ry, m = IDENTITY_MATRIX) {
+  const kx = KAPPA * rx;
+  const ky = KAPPA * ry;
+  const b = new PathBuilder();
+  b.moveTo(cx + rx, cy);
+  b.curveTo(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);
+  b.curveTo(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);
+  b.curveTo(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);
+  b.curveTo(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);
+  b.close();
+  return transformPath(b.build(), m);
+}
+function circleToPath(cx, cy, r, m = IDENTITY_MATRIX) {
+  return ellipseToPath(cx, cy, r, r, m);
+}
+function lineToPath(x1, y1, x2, y2, m = IDENTITY_MATRIX) {
+  const b = new PathBuilder();
+  b.moveTo(x1, y1);
+  b.lineTo(x2, y2);
+  return transformPath(b.build(), m);
+}
+function parsePoints(raw) {
+  const out = [];
+  const nums = raw.match(/[-+]?(?:\d*\.\d+|\d+\.?)(?:[eE][-+]?\d+)?/g);
+  if (!nums) return out;
+  for (let i = 0; i + 1 < nums.length; i += 2) {
+    out.push({ x: parseFloat(nums[i]), y: parseFloat(nums[i + 1]) });
+  }
+  return out;
+}
+function polylineToPath(points, m = IDENTITY_MATRIX) {
+  if (points.length === 0) {
+    return { kind: "polygon", commands: new Uint8Array(), coords: new Float32Array(), fillRule: "nonzero" };
+  }
+  const b = new PathBuilder();
+  b.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);
+  return transformPath(b.build(), m);
+}
+function polygonToPath(points, m = IDENTITY_MATRIX) {
+  if (points.length === 0) {
+    return { kind: "polygon", commands: new Uint8Array(), coords: new Float32Array(), fillRule: "nonzero" };
+  }
+  const b = new PathBuilder();
+  b.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);
+  b.close();
+  return transformPath(b.build(), m);
+}
+function parsePaintAttr(raw) {
+  if (raw == null) return null;
+  const s = raw.trim();
+  if (s === "") return null;
+  if (s === "none") return { kind: "none" };
+  if (s === "currentColor" || s === "currentcolor") {
+    return { kind: "solid", color: "#000000", alpha: 1 };
+  }
+  const urlMatch = /^url\(\s*#([^)\s]+)\s*\)/.exec(s);
+  if (urlMatch) return { kind: "ref", id: urlMatch[1] };
+  try {
+    const [r, g, b, a] = parseColor(s);
+    return { kind: "solid", color: rgbaToHex([r, g, b]), alpha: a };
+  } catch {
+    return null;
+  }
+}
+
+// src/gradients.ts
+function collectGradients(svg, onWarn) {
+  const out = /* @__PURE__ */ new Map();
+  const defs = svg.getElementsByTagName("defs");
+  for (let d = 0; d < defs.length; d++) {
+    const root = defs[d];
+    for (let i = 0; i < root.children.length; i++) {
+      const child = root.children[i];
+      const tag = child.tagName.toLowerCase();
+      const id = child.getAttribute("id");
+      if (!id) continue;
+      if (tag === "lineargradient") {
+        const paint = readLinearGradient(child, onWarn);
+        if (paint) out.set(id, paint);
+      } else if (tag === "radialgradient") {
+        const paint = readRadialGradient(child, onWarn);
+        if (paint) out.set(id, paint);
+      } else if (tag !== "lineargradient" && tag !== "radialgradient") {
+        onWarn?.(`unsupported <defs> child: <${child.tagName}>`);
+      }
+    }
+  }
+  return out;
+}
+function readStops(el, onWarn) {
+  const stops = [];
+  for (let i = 0; i < el.children.length; i++) {
+    const c = el.children[i];
+    if (c.tagName.toLowerCase() !== "stop") continue;
+    const offsetRaw = c.getAttribute("offset") ?? "0";
+    const offset = offsetRaw.endsWith("%") ? parseFloat(offsetRaw) / 100 : parseFloat(offsetRaw);
+    const colorAttr = c.getAttribute("stop-color") ?? "#000000";
+    const parsed = parsePaintAttr(colorAttr);
+    if (parsed && parsed.kind === "solid") {
+      const opacityAttr = c.getAttribute("stop-opacity");
+      const alpha = opacityAttr != null ? parseFloat(opacityAttr) : parsed.alpha;
+      stops.push({ offset, color: alpha < 1 ? applyAlpha(parsed.color, alpha) : parsed.color });
+    } else {
+      onWarn?.(`gradient stop has unrecognized stop-color: ${colorAttr}`);
+      stops.push({ offset, color: "#000000" });
+    }
+  }
+  return stops;
+}
+function applyAlpha(hex, alpha) {
+  const a = Math.max(0, Math.min(255, Math.round(alpha * 255)));
+  return `${hex}${a.toString(16).padStart(2, "0")}`;
+}
+function readLinearGradient(el, onWarn) {
+  const x1 = parseFloat(el.getAttribute("x1") ?? "0");
+  const y1 = parseFloat(el.getAttribute("y1") ?? "0");
+  const x2 = parseFloat(el.getAttribute("x2") ?? "1");
+  const y2 = parseFloat(el.getAttribute("y2") ?? "0");
+  const stops = readStops(el, onWarn);
+  return {
+    fill: "linear-gradient",
+    from: { x: x1, y: y1 },
+    to: { x: x2, y: y2 },
+    stops
+  };
+}
+function readRadialGradient(el, onWarn) {
+  const cx = parseFloat(el.getAttribute("cx") ?? "0.5");
+  const cy = parseFloat(el.getAttribute("cy") ?? "0.5");
+  const r = parseFloat(el.getAttribute("r") ?? "0.5");
+  const stops = readStops(el, onWarn);
+  return {
+    fill: "radial-gradient",
+    center: { x: cx, y: cy },
+    radius: r,
+    stops
+  };
+}
+var GradientRegistry = class {
+  byPaint = /* @__PURE__ */ new Map();
+  order = [];
+  counter = 0;
+  register(paint) {
+    const existing = this.byPaint.get(paint);
+    if (existing) return existing;
+    const id = `grad${this.counter++}`;
+    this.byPaint.set(paint, id);
+    this.order.push(paint);
+    return id;
+  }
+  /** Emit `<defs>...</defs>` XML for all registered gradients. */
+  toDefsXml() {
+    if (this.order.length === 0) return "";
+    const parts = ["<defs>"];
+    for (const paint of this.order) {
+      const id = this.byPaint.get(paint);
+      parts.push(gradientXml(id, paint));
+    }
+    parts.push("</defs>");
+    return parts.join("");
+  }
+};
+function gradientXml(id, paint) {
+  if (paint.fill === "linear-gradient") {
+    const stops = paint.stops.map(stopXml).join("");
+    return `<linearGradient id="${id}" gradientUnits="userSpaceOnUse" x1="${trimNumber(paint.from.x)}" y1="${trimNumber(paint.from.y)}" x2="${trimNumber(paint.to.x)}" y2="${trimNumber(paint.to.y)}">${stops}</linearGradient>`;
+  }
+  if (paint.fill === "radial-gradient") {
+    const stops = paint.stops.map(stopXml).join("");
+    return `<radialGradient id="${id}" gradientUnits="userSpaceOnUse" cx="${trimNumber(paint.center.x)}" cy="${trimNumber(paint.center.y)}" r="${trimNumber(paint.radius)}">${stops}</radialGradient>`;
+  }
+  return "";
+}
+function stopXml(s) {
+  const m = /^#([0-9a-f]{6})([0-9a-f]{2})$/i.exec(s.color);
+  if (m) {
+    const alpha = parseInt(m[2], 16) / 255;
+    return `<stop offset="${trimNumber(s.offset)}" stop-color="#${m[1].toLowerCase()}" stop-opacity="${trimNumber(alpha)}"/>`;
+  }
+  return `<stop offset="${trimNumber(s.offset)}" stop-color="${s.color}"/>`;
+}
+
+// src/cascade.ts
+var EMPTY_STYLE = {};
+var INHERITABLE = [
+  "fill",
+  "fill-opacity",
+  "fill-rule",
+  "stroke",
+  "stroke-width",
+  "stroke-opacity",
+  "stroke-linecap",
+  "stroke-linejoin",
+  "stroke-dasharray",
+  "stroke-miterlimit",
+  "color",
+  "font-size",
+  "font-family",
+  "font-weight",
+  "font-style",
+  "text-anchor"
+];
+function readStyleProp(el, prop) {
+  const style = el.getAttribute("style");
+  if (!style) return null;
+  const re = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i");
+  const m = re.exec(style);
+  if (!m) return null;
+  return m[1].trim();
+}
+function ownProp(el, prop) {
+  return readStyleProp(el, prop) ?? el.getAttribute(prop);
+}
+function deriveStyle(parent, el) {
+  let next = null;
+  for (const prop of INHERITABLE) {
+    const own = ownProp(el, prop);
+    if (own == null || own === "inherit") continue;
+    if (!next) next = { ...parent };
+    next[prop] = own;
+  }
+  return next ?? parent;
+}
+function resolveCurrentColor(raw, style) {
+  if (raw == null) return null;
+  if (raw.trim().toLowerCase() === "currentcolor") return style["color"] ?? "#000000";
+  return raw;
+}
+
+// src/parse.ts
+var SUPPORTED_LEAF_TAGS = /* @__PURE__ */ new Set([
+  "rect",
+  "circle",
+  "ellipse",
+  "line",
+  "polyline",
+  "polygon",
+  "path"
+]);
+var SUPPORTED_GROUP_TAGS = /* @__PURE__ */ new Set(["g", "svg"]);
+var IGNORED_TAGS = /* @__PURE__ */ new Set(["defs", "linearGradient", "radialGradient", "title", "desc", "metadata"]);
+function parseSvg(svg, opts = {}) {
+  const warnings = [];
+  const onWarn = (m) => {
+    warnings.push(m);
+  };
+  let doc;
+  try {
+    doc = new DOMParser().parseFromString(svg, "image/svg+xml");
+  } catch (e) {
+    return { nodes: [], warnings: [`failed to parse SVG: ${e.message}`] };
+  }
+  const errEl = doc.getElementsByTagName("parsererror")[0];
+  if (errEl) {
+    return { nodes: [], warnings: [`SVG parse error: ${errEl.textContent ?? "unknown"}`] };
+  }
+  const root = doc.documentElement;
+  if (!root || root.tagName.toLowerCase() !== "svg") {
+    return { nodes: [], warnings: ["root element is not <svg>"] };
+  }
+  const namespaces = opts.namespaces ?? {};
+  const uriToPrefix = /* @__PURE__ */ new Map();
+  for (const [prefix, uri] of Object.entries(namespaces)) {
+    uriToPrefix.set(uri, prefix);
+  }
+  const documentMeta = collectDocumentMeta(root, uriToPrefix);
+  const gradients = collectGradients(root, onWarn);
+  const rootStyle = deriveStyle(EMPTY_STYLE, root);
+  const nodes = parseChildren(root, IDENTITY_MATRIX, rootStyle, gradients, onWarn, uriToPrefix);
+  const result = { nodes, warnings };
+  if (documentMeta) result.documentMeta = documentMeta;
+  const viewBox = parseViewBoxAttr(root.getAttribute("viewBox"));
+  if (viewBox) result.viewBox = viewBox;
+  const widthAttr = root.getAttribute("width");
+  if (widthAttr != null) {
+    const n = parseFloat(widthAttr);
+    if (Number.isFinite(n)) result.width = n;
+  }
+  const heightAttr = root.getAttribute("height");
+  if (heightAttr != null) {
+    const n = parseFloat(heightAttr);
+    if (Number.isFinite(n)) result.height = n;
+  }
+  for (let i = 0; i < root.children.length; i++) {
+    const c = root.children[i];
+    if (c.tagName.toLowerCase() === "title") {
+      result.title = c.textContent ?? "";
+      break;
+    }
+  }
+  return result;
+}
+function parseViewBoxAttr(raw) {
+  if (raw == null) return void 0;
+  const parts = raw.trim().split(/[\s,]+/).filter(Boolean);
+  if (parts.length !== 4) return void 0;
+  const nums = parts.map(parseFloat);
+  if (nums.some((n) => !Number.isFinite(n))) return void 0;
+  return { x: nums[0], y: nums[1], width: nums[2], height: nums[3] };
+}
+function collectDocumentMeta(root, uriToPrefix) {
+  if (uriToPrefix.size === 0) return void 0;
+  const meta = {};
+  for (let i = 0; i < root.attributes.length; i++) {
+    const a = root.attributes[i];
+    if (!a.namespaceURI) continue;
+    const prefix = uriToPrefix.get(a.namespaceURI);
+    if (!prefix) continue;
+    const bucket = meta[prefix] ??= {};
+    (bucket.attrs ??= {})[a.localName] = a.value;
+  }
+  for (let i = 0; i < root.children.length; i++) {
+    const c = root.children[i];
+    if (!c.namespaceURI) continue;
+    const prefix = uriToPrefix.get(c.namespaceURI);
+    if (!prefix) continue;
+    const bucket = meta[prefix] ??= {};
+    const elements = bucket.elements ??= {};
+    const list = elements[c.localName] ??= [];
+    list.push(collectNamespacedElement(c, uriToPrefix));
+  }
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function collectNamespacedElement(el, uriToPrefix) {
+  const result = { attrs: {} };
+  for (let i = 0; i < el.attributes.length; i++) {
+    const a = el.attributes[i];
+    if (a.name.startsWith("xmlns")) continue;
+    result.attrs[a.localName] = a.value;
+  }
+  let hasChildElements = false;
+  for (let i = 0; i < el.children.length; i++) {
+    const c = el.children[i];
+    if (!c.namespaceURI) continue;
+    const prefix = uriToPrefix.get(c.namespaceURI);
+    if (!prefix) continue;
+    hasChildElements = true;
+    const children = result.children ??= {};
+    const list = children[c.localName] ??= [];
+    list.push(collectNamespacedElement(c, uriToPrefix));
+  }
+  if (!hasChildElements && el.textContent != null && el.textContent.trim() !== "") {
+    result.text = el.textContent;
+  }
+  return result;
+}
+function collectElementMeta(el, uriToPrefix) {
+  if (uriToPrefix.size === 0) return void 0;
+  const meta = {};
+  for (let i = 0; i < el.attributes.length; i++) {
+    const a = el.attributes[i];
+    if (!a.namespaceURI) continue;
+    const prefix = uriToPrefix.get(a.namespaceURI);
+    if (!prefix) continue;
+    const bucket = meta[prefix] ??= {};
+    (bucket.attrs ??= {})[a.localName] = a.value;
+  }
+  for (let i = 0; i < el.children.length; i++) {
+    const c = el.children[i];
+    if (!c.namespaceURI) continue;
+    const prefix = uriToPrefix.get(c.namespaceURI);
+    if (!prefix) continue;
+    const bucket = meta[prefix] ??= {};
+    const elements = bucket.elements ??= {};
+    const list = elements[c.localName] ??= [];
+    list.push(collectNamespacedElement(c, uriToPrefix));
+  }
+  return Object.keys(meta).length > 0 ? meta : void 0;
+}
+function parseChildren(parent, ctm, style, gradients, onWarn, uriToPrefix) {
+  const out = [];
+  for (let i = 0; i < parent.children.length; i++) {
+    const el = parent.children[i];
+    const ns = el.namespaceURI;
+    if (ns && ns !== "http://www.w3.org/2000/svg") continue;
+    const node = parseElement(el, ctm, style, gradients, onWarn, uriToPrefix);
+    if (node) {
+      if (Array.isArray(node)) out.push(...node);
+      else out.push(node);
+    }
+  }
+  return out;
+}
+function parseElement(el, ctm, style, gradients, onWarn, uriToPrefix) {
+  const tag = el.tagName.toLowerCase();
+  if (IGNORED_TAGS.has(tag)) return null;
+  if (tag === "g") {
+    const local = parseTransform(el.getAttribute("transform"), onWarn);
+    const childCtm = multiply(ctm, local);
+    const childStyle = deriveStyle(style, el);
+    const children = parseChildren(el, childCtm, childStyle, gradients, onWarn, uriToPrefix);
+    const opacity2 = readOpacityAttr(el, "opacity");
+    const group = { kind: "group", children };
+    if (opacity2 != null) group.opacity = opacity2;
+    const meta2 = collectElementMeta(el, uriToPrefix);
+    if (meta2) group.meta = meta2;
+    return group;
+  }
+  if (SUPPORTED_GROUP_TAGS.has(tag)) {
+    const childStyle = deriveStyle(style, el);
+    return parseChildren(el, ctm, childStyle, gradients, onWarn, uriToPrefix);
+  }
+  if (tag === "text") {
+    const textNode = parseTextElement(el, ctm, style, gradients, onWarn);
+    if (textNode && !Array.isArray(textNode) && textNode.kind === "text") {
+      const meta2 = collectElementMeta(el, uriToPrefix);
+      if (meta2) textNode.meta = meta2;
+    }
+    return textNode;
+  }
+  if (!SUPPORTED_LEAF_TAGS.has(tag)) {
+    onWarn(`unsupported element: <${el.tagName}>`);
+    return null;
+  }
+  const localTransform = parseTransform(el.getAttribute("transform"), onWarn);
+  let path = lowerLeaf(el, tag, ctm, onWarn);
+  if (!path) return null;
+  let rotation;
+  if (!isIdentity(localTransform)) {
+    const bounds = pathAabb(path);
+    const cx = bounds.x + bounds.width / 2;
+    const cy = bounds.y + bounds.height / 2;
+    const angle = decomposeRotation(localTransform, cx, cy);
+    if (angle != null) {
+      rotation = angle;
+    } else {
+      path = transformPath(path, localTransform);
+      const rotComp = rotationComponent(localTransform);
+      if (Math.abs(rotComp) > 1e-4) {
+        onWarn(`leaf transform has a rotational component that can't be cleanly stored as rotation; baked into geometry (may not round-trip identically)`);
+      }
+    }
+  }
+  const leafStyle = deriveStyle(style, el);
+  const fill = readPaint(leafStyle, "fill", "#000000", gradients, onWarn);
+  const stroke = readStroke(leafStyle, gradients, onWarn);
+  const opacity = readOpacityAttr(el, "opacity");
+  const fillRuleRaw = leafStyle["fill-rule"] ?? null;
+  if (fillRuleRaw === "evenodd" && path.kind === "polygon") {
+    path = { ...path, fillRule: "evenodd" };
+  }
+  const node = { kind: "path", path, fill };
+  if (stroke) node.stroke = stroke;
+  if (opacity != null) node.opacity = opacity;
+  if (rotation != null) node.rotation = rotation;
+  if (tag === "line" && (leafStyle["fill"] ?? null) == null) {
+    node.fill = { kind: "none" };
+  }
+  if (tag === "polyline" && !el.hasAttribute("fill")) ;
+  const meta = collectElementMeta(el, uriToPrefix);
+  if (meta) node.meta = meta;
+  return node;
+}
+function lowerLeaf(el, tag, m, onWarn) {
+  const num = (name, fallback = 0) => {
+    const v = el.getAttribute(name);
+    if (v == null) return fallback;
+    const n = parseFloat(v);
+    return Number.isFinite(n) ? n : fallback;
+  };
+  if (tag === "rect") {
+    const x = num("x", 0);
+    const y = num("y", 0);
+    const w = num("width", 0);
+    const h = num("height", 0);
+    const rx = num("rx", 0);
+    const ry = num("ry", 0);
+    return rectElementToPath(x, y, w, h, rx, ry, m);
+  }
+  if (tag === "circle") return circleToPath(num("cx"), num("cy"), num("r"), m);
+  if (tag === "ellipse") return ellipseToPath(num("cx"), num("cy"), num("rx"), num("ry"), m);
+  if (tag === "line") return lineToPath(num("x1"), num("y1"), num("x2"), num("y2"), m);
+  if (tag === "polyline") return polylineToPath(parsePoints(el.getAttribute("points") ?? ""), m);
+  if (tag === "polygon") return polygonToPath(parsePoints(el.getAttribute("points") ?? ""), m);
+  if (tag === "path") {
+    const d = el.getAttribute("d") ?? "";
+    if (!d.trim()) {
+      onWarn("<path> with empty d=");
+      return null;
+    }
+    const raw = pathFromD(d, onWarn);
+    const transformed = transformPath(raw, m);
+    if (transformed.kind === "polygon") {
+      const rect = polygonToRectIfAxisAligned(transformed);
+      if (rect) return rect;
+    }
+    return transformed;
+  }
+  return null;
+}
+function polygonToRectIfAxisAligned(p) {
+  const cmds = p.commands;
+  if (cmds.length !== 5) return null;
+  if (cmds[0] !== PATH_M) return null;
+  if (cmds[1] !== PATH_L || cmds[2] !== PATH_L || cmds[3] !== PATH_L) return null;
+  if (cmds[4] !== PATH_Z) return null;
+  const c = p.coords;
+  if (c.length !== 8) return null;
+  const x0 = c[0], y0 = c[1];
+  const x1 = c[2], y1 = c[3];
+  const x2 = c[4], y2 = c[5];
+  const x3 = c[6], y3 = c[7];
+  if (y0 !== y1 || x1 !== x2 || y2 !== y3 || x3 !== x0) return null;
+  const x = Math.min(x0, x1);
+  const y = Math.min(y0, y2);
+  const width = Math.abs(x1 - x0);
+  const height = Math.abs(y2 - y1);
+  if (width === 0 || height === 0) return null;
+  return { kind: "rect", x, y, width, height };
+}
+function pathAabb(path) {
+  if (path.kind === "rect") {
+    return { x: path.x, y: path.y, width: path.width, height: path.height };
+  }
+  return boundsOfPath(path);
+}
+function readPaint(style, attr, defaultColor, gradients, onWarn) {
+  const raw = resolveCurrentColor(style[attr] ?? null, style);
+  const opacityRaw = style[`${attr}-opacity`] ?? null;
+  const opacity = opacityRaw != null ? clamp01(parseFloat(opacityRaw)) : void 0;
+  if (raw == null) {
+    if (attr === "stroke") return { kind: "none" };
+    const out2 = { kind: "solid", color: defaultColor };
+    if (opacity != null) out2.opacity = opacity;
+    return out2;
+  }
+  const parsed = parsePaintAttr(raw);
+  if (!parsed) {
+    onWarn(`unrecognized ${attr} value: ${raw}`);
+    return { kind: "solid", color: defaultColor };
+  }
+  if (parsed.kind === "none") return { kind: "none" };
+  if (parsed.kind === "ref") {
+    const paint = gradients.get(parsed.id);
+    if (!paint) {
+      onWarn(`${attr} references unknown gradient #${parsed.id}`);
+      return { kind: "solid", color: defaultColor };
+    }
+    return { kind: "gradient", paint };
+  }
+  const out = { kind: "solid", color: parsed.color };
+  const a = opacity ?? (parsed.alpha < 1 ? parsed.alpha : void 0);
+  if (a != null) out.opacity = a;
+  return out;
+}
+function readStroke(style, gradients, onWarn) {
+  const inheritedStroke = style["stroke"] ?? null;
+  const inheritedWidth = style["stroke-width"] ?? null;
+  if (inheritedStroke == null && inheritedWidth == null) return void 0;
+  const paint = readPaint(style, "stroke", "#000000", gradients, onWarn);
+  if (paint.kind === "none") return void 0;
+  const width = inheritedWidth != null ? parseFloat(inheritedWidth) : 1;
+  const stroke = { paint, width };
+  const opacityRaw = style["stroke-opacity"] ?? null;
+  if (opacityRaw != null) {
+    const a = clamp01(parseFloat(opacityRaw));
+    if (Number.isFinite(a)) stroke.opacity = a;
+  }
+  const cap = style["stroke-linecap"] ?? null;
+  if (cap === "butt" || cap === "round" || cap === "square") {
+    stroke.cap = cap;
+  } else if (cap != null) {
+    onWarn(`unsupported stroke-linecap: ${cap}`);
+  }
+  const join = style["stroke-linejoin"] ?? null;
+  if (join === "miter" || join === "round" || join === "bevel") {
+    stroke.join = join;
+  } else if (join === "arcs" || join === "miter-clip") {
+    onWarn(`stroke-linejoin "${join}" not supported; falling back to miter`);
+    stroke.join = "miter";
+  } else if (join != null) {
+    onWarn(`unsupported stroke-linejoin: ${join}`);
+  }
+  const dashAttr = style["stroke-dasharray"] ?? null;
+  if (dashAttr != null && dashAttr.trim() !== "" && dashAttr.trim() !== "none") {
+    const parsed = parseDashArray(dashAttr);
+    if (parsed) stroke.dash = parsed;
+    else onWarn(`unrecognized stroke-dasharray: ${dashAttr}`);
+  }
+  const miterAttr = style["stroke-miterlimit"] ?? null;
+  if (miterAttr != null) {
+    const m = parseFloat(miterAttr);
+    if (Number.isFinite(m) && m >= 1) stroke.miterLimit = m;
+    else onWarn(`unrecognized stroke-miterlimit: ${miterAttr}`);
+  }
+  return stroke;
+}
+function parseDashArray(s) {
+  const tokens = s.trim().split(/[\s,]+/).filter(Boolean);
+  if (tokens.length === 0) return null;
+  const nums = [];
+  for (const t of tokens) {
+    const n = parseFloat(t);
+    if (!Number.isFinite(n) || n < 0) return null;
+    nums.push(n);
+  }
+  return nums.length % 2 === 1 ? [...nums, ...nums] : nums;
+}
+function readOpacityAttr(el, name) {
+  const raw = el.getAttribute(name);
+  if (raw == null) return void 0;
+  const n = parseFloat(raw);
+  return Number.isFinite(n) ? clamp01(n) : void 0;
+}
+function clamp01(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function parseTextElement(el, ctm, style, gradients, onWarn) {
+  const num = (raw, fallback) => {
+    if (raw == null) return fallback;
+    const n = parseFloat(raw);
+    return Number.isFinite(n) ? n : fallback;
+  };
+  const localTransform = parseTransform(el.getAttribute("transform"), onWarn);
+  const m = ctm;
+  const rawX = num(el.getAttribute("x"), 0);
+  const rawY = num(el.getAttribute("y"), 0);
+  const ax = m[0] * rawX + m[2] * rawY + m[4];
+  const ay = m[1] * rawX + m[3] * rawY + m[5];
+  const leafStyle = deriveStyle(style, el);
+  const textStyle = readTextStyle(leafStyle, el, gradients, onWarn);
+  const fontSize = textStyle.fontSize ?? 16;
+  const lineHeight = textStyle.lineHeight ?? 1.2;
+  const dominantBaseline = el.getAttribute("dominant-baseline");
+  const explicitTopAnchor = dominantBaseline === "text-before-edge" || dominantBaseline === "hanging";
+  const topY = explicitTopAnchor ? ay : ay - fontSize;
+  const runs = [];
+  let plain = "";
+  for (let i = 0; i < el.childNodes.length; i++) {
+    const child = el.childNodes[i];
+    if (child.nodeType === 3) {
+      const t = child.textContent ?? "";
+      if (!t) continue;
+      runs.push({ text: t });
+      plain += t;
+    } else if (child.nodeType === 1) {
+      const sp = child;
+      if (sp.tagName.toLowerCase() !== "tspan") {
+        onWarn(`<text> child <${sp.tagName}> not supported; flattening text content`);
+        const t = sp.textContent ?? "";
+        if (t) {
+          runs.push({ text: t });
+          plain += t;
+        }
+        continue;
+      }
+      const run = readTspanRun(sp, gradients, leafStyle);
+      runs.push(run);
+      plain += run.text;
+    }
+  }
+  const dataW = num(el.getAttribute("data-weasel-width"), NaN);
+  const dataH = num(el.getAttribute("data-weasel-height"), NaN);
+  const width = Number.isFinite(dataW) ? dataW : 99999;
+  const lines = (plain.match(/\n/g)?.length ?? 0) + 1;
+  const height = Number.isFinite(dataH) ? dataH : fontSize * lineHeight * lines;
+  const opacity = readOpacityAttr(el, "opacity");
+  const node = {
+    kind: "text",
+    x: topY === ay ? ax : ax,
+    // x is unchanged by the baseline shift
+    y: topY,
+    width,
+    height,
+    text: plain
+  };
+  const hasStyling = runs.some(
+    (r) => r.bold || r.italic || r.fontFamily || r.fontSize != null || r.fill && ("color" in r.fill || "fill" in r.fill)
+  );
+  if (hasStyling) node.runs = runs;
+  if (Object.keys(textStyle).length > 0) node.style = textStyle;
+  if (opacity != null) node.opacity = opacity;
+  if (!isIdentity(localTransform)) {
+    const cx = node.x + node.width / 2;
+    const cy = node.y + node.height / 2;
+    const angle = decomposeRotation(localTransform, cx, cy);
+    if (angle != null) {
+      node.rotation = angle;
+    } else {
+      const rotComp = rotationComponent(localTransform);
+      if (Math.abs(rotComp) > 1e-4) {
+        onWarn(`<text> transform has a rotational component that can't be cleanly stored as rotation; dropped (may not round-trip identically)`);
+      }
+    }
+  }
+  return node;
+}
+function readTspanRun(el, gradients, style) {
+  const text = el.textContent ?? "";
+  const run = { text };
+  const fw = ownProp(el, "font-weight");
+  if (fw === "bold" || fw === "700" || fw === "bolder") run.bold = true;
+  const fs = ownProp(el, "font-style");
+  if (fs === "italic" || fs === "oblique") run.italic = true;
+  const ff = ownProp(el, "font-family");
+  if (ff) run.fontFamily = ff;
+  const sz = ownProp(el, "font-size");
+  if (sz != null) {
+    const n = parseFloat(sz);
+    if (Number.isFinite(n)) run.fontSize = n;
+  }
+  const tspanStyle = deriveStyle(style, el);
+  const fillAttr = resolveCurrentColor(ownProp(el, "fill"), tspanStyle);
+  if (fillAttr) {
+    const parsed = parsePaintAttr(fillAttr);
+    if (parsed?.kind === "solid") {
+      run.fill = { fill: "solid", color: parsed.color };
+    } else if (parsed?.kind === "ref") {
+      const paint = gradients.get(parsed.id);
+      if (paint) run.fill = paint;
+    }
+  }
+  return run;
+}
+function readTextStyle(style, el, gradients, onWarn) {
+  const out = {};
+  const sz = style["font-size"];
+  if (sz != null) {
+    const n = parseFloat(sz);
+    if (Number.isFinite(n)) out.fontSize = n;
+  }
+  const ff = style["font-family"];
+  if (ff) out.fontFamily = ff;
+  const fw = style["font-weight"];
+  if (fw != null) {
+    const n = parseFloat(fw);
+    out.fontWeight = Number.isFinite(n) ? n : fw;
+  }
+  const fs = style["font-style"];
+  if (fs === "italic" || fs === "normal") out.fontStyle = fs;
+  const anchor = style["text-anchor"];
+  if (anchor === "start") out.align = "left";
+  else if (anchor === "middle") out.align = "center";
+  else if (anchor === "end") out.align = "right";
+  const fillRaw = resolveCurrentColor(style["fill"] ?? null, style);
+  if (fillRaw) {
+    const parsed = parsePaintAttr(fillRaw);
+    if (parsed?.kind === "solid") {
+      out.fill = { fill: "solid", color: parsed.color };
+    } else if (parsed?.kind === "ref") {
+      const paint = gradients.get(parsed.id);
+      if (paint) out.fill = paint;
+    }
+  }
+  if (el.hasAttribute("stroke")) {
+    onWarn('<text stroke="..."> not supported on text; ignoring');
+  }
+  return out;
+}
+function serializePathD(path) {
+  if (path.kind === "rect") {
+    const { x, y, width, height } = path;
+    return `M${trimNumber(x)} ${trimNumber(y)}h${trimNumber(width)}v${trimNumber(height)}h${trimNumber(-width)}Z`;
+  }
+  const cmds = path.commands;
+  const xs = path.coords;
+  const out = [];
+  let ci = 0;
+  for (let i = 0; i < cmds.length; i++) {
+    const c = cmds[i];
+    if (c === PATH_M) {
+      out.push(`M${trimNumber(xs[ci])} ${trimNumber(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_L) {
+      out.push(`L${trimNumber(xs[ci])} ${trimNumber(xs[ci + 1])}`);
+      ci += 2;
+    } else if (c === PATH_C) {
+      out.push(
+        `C${trimNumber(xs[ci])} ${trimNumber(xs[ci + 1])} ${trimNumber(xs[ci + 2])} ${trimNumber(xs[ci + 3])} ${trimNumber(xs[ci + 4])} ${trimNumber(xs[ci + 5])}`
+      );
+      ci += 6;
+    } else if (c === PATH_Q) {
+      out.push(
+        `Q${trimNumber(xs[ci])} ${trimNumber(xs[ci + 1])} ${trimNumber(xs[ci + 2])} ${trimNumber(xs[ci + 3])}`
+      );
+      ci += 4;
+    } else if (c === PATH_Z) {
+      out.push("Z");
+    }
+  }
+  return out.join("");
+}
+
+// src/serialize.ts
+function serializeSvg(nodes, opts = {}) {
+  const registry = new GradientRegistry();
+  registerGradients(nodes, registry);
+  const bounds = opts.viewBox ?? computeBounds(nodes);
+  const vb = `${trimNumber(bounds.x)} ${trimNumber(bounds.y)} ${trimNumber(bounds.width)} ${trimNumber(bounds.height)}`;
+  const namespaces = opts.namespaces ?? {};
+  const rootAttrs = [`xmlns="http://www.w3.org/2000/svg"`];
+  for (const [prefix, uri] of Object.entries(namespaces)) {
+    rootAttrs.push(`xmlns:${prefix}="${escapeAttr(uri)}"`);
+  }
+  rootAttrs.push(`viewBox="${vb}"`);
+  if (opts.width != null) rootAttrs.push(`width="${trimNumber(opts.width)}"`);
+  if (opts.height != null) rootAttrs.push(`height="${trimNumber(opts.height)}"`);
+  if (opts.documentMeta) {
+    for (const prefix of Object.keys(namespaces)) {
+      const bucket = opts.documentMeta[prefix];
+      if (!bucket?.attrs) continue;
+      for (const [name, value] of Object.entries(bucket.attrs)) {
+        rootAttrs.push(`${prefix}:${name}="${escapeAttr(value)}"`);
+      }
+    }
+  }
+  let docMetaXml = "";
+  if (opts.documentMeta) {
+    for (const prefix of Object.keys(namespaces)) {
+      const bucket = opts.documentMeta[prefix];
+      if (!bucket?.elements) continue;
+      for (const [localName, list] of Object.entries(bucket.elements)) {
+        for (const el of list) docMetaXml += namespacedElementXml(prefix, localName, el);
+      }
+    }
+  }
+  const defsXml = registry.toDefsXml();
+  const bodyXml = nodes.map((n) => nodeXml(n, registry, namespaces)).join("");
+  const titleXml = opts.title && opts.title.length > 0 ? `<title>${escapeText(opts.title)}</title>` : "";
+  return `<svg ${rootAttrs.join(" ")}>${titleXml}${defsXml}${docMetaXml}${bodyXml}</svg>`;
+}
+function namespacedElementXml(prefix, localName, el) {
+  const attrs = [];
+  for (const [name, value] of Object.entries(el.attrs)) {
+    attrs.push(`${name}="${escapeAttr(value)}"`);
+  }
+  const head = attrs.length > 0 ? `<${prefix}:${localName} ${attrs.join(" ")}>` : `<${prefix}:${localName}>`;
+  let body = "";
+  if (el.children) {
+    for (const [childName, list] of Object.entries(el.children)) {
+      for (const child of list) body += namespacedElementXml(prefix, childName, child);
+    }
+  } else if (el.text != null) {
+    body = escapeText(el.text);
+  }
+  return `${head}${body}</${prefix}:${localName}>`;
+}
+function metaAttrsXml(meta, namespaces) {
+  if (!meta) return "";
+  const parts = [];
+  for (const prefix of Object.keys(namespaces)) {
+    const bucket = meta[prefix];
+    if (!bucket?.attrs) continue;
+    for (const [name, value] of Object.entries(bucket.attrs)) {
+      parts.push(`${prefix}:${name}="${escapeAttr(value)}"`);
+    }
+  }
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function metaElementsXml(meta, namespaces) {
+  if (!meta) return "";
+  let out = "";
+  for (const prefix of Object.keys(namespaces)) {
+    const bucket = meta[prefix];
+    if (!bucket?.elements) continue;
+    for (const [localName, list] of Object.entries(bucket.elements)) {
+      for (const el of list) out += namespacedElementXml(prefix, localName, el);
+    }
+  }
+  return out;
+}
+function registerGradients(nodes, registry) {
+  for (const n of nodes) {
+    if (n.kind === "group") {
+      registerGradients(n.children, registry);
+    } else if (n.kind === "path") {
+      if (n.fill.kind === "gradient") registry.register(n.fill.paint);
+      if (n.stroke && n.stroke.paint.kind === "gradient") registry.register(n.stroke.paint.paint);
+    } else if (n.kind === "text") {
+      const styleFill = n.style?.fill;
+      if (styleFill && !("color" in styleFill)) {
+        registry.register(styleFill);
+      }
+    }
+  }
+}
+function nodeXml(node, registry, namespaces) {
+  if (node.kind === "group") return groupXml(node, registry, namespaces);
+  if (node.kind === "text") return textXml(node, registry, namespaces);
+  return pathXml(node, registry, namespaces);
+}
+function groupXml(node, registry, namespaces) {
+  const attrs = [];
+  if (node.transform) {
+    const m = formatMatrix(node.transform);
+    if (m) attrs.push(`transform="${m}"`);
+  }
+  if (node.opacity != null && node.opacity !== 1) {
+    attrs.push(`opacity="${trimNumber(node.opacity)}"`);
+  }
+  const metaAttrs = metaAttrsXml(node.meta, namespaces);
+  const head = attrs.length > 0 ? `<g ${attrs.join(" ")}${metaAttrs}>` : `<g${metaAttrs}>`;
+  const body = node.children.map((c) => nodeXml(c, registry, namespaces)).join("");
+  return `${head}${body}${metaElementsXml(node.meta, namespaces)}</g>`;
+}
+function pathXml(node, registry, namespaces) {
+  const attrs = [`d="${serializePathD(node.path)}"`];
+  const fillAttrs = paintAttrs(node.fill, "fill", registry);
+  for (const a of fillAttrs) attrs.push(a);
+  if (node.path.kind === "polygon" && node.path.fillRule === "evenodd") {
+    attrs.push(`fill-rule="evenodd"`);
+  }
+  if (node.stroke) {
+    const strokeAttrs = strokeAttrsFor(node.stroke, registry);
+    for (const a of strokeAttrs) attrs.push(a);
+  } else {
+    attrs.push('stroke="none"');
+  }
+  if (node.opacity != null && node.opacity !== 1) {
+    attrs.push(`opacity="${trimNumber(node.opacity)}"`);
+  }
+  if (node.rotation != null && node.rotation !== 0) {
+    const b = pathBounds(node.path);
+    const cx = b.minX + (b.maxX - b.minX) / 2;
+    const cy = b.minY + (b.maxY - b.minY) / 2;
+    const deg = node.rotation * 180 / Math.PI;
+    attrs.push(`transform="rotate(${trimNumber(deg)} ${trimNumber(cx)} ${trimNumber(cy)})"`);
+  }
+  const metaAttrs = metaAttrsXml(node.meta, namespaces);
+  const metaEls = metaElementsXml(node.meta, namespaces);
+  if (metaEls) {
+    return `<path ${attrs.join(" ")}${metaAttrs}>${metaEls}</path>`;
+  }
+  return `<path ${attrs.join(" ")}${metaAttrs}/>`;
+}
+function paintAttrs(paint, name, registry) {
+  if (paint.kind === "none") return [`${name}="none"`];
+  if (paint.kind === "solid") {
+    const out = [`${name}="${paint.color}"`];
+    if (paint.opacity != null && paint.opacity !== 1) {
+      out.push(`${name}-opacity="${trimNumber(paint.opacity)}"`);
+    }
+    return out;
+  }
+  const id = registry.register(paint.paint);
+  return [`${name}="url(#${id})"`];
+}
+function strokeAttrsFor(stroke, registry) {
+  const attrs = paintAttrs(stroke.paint, "stroke", registry);
+  attrs.push(`stroke-width="${trimNumber(stroke.width)}"`);
+  if (stroke.opacity != null && stroke.opacity !== 1) {
+    attrs.push(`stroke-opacity="${trimNumber(stroke.opacity)}"`);
+  }
+  if (stroke.cap) {
+    attrs.push(`stroke-linecap="${stroke.cap}"`);
+  }
+  if (stroke.join) {
+    attrs.push(`stroke-linejoin="${stroke.join}"`);
+  }
+  if (stroke.dash && stroke.dash.length > 0) {
+    attrs.push(`stroke-dasharray="${stroke.dash.map(trimNumber).join(" ")}"`);
+  }
+  if (stroke.miterLimit != null) {
+    attrs.push(`stroke-miterlimit="${trimNumber(stroke.miterLimit)}"`);
+  }
+  return attrs;
+}
+function computeBounds(nodes) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  const visit = (n) => {
+    if (n.kind === "group") {
+      n.children.forEach(visit);
+      return;
+    }
+    const b = n.kind === "text" ? { minX: n.x, minY: n.y, maxX: n.x + n.width, maxY: n.y + n.height } : pathBounds(n.path);
+    if (b.minX < minX) minX = b.minX;
+    if (b.minY < minY) minY = b.minY;
+    if (b.maxX > maxX) maxX = b.maxX;
+    if (b.maxY > maxY) maxY = b.maxY;
+  };
+  nodes.forEach(visit);
+  if (!Number.isFinite(minX)) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function textXml(node, registry, namespaces) {
+  const attrs = [
+    `x="${trimNumber(node.x)}"`,
+    `y="${trimNumber(node.y)}"`,
+    `dominant-baseline="text-before-edge"`,
+    `data-weasel-width="${trimNumber(node.width)}"`,
+    `data-weasel-height="${trimNumber(node.height)}"`
+  ];
+  const style = node.style;
+  if (style?.fontSize != null) attrs.push(`font-size="${trimNumber(style.fontSize)}"`);
+  if (style?.fontFamily) attrs.push(`font-family="${escapeAttr(style.fontFamily)}"`);
+  if (style?.fontWeight != null) attrs.push(`font-weight="${String(style.fontWeight)}"`);
+  if (style?.fontStyle && style.fontStyle !== "normal") attrs.push(`font-style="${style.fontStyle}"`);
+  if (style?.align && style.align !== "left") {
+    const anchor = style.align === "center" ? "middle" : "end";
+    attrs.push(`text-anchor="${anchor}"`);
+  }
+  if (style?.fill) {
+    if ("color" in style.fill) {
+      attrs.push(`fill="${style.fill.color}"`);
+      if (style.fill.opacity != null && style.fill.opacity !== 1) {
+        attrs.push(`fill-opacity="${trimNumber(style.fill.opacity)}"`);
+      }
+    } else {
+      const id = registry.register(style.fill);
+      attrs.push(`fill="url(#${id})"`);
+    }
+  }
+  if (node.opacity != null && node.opacity !== 1) {
+    attrs.push(`opacity="${trimNumber(node.opacity)}"`);
+  }
+  if (node.rotation != null && node.rotation !== 0) {
+    const cx = node.x + node.width / 2;
+    const cy = node.y + node.height / 2;
+    const deg = node.rotation * 180 / Math.PI;
+    attrs.push(`transform="rotate(${trimNumber(deg)} ${trimNumber(cx)} ${trimNumber(cy)})"`);
+  }
+  const body = node.runs && node.runs.length > 0 ? node.runs.map((r) => runXml(r, registry)).join("") : escapeText(node.text);
+  const metaAttrs = metaAttrsXml(node.meta, namespaces);
+  const metaEls = metaElementsXml(node.meta, namespaces);
+  return `<text ${attrs.join(" ")}${metaAttrs}>${body}${metaEls}</text>`;
+}
+function runXml(run, registry) {
+  const attrs = [];
+  if (run.bold) attrs.push(`font-weight="700"`);
+  if (run.italic) attrs.push(`font-style="italic"`);
+  if (run.fontFamily) attrs.push(`font-family="${escapeAttr(run.fontFamily)}"`);
+  if (run.fontSize != null) attrs.push(`font-size="${trimNumber(run.fontSize)}"`);
+  if (run.fill) {
+    if ("color" in run.fill) {
+      attrs.push(`fill="${run.fill.color}"`);
+    } else {
+      const id = registry.register(run.fill);
+      attrs.push(`fill="url(#${id})"`);
+    }
+  }
+  const head = attrs.length > 0 ? `<tspan ${attrs.join(" ")}>` : "<tspan>";
+  return `${head}${escapeText(run.text)}</tspan>`;
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function pathBounds(path) {
+  if (path.kind === "rect") {
+    return {
+      minX: path.x,
+      minY: path.y,
+      maxX: path.x + path.width,
+      maxY: path.y + path.height
+    };
+  }
+  const b = boundsOfPath(path);
+  return { minX: b.x, minY: b.y, maxX: b.x + b.width, maxY: b.y + b.height };
+}
+var CASCADE_OFFSET_PX = 24;
+var VIEWPORT_FIT = 0.9;
+var GRADIENT_FALLBACK = "#888888";
+function readFileText(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result ?? ""));
+    reader.onerror = () => reject(reader.error);
+    reader.readAsText(file);
+  });
+}
+var svgIdCounter = 0;
+function freshSvgNodeId() {
+  return `n${(svgIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function colorFromPaint(paint, context) {
+  if (!paint) return void 0;
+  if (paint.kind === "none") return "none";
+  if (paint.kind === "solid") return paint.color;
+  dwarn("ingest", `svg unpack: gradient ${context} flattened to ${GRADIENT_FALLBACK}`);
+  return GRADIENT_FALLBACK;
+}
+function svgNodesToKitDrafts(nodes, nextId) {
+  const drafts = [];
+  const visit = (n, parentId) => {
+    if (n.kind === "group") {
+      const draft = {
+        kind: "container",
+        id: nextId(),
+        parentId,
+        pose: { x: 0, y: 0, width: 0, height: 0 }
+      };
+      drafts.push(draft);
+      let acc = null;
+      for (const c of n.children) {
+        const b2 = visit(c, draft.id);
+        if (b2) acc = acc ? unionRect(acc, b2) : b2;
+      }
+      if (!acc) {
+        drafts.splice(drafts.indexOf(draft), 1);
+        return null;
+      }
+      draft.pose = acc;
+      return acc;
+    }
+    if (n.kind === "text") {
+      const pose2 = { x: n.x, y: n.y, width: n.width, height: n.height };
+      if (n.rotation) pose2.rotation = n.rotation;
+      drafts.push({
+        kind: "leaf",
+        id: nextId(),
+        parentId,
+        pose: pose2,
+        data: { text: n.text, ...n.style ? { style: n.style } : {} }
+      });
+      return pose2;
+    }
+    const b = n.path.kind === "rect" ? { x: n.path.x, y: n.path.y, width: n.path.width, height: n.path.height } : boundsOfPath(n.path);
+    const pose = { x: b.x, y: b.y, width: b.width, height: b.height };
+    if (n.rotation) pose.rotation = n.rotation;
+    const fill = colorFromPaint(n.fill, "fill");
+    const stroke = n.stroke ? colorFromPaint(n.stroke.paint, "stroke") : void 0;
+    drafts.push({
+      kind: "leaf",
+      id: nextId(),
+      parentId,
+      pose,
+      data: {
+        path: n.path,
+        ...fill !== void 0 ? { fill } : {},
+        ...stroke !== void 0 && stroke !== "none" ? { stroke, strokeWidth: n.stroke.width } : {}
+      }
+    });
+    return pose;
+  };
+  for (const n of nodes) visit(n, null);
+  return drafts;
+}
+function unionRect(a, b) {
+  const minX = Math.min(a.x, b.x);
+  const minY = Math.min(a.y, b.y);
+  const maxX = Math.max(a.x + a.width, b.x + b.width);
+  const maxY = Math.max(a.y + a.height, b.y + b.height);
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+async function unpackSvgFiles(files, ctx) {
+  const layer = ctx.scene.layers[0]?.id ?? "default";
+  let index = 0;
+  for (const file of files) {
+    try {
+      const text = await readFileText(file);
+      const parsed = parseSvg(text);
+      for (const w of parsed.warnings) dwarn("ingest", `svg "${file.name}":`, w);
+      let drafts = svgNodesToKitDrafts(parsed.nodes, freshSvgNodeId);
+      if (drafts.length === 0) {
+        console.warn(`weasel ingest: svg "${file.name}" parsed to no drawable nodes`);
+        continue;
+      }
+      const roots = drafts.filter((d) => d.parentId === null);
+      if (roots.length > 1) {
+        const wrapperId = freshSvgNodeId();
+        const union2 = roots.map((d) => d.pose).reduce(unionRect);
+        drafts = [
+          { kind: "container", id: wrapperId, parentId: null, pose: union2 },
+          ...drafts.map((d) => d.parentId === null ? { ...d, parentId: wrapperId } : d)
+        ];
+      }
+      const union = drafts.filter((d) => d.parentId === null).map((d) => d.pose).reduce(unionRect);
+      const view = ctx.viewportWorldRect();
+      const scale = Math.min(
+        1,
+        union.width > 0 ? view.width * VIEWPORT_FIT / union.width : 1,
+        union.height > 0 ? view.height * VIEWPORT_FIT / union.height : 1
+      );
+      const target = ctx.point ?? {
+        x: view.x + view.width / 2,
+        y: view.y + view.height / 2
+      };
+      const offset = index * CASCADE_OFFSET_PX;
+      const cx = union.x + union.width / 2;
+      const cy = union.y + union.height / 2;
+      const place = (p) => ({
+        ...p,
+        x: target.x + (p.x - cx) * scale + offset,
+        y: target.y + (p.y - cy) * scale + offset,
+        width: p.width * scale,
+        height: p.height * scale
+      });
+      const ops = drafts.map(
+        (d) => createInsertOp({
+          node: {
+            id: d.id,
+            kind: d.kind,
+            layer,
+            pose: place(d.pose),
+            data: d.kind === "leaf" ? d.data : {},
+            parent: d.parentId
+          },
+          label: "Insert SVG"
+        })
+      );
+      ctx.applyOps(ops, "Insert SVG");
+      index++;
+    } catch (err) {
+      console.warn(`weasel ingest: svg "${file.name}" failed to parse`, err);
+    }
+  }
+}
+
+export { IDENTITY_MATRIX, parseSvg, serializeSvg, svgNodesToKitDrafts, unpackSvgFiles };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map