@stll/folio-core 0.48.0 → 0.50.0

package/dist/docx/shapeAlternateContent.d.ts

@@ -0,0 +1,25 @@
+import { Shape, ShapeAlternateContent, ShapeContent } from "../types/content.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/shapeAlternateContent.d.ts
+/**
+ * Capture the `mc:AlternateContent` a shape was read from, when the shape's
+ * drawing is the sole child of the branch it came from.
+ */
+declare const captureShapeAlternateContent: ({ shape, alternateContent, branch, drawing }: {
+  shape: Shape;
+  alternateContent: XmlElement;
+  branch: XmlElement;
+  drawing: XmlElement;
+}) => ShapeAlternateContent | undefined;
+/** Re-fingerprint a capture for a shape rebuilt from an unedited projection. */
+declare const refingerprintShapeAlternateContent: (shape: Shape, verbatimXml: string) => ShapeAlternateContent;
+/**
+ * The captured `mc:AlternateContent` to write in place of the shape's drawing,
+ * or undefined when the shape must be regenerated.
+ *
+ * Replay requires the modeled shape to still match the capture. An edited shape
+ * is regenerated as a bare `w:drawing` without the stale Fallback.
+ */
+declare const replayableShapeAlternateContent: (content: ShapeContent) => string | undefined;
+//#endregion
+export { captureShapeAlternateContent, refingerprintShapeAlternateContent, replayableShapeAlternateContent };

package/dist/docx/shapeAlternateContent.js

@@ -0,0 +1,52 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { getChildElements, getLocalName } from "./xmlParser.js";
+//#region src/docx/shapeAlternateContent.ts
+/**
+* Every modeled field, text body included: the Fallback repeats the shape's
+* geometry and its text, so an edit to either makes the captured element stale.
+*/
+const shapeFingerprint = (shape) => canonicalJson(shape);
+/**
+* Whether `element` is the only child element of its `mc:Choice` or
+* `mc:Fallback` branch.
+*
+* A branch holding more than the one drawing cannot be written back by the
+* drawing's shape alone: the siblings are parsed into their own run content,
+* and replaying the whole element would write them twice.
+*/
+const isSoleBranchChild = (branch, element) => {
+	const children = getChildElements(branch);
+	return children.length === 1 && children[0] === element;
+};
+/**
+* Capture the `mc:AlternateContent` a shape was read from, when the shape's
+* drawing is the sole child of the branch it came from.
+*/
+const captureShapeAlternateContent = ({ shape, alternateContent, branch, drawing }) => {
+	if (getLocalName(alternateContent.name ?? "") !== "AlternateContent") return;
+	if (!isSoleBranchChild(branch, drawing)) return;
+	return {
+		verbatimXml: captureVerbatimXml(alternateContent),
+		verbatimFingerprint: shapeFingerprint(shape)
+	};
+};
+/** Re-fingerprint a capture for a shape rebuilt from an unedited projection. */
+const refingerprintShapeAlternateContent = (shape, verbatimXml) => ({
+	verbatimXml,
+	verbatimFingerprint: shapeFingerprint(shape)
+});
+/**
+* The captured `mc:AlternateContent` to write in place of the shape's drawing,
+* or undefined when the shape must be regenerated.
+*
+* Replay requires the modeled shape to still match the capture. An edited shape
+* is regenerated as a bare `w:drawing` without the stale Fallback.
+*/
+const replayableShapeAlternateContent = (content) => {
+	const captured = content.alternateContent;
+	if (captured === void 0) return;
+	return captured.verbatimFingerprint === shapeFingerprint(content.shape) ? captured.verbatimXml : void 0;
+};
+//#endregion
+export { captureShapeAlternateContent, refingerprintShapeAlternateContent, replayableShapeAlternateContent };

package/dist/docx/textBoxParser.d.ts

@@ -119,8 +119,16 @@ declare function resolveTextBoxOutlineColor(textBox: document_d_exports.TextBox)
  * Get outline width in pixels
  */
 declare function getTextBoxOutlineWidthPx(textBox: document_d_exports.TextBox): number;
