@stll/folio-core 0.48.0 → 0.49.0

package/dist/ai-edits/minimal-replacement.d.ts

@@ -0,0 +1,64 @@
+import { WordDiffSegment } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.d.ts
+/** Replace `source.slice(start, end)` with `text`; offsets index the source span. */
+type TextChange = {
+  start: number;
+  end: number;
+  text: string;
+};
+/** A clean-text span that can only be replaced whole (a field result). */
+type AtomicTextSpan = {
+  offset: number;
+  length: number;
+};
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+declare const commonPrefixLength: (a: string, b: string) => number;
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+declare const commonSuffixLength: (a: string, b: string) => number;
+/**
+ * Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+ * at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+ * nothing of its source worth aligning to anyway.
+ */
+declare const MAX_TOKEN_EDITS = 1024;
+/**
+ * The shortest edit script between two token sequences (Myers, 1986), as
+ * segments of joined token text, or `null` past `maxEdits` edits.
+ *
+ * Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+ * short matches between changes so a reader sees whole phrases replaced; an
+ * edit applied directly has no reader to serve, and every token it gives up is
+ * text rewritten with someone else's formatting.
+ */
+declare const shortestTokenDiff: (before: readonly string[], after: readonly string[], maxEdits?: number) => WordDiffSegment[] | null;
+/**
+ * The changes from `source` to `replacement`, in source order and disjoint.
+ *
+ * Words (with their leading whitespace, and edge punctuation on its own; see
+ * `tokenizeWords`) are aligned by the shortest edit script, and each changed
+ * stretch is then trimmed to the characters that actually differ, so
+ * appending a letter to a word that spans two runs leaves both runs alone. A
+ * rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+ * both strings exactly (it never should), is one change over the whole span,
+ * trimmed the same way.
+ */
+declare const planTextChanges: (source: string, replacement: string) => TextChange[];
+/**
+ * The changes a diff's segments describe, in source order and disjoint: each
+ * run of `del` and `ins` segments between two `equal` ones is one change,
+ * exactly as wide as the segments say. A redline's segments come cut to the
+ * granularity its reader asked for, so they are not trimmed further.
+ */
+declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => TextChange[];
+/**
+ * `changes` widened so none cuts into an atomic span, then merged where the
+ * widening made two overlap. A widened change re-emits the source text it
+ * absorbed, so applying the result still yields exactly the replacement.
+ *
+ * `spans` are in the same coordinates as the changes (the source span's).
+ */
+declare const widenChangesToAtomicSpans: (source: string, changes: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
+/** `source` with `changes` applied; the invariant the planner owes. */
+declare const applyTextChanges: (source: string, changes: readonly TextChange[]) => string;
+//#endregion
+export { AtomicTextSpan, MAX_TOKEN_EDITS, TextChange, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/ai-edits/minimal-replacement.js

@@ -0,0 +1,282 @@
+import { tokenizeWords } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.ts
+/**
+* The smallest set of text changes that turns one clean-text span into another.
+*
+* A direct-mode replacement (`replaceInBlock`, `replaceRange`, `replaceBlock`)
+* names the text it matched and the text it wants. Swapping the whole match
+* gives every character of the result the formatting of the first one, drops
+* the inline content controls, note references and fields the match crossed,
+* and makes a one-character edit rewrite the paragraph. The edit is the
+* difference between the two strings, so that is all the applier writes:
+*
+* - Text outside a change is not touched: its runs, marks and every inline node
+*   between its characters stay exactly as they were.
+* - A change deletes only the characters it removes (text, tabs, breaks and
+*   whole field results). Non-text inline content between those characters —
+*   bookmarks, comment anchors, drawings, content-control boundaries, rendered
+*   page breaks — stays where it was; the new text is written where the first
+*   removed character stood and takes its formatting.
+* - A pure insertion follows the character before it, with the formatting that
+*   character has, the way typed text does. At the start of the matched span
+*   there is no such character inside the match, so it takes the formatting of
+*   the first matched character. A note reference's number lends no
+*   formatting: prose beside it is not superscript.
+* - An insertion at the edge of an inline content control (`w:sdt`), a link or
+*   a comment range stays inside it only when the whole match lies inside it.
+*   Matching a control's or a link's text edits it; appending to a paragraph
+*   that ends in a checkbox or a link writes after it.
+* - A field result is one unit: a change that would cut into it is widened to
+*   the whole result, which the new text then replaces as plain text (a result
+*   cannot be partly edited; it is regenerated from the field code). A field
+*   whose displayed text the replacement keeps is never touched. A match that
+*   itself starts or ends inside a field result is refused as before
+*   (`unsupportedBlock`).
+*
+* A replacement carrying inline emphasis markup (`**bold**`) states its own
+* formatting and still replaces the match whole in direct mode.
+*
+* Tracked-changes and suggested modes cut their changes from the redline diff
+* instead ({@link changesFromSegments}: word or character granularity, as the
+* caller asked), and map them onto the document by the same rules. A change
+* marks exactly the characters it removes as a deletion, which keeps their
+* runs, and writes its text as an insertion after them, formatted as the
+* first removed character that is not a note reference; a pure insertion is
+* placed and formatted as above. Nothing outside a change is wrapped in a
+* revision.
+*
+* This module is the pure half: clean-text offsets in, changes out. The
+* applier maps each change onto the document.
+*/
+const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+const commonPrefixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let index = 0;
+	while (index < limit && a.charCodeAt(index) === b.charCodeAt(index)) index++;
+	return index > 0 && isHighSurrogate(a.charCodeAt(index - 1)) ? index - 1 : index;
+};
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+const commonSuffixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let length = 0;
+	while (length < limit && a.charCodeAt(a.length - 1 - length) === b.charCodeAt(b.length - 1 - length)) length++;
+	return length > 0 && isLowSurrogate(a.charCodeAt(a.length - length)) ? length - 1 : length;
+};
+/** `change` without the characters its deleted and inserted text share at either end. */
+const trimChange = (source, change) => {
+	const removed = source.slice(change.start, change.end);
+	const prefix = commonPrefixLength(removed, change.text);
+	const suffix = commonSuffixLength(removed.slice(prefix), change.text.slice(prefix));
+	const trimmed = {
+		start: change.start + prefix,
+		end: change.end - suffix,
+		text: change.text.slice(prefix, change.text.length - suffix)
+	};
+	return trimmed.start === trimmed.end && trimmed.text.length === 0 ? null : trimmed;
+};
+const reconstructs = (segments, source, replacement) => {
+	let before = "";
+	let after = "";
+	for (const segment of segments) {
+		if (segment.type !== "ins") before += segment.text;
+		if (segment.type !== "del") after += segment.text;
+	}
+	return before === source && after === replacement;
+};
+/**
+* Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+* at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+* nothing of its source worth aligning to anyway.
+*/
+const MAX_TOKEN_EDITS = 1024;
+/**
+* The shortest edit script between two token sequences (Myers, 1986), as
+* segments of joined token text, or `null` past `maxEdits` edits.
+*
+* Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+* short matches between changes so a reader sees whole phrases replaced; an
+* edit applied directly has no reader to serve, and every token it gives up is
+* text rewritten with someone else's formatting.
+*/
+const shortestTokenDiff = (before, after, maxEdits = MAX_TOKEN_EDITS) => {
+	const n = before.length;
+	const m = after.length;
+	const limit = Math.min(n + m, maxEdits);
+	const offset = limit + 1;
+	const frontier = new Int32Array(2 * limit + 3);
+	const trace = [];
+	let edits = -1;
+	search: for (let d = 0; d <= limit; d++) {
+		trace.push(frontier.slice(offset - d, offset + d + 1));
+		for (let k = -d; k <= d; k += 2) {
+			let x = k === -d || k !== d && frontier[offset + k - 1] < frontier[offset + k + 1] ? frontier[offset + k + 1] : frontier[offset + k - 1] + 1;
+			let y = x - k;
+			while (x < n && y < m && before[x] === after[y]) {
+				x++;
+				y++;
+			}
+			frontier[offset + k] = x;
+			if (x >= n && y >= m) {
+				edits = d;
+				break search;
+			}
+		}
+	}
+	if (edits < 0) return null;
+	const reversed = [];
+	const push = (type, text) => {
+		const last = reversed.at(-1);
+		if (last?.type === type) last.text = text + last.text;
+		else reversed.push({
+			type,
+			text
+		});
+	};
+	let x = n;
+	let y = m;
+	for (let d = edits; d > 0; d--) {
+		const previous = trace[d];
+		const at = (diagonal) => previous[diagonal + d];
+		const k = x - y;
+		const down = k === -d || k !== d && at(k - 1) < at(k + 1);
+		const previousK = down ? k + 1 : k - 1;
+		const previousX = at(previousK);
+		const previousY = previousX - previousK;
+		while (x > previousX && y > previousY) {
+			x--;
+			y--;
+			push("equal", before[x]);
+		}
+		if (down) {
+			y--;
+			push("ins", after[y]);
+		} else {
+			x--;
+			push("del", before[x]);
+		}
+	}
+	while (x > 0 && y > 0) {
+		x--;
+		y--;
+		push("equal", before[x]);
+	}
+	return reversed.toReversed();
+};
+/**
+* The changes from `source` to `replacement`, in source order and disjoint.
+*
+* Words (with their leading whitespace, and edge punctuation on its own; see
+* `tokenizeWords`) are aligned by the shortest edit script, and each changed
+* stretch is then trimmed to the characters that actually differ, so
+* appending a letter to a word that spans two runs leaves both runs alone. A
+* rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+* both strings exactly (it never should), is one change over the whole span,
+* trimmed the same way.
+*/
+const planTextChanges = (source, replacement) => {
+	if (source === replacement) return [];
+	const diffed = shortestTokenDiff(tokenizeWords(source), tokenizeWords(replacement));
+	const segments = diffed !== null && reconstructs(diffed, source, replacement) ? diffed : [{
+		type: "del",
+		text: source
+	}, {
+		type: "ins",
+		text: replacement
+	}];
+	return changesFromSegments(segments).flatMap((change) => trimChange(source, change) ?? []);
+};
+/**
+* The changes a diff's segments describe, in source order and disjoint: each
+* run of `del` and `ins` segments between two `equal` ones is one change,
+* exactly as wide as the segments say. A redline's segments come cut to the
+* granularity its reader asked for, so they are not trimmed further.
+*/
+const changesFromSegments = (segments) => {
+	const changes = [];
+	let cursor = 0;
+	let pending = null;
+	for (const segment of segments) {
+		if (segment.type === "equal") {
+			if (pending !== null) {
+				changes.push(pending);
+				pending = null;
+			}
+			cursor += segment.text.length;
+			continue;
+		}
+		pending ??= {
+			start: cursor,
+			end: cursor,
+			text: ""
+		};
+		if (segment.type === "del") {
+			cursor += segment.text.length;
+			pending.end = cursor;
+		} else pending.text += segment.text;
+	}
+	if (pending !== null) changes.push(pending);
+	return changes;
+};
+const cutsInto = ({ offset, length }, position) => position > offset && position < offset + length;
+/**
+* `changes` widened so none cuts into an atomic span, then merged where the
+* widening made two overlap. A widened change re-emits the source text it
+* absorbed, so applying the result still yields exactly the replacement.
+*
+* `spans` are in the same coordinates as the changes (the source span's).
+*/
+const widenChangesToAtomicSpans = (source, changes, spans) => {
+	if (spans.length === 0 || changes.length === 0) return [...changes];
+	const windows = changes.map(({ start, end }) => {
+		let from = start;
+		let to = end;
+		for (const span of spans) {
+			if (cutsInto(span, from)) from = span.offset;
+			if (cutsInto(span, to)) to = span.offset + span.length;
+		}
+		return {
+			from,
+			to
+		};
+	});
+	const merged = [];
+	let index = 0;
+	while (index < changes.length) {
+		const { from } = windows[index];
+		let { to } = windows[index];
+		const group = [changes[index]];
+		index++;
+		while (index < changes.length && windows[index].from < to) {
+			to = Math.max(to, windows[index].to);
+			group.push(changes[index]);
+			index++;
+		}
+		let text = "";
+		let cursor = from;
+		for (const change of group) {
+			text += source.slice(cursor, change.start) + change.text;
+			cursor = change.end;
+		}
+		text += source.slice(cursor, to);
+		merged.push({
+			start: from,
+			end: to,
+			text
+		});
+	}
+	return merged;
+};
+/** `source` with `changes` applied; the invariant the planner owes. */
+const applyTextChanges = (source, changes) => {
+	let result = "";
+	let cursor = 0;
+	for (const change of changes) {
+		result += source.slice(cursor, change.start) + change.text;
+		cursor = change.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+export { MAX_TOKEN_EDITS, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/controller/layoutPipeline.js

@@ -230,6 +230,15 @@ function runLayoutPipelineMeasured(deps, state, options) {
 				preparedFooter: refs.footerEven ? footerContentByRId?.get(refs.footerEven) : void 0
 			});
 		});
