@stll/folio-core 0.47.7 → 0.48.0

package/dist/prosemirror/attrs/index.js

@@ -14,6 +14,7 @@ import { panic } from "better-result";
 import { DRAWING_RAW_XML_MODES, THEME_COLORS, isOoxmlSymbolCharacter } from "@stll/docx-core/model";
 import { isSafePreservedChildXml, isWithinPreservedMarkupBudget } from "@stll/docx-core/schema";
 //#region src/prosemirror/attrs/index.ts
+const RUN_FORMATTING_VALUE_PROPERTY_SET = new Set(RUN_FORMATTING_VALUE_PROPERTIES);
 const PRESERVED_XML_LEVEL_VALUES = new Set(Object.values(PRESERVED_XML_LEVELS));
 const IMAGE_DISPLAY_MODES = [
 	"inline",
@@ -149,15 +150,12 @@ const SECTION_VERTICAL_ALIGNMENTS = [
 	"bottom"
 ];
 const OMITTED_GRID_SLOT_VALUES = ["before", "after"];
-const paragraphAttrsCache = /* @__PURE__ */ new WeakMap();
 const hardBreakAttrsCache = /* @__PURE__ */ new WeakMap();
 const pageBreakRunAttrsCache = /* @__PURE__ */ new WeakMap();
 const tabAttrsCache = /* @__PURE__ */ new WeakMap();
 const symbolAttrsCache = /* @__PURE__ */ new WeakMap();
 const preservedXmlAttrsCache = /* @__PURE__ */ new WeakMap();
 const preservedBlockAttrsCache = /* @__PURE__ */ new WeakMap();
-const tableAttrsCache = /* @__PURE__ */ new WeakMap();
-const tableRowAttrsCache = /* @__PURE__ */ new WeakMap();
 const tableCellAttrsCache = /* @__PURE__ */ new WeakMap();
 const imageAttrsCache = /* @__PURE__ */ new WeakMap();
 const fieldAttrsCache = /* @__PURE__ */ new WeakMap();
@@ -185,7 +183,36 @@ const runIdentityAttrsCache = /* @__PURE__ */ new WeakMap();
 const inlineWrapperAttrsCache = /* @__PURE__ */ new WeakMap();
 const runFormattingOverrideAttrsCache = /* @__PURE__ */ new WeakMap();
 const hyperlinkAttrsCache = /* @__PURE__ */ new WeakMap();
-const readParagraphAttrs = (node) => {
+/**
+* Read a node's attrs once per node. Nodes are immutable, and one conversion
+* reads each paragraph, table and row several times (node validation, the
+* bookmark walk, numbering). The cached result is frozen, value and issues
+* included, so no caller can change what the next one reads.
+*/
+const memoizeNodeAttrsReader = (read) => {
+	const results = /* @__PURE__ */ new WeakMap();
+	return (node) => {
+		const cached = results.get(node);
+		if (cached !== void 0) return cached;
+		const result = freezeAttrsResult(read(node));
+		results.set(node, result);
+		return result;
+	};
+};
+const freezeAttrsResult = (result) => {
+	if (!result.ok) {
+		const issues = result.issues.map((issue) => Object.freeze({ ...issue }));
+		return Object.freeze({
+			ok: false,
+			issues: Object.freeze(issues)
+		});
+	}
+	return Object.freeze({
+		ok: true,
+		value: Object.freeze(result.value)
+	});
+};
+const readParagraphAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "paragraph", issues);
@@ -244,6 +271,7 @@ const readParagraphAttrs = (node) => {
 	});
 	optionalStringArray(attrs, "listLevelNumFmts", "paragraph.attrs.listLevelNumFmts", issues);
 	optionalNumberArray(attrs, "listLevelStarts", "paragraph.attrs.listLevelStarts", issues);
