@portone/docx-editor 0.1.0

package/dist/docx/tableFormatting/reading.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Reads table formatting for display. Table borders and margins are folded into cell values so CSS
+ * collapsed-border resolution matches OOXML inheritance without changing exported XML.
+ */
+import type { CellFormat, CellMargins, InsideBorders, RowFormat, TableFormat, TableWidth } from "../../model/format";
+export type { CellMargins, InsideBorders } from "../../model/format";
+/**
+ * The width written down by `<w:tblW>` or `<w:tcW>`.
+ * If we cannot make out what it means it is null, and such a width goes back out unchanged on export.
+ *
+ * `auto` and `nil` leave the width to the layout, so whatever number stands beside them says nothing.
+ * A percentage may be written in fiftieths of a percent, as in `w:w="2500"`, or as `w:w="50%"`.
+ * Both have to be gathered into the same unit, or the table collapses into a thin strip on screen.
+ */
+export declare function readTableWidth(parent: Element | null, name: "tblW" | "tcW"): TableWidth | null;
+/** The sequence of column widths (dxa) set by `<w:tblGrid>`. Revision markup (tblGridChange) is skipped */
+export declare function readGridCols(tblGrid: Element | null): number[];
+export declare const NO_INSIDE_BORDERS: InsideBorders;
+export declare function readInsideBorders(tblPr: Element | null): InsideBorders;
+/**
+ * Lays the inside lines a table wrote down on top of the ones its style laid down.
+ * A side the table wrote as `none` wins as well: a document that switched a line off is not to have
+ * the style's line come back.
+ */
+export declare function layerInsideBorders(style: InsideBorders, direct: InsideBorders): InsideBorders;
+export declare const NO_CELL_MARGINS: CellMargins;
+/** The margins `w:tblCellMar` (in a tblPr) or `w:tcMar` (in a tcPr) writes down, one side at a time */
+export declare function readCellMarginsOf(parent: Element | null, name: "tblCellMar" | "tcMar"): CellMargins;
+/**
+ * Lays the margins a table wrote down on top of the ones its style laid down.
+ * A side the table says nothing about keeps the style's margin, which is where most documents get
+ * their cell padding from.
+ */
+export declare function layerCellMargins(style: CellMargins, direct: CellMargins): CellMargins;
+/** The lines a cell falls back on, one per side, already resolved for its spot in the grid */
+export interface CellBorderDefaults {
+    top: string | null;
+    bottom: string | null;
+    left: string | null;
+    right: string | null;
+}
+export declare const NO_BORDER_DEFAULTS: CellBorderDefaults;
+/** Which sides of a cell lie on the edge of the table's grid */
+export interface GridEdges {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+}
+/** A block of grid coordinates. `bottom` and `right` point one past the last cell, not at it */
+export interface GridRect {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+export interface GridSize {
+    rows: number;
+    cols: number;
+}
+/**
+ * Which sides of the block a cell covers lie on the edge of the grid, merges included.
+ * Everything that works out a cell's lines asks this first, whether the cell is being imported,
+ * created fresh, or looked up again in a table on screen.
+ */
+export declare function gridEdgesOf(rect: GridRect, grid: GridSize): GridEdges;
+/**
+ * The lines the four sides of one cell fall back on.
+ *
+ * A side on the edge of the grid falls on the table's outer border, and one facing another cell on
+ * the table's inside line. An outer side the document wrote as `none` is passed through as it is:
+ * the table switched that line off, and nothing is to bring it back.
+ */
+export declare function cellBorderDefaults(edges: GridEdges, outer: TableFormat | null, inside: InsideBorders): CellBorderDefaults;
+/** The name of the table style `w:tblStyle` points at. null if it points at none */
+export declare function tblStyleIdOf(tblPr: Element | null): string | null;
+export declare function readTableFormat(tblPr: Element | null): TableFormat | null;
+export declare function readRowFormat(trPr: Element | null): RowFormat | null;
+/**
+ * Cell formatting.
+ * A side for which the cell has not written down its own border uses the line that side falls on,
+ * which is the table's outer border or its inside line depending on where the cell sits.
+ * The padding works the same way: what the cell wrote down wins, and the table's cell margins lie
+ * underneath it. null if there is nothing at all to draw.
+ */
+export declare function readCellFormat(tcPr: Element | null, defaults: CellBorderDefaults, margins?: CellMargins): CellFormat | null;
+/** The inside lines the table lays down, read from the table's own formatting XML */
+export declare function insideBordersOf(tblPr: string | null): InsideBorders;
+/** The cell margins the table lays down, read from the table's own formatting XML */
+export declare function cellMarginsOf(tblPr: string | null): CellMargins;
+/**
+ * Reads a cell formatting fragment we operated on back into display values, along the same path
+ * the import takes. The same fragment always yields the same display values.
+ */
+export declare function readCellProps(tcPr: string | null, defaults: CellBorderDefaults, margins?: CellMargins): CellFormat | null;
+/** The formatting a cell holds. The original XML and the display values read out of it form a pair */

package/dist/docx/tableFormatting/reading.js

@@ -0,0 +1,221 @@
+// src/docx/tableFormatting/reading.ts
+import {
+  ALIGN_BY_JC,
+  borderSide,
+  childValue,
+  isOn,
+  shadingOf,
+  toNumber,
+  twipsToPt,
+  wAttr
+} from "../../ooxml/units.js";
+import { childByLocalName } from "../../ooxml/xml.js";
+import { parsePropsXml } from "../propsXml.js";
+function readTableWidth(parent, name) {
+  const el = parent ? childByLocalName(parent, name) : null;
+  if (!el) return null;
+  const type = wAttr(el, "type") ?? "dxa";
+  if (type === "auto") return { type: "auto" };
+  if (type === "nil") return { type: "nil" };
+  const raw = wAttr(el, "w");
+  const value = toNumber(raw);
+  if (value === null) return null;
+  if (type === "dxa") return { type: "dxa", twips: value };
+  if (type === "pct") {
+    const isPercentText = raw?.endsWith("%") === true;
+    return {
+      type: "pct",
+      fiftieths: isPercentText ? Math.round(value * 50) : value
+    };
+  }
+  return null;
+}
+function readGridCols(tblGrid) {
+  if (!tblGrid) return [];
+  const cols = [];
+  for (const child of Array.from(tblGrid.children)) {
+    if (child.localName !== "gridCol") continue;
+    const w = toNumber(wAttr(child, "w"));
+    if (w !== null) cols.push(w);
+  }
+  return cols;
+}
+var NO_INSIDE_BORDERS = {
+  horizontal: null,
+  vertical: null
+};
+function readInsideBorders(tblPr) {
+  const borders = tblPr ? childByLocalName(tblPr, "tblBorders") : null;
+  return {
+    horizontal: borderSide(borders, "insideH"),
+    vertical: borderSide(borders, "insideV")
+  };
+}
+function layerInsideBorders(style, direct) {
+  return {
+    horizontal: direct.horizontal ?? style.horizontal,
+    vertical: direct.vertical ?? style.vertical
+  };
+}
+var NO_CELL_MARGINS = {
+  topPt: null,
+  rightPt: null,
+  bottomPt: null,
+  leftPt: null
+};
+function marginSide(margins, names) {
+  for (const name of names) {
+    const el = childByLocalName(margins, name);
+    if (!el) continue;
+    const type = wAttr(el, "type") ?? "dxa";
+    if (type === "nil") return 0;
+    return type === "dxa" ? twipsToPt(wAttr(el, "w")) : null;
+  }
+  return null;
+}
+function readCellMarginsOf(parent, name) {
+  const el = parent ? childByLocalName(parent, name) : null;
+  if (!el) return NO_CELL_MARGINS;
+  return {
+    topPt: marginSide(el, ["top"]),
+    rightPt: marginSide(el, ["end", "right"]),
+    bottomPt: marginSide(el, ["bottom"]),
+    leftPt: marginSide(el, ["start", "left"])
+  };
+}
+function layerCellMargins(style, direct) {
+  return {
+    topPt: direct.topPt ?? style.topPt,
+    rightPt: direct.rightPt ?? style.rightPt,
+    bottomPt: direct.bottomPt ?? style.bottomPt,
+    leftPt: direct.leftPt ?? style.leftPt
+  };
+}
+var NO_BORDER_DEFAULTS = {
+  top: null,
+  bottom: null,
+  left: null,
+  right: null
+};
+function gridEdgesOf(rect, grid) {
+  return {
+    top: rect.top === 0,
+    bottom: rect.bottom === grid.rows,
+    left: rect.left === 0,
+    right: rect.right === grid.cols
+  };
+}
+function cellBorderDefaults(edges, outer, inside) {
+  return {
+    top: edges.top ? outer?.borderTop ?? null : inside.horizontal,
+    bottom: edges.bottom ? outer?.borderBottom ?? null : inside.horizontal,
+    left: edges.left ? outer?.borderLeft ?? null : inside.vertical,
+    right: edges.right ? outer?.borderRight ?? null : inside.vertical
+  };
+}
+function tblStyleIdOf(tblPr) {
+  return tblPr ? childValue(tblPr, "tblStyle") : null;
+}
+function readTableFormat(tblPr) {
+  if (!tblPr) return null;
+  const format = {};
+  const borders = childByLocalName(tblPr, "tblBorders");
+  const top = borderSide(borders, "top");
+  if (top) format.borderTop = top;
+  const bottom = borderSide(borders, "bottom");
+  if (bottom) format.borderBottom = bottom;
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start");
+  if (left) format.borderLeft = left;
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end");
+  if (right) format.borderRight = right;
+  const background = shadingOf(tblPr);
+  if (background) format.background = background;
+  const align = ALIGN_BY_JC[childValue(tblPr, "jc") ?? ""];
+  if (align) format.align = align;
+  const tblInd = childByLocalName(tblPr, "tblInd");
+  const indentLeftPt = tblInd ? twipsToPt(wAttr(tblInd, "w")) : null;
+  if (indentLeftPt !== null) format.indentLeftPt = indentLeftPt;
+  return format;
+}
+function readRowHeight(trHeight) {
+  const pt = twipsToPt(wAttr(trHeight, "val"));
+  if (pt === null || pt <= 0) return null;
+  const rule = wAttr(trHeight, "hRule") === "exact" ? "exact" : "atLeast";
+  return { rule, pt };
+}
+function readRowFormat(trPr) {
+  if (!trPr) return null;
+  const trHeight = childByLocalName(trPr, "trHeight");
+  const height = trHeight ? readRowHeight(trHeight) : null;
+  const format = {};
+  if (height) format.height = height;
+  if (isOn(trPr, "tblHeader")) format.repeatHeader = true;
+  if (isOn(trPr, "cantSplit")) format.cantSplit = true;
+  return format;
+}
+var CELL_VERTICAL_ALIGN_BY_VAL = {
+  top: "top",
+  center: "center",
+  bottom: "bottom"
+};
+function readCellPadding(tcPr, margins) {
+  const padding = layerCellMargins(margins, readCellMarginsOf(tcPr, "tcMar"));
+  const format = {};
+  if (padding.topPt !== null) format.paddingTopPt = padding.topPt;
+  if (padding.rightPt !== null) format.paddingRightPt = padding.rightPt;
+  if (padding.bottomPt !== null) format.paddingBottomPt = padding.bottomPt;
+  if (padding.leftPt !== null) format.paddingLeftPt = padding.leftPt;
+  return format;
+}
+function readCellFormat(tcPr, defaults, margins = NO_CELL_MARGINS) {
+  const borders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
+  const format = {};
+  const top = borderSide(borders, "top") ?? defaults.top;
+  if (top) format.borderTop = top;
+  const bottom = borderSide(borders, "bottom") ?? defaults.bottom;
+  if (bottom) format.borderBottom = bottom;
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? defaults.left;
+  if (left) format.borderLeft = left;
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? defaults.right;
+  if (right) format.borderRight = right;
+  if (tcPr) {
+    const background = shadingOf(tcPr);
+    if (background) format.background = background;
+    const verticalAlign = CELL_VERTICAL_ALIGN_BY_VAL[childValue(tcPr, "vAlign") ?? ""];
+    if (verticalAlign) format.verticalAlign = verticalAlign;
+  }
+  const padded = { ...format, ...readCellPadding(tcPr, margins) };
+  return Object.keys(padded).length > 0 ? padded : null;
+}
+function insideBordersOf(tblPr) {
+  const el = tblPr === null ? null : parsePropsXml(tblPr);
+  return readInsideBorders(el);
+}
+function cellMarginsOf(tblPr) {
+  const el = tblPr === null ? null : parsePropsXml(tblPr);
+  return readCellMarginsOf(el, "tblCellMar");
+}
+function readCellProps(tcPr, defaults, margins = NO_CELL_MARGINS) {
+  const el = tcPr === null ? null : parsePropsXml(tcPr);
+  return readCellFormat(el, defaults, margins);
+}
+export {
+  NO_BORDER_DEFAULTS,
+  NO_CELL_MARGINS,
+  NO_INSIDE_BORDERS,
+  cellBorderDefaults,
+  cellMarginsOf,
+  gridEdgesOf,
+  insideBordersOf,
+  layerCellMargins,
+  layerInsideBorders,
+  readCellFormat,
+  readCellMarginsOf,
+  readCellProps,
+  readGridCols,
+  readInsideBorders,
+  readRowFormat,
+  readTableFormat,
+  readTableWidth,
+  tblStyleIdOf
+};

package/dist/docx/tableFormatting.d.ts

@@ -0,0 +1,2 @@
+export * from "./tableFormatting/editing";
+export * from "./tableFormatting/reading";

package/dist/docx/tableFormatting.js

@@ -0,0 +1,3 @@
+// src/docx/tableFormatting.ts
+export * from "./tableFormatting/editing.js";
+export * from "./tableFormatting/reading.js";

package/dist/docx/tableTemplate.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Builds a single new table as a document model.
+ *
+ * The editor knows nothing about XML, so the `w:tblPr` and `w:tcPr` the new table will use are
+ * written out as text here too. The fragments we write are then read back with the same reading
+ * functions used when opening a document, to derive the display values.
+ * That way a freshly inserted table looks on screen exactly as it does after saving and reopening.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type PageGeometry } from "./pageGeometry";
+/** Whether the value can be used as a row count or a cell count */
+export declare function isTableSide(value: number): boolean;
+/**
+ * A single table made up of nothing but empty cells.
+ *
+ * The table is as wide as one line of body text on the paper the document names, its column
+ * widths divide that width evenly, and the borders are black 0.5pt solid lines. A document that
+ * names no paper gets the A4 body width, which is what every document used to get.
+ * Being a new table with no original fragment, it is rewritten in full by `serializeTable` on export.
+ * The row and cell counts must be values that have passed through `isTableSide`.
+ */
+export declare function createTableNode(rows: number, cols: number, geometry?: PageGeometry): PMNode;