+/** A text-box `w:drawing`, with the `mc:AlternateContent` branch it sits in, if any. */
+type TextBoxDrawing = {
+  drawing: XmlElement;
+  alternateContent?: {
+    element: XmlElement;
+    branch: XmlElement;
+  };
+};
 type TextBoxRunScan = {
-  textBoxDrawings: XmlElement[];
+  textBoxDrawings: TextBoxDrawing[];
   vmlTextBoxes: XmlElement[];
   hasNonTextBoxContent: boolean;
 };
@@ -143,4 +151,4 @@ type ScanRunForTextBoxDrawingsOptions = {
 };
 declare const scanRunForTextBoxDrawings: ({ xmlRun, claimedByRunParser }: ScanRunForTextBoxDrawingsOptions) => TextBoxRunScan;
 //#endregion
-export { ParagraphParserFn, ScanRunForTextBoxDrawingsOptions, TableParserFn, TextBoxRunScan, extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };
+export { ParagraphParserFn, ScanRunForTextBoxDrawingsOptions, TableParserFn, TextBoxDrawing, TextBoxRunScan, extractTextBoxContentElements, getTextBoxContentElement, getTextBoxDimensionsPx, getTextBoxHeightPx, getTextBoxMarginsPx, getTextBoxOutlineWidthPx, getTextBoxText, getTextBoxWidthPx, hasTextBoxContent, hasTextBoxFill, hasTextBoxOutline, isFloatingTextBox, isShapeTextBox, isTextBoxDrawing, parseTextBox, parseTextBoxContent, parseTextBoxFromShape, resolveTextBoxFillColor, resolveTextBoxOutlineColor, scanRunForTextBoxDrawings };

package/dist/docx/textBoxParser.js