+	optionalTabStops(attrs, "listLevelTabs", "paragraph.attrs.listLevelTabs", issues);
 	optionalNumber(attrs, "listAbstractNumId", "paragraph.attrs.listAbstractNumId", issues);
 	optionalBorderMap(attrs, "borders", "paragraph.attrs.borders", issues, [
 		"top",
@@ -271,7 +299,8 @@ const readParagraphAttrs = (node) => {
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "paragraph.attrs._preservedAttributes", issues);
 	return attrsResult(attrs, issues);
 };
-const expectParagraphAttrs = (node) => expectCachedNodeAttrs(node, paragraphAttrsCache, readParagraphAttrs, "paragraph attrs");
+const readParagraphAttrs = memoizeNodeAttrsReader(readParagraphAttrsUncached);
+const expectParagraphAttrs = (node) => expectAttrs(readParagraphAttrs(node), "paragraph attrs");
 const readHardBreakAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -348,7 +377,7 @@ const readPreservedBlockAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
-const readTableAttrs = (node) => {
+const readTableAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "table", issues);
@@ -375,8 +404,9 @@ const readTableAttrs = (node) => {
 	optionalTablePreservedMarkup(attrs, "_preserved", "table.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
-const expectTableAttrs = (node) => expectCachedNodeAttrs(node, tableAttrsCache, readTableAttrs, "table attrs");
-const readTableRowAttrs = (node) => {
+const readTableAttrs = memoizeNodeAttrsReader(readTableAttrsUncached);
+const expectTableAttrs = (node) => expectAttrs(readTableAttrs(node), "table attrs");
+const readTableRowAttrsUncached = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
 	expectNodeType(node, "tableRow", issues);
@@ -399,7 +429,8 @@ const readTableRowAttrs = (node) => {
 	optionalTablePreservedMarkup(attrs, "_preserved", "tableRow.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
-const expectTableRowAttrs = (node) => expectCachedNodeAttrs(node, tableRowAttrsCache, readTableRowAttrs, "table row attrs");
+const readTableRowAttrs = memoizeNodeAttrsReader(readTableRowAttrsUncached);
+const expectTableRowAttrs = (node) => expectAttrs(readTableRowAttrs(node), "table row attrs");
 const readTableCellAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -656,6 +687,7 @@ const readTextBoxAttrs = (node) => {
 	optionalTextBoxTrackedChange(attrs, issues);
 	optionalTextBoxInlineSdts(attrs, issues);
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "textBox.attrs._preservedAttributes", issues);
+	optionalRecord(attrs, "_docxHostParagraph", "textBox.attrs._docxHostParagraph", issues);
 	return attrsResult(attrs, issues);
 };
 const expectTextBoxAttrs = (node) => expectCachedNodeAttrs(node, textBoxAttrsCache, readTextBoxAttrs, "text box attrs");
@@ -1042,8 +1074,7 @@ const readRunFormattingOverrideMarkAttrs = (mark) => {
 	optionalTextFormatting(attrs, "_authoredValues", "runFormattingOverride.attrs._authoredValues", issues);
 	const authoredValues = attrs["_authoredValues"];
 	if (isRecord(authoredValues)) {
-		const allowed = new Set(RUN_FORMATTING_VALUE_PROPERTIES);
-		for (const property of Object.keys(authoredValues)) if (!allowed.has(property)) issues.push({
+		for (const property of Object.keys(authoredValues)) if (!RUN_FORMATTING_VALUE_PROPERTY_SET.has(property)) issues.push({
 			path: `runFormattingOverride.attrs._authoredValues.${property}`,
 			message: "Expected a non-boolean authored formatting property."
 		});
@@ -2199,6 +2230,7 @@ const validateParagraphFormatting = (value, path, issues) => {
 	]);
 	optionalOneOfArray(value, "listLevelNumFmts", `${path}.listLevelNumFmts`, issues, COUNTER_FORMAT_VALUES);
 	optionalNumberArray(value, "listLevelStarts", `${path}.listLevelStarts`, issues);
+	optionalTabStops(value, "listLevelTabs", `${path}.listLevelTabs`, issues);
 	optionalAutospacingBase(value, `${path}._autospacingBase`, issues);
 	for (const key of ["numPr", "numPrFromStyle"]) optionalParagraphNumbering(value, key, `${path}.${key}`, issues);
 	const direction = value["direction"];

package/dist/prosemirror/conversion/fromProseDoc.js

@@ -42,6 +42,7 @@ import { schema } from "../schema/index.js";
 import { PRESERVED_XML_LEVELS } from "../schema/nodes.js";
 import { parseShapeGeometryAdjustments } from "../shapeGeometryAdjustments.js";
 import { expectTextBoxAnchorAttrs } from "../textBoxAnchorAttrs.js";
+import { textBoxHostParagraph } from "../textBoxHostParagraph.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { hasSinkChildren } from "./preservedSinkCarriers.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "./runShadingMark.js";
@@ -678,7 +679,7 @@ function isStillSyntheticFiller(blocks) {
 }
 function appendTextBoxBlock(blocks, node, options) {
 	const attrs = expectTextBoxAttrs(node);
-	const paragraph = convertPMTextBox(node, options.styleResolver);
+	let paragraph = convertPMTextBox(node, options.styleResolver);
 	const previousBlock = blocks.at(-1);
 	if (attrs._docxPlacement === "inlineWithPrevious" && previousBlock?.type === "paragraph") {
 		appendPageBreaks(previousBlock, options.pendingPageBreaks);
@@ -696,6 +697,12 @@ function appendTextBoxBlock(blocks, node, options) {
 		if (!mergeTextBoxIntoTrailingInlineSdts(options.previousStandaloneTextBox.paragraph, paragraph, attrs._docxInlineSdts ?? [])) options.previousStandaloneTextBox.paragraph.content.push(...paragraph.content);
 		return options.previousStandaloneTextBox;
 	}
+	const host = attrs._docxPlacement === "standalone" ? textBoxHostParagraph(node) : void 0;
+	if (host) {
+		const hostParagraph = convertPMParagraph(host, void 0, void 0, options.styleResolver);
+		hostParagraph.content = paragraph.content;
+		paragraph = hostParagraph;
+	}
 	if (attrs._docxPlacement === "standalone" && attrs._preservedAttributes?.length) paragraph.preservedAttributes = attrs._preservedAttributes;
 	prependPageBreaks(paragraph, options.pendingPageBreaks);
 	blocks.push(paragraph);

package/dist/prosemirror/conversion/markInterner.d.ts

@@ -0,0 +1,21 @@
+import { MarkFactory } from "../extensions/marks/markUtils.js";
+import { Schema } from "prosemirror-model";
+//#region src/prosemirror/conversion/markInterner.d.ts
+/**
+ * Build marks that share one instance per distinct (type, attrs) value.
+ *
+ * A document repeats a small set of run formattings across thousands of runs,
+ * so one conversion builds each distinct mark once. Marks are immutable, and
+ * ProseMirror compares them by value, so sharing an instance changes nothing a
+ * caller can observe except the saved allocation. Create one interner per
+ * conversion; it holds every mark it built until it is dropped.
+ *
+ * The native JSON serialization is only a lookup key: it collapses values the
+ * mark would keep apart (`-0`, `NaN`, nested `undefined`), so a hit is shared
+ * only after an exact comparison, and a mismatch builds an unshared mark. A
+ * mark holding `NaN` is never shared: ProseMirror does not find two of them
+ * equal, and a shared instance would.
+ */
+declare const createMarkInterner: (schema: Schema) => MarkFactory;
+//#endregion
+export { createMarkInterner };

package/dist/prosemirror/conversion/markInterner.js

@@ -0,0 +1,90 @@
+import { panic } from "better-result";
+//#region src/prosemirror/conversion/markInterner.ts
+/**
+* Leaves ProseMirror compares with `===`, minus `-0`/`0`: sharing a mark makes
+* `Mark.eq` take its identity shortcut, so two leaves may share only when
+* ProseMirror would call them equal anyway. `NaN` never equals itself there.
+*/
+const sameLeaf = (left, right) => left === right && Object.is(left, right);
+/**
+* Whether two attr values are interchangeable: `sameLeaf` on leaves, and the
+* same own keys in the same order, so `-0`/`0`, `NaN` and `undefined`/absent
+* stay apart. Output follows the shared value's key order, which is why order
+* counts.
+*/
+const sameAttrValue = (left, right) => {
+	if (sameLeaf(left, right)) return true;
+	if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+	if (Object.getPrototypeOf(left) !== Object.getPrototypeOf(right)) return false;
+	if (Array.isArray(left)) {
+		if (!Array.isArray(right) || left.length !== right.length) return false;
+		for (let index = 0; index < left.length; index += 1) if (index in left !== index in right || !sameAttrValue(left[index], right[index])) return false;
+		return true;
+	}
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && sameAttrValue(Reflect.get(left, key), Reflect.get(right, key)));
+};
+const internedMark = (type, attrs) => {
+	const mark = type.create(attrs);
+	const nonDefault = /* @__PURE__ */ new Set();
+	for (const [name, spec] of Object.entries(type.spec.attrs ?? {})) if (!sameLeaf(mark.attrs[name], spec.default)) nonDefault.add(name);
+	return {
+		mark,
+		nonDefault
+	};
+};
+/**
+* Whether `create(attrs)` would compute attrs interchangeable with the
+* interned mark's. `create` fills every declared attr `attrs` leaves
+* `undefined` from its default, so the given attrs must match each value they
+* set and set every attr where the mark holds something else.
+*/
+const matchesInterned = (type, attrs, { mark, nonDefault }) => {
+	const specs = type.spec.attrs ?? {};
+	let covered = 0;
+	for (const name in attrs) {
+		const given = attrs[name];
+		if (given === void 0 || !Object.hasOwn(specs, name)) continue;
+		if (!sameAttrValue(given, mark.attrs[name])) return false;
+		if (nonDefault.has(name)) covered += 1;
+	}
+	return covered === nonDefault.size;
+};
+/**
+* Build marks that share one instance per distinct (type, attrs) value.
+*
+* A document repeats a small set of run formattings across thousands of runs,
+* so one conversion builds each distinct mark once. Marks are immutable, and
+* ProseMirror compares them by value, so sharing an instance changes nothing a
+* caller can observe except the saved allocation. Create one interner per
+* conversion; it holds every mark it built until it is dropped.
+*
+* The native JSON serialization is only a lookup key: it collapses values the
+* mark would keep apart (`-0`, `NaN`, nested `undefined`), so a hit is shared
+* only after an exact comparison, and a mismatch builds an unshared mark. A
+* mark holding `NaN` is never shared: ProseMirror does not find two of them
+* equal, and a shared instance would.
+*/
+const createMarkInterner = (schema) => {
+	const marksByType = /* @__PURE__ */ new Map();
+	return (typeName, attrs) => {
+		const type = schema.marks[typeName];
+		if (type === void 0) panic(`Unknown mark type ${typeName}.`);
+		let marks = marksByType.get(type);
+		if (marks === void 0) {
+			marks = /* @__PURE__ */ new Map();
+			marksByType.set(type, marks);
+		}
+		const key = JSON.stringify(attrs ?? null);
+		const cached = marks.get(key);
+		if (cached === void 0) {
+			const interned = internedMark(type, attrs);
+			marks.set(key, interned);
+			return interned.mark;
+		}
+		return matchesInterned(type, attrs, cached) ? cached.mark : type.create(attrs);
+	};
+};
+//#endregion
+export { createMarkInterner };

package/dist/prosemirror/conversion/toProseDoc.js

@@ -2,7 +2,7 @@ import { rangedCommentIds } from "../../docx/commentAnchorIndex.js";
 import { resolveColorValueToHex } from "../../docx/drawingUtils.js";
 import { isInlineSdtContent, isTrackedChangeWrapperChild } from "../../docx/inlineWrapperContent.js";
 import { mergeParagraphNumbering as mergeParagraphNumbering$1, paragraphNumberingReferenceId as paragraphNumberingReferenceId$1 } from "../../docx/numberingReference.js";
-import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, createProseParagraphWithPropertySource, getDocumentParagraphPropertySourceContract, recreateProseNodeWithParagraphPropertySource, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
+import { PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR, createProseParagraphWithPropertySource, getDocumentParagraphPropertySourceContract, proseParagraphAttrsWithoutPropertySource, recreateProseNodeWithParagraphPropertySource, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
 import { isBaselineVertAlign } from "../../docx/runParser.js";
 import { resolveTableLook } from "../../docx/tableLook.js";
 import { isCellMergeContinuation } from "../../docx/tableParser.js";
@@ -41,6 +41,7 @@ import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
 import { canCarryTrackedRunMark, trackedRunInlineAtomDisposition } from "../trackedRunInlineAtoms.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { resolveEffectiveTableCellFormatting } from "./effectiveTableCellFormatting.js";
+import { createMarkInterner } from "./markInterner.js";
 import { hasSinkChildren } from "./preservedSinkCarriers.js";
 import { sdtAttrsFromProperties } from "./sdtAttrs.js";
 import { panic } from "better-result";
@@ -227,7 +228,8 @@ function toProseDoc(document, options) {
 		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(paragraphs),
 		storyRangedCommentIds: rangedCommentIds(paragraphs),
 		openCommentIds: /* @__PURE__ */ new Set(),
-		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn)
+		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn),
+		createMark: createMarkInterner(schema)
 	};
 	const convertBodyBlocks = (blocks) => {
 		const out = [];
@@ -259,10 +261,12 @@ function toProseDoc(document, options) {
 	if (nodes.length === 0) nodes.push(schema.node("paragraph", {}, []));
 	const finalSectionStart = document.package.document.sections?.at(-1)?.properties.sectionStart ?? null;
 	const adjustLineHeightInTable = document.package.settings?.adjustLineHeightInTable === true;
+	const doNotUseIndentAsNumberingTabStop = document.package.settings?.doNotUseIndentAsNumberingTabStop === true;
 	const pmDoc = stampNumberedRefFieldBaselines(schema.node("doc", {
 		[PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR]: getDocumentParagraphPropertySourceContract(document) ?? null,
 		_finalSectionStart: finalSectionStart,
-		_adjustLineHeightInTable: adjustLineHeightInTable
+		_adjustLineHeightInTable: adjustLineHeightInTable,
+		_doNotUseIndentAsNumberingTabStop: doNotUseIndentAsNumberingTabStop
 	}, nodes));
 	assertValidProseMirrorDocument(pmDoc, "Document conversion produced an invalid ProseMirror document");
 	return pmDoc;
@@ -355,7 +359,10 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 function convertParagraph(paragraph, styleResolver, context, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
 	const { nextHyperlinkInstanceIndex, pairedBookmarkIds, pageBreakRunSourceDescendants, storyRangedCommentIds, openCommentIds } = context;
 	let runIdentityId = 0;
-	const nextRunIdentityId = () => runIdentityId++;
+	const runScope = {
+		nextRunIdentityId: () => runIdentityId++,
+		createMark: context.createMark
+	};
 	const { attrs, effectiveFrame } = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
 	reportParagraphPageBreakProjection({
 		paragraph,
@@ -452,7 +459,7 @@ function convertParagraph(paragraph, styleResolver, context, extraRunFormatting,
 		historical: getHistoricalRunFormatting
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
-		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextRunIdentityId, trackedRunFormattingResolvers, styleResolver, moveKind, textBoxAnchors, wrapperStack));
+		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, runScope, trackedRunFormattingResolvers, styleResolver, moveKind, textBoxAnchors, wrapperStack));
 	};
 	const stacked = withInlineWrapperStacks(paragraph.content);
 	const emptyRanges = planEmptyRanges(stacked.map((item) => item.content));
@@ -476,7 +483,7 @@ function convertParagraph(paragraph, styleResolver, context, extraRunFormatting,
 				emitInlineNode(schema.node("commentReference", { commentId: content.id }));
 				break;
 			case "run":
-				emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), nextRunIdentityId, styleResolver, textBoxAnchors));
+				emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), runScope, styleResolver, textBoxAnchors));
 				break;
 			case "hyperlink": {
 				const linkNodes = convertHyperlink(content, {
@@ -484,7 +491,7 @@ function convertParagraph(paragraph, styleResolver, context, extraRunFormatting,
 					styleResolver,
 					hyperlinkIndex: nextHyperlinkInstanceIndex(),
 					textBoxAnchors,
-					nextRunIdentityId
+					runScope
 				});
 				if (linkNodes.length === 0) {
 					const emptyWrapperStacks = emptyInlineWrapperStacks(content.children);
@@ -511,12 +518,12 @@ function convertParagraph(paragraph, styleResolver, context, extraRunFormatting,
 					getInheritedRunFormatting,
 					styleResolver,
 					nextHyperlinkInstanceIndex,
-					nextRunIdentityId,
+					runScope,
 					textBoxAnchors
 				}));
 				break;
 			case "inlineSdt":
-				emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, nextRunIdentityId, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, stack));
+				emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, runScope, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, stack));
 				break;
 			case "insertion":
 			case "moveTo":
@@ -630,13 +637,13 @@ const withTrackedRunMark = (node, mark, ancestor) => {
 * Convert tracked change (insertion or deletion) content to PM nodes with
 * an insertion/deletion mark applied.
 */
-function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextRunIdentityId, runFormattingResolvers, styleResolver, moveKind = null, textBoxAnchors, wrappedBy = []) {
+function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, runScope, runFormattingResolvers, styleResolver, moveKind = null, textBoxAnchors, wrappedBy = []) {
 	const nodes = [];
 	const getTrackedRunFormatting = markType === "deletion" ? runFormattingResolvers.historical : runFormattingResolvers.current;
 	for (const { content: item, stack } of withInlineWrapperStacks(change.content)) {
 		if (!isTrackedChangeWrapperChild(item)) continue;
 		const itemNodes = [];
-		if (item.type === "run") itemNodes.push(...convertRun(item, getTrackedRunFormatting(item.formatting), nextRunIdentityId, styleResolver, textBoxAnchors));
+		if (item.type === "run") itemNodes.push(...convertRun(item, getTrackedRunFormatting(item.formatting), runScope, styleResolver, textBoxAnchors));
 		else if (item.type === "hyperlink") {
 			const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
 			itemNodes.push(...convertHyperlink(item, {
@@ -644,14 +651,14 @@ function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, next
 				styleResolver,
 				hyperlinkIndex: currentHyperlinkIndex,
 				textBoxAnchors,
-				nextRunIdentityId
+				runScope
 			}));
 		} else if (item.type === "simpleField" || item.type === "complexField") {
 			const fieldNode = convertField(item, {
 				getInheritedRunFormatting: getTrackedRunFormatting,
 				styleResolver,
 				nextHyperlinkInstanceIndex,
-				nextRunIdentityId,
+				runScope,
 				textBoxAnchors
 			});
 			if (fieldNode) itemNodes.push(fieldNode);
@@ -661,9 +668,9 @@ function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, next
 		} else if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
 			const nestedMarkType = item.type === "insertion" || item.type === "moveTo" ? "insertion" : "deletion";
 			const nestedMoveKind = item.type === "moveFrom" || item.type === "moveTo" ? item.type : null;
-			itemNodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, nextRunIdentityId, runFormattingResolvers, styleResolver, nestedMoveKind, textBoxAnchors, [...wrappedBy, ...stack]));
+			itemNodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, runScope, runFormattingResolvers, styleResolver, nestedMoveKind, textBoxAnchors, [...wrappedBy, ...stack]));
 		} else if (item.type === "inlineSdt") {
-			const sdtNode = convertInlineSdt(item, nextHyperlinkInstanceIndex, nextRunIdentityId, getTrackedRunFormatting, runFormattingResolvers, styleResolver, textBoxAnchors, [...wrappedBy, ...stack]);
+			const sdtNode = convertInlineSdt(item, nextHyperlinkInstanceIndex, runScope, getTrackedRunFormatting, runFormattingResolvers, styleResolver, textBoxAnchors, [...wrappedBy, ...stack]);
 			if (sdtNode) itemNodes.push(sdtNode);
 		} else if (item.type === "bookmarkStart") itemNodes.push(schema.node("bookmarkBoundary", {
 			type: "start",
@@ -1080,8 +1087,7 @@ function convertTable(table, styleResolver, context) {
 	const tableStyleId = table.formatting?.styleId;
 	const look = resolveTableLook(table.formatting?.look);
 	const tableStyle = tableStyleId ? styleResolver?.getStyle(tableStyleId) : void 0;
-	const defaultTableStyle = styleResolver?.getDefaultTableStyle();
-	const fallbackTableStyle = tableStyleId ? void 0 : defaultTableStyle;
+	const fallbackTableStyle = tableStyle ? void 0 : styleResolver?.getDefaultTableStyle();
 	const conditionalTableStyleId = tableStyle?.styleId ?? fallbackTableStyle?.styleId;
 	const resolvedTableBorders = table.formatting?.borders ?? tableStyle?.tblPr?.borders ?? fallbackTableStyle?.tblPr?.borders;
 	const fallbackTableIndent = fallbackTableStyle?.tblPr?.indent;
@@ -1466,7 +1472,8 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 			pageBreakRunSourceDescendants,
 			storyRangedCommentIds: rangedCommentIds(cell.content),
 			openCommentIds: /* @__PURE__ */ new Set(),
-			warnPageBreakProjection: noPageBreakProjectionWarning
+			warnPageBreakProjection: noPageBreakProjectionWarning,
+			createMark: createMarkInterner(schema)
 		},
 		isHeader: nodeType === "tableHeader",
 		gridWidthPercent: void 0,
@@ -1479,7 +1486,7 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 		defaultCellMargins: void 0
 	});
 }