package/dist/docx/tableTemplate.js

@@ -0,0 +1,111 @@
+// src/docx/tableTemplate.ts
+import { docxSchema } from "../schema/index.js";
+import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
+import { parsePropsXml } from "./propsXml.js";
+import {
+  cellBorderDefaults,
+  gridEdgesOf,
+  NO_CELL_MARGINS,
+  readCellFormat,
+  readInsideBorders,
+  readTableFormat,
+  readTableWidth
+} from "./tableFormatting.js";
+var MAX_TABLE_SIDE = 50;
+function isTableSide(value) {
+  return Number.isInteger(value) && value >= 1 && value <= MAX_TABLE_SIDE;
+}
+var BORDER_EIGHTHS = 4;
+var BORDER_SIDES = [
+  "top",
+  "left",
+  "bottom",
+  "right",
+  "insideH",
+  "insideV"
+];
+function borderXml(side) {
+  return `<w:${side} w:val="single" w:sz="${BORDER_EIGHTHS}" w:space="0" w:color="000000"/>`;
+}
+function tablePropsXml(width) {
+  const borders = BORDER_SIDES.map(borderXml).join("");
+  return `<w:tblPr><w:tblW w:w="${width}" w:type="dxa"/><w:tblBorders>${borders}</w:tblBorders><w:tblLayout w:type="fixed"/></w:tblPr>`;
+}
+function cellPropsXml(width) {
+  return `<w:tcPr><w:tcW w:w="${width}" w:type="dxa"/></w:tcPr>`;
+}
+function evenGridCols(cols, total) {
+  const base = Math.floor(total / cols);
+  const extra = total - base * cols;
+  return Array.from(
+    { length: cols },
+    (_, index) => index < extra ? base + 1 : base
+  );
+}
+function cellTemplate(width, defaults) {
+  const tcPr = cellPropsXml(width);
+  const el = parsePropsXml(tcPr);
+  return {
+    tcPr,
+    tcW: readTableWidth(el, "tcW"),
+    // A new table writes no `tblCellMar`, so its cells take their padding from the stylesheet
+    format: readCellFormat(el, defaults, NO_CELL_MARGINS)
+  };
+}
+function cellNode(props) {
+  return docxSchema.nodes.tableCell.create(
+    {
+      colspan: 1,
+      rowspan: 1,
+      colwidth: null,
+      tcAttrs: null,
+      tcPr: props.tcPr,
+      tcW: props.tcW,
+      format: props.format
+    },
+    docxSchema.nodes.paragraph.create()
+  );
+}
+function rowNode(cells) {
+  return docxSchema.nodes.tableRow.create(
+    { trAttrs: null, trPr: null, format: null },
+    cells.map(cellNode)
+  );
+}
+function createTableNode(rows, cols, geometry = A4_PORTRAIT) {
+  const total = bodyWidth(geometry).twips;
+  const gridCols = evenGridCols(cols, total);
+  const tblPr = tablePropsXml(total);
+  const tblPrEl = parsePropsXml(tblPr);
+  const inside = readInsideBorders(tblPrEl);
+  const outer = readTableFormat(tblPrEl);
+  const cellAt = (row, col) => cellTemplate(
+    gridCols[col],
+    cellBorderDefaults(
+      gridEdgesOf(
+        { top: row, bottom: row + 1, left: col, right: col + 1 },
+        { rows, cols }
+      ),
+      outer,
+      inside
+    )
+  );
+  return docxSchema.nodes.table.create(
+    {
+      srcId: null,
+      tblAttrs: null,
+      tblPr,
+      tblW: readTableWidth(tblPrEl, "tblW"),
+      gridCols,
+      format: outer
+    },
+    Array.from(
+      { length: rows },
+      (_, row) => rowNode(gridCols.map((_width, col) => cellAt(row, col)))
+    )
+  );
+}
+export {
+  createTableNode,
+  isTableSide
+};

