@stll/folio-core 0.52.0 → 0.54.0

package/dist/paged-layout/transactionDirtyRange.js

@@ -1,49 +1,37 @@
-import { mergeDirtyRanges } from "./incrementalMeasure.js";
+import { sweepPositions } from "../prosemirror/positionSweep.js";
 import { AddMarkStep, RemoveMarkStep } from "prosemirror-transform";
 //#region src/paged-layout/transactionDirtyRange.ts
 function getTransactionDirtyRange(transaction) {
-	const dirtyRange = {
-		from: Number.POSITIVE_INFINITY,
-		to: Number.NEGATIVE_INFINITY
-	};
-	for (let stepIndex = 0; stepIndex < transaction.mapping.maps.length; stepIndex += 1) includeStepDirtyRange(transaction, stepIndex, dirtyRange);
-	if (!Number.isFinite(dirtyRange.from) || !Number.isFinite(dirtyRange.to)) return null;
-	return dirtyRange;
-}
-/** Collect every transaction in an applied batch in the final document's coordinates. */
-function getTransactionsDirtyRange(transactions) {
-	let combinedRange = null;
-	for (let index = 0; index < transactions.length; index += 1) {
-		const transaction = transactions[index];
-		if (!transaction) continue;
-		const range = getTransactionDirtyRange(transaction);
-		if (!range) continue;
-		let from = range.from;
-		let to = range.to;
-		for (const followingTransaction of transactions.slice(index + 1)) {
-			from = followingTransaction.mapping.map(from, -1);
-			to = followingTransaction.mapping.map(to, 1);
-		}
-		combinedRange = mergeDirtyRanges(combinedRange, {
-			from,
-			to
+	const queries = [];
+	const extend = (newStart, newEnd, from) => {
+		queries.push({
+			pos: newStart,
+			assoc: -1,
+			from
+		}, {
+			pos: newEnd,
+			assoc: 1,
+			from
 		});
+	};
+	for (let stepIndex = 0; stepIndex < transaction.mapping.maps.length; stepIndex += 1) {
+		const map = transaction.mapping.maps[stepIndex];
+		if (!map) continue;
+		map.forEach((_oldStart, _oldEnd, newStart, newEnd) => extend(newStart, newEnd, stepIndex + 1));
+		const step = transaction.steps[stepIndex];
+		if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) extend(step.from, step.to, stepIndex + 1);
 	}
-	return combinedRange;
-}
-function includeStepDirtyRange(transaction, stepIndex, dirtyRange) {
-	const map = transaction.mapping.maps[stepIndex];
-	if (!map) return;
-	const followingMaps = transaction.mapping.slice(stepIndex + 1);
-	const extend = (newStart, newEnd) => {
-		const finalStart = followingMaps.map(newStart, -1);
-		const finalEnd = followingMaps.map(newEnd, 1);
-		dirtyRange.from = Math.min(dirtyRange.from, finalStart, finalEnd);
-		dirtyRange.to = Math.max(dirtyRange.to, finalStart, finalEnd);
+	if (queries.length === 0) return null;
+	let from = Number.POSITIVE_INFINITY;
+	let to = Number.NEGATIVE_INFINITY;
+	for (const { pos } of sweepPositions([transaction.mapping], queries)) {
+		from = Math.min(from, pos);
+		to = Math.max(to, pos);
+	}
+	return {
+		from,
+		to
 	};
-	map.forEach((_oldStart, _oldEnd, newStart, newEnd) => extend(newStart, newEnd));
-	const step = transaction.steps[stepIndex];
-	if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) extend(step.from, step.to);
 }
 //#endregion
-export { getTransactionDirtyRange, getTransactionsDirtyRange };
+export { getTransactionDirtyRange };

package/dist/panel-layout.d.ts

@@ -0,0 +1,83 @@
+//#region src/panel-layout.d.ts
+/**
+ * One layout model for the editor's side panels: the page is centred between
+ * a start track (the document outline) and an end track (the comments).
+ *
+ * The editor measures the width it has once, and this module decides how
+ * each panel is presented. Every track the page shares the row with is
+ * counted here, so the page, the outline and the comments cannot overlap:
+ * a panel either gets a track of its own or becomes a drawer the user opens
+ * on purpose. A drawer takes no track.
+ *
+ * Space goes to the page first, then the outline rail, then the comments
+ * column, then the full outline column:
+ *
+ * - comments: a column when the page, the comments and the outline rail fit;
+ *   otherwise a drawer.
+ * - outline: a column when it fits beside the page and the comments column;
+ *   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+ *
+ * The tier names the result: `wide` when every panel has its full column,
+ * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
+ * The thresholds derive from the page width (at the current zoom) and the
+ * panel widths below, never from fixed breakpoints: a zoomed-out page or a
+ * landscape section moves them.
+ */
+/** Widths, in CSS pixels, every tier is derived from. */
+declare const PANEL_METRICS: {
+  /** The outline column in the `wide` tier, border included. */
+  readonly outlineColumnWidth: 256;
+  /** The outline rail in the `medium` tier, border included. */
+  readonly outlineRailWidth: 32;
+  /** A comment card column. */
+  readonly commentsWidth: 280;
+  /** Space between the page edge and the comment cards, and after them. */
+  readonly commentsGap: 12;
+  /** Canvas kept clear on either side of the page. */
+  readonly pageMargin: 20;
+  /** An outline or comments drawer, capped by the width it opens over. */
+  readonly drawerWidth: 304;
+};
+/** Width the comments take beside the page: gap, cards, gap. */
+declare const COMMENTS_TRACK_WIDTH: number;
+type PanelLayoutTier = "wide" | "medium" | "narrow";
+/** How the outline is shown: a column, a rail of ticks, a drawer, or not at all. */
+type OutlinePresentation = "none" | "column" | "rail" | "drawer";
+/** How the comments are shown: a column beside the page, a drawer, or not at all. */
+type CommentsPresentation = "hidden" | "column" | "drawer";
+type PanelLayoutInput = {
+  /** Width of the row the outline track and the scroll viewport share, scrollbar excluded. */
+  availableWidth: number;
+  /** Width of the widest page at the current zoom. */
+  pageWidth: number;
+  /** Whether the document has an outline to show. */
+  outline: "absent" | "available";
+  /** Whether the user (or the auto-open) wants the comments shown. */
+  comments: "closed" | "open";
+};
+type PanelLayout = {
+  tier: PanelLayoutTier;
+  outline: OutlinePresentation;
+  comments: CommentsPresentation;
+  /** Width of the outline track at the page's start (outside the scroll viewport). */
+  outlineTrackWidth: number;
+  /** Width reserved after the page inside the scroll viewport for the comments. */
+  commentsGutter: number;
+  /** Smallest available width for each tier, for the same page and panels. */
+  thresholds: {
+    wide: number;
+    medium: number;
+  };
+};
+/**
+ * The smallest available width for each tier with the comments wanted as
+ * given: `wide` fits every column, `medium` fits the outline rail and the
+ * comments column.
+ */
+declare const panelLayoutThresholds: ({ pageWidth, outline, comments }: Omit<PanelLayoutInput, "availableWidth">) => PanelLayout["thresholds"];
+/** Decide each panel's presentation for the width the editor has. */
+declare const computePanelLayout: (input: PanelLayoutInput) => PanelLayout;
+/** Which drawer is open over the page: at most one at a time. */
+type PanelOverlay = "none" | "outline" | "comments";
+//#endregion
+export { COMMENTS_TRACK_WIDTH, CommentsPresentation, OutlinePresentation, PANEL_METRICS, PanelLayout, PanelLayoutInput, PanelLayoutTier, PanelOverlay, computePanelLayout, panelLayoutThresholds };

package/dist/panel-layout.js

@@ -0,0 +1,96 @@
+//#region src/panel-layout.ts
+/**
+* One layout model for the editor's side panels: the page is centred between
+* a start track (the document outline) and an end track (the comments).
+*
+* The editor measures the width it has once, and this module decides how
+* each panel is presented. Every track the page shares the row with is
+* counted here, so the page, the outline and the comments cannot overlap:
+* a panel either gets a track of its own or becomes a drawer the user opens
+* on purpose. A drawer takes no track.
+*
+* Space goes to the page first, then the outline rail, then the comments
+* column, then the full outline column:
+*
+* - comments: a column when the page, the comments and the outline rail fit;
+*   otherwise a drawer.
+* - outline: a column when it fits beside the page and the comments column;
+*   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+*
+* The tier names the result: `wide` when every panel has its full column,
+* `medium` when the outline is a rail, `narrow` when a panel is a drawer.
+* The thresholds derive from the page width (at the current zoom) and the
+* panel widths below, never from fixed breakpoints: a zoomed-out page or a
+* landscape section moves them.
+*/
+/** Widths, in CSS pixels, every tier is derived from. */
+const PANEL_METRICS = {
+	/** The outline column in the `wide` tier, border included. */
+	outlineColumnWidth: 256,
+	/** The outline rail in the `medium` tier, border included. */
+	outlineRailWidth: 32,
+	/** A comment card column. */
+	commentsWidth: 280,
+	/** Space between the page edge and the comment cards, and after them. */
+	commentsGap: 12,
+	/** Canvas kept clear on either side of the page. */
+	pageMargin: 20,
+	/** An outline or comments drawer, capped by the width it opens over. */
+	drawerWidth: 304
+};
+/** Width the comments take beside the page: gap, cards, gap. */
+const COMMENTS_TRACK_WIDTH = PANEL_METRICS.commentsWidth + 2 * PANEL_METRICS.commentsGap;
+const pageTrackWidth = (pageWidth) => pageWidth + 2 * PANEL_METRICS.pageMargin;
+/**
+* The smallest available width for each tier with the comments wanted as
+* given: `wide` fits every column, `medium` fits the outline rail and the
+* comments column.
+*/
+const panelLayoutThresholds = ({ pageWidth, outline, comments }) => {
+	const page = pageTrackWidth(pageWidth);
+	const commentsTrack = comments === "open" ? COMMENTS_TRACK_WIDTH : 0;
+	const hasOutline = outline === "available";
+	return {
+		wide: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineColumnWidth : 0),
+		medium: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineRailWidth : 0)
+	};
+};
+const OUTLINE_TRACK_WIDTH = {
+	none: 0,
+	column: PANEL_METRICS.outlineColumnWidth,
+	rail: PANEL_METRICS.outlineRailWidth,
+	drawer: 0
+};
+const tierFor = (outline, comments) => {
+	if (outline === "drawer" || comments === "drawer") return "narrow";
+	if (outline === "rail") return "medium";
+	return "wide";
+};
+/** Decide each panel's presentation for the width the editor has. */
+const computePanelLayout = (input) => {
+	const { availableWidth } = input;
+	const thresholds = panelLayoutThresholds(input);
+	const page = pageTrackWidth(input.pageWidth);
+	const comments = (() => {
+		if (input.comments === "closed") return "hidden";
+		return availableWidth >= thresholds.medium ? "column" : "drawer";
+	})();
+	const commentsGutter = comments === "column" ? COMMENTS_TRACK_WIDTH : 0;
+	const outline = (() => {
+		if (input.outline === "absent") return "none";
+		const beside = page + commentsGutter;
+		if (availableWidth >= thresholds.wide) return "column";
+		if (availableWidth >= beside + PANEL_METRICS.outlineRailWidth) return "rail";
+		return "drawer";
+	})();
+	return {
+		tier: tierFor(outline, comments),
+		outline,
+		comments,
+		outlineTrackWidth: OUTLINE_TRACK_WIDTH[outline],
+		commentsGutter,
+		thresholds
+	};
+};
+//#endregion
+export { COMMENTS_TRACK_WIDTH, PANEL_METRICS, computePanelLayout, panelLayoutThresholds };