-function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyperlinkInstanceIndex, nextRunIdentityId, textBoxAnchors }) {
+function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyperlinkInstanceIndex, runScope, textBoxAnchors }) {
 	let displayText = "";
 	let fieldFormatting;
 	let fieldPropertyChanges;
@@ -1490,7 +1497,7 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 		fieldFormatting ??= run.formatting;
 		fieldPropertyChanges ??= run.propertyChanges;
 		if (!hasStructuredSourceContent) return;
-		into.push(...convertRun(run, getInheritedRunFormatting(run.formatting, field.fieldType), nextRunIdentityId, styleResolver, textBoxAnchors));
+		into.push(...convertRun(run, getInheritedRunFormatting(run.formatting, field.fieldType), runScope, styleResolver, textBoxAnchors));
 	};
 	if (field.type === "simpleField") for (const { content, stack } of withInlineWrapperStacks(field.content)) {
 		const itemNodes = [];
@@ -1512,7 +1519,7 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 					styleResolver,
 					hyperlinkIndex: nextHyperlinkInstanceIndex(),
 					textBoxAnchors,
-					nextRunIdentityId
+					runScope
 				}));
 				break;
 			default: break;
@@ -1522,7 +1529,12 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 	else for (const run of field.fieldResult) appendRun(run, inlineNodes);
 	if (!fieldFormatting && field.type === "complexField" && field.fieldResult.length === 0) fieldFormatting = field.formatting;
 	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting, field.fieldType);