package/dist/docx/theme.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The fonts a document's theme names, and the references a run makes to them.
+ *
+ * Instead of naming a font, a `w:rFonts` may point at the theme
+ * (`w:asciiTheme="minorHAnsi"`), which is what Word writes for most of what it produces
+ * and what a Japanese or Chinese document almost always carries.
+ * Resolving those references is what lets such a run be drawn in the font the reader
+ * would see in Word. It is used for display only: the theme attributes themselves are
+ * carried back out untouched, so nothing read here reaches the file.
+ */
+/** The typefaces one font scheme names, one per script */
+interface ThemeFontScheme {
+    latin: string | null;
+    eastAsia: string | null;
+    complexScript: string | null;
+}
+/** The two font schemes a theme defines: one for headings, one for body text */
+export interface ThemeFonts {
+    major: ThemeFontScheme;
+    minor: ThemeFontScheme;
+}
+/** What applies to a document with no theme part, or one whose theme names no font */
+export declare const NO_THEME_FONTS: ThemeFonts;
+/**
+ * The theme attribute paired with each font slot.
+ * A theme reference and a name in the same slot cannot both apply, so the name wins,
+ * the way Word reads them.
+ */
+export declare const THEME_ATTRS: Record<string, readonly string[]>;
+/** The font one theme reference stands for. null for a reference we cannot resolve */
+export declare function themeFontName(fonts: ThemeFonts, value: string | null): string | null;
+/**
+ * Reads the font scheme out of theme1.xml.
+ *
+ * The per-script fonts (`a:font script="Jpan"`) a theme lists beside those three are the
+ * ones Word swaps in when the language of the text changes, which is not something the
+ * screen decides, so they are left alone.
+ */
+export declare function readThemeFonts(theme: Document): ThemeFonts;
+export {};

