reamkit 1.30.0 → 1.32.0

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 };

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

@@ -1,8 +1,10 @@
+import { pageLayers, paintPlan } from "../layout/page-doc.js";
 import { FEATURES } from "../core/ir/features.js";
 import { svgPathData } from "../core/vector.js";
 import { gradientSvgDef } from "../core/drawingml/shape-render.js";
-import { paintPlan } from "../layout/page-doc.js";
+import { BORDER_DASHES, washVeil } from "../layout/line-paint.js";
 import { toBase64 } from "../core/bytes.js";
+import { SvgGlyphs, emitSvgLine } from "./svg-text.js";
 //#region src/svg/svg-writer.ts
 var PAGE_GAP = 12;
 /**
@@ -23,17 +25,25 @@ function writeSvg(laid, opts = {}) {
 	const width = Math.max(1, ...laid.pages.map((p) => p.width));
 	const height = laid.pages.reduce((s, p) => s + p.height, 0) + gap * Math.max(0, laid.pages.length - 1);
 	const parts = [];
-	parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${fmt(width)}" height="${fmt(height)}" viewBox="0 0 ${fmt(width)} ${fmt(height)}">`);
+	const ids = { n: 0 };
+	const glyphs = new SvgGlyphs();
+	const ctx = {
+		glyphs,
+		ids,
+		laid,
+		image: (out, placed) => emitPlaced(out, placed, laid, ids),
+		shape: (out, shape) => emitShape(out, shape, ids)
+	};
 	let yOffset = 0;
-	const idc = { n: 0 };
 	laid.pages.forEach((page, i) => {
 		parts.push(`<g transform="translate(0 ${fmt(yOffset)})" data-page="${i + 1}">`);
 		parts.push(`<rect x="0" y="0" width="${fmt(page.width)}" height="${fmt(page.height)}" fill="#ffffff" stroke="#cccccc"/>`);
-		emitPage(parts, page, laid, losses, idc);
+		emitPage(parts, page, ctx);
 		parts.push("</g>");
 		yOffset += page.height + gap;
 	});
 	parts.push("</svg>");
+	parts.unshift(`<svg xmlns="http://www.w3.org/2000/svg" width="${fmt(width)}" height="${fmt(height)}" viewBox="0 0 ${fmt(width)} ${fmt(height)}">`, glyphs.defsXml());
 	return {
 		bytes: new TextEncoder().encode(parts.join("\n")),
 		losses
@@ -54,11 +64,24 @@ var svgWriter = {
 	]),
 	write: (doc, opts) => writeSvg(doc, opts ?? {})
 };
-function emitPage(out, page, laid, losses, idc) {
-	const plan = paintPlan(page.commands);
-	for (const item of plan.behind) emitPageItem(out, item, laid, losses, idc);
+function emitPage(out, page, ctx) {
+	for (const layer of pageLayers(page.commands)) {
+		const w = layer.window;
+		if (!w) {
+			emitLayer(out, layer.items, ctx);
+			continue;
+		}
+		const id = `win${String(ctx.ids.n++)}`;
+		out.push(`<clipPath id="${id}"><rect x="${fmt(w.x)}" y="${fmt(w.y)}" width="${fmt(w.width)}" height="${fmt(w.height)}"/></clipPath>`, `<g clip-path="url(#${id})">`);
+		emitLayer(out, layer.items, ctx);
+		out.push("</g>");
+	}
+}
+function emitLayer(out, commands, ctx) {
+	const plan = paintPlan(commands);
+	for (const item of plan.behind) emitPageItem(out, item, ctx);
 	for (const f of plan.fills) out.push(`<rect x="${fmt(f.x)}" y="${fmt(f.y)}" width="${fmt(f.width)}" height="${fmt(f.height)}" fill="#${f.fillColorHex}"/>`);
-	for (const img of plan.images) emitImage(out, img, laid, idc);
+	for (const img of plan.images) emitImage(out, img, ctx);
 	for (const b of plan.borders) {
 		const x2 = b.x + b.width;
 		const yTop = b.y;
@@ -84,104 +107,148 @@ function emitPage(out, page, laid, losses, idc) {
 			x2,
 			yBottom
 		];
-		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"${b.borderStyle === "dashed" ? " stroke-dasharray=\"8 2.5\"" : b.borderStyle === "dashSmallGap" ? " stroke-dasharray=\"3 1\"" : b.borderStyle === "dotted" ? " stroke-dasharray=\"0.5 1\"" : ""}/>`);
+		const dash = b.borderStyle !== void 0 ? BORDER_DASHES.get(b.borderStyle) : void 0;
+		out.push(`<line x1="${fmt(ax)}" y1="${fmt(ay)}" x2="${fmt(bx)}" y2="${fmt(by)}" stroke="#${b.borderColorHex}" stroke-width="${fmt(b.borderSizePt)}"${dash ? ` stroke-dasharray="${dash.map(fmt).join(" ")}"` : ""}/>`);
 	}
-	for (const sh of plan.shapes) emitShape(out, sh.shape, idc);
-	for (const picture of plan.pictures) for (const item of picture) emitPageItem(out, item, laid, losses, idc);
-	for (const run of plan.ordered) for (const item of run) emitPageItem(out, item, laid, losses, idc);
-	for (const t of plan.lines) emitTextLine(out, t, losses, idc);
+	for (const sh of plan.shapes) emitShape(out, sh.shape, ctx.ids);
+	for (const picture of plan.pictures) for (const item of picture) emitPageItem(out, item, ctx);
+	for (const run of plan.ordered) for (const item of run) emitPageItem(out, item, ctx);
+	for (const t of plan.lines) emitSvgLine(out, t, ctx);
 }
 /**
-* One picture. §20.1.8.23 `a:duotone` recolours it between two colours — its
-* dark end and its light end — which is a luminance-to-two-tone map, and SVG
-* states exactly that: luminance into every channel, then a two-entry transfer
-* table per channel.
+* One picture item, its placement and its effects: §20.1.8.23 `a:duotone`
+* recolours it between its dark end and its light end — luminance into every
+* channel, then a two-entry transfer table per channel — and a picture FILL
+* (§20.1.8.14) is clipped to the outline of the shape it fills.
 *
 * @param out  The SVG fragment sink.
 * @param img  The image item.
-* @param laid The laid-out document, for the image's data URI.
-* @param idc  The shared id counter, for the filter's id.
+* @param ctx  The document, its id counter, its drawing.
 */