-	const { marks } = buildRunMarks(fieldFormatting, inheritedFormatting, styleResolver);
+	const { marks } = buildRunMarks({
+		runFormatting: fieldFormatting,
+		inherited: inheritedFormatting,
+		styleResolver,
+		createMark: runScope.createMark
+	});
 	const hasConvertedHyperlinkContent = inlineNodes.some((node) => node.marks.some((mark) => mark.type.name === "hyperlink"));
 	const hasConvertedPageBreakContent = inlineNodes.some((node) => node.type.name === "pageBreakRun");
 	const hasConvertedPreservedContent = inlineNodes.some((node) => node.type.name === "preservedXml");
@@ -1602,7 +1614,7 @@ function convertMathEquation(math) {
 * its own leaves, so nothing outside can mark them afterwards: the caller's
 * stack has to reach them here, under the wrappers written inside the control.
 */
-function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, wrappedBy = []) {
+function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, runScope, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, wrappedBy = []) {
 	const props = sdt.properties;
 	const inlineNodes = [];
 	const stacked = withInlineWrapperStacks(sdt.content, wrappedBy);
@@ -1618,7 +1630,7 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, ge
 		if (emptyRanges.closedAt.has(index)) continue;
 		switch (content.type) {
 			case "run":
-				itemNodes.push(...convertRun(content, getInheritedRunFormatting(content.formatting), nextRunIdentityId, styleResolver, textBoxAnchors));
+				itemNodes.push(...convertRun(content, getInheritedRunFormatting(content.formatting), runScope, styleResolver, textBoxAnchors));
 				break;
 			case "hyperlink": {
 				const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
@@ -1627,7 +1639,7 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, ge
 					styleResolver,
 					hyperlinkIndex: currentHyperlinkIndex,
 					textBoxAnchors,
-					nextRunIdentityId
+					runScope
 				}));
 				break;
 			}
