@portone/docx-editor 0.2.1 → 0.3.0

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/merge.d.ts

@@ -7,17 +7,13 @@ 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 guards have 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.
+ * 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 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/locks`).
+ * 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/guards.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.1",
+  "version": "0.3.0",
   "description": "A simple DOCX editor for React, built directly on OOXML.",
   "license": "Apache-2.0",
   "type": "module",
@@ -107,17 +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/comments/verifying.js

@@ -1,206 +0,0 @@
-// src/docx/comments/verifying.ts
-import {
-  attributeByLocalName,
-  elementChildren,
-  isElement,
-  parseXml,
-  serializeXml,
-  W_NS
-} from "../../ooxml/xml.js";
-import { W14_NS, W15_NS } from "./constants.js";
-import {
-  attributesWithin,
-  COMMENT_ATTRIBUTES,
-  lastBodyParagraph,
-  readStrictCommentBody,
-  recordedIdentity,
-  wellFormedCommentExtension,
-  wellFormedPerson
-} from "./grammar.js";
-import { commentReferencesIn } from "./model.js";
-import { commentAuthorId } from "./people.js";
-import { lastParagraphId } from "./reading.js";
-var COMMENT_IDENTITY = [
-  "id",
-  "author",
-  "date",
-  "initials"
-];
-function sameAttributes(entry, original, names) {
-  return names.every(
-    (name) => attributeByLocalName(entry, name) === attributeByLocalName(original, name)
-  );
-}
-function arrivedEntries(xml, localName, idAttr) {
-  const entries = /* @__PURE__ */ new Map();
-  if (xml === null) return entries;
-  for (const el of elementChildren(parseXml(xml).documentElement)) {
-    if (el.localName !== localName) continue;
-    const id = attributeByLocalName(el, idAttr);
-    if (id === null || entries.has(id)) continue;
-    entries.set(id, { el, xml: serializeXml(el) });
-  }
-  return entries;
-}
-function submittedEntries(xml, namespace, localName, idAttr) {
-  if (xml === null) return [];
-  const entries = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const el of elementChildren(parseXml(xml).documentElement)) {
-    if (el.namespaceURI !== namespace || el.localName !== localName)
-      return null;
-    const id = attributeByLocalName(el, idAttr);
-    if (id === null || seen.has(id)) return null;
-    seen.add(id);
-    entries.push({ id, el, xml: serializeXml(el) });
-  }
-  return entries;
-}
-function referencedCommentIds(doc) {
-  const ids = /* @__PURE__ */ new Set();
-  for (const [id, comment] of commentReferencesIn(doc)) {
-    ids.add(id);
-    for (const reply of comment.replies) ids.add(reply.id);
-  }
-  return ids;
-}
-function wellFormedEntry(entry) {
-  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
-    return attributesWithin(entry, COMMENT_ATTRIBUTES) && readStrictCommentBody(entry) !== null;
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
-    return wellFormedCommentExtension(entry);
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
-    return wellFormedPerson(entry);
-  }
-  return false;
-}
-function withoutThreadKey(entry) {
-  const copy = entry.cloneNode(true);
-  if (!isElement(copy)) return serializeXml(entry);
-  const last = lastBodyParagraph(copy);
-  last?.removeAttributeNS(W14_NS, "paraId");
-  return serializeXml(copy);
-}
-function threadKeyAlone(entry, original) {
-  const before = lastParagraphId(original);
-  const after = lastParagraphId(entry);
-  const kept = before === null || after === before;
-  return kept && withoutThreadKey(entry) === withoutThreadKey(original);
-}
-function entryAllowed(entry, original, authorId, editableComments, people) {
-  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
-    const author = attributeByLocalName(entry, "author");
-    const recorded = author === null ? null : commentAuthorId(people, author);
-    if (original === null) return recorded === authorId;
-    const paraId = lastParagraphId(original);
-    if (!sameAttributes(entry, original, COMMENT_IDENTITY) || paraId !== null && lastParagraphId(entry) !== paraId) {
-      return false;
-    }
-    return editableComments === "all" || recorded === null || recorded === authorId;
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
-    if (original === null) return true;
-    return sameAttributes(entry, original, ["paraId", "paraIdParent"]);
-  }
-  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
-    return original === null && recordedIdentity(entry) === authorId;
-  }
-  return false;
-}
-function commentEntries(story) {
-  return Array.from(
-    arrivedEntries(story.session.comments.xml, "comment", "id").values(),
-    (entry) => entry.el
-  );
-}
-var COMMENT_PARTS = [
-  {
-    namespace: W_NS,
-    localName: "comment",
-    idAttr: "id",
-    xmlOf: (story) => story.session.comments.xml,
-    pathOf: (story) => story.session.comments.partPath,
-    referents: (story) => referencedCommentIds(story.doc)
-  },
-  {
-    namespace: W15_NS,
-    localName: "commentEx",
-    idAttr: "paraId",
-    xmlOf: (story) => story.session.comments.extendedXml,
-    pathOf: (story) => story.session.comments.extendedPartPath,
-    // Thread state stands for a comment, and it is keyed by the comment's own thread key
-    referents: (story) => new Set(
-      commentEntries(story).flatMap((el) => {
-        const key = lastParagraphId(el);
-        return key === null ? [] : [key];
-      })
-    )
-  },
-  {
-    namespace: W15_NS,
-    localName: "person",
-    idAttr: "author",
-    xmlOf: (story) => story.session.comments.people.xml,
-    pathOf: (story) => story.session.comments.people.partPath,
-    // An identity stands for a name somebody writes comments under
-    referents: (story) => new Set(
-      commentEntries(story).flatMap((el) => {
-        const author = attributeByLocalName(el, "author");
-        return author === null ? [] : [author];
-      })
-    )
-  }
-];
-function partKept(kind, before, after, authorId, editableComments) {
-  const arrived = arrivedEntries(
-    kind.xmlOf(before),
-    kind.localName,
-    kind.idAttr
-  );
-  const submitted = submittedEntries(
-    kind.xmlOf(after),
-    kind.namespace,
-    kind.localName,
-    kind.idAttr
-  );
-  if (submitted === null) return false;
-  const stoodBehindNow = kind.referents(after);
-  const people = after.session.comments.people;
-  for (const entry of submitted) {
-    const original = arrived.get(entry.id);
-    if (original && original.xml === entry.xml) continue;
-    if (!stoodBehindNow.has(entry.id)) return false;
-    if (original && threadKeyAlone(entry.el, original.el)) continue;
-    if (!wellFormedEntry(entry.el) || !entryAllowed(
-      entry.el,
-      original?.el ?? null,
-      authorId,
-      editableComments,
-      people
-    )) {
-      return false;
-    }
-  }
-  const held = new Set(submitted.map((entry) => entry.id));
-  const stoodBehindBefore = kind.referents(before);
-  return Array.from(arrived.keys()).every(
-    (id) => stoodBehindBefore.has(id) || held.has(id)
-  );
-}
-function commentPartsKept(before, after, authorId, editableComments) {
-  for (const kind of COMMENT_PARTS) {
-    const path = kind.pathOf(after) ?? kind.pathOf(before);
-    if (path === null) continue;
-    if (!partKept(kind, before, after, authorId, editableComments)) {
-      return { ok: false, reason: "part-changed", part: path };
-    }
-  }
-  return { ok: true };
-}
-export {
-  commentPartsKept,
-  entryAllowed,
-  wellFormedEntry
-};

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;

package/dist/docx/formatting/effectiveParagraph.js

@@ -1,81 +0,0 @@
-// src/docx/formatting/effectiveParagraph.ts
-import { toParagraphFormat } from "../../model/format.js";
-import { mergeTabStops } from "../../model/tabStops.js";
-import {
-  EMPTY_NUMBERING,
-  levelIndentPt
-} from "../../numbering/parseNumbering.js";
-import { parsePropsXml } from "../propsXml.js";
-import { readParagraphFormat } from "./direct.js";
-import {
-  paragraphStyleFormat
-} from "./styles.js";
-import { layerParagraphValues } from "./tabStops.js";
-var NO_PARAGRAPH_FORMATTING = {
-  styles: /* @__PURE__ */ new Map(),
-  defaultStyleId: null,
-  defaults: {},
-  numbering: EMPTY_NUMBERING
-};
-function numberingRef(defaults, style, direct) {
-  let value = defaults.numbering;
-  if (style.numbering !== void 0) value = style.numbering;
-  if (direct.numbering !== void 0) value = direct.numbering;
-  return value;
-}
-function numberingLayer(ref, numbering) {
-  if (!ref) return {};
-  const level = numbering.lists.get(ref.numId)?.levels.get(ref.ilvl);
-  if (!level) return {};
-  const indent = levelIndentPt(level.indent);
-  const leadingIndentPt = indent.startPt;
-  const implicitHangingStop = leadingIndentPt !== null && indent.textIndentPt !== null && indent.textIndentPt < 0 ? [{ positionPt: leadingIndentPt, align: "start" }] : [];
-  return {
-    tabStops: [...implicitHangingStop, ...level.tabStops ?? []]
-  };
-}
-function withImplicitHangingStop(format) {
-  const leadingIndentPt = format?.indentStartPt ?? format?.indentLeftPt;
-  if (format?.textIndentPt === void 0 || format.textIndentPt >= 0 || leadingIndentPt === void 0) {
-    return format;
-  }
-  const implicit = {
-    positionPt: leadingIndentPt,
-    align: "start"
-  };
-  return {
-    ...format,
-    tabStops: mergeTabStops([implicit], format.tabStops ?? [])
-  };
-}
-function directLayer(pPr) {
-  if (typeof pPr !== "string") return {};
-  return readParagraphFormat(parsePropsXml(pPr)) ?? {};
-}
-function styleFor(pPr, context) {
-  return paragraphStyleFormat(pPr, context.styles, context.defaultStyleId);
-}
-function effectiveParagraphFormat(pPr, context) {
-  const direct = directLayer(pPr);
-  const style = styleFor(pPr, context)?.paragraph ?? {};
-  const level = numberingLayer(
-    numberingRef(context.defaults, style, direct),
-    context.numbering
-  );
-  const layered = [level, style, direct].reduce(
-    layerParagraphValues,
-    context.defaults
-  );
-  const format = toParagraphFormat(layered);
-  return withImplicitHangingStop(
-    format !== null && Object.keys(format).length === 0 ? null : format
-  );
-}
-function effectiveParagraphStyle(pPr, context) {
-  return styleFor(pPr, context);
-}
-export {
-  NO_PARAGRAPH_FORMATTING,
-  effectiveParagraphFormat,
-  effectiveParagraphStyle
-};

package/dist/docx/propsXml.d.ts

@@ -1,67 +0,0 @@
-/**
- * Handles the XML fragments that carry formatting, such as `<w:rPr>`, `<w:pPr>`, and `<w:tcPr>`.
- *
- * A fragment is never rebuilt: only the one child a job names is sliced out and swapped, so the
- * rest (borders, shading, margins) stays as the original text wrote it. OOXML lays down the order
- * of the children, so the spot to insert a child that was not there is found by that same order.
- */
-export interface PropsChild {
-    /** The name with its namespace prefix stripped off (e.g. `gridSpan`) */
-    name: string;
-    /** This child's original XML fragment exactly as it was */
-    xml: string;
-    /**
-     * Whatever stood between the child before this one and this one: line breaks a producer laid
-     * out, comments, anything that is not an element. Carried so that rewriting one child does not
-     * quietly drop the rest of what the fragment said. Absent rather than empty when nothing did.
-     */
-    before?: string;
-}
-export interface Props {
-    /** The opening tag name exactly as written (e.g. `w:tcPr`) */
-    tag: string;
-    attrs: string | null;
-    children: PropsChild[];
-    /** The same, for what stood between the last child and the closing tag */
-    tail?: string;
-}
-/** The order the children are laid out in under `w:rPr` (CT_RPr) */
-export declare const RUN_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:pPr` (CT_PPr) */
-export declare const P_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:tcPr` (CT_TcPr) */
-export declare const TC_PR_ORDER: readonly string[];
-/** The conventional order of children under `w:trPr` (CT_TrPr). */
-export declare const TR_PR_ORDER: readonly string[];
-/** The order the children are laid out in under `w:tblPr` (CT_TblPr) */
-export declare const TBL_PR_ORDER: readonly string[];
-/**
- * What stood inside a single element, and "" for one that stood empty or cannot be made out.
- *
- * The opening tag is read rather than scanned for, so a `>` inside an attribute value does not
- * pass for the end of it.
- */
-export declare function innerXml(xml: string): string;
-/**
- * Splits a formatting fragment into its opening tag and its list of children.
- * null if its shape cannot be made out (in which case leaving the original untouched is the safe move).
- */
-export declare function parseProps(xml: string): Props | null;
-/**
- * With nothing to say, the formatting fragment itself is not written. A fragment holding only
- * whitespace says nothing; one holding a comment does, so it is written back.
- */
-export declare function renderProps(props: Props): string;
-/**
- * Replaces a single child with new XML.
- * A null `xml` removes that child. A child that was not there goes into the spot the order calls for.
- */
-export declare function setPropsChild(props: Props, name: string, xml: string | null, order: readonly string[]): Props;
-export declare function propsChild(children: PropsChild[], name: string): PropsChild | undefined;
-/**
- * Reads a single formatting fragment into an element.
- *
- * A fragment carries no namespace declarations, so they are put back on as it is wrapped.
- * null if its shape cannot be made out, in which case the caller leaves the display values alone.
- */
-export declare function parsePropsXml(xml: string): Element | null;

package/dist/docx/uniqueControls.d.ts

@@ -1,14 +0,0 @@
-/**
- * Keeping one content control from going out twice under the same name.
- *
- * A control cannot cross a paragraph, so splitting a paragraph in the middle of one leaves that
- * same control standing in two, and dropping unmarked text into the middle of one breaks it in
- * two within the paragraph. Each piece then writes a `w:sdt` of its own (see `docx/sdt` for what
- * a copy must not carry along).
- *
- * A document nobody broke apart comes back node for node as it was, which is what keeps an
- * unedited block going out as its original XML.
- */
-import { type Node as PMNode } from "prosemirror-model";
-/** The document with every copy of a control opening under a name of its own */
-export declare function withUniqueControls(doc: PMNode): PMNode;

package/dist/docx/uniqueControls.js

@@ -1,62 +0,0 @@
-// src/docx/uniqueControls.ts
-import { Fragment } from "prosemirror-model";
-import { docxSchema } from "../schema/index.js";
-import { copiedControlPrefix, newControlId } from "./sdt.js";
-function sdtMarkOf(node) {
-  return node.marks.find((mark) => mark.type === docxSchema.marks.sdt) ?? null;
-}
-function controlName(mark) {
-  const key = mark.attrs.sdtKey;
-  const prefix = mark.attrs.sdtPrefix;
-  return `${typeof key === "number" ? key : 0} ${typeof prefix === "string" ? prefix : ""}`;
-}
-function copiedMark(mark) {
-  const prefix = mark.attrs.sdtPrefix;
-  if (typeof prefix !== "string") return mark;
-  return mark.type.create({
-    ...mark.attrs,
-    sdtPrefix: copiedControlPrefix(prefix, newControlId())
-  });
-}
-function claim(mark, written) {
-  const name = controlName(mark);
-  const copy = written.has(name) ? copiedMark(mark) : null;
-  written.add(name);
-  return { mark, copy };
-}
-function rewriteParagraph(paragraph, written) {
-  const inline = [];
-  let running = null;
-  let renamed = false;
-  paragraph.forEach((child) => {
-    const mark = sdtMarkOf(child);
-    if (!mark) {
-      running = null;
-      inline.push(child);
-      return;
-    }
-    const control = running?.mark.eq(mark) ? running : claim(mark, written);
-    running = control;
-    if (!control.copy) {
-      inline.push(child);
-      return;
-    }
-    renamed = true;
-    inline.push(
-      child.mark(control.copy.addToSet(mark.removeFromSet(child.marks)))
-    );
-  });
-  return renamed ? paragraph.copy(Fragment.fromArray(inline)) : paragraph;
-}
-function rewriteBlock(node, written) {
-  if (node.type.name === "paragraph") return rewriteParagraph(node, written);
-  if (node.childCount === 0) return node;
-  const children = node.children.map((child) => rewriteBlock(child, written));
-  return children.every((child, index) => child === node.child(index)) ? node : node.copy(Fragment.fromArray(children));
-}
-function withUniqueControls(doc) {
-  return rewriteBlock(doc, /* @__PURE__ */ new Set());
-}
-export {
-  withUniqueControls
-};

package/dist/editor/plugins/commentReservations.d.ts

@@ -1,5 +0,0 @@
-/** Keeps identifiers from the opened Comments parts reserved for the lifetime of the editor state. */
-import { type EditorState, Plugin } from "prosemirror-state";
-export declare function commentReservations(ids: Iterable<string>, paraIds: Iterable<string>): Plugin;
-export declare function reservedCommentIds(state: EditorState): ReadonlySet<string>;
-export declare function reservedCommentParaIds(state: EditorState): ReadonlySet<string>;

package/dist/editor/plugins/commentReservations.js

@@ -1,26 +0,0 @@
-// src/editor/plugins/commentReservations.ts
-import { Plugin, PluginKey } from "prosemirror-state";
-var commentReservationsKey = new PluginKey(
-  "docxCommentReservations"
-);
-function commentReservations(ids, paraIds) {
-  const reserved = { ids: new Set(ids), paraIds: new Set(paraIds) };
-  return new Plugin({
-    key: commentReservationsKey,
-    state: {
-      init: () => reserved,
-      apply: (_transaction, value) => value
-    }
-  });
-}
-function reservedCommentIds(state) {
-  return commentReservationsKey.getState(state)?.ids ?? /* @__PURE__ */ new Set();
-}
-function reservedCommentParaIds(state) {
-  return commentReservationsKey.getState(state)?.paraIds ?? /* @__PURE__ */ new Set();
-}
-export {
-  commentReservations,
-  reservedCommentIds,
-  reservedCommentParaIds
-};