@stll/folio-core 0.51.0 → 0.53.0

package/dist/prosemirror/schema/nodes.d.ts

@@ -56,6 +56,8 @@ type PreservedXmlAttrs = {
 type PreservedBlockAttrs = {
   /** Replayable markup, as `captureVerbatimXml` wrote it. */
   xml: string;
+  /** Plain text safely extracted from a related w:altChunk part, when available. */
+  readerText?: string;
 };
 type BookmarkBoundaryAttrs = {
   type: "start";
@@ -118,6 +120,13 @@ type ParagraphAttrs = {
    * `paragraphNumberingAttr`, so a model value cannot land here unconverted.
    */
   numPr?: ParagraphNumberingAttr;
+  /** Clipboard-only hint, replaced with a numbered paragraph before insertion. */
+  _pastedHtmlList?: {
+    group: number;
+    level: number;
+    kind: "bullet" | "numbered";
+    start?: number;
+  };
   /**
    * The style-sourced numPr value when `numPr` came from the paragraph
    * style rather than direct formatting. While `numPr` still equals this,
@@ -526,7 +535,7 @@ type ImageAttrs = {
 /**
  * Field node attributes
  */
-type FieldAttrs = {
+type CommonFieldAttrs = {
   /** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */
   fieldType: document_d_exports.FieldType;
   /** Full field instruction (e.g. "PAGE \\* MERGEFORMAT") */
@@ -535,20 +544,30 @@ type FieldAttrs = {
   displayText: string;
   /** Imported cache that proved numbered REF resolution for this field. */
   _numberedRefBaseline?: string;
-  /** Whether the field came from w:fldSimple or a complex fldChar range */
-  fieldKind: "simple" | "complex";
   /** Field is locked */
   fldLock?: boolean;
   /** Field is dirty and should be recalculated by the host application */
   dirty?: boolean;
-  /**
-   * `displayText` is a rendering fallback folio synthesized (e.g. a legacy
-   * `FORMCHECKBOX` with no cached result run), not authored content. A save
-   * omits it from the field's result so an unedited field keeps its
-   * original, resultless bytes. See `ComplexField.fieldResultIsFallback`.
-   */
-  fieldResultIsFallback?: boolean;
+  /** Authored empty result runs, which have no visible ProseMirror children. */
+  _docxEmptyResultRuns?: document_d_exports.Run[];
 };
+type FieldAttrs = CommonFieldAttrs & ({
+  fieldKind: "simple";
+  fieldResultIsFallback?: never;
+  formFieldDataXml?: never;
+  _docxFieldCode?: never;
+} | {
+  fieldKind: "complex";
+  /** Synthesized display text that must not become an authored result run. */
+  fieldResultIsFallback?: boolean;
+  /** Captured `w:ffData` on a complex field's begin character. */
+  formFieldDataXml?: string;
+  /** Source code runs; valid only while the instruction still matches. */
+  _docxFieldCode?: {
+    instruction: string;
+    runs: document_d_exports.Run[];
+  };
+});
 /**
  * Math equation node attributes
  */
@@ -649,6 +668,12 @@ type BlockSdtAttrs = {
   /** Verbatim XML for sdt siblings after sdtContent (range markers). */
   rawSdtChildrenAfterContent?: string;
 };
+/** Verbatim shell retained around editable block custom XML content. */
+type BlockCustomXmlAttrs = {
+  openingXml: string;
+  closingXml: string;
+  _originallyEmpty: boolean;
+};
 /**
  * The `mc:AlternateContent` a shape or text box was read from, with a
  * fingerprint of the node it was attached to. `fromProseDoc` hands the element
@@ -992,6 +1017,8 @@ type TableAttrs = {
    * none and a copy does not inherit one.
    */
   _preserved?: document_d_exports.TablePreservedMarkup;
+  /** Transparent table-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Marks this whole table as a *suggested* insertion (AI proposal). The table
    * is dropped from serialized DOCX until accepted; because OOXML has no tracked
@@ -1054,6 +1081,8 @@ type TableRowAttrs = {
    * name the same control. See `TableRow.contentControls`.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /**
    * Markup the authored `w:tr` carried beside its cells, with the cell count
    * that places it back between the same two cells. Follows the record the
@@ -1219,10 +1248,12 @@ type TableCellAttrs = {
    * outermost first. The row's twin, one level down.
    */
   contentControls?: document_d_exports.SdtProperties[];
+  /** Transparent row-level custom-XML wrappers, outermost first. */
+  carrierStack?: document_d_exports.TableContentCarrier[];
   /** Preserve a DOCX vMerge restart even when PM cannot model it as a rowspan. */
   _preserveVMergeRestart?: boolean;
   /** Original DOCX vMerge continuation cells skipped into this PM rowspan. */
   _docxVMergeContinuationCells?: unknown;
 };
 //#endregion
-export { AlternateContentAttrs, AuthoredEmuAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };
+export { AlternateContentAttrs, AuthoredEmuAttrs, BlockCustomXmlAttrs, BlockSdtAttrs, BookmarkBoundaryAttrs, CommentReferenceAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, ImagePositionAttrs, MathAttrs, PRESERVED_XML_LEVELS, PageBreakRunAttrs, ParagraphAttrs, ParagraphAttrsPatch, ParagraphPropertyChangeAttrs, PreservedBlockAttrs, PreservedXmlAttrs, PreservedXmlLevel, SdtAttrs, ShapeAttrs, SuggestedStructuralMarker, SymbolAttrs, TEXT_BOX_TEXT_BODY_CONTENT_STATE_TYPES, TabAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAnchorAttrs, TextBoxAttrs, TextBoxTextBodyContentState };

package/dist/prosemirror/sectionMarkEdits.d.ts

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+//#region src/prosemirror/sectionMarkEdits.d.ts
+type SectionMarkEdits = {
+  /** Section records whose paragraph mark a replacement deleted. */
+  deletedMarks: ReadonlySet<document_d_exports.SectionProperties>;
+  /**
+   * Paragraphs of the final document, by position, and the section record
+   * each must hold because of the mark it now ends with.
+   */
+  carriers: readonly {
+    position: number;
+    record: document_d_exports.SectionProperties | null;
+  }[];
+};
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+declare const sectionMarkEditsOf: (transactions: readonly Transaction[], finalDoc: Node) => SectionMarkEdits;
+//#endregion
+export { SectionMarkEdits, sectionMarkEditsOf };

package/dist/prosemirror/sectionMarkEdits.js

@@ -0,0 +1,59 @@
+import { sectionPropertiesOf } from "./sectionCarrier.js";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+//#region src/prosemirror/sectionMarkEdits.ts
+const isParagraph = (node) => node.type.name === "paragraph";
+/** Read `transactions`, applied in order and ending at `finalDoc`. */
+const sectionMarkEditsOf = (transactions, finalDoc) => {
+	const deletedMarks = /* @__PURE__ */ new Set();
+	const carriers = [];
+	const replacements = [];
+	const mapping = new Mapping();
+	for (const transaction of transactions) for (const [index, step] of transaction.steps.entries()) {
+		const doc = transaction.docs[index];
+		if (step instanceof ReplaceStep && step.from < step.to && doc) replacements.push({
+			step,
+			doc,
+			mapIndex: mapping.maps.length
+		});
+		const map = transaction.mapping.maps[index];
+		if (map) mapping.appendMap(map);
+	}
+	for (const { step, doc, mapIndex } of replacements) {
+		const { from, to } = step;
+		doc.nodesBetween(from, to, (node, position) => {
+			if (!isParagraph(node)) return true;
+			const record = sectionPropertiesOf(node);
+			const markFrom = position + node.nodeSize - 1;
+			if (record && markFrom >= from && markFrom + 1 <= to) deletedMarks.add(record);
+			return false;
+		});
+		const $from = doc.resolve(from);
+		const $to = doc.resolve(to);
+		if (!isParagraph($from.parent) || !isParagraph($to.parent) || $from.start() === $to.start()) continue;
+		const leftRecord = sectionPropertiesOf($from.parent);
+		const rightRecord = sectionPropertiesOf($to.parent);
+		if (leftRecord === null && rightRecord === null) continue;
+		const after = mapping.slice(mapIndex);
+		const left = after.mapResult(from, -1);
+		const right = after.mapResult(to, 1);
+		if (right.deleted) continue;
+		const $right = finalDoc.resolve(right.pos);
+		if (!isParagraph($right.parent)) continue;
+		carriers.push({
+			position: $right.before(),
+			record: rightRecord
+		});
+		if (left.deleted) continue;
+		const $left = finalDoc.resolve(left.pos);
+		if (isParagraph($left.parent) && $left.start() !== $right.start()) carriers.push({
+			position: $left.before(),
+			record: null
+		});
+	}
+	return {
+		deletedMarks,
+		carriers
+	};
+};
+//#endregion
+export { sectionMarkEditsOf };

package/dist/prosemirror/storyListNumbering.d.ts

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../types/document.js";
+import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/storyListNumbering.d.ts
+type StoryListNumbering = {
+  /** The story with every colliding list moved to its own ids. */
+  doc: Node;
+  /** `numbering` plus the lists the story defines. */
+  numbering: document_d_exports.NumberingDefinitions | undefined;
+};
+/**
+ * The story in `state` as it should be written into a package whose numbering
+ * is now `numbering`, and that numbering completed with the story's lists.
+ */
+declare const storyListNumbering: (state: EditorState, numbering: document_d_exports.NumberingDefinitions | undefined) => StoryListNumbering;
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/storyListNumbering.js

@@ -0,0 +1,102 @@
+import { getCachedNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
+import { paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
+import { expectParagraphAttrs } from "./attrs/index.js";
+import { completeNumberingForDoc, paragraphListReferences } from "./listInstanceReferences.js";
+import { paragraphNumberingAttr } from "./numberingAttr.js";
+import { getPackageNumberingDefinitions } from "./plugins/documentNumbering.js";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/storyListNumbering.ts
+const remappedNumPr = (numPr, numIds) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const next = numId === void 0 ? void 0 : numIds.get(numId);
+	if (next === void 0) return numPr;
+	const ilvl = paragraphNumberingLevel(numPr ?? void 0);
+	return paragraphNumberingAttr(paragraphNumberingReference(ilvl === void 0 ? { numId: next } : {
+		numId: next,
+		ilvl
+	}));
+};
+const remappedAbstractNumId = (abstractNumId, remap) => {
+	if (abstractNumId === null || abstractNumId === void 0 || remap.baseAbstractNumIds.has(abstractNumId)) return abstractNumId;
+	let next = remap.abstractNumIds.get(abstractNumId);
+	if (next === void 0) {
+		next = remap.nextAbstractNumId++;
+		remap.abstractNumIds.set(abstractNumId, next);
+	}
+	return next;
+};
+const maxOf = (ids, floor) => {
+	let max = floor;
+	for (const id of ids) max = Math.max(max, id);
+	return max;
+};
+/**
+* The story in `state` as it should be written into a package whose numbering
+* is now `numbering`, and that numbering completed with the story's lists.
+*/
+const storyListNumbering = (state, numbering) => {
+	const packageDefinitions = getPackageNumberingDefinitions(state);
+	const storyBase = new Set((packageDefinitions?.nums ?? []).map(({ numId }) => numId));
+	const defined = new Set((numbering?.nums ?? []).map(({ numId }) => numId));
+	const definedMap = numbering ? getCachedNumberingMap(numbering) : null;
+	const referenced = /* @__PURE__ */ new Set();
+	const colliding = /* @__PURE__ */ new Set();
+	state.doc.descendants((node) => {
+		if (node.type.name !== "paragraph") return true;
+		for (const numId of paragraphListReferences(node)) referenced.add(numId);
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		if (numId !== void 0 && !storyBase.has(numId) && definedMap?.hasNumbering(numId)) {
+			const level = definedMap.getLevel(numId, paragraphNumberingLevel(attrs.numPr) ?? 0);
+			if (!(level !== null && isBulletLevel(level) === (attrs.listIsBullet === true) && (attrs.listAbstractNumId ?? void 0) === (definedMap.getAbstractNumId(numId) ?? void 0))) colliding.add(numId);
+		}
+		return false;
+	});
+	if (colliding.size === 0) return {
+		doc: state.doc,
+		numbering: completeNumberingForDoc(numbering, state.doc)
+	};
+	let nextNumId = maxOf([...defined, ...referenced], 0) + 1;
+	const remap = {
+		numIds: new Map([...colliding].map((numId) => [numId, nextNumId++])),
+		baseAbstractNumIds: new Set((packageDefinitions?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId)),
+		abstractNumIds: /* @__PURE__ */ new Map(),
+		nextAbstractNumId: maxOf((numbering?.abstractNums ?? []).map(({ abstractNumId }) => abstractNumId), -1) + 1
+	};
+	const tr = new Transform(state.doc);
+	state.doc.descendants((node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		const attrs = expectParagraphAttrs(node);
+		const numId = paragraphNumberingReferenceId(attrs.numPr);
+		const moves = numId !== void 0 && remap.numIds.has(numId);
+		const changes = attrs._propertyChanges?.map((change) => {
+			const previous = change.previousFormatting;
+			const previousNumId = paragraphNumberingReferenceId(previous?.numPr ?? void 0);
+			if (!previous || previousNumId === void 0 || !remap.numIds.has(previousNumId)) return change;
+			return {
+				...change,
+				previousFormatting: {
+					...previous,
+					numPr: remappedNumPr(previous.numPr, remap.numIds),
+					listAbstractNumId: remappedAbstractNumId(previous.listAbstractNumId, remap) ?? void 0
+				}
+			};
+		});
+		const changesMoved = changes?.some((change, index) => change !== attrs._propertyChanges?.[index]);
+		if (moves || changesMoved) tr.setNodeMarkup(pos, void 0, {
+			...node.attrs,
+			...moves ? {
+				numPr: remappedNumPr(attrs.numPr, remap.numIds),
+				listAbstractNumId: remappedAbstractNumId(attrs.listAbstractNumId, remap) ?? null
+			} : {},
+			...changesMoved ? { _propertyChanges: changes } : {}
+		});
+		return false;
+	});
+	return {
+		doc: tr.doc,
+		numbering: completeNumberingForDoc(numbering, tr.doc)
+	};
+};
+//#endregion
+export { storyListNumbering };

package/dist/prosemirror/tableGridMutation.d.ts

@@ -1,6 +1,38 @@
-import { Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
+import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.d.ts
+type RemoveTableRowOptions = {
+  map: TableMap;
+  table: Node;
+  tableStart: number;
+};
+/**
+ * Remove one row, keeping every vertical merge that touches it whole: a merge
+ * reaching through the row from above closes one row sooner, and a cell that
+ * starts in the row and spans down moves into the row below, one row shorter.
+ *
+ * `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+ * across the row skips a cell's extra columns without moving its map index
+ * along with them, so after a cell wider than one column it reads the wrong
+ * slots: a merge reaching through the row further right is never shortened,
+ * and the table is left one row shorter than that merge.
+ */
+declare const removeTableRow: (tr: Transaction, { map, table, tableStart }: RemoveTableRowOptions, row: number) => void;
+/**
+ * Remove every row a structural edit left without a cell of its own, closing
+ * the vertical merges that reached through it over one row fewer.
+ *
+ * Deleting the only column a row still had a cell in, or merging whole rows
+ * together, leaves a row holding nothing but the merges from above. The
+ * editable model can carry such a row, but nothing else agrees with it: a
+ * package spells it as a row of `w:vMerge` continuations, which the reader
+ * gives a cell of its own by splitting the merge apart, so the reopened table
+ * differs from the one the operation reported. Accepting the same deletion
+ * tracked removes the cells one at a time and the row with its last one,
+ * which is this result; the two modes have to leave the same table.
+ */
+declare const removeRowsWithoutCells: (tr: Transaction, tablePosition: number) => void;
 type ReconcileTableGridAfterColumnRemovalOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -16,5 +48,19 @@ type ReconcileTableGridAfterColumnRemovalOptions = {
  * the old grid; reopening then has to interpret surviving cells as spans.
  */
 declare const reconcileTableGridAfterColumnRemoval: ({ tr, tablePosition, previousTable, removedColumn }: ReconcileTableGridAfterColumnRemovalOptions) => void;
+type ReconcileTableGridAfterColumnInsertionOptions = {
+  tr: Transaction;
+  tablePosition: number;
+  previousTable: Node;
+  insertedColumn: number;
+};
+/**
+ * The same for a physical column insertion: the new grid column takes the
+ * width of the column beside it, and the table grows by it.
+ *
+ * Without it the table keeps the grid it had, so every row spans one column
+ * more than `w:tblGrid` declares.
+ */
+declare const reconcileTableGridAfterColumnInsertion: ({ tr, tablePosition, previousTable, insertedColumn }: ReconcileTableGridAfterColumnInsertionOptions) => void;
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow };

package/dist/prosemirror/tableGridMutation.js

@@ -2,6 +2,77 @@ import { expectTableAttrs, mergeTableAttrs } from "./attrs/index.js";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/tableGridMutation.ts
 /**
+* Remove one row, keeping every vertical merge that touches it whole: a merge
+* reaching through the row from above closes one row sooner, and a cell that
+* starts in the row and spans down moves into the row below, one row shorter.
+*
+* `prosemirror-tables` exports the same operation as `removeRow`, but its walk
+* across the row skips a cell's extra columns without moving its map index
+* along with them, so after a cell wider than one column it reads the wrong
+* slots: a merge reaching through the row further right is never shortened,
+* and the table is left one row shorter than that merge.
+*/
+const removeTableRow = (tr, { map, table, tableStart }, row) => {
+	let rowPosition = 0;
+	for (let index = 0; index < row; index++) rowPosition += table.child(index).nodeSize;
+	const nextRow = rowPosition + table.child(row).nodeSize;
+	const mapFrom = tr.mapping.maps.length;
+	tr.delete(tableStart + rowPosition, tableStart + nextRow);
+	for (let column = 0; column < map.width;) {
+		const index = row * map.width + column;
+		const position = map.map[index];
+		const cell = position === void 0 ? null : table.nodeAt(position);
+		if (position === void 0 || !cell) {
+			column += 1;
+			continue;
+		}
+		const colspan = Math.max(1, Number(cell.attrs["colspan"]) || 1);
+		const rowspan = Math.max(1, Number(cell.attrs["rowspan"]) || 1);
+		if (row > 0 && position === map.map[index - map.width]) tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(tableStart + position), null, {
+			...cell.attrs,
+			rowspan: rowspan - 1
+		});
+		else if (row + 1 < map.height && position === map.map[index + map.width]) {
+			const moved = cell.type.create({
+				...cell.attrs,
+				rowspan: rowspan - 1
+			}, cell.content);
+			const below = map.positionAt(row + 1, column, table);
+			tr.insert(tr.mapping.slice(mapFrom).map(tableStart + below), moved);
+		}
+		column += colspan;
+	}
+};
+/**
+* Remove every row a structural edit left without a cell of its own, closing
+* the vertical merges that reached through it over one row fewer.
+*
+* Deleting the only column a row still had a cell in, or merging whole rows
+* together, leaves a row holding nothing but the merges from above. The
+* editable model can carry such a row, but nothing else agrees with it: a
+* package spells it as a row of `w:vMerge` continuations, which the reader
+* gives a cell of its own by splitting the merge apart, so the reopened table
+* differs from the one the operation reported. Accepting the same deletion
+* tracked removes the cells one at a time and the row with its last one,
+* which is this result; the two modes have to leave the same table.
+*/
+const removeRowsWithoutCells = (tr, tablePosition) => {
+	for (;;) {
+		const table = tr.doc.nodeAt(tablePosition);
+		if (!table || table.type.spec["tableRole"] !== "table" || table.childCount < 2) return;
+		let emptyRow = -1;
+		table.forEach((row, _offset, index) => {
+			if (emptyRow === -1 && row.childCount === 0) emptyRow = index;
+		});
+		if (emptyRow === -1) return;
+		removeTableRow(tr, {
+			map: TableMap.get(table),
+			table,
+			tableStart: tablePosition + 1
+		}, emptyRow);
+	}
+};
+/**
 * Keep the editable table grid aligned with a physical column removal.
 *
 * `prosemirror-tables` owns cell topology, but Folio separately retains the
@@ -18,6 +89,40 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 	const removedColumnCount = previousColumnCount - columnCount;
 	const previousWidths = expectTableAttrs(previousTable).columnWidths;
 	const columnWidths = previousWidths?.length === previousColumnCount ? previousWidths.toSpliced(removedColumn, removedColumnCount) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+/**
+* The same for a physical column insertion: the new grid column takes the
+* width of the column beside it, and the table grows by it.
+*
+* Without it the table keeps the grid it had, so every row spans one column
+* more than `w:tblGrid` declares.
+*/
+const reconcileTableGridAfterColumnInsertion = ({ tr, tablePosition, previousTable, insertedColumn }) => {
+	const previousColumnCount = TableMap.get(previousTable).width;
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return;
+	const columnCount = TableMap.get(table).width;
+	if (columnCount <= previousColumnCount) return;
+	const insertedColumnCount = columnCount - previousColumnCount;
+	const previousWidths = expectTableAttrs(previousTable).columnWidths;
+	const neighbourWidth = previousWidths?.[Math.max(0, Math.min(insertedColumn, previousColumnCount) - 1)] ?? previousWidths?.[0];
+	const columnWidths = previousWidths?.length === previousColumnCount && neighbourWidth !== void 0 ? previousWidths.toSpliced(insertedColumn, 0, ...Array.from({ length: insertedColumnCount }, () => neighbourWidth)) : void 0;
+	setTableGrid({
+		tr,
+		tablePosition,
+		table,
+		columnWidths,
+		columnCount
+	});
+};
+const setTableGrid = ({ tr, tablePosition, table, columnWidths, columnCount }) => {
 	const formatting = expectTableAttrs(table)._originalFormatting;
 	const originalFormatting = formatting ? { ...formatting } : void 0;
 	if (originalFormatting) delete originalFormatting.gridSourceXml;
@@ -27,4 +132,4 @@ const reconcileTableGridAfterColumnRemoval = ({ tr, tablePosition, previousTable
 	}));
 };
 //#endregion
-export { reconcileTableGridAfterColumnRemoval };
+export { reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeTableRow };

package/dist/prosemirror/validation.js

@@ -1,4 +1,4 @@
-import { readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs } from "./attrs/index.js";
+import { readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs } from "./attrs/index.js";
 import { readBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
 import { readCommentReferenceAttrs } from "./commentReferenceAttrs.js";
 import { INLINE_WRAPPER_MARK_NAME } from "./extensions/marks/InlineWrapperExtension.js";
@@ -288,6 +288,10 @@ const validateNodeAttrs = (node, path, issues) => {
 			appendAttrIssues(path, readBlockSdtAttrs(node), issues);
 			for (let i = 0; i < node.childCount; i += 1) validateNode(node.child(i), `${path}.content[${i}]`, issues);
 			return;
+		case "blockCustomXml":
+			appendAttrIssues(path, readBlockCustomXmlAttrs(node), issues);
+			for (let i = 0; i < node.childCount; i += 1) validateNode(node.child(i), `${path}.content[${i}]`, issues);
+			return;
 		case "shape":
 			appendAttrIssues(path, readShapeAttrs(node), issues);
 			return;