@@ -1637,14 +1649,14 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, ge
 					getInheritedRunFormatting,
 					styleResolver,
 					nextHyperlinkInstanceIndex,
-					nextRunIdentityId,
+					runScope,
 					textBoxAnchors
 				});
 				if (fieldNode) itemNodes.push(fieldNode);
 				break;
 			}
 			case "inlineSdt": {
-				const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, nextRunIdentityId, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, stack);
+				const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, runScope, getInheritedRunFormatting, trackedRunFormattingResolvers, styleResolver, textBoxAnchors, stack);
 				if (nestedSdt) itemNodes.push(nestedSdt);
 				break;
 			}
@@ -1652,7 +1664,7 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, ge
 			case "deletion":
 			case "moveTo":
 			case "moveFrom":
-				itemNodes.push(...convertTrackedChange(content, content.type === "insertion" || content.type === "moveTo" ? "insertion" : "deletion", nextHyperlinkInstanceIndex, nextRunIdentityId, trackedRunFormattingResolvers, styleResolver, content.type === "moveTo" || content.type === "moveFrom" ? content.type : null, textBoxAnchors));
+				itemNodes.push(...convertTrackedChange(content, content.type === "insertion" || content.type === "moveTo" ? "insertion" : "deletion", nextHyperlinkInstanceIndex, runScope, trackedRunFormattingResolvers, styleResolver, content.type === "moveTo" || content.type === "moveFrom" ? content.type : null, textBoxAnchors));
 				break;
 			case "mathEquation": {
 				const mathNode = convertMathEquation(content);
@@ -1697,11 +1709,16 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextRunIdentityId, ge
 * @param run - The run to convert
 * @param resolvedStyleFormatting - Paragraph formatting and its explicit style-toggle state
 */
-function convertRun(run, resolvedStyleFormatting, nextRunIdentityId, styleResolver, textBoxAnchors) {
+function convertRun(run, resolvedStyleFormatting, runScope, styleResolver, textBoxAnchors) {
 	const nodes = [];
-	const { marks, mergedFormatting } = buildRunMarks(run.formatting, resolvedStyleFormatting, styleResolver);
+	const { marks, mergedFormatting } = buildRunMarks({
+		runFormatting: run.formatting,
+		inherited: resolvedStyleFormatting,
+		styleResolver,
+		createMark: runScope.createMark
+	});
 	if (run.propertyChanges && run.propertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...run.propertyChanges] }));