+		const sectionFirstPageMargins = sectionHeaderFooterRefs?.map((refs, index) => {
+			if (refs.titlePg !== true) return;
+			const properties = sectionPropertiesForMargins[index];
+			return bodyMarginsClearHeaderFooter({
+				authoredMargins: properties ? getMargins(properties) : margins,
+				preparedHeader: refs.headerFirst ? headerContentByRId?.get(refs.headerFirst) : void 0,
+				preparedFooter: refs.footerFirst ? footerContentByRId?.get(refs.footerFirst) : void 0
+			});
+		});
 		newBlocks = bodyBlocksClearSectionHeaderFooter(newBlocks, {
 			authoredMargins: margins,
 			sectionHeaderFooterRefs,
@@ -358,7 +367,8 @@ function runLayoutPipelineMeasured(deps, state, options) {
 			};
 			if (document?.package.document.sections !== void 0) nextLayoutOpts.sectionVerticalAlignments = document.package.document.sections.map(({ properties }) => properties.verticalAlign);
 			else if (sectionProperties !== null && sectionProperties !== void 0) nextLayoutOpts.sectionVerticalAlignments = [sectionProperties.verticalAlign];
-			if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
+			if (sectionFirstPageMargins !== void 0) nextLayoutOpts.sectionFirstPageMargins = sectionFirstPageMargins;
+			else if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
 				authoredMargins: margins,
 				preparedHeader: firstPageHeaderForRender,
 				preparedFooter: firstPageFooterForRender

package/dist/display-list/build/paragraphPrimitives.js

@@ -1,6 +1,7 @@
 import { getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont } from "../../layout-engine/measure/listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "../../layout-engine/measure/measureHelpers.js";
 import { getFontMetrics, measureTextWidth } from "../../layout-engine/measure/measureProvider.js";
+import { SMALL_CAPS_SCALE, smallCapsSegments } from "../../layout-engine/measure/smallCapsCasing.js";
 import { calculateTabWidth, pixelsToTwips } from "../../layout-engine/measure/tabCalculator.js";
 import { countCompressibleSpaces, toPaintedText } from "../../layout-engine/measure/textMeasurementPolicy.js";
 import { isFloatingImageRun } from "../../layout-engine/types.js";
@@ -315,6 +316,39 @@ const runGlyphDirection = (run, paragraphIsRtl) => run.bidiWrapper?.direction ??
 */
 const runUnicodeBidi = (run) => run.bidiWrapper === void 0 ? void 0 : UNICODE_BIDI_BY_WRAPPER_CONTROL[run.bidiWrapper.control];
 /**
+* `glyphs` split into same-size stretches for a `w:smallCaps` run, or
+* `undefined` when it has no lowercase letter (a heading typed in caps, a run
+* of digits and punctuation): that run paints as the single glyph run it
+* always did, no backend work spent on a split it does not need.
+*
+* Every backend draws one glyph size per `glyphRun` (a PDF's `Tf` sets the
+* whole text-showing operation's size; a DOM span sets one `font-size`), so a
+* mixed-size run becomes a short run of primitives instead of one primitive
+* with glyphs a backend cannot all draw at the size it is told. `advancesPx`
+* is sliced from the already-measured run — the widths line breaking decided
+* on — never re-measured, so the split cannot disagree with the width the
+* line was fitted at.
+*/
+const smallCapsGlyphRunSegments = (glyphs, fontSizePx) => {
+	const segments = smallCapsSegments(glyphs.text);
+	if (!segments.some((segment) => segment.small)) return;
+	const smallFontSizePx = fontSizePx * SMALL_CAPS_SCALE;
+	const result = [];
+	let advanceIndex = 0;
+	for (const segment of segments) {
+		const codePointCount = [...segment.text].length;
+		const advancesPx = glyphs.advancesPx.slice(advanceIndex, advanceIndex + codePointCount);
+		advanceIndex += codePointCount;
+		result.push({
+			text: segment.text,
+			fontSizePx: segment.small ? smallFontSizePx : fontSizePx,
+			advancesPx,
+			widthPx: advancesPx.reduce((sum, advance) => sum + advance, 0)
+		});
+	}
+	return result;
+};
+/**
 * One `glyphRun` plus everything painted around it: the run's background rect
 * first, then the glyphs, then the decorations whose geometry CSS would have
 * derived from the font.
@@ -380,20 +414,43 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 		pattern: "solid"
 	} : void 0;
 	const unicodeBidi = runUnicodeBidi(run);
-	sink.glyphs.push({
-		kind: "glyphRun",
+	const direction = runGlyphDirection(run, isRtl);
+	const commonFields = {
 		font,
-		fontSizePx,
 		color,
-		xPx: paintXPx,
 		baselineYPx: runBaselineYPx,
-		...glyphRunText(glyphs),
-		direction: runGlyphDirection(run, isRtl),
+		direction,
 		...unicodeBidi === void 0 ? {} : { unicodeBidi },
 		...stroke === void 0 ? {} : { stroke },
 		...pmRange === void 0 ? {} : { pmRange },
 		...collapsedEdge === void 0 ? {} : { collapsedEdge }
+	};
+	const smallCapsRuns = style.fontVariant === "small-caps" && direction === "ltr" ? smallCapsGlyphRunSegments(glyphs, fontSizePx) : void 0;
+	if (smallCapsRuns === void 0) sink.glyphs.push({
+		kind: "glyphRun",
+		fontSizePx,
+		xPx: paintXPx,
+		...glyphRunText(glyphs),
+		...commonFields
 	});
+	else {
+		const adjustments = glyphs.adjustments === void 0 ? {} : { adjustments: glyphs.adjustments };
+		let segmentXPx = paintXPx;
+		for (const segment of smallCapsRuns) {
+			sink.glyphs.push({
+				kind: "glyphRun",
+				fontSizePx: segment.fontSizePx,
+				xPx: segmentXPx,
+				text: segment.text,
+				advancesPx: segment.advancesPx,
+				kerning: glyphs.kerning,
+				smallCaps: true,
+				...adjustments,
+				...commonFields
+			});
+			segmentXPx += segment.widthPx;
+		}
+	}
 	emitDecorations({
 		sink,
 		run,
@@ -506,7 +563,6 @@ const emitDecorations = ({ sink, run, color, context, xPx, glyphs, baselineYPx,
 */
 const reportRunEffects = (run, context) => {
 	const { unsupported, pageIndex } = context;
-	if (run.smallCaps) unsupported.report(UNSUPPORTED_CONSTRUCT.smallCaps, pageIndex, "w:smallCaps is carried on the run and painted by the DOM backend; the PDF backend paints full-size glyphs for it");
 	if (getHorizontalScaleFactor(run.horizontalScale) !== 1) unsupported.report(UNSUPPORTED_CONSTRUCT.horizontalScale, pageIndex, `w:w ${String(run.horizontalScale)}% is carried on the run and painted by the DOM backend; the PDF backend paints unnarrowed glyphs at the measured advances`);
 	if (run.textEffect) unsupported.report(UNSUPPORTED_CONSTRUCT.textEffect, pageIndex, `w:effect ${run.textEffect}`);
 	if (run.emphasisMark) unsupported.report(UNSUPPORTED_CONSTRUCT.emphasisMark, pageIndex, `w:em ${run.emphasisMark}`);

package/dist/display-list/build/textBoxPrimitives.js

@@ -64,7 +64,7 @@ const paintUnrotatedTextBoxFragment = ({ composer, fragment, block, measure, con
 			fill
 		});
 		else context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `text box fill ${block.fillColor}`);
-	}
+	} else if (block.fillGradient) context.unsupported.report(UNSUPPORTED_CONSTRUCT.textBoxGradientFill, context.pageIndex, "text box gradient fill");
 	let outlineWidthPx = 0;
 	const outlineDash = presetDashForOutlineAttr(block.outlineStyle) ?? "solid";
 	if (block.outlineWidth !== void 0 && block.outlineWidth > 0 && outlineDash !== "none") {

package/dist/display-list/build/unsupported.d.ts

@@ -7,8 +7,6 @@ import { DisplayUnsupported } from "../types.js";
 declare const UNSUPPORTED_CONSTRUCT: {
   /** `w:effect` animations (blinkBackground, shimmer, …). */
   readonly textEffect: "textEffect";
-  /** `w:smallCaps`: advances are correct, the small-cap glyph choice is not expressible. */
-  readonly smallCaps: "smallCaps";
   /** `w:w` horizontal scale: folded into advances, but the glyphs are not narrowed. */
   readonly horizontalScale: "horizontalScale";
   /** `w:em` emphasis marks. */
@@ -39,6 +37,8 @@ declare const UNSUPPORTED_CONSTRUCT: {
   readonly headerFooterContent: "headerFooterContent";
   /** `a:bodyPr` middle/bottom anchoring inside a text box. */
   readonly textBoxVerticalAlign: "textBoxVerticalAlign";
+  /** A text box's `a:gradFill`: the primitives carry no gradient. */
+  readonly textBoxGradientFill: "textBoxGradientFill";
   /** A fragment kind with no builder. */
   readonly fragmentKind: "fragmentKind";
   /** A fragment whose block or measure is missing from the block lookup. */

package/dist/display-list/dom/renderDisplayListToDom.js

@@ -297,7 +297,6 @@ const paintGlyphRun = (run, context) => {
 	if (run.unicodeBidi !== void 0) span.style.unicodeBidi = run.unicodeBidi;
 	if (run.stroke !== void 0) span.style.webkitTextStroke = `${px(run.stroke.thicknessPx)} ${cssColor(run.stroke.color)}`;
 	span.style.fontKerning = run.kerning ? "normal" : "none";
-	if (run.smallCaps) span.style.fontVariant = "small-caps";
 	applyAdjustments(span, run.adjustments);
 	span.dataset["advanceSum"] = String(advanceSum);
 	applyModelRange(span, run.pmRange);

package/dist/docx/blockContentParser.js

@@ -1,5 +1,5 @@
 import { parseBookmarkEnd, parseBookmarkStart } from "./bookmarkParser.js";
-import { convertBulletToUnicode } from "./bulletMarkers.js";
+import { bulletMarkerFontName, convertBulletToUnicode } from "./bulletMarkers.js";
 import { CAPTURE, dispatchChildrenWithContext, ownedElsewhere, withPreservedChildren } from "./containerChildren.js";
 import { isNumberingReference } from "./numberingReference.js";
 import { formatOoxmlCounter } from "./ooxmlCounterFormatter.js";
@@ -62,7 +62,7 @@ const computeListMarker = (paragraph, { numbering, listCounters, abstractCounter
 	previousList.numId = numId;
 	const pattern = listRendering.marker;
 	if (listRendering.isBullet) {
-		listRendering.marker = convertBulletToUnicode(pattern || "");
+		listRendering.marker = convertBulletToUnicode(pattern || "", bulletMarkerFontName(listRendering.markerFormatting));
 		previousList.abstractNumId = null;
 		previousList.fromStyle = false;
 		previousList.numId = null;

package/dist/docx/bulletMarkers.d.ts

@@ -1,4 +1,20 @@
 //#region src/docx/bulletMarkers.d.ts
-declare const convertBulletToUnicode: (bulletChar: string) => string;
+type MarkerFontFamily = {
+  ascii?: string | undefined;
+  hAnsi?: string | undefined;
+};
+/** The face a bullet level's `w:rFonts` names for its (Latin-range) marker character. */
+declare const bulletMarkerFontName: (formatting: {
+  fontFamily?: MarkerFontFamily | undefined;
+} | null | undefined) => string | undefined;
+/**
+ * Map a bullet level's `w:lvlText` to the character painted for it.
+ *
+ * `fontName` is the level's own `w:rFonts` face. When it is an ordinary text
+ * font, a Latin-range character is the letter itself (the common `o` bullet
+ * in a monospace face); without a named face the character is read as a
+ * symbol-font code.
+ */
+declare const convertBulletToUnicode: (bulletChar: string, fontName?: string) => string;
 //#endregion
-export { convertBulletToUnicode };
+export { bulletMarkerFontName, convertBulletToUnicode };

package/dist/docx/bulletMarkers.js

@@ -28,10 +28,35 @@ const SYMBOL_BULLET_MAP = {
 	62: ">",
 	45: "-"
 };
-const convertBulletToUnicode = (bulletChar) => {
+/**
+* Fonts whose single-byte codes name pictographs rather than Latin letters.
+* A `w:lvlText` character below U+0100 only means a symbol glyph when the
+* numbering level's `w:rFonts` selects one of these faces.
+*/
+const SYMBOL_ENCODED_FONTS = /* @__PURE__ */ new Set([
+	"symbol",
+	"wingdings",
+	"wingdings 2",
+	"wingdings 3",
+	"webdings"
+]);
+/** The face a bullet level's `w:rFonts` names for its (Latin-range) marker character. */
+const bulletMarkerFontName = (formatting) => formatting?.fontFamily?.ascii ?? formatting?.fontFamily?.hAnsi;
+/** A printable Latin-1 character in a named, non-symbol face paints as itself. */
+const isTextFontCharacter = (charCode, fontName) => fontName !== void 0 && (charCode >= 32 && charCode < 127 || charCode >= 160 && charCode < 256) && !SYMBOL_ENCODED_FONTS.has(fontName.trim().toLowerCase());
+/**
+* Map a bullet level's `w:lvlText` to the character painted for it.
+*
+* `fontName` is the level's own `w:rFonts` face. When it is an ordinary text
+* font, a Latin-range character is the letter itself (the common `o` bullet
+* in a monospace face); without a named face the character is read as a
+* symbol-font code.
+*/
+const convertBulletToUnicode = (bulletChar, fontName) => {
 	if (!bulletChar || bulletChar.trim() === "") return "•";
 	const charCode = bulletChar.codePointAt(0);
 	if (charCode === void 0) return "•";
+	if (isTextFontCharacter(charCode, fontName)) return bulletChar;
 	const mapped = SYMBOL_BULLET_MAP[charCode];
 	if (mapped !== void 0) return mapped;
 	if (charCode >= 57344 && charCode <= 63743) return "•";
@@ -39,4 +64,4 @@ const convertBulletToUnicode = (bulletChar) => {
 	return bulletChar;
 };
 //#endregion
-export { convertBulletToUnicode };
+export { bulletMarkerFontName, convertBulletToUnicode };

package/dist/docx/drawingGroupChildren.d.ts

@@ -0,0 +1,60 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/drawingGroupChildren.d.ts
+type GroupTextBoxFrame = {
+  /** Element indices from the `wpg:wgp` down to the `wps:wsp`. */
+  path: number[];
+  wsp: XmlElement;
+  /** EMUs from the group's top-left corner. */
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** Degrees clockwise. */
+  rotation: number;
+  flipH: boolean;
+  flipV: boolean;
+};
+type Transform2D = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  childX: number;
+  childY: number;
+  childWidth: number;
+  childHeight: number;
+  rotation: number;
+  flipH: boolean;
+  flipV: boolean;
+};
+/** A `CT_GroupTransform2D` or `CT_Transform2D`; absent children read as zero. */
+declare const readTransform: (xfrm: XmlElement | null) => Transform2D;
+/**
+ * Every `wps:wsp` with a text box in the group, nested groups included, with
+ * its frame in EMUs from the group's top-left corner.
+ *
+ * A nested group that is rotated or flipped turns its children's frames into
+ * something other than a rectangle in the drawing's axes, so its text boxes
+ * are left out and stay with the preview.
+ */
+declare const collectGroupTextBoxes: (group: XmlElement, width: number, height: number) => GroupTextBoxFrame[];
+/** Identity of a group drawing's authored XML. */
+declare const groupXmlFingerprint: (rawXml: string) => string;
+/** Identity of a text box's content, compared on save to tell an edit. */
+declare const groupTextContentFingerprint: (content: unknown) => string;
+type GroupTextBoxEdit = {
+  path: readonly number[];
+  /** Serialized `w:txbxContent` children. */
+  contentXml: string;
+};
+/**
+ * The captured group XML with each edited text box's content replaced, or
+ * undefined when an edit names no text box in it.
+ *
+ * The replacement is written as a placeholder element and substituted after
+ * the tree is serialized, so the new content is never reparsed and the rest
+ * of the capture is written exactly as it was read.
+ */
+declare const replaceGroupTextBoxContent: (rawXml: string, edits: readonly GroupTextBoxEdit[]) => string | undefined;
+//#endregion
+export { GroupTextBoxEdit, GroupTextBoxFrame, collectGroupTextBoxes, groupTextContentFingerprint, groupXmlFingerprint, readTransform, replaceGroupTextBoxContent };