package/dist/docx/theme.js

@@ -0,0 +1,61 @@
+// src/docx/theme.ts
+import { childByLocalName } from "../ooxml/xml.js";
+var NO_FONT_SCHEME = {
+  latin: null,
+  eastAsia: null,
+  complexScript: null
+};
+var NO_THEME_FONTS = {
+  major: NO_FONT_SCHEME,
+  minor: NO_FONT_SCHEME
+};
+var THEME_ATTRS = {
+  ascii: ["asciiTheme"],
+  hAnsi: ["hAnsiTheme"],
+  eastAsia: ["eastAsiaTheme"],
+  // This is the slot whose capitalization varies from document to document
+  cs: ["cstheme", "csTheme"]
+};
+var THEME_SLOTS = {
+  majorascii: { scheme: "major", script: "latin" },
+  majorhansi: { scheme: "major", script: "latin" },
+  majoreastasia: { scheme: "major", script: "eastAsia" },
+  majorbidi: { scheme: "major", script: "complexScript" },
+  minorascii: { scheme: "minor", script: "latin" },
+  minorhansi: { scheme: "minor", script: "latin" },
+  minoreastasia: { scheme: "minor", script: "eastAsia" },
+  minorbidi: { scheme: "minor", script: "complexScript" }
+};
+function themeFontName(fonts, value) {
+  if (value === null) return null;
+  const slot = THEME_SLOTS[value.trim().toLowerCase()];
+  return slot ? fonts[slot.scheme][slot.script] : null;
+}
+function typefaceOf(font, name) {
+  const el = font ? childByLocalName(font, name) : null;
+  const typeface = el?.getAttribute("typeface") ?? null;
+  return typeface !== null && typeface.length > 0 ? typeface : null;
+}
+function fontSchemeOf(fontScheme, slot) {
+  const font = fontScheme ? childByLocalName(fontScheme, slot) : null;
+  if (!font) return NO_FONT_SCHEME;
+  return {
+    latin: typefaceOf(font, "latin"),
+    eastAsia: typefaceOf(font, "ea"),
+    complexScript: typefaceOf(font, "cs")
+  };
+}
+function readThemeFonts(theme) {
+  const elements = childByLocalName(theme.documentElement, "themeElements");
+  const fontScheme = elements ? childByLocalName(elements, "fontScheme") : null;
+  return {
+    major: fontSchemeOf(fontScheme, "majorFont"),
+    minor: fontSchemeOf(fontScheme, "minorFont")
+  };
+}
+export {
+  NO_THEME_FONTS,
+  THEME_ATTRS,
+  readThemeFonts,
+  themeFontName
+};

package/dist/docx/uniqueControls.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,62 @@
+// 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
+};