package/dist/prosemirror/anchoredTextBoxes.d.ts

@@ -0,0 +1,37 @@
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/anchoredTextBoxes.d.ts
+/** The id a text box anchor names, or `undefined` for anything else. */
+declare const textBoxAnchorIdOf: (node: Node) => string | undefined;
+/** The anchor ids of the text boxes drawn in `node`. */
+declare const textBoxAnchorIdsIn: (node: Node) => Set<string>;
+/** The anchor id of a text box block drawn in a paragraph, or `undefined`. */
+declare const anchoredTextBoxId: (node: Node) => string | undefined;
+/**
+ * Where the paragraph at `position` ends together with the text boxes drawn
+ * in it that follow it: the place for a block inserted after the paragraph.
+ */
+declare const endOfParagraphWithItsTextBoxes: (doc: Node, position: number) => number;
+/** Anchor ids `before` holds and `after` does not. */
+declare const droppedTextBoxAnchorIds: (before: Node, after: Node) => Set<string>;
+/**
+ * Delete the text box blocks whose anchors are in `anchorIds`. Returns whether
+ * any went.
+ */
+declare const deleteTextBoxesAnchoredAt: (tr: Transaction, anchorIds: ReadonlySet<string>) => boolean;
+/**
+ * Put every text box drawn in the paragraph at `position` right after it,
+ * keeping the boxes' order. For a paragraph just split: the boxes follow the
+ * second half, and those anchored in the first half move up to it.
+ */
+declare const gatherTextBoxesAfterParagraph: (tr: Transaction, position: number) => void;
+/** The anchor ids of the text boxes drawn between `from` and `to`. */
+declare const textBoxAnchorIdsBetween: (doc: Node, from: number, to: number) => Set<string>;
+/**
+ * Before the paragraph at `position` joins the one after it: move the text
+ * boxes drawn in it, which stand between the two, past that paragraph, where
+ * they follow the joined one. Returns whether any moved.
+ */
+declare const moveTextBoxesPastNextParagraph: (tr: Transaction, position: number) => boolean;
+//#endregion
+export { anchoredTextBoxId, deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, moveTextBoxesPastNextParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween, textBoxAnchorIdsIn };

