@portone/docx-editor 0.2.0 → 0.3.0

package/dist/schema/protection.d.ts

@@ -11,9 +11,9 @@
  *
  * The protection is editor state rather than document state: it is the reader's standing, not the
  * file's, so nothing here is written to or read from OOXML. `editor/plugins/documentProtection`
- * holds it in the state and `./protectionState` reads it back; the guard (`transactionAllowed` in
- * `./locks`) asks the judgements here. They take documents alone, so that the `./core` entry can
- * make the same judgement over a file without an editor.
+ * holds it in the state and `./protectionState` reads it back; the guard list (`./guards`) asks the
+ * judgements here. They take documents alone, so that the `./core` entry can make the same
+ * judgement over a file without an editor.
  */
 import { type Node as PMNode } from "prosemirror-model";
 export type EditingProtection = "none" | "readOnly" | "comments";
@@ -31,7 +31,20 @@ export interface ProtectionState {
 }
 /** Whether this node is one of the three a comment stands in the story as */
 export declare function isCommentNode(node: PMNode): boolean;
-/** Whether the two documents differ in nothing but their comments */
+/**
+ * The document with every comment taken out of it.
+ *
+ * `Fragment.fromArray` joins the text a marker had split, so a document a comment was put into
+ * reads the same as it did before the comment, and the two compare equal.
+ */
+export declare function withoutComments(node: PMNode): PMNode;
+/**
+ * Whether the two documents differ in nothing but their comments.
+ *
+ * The comparison is by source (`./sourceEquality`): a display value worked out again beside a
+ * comment is no content change, so it neither turns a comment edit into a body edit nor takes the
+ * ownership question off it.
+ */
 export declare function changesOnlyComments(before: PMNode, after: PMNode): boolean;
 /**
  * Whether a comment written under this identity may be edited or deleted.

package/dist/schema/protection.js

@@ -1,5 +1,6 @@
 // src/schema/protection.ts
 import { Fragment } from "prosemirror-model";
+import { sameSource } from "./sourceEquality.js";
 var COMMENT_NODES = /* @__PURE__ */ new Set([
   "commentStart",
   "commentEnd",
@@ -17,7 +18,7 @@ function withoutComments(node) {
   return node.copy(Fragment.fromArray(kept));
 }
 function changesOnlyComments(before, after) {
-  return withoutComments(before).eq(withoutComments(after));
+  return sameSource(withoutComments(before), withoutComments(after));
 }
 function stringOrNull(value) {
   return typeof value === "string" ? value : null;
@@ -166,5 +167,6 @@ export {
   commentIdentitiesKept,
   commentOwned,
   isCommentNode,
-  protectionAllows
+  protectionAllows,
+  withoutComments
 };

package/dist/schema/sourceEquality.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whether two nodes would be written back as the same XML.
+ *
+ * `Node.eq` answers a different question: whether they are the same node, display values and all.
+ * That is the right question inside an editing session, where both sides came from one import and
+ * a difference can only be an edit. It is the wrong one across a re-derivation, because the values
+ * worked out from the surroundings (`./attrRoles`) move without the document moving, and a block
+ * judged changed is a block rewritten, which costs it the markup the writer does not model.
+ *
+ * So the comparison is `Node.eq` with the display attrs left out, and nothing else left out: the
+ * type, the text, the marks and the source and session attrs all have to agree, and the recursion
+ * runs the same way, so a node that says the same thing in a different shape is still a change.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+/**
+ * Whether the two would write the same XML: the same type, text, marks and source attrs, all the
+ * way down. What the editor works out for the screen is not compared.
+ */
+export declare function sameSource(a: PMNode, b: PMNode): boolean;

package/dist/schema/sourceEquality.js

@@ -0,0 +1,39 @@
+// src/schema/sourceEquality.ts
+import { displayAttrsOf } from "./attrRoles.js";
+function sameValue(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((item, at) => sameValue(item, b[at]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const left = Object.entries(a);
+  return left.length === Object.keys(b).length && left.every(
+    ([key, value]) => key in b && sameValue(value, b[key])
+  );
+}
+function sameAttrs(display, a, b) {
+  return Object.keys(a).filter((name) => !display.includes(name)).every((name) => sameValue(a[name], b[name]));
+}
+function sameMarks(a, b) {
+  return a.length === b.length && a.every((mark, at) => {
+    const other = b[at];
+    return other !== void 0 && mark.type === other.type && sameAttrs(displayAttrsOf(mark.type), mark.attrs, other.attrs);
+  });
+}
+function sameSource(a, b) {
+  if (a === b) return true;
+  if (a.type !== b.type || !sameMarks(a.marks, b.marks) || !sameAttrs(displayAttrsOf(a.type), a.attrs, b.attrs)) {
+    return false;
+  }
+  if (a.isText) return a.text === b.text;
+  if (a.childCount !== b.childCount) return false;
+  for (let at = 0; at < a.childCount; at += 1) {
+    if (!sameSource(a.child(at), b.child(at))) return false;
+  }
+  return true;
+}
+export {
+  sameSource
+};

package/dist/styles/inlineStyle.js

@@ -59,20 +59,29 @@ function lineHeightValue(spacing) {
   return `max(${pt(spacing.pt)},${SINGLE_LINE_RATIO}em)`;
 }
 function textDecoration(format) {
+  const underline = format.underline !== void 0 && format.underline !== "none" ? format.underline : void 0;
   const lines = [];
-  if (format.underline) lines.push("underline");
+  if (underline) lines.push("underline");
   if (format.strike) lines.push("line-through");
-  if (lines.length === 0) return [];
+  if (lines.length === 0) {
+    return format.underline === "none" || format.strike === false ? ["text-decoration-line:none"] : [];
+  }
   const css = [`text-decoration-line:${lines.join(" ")}`];
-  const style = format.underline ? UNDERLINE_STYLES[format.underline] : void 0;
+  const style = underline ? UNDERLINE_STYLES[underline] : void 0;
   if (style) css.push(`text-decoration-style:${style}`);
   return css;
 }
 function inheritedRunCss(format, fontFallbacks) {
   const css = [];
-  if (format.bold) css.push("font-weight:bold");
-  if (format.italic) css.push("font-style:italic");
-  if (format.smallCaps) css.push("font-variant:small-caps");
+  if (format.bold !== void 0) {
+    css.push(`font-weight:${format.bold ? "bold" : "normal"}`);
+  }
+  if (format.italic !== void 0) {
+    css.push(`font-style:${format.italic ? "italic" : "normal"}`);
+  }
+  if (format.smallCaps !== void 0) {
+    css.push(`font-variant:${format.smallCaps ? "small-caps" : "normal"}`);
+  }
   css.push(...textDecoration(format));
   if (format.fontSizePt !== void 0)
     css.push(`font-size:${pt(format.fontSizePt)}`);

package/dist/table/cellFormatting.d.ts

@@ -41,7 +41,14 @@ export declare function setCellBorders(preset: CellBorderPreset): TableCommand;
 export declare function setCellBorderColor(hex: string | null): TableCommand;
 /** Fills the selected cells with `#RRGGBB`. Null takes the fill away */
 export declare function setCellBackground(hex: string | null): TableCommand;
-/** Whether direct cell formatting can act on the whole current cell selection. */
+/**
+ * Whether direct cell formatting can act on the whole current cell selection.
+ *
+ * What a cell records about itself is rewritten around its content, which is the block intent the
+ * guards answer (`schema/guards`): a cell a control shuts is refused, and so is every cell while a
+ * protection shuts the body. The spot asked about stands inside the cell, since that is where the
+ * control wrapping it is an ancestor.
+ */
 export declare function canSetCellFormatting(state: EditorState): boolean;
 /** The fill shared by the selected cells. Null when they differ or none is filled */
 export declare function activeCellBackground(state: EditorState): string | null;

package/dist/table/cellFormatting.js

@@ -8,8 +8,7 @@ import {
   NO_FILL,
   toCellFormat
 } from "../model/format.js";
-import { isLockedCell, transactionAllowed } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut, guardedCommand } from "../schema/guards.js";
 import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -51,19 +50,12 @@ function planChanges(rect, edit) {
   return changes;
 }
 function cellFormatCommand(edit) {
-  return (state, dispatch) => {
-    if (!pmIsInTable(state)) return false;
+  return guardedCommand((state) => {
+    if (!canSetCellFormatting(state)) return null;
     const rect = selectedRect(state);
-    if (rect.map.cellsInRect(rect).some((pos) => isLockedCell(rect.table.nodeAt(pos)))) {
-      return false;
-    }
     const changes = planChanges(rect, edit);
-    if (changes.length === 0) return false;
-    const transaction = applyChanges(state.tr, rect.tableStart, changes);
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changes.length === 0 ? null : applyChanges(state.tr, rect.tableStart, changes);
+  });
 }
 function shared(values) {
   const [first, ...rest] = values;
@@ -111,17 +103,18 @@ function selectedCells(state) {
   const cells = [];
   for (const pos of rect.map.cellsInRect(rect)) {
     const cell = rect.table.nodeAt(pos);
-    if (cell) cells.push(cell);
+    if (cell) cells.push({ node: cell, pos: rect.tableStart + pos });
   }
   return cells;
 }
 function cellFormats(state) {
-  return selectedCells(state).map((cell) => toCellFormat(cell.attrs.format));
+  return selectedCells(state).map(
+    ({ node }) => toCellFormat(node.attrs.format)
+  );
 }
 function canSetCellFormatting(state) {
-  if (editsShut(state)) return false;
   const cells = selectedCells(state);
-  return cells.length > 0 && cells.every((cell) => !isLockedCell(cell));
+  return cells.length > 0 && cells.every(({ pos }) => !editShut(state, { kind: "block", at: pos + 1 }));
 }
 function sharedValue(values) {
   const [first, ...rest] = values;

package/dist/table/commands.d.ts

@@ -1,8 +1,8 @@
 /**
  * Building a transaction and running it are kept apart.
  * Following the ProseMirror convention, calling a command without `dispatch` only
- * reports whether it can run right now, and that answer takes in the lock guard
- * (`schema/locks`), so no caller has to ask about locks separately.
+ * reports whether it can run right now, and that answer takes in every guard an edit
+ * is judged by (`schema/guards`), so no caller has to ask about them separately.
  */
 import type { EditorState, Transaction } from "prosemirror-state";
 export type TableCommand = (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;

package/dist/table/commands.js

@@ -3,7 +3,7 @@ import {
   deleteTable as pmDeleteTable,
   isInTable as pmIsInTable
 } from "prosemirror-tables";
-import { transactionAllowed } from "../schema/locks.js";
+import { guardedCommand } from "../schema/guards.js";
 import {
   buildAddColumnAfterTransaction,
   buildAddColumnBeforeTransaction,
@@ -18,26 +18,22 @@ import {
 function isInTable(state) {
   return pmIsInTable(state);
 }
-function toCommand(build) {
-  return (state, dispatch) => {
-    const tr = build(state);
-    if (!tr || !transactionAllowed(tr, state)) return false;
-    dispatch?.(tr);
-    return true;
-  };
-}
-var addRowBefore = toCommand(
+var addRowBefore = guardedCommand(
   buildAddRowBeforeTransaction
 );
-var addRowAfter = toCommand(buildAddRowAfterTransaction);
-var deleteRow = toCommand(buildDeleteRowTransaction);
-var addColumnBefore = toCommand(
+var addRowAfter = guardedCommand(
+  buildAddRowAfterTransaction
+);
+var deleteRow = guardedCommand(
+  buildDeleteRowTransaction
+);
+var addColumnBefore = guardedCommand(
   buildAddColumnBeforeTransaction
 );
-var addColumnAfter = toCommand(
+var addColumnAfter = guardedCommand(
   buildAddColumnAfterTransaction
 );
-var deleteColumn = toCommand(
+var deleteColumn = guardedCommand(
   buildDeleteColumnTransaction
 );
 function buildDeleteTableTransaction(state) {
@@ -46,9 +42,15 @@ function buildDeleteTableTransaction(state) {
   pmDeleteTable(state, (tr) => captured.push(tr));
   return captured[0] ?? null;
 }
-var deleteTable = toCommand(buildDeleteTableTransaction);
-var mergeCells = toCommand(buildMergeCellsTransaction);
-var splitCell = toCommand(buildSplitCellTransaction);
+var deleteTable = guardedCommand(
+  buildDeleteTableTransaction
+);
+var mergeCells = guardedCommand(
+  buildMergeCellsTransaction
+);
+var splitCell = guardedCommand(
+  buildSplitCellTransaction
+);
 export {
   addColumnAfter,
   addColumnBefore,

package/dist/table/format.d.ts

@@ -2,6 +2,9 @@
  * Newly created cells and rows inherit only the formatting of the cell or row they
  * are based on. Values that have to be recomputed from the grid (colspan, rowspan,
  * colwidth) are not inherited.
+ *
+ * What that comes to per attr is `docx/cloning`, which answers the same question for a
+ * paragraph an edit makes out of another paragraph.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { GridRect } from "../docx/tableFormatting";

package/dist/table/format.js

@@ -1,4 +1,5 @@
 // src/table/format.ts
+import { CLONE_POLICIES } from "../docx/cloning.js";
 function isNumberArray(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
 }
@@ -6,18 +7,11 @@ function colwidthOf(cell) {
   const value = cell.attrs.colwidth;
   return isNumberArray(value) ? value : null;
 }
-var INHERITED_CELL_ATTRS = ["tcAttrs", "tcPr", "tcW", "format"];
 function inheritCellAttrs(cell, overrides = {}) {
-  const attrs = {};
-  for (const key of INHERITED_CELL_ATTRS) attrs[key] = cell.attrs[key];
-  return { ...attrs, ...overrides };
+  return { ...CLONE_POLICIES.tableCell.attrs(cell, "copy"), ...overrides };
 }
-var INHERITED_ROW_ATTRS = ["trAttrs", "trPr", "format"];
 function inheritRowAttrs(row) {
-  if (!row) return null;
-  const attrs = {};
-  for (const key of INHERITED_ROW_ATTRS) attrs[key] = row.attrs[key];
-  return attrs;
+  return row ? CLONE_POLICIES.tableRow.attrs(row, "copy") : null;
 }
 export {
   colwidthOf,

package/dist/table/gridBorders.d.ts

@@ -1,5 +1,5 @@
 /**
- * The lines a cell draws because of where it sits in the grid, kept true after a structure edit.
+ * The lines a cell draws because of where it sits in the grid.
  *
  * Every line of a table is drawn by its cells (see `docx/tableFormatting`), so which line a side
  * falls back on depends on where in the grid the cell sits. A new cell inherits its neighbour's
@@ -9,13 +9,14 @@
  *
  * So the cells of a table whose grid moved derive their display values again, along the same path
  * the import takes. What a cell wrote down itself lives in its `w:tcPr` and is read straight back
- * out of it, so only the share that came from the table can change.
+ * out of it, so only the share that came from the table can change. `cellFixes` says which cells
+ * carry the wrong lines and `sameFormattingInputs` whether anything they depend on moved; the
+ * deriver that runs them after an edit is `editor/plugins/tableDisplay`.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { Plugin } from "prosemirror-state";
 import { type CellBorderDefaults } from "../docx/tableFormatting";
 import { type CellMargins, type InsideBorders, type TableFormat } from "../model/format";
-import type { TableGridMap } from "./format";
+import type { NodeAttrs, TableGridMap } from "./format";
 /**
  * What a table lays down for its cells to draw.
  * The values a table style laid down are not in the `tblPr`, so the table carries them separately.
@@ -28,15 +29,12 @@ export interface TableCellSources {
 export declare function tableCellSources(table: PMNode): TableCellSources;
 /** The lines the cell at this position falls back on for the sides it draws no border of its own on */
 export declare function cellDefaultsAt(map: TableGridMap, pos: number, sources: TableCellSources): CellBorderDefaults;
-/** Derives shared-border display values before the first editor view is drawn. */
-export declare function withDerivedGridBorders(doc: PMNode): PMNode;
-/**
- * Keeps the derived lines current after a table's grid or border inputs change.
- *
- * The tables are paired up by the order they stand in. A document that gained or lost a whole table
- * pairs the ones after it with the wrong partner, which costs a derivation that changes no cell.
- *
- * No transaction of its own goes to the history: ProseMirror hands an appended transaction to the
- * history as part of the same event, so a single undo takes the edit and this correction back together.
- */
-export declare function gridBorders(): Plugin;
+export interface CellFix {
+    /** The position of the cell within the table's content */
+    pos: number;
+    attrs: NodeAttrs;
+}
+/** The cells of this table whose display values do not match the spot they now sit in */
+export declare function cellFixes(table: PMNode): CellFix[];
+/** Whether everything the cells' lines are derived from reads the same in both tables */
+export declare function sameFormattingInputs(a: PMNode, b: PMNode): boolean;

package/dist/table/gridBorders.js

@@ -1,7 +1,5 @@
 // src/table/gridBorders.ts
-import { Plugin } from "prosemirror-state";
 import { TableMap } from "prosemirror-tables";
-import { Transform } from "prosemirror-transform";
 import {
   cellBorderDefaults,
   cellMarginsOf,
@@ -129,14 +127,6 @@ function cellFixes(table) {
   }
   return fixes;
 }
-function tablesOf(doc) {
-  const tables = [];
-  doc.descendants((node, pos) => {
-    if (node.type.spec.tableRole === "table") tables.push({ pos, table: node });
-    return !node.isTextblock;
-  });
-  return tables;
-}
 function sameSpans(a, b) {
   return spanCount(a.attrs.colspan) === spanCount(b.attrs.colspan) && spanCount(a.attrs.rowspan) === spanCount(b.attrs.rowspan);
 }
@@ -156,37 +146,9 @@ function sameCellFormattingInputs(a, b) {
 function sameFormattingInputs(a, b) {
   return sameGrid(a, b) && a.attrs.tblPr === b.attrs.tblPr && a.attrs.format === b.attrs.format && a.attrs.styleInside === b.attrs.styleInside && a.attrs.styleCellMargins === b.attrs.styleCellMargins && sameCellFormattingInputs(a, b);
 }
-function withDerivedGridBorders(doc) {
-  const transform = new Transform(doc);
-  for (const { pos, table } of tablesOf(doc)) {
-    for (const fix of cellFixes(table)) {
-      transform.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
-    }
-  }
-  return transform.doc;
-}
-function gridBorders() {
-  return new Plugin({
-    appendTransaction(transactions, oldState, newState) {
-      if (!transactions.some((transaction) => transaction.docChanged)) {
-        return null;
-      }
-      const before = tablesOf(oldState.doc);
-      const tr = newState.tr;
-      tablesOf(newState.doc).forEach(({ pos, table }, index) => {
-        const was = before[index]?.table;
-        if (was && sameFormattingInputs(was, table)) return;
-        for (const fix of cellFixes(table)) {
-          tr.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
-        }
-      });
-      return tr.docChanged ? tr : null;
-    }
-  });
-}
 export {
   cellDefaultsAt,
-  gridBorders,
-  tableCellSources,
-  withDerivedGridBorders
+  cellFixes,
+  sameFormattingInputs,
+  tableCellSources
 };

package/dist/table/index.d.ts

@@ -3,8 +3,8 @@
  *
  * Only what the toolbar needs is exported. Following the ProseMirror convention,
  * calling a command without `dispatch` only reports whether it can run right now, and that answer
- * takes in the lock: a structural edit that would carry a locked cell off reports that it does not
- * apply, rather than being refused after the click (`schema/locks`).
+ * takes in every guard an edit is judged by (`schema/guards`): a structural edit that would carry a
+ * locked cell off reports that it does not apply, rather than being refused after the click.
  *
  * Everything here works on a table already in the document; putting a new one into the body is
  * `insertTable` in `./commands`, which reads the page geometry the editor holds.

package/dist/table/merge.d.ts

@@ -6,18 +6,14 @@ import type { EditorState, Transaction } from "prosemirror-state";
 /**
  * Whether several cells can be merged into one.
  * The selection has to be a rectangle spanning more than one cell, no merged cell may stick out
- * past that rectangle, and the lock guard has to let the merge through: a locked cell may not be
- * swallowed by another (`schema/locks`).
- *
- * The two queries are defined from the very transaction the commands run, so they cannot drift
- * from them. They live here rather than beside the commands because `./commands` imports these
- * builders, and the other way round would turn that import around.
+ * past that rectangle, and the guards have to let the merge through: a locked cell may not be
+ * swallowed by another (`schema/guards`).
  */
 export declare function canMergeCells(state: EditorState): boolean;
 /**
  * Whether a split is possible. The cursor has to sit inside a cell that is merged horizontally or
- * vertically, and the lock guard has to let the split through: the cells a split makes would each
- * carry the original's lock, which is a lock planted in places it was never put (`schema/locks`).
+ * vertically, and the guards have to let the split through: the cells a split makes would each
+ * carry the original's lock, which is a lock planted in places it was never put (`schema/guards`).
  */
 export declare function canSplitCell(state: EditorState): boolean;
 /**

package/dist/table/merge.js

@@ -11,7 +11,7 @@ import {
   widthNumber,
   withWidthNumber
 } from "../model/format.js";
-import { transactionAllowed } from "../schema/locks.js";
+import { guardedCommand } from "../schema/guards.js";
 import { inheritCellAttrs } from "./format.js";
 import { cellWidthForGridCol, gridSpanWidth, tableGridCols } from "./widths.js";
 function tableAfter(tr, tableStart) {
@@ -24,13 +24,13 @@ function cellAt(rect, row, col) {
   const pos = rect.map.map[row * rect.map.width + col];
   return pos == null ? null : rect.table.nodeAt(pos);
 }
+var merging = guardedCommand(buildMergeCellsTransaction);
+var splitting = guardedCommand(buildSplitCellTransaction);
 function canMergeCells(state) {
-  const tr = buildMergeCellsTransaction(state);
-  return tr !== null && transactionAllowed(tr, state);
+  return merging(state);
 }
 function canSplitCell(state) {
-  const tr = buildSplitCellTransaction(state);
-  return tr !== null && transactionAllowed(tr, state);
+  return splitting(state);
 }
 function coveredWidthSum(rect, type) {
   let sum = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portone/docx-editor",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A simple DOCX editor for React, built directly on OOXML.",
   "license": "Apache-2.0",
   "type": "module",
@@ -76,7 +76,9 @@
     "@biomejs/biome": "2.5.10",
     "@changesets/changelog-github": "^1.0.0",
     "@changesets/cli": "^3.0.1",
+    "@microsoft/api-extractor": "7.59.0",
     "@playwright/test": "^1.62.1",
+    "@types/jsdom": "^30.0.0",
     "@types/node": "^26.2.0",
     "@types/react": "19.2.18",
     "@types/react-dom": "19.2.5",
@@ -105,16 +107,21 @@
     "build:demo": "vite build --config demo/vite.config.ts",
     "dev:site": "pnpm --filter @portone/docx-editor-site dev",
     "build:site": "pnpm --filter @portone/docx-editor-site build",
-    "check": "pnpm lint && pnpm typecheck && pnpm test",
+    "check": "pnpm lint && pnpm typecheck && pnpm test && pnpm test:fixtures && pnpm test:site-release && pnpm check:demo-library",
     "typecheck": "tsc --noEmit && tsc --noEmit -p e2e && tsc --noEmit -p demo && pnpm --filter @portone/docx-editor-site typecheck",
     "lint": "pnpm biome check . --diagnostic-level=error",
     "test": "vitest run",
+    "test:fixtures": "node --test scripts/sanitize-fixture.test.mjs",
     "test:package": "vitest run --dir packaging --no-file-parallelism",
     "verify:package": "node scripts/verify-package.mjs",
+    "check:demo-library": "node scripts/demo-library-pin.mjs",
+    "pin:demo-library": "node scripts/demo-library-pin.mjs --write",
+    "api:update": "pnpm build && node scripts/api-report.mjs --local",
     "spec": "node scripts/index-ooxml-spec.mjs",
     "changeset": "changeset",
     "changeset:version": "changeset version",
-    "test:e2e": "playwright test"
+    "test:e2e": "playwright test",
+    "test:site-release": "node --test scripts/site-release.test.mjs"
   },
   "types": "./dist/index.d.ts"
 }

package/dist/docx/comments/contentTypes.d.ts

@@ -1,7 +0,0 @@
-/** Declares a part an export adds in `[Content_Types].xml`, leaving the original text as it came. */
-/**
- * The content types part with an override for this part, or null when it already declares one.
- * `current` is the part as an earlier addition in the same export left it, so that two additions
- * do not each write over the other's declaration.
- */
-export declare function withContentType(parts: Map<string, Uint8Array>, partPath: string, contentType: string, current: Uint8Array | undefined): Uint8Array | null;

package/dist/docx/comments/contentTypes.js

@@ -1,38 +0,0 @@
-// src/docx/comments/contentTypes.ts
-import { DocxExportError } from "../../ooxml/errors.js";
-import { decodeUtf8, encodeUtf8 } from "../../ooxml/xml.js";
-import { CONTENT_TYPES_PATH } from "./constants.js";
-var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
-function withContentType(parts, partPath, contentType, current) {
-  const original = current ?? parts.get(CONTENT_TYPES_PATH);
-  if (!original) {
-    throw new DocxExportError(
-      "missing-content-types",
-      `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
-    );
-  }
-  const { text, hadBom } = decodeUtf8(original);
-  const partName = `/${partPath}`;
-  if (new RegExp(
-    `<(?:[\\w.-]+:)?Override[^>]+PartName=["']${partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`,
-    "i"
-  ).test(text)) {
-    return null;
-  }
-  const open = TYPES_OPEN_TAG.exec(text);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      `${CONTENT_TYPES_PATH} has no Types element`
-    );
-  }
-  const rootName = /^<([^\s>]+)/.exec(open[0])?.[1] ?? "Types";
-  const separator = rootName.indexOf(":");
-  const prefix = separator < 0 ? "" : `${rootName.slice(0, separator)}:`;
-  const declaration = `<${prefix}Override PartName="${partName}" ContentType="${contentType}"/>`;
-  const at = open.index + open[0].length;
-  return encodeUtf8(text.slice(0, at) + declaration + text.slice(at), hadBom);
-}
-export {
-  withContentType
-};

package/dist/docx/formatting/effectiveParagraph.d.ts

@@ -1,15 +0,0 @@
-import { type ParagraphFormat } from "../../model/format";
-import { type Numbering } from "../../numbering/parseNumbering";
-import { type StyleFormat, type StyleTable } from "./styles";
-import { type ParagraphFormatLayer } from "./tabStops";
-export interface ParagraphFormattingContext {
-    styles: StyleTable;
-    defaultStyleId: string | null;
-    defaults: ParagraphFormatLayer;
-    numbering: Numbering;
-}
-export declare const NO_PARAGRAPH_FORMATTING: ParagraphFormattingContext;
-/** Resolves the effective OOXML paragraph-property hierarchy for display. */
-export declare function effectiveParagraphFormat(pPr: unknown, context: ParagraphFormattingContext): ParagraphFormat | null;
-/** Resolves the run properties supplied by the paragraph style. */
-export declare function effectiveParagraphStyle(pPr: unknown, context: ParagraphFormattingContext): StyleFormat | undefined;