@@ -328,9 +328,12 @@ const scanRunForTextBoxDrawings = ({ xmlRun, claimedByRunParser }) => {
 	const textBoxDrawings = [];
 	const vmlTextBoxes = [];
 	let hasNonTextBoxContent = false;
-	const visitDrawing = (drawingEl) => {
+	const visitDrawing = (drawingEl, alternateContent) => {
 		if (isTextBoxDrawing(drawingEl)) {
-			textBoxDrawings.push(drawingEl);
+			textBoxDrawings.push({
+				drawing: drawingEl,
+				...alternateContent === void 0 ? {} : { alternateContent }
+			});
 			return;
 		}
 		hasNonTextBoxContent = true;
@@ -355,7 +358,10 @@ const scanRunForTextBoxDrawings = ({ xmlRun, claimedByRunParser }) => {
 				if (!branch) return false;
 				let found = false;
 				for (const innerEl of getChildElements(branch)) if (getLocalName(innerEl.name ?? "") === "drawing") {
-					visitDrawing(innerEl);
+					visitDrawing(innerEl, {
+						element: el,
+						branch
+					});
 					found = true;
 				}
 				return found;

package/dist/export-pdf.d.ts

@@ -1,5 +1,5 @@
 import { DocxInput } from "./utils/docxInput.js";
-import { DisplayMetadata, DisplayUnsupported } from "./display-list/types.js";
+import { DisplayList, DisplayMetadata, DisplayUnsupported } from "./display-list/types.js";
 import { HeadlessFontSource, HeadlessFontSubstitution } from "./fonts/headlessMeasure.js";
 import { HeadlessLayoutGap } from "./headless-layout.js";
 import { PdfSubstitution } from "./pdf/fonts.js";
@@ -23,6 +23,11 @@ type ExportDocxToPdfOptions = {
   readonly timestamp: string;
   readonly metadata?: DisplayMetadata;
   readonly producer?: string;
+  /**
+   * 0-based indices of the pages to write, in order. Links and outline
+   * entries to other pages are dropped. Omit for every page.
+   */
+  readonly pages?: readonly number[];
 };
 type ExportDocxToPdfResult = {
   readonly bytes: Uint8Array;
@@ -38,6 +43,34 @@ type ExportDocxToPdfResult = {
   /** Code points painted as `.notdef` because no supplied face covers them. */
   readonly unencodable: readonly PdfUnencodable[];
 };
+type BuildDocxDisplayListOptions = {
+  /** Supplies face binaries for measurement. */
+  readonly fonts: HeadlessFontSource;
+  readonly metadata?: DisplayMetadata;
+};
+type BuildDocxDisplayListResult = {
+  /** The pages every backend paints: the PDF writer, the DOM and HTML backends. */
+  readonly list: DisplayList;
+  /** Stories the headless pipeline does not paginate. */
+  readonly layoutGaps: readonly HeadlessLayoutGap[];
+  /** Faces measured with a stand-in. */
+  readonly measurementSubstitutions: readonly HeadlessFontSubstitution[];
+};
+/**
+ * Lay a package out headlessly and build its display list: the one structure
+ * the PDF writer and the DOM backend both paint. Runs one at a time with
+ * every other headless build and export, for the reason
+ * {@link runExclusively} gives.
+ */
+declare const buildDocxDisplayList: (input: DocxInput, options: BuildDocxDisplayListOptions) => Promise<Result<BuildDocxDisplayListResult, ExportPdfError>>;
 declare const exportDocxToPdf: (input: DocxInput, options: ExportDocxToPdfOptions) => Promise<Result<ExportDocxToPdfResult, ExportPdfError>>;
+type WriteDisplayListPdfOptions = Pick<ExportDocxToPdfOptions, "fonts" | "timestamp" | "producer">;
+type WriteDisplayListPdfResult = Pick<ExportDocxToPdfResult, "bytes" | "pageCount" | "embeddingSubstitutions" | "unencodable">;
+/**
+ * Write a display list built by {@link buildDocxDisplayList} (or narrowed by
+ * `selectDisplayPages`) as a PDF, embedding faces from the same source the
+ * layout measured with.
+ */
+declare const writeDisplayListPdf: (list: DisplayList, options: WriteDisplayListPdfOptions) => Promise<Result<WriteDisplayListPdfResult, ExportPdfError>>;
 //#endregion
-export { ExportDocxToPdfOptions, ExportDocxToPdfResult, ExportPdfError, exportDocxToPdf };
+export { BuildDocxDisplayListOptions, BuildDocxDisplayListResult, ExportDocxToPdfOptions, ExportDocxToPdfResult, ExportPdfError, WriteDisplayListPdfOptions, WriteDisplayListPdfResult, buildDocxDisplayList, exportDocxToPdf, writeDisplayListPdf };

package/dist/export-pdf.js

@@ -1,5 +1,6 @@
 import { buildDisplayList } from "./display-list/build/buildDisplayList.js";
 import { displayCommentsFrom } from "./display-list/build/commentAnnotations.js";
+import { selectDisplayPages } from "./display-list/selectDisplayPages.js";
 import { installHeadlessMeasureProvider } from "./fonts/headlessMeasure.js";
 import { layoutDocxHeadless } from "./headless-layout.js";
 import { getMeasureProvider, setMeasureProvider } from "./layout-engine/measure/measureProvider.js";
@@ -52,16 +53,59 @@ const runExclusively = (run) => {
 	exportQueue = current.then(() => void 0, () => void 0);
 	return current;
 };
-const exportDocxToPdf = (input, options) => runExclusively(() => exportOnce(input, options));
-const exportOnce = async (input, options) => {
+/**
+* Lay a package out headlessly and build its display list: the one structure
+* the PDF writer and the DOM backend both paint. Runs one at a time with
+* every other headless build and export, for the reason
+* {@link runExclusively} gives.
+*/
+const buildDocxDisplayList = (input, options) => runExclusively(async () => {
 	const callerProvider = getMeasureProvider();
 	try {
-		return await exportWithHeadlessProvider(input, options);
+		return await buildWithHeadlessProvider(input, options);
 	} finally {
 		setMeasureProvider(callerProvider);
 	}
+});
+const exportDocxToPdf = async (input, options) => {
+	const built = await buildDocxDisplayList(input, {
+		fonts: options.fonts,
+		...options.metadata === void 0 ? {} : { metadata: options.metadata }
+	});
+	if (built.isErr()) return Result.err(built.error);
+	const list = options.pages === void 0 ? built.value.list : selectDisplayPages(built.value.list, options.pages);
+	const written = await writeDisplayListPdf(list, options);
+	if (written.isErr()) return Result.err(written.error);
+	return Result.ok({
+		...written.value,
+		unsupported: list.unsupported,
+		layoutGaps: built.value.layoutGaps,
+		measurementSubstitutions: built.value.measurementSubstitutions
+	});
+};
+/**
+* Write a display list built by {@link buildDocxDisplayList} (or narrowed by
+* `selectDisplayPages`) as a PDF, embedding faces from the same source the
+* layout measured with.
+*/
+const writeDisplayListPdf = async (list, options) => {
+	const written = await writePdf(list, {
+		fonts: { load: (face) => options.fonts.load(toFontRequest(face)) },
+		timestamp: options.timestamp,
+		...options.producer === void 0 ? {} : { producer: options.producer }
+	});
+	if (written.isErr()) return Result.err(new ExportPdfError({
+		message: written.error.message,
+		cause: written.error
+	}));
+	return Result.ok({
+		bytes: written.value.bytes,
+		pageCount: list.pages.length,
+		embeddingSubstitutions: written.value.substitutions,
+		unencodable: written.value.unencodable
+	});
 };
-const exportWithHeadlessProvider = async (input, options) => {
+const buildWithHeadlessProvider = async (input, options) => {
 	const headless = installHeadlessMeasureProvider(options.fonts);
 	const laidOut = await layoutDocxHeadless(input, { pageGap: 0 });
 	if (laidOut.isErr()) return Result.err(new ExportPdfError({
@@ -77,24 +121,11 @@ const exportWithHeadlessProvider = async (input, options) => {
 		...laidOut.value.document.package.document.comments === void 0 ? {} : { comments: displayCommentsFrom(laidOut.value.document.package.document.comments) },
 		...options.metadata === void 0 ? {} : { metadata: options.metadata }
 	});
-	const written = await writePdf(list, {
-		fonts: { load: (face) => options.fonts.load(toFontRequest(face)) },
-		timestamp: options.timestamp,
-		...options.producer === void 0 ? {} : { producer: options.producer }
-	});
-	if (written.isErr()) return Result.err(new ExportPdfError({
-		message: written.error.message,
-		cause: written.error
-	}));
 	return Result.ok({
-		bytes: written.value.bytes,
-		pageCount: list.pages.length,
-		unsupported: list.unsupported,
+		list,
 		layoutGaps: laidOut.value.unsupported,
-		measurementSubstitutions: headless.substitutions(),
-		embeddingSubstitutions: written.value.substitutions,
-		unencodable: written.value.unencodable
+		measurementSubstitutions: headless.substitutions()
 	});
 };
 //#endregion
-export { ExportPdfError, exportDocxToPdf };
+export { ExportPdfError, buildDocxDisplayList, exportDocxToPdf, writeDisplayListPdf };

package/dist/fonts/fontsourceFaces.d.ts

@@ -0,0 +1,47 @@
+import { HeadlessFontSource } from "./headlessMeasure.js";
+//#region src/fonts/fontsourceFaces.d.ts
+/** Where `@fontsource` files come from: `null` when the package or file is absent. */
+type FontsourceFiles = {
+  /** Bytes of `@fontsource/<packageName>/<relativePath>`. */
+  readonly read: (packageName: string, relativePath: string) => Uint8Array | null;
+};
+/** Each bundled family and the `@fontsource` package that ships it. */
+declare const FONTSOURCE_PACKAGES: {
+  readonly Arimo: "arimo";
+  readonly Caladea: "caladea";
+  readonly Carlito: "carlito";
+  readonly Cousine: "cousine";
+  readonly Lato: "lato";
+  readonly "Noto Sans Arabic": "noto-sans-arabic";
+  readonly "Source Sans 3": "source-sans-3";
+  readonly Tinos: "tinos";
+};
+/**
+ * A CSS `<string>` token, quoted and escaped. A family name comes from an
+ * authored document and is emitted into a `<style>` element, so the
+ * backslash is escaped first, then the quote, and line terminators become hex
+ * escapes, which CSS strings require.
+ */
+declare const cssString: (value: string) => string;
+type FontsourceFontFaceCssOptions = {
+  /**
+   * Families to declare beyond the names the faces answer to directly. Pass a
+   * display list's own `fonts` families: a face reached through the fallback
+   * chain has no rule of its own, and the page names it by its authored name.
+   */
+  readonly families?: readonly string[];
+};
+type FontsourceFaces = {
+  /** Binaries for the headless measurer and the PDF writer. */
+  readonly source: HeadlessFontSource;
+  /**
+   * `@font-face` rules with the `.woff` bytes inlined as `data:` URLs, one
+   * rule per served subset of each face, so a browser paints each code point
+   * from the binary that was measured.
+   */
+  readonly fontFaceCss: (options?: FontsourceFontFaceCssOptions) => string;
+};
+/** The `@fontsource` faces, read through `files` and cached per face. */
+declare const createFontsourceFaces: (files: FontsourceFiles) => FontsourceFaces;
+//#endregion
+export { FONTSOURCE_PACKAGES, FontsourceFaces, FontsourceFiles, FontsourceFontFaceCssOptions, createFontsourceFaces, cssString };

package/dist/fonts/fontsourceFaces.js

@@ -0,0 +1,230 @@
+import { bytesToDataUrl } from "../utils/base64.js";
+import { FONT_MAPPING } from "../utils/fontLoader.js";
+import { parseFontFamilyList, resolveFontFamily } from "../utils/fontResolver.js";
+//#region src/fonts/fontsourceFaces.ts
+/**
+* The subsets served, in resolution priority: a code point two subsets cover
+* resolves to the earlier one on both sides.
+*/
+const SUBSET_PRIORITY = [
+	"latin",
+	"latin-ext",
+	"arabic"
+];
+/** Folio paints 400 and 700 only, as `DisplayFontFace` states. */
+const REGULAR_WEIGHT = 400;
+const BOLD_WEIGHT = 700;
+/** Each bundled family and the `@fontsource` package that ships it. */
+const FONTSOURCE_PACKAGES = {
+	Arimo: "arimo",
+	Caladea: "caladea",
+	Carlito: "carlito",
+	Cousine: "cousine",
+	Lato: "lato",
+	"Noto Sans Arabic": "noto-sans-arabic",
+	"Source Sans 3": "source-sans-3",
+	Tinos: "tinos"
+};
+/** A CSS stack ends in a generic, so a generic must resolve to a bundled family too. */
+const GENERIC_FAMILIES = {
+	serif: "Tinos",
+	"sans-serif": "Arimo",
+	monospace: "Cousine"
+};
+const isBundledFamily = (name) => Object.hasOwn(FONTSOURCE_PACKAGES, name);
+const isGenericFamily = (name) => Object.hasOwn(GENERIC_FAMILIES, name);
+/** Every name a bundled family answers to: its own, and the authored names mapped to it. */
+const familyIndexEntries = () => {
+	const entries = [];
+	for (const family of Object.keys(FONTSOURCE_PACKAGES)) if (isBundledFamily(family)) entries.push([family.toLowerCase(), family]);
+	for (const [authored, mapped] of Object.entries(FONT_MAPPING)) {
+		if (isBundledFamily(mapped)) {
+			entries.push([authored.toLowerCase(), mapped]);
+			continue;
+		}
+		if (isGenericFamily(mapped)) entries.push([authored.toLowerCase(), GENERIC_FAMILIES[mapped]]);
+	}
+	for (const [generic, bundled] of Object.entries(GENERIC_FAMILIES)) entries.push([generic, bundled]);
+	return entries;
+};
+const FAMILY_INDEX = new Map(familyIndexEntries());
+/** Every family name the faces answer to, in a stable order for the CSS. */
+const bundledFamilyAliases = () => [...Object.keys(FONTSOURCE_PACKAGES), ...Object.keys(FONT_MAPPING).filter((authored) => FAMILY_INDEX.has(authored.toLowerCase()))].sort((a, b) => a.localeCompare(b, "en"));
+/**
+* The bundled family a requested name resolves to: directly, or through the
+* same fallback chain the editor's font resolver walks.
+*/
+const resolveBundledFamily = (family) => {
+	const direct = FAMILY_INDEX.get(family.trim().toLowerCase());
+	if (direct !== void 0) return direct;
+	for (const candidate of parseFontFamilyList(resolveFontFamily(family).cssFallback)) {
+		const resolved = FAMILY_INDEX.get(candidate.trim().toLowerCase());
+		if (resolved !== void 0) return resolved;
+	}
+	return null;
+};
+const weightOf = (bold) => bold ? BOLD_WEIGHT : REGULAR_WEIGHT;
+/** `@fontsource` ships the ranges it cut each subset with, beside the files. */
+const UNICODE_RANGE_FILE = "unicode.json";
+const RANGE_TOKEN_RE = /^U\+([0-9A-Fa-f]+)(?:-([0-9A-Fa-f]+))?$/u;
+const parseRangeToken = (token) => {
+	const match = RANGE_TOKEN_RE.exec(token.trim());
+	if (match === null) return [];
+	const first = Number.parseInt(match[1] ?? "", 16);
+	const last = match[2] === void 0 ? first : Number.parseInt(match[2], 16);
+	if (Number.isNaN(first) || Number.isNaN(last)) return [];
+	return [[first, last]];
+};
+const parseRangeList = (declared) => declared.split(",").flatMap(parseRangeToken);
+const parseDeclaredRanges = (bytes) => {
+	const ranges = /* @__PURE__ */ new Map();
+	const parsed = JSON.parse(new TextDecoder().decode(bytes));
+	if (typeof parsed !== "object" || parsed === null) return ranges;
+	for (const [subset, declared] of Object.entries(parsed)) if (typeof declared === "string") ranges.set(subset, parseRangeList(declared));
+	return ranges;
+};
+const withoutRange = (range, [start, end]) => {
+	const [first, last] = range;
+	if (end < first || start > last) return [range];
+	const remainder = [];
+	if (start > first) remainder.push([first, start - 1]);
+	if (end < last) remainder.push([end + 1, last]);
+	return remainder;
+};
+/**
+* `subject` minus everything a higher-priority subset already serves. The
+* declared ranges overlap (`latin` and `latin-ext` both claim some combining
+* marks); cutting the overlap out of the lower-priority rule makes a browser,
+* which resolves an overlap by declaration order, agree with this table.
+*/
+const subtractRanges = (subject, taken) => {
+	let remaining = subject;
+	for (const range of taken) remaining = remaining.flatMap((candidate) => withoutRange(candidate, range));
+	return remaining;
+};
+const hex = (codePoint) => codePoint.toString(16).toUpperCase().padStart(4, "0");
+const formatRangeList = (ranges) => ranges.map(([first, last]) => first === last ? `U+${hex(first)}` : `U+${hex(first)}-${hex(last)}`).join(",");
+/**
+* A CSS `<string>` token, quoted and escaped. A family name comes from an
+* authored document and is emitted into a `<style>` element, so the
+* backslash is escaped first, then the quote, and line terminators become hex
+* escapes, which CSS strings require.
+*/
+const cssString = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\A ").replaceAll("\r", "\\D ").replaceAll("\f", "\\C ")}"`;
+const FACE_VARIANTS = [
+	{
+		weight: REGULAR_WEIGHT,
+		italic: false
+	},
+	{
+		weight: REGULAR_WEIGHT,
+		italic: true
+	},
+	{
+		weight: BOLD_WEIGHT,
+		italic: false
+	},
+	{
+		weight: BOLD_WEIGHT,
+		italic: true
+	}
+];
+/** The media type a `.woff` face is inlined under. */
+const WOFF_MEDIA_TYPE = "font/woff";
+const fontFaceRule = ({ family, dataUrl, weight, italic, unicodeRange }) => [
+	"@font-face {",
+	`  font-family: ${cssString(family)};`,
+	`  src: url(${dataUrl}) format("woff");`,
+	`  font-weight: ${String(weight)};`,
+	`  font-style: ${italic ? "italic" : "normal"};`,
+	`  unicode-range: ${formatRangeList(unicodeRange)};`,
+	"  font-display: block;",
+	"}"
+].join("\n");
+/** The `@fontsource` faces, read through `files` and cached per face. */
+const createFontsourceFaces = (files) => {
+	const faceCache = /* @__PURE__ */ new Map();
+	const rangeCache = /* @__PURE__ */ new Map();
+	const dataUrlCache = /* @__PURE__ */ new Map();
+	const faceBinaries = ({ family, weight, italic }) => {
+		const bundled = resolveBundledFamily(family);
+		if (bundled === null) return [];
+		const packageName = FONTSOURCE_PACKAGES[bundled];
+		const style = italic ? "italic" : "normal";
+		const key = `${packageName}|${String(weight)}|${style}`;
+		const cached = faceCache.get(key);
+		if (cached !== void 0) return cached;
+		const binaries = SUBSET_PRIORITY.flatMap((subset) => {
+			const bytes = files.read(packageName, `files/${packageName}-${subset}-${String(weight)}-${style}.woff`);
+			return bytes === null ? [] : [{
+				subset,
+				bytes
+			}];
+		});
+		faceCache.set(key, binaries);
+		return binaries;
+	};
+	const declaredRanges = (packageName) => {
+		const cached = rangeCache.get(packageName);
+		if (cached !== void 0) return cached;
+		const bytes = files.read(packageName, UNICODE_RANGE_FILE);
+		const ranges = bytes === null ? /* @__PURE__ */ new Map() : parseDeclaredRanges(bytes);
+		rangeCache.set(packageName, ranges);
+		return ranges;
+	};
+	const dataUrlOf = (bytes) => {
+		const cached = dataUrlCache.get(bytes);
+		if (cached !== void 0) return cached;
+		const encoded = bytesToDataUrl(bytes, WOFF_MEDIA_TYPE);
+		dataUrlCache.set(bytes, encoded);
+		return encoded;
+	};
+	/**
+	* The rules for one variant of one family name. A subset whose range a
+	* higher-priority subset already serves, or that `unicode.json` does not
+	* describe, is not declared: a rule with no `unicode-range` would cover
+	* every code point.
+	*/
+	const variantRules = ({ family, weight, italic }) => {
+		const bundled = resolveBundledFamily(family);
+		if (bundled === null) return [];
+		const ranges = declaredRanges(FONTSOURCE_PACKAGES[bundled]);
+		const rules = [];
+		const taken = [];
+		for (const binary of faceBinaries({
+			family,
+			weight,
+			italic
+		})) {
+			const unicodeRange = subtractRanges(ranges.get(binary.subset) ?? [], taken);
+			if (unicodeRange.length === 0) continue;
+			rules.push(fontFaceRule({
+				family,
+				dataUrl: dataUrlOf(binary.bytes),
+				weight,
+				italic,
+				unicodeRange
+			}));
+			taken.push(...unicodeRange);
+		}
+		return rules;
+	};
+	return {
+		source: { load: ({ family, bold, italic }) => faceBinaries({
+			family,
+			weight: weightOf(bold),
+			italic
+		}).map(({ bytes }) => bytes) },
+		fontFaceCss: (options = {}) => {
+			const declared = /* @__PURE__ */ new Map();
+			for (const family of [...bundledFamilyAliases(), ...options.families ?? []]) declared.set(family.trim().toLowerCase(), family.trim());
+			return [...declared.values()].flatMap((family) => FACE_VARIANTS.flatMap(({ weight, italic }) => variantRules({
+				family,
+				weight,
+				italic
+			}))).join("\n");
+		}
+	};
+};
+//#endregion
+export { FONTSOURCE_PACKAGES, createFontsourceFaces, cssString };

package/dist/internal/headlessRevisionResolution.js

@@ -1,6 +1,8 @@
 import { recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { resolutionRemovesControl, withoutResolvedEnclosures } from "../prosemirror/contentControlRevisions.js";
 import "../prosemirror/extensions/nodes/SdtExtension.js";
+import { continuedRunMarks } from "../prosemirror/rejoinRunCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../prosemirror/runFormattingMarkNames.js";
 import { reconstructRejectedRunFormattingMarks } from "../prosemirror/runPropertyChangeResolution.js";
 import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
@@ -75,8 +77,26 @@ const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	if (context.keepType) marks = marks.filter((mark) => mark.type !== context.keepType);
 	return marksEqual(marks, node.marks) ? node : node.mark(marks);
 };
+/**
+* The pieces a revision split off its run, one run again: the headless half of
+* `rejoinRunsAt`, over the children of one inline container.
+*/
+const rejoinResolvedRuns = ({ children, resolvedBoundaries, paragraphScope, context }) => {
+	for (const index of [...resolvedBoundaries].toSorted((left, right) => left - right)) {
+		const left = children[index - 1];
+		const right = children[index];
+		if (!left || !right) continue;
+		const marks = continuedRunMarks({
+			left,
+			right,
+			context: () => resolveParagraphRunStyleScope(paragraphScope, context.styleResolver),
+			styleResolver: context.styleResolver
+		});
+		if (marks !== null) children[index] = right.mark(marks);
+	}
+};
 const resolveInlineContent = ({ node, position, context, inheritedParagraphScope }) => {
-	const paragraphScope = node.type.name === "paragraph" && context.mode === "reject" ? { paragraph: node } : inheritedParagraphScope;
+	const paragraphScope = node.type.name === "paragraph" ? { paragraph: node } : inheritedParagraphScope;
 	const replacementRangeStart = context.replacementRanges.length;
 	let resolvedNode = node;
 	if (node.isInline) {
@@ -96,7 +116,21 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		resolvedNode = resolved;
 		if (resolvedNode.isLeaf) return resolvedNode;
 	}
+	if (resolutionRemovesControl({
+		control: resolvedNode,
+		removeType: context.removeType,
+		resolves: () => true
+	})) {
+		context.replacementRanges.push({
+			from: position,
+			to: position + node.nodeSize,
+			newSize: 0
+		});
+		return null;
+	}
 	const children = [];
+	/** Indices into `children` where resolved content began or ended. */
+	const resolvedBoundaries = /* @__PURE__ */ new Set();
 	const contentStart = resolvedNode.type.name === "doc" ? 0 : position + 1;
 	let contentChanged = false;
 	resolvedNode.forEach((child, offset) => {
@@ -106,20 +140,23 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 			context,
 			...paragraphScope !== void 0 ? { inheritedParagraphScope: paragraphScope } : {}
 		});
+		if (resolved !== child) {
+			contentChanged = true;
+			resolvedBoundaries.add(children.length);
+		}
 		if (resolved) {
 			children.push(resolved);
-			contentChanged ||= resolved !== child;
-		} else contentChanged = true;
+			if (resolved !== child) resolvedBoundaries.add(children.length);
+		}
+	});
+	const resolvedAttrs = resolvedNode.type.name === "sdt" ? withoutResolvedEnclosures(resolvedNode, () => true) ?? resolvedNode.attrs : resolvedNode.attrs;
+	if (!contentChanged && resolvedAttrs === resolvedNode.attrs) return resolvedNode;
+	if (contentChanged && resolvedNode.inlineContent) rejoinResolvedRuns({
+		children,
+		resolvedBoundaries,
+		paragraphScope,
+		context
 	});
-	if (!contentChanged) return resolvedNode;
-	if (children.length === 0 && node.childCount > 0 && resolvedNode.type.name === "sdt") {
-		context.replacementRanges.splice(replacementRangeStart, context.replacementRanges.length - replacementRangeStart, {
-			from: position,
-			to: position + node.nodeSize,
-			newSize: 0
-		});
-		return null;
-	}
 	let resolvedContent = Fragment.fromArray(children);
 	if (!resolvedNode.type.validContent(resolvedContent)) {
 		const fitted = resolvedNode.type.createAndFill(resolvedNode.attrs, resolvedContent, resolvedNode.marks);
@@ -143,7 +180,7 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		from: position,
 		to: position + resolvedNode.nodeSize
 	});
-	return rebuildNode(node, resolvedNode.attrs, resolvedContent, resolvedNode.marks);
+	return rebuildNode(node, resolvedAttrs, resolvedContent, resolvedNode.marks);
 };
 const coalesceReplacementRanges = (replacementRanges) => {
 	const coalesced = [];

package/dist/layout-bridge/convert/flowBlockPostprocessing.d.ts

@@ -0,0 +1,8 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+//#region src/layout-bridge/convert/flowBlockPostprocessing.d.ts
+declare function suppressFinalEmptyParagraphAfterTable(blocks: FlowBlock[]): void;
+declare function suppressFinalParagraphInRepeatedEmptySuffix(blocks: FlowBlock[]): void;
+declare function reserveLeadingEmptyOutlineHeight(blocks: FlowBlock[]): void;
+declare function mergeRunInParagraphs(blocks: FlowBlock[]): FlowBlock[];
+//#endregion
+export { mergeRunInParagraphs, reserveLeadingEmptyOutlineHeight, suppressFinalEmptyParagraphAfterTable, suppressFinalParagraphInRepeatedEmptySuffix };