package/dist/prosemirror/anchoredTextBoxes.js

@@ -0,0 +1,156 @@
+import { expectTextBoxAttrs } from "./attrs/index.js";
+import "./extensions/nodes/TextBoxAnchorExtension.js";
+import { readTextBoxAnchorAttrs } from "./textBoxAnchorAttrs.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/anchoredTextBoxes.ts
+/**
+* A text box and the paragraph it is drawn in.
+*
+* In DOCX a text box is run content: a `w:drawing` in a run of its paragraph.
+* The editor lifts it out into a `textBox` block after that paragraph and
+* leaves a zero-width `textBoxAnchor` where the run was; the save puts the box
+* back at its anchor, wherever the block has ended up. So the anchor, not the
+* block's position, says which paragraph owns the box, and two rules follow:
+*
+* - The box follows its anchor. A paragraph deleted, or its anchor deleted,
+*   takes the box with it: a drawing is content of the paragraph it is in.
+*   Left behind, the block was saved into whatever paragraph came before it.
+* - The box sits right after its paragraph. The reader lists the box's
+*   paragraphs where the block is, and a reopened package puts the block
+*   right after the paragraph holding its anchor, so a block written between
+*   the two is read in a different order once saved.
+*
+* Only a box placed `inlineWithPrevious` has an anchor: a `standalone` one
+* stands in for a paragraph that held nothing else.
+*/
+/**
+* Add the anchor id of `node`, when it is an anchor that names one. An anchor
+* naming none ties no box to its paragraph.
+*/
+const collectAnchorId = (node, ids) => {
+	const anchorId = textBoxAnchorIdOf(node);
+	if (anchorId !== void 0) ids.add(anchorId);
+};
+/** The id a text box anchor names, or `undefined` for anything else. */
+const textBoxAnchorIdOf = (node) => {
+	if (node.type.name !== "textBoxAnchor") return;
+	const attrs = readTextBoxAnchorAttrs(node);
+	return attrs.ok ? attrs.value.anchorId : void 0;
+};
+/** The anchor ids of the text boxes drawn in `node`. */
+const textBoxAnchorIdsIn = (node) => {
+	const ids = /* @__PURE__ */ new Set();
+	node.descendants((child) => {
+		collectAnchorId(child, ids);
+		return true;
+	});
+	return ids;
+};
+/** The anchor id of a text box block drawn in a paragraph, or `undefined`. */
+const anchoredTextBoxId = (node) => {
+	if (node.type.name !== "textBox") return;
+	const attrs = expectTextBoxAttrs(node);
+	return attrs._docxPlacement === "inlineWithPrevious" ? attrs._docxAnchorId : void 0;
+};
+/**
+* Where the paragraph at `position` ends together with the text boxes drawn
+* in it that follow it: the place for a block inserted after the paragraph.
+*/
+const endOfParagraphWithItsTextBoxes = (doc, position) => {
+	const paragraph = doc.nodeAt(position);
+	if (!paragraph) return position;
+	let end = position + paragraph.nodeSize;
+	const anchors = textBoxAnchorIdsIn(paragraph);
+	if (anchors.size === 0) return end;
+	const after = doc.resolve(end);
+	for (let index = after.index(); index < after.parent.childCount; index += 1) {
+		const sibling = after.parent.child(index);
+		const anchorId = anchoredTextBoxId(sibling);
+		if (anchorId === void 0 || !anchors.has(anchorId)) break;
+		end += sibling.nodeSize;
+	}
+	return end;
+};
+/** Anchor ids `before` holds and `after` does not. */
+const droppedTextBoxAnchorIds = (before, after) => {
+	const dropped = textBoxAnchorIdsIn(before);
+	if (dropped.size === 0) return dropped;
+	for (const anchorId of textBoxAnchorIdsIn(after)) dropped.delete(anchorId);
+	return dropped;
+};
+/**
+* Delete the text box blocks whose anchors are in `anchorIds`. Returns whether
+* any went.
+*/
+const deleteTextBoxesAnchoredAt = (tr, anchorIds) => {
+	if (anchorIds.size === 0) return false;
+	const ranges = [];
+	tr.doc.descendants((node, position) => {
+		const anchorId = anchoredTextBoxId(node);
+		if (anchorId !== void 0 && anchorIds.has(anchorId)) {
+			ranges.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			return false;
+		}
+		return !node.isTextblock;
+	});
+	for (const { from, to } of ranges.toReversed()) tr.delete(from, to);
+	return ranges.length > 0;
+};
+/**
+* Put every text box drawn in the paragraph at `position` right after it,
+* keeping the boxes' order. For a paragraph just split: the boxes follow the
+* second half, and those anchored in the first half move up to it.
+*/
+const gatherTextBoxesAfterParagraph = (tr, position) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return;
+	const anchors = textBoxAnchorIdsIn(paragraph);
+	if (anchors.size === 0) return;
+	const boxesEnd = endOfParagraphWithItsTextBoxes(tr.doc, position);
+	const at = tr.doc.resolve(boxesEnd);
+	const moved = [];
+	let offset = boxesEnd;
+	for (let index = at.index(); index < at.parent.childCount; index += 1) {
+		const sibling = at.parent.child(index);
+		const anchorId = anchoredTextBoxId(sibling);
+		if (anchorId !== void 0 && anchors.has(anchorId)) moved.push({
+			node: sibling,
+			from: offset
+		});
+		offset += sibling.nodeSize;
+	}
+	if (moved.length === 0) return;
+	for (const { node, from } of moved.toReversed()) tr.delete(from, from + node.nodeSize);
+	tr.insert(boxesEnd, Fragment.fromArray(moved.map(({ node }) => node)));
+};
+/** The anchor ids of the text boxes drawn between `from` and `to`. */
+const textBoxAnchorIdsBetween = (doc, from, to) => {
+	const ids = /* @__PURE__ */ new Set();
+	doc.nodesBetween(from, to, (node) => {
+		collectAnchorId(node, ids);
+		return true;
+	});
+	return ids;
+};
+/**
+* Before the paragraph at `position` joins the one after it: move the text
+* boxes drawn in it, which stand between the two, past that paragraph, where
+* they follow the joined one. Returns whether any moved.
+*/
+const moveTextBoxesPastNextParagraph = (tr, position) => {
+	const paragraph = tr.doc.nodeAt(position);
+	if (!paragraph) return false;
+	const paragraphEnd = position + paragraph.nodeSize;
+	const boxesEnd = endOfParagraphWithItsTextBoxes(tr.doc, position);
+	const next = boxesEnd > paragraphEnd ? tr.doc.nodeAt(boxesEnd) : null;
+	if (!next || next.type !== paragraph.type) return false;
+	const boxes = tr.doc.slice(paragraphEnd, boxesEnd).content;
+	tr.delete(paragraphEnd, boxesEnd);
+	tr.insert(paragraphEnd + next.nodeSize, boxes);
+	return true;
+};
+//#endregion
+export { anchoredTextBoxId, deleteTextBoxesAnchoredAt, droppedTextBoxAnchorIds, endOfParagraphWithItsTextBoxes, gatherTextBoxesAfterParagraph, moveTextBoxesPastNextParagraph, textBoxAnchorIdOf, textBoxAnchorIdsBetween, textBoxAnchorIdsIn };

