reamkit 1.31.0 → 1.32.0

package/dist/esm/pdf/styled-page-emitter.js

@@ -1,10 +1,10 @@
 import { dict, name, ref, stream, unicodeString } from "./objects.js";
 import { embedTtfFont } from "./cid-font.js";
 import { preparePdfEncryption } from "./encryption.js";
-import { reorderVisual } from "../core/bidi/algorithm.js";
+import { pageLayers, paintPlan } from "../layout/page-doc.js";
 import { reverseByCodePoint } from "../core/bidi/index.js";
-import { GLUE_SHRINK_RATIO } from "../layout/styled-layout.js";
-import { paintPlan } from "../layout/page-doc.js";
+import "../layout/styled-layout.js";
+import { BORDER_DASHES, FAUX_ITALIC_SHEAR, computeJustifyExtra, lineVisualOrder, settableInOneMatrix, washVeil } from "../layout/line-paint.js";
 import { emitClipPath, emitVectorShape, shadowBlurLayers } from "./vector-graphics.js";
 import { buildGradientAlphaMask, buildGradientPattern, shapeBbox } from "./shading.js";
 import { warpGlyphMatrix } from "../core/drawingml/text-warp.js";
@@ -16,16 +16,6 @@ import { addSignaturePlaceholder } from "./signature.js";
 import { buildXmpPacket } from "./xmp.js";
 //#region src/pdf/styled-page-emitter.ts
 var encoder = new TextEncoder();
-function washVeil(wash) {
-	if (!wash) return void 0;
-	const alpha = 1 - wash.gain;
-	if (!(alpha > .004)) return void 0;
-	const offset = .5 * (1 - wash.gain) + wash.black;
-	return {
-		alpha: Math.min(1, alpha),
-		grey: Math.max(0, Math.min(1, offset / alpha))
-	};
-}
 /**
 * The veil operators for a washed picture, to follow its own `/Im Do`: the
 * placement matrix maps the unit square onto the picture as drawn, so the wash
@@ -268,7 +258,7 @@ function assembleStyledPdf(laid, options, doc) {
 				tagFor: (structId) => builder.node(structId).type
 			};
 		}
-		const { content: contentBytes, links } = emitPageContent(page, pageTagging, gradientNames, alphaStateNames, wantDuotone, gradientMaskNames);
+		const { content: contentBytes, links } = emitPageLayers(page, pageTagging, gradientNames, alphaStateNames, wantDuotone, gradientMaskNames);
 		const contentsRef = doc.add(stream({}, contentBytes));
 		const pageEntries = {
 			Type: name("Page"),
@@ -611,31 +601,56 @@ function emitTaggedRuns(out, cmds, tagging, body) {
 * 24. Scaling them by the width instead drew page-borders-export-case-2.docx's
 * half-point frame as a row of specks a quarter the length it should be.
 */
-var BORDER_DASHES = new Map([
-	["dashed", [8, 2.5]],
-	["dashSmallGap", [3, 1]],
-	["dotted", [.5, 1]],
-	["dashDot", [
-		8,
-		2.5,
-		2.5,
-		2.5
-	]],
-	["dashDotDot", [
-		8,
-		2.5,
-		2.5,
-		2.5,
-		2.5,
-		2.5
-	]]
-]);
-var FAUX_ITALIC_SHEAR = .2126;
 /** The PDF dash array for a border style; an empty string means a solid rule. */
 function dashPatternFor(style) {
 	const pattern = style !== void 0 ? BORDER_DASHES.get(style) : void 0;
 	return pattern ? `[${pattern.map(formatNumber).join(" ")}]` : "";
 }