-function emitImage(out, img, laid, idc) {
-	const href = imageHref(img.imageResourceName, laid);
-	if (!href) return;
-	let filter = "";
+function emitImage(out, img, ctx) {
+	let filter;
 	if (img.duotone) {
-		const id = `duo${String(idc.n++)}`;
+		const id = `duo${String(ctx.ids.n++)}`;
 		const chan = (hex, at) => parseInt(hex.slice(at, at + 2), 16) / 255;
 		const table = (at) => `${fmt(chan(img.duotone.shadowHex, at))} ${fmt(chan(img.duotone.highlightHex, at))}`;
 		out.push(`<filter id="${id}" color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0.2126 0.7152 0.0722 0 0 0 0 0 1 0"/><feComponentTransfer><feFuncR type="table" tableValues="${table(0)}"/><feFuncG type="table" tableValues="${table(2)}"/><feFuncB type="table" tableValues="${table(4)}"/></feComponentTransfer></filter>`);
-		filter = ` filter="url(#${id})"`;
+		filter = id;
+	}
+	let clipped = false;
+	if (img.clip) {
+		const id = `pic${String(ctx.ids.n++)}`;
+		const [a, b, c, d, e, f] = img.clip.transform;
+		out.push(`<clipPath id="${id}">` + img.clip.paths.map((p) => `<path d="${pathData(p.segments)}" transform="matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e)} ${fmt(f)})"/>`).join("") + `</clipPath>`, `<g clip-path="url(#${id})">`);
+		clipped = true;
+	}
+	emitPlaced(out, {
+		resourceName: img.imageResourceName,
+		x: img.x,
+		y: img.y,
+		width: img.width,
+		height: img.height,
+		...img.crop ? { crop: img.crop } : {},
+		...img.rotationDeg !== void 0 ? { rotationDeg: img.rotationDeg } : {},
+		...img.flipH === true ? { flipH: true } : {},
+		...img.flipV === true ? { flipV: true } : {},
+		...img.alpha !== void 0 ? { alpha: img.alpha } : {}
+	}, ctx.laid, ctx.ids, filter, img.wash);
+	if (clipped) out.push("</g>");
+}
+/**
+* A picture in its box, as the PDF places one: turned about the box's centre
+* (clockwise, as DrawingML measures), mirrored about it, and — cropped by
+* `a:srcRect` (§20.1.8.55) — drawn larger than the box with the box as its clip,
+* so the part that was kept fills it. A wash (§14.1.2.10) is the veil laid over
+* it.
+*/
+function emitPlaced(out, placed, laid, ids, filter, wash) {
+	const href = imageHref(placed.resourceName, laid);
+	if (!href) return;
+	const { x, y, width, height } = placed;
+	const cx = x + width / 2;
+	const cy = y + height / 2;
+	const turns = [];
+	if (placed.rotationDeg) turns.push(`rotate(${fmt(placed.rotationDeg)} ${fmt(cx)} ${fmt(cy)})`);
+	if (placed.flipH === true || placed.flipV === true) {
+		const sx = placed.flipH === true ? -1 : 1;
+		const sy = placed.flipV === true ? -1 : 1;
+		turns.push(`matrix(${String(sx)} 0 0 ${String(sy)} ${fmt(sx === -1 ? 2 * cx : 0)} ${fmt(sy === -1 ? 2 * cy : 0)})`);
 	}
-	out.push(`<image x="${fmt(img.x)}" y="${fmt(img.y)}" width="${fmt(img.width)}" height="${fmt(img.height)}" href="${href}" preserveAspectRatio="none"${filter}/>`);
+	const open = turns.length > 0 ? `<g transform="${turns.join(" ")}">` : "";
+	if (open) out.push(open);
+	const crop = placed.crop;
+	let clipId;
+	let drawn = {
+		x,
+		y,
+		width,
+		height
+	};
+	if (crop) {
+		const keptW = 1 - crop.left - crop.right;
+		const keptH = 1 - crop.top - crop.bottom;
+		if (keptW > 0 && keptH > 0) {
+			const fullW = width / keptW;
+			const fullH = height / keptH;
+			drawn = {
+				x: x - crop.left * fullW,
+				y: y - crop.top * fullH,
+				width: fullW,
+				height: fullH
+			};
+			clipId = `crop${String(ids.n++)}`;
+			out.push(`<clipPath id="${clipId}"><rect x="${fmt(x)}" y="${fmt(y)}" width="${fmt(width)}" height="${fmt(height)}"/></clipPath>`);
+		}
+	}
+	const alpha = placed.alpha !== void 0 && placed.alpha < 1 ? ` opacity="${fmt(placed.alpha)}"` : "";
+	out.push(`<image x="${fmt(drawn.x)}" y="${fmt(drawn.y)}" width="${fmt(drawn.width)}" height="${fmt(drawn.height)}" href="${href}" preserveAspectRatio="none"${clipId ? ` clip-path="url(#${clipId})"` : ""}${filter ? ` filter="url(#${filter})"` : ""}${alpha}/>`);
+	const veil = washVeil(wash);
+	if (veil) {
+		const grey = Math.round(veil.grey * 255).toString(16).padStart(2, "0");
+		out.push(`<rect x="${fmt(x)}" y="${fmt(y)}" width="${fmt(width)}" height="${fmt(height)}" fill="#${grey}${grey}${grey}" opacity="${fmt(veil.alpha)}"/>`);
+	}
+	if (open) out.push("</g>");
 }
 /**
 * One page item, whatever its kind — for the runs that paint in their own order
 * (what stands behind the content, and a picture's own primitives) rather than
 * in the by-kind passes.
 *
-* @param out    The SVG fragment sink.
-* @param item   The item to draw.
-* @param laid   The laid-out document, for image resources.
-* @param losses Where an unrenderable item records itself.
-* @param idc    The shared id counter for generated defs.
+* @param out  The SVG fragment sink.
+* @param item The item to draw.
+* @param ctx  The document, its glyphs, its id counter and its drawing.
 */
-function emitPageItem(out, item, laid, losses, idc) {
+function emitPageItem(out, item, ctx) {
 	if (item.type === "shape") {
-		emitShape(out, item.shape, idc);
+		emitShape(out, item.shape, ctx.ids);
 		return;
 	}
 	if (item.type === "line") {
-		emitTextLine(out, item, losses, idc);
+		emitSvgLine(out, item, ctx);
 		return;
 	}
 	if (item.type === "image") {
-		emitImage(out, item, laid, idc);
+		emitImage(out, item, ctx);
 		return;
 	}
 	if (item.type === "fill") out.push(`<rect x="${fmt(item.x)}" y="${fmt(item.y)}" width="${fmt(item.width)}" height="${fmt(item.height)}" fill="#${item.fillColorHex}"/>`);
 }
-function emitTextLine(out, item, losses, idc) {
-	const clip = item.clip;
-	if (clip) {
-		const id = `clip${idc.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})">`);
-	}
-	const y = item.baselineY;
-	let x = item.originX;
-	const rot = item.rotationDeg ? ` transform="rotate(${fmt(-item.rotationDeg)} ${fmt(item.originX)} ${fmt(item.baselineY)})"` : "";
-	for (const tok of item.line.tokens) {
-		if (tok.kind === "image") {
-			x += tok.widthPt;
-			continue;
-		}
-		if (tok.kind === "math") {
-			losses.push({
-				severity: "dropped",
-				feature: FEATURES.math,
-				detail: "inline math box not rendered by the SVG writer (v0)"
-			});
-			x += tok.widthPt;
-			continue;
-		}
-		if (tok.text.trim().length > 0) out.push(`<text x="${fmt(x)}" y="${fmt(y)}"${rot} font-family="sans-serif" font-size="${fmt(tok.fontSizePt)}" fill="#${tok.resolvedRun.colorHex}">${escapeXml(tok.text)}</text>`);
-		x += tok.widthPt;
-	}
-	if (clip) out.push("</g>");
-}
-function emitShape(out, shape, idc) {
+function emitShape(out, shape, ids) {
 	const [a, b, c, d, e, f] = shape.transform;
 	const transform = `matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e)} ${fmt(f)})`;
 	let fill;
 	if (shape.fillGradient) {
-		const id = `grad${idc.n++}`;
+		const id = `grad${String(ids.n++)}`;
 		out.push(gradientSvgDef(id, shape.fillGradient));
 		fill = `url(#${id})`;
 	} else fill = shape.fillColorHex ? `#${shape.fillColorHex}` : "none";
-	const stroke = shape.stroke ? ` stroke="#${shape.stroke.colorHex}" stroke-width="${fmt(shape.stroke.widthPt)}"` : "";
+	const fillAlpha = shape.fillAlpha !== void 0 && shape.fillAlpha < 1 && fill !== "none" ? ` fill-opacity="${fmt(shape.fillAlpha)}"` : "";
+	const s = shape.stroke;
+	const stroke = s ? ` stroke="#${s.colorHex}" stroke-width="${fmt(s.widthPt)}"` + (s.cap !== void 0 ? ` stroke-linecap="${s.cap}"` : "") + (s.join !== void 0 ? ` stroke-linejoin="${s.join}"` : "") + (s.dash && s.dash.length > 0 ? ` stroke-dasharray="${s.dash.map(fmt).join(" ")}"` : "") : "";
 	const shadow = shape.shadow;
 	if (shadow) {
-		const id = `shadow${idc.n++}`;
+		const id = `shadow${String(ids.n++)}`;
 		if (shadow.blurPt > 0) out.push(`<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="${fmt(shadow.blurPt / 2)}"/></filter>`);
 		const shTransform = `matrix(${fmt(a)} ${fmt(b)} ${fmt(c)} ${fmt(d)} ${fmt(e + shadow.dxPt)} ${fmt(f + shadow.dyPt)})`;
 		out.push(`<g opacity="${fmt(shadow.alpha)}"${shadow.blurPt > 0 ? ` filter="url(#${id})"` : ""}>`);
@@ -194,7 +261,7 @@ function emitShape(out, shape, idc) {
 	for (const path of shape.paths) {
 		const d2 = pathData(path.segments);
 		const rule = path.fillRule === "evenodd" ? " fill-rule=\"evenodd\"" : "";
-		out.push(`<path d="${d2}" fill="${fill}"${rule}${stroke} transform="${transform}"/>`);
+		out.push(`<path d="${d2}" fill="${fill}"${fillAlpha}${rule}${stroke} transform="${transform}"/>`);
 	}
 }
 function pathData(segments) {
@@ -209,9 +276,6 @@ function imageHref(resourceName, laid) {
 		return `data:${res.prepared.mimeType};base64,${toBase64(bytes)}`;
 	}
 }
-function escapeXml(s) {
-	return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
-}
 function fmt(n) {
 	const r = Math.round(n * 100) / 100;
 	return Object.is(r, -0) ? "0" : String(r);

package/dist/esm/word/doc/doc-reader.js

@@ -178,7 +178,8 @@ function readDoc(bytes) {
 			},
 			styles: EMPTY_STYLE_SHEET,
 			resources,
-			...headersFooters.size > 0 ? { headersFooters } : {}
+			...headersFooters.size > 0 ? { headersFooters } : {},
+			typesetBy: "word"
 		},
 		losses: [content.encrypted ? DOC_ENCRYPTED_LOSS : DOC_TEXT_LOSS]
 	};
@@ -406,7 +407,10 @@ function toParaProperties(p) {
 		...p.indentRightTwips !== void 0 ? { indentRight: pt(p.indentRightTwips / 20) } : {},
 		...p.indentFirstTwips !== void 0 ? { indentFirstLine: pt(p.indentFirstTwips / 20) } : {},
 		...p.spaceBeforeTwips !== void 0 ? { spacingBefore: pt(p.spaceBeforeTwips / 20) } : {},
-		...p.spaceAfterTwips !== void 0 ? { spacingAfter: pt(p.spaceAfterTwips / 20) } : {}
+		...p.spaceAfterTwips !== void 0 ? { spacingAfter: pt(p.spaceAfterTwips / 20) } : {},
+		...p.widowControl !== void 0 ? { widowControl: p.widowControl } : {},
+		...p.keepNext !== void 0 ? { keepNext: p.keepNext } : {},
+		...p.keepLines !== void 0 ? { keepLines: p.keepLines } : {}
 	};
 }
 function underlineStyle(kul) {

package/dist/esm/word/doc/doc-text.d.ts

@@ -74,6 +74,12 @@ export interface DocParaProps {
     readonly listIlfo?: number;
     /** `sprmPIlvl` — list level (0–8). */
     readonly listIlvl?: number;
+    /** `sprmPFWidowControl` — no first or last line left alone on a page. */
+    readonly widowControl?: boolean;
+    /** `sprmPFKeepFollow` — on the same page as the start of the next paragraph. */
+    readonly keepNext?: boolean;
+    /** `sprmPFKeep` — every line on one page. */
+    readonly keepLines?: boolean;
 }
 /** One maximal same-formatting run of text, or an embedded picture. */
 export interface DocRun {