@weasel-js/labkit 1.6.0 → 1.6.1

package/dist/chunk-QGMOA2YE.js

@@ -0,0 +1,731 @@
+import { resolveScreenLength, SCRIPT_METRICS, boundsOfPath, getMarker, PATH_M, PATH_L, PATH_C, PATH_Q, PATH_Z, resolveAlign, getPaintKind } from '@weasel-js/core';
+import { tileGeometry } from '@weasel-js/core/patterns-builtin';
+
+// ../svg/dist/index.js
+
+// ../geom/dist/index.js
+function identity() {
+  return [1, 0, 0, 1, 0, 0];
+}
+function multiply(m, n) {
+  return [
+    m[0] * n[0] + m[2] * n[1],
+    m[1] * n[0] + m[3] * n[1],
+    m[0] * n[2] + m[2] * n[3],
+    m[1] * n[2] + m[3] * n[3],
+    m[0] * n[4] + m[2] * n[5] + m[4],
+    m[1] * n[4] + m[3] * n[5] + m[5]
+  ];
+}
+var IDENTITY_MATRIX = identity();
+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;
+}
+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);
+}
+function anchorOffset(style, width) {
+  const edge = resolveAlign(style?.align ?? "left", style?.direction ?? "ltr");
+  return edge === "center" ? width / 2 : edge === "right" ? width : 0;
+}
+function patternSpecOf(paint) {
+  return "tile" in paint.pattern ? paint.pattern : null;
+}
+function patternXml(id, paint, onWarn) {
+  const spec = patternSpecOf(paint);
+  if (!spec) {
+    onWarn?.("pattern fill carries a TextureHandle, which has no vector form \u2014 omitted from <defs>");
+    return "";
+  }
+  const geometry = tileGeometry(spec);
+  const body = geometry.shapes.map(shapeXml).join("");
+  const origin = paint.origin ?? { x: 0, y: 0 };
+  const attrs = [
+    `id="${id}"`,
+    'patternUnits="userSpaceOnUse"',
+    `width="${trimNumber(geometry.size)}"`,
+    `height="${trimNumber(geometry.size)}"`
+  ];
+  if (origin.x !== 0 || origin.y !== 0) {
+    attrs.push(`x="${trimNumber(origin.x)}"`, `y="${trimNumber(origin.y)}"`);
+  }
+  attrs.push(`data-weasel-tile="${escapeAttr(JSON.stringify(spec))}"`);
+  return `<pattern ${attrs.join(" ")}>${body}</pattern>`;
+}
+function tilePreviewSvg(spec, background) {
+  const geometry = tileGeometry(spec);
+  const s = trimNumber(geometry.size);
+  const bg = background ? `<rect width="${s}" height="${s}" fill="${background}"/>` : "";
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${s}" height="${s}" viewBox="0 0 ${s} ${s}">${bg}${geometry.shapes.map(shapeXml).join("")}</svg>`;
+}
+function tilePreviewCssUrl(spec, background) {
+  return `url("data:image/svg+xml,${encodeURIComponent(tilePreviewSvg(spec, background))}")`;
+}
+function shapeXml(shape) {
+  switch (shape.kind) {
+    case "line":
+      return `<line x1="${trimNumber(shape.x1)}" y1="${trimNumber(shape.y1)}" x2="${trimNumber(shape.x2)}" y2="${trimNumber(shape.y2)}" stroke="${shape.color}" stroke-width="${trimNumber(shape.width)}"/>`;
+    case "circle":
+      return `<circle cx="${trimNumber(shape.cx)}" cy="${trimNumber(shape.cy)}" r="${trimNumber(shape.r)}" fill="${shape.color}"/>`;
+    case "ellipse": {
+      const deg = shape.rotation * 180 / Math.PI;
+      const transform = deg === 0 ? "" : ` transform="rotate(${trimNumber(deg)} ${trimNumber(shape.cx)} ${trimNumber(shape.cy)})"`;
+      return `<ellipse cx="${trimNumber(shape.cx)}" cy="${trimNumber(shape.cy)}" rx="${trimNumber(shape.rx)}" ry="${trimNumber(shape.ry)}" fill="${shape.color}"${transform}/>`;
+    }
+    case "rect":
+      return `<rect x="${trimNumber(shape.x)}" y="${trimNumber(shape.y)}" width="${trimNumber(shape.width)}" height="${trimNumber(shape.height)}" fill="${shape.color}"/>`;
+    default:
+      return "";
+  }
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+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("");
+}
+var WEASEL_NS = "urn:weasel-js:svg";
+var WEASEL_NS_PREFIX = "wzl";
+function hasNativeSvgForm(paint) {
+  const kind = paint.fill ?? "solid";
+  return kind === "solid" || kind === "linear-gradient" || kind === "radial-gradient" || kind === "pattern";
+}
+var INTERPOLATE_SPACES = /* @__PURE__ */ new Set(["rgb", "oklab", "oklch"]);
+function interpolateAttr(space) {
+  if (!space || space === "rgb") return "";
+  return ` ${WEASEL_NS_PREFIX}:interpolate="${space}"`;
+}
+function usesInterpolateAttr(paint) {
+  const space = paint.interpolate;
+  return space != null && space !== "rgb" && INTERPOLATE_SPACES.has(space);
+}
+var PaintServerRegistry = class {
+  byPaint = /* @__PURE__ */ new Map();
+  order = [];
+  counter = 0;
+  // Marker keys referenced by any stroke, in first-use order. The `<defs>`
+  // id is the marker key itself, not a minted counter id: `parseSvg` reads a
+  // `marker-end="url(#id)"` fragment back as the marker key directly when the
+  // registry knows it, so a synthetic id would come back as a stranger.
+  markerKeys = [];
+  markerKeySet = /* @__PURE__ */ new Set();
+  // Clip paths, in first-use order. Identity, not value: two groups clipped by
+  // equal outlines get a def each, which costs bytes and misleads nobody.
+  clips = [];
+  clipIds = /* @__PURE__ */ new Map();
+  register(paint) {
+    const existing = this.byPaint.get(paint);
+    if (existing) return existing;
+    const id = paint.fill === "pattern" ? `pat${this.counter++}` : `grad${this.counter++}`;
+    this.byPaint.set(paint, id);
+    this.order.push(paint);
+    return id;
+  }
+  /**
+   * The `fill` / `stroke` attribute value referencing this paint server: a
+   * `url(#id)` reference, plus the fallback paint SVG's own grammar allows
+   * after one for any kind SVG cannot express. A renderer that cannot resolve
+   * the reference takes the fallback instead of dropping the fill, which is
+   * the difference between a flat shape and a vanished one.
+   */
+  ref(paint) {
+    const id = this.register(paint);
+    if (hasNativeSvgForm(paint)) return `url(#${id})`;
+    return `url(#${id}) ${paintFallback(paint)}`;
+  }
+  /** Whether any registered paint serializes outside SVG's own vocabulary, so
+   *  the root has to declare {@link WEASEL_NS}. */
+  usesPrivateNamespace() {
+    return this.order.some((paint) => !hasNativeSvgForm(paint) || usesInterpolateAttr(paint));
+  }
+  /** The `<defs>` id for a marker key — the key itself, minting nothing.
+   *  `undefined` when nothing is registered under `key`, so a caller emits no
+   *  attribute at all rather than a `url(#…)` pointing at a def that will
+   *  never be written. */
+  markerId(key) {
+    if (getMarker(key) === void 0) return void 0;
+    if (!this.markerKeySet.has(key)) {
+      this.markerKeySet.add(key);
+      this.markerKeys.push(key);
+    }
+    return key;
+  }
+  /** Mint (or recall) the `<defs>` id for a clip outline. */
+  clipId(path) {
+    const existing = this.clipIds.get(path);
+    if (existing) return existing;
+    const id = `clip${this.clips.length}`;
+    this.clipIds.set(path, id);
+    this.clips.push(path);
+    return id;
+  }
+  /** Emit `<defs>...</defs>` XML for every registered paint server, marker
+   *  and clip path. */
+  toDefsXml(onWarn) {
+    if (this.order.length === 0 && this.markerKeys.length === 0 && this.clips.length === 0) {
+      return "";
+    }
+    const parts = ["<defs>"];
+    for (const paint of this.order) {
+      parts.push(paintServerXml(this.byPaint.get(paint), paint, onWarn));
+    }
+    for (const key of this.markerKeys) {
+      const entry = getMarker(key);
+      if (!entry) continue;
+      parts.push(entry.toSvg ? entry.toSvg(key, entry) : defaultMarkerXml(key, entry, onWarn));
+    }
+    for (const path of this.clips) {
+      parts.push(
+        `<clipPath id="${this.clipIds.get(path)}"><path d="${serializePathD(path)}"/></clipPath>`
+      );
+    }
+    parts.push("</defs>");
+    return parts.join("");
+  }
+};
+function defaultMarkerXml(id, entry, onWarn) {
+  const path = entry.path({ size: 1, stroke: { paint: { fill: "solid", color: "#000" } } });
+  const d = serializePathD(path);
+  const fill = markerPaintAttrs("fill", entry.fill, id, onWarn);
+  const outline = entry.outline ? ` ${markerPaintAttrs("stroke", entry.outline.paint, id, onWarn)} stroke-width="${trimNumber(entry.outline.width)}" stroke-linecap="round" stroke-linejoin="round"` : "";
+  const orient = typeof entry.orient === "number" ? trimNumber(entry.orient * 180 / Math.PI) : "auto-start-reverse";
+  return `<marker id="${id}" markerUnits="strokeWidth" markerWidth="8" markerHeight="8" refX="0" refY="0" orient="${orient}" overflow="visible"><path d="${d}" ${fill}${outline}/></marker>`;
+}
+function markerPaintAttrs(attr, paint, id, onWarn) {
+  if (paint === "none") return `${attr}="none"`;
+  if (paint === void 0 || paint === "line") return `${attr}="context-stroke"`;
+  if ("color" in paint && (paint.fill === void 0 || paint.fill === "solid")) {
+    return paint.opacity != null && paint.opacity !== 1 ? `${attr}="${paint.color}" ${attr}-opacity="${trimNumber(paint.opacity)}"` : `${attr}="${paint.color}"`;
+  }
+  onWarn?.(`marker "${id}" ${attr} is a paint server, which a <marker> def cannot reference here; written as the line's paint`);
+  return `${attr}="context-stroke"`;
+}
+function paintServerXml(id, paint, onWarn) {
+  if (paint.fill === "pattern") return patternXml(id, paint, onWarn);
+  const builtin = gradientXml(id, paint);
+  if (builtin) return builtin;
+  const custom = getPaintKind(paint.fill)?.toSvg?.(id, paint);
+  if (custom) return custom;
+  onWarn?.(`${paint.fill} fill has no vector form \u2014 omitted from <defs>`);
+  return "";
+}
+function gradientUnitsAttr(units) {
+  return units === "bounds" ? "objectBoundingBox" : "userSpaceOnUse";
+}
+function gradientXml(id, paint) {
+  if (paint.fill === "linear-gradient") {
+    const stops = paint.stops.map(stopXml).join("");
+    return `<linearGradient id="${id}" gradientUnits="${gradientUnitsAttr(paint.units)}" x1="${trimNumber(paint.from.x)}" y1="${trimNumber(paint.from.y)}" x2="${trimNumber(paint.to.x)}" y2="${trimNumber(paint.to.y)}"${interpolateAttr(paint.interpolate)}>${stops}</linearGradient>`;
+  }
+  if (paint.fill === "conic-gradient") {
+    const stops = paint.stops.map(stopXml).join("");
+    const P = WEASEL_NS_PREFIX;
+    return `<${P}:conicGradient id="${id}" gradientUnits="${gradientUnitsAttr(paint.units)}" cx="${trimNumber(paint.center.x)}" cy="${trimNumber(paint.center.y)}" angle="${trimNumber(paint.angle)}"${interpolateAttr(paint.interpolate)}>${stops}</${P}:conicGradient>`;
+  }
+  if (paint.fill === "radial-gradient") {
+    const stops = paint.stops.map(stopXml).join("");
+    return `<radialGradient id="${id}" gradientUnits="${gradientUnitsAttr(paint.units)}" cx="${trimNumber(paint.center.x)}" cy="${trimNumber(paint.center.y)}" r="${trimNumber(paint.radius)}"${interpolateAttr(paint.interpolate)}>${stops}</radialGradient>`;
+  }
+  return "";
+}
+function paintFallback(paint) {
+  const color = getPaintKind(paint.fill)?.colorOf(paint);
+  if (!color) return "none";
+  const packed = /^#([0-9a-f]{6})[0-9a-f]{2}$/i.exec(color);
+  return packed ? `#${packed[1].toLowerCase()}` : color;
+}
+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}"/>`;
+}
+function serializeSvg(nodes, opts = {}) {
+  const registry = new PaintServerRegistry();
+  registerPaintServers(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"`];
+  if (registry.usesPrivateNamespace() && namespaces[WEASEL_NS_PREFIX] == null) {
+    rootAttrs.push(`xmlns:${WEASEL_NS_PREFIX}="${WEASEL_NS}"`);
+  }
+  for (const [prefix, uri] of Object.entries(namespaces)) {
+    rootAttrs.push(`xmlns:${prefix}="${escapeAttr2(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}="${escapeAttr2(value)}"`);
+      }
+    }
+  }
+  let docMetaXml = "";
+  if (opts.documentMeta) {
+    for (const prefix of Object.keys(namespaces)) {
+      const bucket = opts.documentMeta[prefix];
+      if (!bucket?.elements) continue;
+      for (const [localName2, list] of Object.entries(bucket.elements)) {
+        for (const el of list) docMetaXml += namespacedElementXml(prefix, localName2, el);
+      }
+    }
+  }
+  const defsXml = registry.toDefsXml(opts.onWarn);
+  const said = /* @__PURE__ */ new Set();
+  const warn = (m) => {
+    if (!opts.onWarn || said.has(m)) return;
+    said.add(m);
+    opts.onWarn(m);
+  };
+  const bodyXml = nodes.map((n) => nodeXml(n, registry, namespaces, warn)).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, localName2, el) {
+  const attrs = [];
+  for (const [name, value] of Object.entries(el.attrs)) {
+    attrs.push(`${name}="${escapeAttr2(value)}"`);
+  }
+  const head = attrs.length > 0 ? `<${prefix}:${localName2} ${attrs.join(" ")}>` : `<${prefix}:${localName2}>`;
+  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}:${localName2}>`;
+}
+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}="${escapeAttr2(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 [localName2, list] of Object.entries(bucket.elements)) {
+      for (const el of list) out += namespacedElementXml(prefix, localName2, el);
+    }
+  }
+  return out;
+}
+function registerPaintServers(nodes, registry) {
+  for (const n of nodes) {
+    if (n.kind === "group") {
+      if (n.clip) registry.clipId(n.clip);
+      registerPaintServers(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);
+      registerMarkers(n.stroke, registry);
+    } else if (n.kind === "text") {
+      registerTextPaint(n.fill, registry);
+      registerTextPaint(n.stroke?.paint, registry);
+      registerMarkers(n.stroke, registry);
+      for (const run of n.runs ?? []) {
+        registerTextPaint(run.fill, registry);
+        registerTextPaint(run.stroke?.paint, registry);
+      }
+    }
+  }
+}
+function registerTextPaint(paint, registry) {
+  if (paint && !("color" in paint)) registry.register(paint);
+}
+function markerKeyOfRef(ref) {
+  if (typeof ref === "string") return ref;
+  if (ref && typeof ref === "object" && "key" in ref) return String(ref.key);
+  return void 0;
+}
+function registerMarkers(stroke, registry) {
+  if (!stroke) return;
+  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {
+    const key = markerKeyOfRef(ref);
+    if (key) registry.markerId(key);
+  }
+}
+function nodeXml(node, registry, namespaces, warn) {
+  if (node.kind === "group") return groupXml(node, registry, namespaces, warn);
+  if (node.kind === "text") return textXml(node, registry, namespaces, warn);
+  if (node.kind === "image") return imageXml(node, namespaces);
+  return pathXml(node, registry, namespaces, warn);
+}
+function warnStrokeAlign(align, warn) {
+  if (align && align !== "center") {
+    warn(`a stroke aligned "${align}" of its edge is written centered: SVG has no stroke alignment`);
+  }
+}
+function imageXml(node, namespaces) {
+  const box = `x="${trimNumber(node.x)}" y="${trimNumber(node.y)}" width="${trimNumber(node.width)}" height="${trimNumber(node.height)}"`;
+  const outer = [];
+  if (node.opacity != null && node.opacity !== 1) {
+    outer.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;
+    outer.push(`transform="rotate(${trimNumber(deg)} ${trimNumber(cx)} ${trimNumber(cy)})"`);
+  }
+  const metaAttrs = metaAttrsXml(node.meta, namespaces);
+  const metaEls = metaElementsXml(node.meta, namespaces);
+  const href = `href="${escapeAttr2(node.href)}"`;
+  if (!node.source && !node.flipX && !node.flipY) {
+    const attrs = [href, box, 'preserveAspectRatio="none"', ...outer].join(" ");
+    if (metaEls) return `<image ${attrs}${metaAttrs}>${metaEls}</image>`;
+    return `<image ${attrs}${metaAttrs}/>`;
+  }
+  const src = node.source ?? { x: 0, y: 0, width: 1, height: 1 };
+  const viewBox = [src.x, src.y, src.width, src.height].map(trimNumber).join(" ");
+  const flip = node.flipX || node.flipY ? ` transform="matrix(${node.flipX ? -1 : 1} 0 0 ${node.flipY ? -1 : 1} ${trimNumber(node.flipX ? 2 * src.x + src.width : 0)} ${trimNumber(node.flipY ? 2 * src.y + src.height : 0)})"` : "";
+  const head = ['<g data-weasel-image="true"', ...outer].join(" ");
+  return `${head}${metaAttrs}><svg ${box} viewBox="${viewBox}" preserveAspectRatio="none"><image ${href} x="0" y="0" width="1" height="1" preserveAspectRatio="none"${flip}/></svg>${metaEls}</g>`;
+}
+function groupXml(node, registry, namespaces, warn) {
+  const attrs = [];
+  if (node.transform) {
+    const m = formatMatrix(node.transform);
+    if (m) attrs.push(`transform="${m}"`);
+  }
+  if (node.clip) {
+    attrs.push(`clip-path="url(#${registry.clipId(node.clip)})"`);
+  }
+  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, warn)).join("");
+  return `${head}${body}${metaElementsXml(node.meta, namespaces)}</g>`;
+}
+function pathXml(node, registry, namespaces, warn) {
+  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, warn);
+    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, includeOpacity = true) {
+  if (paint.kind === "none") return [`${name}="none"`];
+  if (paint.kind === "solid") {
+    const out = [`${name}="${paint.color}"`];
+    if (includeOpacity && paint.opacity != null && paint.opacity !== 1) {
+      out.push(`${name}-opacity="${trimNumber(paint.opacity)}"`);
+    }
+    return out;
+  }
+  return [`${name}="${registry.ref(paint.paint)}"`];
+}
+function strokeWidthAttrs(width) {
+  if (typeof width === "number") return [`stroke-width="${trimNumber(width)}"`];
+  return [`stroke-width="${trimNumber(width.px)}"`, 'vector-effect="non-scaling-stroke"'];
+}
+function coreStrokeAttrs(stroke, registry, warn) {
+  const paint = stroke?.paint;
+  if (!stroke || !paint) return [];
+  const width = stroke.width ?? 1;
+  if (!((typeof width === "object" ? width.px : width) > 0)) return [];
+  warnStrokeAlign(stroke.align, warn);
+  const attrs = [];
+  if ("color" in paint) {
+    attrs.push(`stroke="${paint.color}"`);
+    if (paint.opacity != null && paint.opacity !== 1) {
+      attrs.push(`stroke-opacity="${trimNumber(paint.opacity)}"`);
+    }
+  } else {
+    attrs.push(`stroke="${registry.ref(paint)}"`);
+  }
+  attrs.push(...strokeWidthAttrs(width));
+  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)}"`);
+  for (const [field, attr] of [
+    ["markerStart", "marker-start"],
+    ["markerMid", "marker-mid"],
+    ["markerEnd", "marker-end"]
+  ]) {
+    const ref = stroke[field];
+    if (ref === void 0) continue;
+    const key = typeof ref === "string" ? ref : ref.key;
+    const id = registry.markerId(key);
+    if (id === void 0) continue;
+    attrs.push(`${attr}="url(#${id})"`);
+  }
+  return attrs;
+}
+function strokeAttrsFor(stroke, registry, warn) {
+  warnStrokeAlign(stroke.align, warn);
+  const attrs = paintAttrs(stroke.paint, "stroke", registry, false);
+  attrs.push(...strokeWidthAttrs(stroke.width));
+  const opacity = stroke.opacity ?? (stroke.paint.kind === "solid" ? stroke.paint.opacity : void 0);
+  if (opacity != null && opacity !== 1) {
+    attrs.push(`stroke-opacity="${trimNumber(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)}"`);
+  }
+  for (const [field, attr] of [
+    ["markerStart", "marker-start"],
+    ["markerMid", "marker-mid"],
+    ["markerEnd", "marker-end"]
+  ]) {
+    const ref = stroke[field];
+    if (ref === void 0) continue;
+    const id = registry.markerId(ref);
+    if (id === void 0) continue;
+    attrs.push(`${attr}="url(#${id})"`);
+  }
+  return attrs;
+}
+function computeBounds(nodes) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  const visit = (n, ctm) => {
+    if (n.kind === "group") {
+      const childCtm = n.transform ? multiply(ctm, n.transform) : ctm;
+      n.children.forEach((c) => visit(c, childCtm));
+      return;
+    }
+    const b = n.kind === "text" || n.kind === "image" ? { minX: n.x, minY: n.y, maxX: n.x + n.width, maxY: n.y + n.height } : pathBounds(n.path);
+    const local = n.rotation ? rotateAboutCenter(ctm, b, n.rotation) : ctm;
+    for (const [x, y] of corners(b)) {
+      const px = local[0] * x + local[2] * y + local[4];
+      const py = local[1] * x + local[3] * y + local[5];
+      if (px < minX) minX = px;
+      if (py < minY) minY = py;
+      if (px > maxX) maxX = px;
+      if (py > maxY) maxY = py;
+    }
+  };
+  nodes.forEach((n) => visit(n, IDENTITY_MATRIX));
+  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 corners(b) {
+  return [[b.minX, b.minY], [b.maxX, b.minY], [b.maxX, b.maxY], [b.minX, b.maxY]];
+}
+function rotateAboutCenter(ctm, b, angle) {
+  const cx = (b.minX + b.maxX) / 2;
+  const cy = (b.minY + b.maxY) / 2;
+  const c = Math.cos(angle);
+  const s = Math.sin(angle);
+  return multiply(ctm, [c, s, -s, c, cx - cx * c + cy * s, cy - cx * s - cy * c]);
+}
+function textXml(node, registry, namespaces, warn) {
+  const attrs = [
+    `x="${trimNumber(node.x + anchorOffset(node.style, node.width))}"`,
+    `y="${trimNumber(node.y)}"`,
+    `dominant-baseline="text-before-edge"`,
+    // The runs model stores real line breaks; SVG's default whitespace
+    // handling would collapse them (and any indentation) away on re-import.
+    `xml:space="preserve"`,
+    `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(resolveScreenLength(style.fontSize, 1))}"`);
+  if (style?.fontFamily) attrs.push(`font-family="${escapeAttr2(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}"`);
+  const direction = style?.direction ?? "ltr";
+  if (direction === "rtl") attrs.push('direction="rtl"');
+  if (style?.align != null || direction === "rtl") {
+    const align = style?.align ?? "left";
+    const anchor = align === "center" ? "middle" : align === "start" ? "start" : align === "end" ? "end" : align === "left" === (direction === "ltr") ? "start" : "end";
+    if (anchor !== "start") attrs.push(`text-anchor="${anchor}"`);
+  }
+  if (style?.letterSpacing != null && style.letterSpacing !== 0) {
+    attrs.push(`letter-spacing="${trimNumber(resolveScreenLength(style.letterSpacing, 1))}"`);
+  }
+  const decoration = textDecorationValue(style?.underline, style?.strikethrough, style?.overline);
+  if (decoration) attrs.push(`text-decoration="${decoration}"`);
+  if (style?.textTransform && style.textTransform !== "none") {
+    attrs.push(`style="text-transform:${style.textTransform}"`);
+  }
+  if (style?.wrap) {
+    attrs.push('data-weasel-wrap="true"');
+    warn("text that wraps at its box width is written unwrapped: SVG text does not wrap, so other readers draw one line per hard break (weasel reads the wrap back)");
+  }
+  if (node.verticalAlign && node.verticalAlign !== "top") {
+    attrs.push(`data-weasel-vertical-align="${node.verticalAlign}"`);
+    warn(`text aligned to the ${node.verticalAlign} of its box is written top-aligned: SVG text has no box, so other readers draw it at the top (weasel reads the alignment back)`);
+  }
+  if (node.fill === null) {
+    attrs.push('fill="none"');
+  } else if (node.fill) {
+    if ("color" in node.fill) {
+      attrs.push(`fill="${node.fill.color}"`);
+      if (node.fill.opacity != null && node.fill.opacity !== 1) {
+        attrs.push(`fill-opacity="${trimNumber(node.fill.opacity)}"`);
+      }
+    } else {
+      attrs.push(`fill="${registry.ref(node.fill)}"`);
+    }
+  }
+  for (const a of coreStrokeAttrs(node.stroke, registry, warn)) attrs.push(a);
+  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, warn)).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, warn) {
+  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="${escapeAttr2(run.fontFamily)}"`);
+  const presetScale = run.script != null && run.baselineShift != null ? SCRIPT_METRICS[run.script].size : void 0;
+  const scale = run.fontScale ?? presetScale;
+  if (run.fontSize != null) attrs.push(`font-size="${trimNumber(resolveScreenLength(run.fontSize, 1))}"`);
+  else if (scale != null) attrs.push(`font-size="${trimNumber(scale * 100)}%"`);
+  if (run.baselineShift != null) {
+    attrs.push(`baseline-shift="${trimNumber(run.baselineShift * 100)}%"`);
+  } else if (run.script) {
+    attrs.push(`baseline-shift="${run.script}"`);
+  }
+  if (run.letterSpacing != null) {
+    attrs.push(`letter-spacing="${trimNumber(resolveScreenLength(run.letterSpacing, 1))}"`);
+  }
+  const runDecoration = textDecorationValue(run.underline, run.strikethrough, run.overline);
+  if (runDecoration) attrs.push(`text-decoration="${runDecoration}"`);
+  if (run.fill) {
+    if ("color" in run.fill) {
+      attrs.push(`fill="${run.fill.color}"`);
+    } else {
+      attrs.push(`fill="${registry.ref(run.fill)}"`);
+    }
+  }
+  for (const a of coreStrokeAttrs(run.stroke, registry, warn)) attrs.push(a);
+  if (run.textTransform) attrs.push(`style="text-transform:${run.textTransform}"`);
+  const head = attrs.length > 0 ? `<tspan ${attrs.join(" ")}>` : "<tspan>";
+  return `${head}${escapeText(run.text)}</tspan>`;
+}
+function textDecorationValue(underline, strikethrough, overline) {
+  const tokens = [];
+  if (underline) tokens.push("underline");
+  if (strikethrough) tokens.push("line-through");
+  if (overline) tokens.push("overline");
+  return tokens.length > 0 ? tokens.join(" ") : null;
+}
+function escapeAttr2(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 };
+}
+
+export { serializeSvg, tilePreviewCssUrl };
+//# sourceMappingURL=chunk-QGMOA2YE.js.map
+//# sourceMappingURL=chunk-QGMOA2YE.js.map