-	const identity = runIdentityMark(run, nextRunIdentityId);
+	const identity = runIdentityMark(run, runScope.nextRunIdentityId);
 	if (identity) marks.push(identity);
 	for (const content of run.content) {
 		const contentNodes = convertRunContent(content, marks, mergedFormatting, textBoxAnchors, run.formatting);
@@ -2015,12 +2032,13 @@ const canReconstructAuthoredRunFormatting = ({ directFormatting, effectiveFormat
 	}
 	return true;
 };
-function buildRunMarks(runFormatting, inherited, styleResolver) {
+function buildRunMarks({ runFormatting, inherited, styleResolver, createMark }) {
 	if (runFormatting === void 0 && inherited.implicitCharacterStyleApplied === true && inherited.paragraphMarkOverrides === void 0) return {
 		marks: textFormattingToMarks(inherited.formatting, schema, {
 			overrideFormatting: void 0,
 			directFormatting: void 0,
-			authoredCarrier: "reconstruct"
+			authoredCarrier: "reconstruct",
+			createMark
 		}),
 		mergedFormatting: inherited.formatting
 	};
@@ -2064,9 +2082,10 @@ function buildRunMarks(runFormatting, inherited, styleResolver) {
 	const marks = textFormattingToMarks(mergedFormatting, schema, {
 		overrideFormatting,
 		directFormatting: runFormatting,
-		authoredCarrier
+		authoredCarrier,
+		createMark
 	});
-	if (styleId) marks.push(schema.mark("characterStyle", { styleId }));
+	if (styleId) marks.push(createMark("characterStyle", { styleId }));
 	return {
 		marks,
 		mergedFormatting
@@ -2334,7 +2353,7 @@ function convertImage({ image, rawXml, rawXmlMode, rawImageFingerprint, runForma
 		_docxRunFormatting: runFormatting
 	});
 }
-function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver, hyperlinkIndex, textBoxAnchors, nextRunIdentityId }) {
+function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver, hyperlinkIndex, textBoxAnchors, runScope }) {
 	const nodes = [];
 	const href = hyperlink.href || (hyperlink.anchor ? `#${hyperlink.anchor}` : "");
 	const linkMark = schema.mark("hyperlink", {
@@ -2371,9 +2390,14 @@ function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver,
 				break;
 			case "run": {
 				const inheritedFormatting = getInheritedRunFormatting(child.formatting);
-				const { marks: runMarks, mergedFormatting } = buildRunMarks(child.formatting, inheritedFormatting, styleResolver);
+				const { marks: runMarks, mergedFormatting } = buildRunMarks({
+					runFormatting: child.formatting,
+					inherited: inheritedFormatting,
+					styleResolver,
+					createMark: runScope.createMark
+				});
 				if (child.propertyChanges && child.propertyChanges.length > 0) runMarks.push(schema.mark("runPropertyChange", { changes: [...child.propertyChanges] }));
-				const identity = runIdentityMark(child, nextRunIdentityId);
+				const identity = runIdentityMark(child, runScope.nextRunIdentityId);
 				if (identity) runMarks.push(identity);
 				const allMarks = [...runMarks, linkMark];
 				for (const content of child.content) childNodes.push(...convertRunContent(content, allMarks, mergedFormatting, textBoxAnchors, child.formatting));
@@ -2518,10 +2542,20 @@ function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, c
 		context,
 		trackedChange,
 		inlineSdts,
-		...standalone && index === 0 && block.preservedAttributes ? { hostPreservedAttributes: block.preservedAttributes } : {}
+		...standalone && index === 0 && block.preservedAttributes ? { hostPreservedAttributes: block.preservedAttributes } : {},
+		...standalone && index === 0 ? { hostParagraph: hostParagraphAttrs(pmParagraph.attrs) } : {}
 	}));
 	return nodes;
 }
+/**
+* The host paragraph's attributes without its identity. The node may be
+* copied, and a copy must not make a second claim on the same `w:p`; the
+* attribute remainder travels in the node's own `_preservedAttributes`.
+*/
+function hostParagraphAttrs(attrs) {
+	const { paraId: _paraId, textId: _textId, idStability: _idStability, _preservedAttributes, ...host } = proseParagraphAttrsWithoutPropertySource(attrs);
+	return host;
+}
 function hasContentBesidesTextBoxAnchors(paragraph) {
 	let hasContent = false;
 	paragraph.descendants((node) => {
@@ -2785,7 +2819,8 @@ function convertTextBox(textBox, styleResolver, options) {
 		_docxTextBodyContentState: textBox.content.length === 0 ? { type: "source-empty" } : { type: "authored" },
 		_docxTrackedChange: options.trackedChange,
 		_docxInlineSdts: options.inlineSdts.length > 0 ? options.inlineSdts : void 0,
-		_preservedAttributes: options.hostPreservedAttributes
+		_preservedAttributes: options.hostPreservedAttributes,
+		_docxHostParagraph: options.hostParagraph
 	}, contentNodes);
 }
 /**
@@ -2809,7 +2844,8 @@ function headerFooterToProseDoc(content, options) {
 		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(content),
 		storyRangedCommentIds: rangedCommentIds(content),
 		openCommentIds: /* @__PURE__ */ new Set(),
-		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn)
+		warnPageBreakProjection: pageBreakProjectionWarn(options?.warn),
+		createMark: createMarkInterner(schema)
 	};
 	const convertBlocks = (blocks) => {
 		const out = [];

package/dist/prosemirror/extensions/core/DocExtension.js

@@ -11,7 +11,8 @@ const DocExtension = createNodeExtension({
 		attrs: {
 			[PROSE_PARAGRAPH_SOURCE_CONTRACT_ATTR]: { default: null },
 			_finalSectionStart: { default: null },
-			_adjustLineHeightInTable: { default: false }
+			_adjustLineHeightInTable: { default: false },
+			_doNotUseIndentAsNumberingTabStop: { default: false }
 		},
 		content: "(paragraph | horizontalRule | pageBreak | table | textBox | blockSdt | preservedBlock | blockBookmarkBoundary)+"
 	}