+/**
+* A page's content stream in its layers (pageLayers): its own items, then —
+* when some of them stand IN FRONT of its text (PageItemBase.over) — those,
+* painted again pass by pass over what the first layer left, their own text
+* last; and each group seen through a window of its own (PageItemBase.window)
+* inside a clip to it. Each layer is a balanced stream of its own, so they
+* simply follow one another.
+*/
+function emitPageLayers(page, ...rest) {
+	const layers = pageLayers(page.commands);
+	if (layers.length === 1 && !layers[0].window) return emitPageContent(page, ...rest);
+	const parts = [];
+	const links = [];
+	for (const layer of layers) {
+		const emitted = emitPageContent({
+			...page,
+			commands: layer.items
+		}, ...rest);
+		links.push(...emitted.links);
+		const w = layer.window;
+		if (!w) {
+			parts.push(emitted.content);
+			continue;
+		}
+		if (emitted.content.length === 0) continue;
+		const rect = [
+			w.x,
+			page.height - w.y - w.height,
+			w.width,
+			w.height
+		].map(formatNumber);
+		parts.push(encoder.encode(`q ${rect.join(" ")} re W n`), emitted.content, encoder.encode("Q"));
+	}
+	const content = new Uint8Array(parts.reduce((sum, p) => sum + p.length, 0) + Math.max(0, parts.length - 1));
+	let at = 0;
+	parts.forEach((p, i) => {
+		if (i > 0) content[at++] = 10;
+		content.set(p, at);
+		at += p.length;
+	});
+	return {
+		content,
+		links
+	};
+}
 function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneStateFor, gradientMaskNames) {
 	const commands = page.commands;
 	const links = [];
@@ -1414,9 +1429,6 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		links
 	};
 }