package/dist/prosemirror/attrs/index.d.ts

@@ -1,5 +1,5 @@
 import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, InlineWrapperAttrs, InlineWrapperLayer, LanguageAttrs, RunFormattingOverrideAttrs, RunIdentityMarkAttrs, RunPropertyChangeMarkAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, TrackedRevisionAncestor, UnderlineAttrs } from "../schema/marks.js";
-import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
+import { BlockCustomXmlAttrs, BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, PageBreakRunAttrs, ParagraphAttrs, PreservedBlockAttrs, PreservedXmlAttrs, SdtAttrs, ShapeAttrs, SymbolAttrs, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
 import "../schema/index.js";
 import { Mark, Node } from "prosemirror-model";
 //#region src/prosemirror/attrs/index.d.ts
@@ -36,12 +36,16 @@ declare const readTableCellAttrs: (node: Node) => ReadProseMirrorAttrsResult<Tab
 declare const expectTableCellAttrs: (node: Node) => TableCellAttrs;
 declare const readImageAttrs: (node: Node) => ReadProseMirrorAttrsResult<ImageAttrs>;
 declare const expectImageAttrs: (node: Node) => ImageAttrs;
+declare const isValidEmptyFieldResultRuns: (value: unknown) => value is NonNullable<FieldAttrs["_docxEmptyResultRuns"]>;
+declare const isValidFieldCode: (value: unknown) => value is NonNullable<FieldAttrs["_docxFieldCode"]>;
 declare const readFieldAttrs: (node: Node) => ReadProseMirrorAttrsResult<FieldAttrs>;
 declare const expectFieldAttrs: (node: Node) => FieldAttrs;
 declare const readMathAttrs: (node: Node) => ReadProseMirrorAttrsResult<MathAttrs>;
 declare const expectMathAttrs: (node: Node) => MathAttrs;
 declare const readSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<SdtAttrs>;
 declare const expectSdtAttrs: (node: Node) => SdtAttrs;
+declare const readBlockCustomXmlAttrs: (node: Node) => ReadProseMirrorAttrsResult<BlockCustomXmlAttrs>;
+declare const expectBlockCustomXmlAttrs: (node: Node) => BlockCustomXmlAttrs;
 declare const readBlockSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<BlockSdtAttrs>;
 declare const expectBlockSdtAttrs: (node: Node) => BlockSdtAttrs;
 declare const readShapeAttrs: (node: Node) => ReadProseMirrorAttrsResult<ShapeAttrs>;
@@ -119,4 +123,4 @@ declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttr
  */
 declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
 //#endregion
-export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };