@weasel-js/svg 1.13.0 → 1.14.1

package/dist/index.js

@@ -1,6 +1,6 @@
-import { identity, multiply, pathToD, invert, splitByClosure, fillsOpenSubpaths, rotateAboutPoint, hasOpenSubpath, splitSubpaths } from '@weasel-js/geom';
+import { identity, multiply, pathToD, invert, splitByClosure, fillsOpenSubpaths, rotateAboutPoint, hasOpenSubpath, worldCoords, splitSubpaths, joinPaths } from '@weasel-js/geom';
 export { pathToD as serializePathD } from '@weasel-js/geom';
-import { isTileKind, boundsOfPath, transformPath, isSolidPaint, warmFonts, warmPaintKinds, isPaintKindKnown, solid, fillToBoundsFrame, getMarker, registerMarker, dwarn, unionAABB, createInsertOp, fillInPoseFrame, resolveStroke, pathThroughPoseFrame, resolveFill, pathInPoseFrame, poseLinearOf, poseFrameOf, INHERIT, clipOutline, resolveScreenLength, pathFromD, isPatternPaint, resolveTextStyle, strokeToPath, toRuns, resolveRunFace, DEFAULT_TEXT_FILL, parseColor, rgbaToHex, layoutRuns, resolveRuns, resolveAlign, PathBuilder, PATH_M, PATH_L, PATH_Z, scaleVertexWidth, getPaintKind, resolveMarkerSize, paragraphDirection, scriptMetricsFor, vertexHalfWidths, isTilePaint, tileSpecOf } from '@weasel-js/core';
+import { isTileKind, boundsOfPath, transformPath, isSolidPaint, warmFonts, warmPaintKinds, isPaintKindKnown, solid, fillToBoundsFrame, getMarker, registerMarker, dwarn, unionAABB, localizeWorldPoses, createInsertOp, fillInPoseFrame, resolveStroke, pathThroughPoseFrame, resolveFill, pathInPoseFrame, poseLinearOf, poseFrameOf, definesFrame, INHERIT, clipOutline, resolveScreenLength, pathFromD, isPatternPaint, resolveTextStyle, halfLeadingFor, numericWeight, strokeToPath, booleanGroupFields, toRuns, resolveRunFace, derivedDepOf, documentOf, booleanOpOf, DEFAULT_TEXT_FILL, parseColor, rgbaToHex, layoutRuns, resolveRuns, resolveAlign, PathBuilder, PATH_M, PATH_L, PATH_Z, scaleVertexWidth, getPaintKind, resolveMarkerSize, paragraphDirection, scriptMetricsFor, vertexHalfWidths, isImagePatternPaint, isTilePaint, tileSpecOf } from '@weasel-js/core';
 import { tileGeometry } from '@weasel-js/core/patterns-builtin';
 
 // src/types.ts
@@ -1296,9 +1296,153 @@ function collectElementsByTag(root, tags) {
   for (let i = 0; i < all.length; i++) consider(all[i]);
   return out;
 }