-function lineVisualOrder(line) {
-	return reorderVisual(line.tokens.map((t) => t.bidiLevel));
-}
 /**
 * The operators that put an image XObject in a box — ISO 32000-1 §8.9.5.1: the
 * unit square scaled to the box and moved to `(x, y)`, its bottom-left corner.
@@ -1460,40 +1472,6 @@ function rotateAboutCm(cx, cy, deg) {
 	const s = Math.sin(rad);
 	return `${formatNumber(c)} ${formatNumber(s)} ${formatNumber(-s)} ${formatNumber(c)} ${formatNumber(cx - cx * c + cy * s)} ${formatNumber(cy - cx * s - cy * c)} cm`;
 }
-/**
-* Whether a line is ONE text matrix and a run of glyphs: nothing in it placed
-* on its own — a tab, a stretched space, a picture, a formula, a right-to-left
-* run, a rise, a faked italic — and nothing drawn beside its glyphs, a run's
-* shading, a highlight or a rule. Only such a line can be turned by its matrix
-* alone; any other is placed token by token in page space.
-*
-* @param line The laid-out line.
-* @returns True when a single `Tm` sets the whole of it.
-*/
-function settableInOneMatrix(line) {
-	return computeJustifyExtra(line) === 0 && line.tokens.every((t) => t.kind === "text" && t.tab !== true && t.bidiLevel % 2 === 0 && t.risePt === void 0 && t.synthetic?.italic !== true && t.highlight !== true && t.resolvedRun.shadingColorHex === void 0 && t.resolvedRun.underline === "none" && !t.resolvedRun.strike);
-}
-function computeJustifyExtra(line) {
-	const alignment = line.resolved.alignment;
-	if (alignment !== "both" && alignment !== "distribute") return 0;
-	if (line.noJustify === true) return 0;
-	if (line.isLastInParagraph && alignment !== "distribute") return 0;
-	let last = line.tokens.length - 1;
-	while (last >= 0 && line.tokens[last].kind === "text" && line.tokens[last].isSpace) last--;
-	let spaces = 0;
-	let narrowest = Infinity;
-	let contentWidthPt = 0;
-	for (let i = 0; i <= last; i++) {
-		const tok = line.tokens[i];
-		contentWidthPt += tok.widthPt;
-		if (!tok.isSpace) continue;
-		spaces++;
-		if (tok.widthPt < narrowest) narrowest = tok.widthPt;
-	}
-	if (spaces === 0) return 0;
-	const extra = (line.availableWidthPt - contentWidthPt) / spaces;
-	return extra < 0 ? Math.max(extra, -narrowest * GLUE_SHRINK_RATIO) : extra;
-}
 function hexToRgb01(hex) {
 	return [
 		parseInt(hex.slice(0, 2), 16) / 255,

package/dist/esm/pdf/styled-page-renderer.js

@@ -1,6 +1,6 @@
 import { PdfDocument } from "./writer.js";
-import { layoutStyledDocument } from "../layout/styled-layout.js";
 import "../layout/page-doc.js";
+import { layoutStyledDocument } from "../layout/styled-layout.js";
 import { emitStyledPdf, emitStyledPdfEncrypted } from "./styled-page-emitter.js";
 //#region src/pdf/styled-page-renderer.ts
 /**

package/dist/esm/pdf-reader/font.js

@@ -1,14 +1,14 @@
 import { knowsFamily, resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
 import { parseTtf } from "../core/font/ttf-parser.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName } from "./encodings.js";
+import { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, openTypeCff } from "./cff-outline.js";
+import { cmapSubtables, outlineSource, postGlyphNames, sfntFsType, sfntSpaceAdvance } from "./glyf-outline.js";
 import { parseToUnicodeCMap } from "./cmap.js";
 import { decodePredefined, predefinedCMap, splitPredefined } from "./predefined-cmap.js";
 import { isZapfDingbats, zapfDingbatsChar } from "./dingbats.js";
 import { textForGlyphName } from "./glyph-names.js";
-import { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName } from "./encodings.js";
-import { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, openTypeCff } from "./cff-outline.js";
 import { type1Font } from "./type1-outline.js";
-import { cmapSubtables, outlineSource, postGlyphNames, sfntFsType, sfntSpaceAdvance } from "./glyf-outline.js";
 import { standardFace, standardWidth } from "./standard-widths.js";
 import { eachPageFont, embeddedFontName, hasLiftableProgram, programStyle } from "./embedded-fonts.js";
 //#region src/pdf-reader/font.ts

package/dist/esm/svg/svg-text.d.ts

@@ -0,0 +1,58 @@
+import { FontResource, LaidOutDocument, TextLineItem } from '../layout/page-doc.js';
+import { ImageCrop } from '../core/document-model/index.js';
+import { VectorShape } from '../core/vector.js';
+/** The glyph outlines of a page's faces, each defined once and used by id. */
+export declare class SvgGlyphs {
+    private readonly sources;
+    private readonly ids;
+    private readonly defs;
+    private readonly faceIds;
+    /**
+     * The id of the path that draws glyph `gid` of `font`, defining it on first
+     * use: `null` for a glyph with no ink (a space), `undefined` where the face
+     * carries no outlines this reads — the caller then sets the token as text.
+     *
+     * @param font The face.
+     * @param gid  The glyph.
+     * @returns The `<path>` id, `null`, or `undefined`.
+     */
+    use(font: FontResource, gid: number): string | null | undefined;
+    /** The `<defs>` holding every glyph used, or nothing when none was. */
+    defsXml(): string;
+    private sourceOf;
+}
+/** What drawing a line needs from the writer around it. */
+export interface SvgLineCtx {
+    readonly glyphs: SvgGlyphs;
+    /** The document-wide counter generated ids are numbered from. */
+    readonly ids: {
+        n: number;
+    };
+    readonly laid: LaidOutDocument;
+    /** A picture in a box, as the writer draws one. */
+    readonly image: (out: Array<string>, placed: PlacedImage) => void;
+    /** A vector shape, as the writer draws one. */
+    readonly shape: (out: Array<string>, shape: VectorShape) => void;
+}
+/** A picture placed in a box on the page — its top-left corner and size, in points. */
+export interface PlacedImage {
+    readonly resourceName: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly crop?: ImageCrop;
+    readonly rotationDeg?: number;
+    readonly flipH?: boolean;
+    readonly flipV?: boolean;
+    readonly alpha?: number;
+}
+/**
+ * Draw one laid-out line: what stands behind its glyphs, then the glyphs, a
+ * picture or formula wherever one stands in it.
+ *
+ * @param out  The SVG fragment sink.
+ * @param item The line, as the layout placed it.
+ * @param ctx  The glyph definitions and the writer's own drawing.
+ */
+export declare function emitSvgLine(out: Array<string>, item: TextLineItem, ctx: SvgLineCtx): void;

package/dist/esm/svg/svg-text.js

@@ -0,0 +1,322 @@
+import { svgPathData } from "../core/vector.js";
+import { reverseByCodePoint } from "../core/bidi/index.js";
+import { FAUX_ITALIC_SHEAR, computeJustifyExtra, lineVisualOrder } from "../layout/line-paint.js";
+import { warpGlyphMatrix } from "../core/drawingml/text-warp.js";
+import { sanitizeHref } from "../core/links.js";
+import { cffOutlineSource, openTypeCff } from "../pdf-reader/cff-outline.js";
+import { outlineSource } from "../pdf-reader/glyf-outline.js";
+//#region src/svg/svg-text.ts
+/** The colour of a comment range's highlight — the PDF emitter's. */
+var HIGHLIGHT_HEX = "fff3a3";
+/** The glyph outlines of a page's faces, each defined once and used by id. */
+var SvgGlyphs = class {
+	sources = /* @__PURE__ */ new Map();
+	ids = /* @__PURE__ */ new Map();
+	defs = [];
+	faceIds = /* @__PURE__ */ new Map();
+	/**
+	* The id of the path that draws glyph `gid` of `font`, defining it on first
+	* use: `null` for a glyph with no ink (a space), `undefined` where the face
+	* carries no outlines this reads — the caller then sets the token as text.
+	*
+	* @param font The face.
+	* @param gid  The glyph.
+	* @returns The `<path>` id, `null`, or `undefined`.
+	*/
+	use(font, gid) {
+		const source = this.sourceOf(font);
+		if (!source) return void 0;
+		let face = this.faceIds.get(font);
+		if (face === void 0) {
+			face = this.faceIds.size;
+			this.faceIds.set(font, face);
+		}
+		const key = `g${String(face)}-${String(gid)}`;
+		const known = this.ids.get(key);
+		if (known !== void 0) return known;
+		const path = source.path(gid);
+		if (!path || path.length === 0) {
+			this.ids.set(key, null);
+			return null;
+		}
+		this.defs.push(`<path id="${key}" d="${svgPathData(path, fmtEm)}"/>`);
+		this.ids.set(key, key);
+		return key;
+	}
+	/** The `<defs>` holding every glyph used, or nothing when none was. */
+	defsXml() {
+		return this.defs.length > 0 ? `<defs>${this.defs.join("")}</defs>` : "";
+	}
+	sourceOf(font) {
+		let source = this.sources.get(font);
+		if (source === void 0) {
+			const raw = font.parsed.raw;
+			const cff = font.parsed.tables.has("CFF ") ? openTypeCff(raw) : void 0;
+			source = (cff ? cffOutlineSource(cff) : outlineSource(raw)) ?? null;
+			this.sources.set(font, source);
+		}
+		return source ?? void 0;
+	}
+};
+/**
+* Draw one laid-out line: what stands behind its glyphs, then the glyphs, a
+* picture or formula wherever one stands in it.
+*
+* @param out  The SVG fragment sink.
+* @param item The line, as the layout placed it.
+* @param ctx  The glyph definitions and the writer's own drawing.
+*/
+function emitSvgLine(out, item, ctx) {
+	const clip = item.clip;
+	if (clip) {
+		const id = `clip${String(ctx.ids.n++)}`;
+		out.push(`<clipPath id="${id}"><rect x="${fmt(clip.x)}" y="${fmt(clip.y)}" width="${fmt(clip.width)}" height="${fmt(clip.height)}"/></clipPath>`, `<g clip-path="url(#${id})">`);
+	}
+	if (item.warp) emitWarped(out, item, ctx);
+	else if (item.rotationDeg) {
+		out.push(`<g transform="rotate(${fmt(-item.rotationDeg)} ${fmt(item.originX)} ${fmt(item.baselineY)})">`);
+		emitFlat(out, item, ctx);
+		out.push("</g>");
+	} else emitFlat(out, item, ctx);
+	if (clip) out.push("</g>");
+}
+/** A line set along its baseline, token by token. */
+function emitFlat(out, item, ctx) {
+	const line = item.line;
+	const originX = item.originX;
+	const baseline = item.baselineY;
+	const extraPerSpace = computeJustifyExtra(line);
+	const advance = (tok) => tok.widthPt + (tok.kind === "text" && tok.isSpace ? extraPerSpace : 0);
+	const lineFs = line.maxFontSizePt || 12;
+	const boxAscent = Math.max(lineFs, line.mathAscentPt ?? 0);
+	const boxDescent = Math.max(lineFs * .2, line.mathDescentPt ?? 0);
+	let x = originX;
+	for (const tok of line.tokens) {
+		const w = advance(tok);
+		if (tok.kind === "text") {
+			const hex = tok.resolvedRun.shadingColorHex ?? (tok.highlight === true ? HIGHLIGHT_HEX : void 0);
+			if (hex !== void 0) out.push(`<rect x="${fmt(x)}" y="${fmt(baseline - boxAscent)}" width="${fmt(w)}" height="${fmt(boxAscent + boxDescent)}" fill="#${hex}"/>`);
+		}
+		x += w;
+	}
+	x = originX;
+	for (const tok of line.tokens) {
+		const w = advance(tok);
+		if (tok.kind === "text" && (tok.resolvedRun.underline !== "none" || tok.resolvedRun.strike)) emitDecoration(out, tok, x, w, baseline);
+		x += w;
+	}
+	const order = line.tokens.some((t) => t.bidiLevel % 2 === 1) ? lineVisualOrder(line) : line.tokens.map((_, i) => i);
+	x = originX;
+	for (const i of order) {
+		const tok = line.tokens[i];
+		if (tok.kind === "image") emitImageToken(out, tok, x, baseline, ctx);
+		else if (tok.kind === "math") emitMathToken(out, tok, x, baseline, ctx);
+		else emitTextToken(out, tok, x, baseline, ctx);
+		x += advance(tok);
+	}
+	const words = line.tokens.map((t) => t.kind === "text" ? t.text : "").join("");
+	if (words.trim().length > 0) out.push(`<text x="${fmt(originX)}" y="${fmt(baseline)}" font-size="${fmt(lineFs)}" textLength="${fmt(x - originX)}" lengthAdjust="spacingAndGlyphs" fill-opacity="0" xml:space="preserve">${escapeXml(words)}</text>`);
+}
+/**
+* One run's glyphs from `x` along the baseline: the shaped glyphs of its text
+* (reversed for a right-to-left run, as the PDF shows it), each at the advance
+* the shaper gave it plus the run's letter spacing.
+*/
+function emitTextToken(out, tok, x, baseline, ctx) {
+	if (tok.text.length === 0) return;
+	const size = tok.fontSizePt;
+	const scale = (tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1);
+	const slant = tok.synthetic?.italic === true ? FAUX_ITALIC_SHEAR : 0;
+	const rise = tok.risePt ?? 0;
+	const text = tok.bidiLevel % 2 === 1 ? reverseByCodePoint(tok.text) : tok.text;
+	const run = tok.font.measure.glyphRun(text);
+	const upem = tok.font.parsed.unitsPerEm;
+	const spacingEm = (tok.resolvedRun.letterSpacingPt ?? 0) / (size * scale);
+	const uses = [];
+	let pen = 0;
+	for (let g = 0; g < run.gids.length; g++) {
+		const id = ctx.glyphs.use(tok.font, run.gids[g]);
+		if (id === void 0) {
+			emitAsText(out, tok, x, baseline);
+			return;
+		}
+		if (id !== null) uses.push(`<use href="#${id}"${pen !== 0 ? ` x="${fmtEm(pen)}"` : ""}/>`);
+		pen += (run.advances[g] ?? 0) / upem + spacingEm;
+	}
+	if (uses.length === 0) return;
+	const outline = tok.resolvedRun.textOutline;
+	const strokeWidth = outline !== void 0 ? outline.widthPt : tok.synthetic?.bold === true ? size * .03 : 0;
+	const stroke = strokeWidth > 0 ? ` stroke="#${outline?.colorHex ?? tok.resolvedRun.colorHex}" stroke-width="${fmtEm(strokeWidth / size)}"` : "";
+	const group = `<g transform="matrix(${fmt(size * scale)} 0 ${fmt(slant * size)} ${fmt(-size)} ${fmt(x)} ${fmt(baseline - rise)})" fill="#${tok.resolvedRun.colorHex}"${stroke}>${uses.join("")}</g>`;
+	const href = tok.href !== void 0 ? sanitizeHref(tok.href) : void 0;
+	out.push(href !== void 0 ? `<a href="${escapeXml(href)}">${group}</a>` : group);
+}
+/** A run of a face whose outlines cannot be read: its characters, for the viewer's fonts to set. */
+function emitAsText(out, tok, x, baseline) {
+	if (tok.text.trim().length === 0) return;
+	out.push(`<text x="${fmt(x)}" y="${fmt(baseline - (tok.risePt ?? 0))}" font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
+}
+/** A run's underline and strikethrough, where the PDF emitter draws them. */
+function emitDecoration(out, tok, x, w, baseline) {
+	const size = tok.fontSizePt;
+	const thickness = Math.max(.4, size * .06);
+	const style = tok.resolvedRun.underline;
+	if (style !== "none") {
+		const hex = tok.resolvedRun.underlineColorHex ?? tok.resolvedRun.colorHex;
+		const t = style === "thick" || style === "dottedHeavy" || style === "dashHeavy" ? thickness * 2 : thickness;
+		const top = baseline + size * .12;
+		const dashed = style === "dotted" || style === "dottedHeavy" ? [t, t * 2] : style === "dash" || style === "dashHeavy" ? [t * 4, t * 3] : void 0;
+		if (dashed) out.push(`<line x1="${fmt(x)}" y1="${fmt(top + t / 2)}" x2="${fmt(x + w)}" y2="${fmt(top + t / 2)}" stroke="#${hex}" stroke-width="${fmt(t)}" stroke-dasharray="${dashed.map(fmt).join(" ")}"/>`);
+		else {
+			out.push(`<rect x="${fmt(x)}" y="${fmt(top)}" width="${fmt(w)}" height="${fmt(t)}" fill="#${hex}"/>`);
+			if (style === "double") out.push(`<rect x="${fmt(x)}" y="${fmt(top + t * 2)}" width="${fmt(w)}" height="${fmt(t)}" fill="#${hex}"/>`);
+		}
+	}
+	if (tok.resolvedRun.strike) out.push(`<rect x="${fmt(x)}" y="${fmt(baseline - size * .26 - thickness)}" width="${fmt(w)}" height="${fmt(thickness)}" fill="#${tok.resolvedRun.colorHex}"/>`);
+}
+/**
+* An inline picture standing on the baseline, its bottom edge on it — or a
+* metafile, which draws itself from that corner in a frame of its own (y up).
+*/
+function emitImageToken(out, tok, x, baseline, ctx) {
+	const b = tok.drawBox;
+	const left = x + (b?.dxPt ?? 0);
+	const bottom = baseline - (b?.dyPt ?? 0);
+	const width = b?.widthPt ?? tok.widthPt;
+	const height = b?.heightPt ?? tok.heightPt;
+	const meta = tok.metafile;
+	if (meta) {
+		for (const img of meta.images ?? []) {
+			if (img.resourceName === "") continue;
+			ctx.image(out, {
+				resourceName: img.resourceName,
+				x: left + img.x,
+				y: bottom - img.y - img.height,
+				width: img.width,
+				height: img.height,
+				...img.rotationDeg !== void 0 ? { rotationDeg: img.rotationDeg } : {}
+			});
+		}
+		for (const sh of meta.shapes) ctx.shape(out, {
+			...sh,
+			transform: [
+				1,
+				0,
+				0,
+				-1,
+				left,
+				bottom
+			]
+		});
+		for (const t of meta.texts) {
+			const first = t.line.tokens.find((k) => k.kind === "text");
+			if (first?.kind !== "text") continue;
+			emitTextToken(out, first, left + t.x, bottom - t.y, ctx);
+		}
+		return;
+	}
+	if (!tok.imageResourceName) return;
+	const shadow = tok.shadow;
+	if (shadow) {
+		const id = `shadow${String(ctx.ids.n++)}`;
+		const blur = shadow.blurPt > 0;
+		if (blur) out.push(`<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="${fmt(shadow.blurPt / 2)}"/></filter>`);
+		out.push(`<rect x="${fmt(left + shadow.dxPt)}" y="${fmt(bottom - height + shadow.dyPt)}" width="${fmt(width)}" height="${fmt(height)}" fill="#${shadow.colorHex}" opacity="${fmt(shadow.alpha)}"${blur ? ` filter="url(#${id})"` : ""}/>`);
+	}
+	ctx.image(out, {
+		resourceName: tok.imageResourceName,
+		x: left,
+		y: bottom - height,
+		width,
+		height,
+		...tok.crop ? { crop: tok.crop } : {},
+		...tok.rotationDeg !== void 0 ? { rotationDeg: tok.rotationDeg } : {},
+		...tok.flipH === true ? { flipH: true } : {},
+		...tok.flipV === true ? { flipV: true } : {}
+	});
+	const frame = tok.outline;
+	if (frame) out.push(`<rect x="${fmt(left)}" y="${fmt(bottom - height)}" width="${fmt(width)}" height="${fmt(height)}" fill="none" stroke="#${frame.colorHex}" stroke-width="${fmt(frame.widthPt)}"/>`);
+}
+/** An inline formula: its glyphs, rules and paths, placed from its origin on the baseline (y up). */
+function emitMathToken(out, tok, x, baseline, ctx) {
+	for (const it of tok.items) if (it.kind === "glyph") {
+		const run = it.font.measure.glyphRun(it.text);
+		const upem = it.font.parsed.unitsPerEm;
+		const uses = [];
+		let pen = 0;
+		for (let g = 0; g < run.gids.length; g++) {
+			const id = ctx.glyphs.use(it.font, run.gids[g]);
+			if (id) uses.push(`<use href="#${id}"${pen !== 0 ? ` x="${fmtEm(pen)}"` : ""}/>`);
+			pen += (run.advances[g] ?? 0) / upem;
+		}
+		if (uses.length > 0) out.push(`<g transform="matrix(${fmt(it.sizePt)} 0 0 ${fmt(-it.sizePt)} ${fmt(x + it.x)} ${fmt(baseline - it.y)})" fill="#000000">${uses.join("")}</g>`);
+	} else if (it.kind === "rule") out.push(`<rect x="${fmt(x + it.x)}" y="${fmt(baseline - it.y - it.h)}" width="${fmt(it.w)}" height="${fmt(it.h)}" fill="#000000"/>`);
+	else ctx.shape(out, {
+		paths: [{ segments: it.segments }],
+		...it.fill === true ? { fillColorHex: "000000" } : {},
+		...it.strokeWidthPt !== void 0 ? { stroke: {
+			colorHex: "000000",
+			widthPt: it.strokeWidthPt
+		} } : {},
+		transform: [
+			1,
+			0,
+			0,
+			-1,
+			x,
+			baseline
+		]
+	});
+}
+/**
+* §20.1.9.10 — WordArt: every glyph at its own point on the warp's curve, each
+* with its own matrix. The token's glyphs are rescaled to the width it was
+* measured at, as the PDF does, so the block still ends where the layout said.
+*/
+function emitWarped(out, item, ctx) {
+	const warp = item.warp;
+	let cursor = item.originX;
+	for (const tok of item.line.tokens) {
+		if (tok.kind !== "text" || tok.isSpace) {
+			cursor += tok.widthPt;
+			continue;
+		}
+		const size = tok.fontSizePt;
+		const chars = [...tok.text];
+		const raw = chars.map((c) => tok.font.measure.textWidthPt(c, size));
+		const total = raw.reduce((a, b) => a + b, 0);
+		const k = total > 0 ? tok.widthPt / total : 1;
+		for (let i = 0; i < chars.length; i++) {
+			const adv = raw[i] * k;
+			const m = warpGlyphMatrix(warp, cursor, adv, item.baselineY);
+			cursor += adv;
+			if (!m) continue;
+			const run = tok.font.measure.glyphRun(chars[i]);
+			const upem = tok.font.parsed.unitsPerEm;
+			const uses = [];
+			let pen = 0;
+			for (let g = 0; g < run.gids.length; g++) {
+				const id = ctx.glyphs.use(tok.font, run.gids[g]);
+				if (id) uses.push(`<use href="#${id}"${pen !== 0 ? ` x="${fmtEm(pen)}"` : ""}/>`);
+				pen += (run.advances[g] ?? 0) / upem;
+			}
+			if (uses.length === 0) continue;
+			out.push(`<g transform="matrix(${fmt(m[0] * size)} ${fmt(m[1] * size)} ${fmt(m[2] * size)} ${fmt(m[3] * size)} ${fmt(m[4])} ${fmt(m[5])})" fill="#${tok.resolvedRun.colorHex}">${uses.join("")}</g>`);
+		}
+	}
+}
+function escapeXml(s) {
+	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+}
+/** A page coordinate, to the hundredth of a point. */
+function fmt(n) {
+	const r = Math.round(n * 100) / 100;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+/** A coordinate in a one-unit em, to a ten-thousandth of it. */
+function fmtEm(n) {
+	const r = Math.round(n * 1e4) / 1e4;
+	return Object.is(r, -0) ? "0" : String(r);
+}
+//#endregion
+export { SvgGlyphs, emitSvgLine };