+var near = (v, target) => Math.abs(v - target) <= 1e-9;
+function placeBox(box, m, stretch) {
+  const [a, b, c, d] = m;
+  const scale = Math.sqrt(Math.abs(a * d - b * c));
+  const eps = 1e-4 * Math.hypot(a, b, c, d);
+  const uniform = Math.abs(a - d) <= eps;
+  if (Math.abs(b) <= eps && Math.abs(c) <= eps && (stretch || uniform && a > 0)) {
+    const p0 = applyMatrix(m, box.x, box.y);
+    const p1 = applyMatrix(m, box.x + box.width, box.y + box.height);
+    return {
+      x: Math.min(p0.x, p1.x),
+      y: Math.min(p0.y, p1.y),
+      width: Math.abs(p1.x - p0.x),
+      height: Math.abs(p1.y - p0.y),
+      rotation: 0,
+      scale,
+      flipX: a < 0,
+      flipY: d < 0
+    };
+  }
+  const p = Math.hypot(a, b);
+  const q = (a * c + b * d) / p;
+  const r = (a * d - b * c) / p;
+  const settle = (v) => Math.abs(v - 1) <= 1e-5 ? 1 : v;
+  const sx = settle(stretch ? p : scale);
+  const sy = settle(stretch ? Math.abs(r) : scale);
+  const flipY = stretch && r < 0;
+  const ry = flipY ? -sy : sy;
+  const linear = [p / sx, 0, q / ry, r / ry];
+  const center = applyMatrix(m, box.x + box.width / 2, box.y + box.height / 2);
+  const width2 = box.width * sx;
+  const height2 = box.height * sy;
+  const placed = {
+    x: center.x - width2 / 2,
+    y: center.y - height2 / 2,
+    width: width2,
+    height: height2,
+    rotation: Math.atan2(b, a),
+    scale: settle(scale),
+    flipX: false,
+    flipY
+  };
+  if (!near(linear[0], 1) || !near(linear[2], 0) || !near(linear[3], 1)) placed.transform = linear;
+  return placed;
+}
+function placeNode(node, tag, m, stretch, onWarn) {
+  if (isIdentity(m)) return 1;
+  const cx = node.x + node.width / 2;
+  const cy = node.y + node.height / 2;
+  if (!invert(m)) {
+    onWarn(`<${tag}> sits under a singular transform; kept its size`);
+    const center = applyMatrix(m, cx, cy);
+    node.x = center.x - node.width / 2;
+    node.y = center.y - node.height / 2;
+    return 1;
+  }
+  const turn = decomposeRotation(m, cx, cy);
+  if (turn != null) {
+    node.rotation = turn;
+    return 1;
+  }
+  const placed = placeBox(node, m, stretch);
+  node.x = placed.x;
+  node.y = placed.y;
+  node.width = placed.width;
+  node.height = placed.height;
+  if (Math.abs(placed.rotation) > 1e-9) node.rotation = placed.rotation;
+  if (placed.flipX) node.flipX = !node.flipX;
+  if (placed.flipY) node.flipY = !node.flipY;
+  if (placed.transform) node.transform = placed.transform;
+  return placed.scale;
+}
+function boxTransformAttr(node) {
+  if (poseLinearOf(node)) {
+    const frame = poseFrameOf(node);
+    const m = frame && formatMatrix(frame);
+    return m ? `transform="${m}"` : null;
+  }
+  if (!node.rotation) return null;
+  const cx = node.x + node.width / 2;
+  const cy = node.y + node.height / 2;
+  const deg = node.rotation * 180 / Math.PI;
+  return `transform="rotate(${trimNumber(deg)} ${trimNumber(cx)} ${trimNumber(cy)})"`;
+}
+
+// src/viewBox.ts
+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] };
+}
+
+// src/readImage.ts
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+function parseImageElement(el, ctm, onWarn) {
+  const href = imageHref(el);
+  if (!href) {
+    onWarn("<image> without href; dropped");
+    return null;
+  }
+  const node = imageNodeAt(el, el, href, ctm, onWarn);
+  if (el.hasAttribute("preserveAspectRatio") && el.getAttribute("preserveAspectRatio") !== "none") {
+    onWarn("<image> preserveAspectRatio is not modeled; the box is taken literally");
+  }
+  return node;
+}
+function imageHref(el) {
+  return el.getAttribute("href") ?? el.getAttributeNS(XLINK_NS, "href") ?? el.getAttribute("xlink:href");
+}
+function imageNodeAt(boxEl, ownerEl, href, ctm, onWarn) {
+  const rawX = readLength(boxEl, "x", "x", 0, onWarn);
+  const rawY = readLength(boxEl, "y", "y", 0, onWarn);
+  const rawW = readLength(boxEl, "width", "x", 0, onWarn);
+  const rawH = readLength(boxEl, "height", "y", 0, onWarn);
+  const node = { kind: "image", href, x: rawX, y: rawY, width: rawW, height: rawH };
+  const opacity = ownValue(ownerEl, "opacity");
+  if (opacity != null) node.opacity = opacity;
+  const localTransform = parseTransform(ownerEl.getAttribute("transform"), onWarn);
+  placeNode(node, "image", multiply(ctm, localTransform), true, onWarn);
+  return node;
+}
+function parseCroppedImage(g, ctm, onWarn) {
+  const viewport = [...g.children].find((c) => c.tagName.toLowerCase() === "svg");
+  const img = viewport && [...viewport.children].find((c) => c.tagName.toLowerCase() === "image");
+  const href = img && imageHref(img);
+  const source = viewport && parseViewBoxAttr(viewport.getAttribute("viewBox"));
+  if (!img || !href || !source) return null;
+  const node = imageNodeAt(viewport, g, href, ctm, onWarn);
+  if (source.x !== 0 || source.y !== 0 || source.width !== 1 || source.height !== 1) {
+    node.source = source;
+  }
+  const flip = parseTransform(img.getAttribute("transform"), onWarn);
+  if (flip[0] < 0) toggle(node, "flipX");
+  if (flip[3] < 0) toggle(node, "flipY");
+  return node;
+}
+function toggle(node, key) {
+  if (node[key]) delete node[key];
+  else node[key] = true;
+}
 
 // src/patterns.ts
 function patternXml(id, paint, onWarn) {
+  if (isImagePatternPaint(paint)) return imagePatternXml(id, paint, onWarn);
   if (!isTilePaint(paint)) {
     onWarn?.("texture fill carries a TextureHandle, which has no vector form \u2014 omitted from <defs>");
     return "";
@@ -1306,12 +1450,30 @@ function patternXml(id, paint, onWarn) {
   const spec = tileSpecOf(paint);
   const geometry = tileGeometry(spec);
   const body = geometry.shapes.map(shapeXml).join("");
+  const attrs = [
+    ...patternBoxAttrs(id, geometry.size, geometry.size, paint),
+    `data-weasel-tile="${escapeAttr(JSON.stringify(spec))}"`
+  ];
+  return `<pattern ${attrs.join(" ")}>${body}</pattern>`;
+}
+function imagePatternXml(id, paint, onWarn) {
+  const { width: width2, height: height2 } = paint;
+  if (!(width2 > 0) || !(height2 > 0)) {
+    onWarn?.("image fill names no tile width and height, which an SVG pattern needs \u2014 omitted from <defs>");
+    return "";
+  }
+  const w = trimNumber(width2);
+  const h = trimNumber(height2);
+  const body = `<image href="${escapeAttr(paint.src)}" width="${w}" height="${h}" preserveAspectRatio="none"/>`;
+  return `<pattern ${patternBoxAttrs(id, width2, height2, paint).join(" ")}>${body}</pattern>`;
+}
+function patternBoxAttrs(id, width2, height2, paint) {
   const origin = paint.origin ?? { x: 0, y: 0 };
   const attrs = [
     `id="${id}"`,
     'patternUnits="userSpaceOnUse"',
-    `width="${trimNumber(geometry.size)}"`,
-    `height="${trimNumber(geometry.size)}"`
+    `width="${trimNumber(width2)}"`,
+    `height="${trimNumber(height2)}"`
   ];
   const [a, b, c, d] = paint.transform ?? [1, 0, 0, 1];
   const placement = formatMatrix([a, b, c, d, origin.x, origin.y]);
@@ -1320,8 +1482,7 @@ function patternXml(id, paint, onWarn) {
   } else 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>`;
+  return attrs;
 }
 function tilePreviewSvg(spec, background) {
   const geometry = tileGeometry(spec);
@@ -1360,6 +1521,8 @@ function collectPatterns(svg, onWarn) {
 var PATTERN_TAGS = /* @__PURE__ */ new Set(["pattern"]);
 function readPattern(el, onWarn) {
   const raw = el.getAttribute("data-weasel-tile");
+  const image = raw ? null : readImagePattern(el);
+  if (image) return image;
   if (!raw) {
     onWarn?.(`<pattern id="${el.getAttribute("id")}"> has no data-weasel-tile \u2014 unsupported pattern, dropped`);
     return null;
@@ -1375,21 +1538,40 @@ function readPattern(el, onWarn) {
     onWarn?.(`<pattern id="${el.getAttribute("id")}"> data-weasel-tile is not a tile spec \u2014 dropped`);
     return null;
   }
+  return { ...spec, ...readPlacement(el, onWarn) };
+}
+function readImagePattern(el) {
+  const children = Array.from(el.children);
+  const img = children[0];
+  if (children.length !== 1 || img.localName !== "image") return null;
+  if (el.getAttribute("patternUnits") !== "userSpaceOnUse") return null;
+  if (el.hasAttribute("viewBox") || el.hasAttribute("patternContentUnits")) return null;
+  const src = imageHref(img);
+  const width2 = parseFloat(el.getAttribute("width") ?? "");
+  const height2 = parseFloat(el.getAttribute("height") ?? "");
+  if (!src || !(width2 > 0) || !(height2 > 0)) return null;
+  const at = (name, fallback) => parseFloat(img.getAttribute(name) ?? String(fallback));
+  if (at("x", 0) !== 0 || at("y", 0) !== 0 || at("width", width2) !== width2 || at("height", height2) !== height2) {
+    return null;
+  }
+  return { kind: "image", src, width: width2, height: height2, ...readPlacement(el) };
+}
+function readPlacement(el, onWarn) {
   const x = parseFloat(el.getAttribute("x") ?? "0");
   const y = parseFloat(el.getAttribute("y") ?? "0");
   const m = parseTransform(el.getAttribute("patternTransform"), onWarn);
   const origin = applyMatrix(m, x, y);
-  const paint = { ...spec };
-  if (origin.x !== 0 || origin.y !== 0) paint.origin = origin;
-  if (!isIdentity([m[0], m[1], m[2], m[3], 0, 0])) paint.transform = [m[0], m[1], m[2], m[3]];
-  return paint;
+  const placement = {};
+  if (origin.x !== 0 || origin.y !== 0) placement.origin = origin;
+  if (!isIdentity([m[0], m[1], m[2], m[3], 0, 0])) placement.transform = [m[0], m[1], m[2], m[3]];
+  return placement;
 }
 
 // src/gradients.ts
 var WEASEL_NS = "urn:weasel-js:svg";
 var WEASEL_NS_PREFIX = "wzl";
 function nativeSvgKind(kind) {
-  return kind === "solid" || kind === "linear-gradient" || kind === "radial-gradient" || kind === "texture" || isTileKind(kind);
+  return kind === "solid" || kind === "linear-gradient" || kind === "radial-gradient" || kind === "texture" || kind === "image" || isTileKind(kind);
 }
 function hasNativeSvgForm(paint) {
   return nativeSvgKind(paint.kind ?? "solid");
@@ -1423,7 +1605,7 @@ var GRADIENT_TAGS = /* @__PURE__ */ new Set([
   "meshgradient",
   `${WEASEL_NS_PREFIX}:meshgradient`
 ]);
-var XLINK_NS = "http://www.w3.org/1999/xlink";
+var XLINK_NS2 = "http://www.w3.org/1999/xlink";
 function collectGradients(svg, onWarn) {
   const out = /* @__PURE__ */ new Map();
   const elements = collectElementsByTag(svg, GRADIENT_TAGS);
@@ -1450,7 +1632,7 @@ function warnUnsupportedDefsChildren(svg, onWarn) {
   }
 }
 function hrefTarget(el, elements) {
-  const raw = el.getAttribute("href") ?? el.getAttributeNS(XLINK_NS, "href") ?? el.getAttribute("xlink:href");
+  const raw = el.getAttribute("href") ?? el.getAttributeNS(XLINK_NS2, "href") ?? el.getAttribute("xlink:href");
   if (!raw || !raw.startsWith("#")) return null;
   return elements.get(raw.slice(1)) ?? null;
 }
@@ -1774,7 +1956,7 @@ function rectElementToPath(x, y, width2, height2, rx, ry, m = IDENTITY_MATRIX) {
   const k = KAPPA * rad;
   const x2 = x + width2;
   const y2 = y + height2;
-  const b = new PathBuilder();
+  const b = new PathBuilder().autoOrigin();
   b.moveTo(x + rad, y);
   b.lineTo(x2 - rad, y);
   b.curveTo(x2 - rad + k, y, x2, y + rad - k, x2, y + rad);
@@ -1790,7 +1972,7 @@ function rectElementToPath(x, y, width2, height2, rx, ry, m = IDENTITY_MATRIX) {
 function ellipseToPath(cx, cy, rx, ry, m = IDENTITY_MATRIX) {
   const kx = KAPPA * rx;
   const ky = KAPPA * ry;
-  const b = new PathBuilder();
+  const b = new PathBuilder().autoOrigin();
   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);
@@ -1803,7 +1985,7 @@ 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();
+  const b = new PathBuilder().autoOrigin();
   b.moveTo(x1, y1);
   b.lineTo(x2, y2);
   return transformPath(b.build(), m);
@@ -1821,7 +2003,7 @@ 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();
+  const b = new PathBuilder().autoOrigin();
   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);
@@ -1830,7 +2012,7 @@ 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();
+  const b = new PathBuilder().autoOrigin();
   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();
@@ -1894,7 +2076,7 @@ function polygonToRectIfAxisAligned(p) {
   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;
+  const c = worldCoords(p);
   if (c.length !== 8) return null;
   const x0 = c[0], y0 = c[1];
   const x1 = c[2], y1 = c[3];
@@ -1908,16 +2090,6 @@ function polygonToRectIfAxisAligned(p) {
   if (width2 === 0 || height2 === 0) return null;
   return { kind: "rect", x, y, width: width2, height: height2 };
 }
-
-// src/viewBox.ts
-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 collectClipPaths(root, onWarn) {
   const out = /* @__PURE__ */ new Map();
   for (const [id, el] of collectElementsByTag(root, /* @__PURE__ */ new Set(["clippath"]))) {
@@ -2157,139 +2329,6 @@ function withVariableWidth(el, stroke) {
   }
   return out;
 }
-var near = (v, target) => Math.abs(v - target) <= 1e-9;
-function placeBox(box, m, stretch) {
-  const [a, b, c, d] = m;
-  const scale = Math.sqrt(Math.abs(a * d - b * c));
-  const eps = 1e-4 * Math.hypot(a, b, c, d);
-  const uniform = Math.abs(a - d) <= eps;
-  if (Math.abs(b) <= eps && Math.abs(c) <= eps && (stretch || uniform && a > 0)) {
-    const p0 = applyMatrix(m, box.x, box.y);
-    const p1 = applyMatrix(m, box.x + box.width, box.y + box.height);
-    return {
-      x: Math.min(p0.x, p1.x),
-      y: Math.min(p0.y, p1.y),
-      width: Math.abs(p1.x - p0.x),
-      height: Math.abs(p1.y - p0.y),
-      rotation: 0,
-      scale,
-      flipX: a < 0,
-      flipY: d < 0
-    };
-  }
-  const p = Math.hypot(a, b);
-  const q = (a * c + b * d) / p;
-  const r = (a * d - b * c) / p;
-  const settle = (v) => Math.abs(v - 1) <= 1e-5 ? 1 : v;
-  const sx = settle(stretch ? p : scale);
-  const sy = settle(stretch ? Math.abs(r) : scale);
-  const flipY = stretch && r < 0;
-  const ry = flipY ? -sy : sy;
-  const linear = [p / sx, 0, q / ry, r / ry];
-  const center = applyMatrix(m, box.x + box.width / 2, box.y + box.height / 2);
-  const width2 = box.width * sx;
-  const height2 = box.height * sy;
-  const placed = {
-    x: center.x - width2 / 2,
-    y: center.y - height2 / 2,
-    width: width2,
-    height: height2,
-    rotation: Math.atan2(b, a),
-    scale: settle(scale),
-    flipX: false,
-    flipY
-  };
-  if (!near(linear[0], 1) || !near(linear[2], 0) || !near(linear[3], 1)) placed.transform = linear;
-  return placed;
-}
-function placeNode(node, tag, m, stretch, onWarn) {
-  if (isIdentity(m)) return 1;
-  const cx = node.x + node.width / 2;
-  const cy = node.y + node.height / 2;
-  if (!invert(m)) {
-    onWarn(`<${tag}> sits under a singular transform; kept its size`);
-    const center = applyMatrix(m, cx, cy);
-    node.x = center.x - node.width / 2;
-    node.y = center.y - node.height / 2;
-    return 1;
-  }
-  const turn = decomposeRotation(m, cx, cy);
-  if (turn != null) {
-    node.rotation = turn;
-    return 1;
-  }
-  const placed = placeBox(node, m, stretch);
-  node.x = placed.x;
-  node.y = placed.y;
-  node.width = placed.width;
-  node.height = placed.height;
-  if (Math.abs(placed.rotation) > 1e-9) node.rotation = placed.rotation;
-  if (placed.flipX) node.flipX = !node.flipX;
-  if (placed.flipY) node.flipY = !node.flipY;
-  if (placed.transform) node.transform = placed.transform;
-  return placed.scale;
-}
-function boxTransformAttr(node) {
-  if (poseLinearOf(node)) {
-    const frame = poseFrameOf(node);
-    const m = frame && formatMatrix(frame);
-    return m ? `transform="${m}"` : null;
-  }
-  if (!node.rotation) return null;
-  const cx = node.x + node.width / 2;
-  const cy = node.y + node.height / 2;
-  const deg = node.rotation * 180 / Math.PI;
-  return `transform="rotate(${trimNumber(deg)} ${trimNumber(cx)} ${trimNumber(cy)})"`;
-}
-
-// src/readImage.ts
-var XLINK_NS2 = "http://www.w3.org/1999/xlink";
-function parseImageElement(el, ctm, onWarn) {
-  const href = imageHref(el);
-  if (!href) {
-    onWarn("<image> without href; dropped");
-    return null;
-  }
-  const node = imageNodeAt(el, el, href, ctm, onWarn);
-  if (el.hasAttribute("preserveAspectRatio") && el.getAttribute("preserveAspectRatio") !== "none") {
-    onWarn("<image> preserveAspectRatio is not modeled; the box is taken literally");
-  }
-  return node;
-}
-function imageHref(el) {
-  return el.getAttribute("href") ?? el.getAttributeNS(XLINK_NS2, "href") ?? el.getAttribute("xlink:href");
-}
-function imageNodeAt(boxEl, ownerEl, href, ctm, onWarn) {
-  const rawX = readLength(boxEl, "x", "x", 0, onWarn);
-  const rawY = readLength(boxEl, "y", "y", 0, onWarn);
-  const rawW = readLength(boxEl, "width", "x", 0, onWarn);
-  const rawH = readLength(boxEl, "height", "y", 0, onWarn);
-  const node = { kind: "image", href, x: rawX, y: rawY, width: rawW, height: rawH };
-  const opacity = ownValue(ownerEl, "opacity");
-  if (opacity != null) node.opacity = opacity;
-  const localTransform = parseTransform(ownerEl.getAttribute("transform"), onWarn);
-  placeNode(node, "image", multiply(ctm, localTransform), true, onWarn);
-  return node;
-}
-function parseCroppedImage(g, ctm, onWarn) {
-  const viewport = [...g.children].find((c) => c.tagName.toLowerCase() === "svg");
-  const img = viewport && [...viewport.children].find((c) => c.tagName.toLowerCase() === "image");
-  const href = img && imageHref(img);
-  const source = viewport && parseViewBoxAttr(viewport.getAttribute("viewBox"));
-  if (!img || !href || !source) return null;
-  const node = imageNodeAt(viewport, g, href, ctm, onWarn);
-  if (source.x !== 0 || source.y !== 0 || source.width !== 1 || source.height !== 1) {
-    node.source = source;
-  }
-  const flip = parseTransform(img.getAttribute("transform"), onWarn);
-  if (flip[0] < 0) toggle(node, "flipX");
-  if (flip[3] < 0) toggle(node, "flipY");
-  return node;
-}
-function toggle(node, key) {
-  if (node[key]) delete node[key];
-  else node[key] = true;
-}
 function svgDirection(style, text) {
   return paragraphDirection(text, style?.direction ?? "auto");
 }
@@ -2301,6 +2340,7 @@ function anchorOffset(style, width2, text) {
 // src/tspanLines.ts
 var LINES_ATTR = "data-weasel-lines";
 var LINE_HEIGHT_ATTR = "data-weasel-line-height";
+var writtenByWeasel = (text) => text.hasAttribute("data-weasel-width");
 var statesLines = (tspan) => tspan.hasAttribute(LINES_ATTR);
 function linesXml(pieces, x, pitch) {
   let out = "";
@@ -2329,25 +2369,55 @@ var DEFAULT_LINE_HEIGHT = 1.2;
 var LineTracker = class {
   constructor(text, onWarn) {
     this.onWarn = onWarn;
-    this.y = text.getAttribute("y");
-    this.at = readLength(text, "y", "y", 0, onWarn);
+    this.at = this.lineY = readLength(text, "y", "y", 0, onWarn);
   }
   onWarn;
-  y;
-  /** Where the current line sits, in user units. */
+  /** The current line's baseline, in user units. */
+  lineY;
+  /** Where the pen is, in user units. */
   at;
   pitches = [];
+  /** The first line's baseline, once a glyph has landed on it. */
+  first;
+  /** Whether the text opens with blank lines it states, below the text's `y`. */
+  keepsTop = false;
+  /** How far the pen sits above the current line's baseline, in user units. */
+  get rise() {
+    return this.lineY - this.at;
+  }
+  /** Move the pen to `y`, when given, and then down by `dy`. */
+  move(y, dy) {
+    this.at = (y ?? this.at) + dy;
+  }
+  /** Say that `glyph` sits at the pen. The first glyph that is not white
+   *  space settles the first line where it sits, wherever the text's `y` was:
+   *  a line is placed by its glyphs. */
+  land(glyph) {
+    if (this.first !== void 0 || /^\s$/u.test(glyph)) return;
+    if (!this.keepsTop) this.lineY = this.at;
+    this.first = this.lineY;
+  }
+  /** The baseline the box's first line sits on: the text's `y` where the text
+   *  opens with blank lines it states, otherwise where the first glyph landed.
+   *  `undefined` before any glyph has. */
+  get firstBaseline() {
+    return this.keepsTop ? void 0 : this.first;
+  }
   /** How many lines down `tspan` opens a new line, or 0 when it stays on the
-   *  current one. Call once per tspan, in order. `afterText` is whether any
-   *  text precedes it: the first line's own placement is not a pitch. */
-  startsLine(tspan, afterText) {
-    const y = tspan.getAttribute("y");
-    const movedY = y != null && y !== this.y;
-    if (y != null) this.y = y;
-    const from = this.at;
-    const dy = readLength(tspan, "dy", "y", 0, this.onWarn);
-    this.at = (y != null ? readLength(tspan, "y", "y", from, this.onWarn) : from) + dy;
-    if (!tspan.hasAttribute("x") || !(movedY || dy !== 0)) return 0;
+   *  current one. A tspan opens one when it has its own `x` and puts the pen
+   *  off the line's baseline; without an `x` it only moves its glyphs off the
+   *  line. `inherited` is the enclosing `<text>`'s `y` and `dy` for the
+   *  tspan's first glyph, used where the tspan has none of its own. Call once
+   *  per tspan, in order. `afterText` is whether any text precedes it: the
+   *  first line's own placement is not a pitch. */
+  startsLine(tspan, afterText, inherited2 = {}) {
+    const from = this.lineY;
+    const y = tspan.hasAttribute("y") ? readLength(tspan, "y", "y", this.at, this.onWarn) : inherited2.y;
+    const dy = tspan.hasAttribute("dy") ? readLength(tspan, "dy", "y", 0, this.onWarn) : inherited2.dy ?? 0;
+    this.move(y, dy);
+    if (!afterText && this.first === void 0 && statesLines(tspan)) this.keepsTop = true;
+    if (!tspan.hasAttribute("x") || Math.abs(this.at - from) < 1e-9) return 0;
+    this.lineY = this.at;
     const stated = Number(tspan.getAttribute(LINES_ATTR) ?? NaN);
     const lines = Number.isInteger(stated) && stated >= 0 ? stated : 1;
     if (afterText && lines > 0 && this.at > from) this.pitches.push((this.at - from) / lines);
@@ -2355,17 +2425,18 @@ var LineTracker = class {
   }
   /**
    * The line height the lines were pitched at, as a multiple of `fontSize`:
-   * `undefined` for a single line, or for lines at the default pitch. The
-   * model holds one line height, so uneven pitches give their mean, which
-   * keeps the block's height.
+   * `stated` for a single line or for lines pitched as it says, otherwise
+   * `undefined` at the default pitch. The model holds one line height, so
+   * uneven pitches give their mean, which keeps the block's height.
    */
-  lineHeight(fontSize) {
+  lineHeight(fontSize, stated) {
     const { pitches } = this;
-    if (pitches.length === 0 || !(fontSize > 0)) return void 0;
+    if (pitches.length === 0 || !(fontSize > 0)) return stated;
     const mean = pitches.reduce((sum, p) => sum + p, 0) / pitches.length;
     if (pitches.some((p) => Math.abs(p - mean) > 1e-3 * fontSize)) {
       this.onWarn("<text> lines are pitched unevenly; they take the mean pitch as one line height");
     }
+    if (stated !== void 0 && Math.abs(mean - stated * fontSize) <= 1e-3 * fontSize) return stated;
     const lineHeight = Math.round(mean / fontSize * 1e6) / 1e6;
     return Math.abs(lineHeight - DEFAULT_LINE_HEIGHT) < 1e-6 ? void 0 : lineHeight;
   }
@@ -2374,19 +2445,6 @@ var holdsOnlyText = (el) => !Array.from(el.childNodes).some(
   (child) => child.nodeType === 1
   /* ELEMENT_NODE */
 );
-function warnUnreadPositions(el, onWarn) {
-  const tag = el.tagName.toLowerCase();
-  for (const name of ["x", "y"]) {
-    const raw = el.getAttribute(name)?.trim() ?? "";
-    if (/[\s,]/.test(raw)) onWarn(`<${tag} ${name}="${raw}"> positions each glyph; only the first value is read`);
-  }
-  for (const name of tag === "tspan" || holdsOnlyText(el) ? ["rotate"] : ["dx", "rotate"]) {
-    const raw = el.getAttribute(name)?.trim() ?? "";
-    if (raw.split(/[\s,]+/).some((v) => parseFloat(v) !== 0 && v !== "")) {
-      onWarn(`<${tag} ${name}="${raw}"> is not read; the glyphs keep their own advance and angle`);
-    }
-  }
-}
 function sameStyle(a, b) {
   const style = (run) => JSON.stringify(
     Object.entries(run).filter(([k, v]) => k !== "text" && v !== void 0).sort(([j], [k]) => j < k ? -1 : 1)
@@ -2478,21 +2536,101 @@ function laidLinesXml(pieces, layout, anchor) {
       out += rangeXml(pieces, offsets, from, to, lead);
     });
   }
-  const trailing = breaksIn(text.slice(prevEnd));
-  const last = layout.laid.lines[layout.laid.lines.length - 1];
-  if (trailing > 0 && last) out += `<tspan ${[px(last.x0), py(last), ...count(trailing)].join(" ")}></tspan>`;
-  return out;
+  const trailing = breaksIn(text.slice(prevEnd));
+  const last = layout.laid.lines[layout.laid.lines.length - 1];
+  if (trailing > 0 && last) out += `<tspan ${[px(last.x0), py(last), ...count(trailing)].join(" ")}></tspan>`;
+  return out;
+}
+
+// src/textWhitespace.ts
+var XML_NS = "http://www.w3.org/XML/1998/namespace";
+function preservesSpace(el) {
+  for (let e = el; e; e = e.parentElement) {
+    const v = e.getAttributeNS(XML_NS, "space") ?? e.getAttribute("xml:space");
+    if (v === "preserve") return true;
+    if (v === "default") return false;
+  }
+  return false;
+}
+function collapseRunWhitespace(runs) {
+  let atStart = true;
+  let lastWasSpace = false;
+  for (const run of runs) {
+    let out = "";
+    for (const ch of run.text.replace(/\n/g, "").replace(/[\t\r]/g, " ")) {
+      if (ch === " ") {
+        if (atStart || lastWasSpace) continue;
+        out += " ";
+        lastWasSpace = true;
+        continue;
+      }
+      out += ch;
+      lastWasSpace = false;
+      atStart = false;
+    }
+    run.text = out;
+  }
+  for (let i = runs.length - 1; i >= 0; i--) {
+    if (runs[i].text === "") continue;
+    if (runs[i].text.endsWith(" ")) runs[i].text = runs[i].text.slice(0, -1);
+    break;
+  }
+  for (let i = runs.length - 1; i >= 0; i--) {
+    if (runs[i].text === "") runs.splice(i, 1);
+  }
 }
+
+// src/glyphShifts.ts
 var COLLAPSIBLE = /^\s|\s$|\s\s|[\n\t\r]/;
-function readDx(el, onWarn) {
-  const raw = el.getAttribute("dx")?.trim();
-  if (!raw) return null;
-  const values = raw.split(/[\s,]+/).map((v) => resolveLength(v, el, "dx", "x", 0, onWarn));
-  return values.some((v) => v !== 0) ? values : null;
+var collapses = (el, text = el.textContent ?? "") => COLLAPSIBLE.test(text) && !preservesSpace(el);
+function readList(el, name, onWarn) {
+  const raw = el.getAttribute(name)?.trim();
+  if (!raw) return [];
+  const axis = name.endsWith("x") ? "x" : "y";
+  return raw.split(/[\s,]+/).map((v) => resolveLength(v, el, name, axis, 0, onWarn));
+}
+function pensOf(line, rtl) {
+  const pens = line.cells.map((c) => c.x);
+  if (rtl) for (const g of line.glyphs) pens[g.cell] = g.x + g.advance;
+  return pens;
+}
+function cellsOf(run, style, rtl) {
+  const resolved = resolveTextStyle(style);
+  const { lines } = layoutRuns(resolveRuns([run], resolved), {
+    maxWidth: Infinity,
+    lineHeight: resolved.lineHeight,
+    align: rtl ? "right" : "left",
+    direction: rtl ? "rtl" : "ltr",
+    tabSize: resolved.tabSize
+  });
+  const line = lines[0];
+  if (lines.length !== 1 || !line || line.cells.length !== Array.from(run.text).length) return null;
+  return { cells: line.cells, line, width: line.x1 - line.x0 };
+}
+var allRead = (cells, rtl) => cells.every((c) => c.level % 2 === (rtl ? 1 : 0));
+function penPositions(run, style, rtl) {
+  const laid = cellsOf(run, style, rtl);
+  if (!laid || !(laid.width > 0) || !allRead(laid.cells, rtl)) return null;
+  const pens = pensOf(laid.line, rtl);
+  return pens.map((p) => p - pens[0]);
+}
+function foldPositions(lists, run, style, rtl, onWarn) {
+  const { dx, x } = lists;
+  const pens = x.length > 1 ? penPositions(run, style, rtl) : null;
+  if (x.length > 1 && !pens) {
+    onWarn(`<${lists.tag} x="${lists.raw.x?.trim()}"> positions each glyph; only the first value is read`);
+  }
+  const placed = pens ? Math.min(x.length, pens.length) : 0;
+  const out = Array.from({ length: Math.max(dx.length, placed) }, (_, i) => {
+    const own2 = dx[i] ?? 0;
+    if (i === 0 || i >= placed) return own2;
+    return x[i] + own2 - (x[i - 1] + (dx[i - 1] ?? 0)) - (pens[i] - pens[i - 1]);
+  });
+  return out.some((v) => v !== 0) ? out : null;
 }
 var spacingOf = (run, inherited2) => resolveScreenLength(run.letterSpacing ?? inherited2 ?? 0, 1);
-function spread(run, extra, inherited2) {
-  const base = spacingOf(run, inherited2);
+function spread(run, extra, style) {
+  const base = spacingOf(run, style.letterSpacing);
   const out = [];
   let last;
   Array.from(run.text).forEach((glyph, i) => {
@@ -2503,71 +2641,388 @@ function spread(run, extra, inherited2) {
   });
   return out;
 }
-function placeTspanRun(tspan, run, lines, inherited2, onWarn) {
+function placeRun(lists, run, lines, style, onWarn) {
   const line = lines[lines.length - 1];
-  const dx = readDx(tspan, onWarn);
-  if (!dx) {
+  const names = ["dx", "x"].filter((n) => n === "dx" ? lists.dx.some((v) => v !== 0) : lists.x.length > 1);
+  const named = `<${lists.tag} ${names.map((n) => `${n}="${lists.raw[n]}"`).join(" ")}>`;
+  if (names.length > 0 && collapses(lists.el, run.text)) {
+    onWarn(`${named} is not read: its text has white space SVG collapses, which moves the glyphs the list names`);
+    line.push(run);
+    return 0;
+  }
+  const rtl = style.direction === "rtl";
+  const shifts = names.length > 0 ? foldPositions(lists, run, style, rtl, onWarn) : null;
+  const laid = shifts && rtl ? cellsOf(run, style, rtl) : null;
+  if (shifts && rtl && !(laid && allRead(laid.cells, rtl))) {
+    onWarn(`${named} is not read: in right-to-left text it is read only where a bidi engine says every glyph reads right to left`);
     line.push(run);
     return 0;
   }
-  const raw = tspan.getAttribute("dx");
-  const tag = tspan.tagName.toLowerCase();
-  if (COLLAPSIBLE.test(run.text)) {
-    onWarn(`<${tag} dx="${raw}"> is not read: its text has white space SVG collapses, which moves the glyphs the list names`);
+  if (!shifts) {
     line.push(run);
     return 0;
   }
+  const dx = rtl ? shifts.map((v) => -v) : shifts;
   let lead = 0;
   let before = line.length - 1;
   while (before >= 0 && line[before].text === "") before--;
   if (dx[0] !== 0 && before >= 0) {
     const glyphs = Array.from(line[before].text);
-    line.splice(before, 1, ...spread(line[before], [...glyphs.slice(1).map(() => 0), dx[0]], inherited2));
+    line.splice(before, 1, ...spread(line[before], [...glyphs.slice(1).map(() => 0), dx[0]], style));
   } else if (dx[0] !== 0 && lines.length === 1) {
-    lead = dx[0];
+    lead = shifts[0];
   } else if (dx[0] !== 0) {
-    onWarn(`<${tag} dx="${raw}"> opens a line; the line starts at the box edge, and the rest of the list is read`);
+    onWarn(`${named} opens a line; the line starts at the box edge, and the rest of the list is read`);
   }
-  line.push(...spread(run, dx.slice(1), inherited2));
+  line.push(...spread(run, dx.slice(1), style));
   return lead;
 }
+function placeTspanRun(tspan, run, lines, style, onWarn, inherited2 = { dx: [], raw: null }) {
+  const own2 = inherited2.merged ? [] : readList(tspan, "dx", onWarn);
+  const borrows = own2.length < inherited2.dx.length;
+  const theirs = borrows && own2.length === 0;
+  return placeRun({
+    el: tspan,
+    tag: theirs ? "text" : tspan.tagName.toLowerCase(),
+    dx: borrows ? [...own2, ...inherited2.dx.slice(own2.length)] : own2,
+    x: inherited2.merged ? [] : readList(tspan, "x", onWarn),
+    raw: { dx: theirs ? inherited2.raw : tspan.getAttribute("dx"), x: tspan.getAttribute("x") }
+  }, run, lines, style, onWarn);
+}
+function mayOpenLine(tspan, ownX, onWarn) {
+  if (!tspan || ownX.length === 0) return false;
+  return tspan.hasAttribute("y") || (readList(tspan, "dy", onWarn)[0] ?? 0) !== 0;
+}
+function measureLine(runs, glyphs, style, rtl) {
+  const resolved = resolveTextStyle(style);
+  const { lines } = layoutRuns(resolveRuns(runs, resolved), {
+    maxWidth: Infinity,
+    lineHeight: resolved.lineHeight,
+    align: rtl ? "right" : "left",
+    direction: rtl ? "rtl" : "ltr",
+    tabSize: resolved.tabSize
+  });
+  const line = lines.length === 1 ? lines[0] : null;
+  if (!line || line.cells.length !== glyphs || !(line.x1 > line.x0)) return "no loaded face measures its glyphs";
+  if (!allRead(line.cells, rtl)) {
+    return "in right-to-left text it is read only where a bidi engine says every glyph reads right to left";
+  }
+  return line;
+}
+function foldTextPositions(x, dx, pieces, style, onWarn) {
+  const segments = [];
+  const xs = [];
+  const dxs = [];
+  for (let at2 = 0, k = 0; at2 < x.length && k < pieces.length; k++) {
+    const { tspan, run } = pieces[k];
+    const ownX = tspan ? readList(tspan, "x", onWarn) : [];
+    const ownDx = tspan ? readList(tspan, "dx", onWarn) : [];
+    if (segments.length === 0 || mayOpenLine(tspan, ownX, onWarn)) segments.push({ runs: [], start: xs.length });
+    const n = Array.from(run.text).length;
+    for (let i = 0; i < n; i++) {
+      xs.push(i < ownX.length ? ownX[i] : x[at2 + i]);
+      dxs.push(i < ownDx.length ? ownDx[i] : dx[at2 + i] ?? 0);
+    }
+    segments[segments.length - 1].runs.push(run);
+    at2 += n;
+  }
+  const rtl = style.direction === "rtl";
+  const glyphs = xs.length;
+  const pens = [];
+  for (const [s, { runs, start }] of segments.entries()) {
+    const line = measureLine(runs, (segments[s + 1]?.start ?? glyphs) - start, style, rtl);
+    if (typeof line === "string") return line;
+    pens.push(...pensOf(line, rtl));
+  }
+  const starts = new Set(segments.map((s) => s.start));
+  const at = [];
+  for (let i = 0; i < glyphs; i++) {
+    const own2 = xs[i];
+    at.push(own2 !== void 0 ? own2 + dxs[i] : at[i - 1] + pens[i] - pens[i - 1] + dxs[i]);
+  }
+  const out = Array.from({ length: Math.max(dx.length, glyphs) }, (_, i) => {
+    if (i >= glyphs) return dx[i] ?? 0;
+    if (i === 0) return at[0] - x[0];
+    if (starts.has(i)) return dxs[i];
+    return at[i] - at[i - 1] - (pens[i] - pens[i - 1]);
+  });
+  return { dx: out, reached: glyphs };
+}
+var TextShifts = class {
+  constructor(text, onWarn, pieces = [], style = {}) {
+    this.text = text;
+    this.onWarn = onWarn;
+    this.raw = text.getAttribute("dx");
+    const dx = readList(text, "dx", onWarn);
+    const x = readList(text, "x", onWarn);
+    const collapsible = collapses(text);
+    const unread = dx.some((v) => v !== 0) && collapsible;
+    if (unread) {
+      onWarn(`<text dx="${this.raw}"> is not read: its text has white space SVG collapses, which moves the glyphs the list names`);
+    }
+    this.dx = unread ? [] : dx;
+    if (x.length < 2) return;
+    const folded = collapsible ? "its text has white space SVG collapses, which moves the glyphs the list names" : foldTextPositions(x, this.dx, pieces, style, onWarn);
+    if (typeof folded === "string") {
+      onWarn(`<text x="${text.getAttribute("x")?.trim()}"> positions each glyph; only the first value is read: ${folded}`);
+    } else {
+      this.dx = folded.dx;
+      this.merged = folded.reached;
+    }
+  }
+  text;
+  onWarn;
+  dx;
+  raw;
+  at = 0;
+  /** How many glyphs the text's `x` list was merged over with their tspans' own lists. */
+  merged = 0;
+  /** The values over the next `run`'s glyphs, empty when they move none. */
+  take(run) {
+    const n = Array.from(run.text).length;
+    const out = this.dx.slice(this.at, this.at + n);
+    const merged = this.at < this.merged;
+    this.at += n;
+    return { dx: out.some((v) => v !== 0) ? out : [], raw: this.raw, ...merged ? { merged } : {} };
+  }
+  /** Add a bare text run of the `<text>` to `lines`, spaced by its stretch of the list. */
+  place(run, lines, style) {
+    const { dx } = this.take(run);
+    if (dx.length === 0) {
+      lines[lines.length - 1].push(run);
+      return 0;
+    }
+    return placeRun({ el: this.text, tag: "text", dx, x: [], raw: { dx: this.raw, x: null } }, run, lines, style, this.onWarn);
+  }
+};
 
-// src/textWhitespace.ts
-var XML_NS = "http://www.w3.org/XML/1998/namespace";
-function preservesSpace(el) {
+// src/glyphTurns.ts
+function turnsOf(el, onWarn) {
+  const raw = el.getAttribute("rotate")?.trim();
+  if (!raw) return [];
+  const list = raw.split(/[\s,]+/).map(Number);
+  if (list.some((v) => !Number.isFinite(v))) {
+    onWarn(`<${el.tagName.toLowerCase()} rotate="${raw}"> is not read: it is not a list of numbers`);
+    return [];
+  }
+  if (list.some((v) => v !== list[0]) && collapses(el)) {
+    onWarn(`<${el.tagName.toLowerCase()} rotate="${raw}"> is not read: its text has white space SVG collapses, which moves the glyphs the list names`);
+    return [];
+  }
+  return list;
+}
+var valueAt = (list, i) => list.length === 0 ? void 0 : list[Math.min(i, list.length - 1)];
+var TextTurns = class {
+  list;
+  at = 0;
+  constructor(text, onWarn) {
+    this.list = turnsOf(text, onWarn);
+  }
+  /** The turns of the next `n` glyphs, the `own` list of their `<tspan>`
+   *  winning where it has one. */
+  take(n, own2 = []) {
+    const out = Array.from({ length: n }, (_, i) => valueAt(own2, i) ?? valueAt(this.list, this.at + i) ?? 0);
+    this.at += n;
+    return out;
+  }
+};
+function turnRuns(line, turns) {
+  if (turns.every((t) => t === 0)) return;
+  let start = line.length;
+  let n = turns.length;
+  while (n > 0 && start > 0) n -= Array.from(line[--start].text).length;
+  const out = [];
+  let g = Math.min(n, 0);
+  for (const run of line.slice(start)) {
+    if (run.text === "") {
+      out.push(run);
+      continue;
+    }
+    const { rotate: own2, ...upright } = run;
+    let last;
+    for (const glyph of Array.from(run.text)) {
+      const turn = g < 0 ? own2 ?? 0 : turns[g] ?? 0;
+      g++;
+      if (turn === last) out[out.length - 1].text += glyph;
+      else out.push(turn === 0 ? { ...upright, text: glyph } : { ...upright, text: glyph, rotate: turn });
+      last = turn;
+    }
+  }
+  line.splice(start, line.length - start, ...out);
+}
+var NO_MOVES = { y: [], dy: [] };
+function movesOf(el, onWarn) {
+  const y = readList(el, "y", onWarn);
+  const dy = readList(el, "dy", onWarn);
+  const perGlyph = y.length > 1 || dy.slice(1).some((v) => v !== 0);
+  if (perGlyph && collapses(el)) {
+    const named = ["y", "dy"].filter((n) => el.hasAttribute(n)).map((n) => `${n}="${el.getAttribute(n)}"`);
+    onWarn(`<${el.tagName.toLowerCase()} ${named.join(" ")}> is read only to its first value: its text has white space SVG collapses, which moves the glyphs the list names`);
+    return { y: y.slice(0, 1), dy: dy.slice(0, 1) };
+  }
+  return { y, dy };
+}
+var TextMoves = class {
+  moves;
+  at = 0;
+  constructor(text, onWarn) {
+    const { y, dy } = movesOf(text, onWarn);
+    this.moves = { y: [void 0, ...y.slice(1)], dy: [writtenByWeasel(text) ? 0 : dy[0] ?? 0, ...dy.slice(1)] };
+  }
+  /** The values over the next `n` glyphs. */
+  take(n) {
+    const out = { y: this.moves.y.slice(this.at, this.at + n), dy: this.moves.dy.slice(this.at, this.at + n) };
+    this.at += n;
+    return out;
+  }
+};
+function risesOver(glyphs, own2, inherited2, tracker, placed) {
+  const out = [];
+  for (let i = 0; i < glyphs.length; i++) {
+    if (i > 0 || !placed) {
+      tracker.move(i < own2.y.length ? own2.y[i] : inherited2.y[i], (i < own2.dy.length ? own2.dy[i] : inherited2.dy[i]) ?? 0);
+    }
+    tracker.land(glyphs[i]);
+    out.push(tracker.rise);
+  }
+  return out;
+}
+function ownShift(run, style) {
+  if (run.baselineShift != null) return run.baselineShift;
+  if (!run.script) return 0;
+  const face = resolveRunFace(run, resolveTextStyle(style));
+  return scriptMetricsFor(face.fontFamily, face.fontWeight, face.fontStyle)[run.script].shift;
+}
+function raiseRuns(line, rises, fontSize, style) {
+  if (!(fontSize > 0) || rises.every((r) => Math.abs(r) < 1e-9)) return;
+  let start = line.length;
+  for (let n = rises.length; n > 0 && start > 0; ) n -= Array.from(line[--start].text).length;
+  const out = [];
+  let g = 0;
+  for (const run of line.slice(start)) {
+    if (run.text === "") {
+      out.push(run);
+      continue;
+    }
+    let last;
+    for (const glyph of Array.from(run.text)) {
+      const em = Math.round((rises[g++] ?? 0) / fontSize * 1e6) / 1e6;
+      if (em === last) out[out.length - 1].text += glyph;
+      else out.push(em === 0 ? { ...run, text: glyph } : { ...run, text: glyph, baselineShift: ownShift(run, style) + em });
+      last = em;
+    }
+  }
+  line.splice(start, line.length - start, ...out);
+}
+
+// src/textLang.ts
+var XML_NS2 = "http://www.w3.org/XML/1998/namespace";
+function ownLang(el) {
+  return el.getAttributeNS(XML_NS2, "lang") ?? el.getAttribute("xml:lang") ?? el.getAttribute("lang");
+}
+function inheritedLang(el) {
   for (let e = el; e; e = e.parentElement) {
-    const v = e.getAttributeNS(XML_NS, "space") ?? e.getAttribute("xml:space");
-    if (v === "preserve") return true;
-    if (v === "default") return false;
+    const v = ownLang(e);
+    if (v !== null) return v.trim() || void 0;
   }
-  return false;
+  return void 0;
 }
-function collapseRunWhitespace(runs) {
-  let atStart = true;
-  let lastWasSpace = false;
-  for (const run of runs) {
-    let out = "";
-    for (const ch of run.text.replace(/\n/g, "").replace(/[\t\r]/g, " ")) {
-      if (ch === " ") {
-        if (atStart || lastWasSpace) continue;
-        out += " ";
-        lastWasSpace = true;
+
+// src/readRuns.ts
+var glyphCount = (text) => Array.from(text).length;
+function readRuns(el, tracker, inheritedShift, textStyle, gradients, leafStyle, onWarn) {
+  const runLines = [[]];
+  const fontSize = resolveScreenLength(textStyle.fontSize ?? 16, 1);
+  const moves = new TextMoves(el, onWarn);
+  const turns = new TextTurns(el, onWarn);
+  const turn = (text, own2) => turnRuns(runLines[runLines.length - 1], turns.take(glyphCount(text), own2));
+  const raise = (text, own2, inherited2, placed) => raiseRuns(runLines[runLines.length - 1], risesOver(Array.from(text), own2, inherited2, tracker, placed), fontSize, textStyle);
+  let leading = 0;
+  let lead = 0;
+  if (holdsOnlyText(el) && (el.hasAttribute("dx") || el.hasAttribute("x"))) {
+    const t = el.textContent ?? "";
+    if (t) {
+      lead = placeTspanRun(el, { text: t, ...inheritedShift }, runLines, textStyle, onWarn);
+      raise(t, NO_MOVES, moves.take(glyphCount(t)), false);
+      turn(t);
+    }
+  } else {
+    const pieces = Array.from(el.childNodes).flatMap((child) => {
+      if (child.nodeType === 1 && child.tagName.toLowerCase() === "tspan") {
+        const sp = child;
+        return [{ tspan: sp, run: readTspanRun(sp, gradients, leafStyle, onWarn) }];
+      }
+      if (child.nodeType === 1) onWarn(`<text> child <${child.tagName}> not supported; flattening text content`);
+      else if (child.nodeType !== 3) return [];
+      const t = child.textContent ?? "";
+      return t ? [{ tspan: null, run: { text: t, ...inheritedShift } }] : [];
+    });
+    const shifts = new TextShifts(el, onWarn, pieces, textStyle);
+    for (const { tspan: sp, run } of pieces) {
+      if (!sp) {
+        lead += shifts.place(run, runLines, textStyle);
+        raise(run.text, NO_MOVES, moves.take(glyphCount(run.text)), false);
+        turn(run.text);
         continue;
       }
-      out += ch;
-      lastWasSpace = false;
-      atStart = false;
+      const inherited2 = moves.take(glyphCount(run.text));
+      const afterText = runLines.some((line) => line.some((r) => r.text.trim() !== ""));
+      const lines = tracker.startsLine(sp, afterText, { y: inherited2.y[0], dy: inherited2.dy[0] });
+      if (runLines.length === 1 && runLines[0].length === 0 && statesLines(sp)) leading = lines;
+      else for (let n = 0; n < lines; n++) runLines.push([]);
+      lead += placeTspanRun(sp, run, runLines, textStyle, onWarn, shifts.take(run));
+      raise(run.text, movesOf(sp, onWarn), inherited2, true);
+      turn(run.text, turnsOf(sp, onWarn));
     }
-    run.text = out;
-  }
-  for (let i = runs.length - 1; i >= 0; i--) {
-    if (runs[i].text === "") continue;
-    if (runs[i].text.endsWith(" ")) runs[i].text = runs[i].text.slice(0, -1);
-    break;
   }
-  for (let i = runs.length - 1; i >= 0; i--) {
-    if (runs[i].text === "") runs.splice(i, 1);
+  if (!preservesSpace(el)) for (const line of runLines) collapseRunWhitespace(line);
+  return { runs: joinLines(runLines, leading), lead };
+}
+function readTspanRun(el, gradients, style, onWarn) {
+  const text = el.textContent ?? "";
+  const run = { text };
+  const fw = ownValue(el, "font-weight", onWarn);
+  if (fw === "bold" || fw === "bolder" || fw === 700) run.bold = true;
+  else if (fw === "normal") run.fontWeight = 400;
+  else if (typeof fw === "number") run.fontWeight = fw;
+  if (ownValue(el, "font-style", onWarn) === "italic") run.italic = true;
+  const ff = ownValue(el, "font-family", onWarn);
+  if (ff) run.fontFamily = ff;
+  const size = ownValue(el, "font-size", onWarn);
+  if (size?.fontSize != null) run.fontSize = size.fontSize;
+  if (size?.fontScale != null) run.fontScale = size.fontScale;
+  const tspanStyle = deriveStyle(style, el);
+  const ls = ownValue(el, "letter-spacing", onWarn, fontSizeOf(tspanStyle));
+  if (ls != null) run.letterSpacing = ls;
+  const shift = ownValue(el, "baseline-shift", onWarn);
+  if (shift?.script != null) run.script = shift.script;
+  if (shift?.baselineShift != null) run.baselineShift = shift.baselineShift;
+  const decoration = ownValue(el, "text-decoration", onWarn);
+  if (decoration?.underline) run.underline = true;
+  if (decoration?.strikethrough) run.strikethrough = true;
+  if (decoration?.overline) run.overline = true;
+  const transform = ownValue(el, "text-transform", onWarn);
+  if (transform) run.textTransform = transform;
+  const variant = ownValue(el, "font-variant", onWarn);
+  if (variant) run.fontVariantCaps = variant;
+  const lang = ownLang(el)?.trim();
+  if (lang) run.lang = lang;
+  const fillAttr = resolveCurrentColor(ownProp(el, "fill"), tspanStyle);
+  if (fillAttr) {
+    const parsed = readProperty("fill", fillAttr);
+    if (parsed?.kind === "none") {
+      run.fill = null;
+    } else if (parsed?.kind === "solid") {
+      run.fill = { paint: { kind: "solid", color: parsed.color } };
+    } else if (parsed?.kind === "ref") {
+      const paint = gradients.get(parsed.id);
+      if (paint) run.fill = { paint };
+      else if (parsed.fallback) run.fill = { paint: { kind: "solid", color: parsed.fallback.color } };
+    }
   }
+  const stroke = coreStroke(readStroke(ownStrokeStyle(el, tspanStyle), gradients, onWarn, isNonScalingStroke(el)));
+  if (stroke) run.stroke = stroke;
+  return run;
 }
 
 // src/fillPaint.ts
@@ -2629,22 +3084,25 @@ function parseTextElement(el, ctm, style, gradients, onWarn) {
     return Number.isFinite(n) ? n : fallback;
   };
   const localTransform = parseTransform(el.getAttribute("transform"), onWarn);
-  warnUnreadPositions(el, onWarn);
   const ax = readLength(el, "x", "x", 0, onWarn);
   const ay = readLength(el, "y", "y", 0, onWarn);
   const leafStyle = deriveStyle(style, el);
   const textStyle = readTextStyle(leafStyle, onWarn);
+  const lang = inheritedLang(el);
+  if (lang) textStyle.lang = lang;
   const textPaint = readTextPaint(leafStyle, gradients, onWarn, isNonScalingStroke(el));
   const fontSize = resolveScreenLength(textStyle.fontSize ?? 16, 1);
   const dominantBaseline = el.getAttribute("dominant-baseline");
   const laid = el.hasAttribute(LAID_ATTR);
   const explicitTopAnchor = laid || dominantBaseline === "text-before-edge" || dominantBaseline === "hanging";
-  const topY = explicitTopAnchor ? ay : ay - fontSize;
   const inheritedShift = ownValue(el, "baseline-shift", onWarn) ?? {};
   const tracker = new LineTracker(el, onWarn);
-  const { runs, lead } = readRuns(el, tracker, inheritedShift, textStyle.letterSpacing, gradients, leafStyle, onWarn);
+  const { runs, lead } = readRuns(el, tracker, inheritedShift, textStyle, gradients, leafStyle, onWarn);
   const plain = runs.map((r) => r.text).join("");
-  const pitched = laid ? numberAttr(el, LINE_HEIGHT_ATTR) : tracker.lineHeight(fontSize);
+  const firstY = laid ? ay : tracker.firstBaseline ?? ay;
+  const topY = explicitTopAnchor ? firstY : firstY - fontSize;
+  const stated = numberAttr(el, LINE_HEIGHT_ATTR);
+  const pitched = laid ? stated : tracker.lineHeight(fontSize, stated);
   if (pitched !== void 0) textStyle.lineHeight = pitched;
   const lineHeight = textStyle.lineHeight ?? DEFAULT_LINE_HEIGHT;
   const dataW = num2(el.getAttribute("data-weasel-width"), NaN);
@@ -2665,7 +3123,7 @@ function parseTextElement(el, ctm, style, gradients, onWarn) {
     (r) => Object.entries(r).some(([k, v]) => k !== "text" && v !== void 0)
   );
   if (hasStyling) node.runs = runs;
-  if (textStyle.direction === void 0 && !el.hasAttribute("data-weasel-width")) {
+  if (textStyle.direction === void 0 && !writtenByWeasel(el)) {
     textStyle.direction = "ltr";
   }
   if (el.getAttribute("data-weasel-wrap") === "true") textStyle.wrap = true;
@@ -2681,85 +3139,6 @@ function parseTextElement(el, ctm, style, gradients, onWarn) {
   placeTextNode(node, multiply(ctm, localTransform), onWarn);
   return node;
 }
-function readRuns(el, tracker, inheritedShift, letterSpacing, gradients, leafStyle, onWarn) {
-  const runLines = [[]];
-  let leading = 0;
-  let lead = 0;
-  const push = (run) => {
-    runLines[runLines.length - 1].push(run);
-  };
-  if (holdsOnlyText(el) && el.hasAttribute("dx")) {
-    const t = el.textContent ?? "";
-    if (t) lead = placeTspanRun(el, { text: t, ...inheritedShift }, runLines, letterSpacing, onWarn);
-  } else 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;
-      push({ text: t, ...inheritedShift });
-    } 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) push({ text: t, ...inheritedShift });
-        continue;
-      }
-      warnUnreadPositions(sp, onWarn);
-      const afterText = runLines.some((line) => line.some((r) => r.text.trim() !== ""));
-      const lines = tracker.startsLine(sp, afterText);
-      if (runLines.length === 1 && runLines[0].length === 0 && statesLines(sp)) leading = lines;
-      else for (let n = 0; n < lines; n++) runLines.push([]);
-      lead += placeTspanRun(sp, readTspanRun(sp, gradients, leafStyle, onWarn), runLines, letterSpacing, onWarn);
-    }
-  }
-  if (!preservesSpace(el)) for (const line of runLines) collapseRunWhitespace(line);
-  return { runs: joinLines(runLines, leading), lead };
-}
-function readTspanRun(el, gradients, style, onWarn) {
-  const text = el.textContent ?? "";
-  const run = { text };
-  const fw = ownValue(el, "font-weight", onWarn);
-  if (fw === "bold" || fw === "bolder" || fw === 700) run.bold = true;
-  else if (fw === "normal") run.fontWeight = 400;
-  else if (typeof fw === "number") run.fontWeight = fw;
-  if (ownValue(el, "font-style", onWarn) === "italic") run.italic = true;
-  const ff = ownValue(el, "font-family", onWarn);
-  if (ff) run.fontFamily = ff;
-  const size = ownValue(el, "font-size", onWarn);
-  if (size?.fontSize != null) run.fontSize = size.fontSize;
-  if (size?.fontScale != null) run.fontScale = size.fontScale;
-  const tspanStyle = deriveStyle(style, el);
-  const ls = ownValue(el, "letter-spacing", onWarn, fontSizeOf(tspanStyle));
-  if (ls != null) run.letterSpacing = ls;
-  const shift = ownValue(el, "baseline-shift", onWarn);
-  if (shift?.script != null) run.script = shift.script;
-  if (shift?.baselineShift != null) run.baselineShift = shift.baselineShift;
-  const decoration = ownValue(el, "text-decoration", onWarn);
-  if (decoration?.underline) run.underline = true;
-  if (decoration?.strikethrough) run.strikethrough = true;
-  if (decoration?.overline) run.overline = true;
-  const transform = ownValue(el, "text-transform", onWarn);
-  if (transform) run.textTransform = transform;
-  const variant = ownValue(el, "font-variant", onWarn);
-  if (variant) run.fontVariantCaps = variant;
-  const fillAttr = resolveCurrentColor(ownProp(el, "fill"), tspanStyle);
-  if (fillAttr) {
-    const parsed = readProperty("fill", fillAttr);
-    if (parsed?.kind === "none") {
-      run.fill = null;
-    } else if (parsed?.kind === "solid") {
-      run.fill = { paint: { kind: "solid", color: parsed.color } };
-    } else if (parsed?.kind === "ref") {
-      const paint = gradients.get(parsed.id);
-      if (paint) run.fill = { paint };
-      else if (parsed.fallback) run.fill = { paint: { kind: "solid", color: parsed.fallback.color } };
-    }
-  }
-  const stroke = coreStroke(readStroke(ownStrokeStyle(el, tspanStyle), gradients, onWarn, isNonScalingStroke(el)));
-  if (stroke) run.stroke = stroke;
-  return run;
-}
 function readTextStyle(style, onWarn) {
   const out = {};
   const size = styleValue(style, "font-size", onWarn);
@@ -2982,20 +3361,9 @@ function markerEntryFrom(el, id, role, strokeWidth, gradients, onWarn) {
   if (parts.some((p) => JSON.stringify(p.style) !== JSON.stringify(first))) {
     onWarn(`<marker id="${id}"> paints its parts differently; all take the first part's paint`);
   }
-  let commandCount = 0, coordCount = 0;
-  for (const p of parts) {
-    commandCount += p.path.commands.length;
-    coordCount += p.path.coords.length;
-  }
-  const commands = new Uint8Array(commandCount);
-  const coords = new Float32Array(coordCount);
-  let ci = 0, pi = 0;
-  for (const p of parts) {
-    commands.set(p.path.commands, ci);
-    ci += p.path.commands.length;
-    coords.set(p.path.coords, pi);
-    pi += p.path.coords.length;
-  }
+  const joined = joinPaths(parts.map((p) => p.path));
+  const commands = joined.commands;
+  const coords = worldCoords(joined);
   const fillRule = parts[0].path.fillRule ?? "nonzero";
   const inset = markerInsetAttr(el);
   const round = (v) => Math.round(v * 1e4) / 1e4 + 0;
@@ -3049,6 +3417,27 @@ function groupPaint(el, from, style, ctm, gradients, onWarn) {
   if (stroke) paint.stroke = strokeThroughMatrix(stroke, ctm);
   return { paint: { ...paint, ...inheritsFrom(el, from) }, children };
 }
+var BOOLEAN_ATTR = "data-weasel-boolean";
+var OPS = /* @__PURE__ */ new Set(["union", "intersect", "subtract", "exclude"]);
+function booleanAttrOf(el) {
+  const op = el.tagName.toLowerCase() === "g" ? el.getAttribute(BOOLEAN_ATTR) : null;
+  return op !== null && OPS.has(op) ? { boolean: op } : {};
+}
+function derivedPathIn(tree, id) {
+  if (tree.derivedPathOf) return tree.derivedPathOf(id);
+  if (tree.overrides === void 0) return null;
+  return derivedDepOf(documentOf(tree), id)?.path ?? null;
+}
+function asBooleanLeaf(node, path, place) {
+  if (path === null || path.kind === "polygon" && path.commands.length === 0) {
+    return { ...node, data: { ...node.data, path: void 0 } };
+  }
+  return { ...node, data: { ...node.data, path }, pose: place(boundsOfPath(path)) };
+}
+function booleanGroupSvg(self, operands, data, paint) {
+  const held = { kind: "group", children: operands, boolean: booleanOpOf(data), hidden: true };
+  return { kind: "group", children: self ? [self, held] : [held], ...paint };
+}
 
 // src/parse.ts
 var SUPPORTED_GROUP_TAGS = /* @__PURE__ */ new Set(["g", "svg"]);
@@ -3073,10 +3462,7 @@ function parseSvg(svg, opts = {}) {
   }
   bindStylesheets(doc, mediaEnvironmentFor(root, opts.media), onWarn);
   const namespaces = opts.namespaces ?? {};
-  const uriToPrefix = /* @__PURE__ */ new Map();
-  for (const [prefix, uri] of Object.entries(namespaces)) {
-    uriToPrefix.set(uri, prefix);
-  }
+  const uriToPrefix = new Map(Object.entries(namespaces).map(([prefix, uri]) => [uri, prefix]));
   const documentMeta = collectDocumentMeta(root, uriToPrefix);
   const gradients = collectGradients(root, onWarn);
   for (const [id, paint] of collectPatterns(root, onWarn)) gradients.set(id, paint);
@@ -3190,7 +3576,7 @@ function parseChildren(parent, ctm, style, from, gradients, clips, onWarn, uriTo
     const ns = el.namespaceURI;
     if (ns && ns !== "http://www.w3.org/2000/svg" || isStrokeOutline(el)) continue;
     const hidden = isHiddenElement(el, style);
-    if (hidden && !keepHidden) continue;
+    if (hidden && !keepHidden && booleanAttrOf(el).boolean === void 0) continue;
     const node = unwrapStrokeGroup(el, parseElement(el, ctm, style, from, gradients, clips, onWarn, uriToPrefix, keepHidden));
     if (!node) continue;
     const parsed = Array.isArray(node) ? node : [node];
@@ -3299,7 +3685,7 @@ function parseGroup(el, ctm, style, from, gradients, clips, onWarn, uriToPrefix,
   const paint = groupPaint(el, from, childStyle, childCtm, gradients, onWarn);
   const children = parseChildren(el, childCtm, childStyle, paint.children, gradients, clips, onWarn, uriToPrefix, keepHidden);
   const opacity = ownValue(el, "opacity");
-  const group = { kind: "group", children, ...paint.paint };
+  const group = { kind: "group", children, ...paint.paint, ...booleanAttrOf(el) };
   const clip = clipFor(el, childCtm, clips, onWarn);
   if (clip) group.clip = clip;
   if (opacity != null) group.opacity = opacity;
@@ -3410,7 +3796,8 @@ var closedStroke = (stroke) => stroke && capsEnds(stroke) ? withoutEndMarkers(st
 var isClosed = (part) => splitByClosure(part).open === null;
 function samePath(a, b) {
   if (a === b) return true;
-  return a.commands.length === b.commands.length && a.coords.length === b.coords.length && a.commands.every((c, i) => c === b.commands[i]) && a.coords.every((v, i) => v === b.coords[i]);
+  const ac = worldCoords(a), bc = worldCoords(b);
+  return a.commands.length === b.commands.length && ac.length === bc.length && a.commands.every((c, i) => c === b.commands[i]) && ac.every((v, i) => v === bc[i]);
 }
 function strokeParts(path, stroke, filled, closed, open) {
   const none = { kind: "none" };
@@ -3598,11 +3985,20 @@ function fitLeafXml(xml, inherits, painted) {
 }
 function textXml(node, registry, namespaces, warn, given) {
   const layout = given && layoutMeasured(given, node.text) ? given : null;
+  const resolved = resolveTextStyle(node.style);
   const x = node.x + anchorOffset(node.style, node.width, node.text);
+  const leading = layout ? void 0 : halfLeadingFor(
+    resolved.fontFamily,
+    numericWeight(resolved.fontWeight),
+    resolved.fontStyle,
+    resolved.fontSize,
+    resolved.lineHeight
+  );
   const attrs = [
     `x="${trimNumber(x)}"`,
     `y="${trimNumber(node.y)}"`,
     layout ? `${LAID_ATTR}="lines"` : `dominant-baseline="text-before-edge"`,
+    ...leading ? [`dy="${trimNumber(leading)}"`] : [],
     // SVG's default whitespace handling would collapse indentation and runs
     // of spaces away on re-import.
     `xml:space="preserve"`,
@@ -3615,6 +4011,7 @@ function textXml(node, registry, namespaces, warn, given) {
   if (style?.fontWeight != null) attrs.push(`font-weight="${escapeAttr(String(style.fontWeight))}"`);
   if (style?.fontStyle && style.fontStyle !== "normal") attrs.push(`font-style="${style.fontStyle}"`);
   if (style?.fontVariantCaps === "small-caps") attrs.push('font-variant="small-caps"');
+  if (style?.lang) attrs.push(`xml:lang="${escapeAttr(style.lang)}"`);
   const direction = svgDirection(style, node.text);
   if (direction === "rtl" || style?.direction === "ltr") attrs.push(`direction="${direction}"`);
   let anchor = "start";
@@ -3642,7 +4039,7 @@ function textXml(node, registry, namespaces, warn, given) {
     attrs.push(`data-weasel-vertical-align="${node.verticalAlign}"`);
     if (!layout) 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 (layout && style?.lineHeight != null) attrs.push(`${LINE_HEIGHT_ATTR}="${trimNumber(style.lineHeight)}"`);
+  if (style?.lineHeight != null) attrs.push(`${LINE_HEIGHT_ATTR}="${trimNumber(style.lineHeight)}"`);
   if (node.fill !== void 0) {
     const paint = node.fill?.paint;
     if (!paint) attrs.push('fill="none"');
@@ -3658,7 +4055,6 @@ function textXml(node, registry, namespaces, warn, given) {
   const frame = boxTransformAttr(node);
   if (frame) attrs.push(frame);
   const pieces = node.runs && node.runs.length > 0 ? node.runs.map((r) => ({ text: r.text, attrs: runAttrs(r, style, registry, warn) })) : [{ text: node.text, attrs: null }];
-  const resolved = resolveTextStyle(style);
   const body = layout ? laidLinesXml(pieces, layout, { anchor, rtl: direction === "rtl" }) : linesXml(pieces, x, resolved.fontSize * resolved.lineHeight);
   const metaAttrs = metaAttrsXml(node.meta, namespaces);
   const metaEls = metaElementsXml(node.meta, namespaces);
@@ -3676,6 +4072,7 @@ function runAttrs(run, style, registry, warn) {
   if (run.italic) attrs.push(`font-style="italic"`);
   if (run.fontVariantCaps) attrs.push(`font-variant="${run.fontVariantCaps}"`);
   if (run.fontFamily) attrs.push(`font-family="${escapeAttr(run.fontFamily)}"`);
+  if (run.lang) attrs.push(`xml:lang="${escapeAttr(run.lang)}"`);
   const face = scriptSizeFace(run, style);
   const presetScale = face && run.script ? scriptMetricsFor(face.family, face.weight, face.style)[run.script].size : void 0;
   const scale = run.fontScale ?? presetScale;
@@ -3699,6 +4096,7 @@ function runAttrs(run, style, registry, warn) {
   }
   for (const a of coreStrokeAttrs(run.stroke, registry, warn)) attrs.push(a);
   if (run.textTransform) attrs.push(`style="text-transform:${run.textTransform}"`);
+  if (run.rotate) attrs.push(`rotate="${trimNumber(run.rotate)}"`);
   return attrs;
 }
 function textDecorationValue(underline, strikethrough, overline) {
@@ -3869,6 +4267,7 @@ function groupXml(node, registry, namespaces, warn, layoutOf, painted = NOTHING_
   if (node.opacity != null && node.opacity !== 1) {
     attrs.push(`opacity="${trimNumber(node.opacity)}"`);
   }
+  if (node.boolean) attrs.push(`${BOOLEAN_ATTR}="${node.boolean}"`);
   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, layoutOf, below)).join("");
@@ -4030,6 +4429,12 @@ function svgNodesToKitDrafts(input, nextId, options = {}) {
     const takes = takesOf(n, from, k);
     if (n.kind === "group") {
       const [own2, kids, ...more] = n.children;
+      if (own2 && own2.kind !== "group" && kids?.kind === "group" && kids.boolean) {
+        return visitMark(n, own2, kids, more, parentId, k, takes);
+      }
+      if (own2?.kind === "group" && own2.boolean) {
+        return visitMark(n, emptyResultOf(n), own2, [kids, ...more].filter((c) => c !== void 0), parentId, k, takes, true);
+      }
       if (own2 && own2.kind !== "group" && (kids === void 0 || kids.kind === "group") && options.mark?.(n)) {
         if (n.clip) return visit(clippingGroup(n), parentId, inherited2, from);
         return visitMark(n, own2, kids, more, parentId, k, takes);
@@ -4059,25 +4464,29 @@ function svgNodesToKitDrafts(input, nextId, options = {}) {
     const { pose, data } = leafDraft(n, takes, k);
     return pushLeaf(n, parentId, pose, data);
   };
-  const visitMark = (n, own2, kids, more, parentId, k, takes) => {
+  const visitMark = (n, own2, kids, more, parentId, k, takes, empty = false) => {
     const inner = groupTakes(n, takes, k);
     const pose = visit(own2, parentId, k, inner);
     const mark = pose === null ? null : drafts.at(-1);
     const under = mark?.id ?? parentId;
     if (mark && n.hidden) mark.hidden = true;
     if (mark && kids?.clip) mark.clip = "outline";
+    if (mark && kids?.boolean) mark.boolean = kids.boolean;
     const poses = [pose];
     if (kids) {
       const at = drafts.length;
       const kk = k * (kids.opacity ?? 1);
       const below = groupTakes(kids, takesOf(kids, inner, kk), kk);
       for (const c of kids.children) poses.push(visit(c, under, kk, below));
-      if (kids.hidden) {
+      if (kids.hidden && !kids.boolean) {
         for (const d of drafts.slice(at)) if (d.parentId === under) d.hidden = true;
       }
     }
     for (const c of more) poses.push(visit(c, under, k, inner));
-    return unionAABB(poses);
+    if (!empty) return unionAABB(poses);
+    const box = unionAABB(poses.slice(1));
+    if (mark && box) mark.pose = box;
+    return box;
   };
   for (const n of nodes) visit(n, null, 1, NO_TAKES);
   return drafts;
@@ -4153,6 +4562,16 @@ function containerPaint(n, takes, box, k) {
     ...takes.stroke ? { stroke: INHERIT } : stroke ? { stroke: fadeStroke(stroke, k) } : {}
   };
 }
+function emptyResultOf(n) {
+  const path = { kind: "polygon", commands: new Uint8Array(0), coords: new Float32Array(0), fillRule: "nonzero" };
+  return {
+    kind: "path",
+    path,
+    fill: n.fill ?? { kind: "none" },
+    ...n.stroke ? { stroke: n.stroke } : {},
+    ...n.inherits ? { inherits: n.inherits } : {}
+  };
+}
 function boxOfPath(path) {
   const b = boundsOfPath(path);
   return { x: b.x, y: b.y, width: b.width, height: b.height };
@@ -4180,6 +4599,10 @@ function scaleLeafData(data, scale) {
   }
   return out;
 }
+function asBooleanGroup(op, data) {
+  const { path: _path, ...rest } = data;
+  return { ...booleanGroupFields(), data: { ...rest, boolean: op } };
+}
 async function unpackSvgFiles(files, ctx) {
   const layer = ctx.scene.layers[0]?.id ?? "default";
   let index = 0;
@@ -4223,14 +4646,19 @@ async function unpackSvgFiles(files, ctx) {
         width: p.width * scale,
         height: p.height * scale
       });
+      const placed = localizeWorldPoses(
+        drafts.map((d) => ({ id: d.id, parent: d.parentId, pose: place(d.pose) })),
+        ctx.scene.composition
+      );
       const ops = drafts.map(
-        (d) => createInsertOp({
+        (d, i) => createInsertOp({
           node: {
             id: d.id,
             kind: d.kind,
             layer,
-            pose: place(d.pose),
+            pose: placed[i].pose,
             data: d.kind === "mark" ? scaleLeafData(d.data, scale) : d.data,
+            ...d.kind === "mark" && d.boolean ? asBooleanGroup(d.boolean, scaleLeafData(d.data, scale)) : {},
             parent: d.parentId,
             ...d.clip ? { clip: d.clip } : {},
             ...d.hidden ? { hidden: true } : {}
@@ -4351,12 +4779,36 @@ function svgTextFromKit(data, pose) {
 }
 function svgNodesFromKit(tree, options = {}) {
   const { include, leaf, group, mark } = options;
-  const emit = (id, up) => {
-    const node = tree.get(id);
-    const out2 = node && (!include || include(id)) ? lower(id, node, up) : null;
+  const compose = tree.composition?.compose;
+  const emit = (id, up, frame) => {
+    const stored = tree.get(id);
+    const node = stored && compose && frame ? { ...stored, pose: compose(frame, stored.pose) } : stored;
+    const own2 = node && definesFrame(node) ? node.pose : frame;
+    const out2 = node && (!include || include(id)) ? lower(id, node, up, own2) : null;
     return out2 && node?.hidden === true ? { ...out2, hidden: true } : out2;
   };
-  const lower = (id, node, up) => {
+  const frameAbove = (id) => {
+    if (!compose) return null;
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set([id]);
+    let at = tree.get(id)?.parent ?? null;
+    while (at !== null && !seen.has(at)) {
+      seen.add(at);
+      const n = tree.get(at);
+      if (!n) break;
+      chain.unshift(n);
+      at = n.parent ?? null;
+    }
+    let frame = null;
+    for (const n of chain) {
+      const pose = frame ? compose(frame, n.pose) : n.pose;
+      if (definesFrame(n)) frame = pose;
+    }
+    return frame;
+  };
+  const lower = (id, stored, up, frame) => {
+    const booleans = stored.consumesChildren === true;
+    const node = booleans ? asBooleanLeaf(stored, derivedPathIn(tree, id), (box) => compose && frame ? compose(frame, box) : box) : stored;
     const own2 = node.data;
     const isGroup = node.kind === "group";
     const self = isGroup ? null : markInherits(
@@ -4373,7 +4825,7 @@ function svgNodesFromKit(tree, options = {}) {
     const emitChildren = () => {
       const children = [];
       for (const c of kids) {
-        const child = emit(c, below);
+        const child = emit(c, below, frame);
         if (child) children.push(child);
       }
       return children;
@@ -4382,6 +4834,10 @@ function svgNodesFromKit(tree, options = {}) {
     const copies = node.copiesFromPose?.(node.pose, node) ?? [];
     const content = () => ({ kind: "group", children: emitChildren(), ...clip ? { clip } : {} });
     const paint = groupPaintFromKit(own2, below, node.pose);
+    if (booleans) {
+      const g = booleanGroupSvg(self, emitChildren(), own2, paint);
+      return mark ? mark(id, g) : g;
+    }
     const copied = () => copies.map((transform) => ({ kind: "group", transform, children: [content()] }));
     const withCopies = (g) => copies.length === 0 ? g : { kind: "group", children: [g, ...copied()] };
     if (isGroup) {
@@ -4398,7 +4854,7 @@ function svgNodesFromKit(tree, options = {}) {
   };
   const out = [];
   for (const id of options.roots ?? tree.roots) {
-    const n = emit(id, NO_UP_PAINT);
+    const n = emit(id, NO_UP_PAINT, frameAbove(id));
     if (n) out.push(n);
   }
   return out;