@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/scan.js

@@ -1,49 +1,19 @@
 // src/docx/scan.ts
 import { DocxImportError } from "../ooxml/errors.js";
+import { readTag } from "../ooxml/tagScan.js";
 import { localPart } from "../ooxml/xml.js";
-function skipPast(source, from, marker) {
-  const at = source.indexOf(marker, from);
-  if (at === -1) {
-    throw new DocxImportError("malformed-xml", `no ${marker} to close a tag`);
-  }
-  return at + marker.length;
-}
-function skipNonTag(source, lt) {
-  if (source.startsWith("<?", lt)) return skipPast(source, lt, "?>");
-  if (source.startsWith("<!--", lt)) return skipPast(source, lt, "-->");
-  if (source.startsWith("<![CDATA[", lt)) return skipPast(source, lt, "]]>");
-  if (source.startsWith("<!", lt)) return skipPast(source, lt, ">");
-  return null;
-}
-function readOpenTag(source, lt) {
-  let i = lt + 1;
-  const nameStart = i;
-  while (i < source.length && !" 	\r\n/>".includes(source[i])) i += 1;
-  const name = source.slice(nameStart, i);
-  if (!name)
-    throw new DocxImportError("malformed-xml", "a tag has an empty name");
-  let quote = null;
-  while (i < source.length) {
-    const ch = source[i];
-    if (quote !== null) {
-      if (ch === quote) quote = null;
-    } else if (ch === '"' || ch === "'") {
-      quote = ch;
-    } else if (ch === ">") {
-      return { name, end: i + 1, selfClosing: source[i - 1] === "/" };
-    }
-    i += 1;
+function tagAt(source, lt) {
+  const tag = readTag(source, lt);
+  if (!tag) {
+    throw new DocxImportError(
+      "malformed-xml",
+      "a tag cannot be read to its end"
+    );
   }
-  throw new DocxImportError("malformed-xml", "a tag is left unclosed");
-}
-function readCloseTag(source, lt) {
-  const gt = source.indexOf(">", lt);
-  if (gt === -1)
-    throw new DocxImportError("malformed-xml", "a tag is left unclosed");
-  return { name: source.slice(lt + 2, gt).trim(), end: gt + 1 };
+  return tag;
 }
 function isBodyTag(tag, depth) {
-  return localPart(tag.name) === "body" && depth === 1 && !tag.selfClosing;
+  return localPart(tag.name) === "body" && depth === 1 && tag.kind === "open";
 }
 function scanBody(source) {
   const stack = [];
@@ -60,33 +30,31 @@ function scanBody(source) {
   while (i < source.length) {
     const lt = source.indexOf("<", i);
     if (lt === -1) break;
-    const skipped = skipNonTag(source, lt);
-    if (skipped !== null) {
-      i = skipped;
+    const tag = tagAt(source, lt);
+    if (tag.kind === "other") {
+      i = tag.end;
       continue;
     }
-    if (source.startsWith("</", lt)) {
-      const tag2 = readCloseTag(source, lt);
+    if (tag.kind === "close") {
       const opened = stack.pop();
-      if (opened !== tag2.name) {
+      if (opened !== tag.name) {
         throw new DocxImportError(
           "malformed-xml",
-          `mismatched tags: ${opened} vs ${tag2.name}`
+          `mismatched tags: ${opened} vs ${tag.name}`
         );
       }
-      if (atBodyLevel()) takeBlock(tag2.name, tag2.end);
-      i = tag2.end;
+      if (atBodyLevel()) takeBlock(tag.name, tag.end);
+      i = tag.end;
       continue;
     }
-    const tag = readOpenTag(source, lt);
     if (bodyDepth === null && isBodyTag(tag, stack.length)) {
       stack.push(tag.name);
       bodyDepth = stack.length;
       contentStart = tag.end;
       sliceStart = tag.end;
     } else {
-      if (atBodyLevel() && tag.selfClosing) takeBlock(tag.name, tag.end);
-      if (!tag.selfClosing) stack.push(tag.name);
+      if (atBodyLevel() && tag.kind === "empty") takeBlock(tag.name, tag.end);
+      if (tag.kind === "open") stack.push(tag.name);
     }
     i = tag.end;
   }

package/dist/docx/sdt.js

@@ -1,12 +1,14 @@
 // src/docx/sdt.ts
-import { wAttr } from "../ooxml/units.js";
-import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
+import { elementXml, openTagXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
 import {
   parseProps,
   propsChild,
-  renderProps,
-  setPropsChild
-} from "./propsXml.js";
+  renderElement,
+  setChild
+} from "../ooxml/props.js";
+import { wAttr } from "../ooxml/units.js";
+import { attrString, elementChildren, serializeXml } from "../ooxml/xml.js";
 var CONTENTS_LOCKED = ["contentLocked", "sdtContentLocked"];
 var DELETION_LOCKED = ["sdtLocked", "sdtContentLocked"];
 function lockValue(sdtPr) {
@@ -31,30 +33,18 @@ function readSdtWrapper(el) {
   const attrs = attrString(el);
   const val = lockValue(sdtPr);
   return {
-    prefix: (attrs ? `<w:sdt ${attrs}>` : "<w:sdt>") + head.map(serializeXml).join(""),
+    prefix: openTagXml(wName("sdt"), attrs) + head.map(serializeXml).join(""),
     content,
     contentsLocked: val !== null && CONTENTS_LOCKED.includes(val),
     deletionLocked: val !== null && DELETION_LOCKED.includes(val)
   };
 }
-var SDT_ORDER = ["sdtPr", "sdtEndPr", "sdtContent"];
-var SDT_PR_ORDER = [
-  "rPr",
-  "alias",
-  "tag",
-  "id",
-  "lock",
-  "placeholder",
-  "showingPlcHdr",
-  "dataBinding",
-  "temporary"
-];
 function newControlId() {
   return Math.floor(Math.random() * 2147483647);
 }
 function renderPrefix(props) {
-  const open = props.attrs ? `<${props.tag} ${props.attrs}>` : `<${props.tag}>`;
-  return open + props.children.map((child) => child.xml).join("");
+  const inner = props.children.map((child) => (child.before ?? "") + child.xml).join("");
+  return openTagXml(props.tag, props.attrs) + inner + (props.tail ?? "");
 }
 var NAMES_NOTHING = ["id", "lock"];
 function namesNothing(prefix) {
@@ -65,32 +55,19 @@ function namesNothing(prefix) {
   if (!props || sdt.children.length !== 1) return false;
   return props.children.every((child) => NAMES_NOTHING.includes(child.name));
 }
-function emptyProps(props) {
-  return props.attrs ? `<${props.tag} ${props.attrs}/>` : `<${props.tag}/>`;
-}
 function editSdtPrefix(prefix, edits) {
   const sdt = parseProps(`${prefix}</w:sdt>`);
   const sdtPr = sdt && propsChild(sdt.children, "sdtPr");
   const props = sdtPr ? parseProps(sdtPr.xml) : null;
   if (!sdt || !props) return null;
-  const children = edits.reduce(
-    (kept, [name, xml]) => setPropsChild(kept, name, xml, SDT_PR_ORDER),
-    props.children
+  const rendered = renderElement(
+    edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), props)
   );
-  const rendered = renderProps({ ...props, children });
-  return renderPrefix({
-    ...sdt,
-    children: setPropsChild(
-      sdt.children,
-      "sdtPr",
-      rendered === "" ? emptyProps(props) : rendered,
-      SDT_ORDER
-    )
-  });
+  return renderPrefix(setChild(sdt, "sdtPr", rendered));
 }
 function copiedControlPrefix(prefix, id) {
   const copied = editSdtPrefix(prefix, [
-    ["id", `<w:id w:val="${id}"/>`],
+    ["id", elementXml(wName("id"), [[wName("val"), `${id}`]])],
     ["dataBinding", null]
   ]);
   return copied ?? prefix;

package/dist/docx/sdtProps.d.ts

@@ -1,5 +1,6 @@
 /**
- * Turning the lock of a content control on and off inside the opening XML it goes back out as.
+ * Turning the lock of a content control on and off inside the opening XML it goes back out as,
+ * and writing the opening of a control that is locked from the start.
  *
  * Nothing but the `w:lock` child of the `w:sdtPr` moves. The id Word gave the control, the alias
  * and tag it goes by, and the `w:dataBinding` that ties it to the file's own XML all stay, which
@@ -10,6 +11,12 @@
  * A control Word gave nothing but a guard against deletion (`sdtLocked`) is therefore shut by
  * being given the stricter value, and lifting that lock afterwards opens both clauses.
  */
+/**
+ * The opening of a new control that shuts both clauses, which is what a stretch being locked is
+ * wrapped in. It carries its id and the lock and nothing else, so a later lock may take it over
+ * (`namesNothing` in `./sdt`).
+ */
+export declare function lockedControlPrefix(id: number): string;
 /**
  * The opening of the control with its lock shut or lifted.
  * null for a prefix whose shape cannot be made out, which leaves the caller to decide what to do

package/dist/docx/sdtProps.js

@@ -1,11 +1,21 @@
 // src/docx/sdtProps.ts
+import { elementXml, openTagXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
 import { editSdtPrefix } from "./sdt.js";
 var LOCK_BOTH_CLAUSES = '<w:lock w:val="sdtContentLocked"/>';
+function lockedControlPrefix(id) {
+  return openTagXml(wName("sdt"), null) + elementXml(
+    wName("sdtPr"),
+    [],
+    [elementXml(wName("id"), [[wName("val"), `${id}`]]), LOCK_BOTH_CLAUSES]
+  );
+}
 function withContentLock(sdtPrefix, locked) {
   return editSdtPrefix(sdtPrefix, [
     ["lock", locked ? LOCK_BOTH_CLAUSES : null]
   ]);
 }
 export {
+  lockedControlPrefix,
   withContentLock
 };

package/dist/docx/serializeBlock.d.ts

@@ -1,4 +1,6 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { type ExportRefs } from "./exportRefs";
 import { type SessionStore } from "./session";
+/** Why there is no original to write, which a block that came in from another document answers differently */
+export declare function lostOriginal(node: PMNode, session: SessionStore): string;
 export declare function serializeBlock(node: PMNode, session: SessionStore, refs?: ExportRefs): string;

package/dist/docx/serializeBlock.js

@@ -3,14 +3,16 @@ import { DocxExportError } from "../ooxml/errors.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
 import { preservedXml, serializeParagraph } from "./serializeParagraph.js";
 import { serializeTable } from "./serializeTable.js";
-import { originalBlock } from "./session.js";
+import { originalBlock, splitBlockKey } from "./session.js";
+function lostOriginal(node, session) {
+  const srcId = node.attrs.srcId;
+  const key = typeof srcId === "string" ? splitBlockKey(srcId) : null;
+  return key === null || key.sessionId === session.sessionId ? "a preserved block has lost its original XML" : `a preserved block comes from another document (${key.sessionId})`;
+}
 function serializeRaw(node, session) {
   const imported = originalBlock(node, session);
   if (!imported) {
-    throw new DocxExportError(
-      "lost-original",
-      "a preserved block has lost its original XML"
-    );
+    throw new DocxExportError("lost-original", lostOriginal(node, session));
   }
   return imported.xml;
 }
@@ -18,13 +20,13 @@ function serializeBlock(node, session, refs = NO_EXPORT_REFS) {
   if (node.type.name === "paragraph") return serializeParagraph(node, refs);
   if (node.type.name === "table") return serializeTable(node, refs);
   if (node.type.name === "rawBlock") return preservedXml(node);
-  if (node.type.name === "bookmarkBlock") return serializeRaw(node, session);
-  if (node.type.name === "docxRaw") return serializeRaw(node, session);
+  if (node.type.isInGroup("preserved")) return serializeRaw(node, session);
   throw new DocxExportError(
     "unsupported-content",
     `block we cannot serialize: ${node.type.name}`
   );
 }
 export {
+  lostOriginal,
   serializeBlock
 };

package/dist/docx/serializeParagraph.d.ts

@@ -10,6 +10,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import { type ExportRefs } from "./exportRefs";
-export declare function openTag(name: string, attrs: unknown): string;
+/** The attribute text a node attr holds, which is either what the original wrote or nothing */
+export declare function rawAttrsOf(value: unknown): string | null;
 export declare function preservedXml(node: PMNode): string;
 export declare function serializeParagraph(node: PMNode, refs?: ExportRefs): string;

package/dist/docx/serializeParagraph.js

@@ -1,4 +1,5 @@
 // src/docx/serializeParagraph.ts
+import { elementXml, emptyTagXml, openTagXml } from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
 import {
   imageDrawingXml,
@@ -6,6 +7,7 @@ import {
   toImageSrc,
   withExtent
 } from "../ooxml/image.js";
+import { wName } from "../ooxml/names.js";
 import { escapeXml } from "../ooxml/xml.js";
 import { NO_EXPORT_REFS } from "./exportRefs.js";
 import { relIdIn, withRelId } from "./hyperlink.js";
@@ -16,11 +18,8 @@ function sameMark(a, b) {
 function markOf(node, name) {
   return node.marks.find((mark) => mark.type.name === name) ?? null;
 }
-function openTag(name, attrs) {
-  return typeof attrs === "string" ? `<${name} ${attrs}>` : `<${name}>`;
-}
-function emptyTag(name, attrs) {
-  return typeof attrs === "string" ? `<${name} ${attrs}/>` : `<${name}/>`;
+function rawAttrsOf(value) {
+  return typeof value === "string" ? value : null;
 }
 function renderImage(node, images) {
   const extent = toImageExtent(node.attrs.extent);
@@ -51,19 +50,28 @@ function renderInline(node, images) {
   if (node.isText) {
     const tab = markOf(node, "tab");
     return (node.text ?? "").split("	").flatMap((text, index, pieces) => {
-      const rendered = text ? [`<w:t xml:space="preserve">${escapeXml(text)}</w:t>`] : [];
-      return index < pieces.length - 1 ? [...rendered, emptyTag("w:tab", tab?.attrs.tabAttrs)] : rendered;
+      const rendered = text ? [
+        elementXml(
+          wName("t"),
+          [["xml:space", "preserve"]],
+          [escapeXml(text)]
+        )
+      ] : [];
+      return index < pieces.length - 1 ? [
+        ...rendered,
+        emptyTagXml(wName("tab"), rawAttrsOf(tab?.attrs.tabAttrs))
+      ] : rendered;
     }).join("");
   }
   if (node.type.name === "hardBreak")
-    return emptyTag("w:br", node.attrs.brAttrs);
+    return emptyTagXml(wName("br"), rawAttrsOf(node.attrs.brAttrs));
   if (node.type.name === "image") return renderImage(node, images);
   if (node.type.name === "commentReference") {
     const original = node.attrs.referenceXml;
     if (typeof original === "string") return original;
     const id = node.attrs.id;
     if (typeof id === "string") {
-      return `<w:commentReference w:id="${escapeXml(id)}"/>`;
+      return elementXml(wName("commentReference"), [[wName("id"), id]]);
     }
     throw new DocxExportError(
       "lost-original",
@@ -76,7 +84,7 @@ function renderInline(node, images) {
     const id = node.attrs.id;
     const name = node.attrs.kind === "endnote" ? "endnoteReference" : "footnoteReference";
     if (typeof id === "string") {
-      return `<w:${name} w:id="${escapeXml(id)}"/>`;
+      return elementXml(wName(name), [[wName("id"), id]]);
     }
     throw new DocxExportError(
       "lost-original",
@@ -117,7 +125,10 @@ function addInline(parts, child, images) {
       );
     }
     const name = child.type.name === "commentStart" ? "commentRangeStart" : "commentRangeEnd";
-    parts.push({ kind: "raw", xml: `<w:${name} w:id="${escapeXml(id)}"/>` });
+    parts.push({
+      kind: "raw",
+      xml: elementXml(wName(name), [[wName("id"), id]])
+    });
     return;
   }
   const piece = renderInline(child, images);
@@ -150,7 +161,7 @@ function splitParagraphGroups(paragraph, refs) {
 }
 function renderParagraphPart(part) {
   if (part.kind === "raw") return part.xml;
-  const open = openTag("w:r", part.mark?.attrs.rAttrs);
+  const open = openTagXml(wName("r"), rawAttrsOf(part.mark?.attrs.rAttrs));
   const rPr = part.mark?.attrs.rPr;
   return open + (typeof rPr === "string" ? rPr : "") + part.pieces.join("") + "</w:r>";
 }
@@ -196,13 +207,13 @@ function renderParagraphGroup(group, refs) {
   return `${prefix}<w:sdtContent>${body}</w:sdtContent></w:sdt>`;
 }
 function serializeParagraph(node, refs = NO_EXPORT_REFS) {
-  const open = openTag("w:p", node.attrs.pAttrs);
+  const open = openTagXml(wName("p"), rawAttrsOf(node.attrs.pAttrs));
   const pPr = node.attrs.pPr;
   const body = splitParagraphGroups(node, refs).map((group) => renderParagraphGroup(group, refs)).join("");
   return open + (typeof pPr === "string" ? pPr : "") + body + "</w:p>";
 }
 export {
-  openTag,
   preservedXml,
+  rawAttrsOf,
   serializeParagraph
 };

package/dist/docx/serializeTable.js

@@ -5,18 +5,21 @@ import {
   toTableWidth,
   widthNumber
 } from "../model/format.js";
+import { elementXml, openTagXml } from "../ooxml/element.js";
 import { DocxExportError } from "../ooxml/errors.js";
-import { NO_EXPORT_REFS } from "./exportRefs.js";
+import { wName } from "../ooxml/names.js";
 import {
+  innerXml,
   parseProps,
+  propsChild,
   renderProps,
-  setPropsChild,
-  TBL_PR_ORDER,
-  TC_PR_ORDER
-} from "./propsXml.js";
+  setChild
+} from "../ooxml/props.js";
+import { ST_MeasurementOrPercent, ST_TwipsMeasure } from "../ooxml/simpleTypes.js";
+import { NO_EXPORT_REFS } from "./exportRefs.js";
 import {
-  openTag,
   preservedXml,
+  rawAttrsOf,
   serializeParagraph
 } from "./serializeParagraph.js";
 function propsOf(xml, tag) {
@@ -27,44 +30,72 @@ function propsOf(xml, tag) {
   }
   return parsed;
 }
-function widthXml(name, width) {
-  return `<w:${name} w:w="${widthNumber(width) ?? 0}" w:type="${width.type}"/>`;
+function modelled(name, attrs, replacing) {
+  const inner = replacing === void 0 ? "" : innerXml(replacing);
+  return elementXml(wName(name), attrs, inner === "" ? [] : [inner]);
+}
+function widthText(width) {
+  const value = widthNumber(width);
+  if (value === null || !Number.isFinite(value)) return "0";
+  return ST_MeasurementOrPercent.format({
+    kind: "number",
+    value: Math.round(value)
+  }) ?? "0";
+}
+function widthXml(name, width, replacing) {
+  return modelled(
+    name,
+    [
+      [wName("w"), widthText(width)],
+      [wName("type"), width.type]
+    ],
+    replacing
+  );
 }
-function withWidth(props, name, width, order) {
+function withWidth(props, name, width) {
   if (!width) return props;
-  return {
-    ...props,
-    children: setPropsChild(props.children, name, widthXml(name, width), order)
-  };
+  const replacing = propsChild(props.children, name)?.xml;
+  return setChild(props, name, widthXml(name, width, replacing));
 }
 function tablePropsXml(table) {
   const props = propsOf(table.attrs.tblPr, "w:tblPr");
   const width = toTableWidth(table.attrs.tblW);
-  return renderProps(withWidth(props, "tblW", width, TBL_PR_ORDER));
+  return renderProps(withWidth(props, "tblW", width)) || elementXml(wName("tblPr"), []);
 }
 function tableGridXml(table) {
   const gridCols = toGridCols(table.attrs.gridCols);
-  if (gridCols.length === 0) return "";
-  const cols = gridCols.map((w) => `<w:gridCol w:w="${w}"/>`).join("");
-  return `<w:tblGrid>${cols}</w:tblGrid>`;
+  const gridChange = typeof table.attrs.gridChange === "string" ? table.attrs.gridChange : "";
+  if (gridCols.length === 0 && gridChange === "") return "";
+  const cols = gridCols.map((w) => {
+    const width = ST_TwipsMeasure.format(Math.round(w));
+    if (width === null) {
+      throw new DocxExportError(
+        "invalid-table",
+        "a grid column has no writable width"
+      );
+    }
+    return elementXml(wName("gridCol"), [[wName("w"), width]]);
+  }).join("");
+  return elementXml(wName("tblGrid"), [], [cols + gridChange]);
 }
 function cellPropsXml(cell, role) {
   const props = propsOf(cell.attrs.tcPr, "w:tcPr");
   const colspan = spanCount(cell.attrs.colspan);
   const rowspan = spanCount(cell.attrs.rowspan);
-  const gridSpan = colspan > 1 ? `<w:gridSpan w:val="${colspan}"/>` : null;
-  const vMerge = role === "continue" ? "<w:vMerge/>" : rowspan > 1 ? '<w:vMerge w:val="restart"/>' : null;
-  let children = setPropsChild(
-    props.children,
+  const gridSpan = colspan > 1 ? modelled(
     "gridSpan",
-    gridSpan,
-    TC_PR_ORDER
-  );
-  children = setPropsChild(children, "vMerge", vMerge, TC_PR_ORDER);
+    [[wName("val"), `${colspan}`]],
+    propsChild(props.children, "gridSpan")?.xml
+  ) : null;
+  const vMerge = role === "continue" ? elementXml(wName("vMerge"), []) : rowspan > 1 ? modelled(
+    "vMerge",
+    [[wName("val"), "restart"]],
+    propsChild(props.children, "vMerge")?.xml
+  ) : null;
+  const spanned = setChild(props, "gridSpan", gridSpan);
+  const merged = setChild(spanned, "vMerge", vMerge);
   const width = toTableWidth(cell.attrs.tcW);
-  return renderProps(
-    withWidth({ ...props, children }, "tcW", width, TC_PR_ORDER)
-  );
+  return renderProps(withWidth(merged, "tcW", width));
 }
 function cellBlockXml(block, refs) {
   if (block.type.name === "paragraph") return serializeParagraph(block, refs);
@@ -81,8 +112,8 @@ function wrapInSdt(xml, cell, role) {
   return `${prefix}<w:sdtContent>${xml}</w:sdtContent></w:sdt>`;
 }
 function cellXml(cell, role, refs) {
-  const body = role === "continue" ? "<w:p/>" : cell.children.map((block) => cellBlockXml(block, refs)).join("");
-  const xml = openTag("w:tc", cell.attrs.tcAttrs) + cellPropsXml(cell, role) + body + "</w:tc>";
+  const body = role === "continue" ? elementXml(wName("p"), []) : cell.children.map((block) => cellBlockXml(block, refs)).join("");
+  const xml = openTagXml(wName("tc"), rawAttrsOf(cell.attrs.tcAttrs)) + cellPropsXml(cell, role) + body + "</w:tc>";
   return wrapInSdt(xml, cell, role);
 }
 function placeRow(row, covering) {
@@ -116,7 +147,7 @@ function rowXml(row, covering, refs) {
   const cells = placeRow(row, covering).map((placed) => cellXml(placed.cell, placed.role, refs)).join("");
   const tblPrEx = row.attrs.tblPrEx;
   const trPr = row.attrs.trPr;
-  return openTag("w:tr", row.attrs.trAttrs) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
+  return openTagXml(wName("tr"), rawAttrsOf(row.attrs.trAttrs)) + (typeof tblPrEx === "string" ? tblPrEx : "") + (typeof trPr === "string" ? trPr : "") + cells + "</w:tr>";
 }
 function serializeTable(table, refs = NO_EXPORT_REFS) {
   const covering = [];
@@ -127,7 +158,7 @@ function serializeTable(table, refs = NO_EXPORT_REFS) {
       "a vertical merge in the table reaches past the last row"
     );
   }
-  return openTag("w:tbl", table.attrs.tblAttrs) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
+  return openTagXml(wName("tbl"), rawAttrsOf(table.attrs.tblAttrs)) + tablePropsXml(table) + tableGridXml(table) + rows + "</w:tbl>";
 }
 export {
   serializeTable

package/dist/docx/session.d.ts

@@ -9,9 +9,9 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { DocumentDefaults } from "../model/format";
-import { type Numbering } from "../numbering/parseNumbering";
+import { type Numbering, type NumberingOptions } from "../numbering/parseNumbering";
 import type { ImportedComments } from "./comments";
-import type { ParagraphFormatLayer, ParagraphStyleOption, StyleTable } from "./formatting";
+import type { FormattingContext, ParagraphStyleOption } from "./formatting";
 import type { HeadersFooters } from "./headersFooters";
 import type { PageGeometry } from "./pageGeometry";
 export interface ImportedBlock {
@@ -28,9 +28,23 @@ export interface ImportedBlock {
 export interface DocxSession {
     readonly kind: "docxSession";
 }
+/** What names one open document, which a block key is written against */
+export interface SessionIdentity {
+    readonly sessionId: string;
+}
+/**
+ * A name for one open document.
+ *
+ * Opening the same bytes twice opens two documents, so this is drawn fresh each time rather than
+ * worked out from what was opened. It carries no `:`, which is what lets a block key be read back
+ * however many colons the story it names holds.
+ */
+export declare function newSessionId(): string;
 /** What the package's own layers read the open document off */
-export declare class SessionStore implements DocxSession {
+export declare class SessionStore implements DocxSession, SessionIdentity {
     readonly kind = "docxSession";
+    /** Which open document this is. Every block key of it names it, so a block of another document is not taken for one of this one */
+    readonly sessionId: string;
     readonly parts: Map<string, Uint8Array>;
     readonly mainPartPath: string;
     readonly documentPrefix: string;
@@ -41,19 +55,12 @@ export declare class SessionStore implements DocxSession {
     readonly defaults: DocumentDefaults;
     /** The effective automatic tab interval read from settings.xml. Used for display only. */
     readonly defaultTabStopPt: number;
-    /** The paragraph properties at the base of the OOXML formatting hierarchy. */
-    readonly paragraphDefaults: ParagraphFormatLayer;
     /** The paper this document is written on, read from the first section. Used for display only: the `w:sectPr` itself goes back out in the preserved tail */
     readonly geometry: PageGeometry;
-    /** The style chain from styles.xml. Used only to fold the style a paragraph points at into its displayed values */
-    readonly styles: StyleTable;
+    /** Everything the display values of a paragraph or a run are resolved against: the style chain, the defaults, the list definitions */
+    readonly formatting: FormattingContext;
     /** The paragraph styles this document defines, in the order styles.xml lists them. What the style picker offers */
     readonly paragraphStyles: ParagraphStyleOption[];
-    /**
-     * The paragraph style every paragraph with no `w:pStyle` of its own wears (`w:default="1"`,
-     * usually Normal). null when the document marks none
-     */
-    readonly defaultParagraphStyleId: string | null;
     /** The raw text of numbering.xml. Kept around so list numbers can be drawn on screen. null if there is none */
     readonly numberingXml: string | null;
     /** Where numbering.xml sits inside the zip. When a new list is exported it is rewritten at that spot. null if there is none */
@@ -76,6 +83,27 @@ export declare function sessionOf(session: DocxSession): SessionStore;
 /** Where the body part sits inside the package, which is the one part an export rewrites */
 export declare function documentPartPath(session: DocxSession): string;
 /** The list definitions the document carries, which is what a paragraph's numbering points into */
-export declare function documentNumbering(session: DocxSession): Numbering;
-/** Finds which original block a node came from. undefined for a node newly created during editing */
+export declare function documentNumbering(session: DocxSession, options?: NumberingOptions): Numbering;
+/** The story a block key names when the block stood in the main document body */
+export declare const BODY_STORY_KEY = "body";
+/** A block key read back: which open document the block came from, which story of it, and where in that story */
+export interface BlockKey {
+    sessionId: string;
+    storyKey: string;
+    index: number;
+}
+/** Where a block stands, as the one string a node carries on its `srcId` */
+export declare function blockKey(session: SessionIdentity, storyKey: string, index: number): string;
+/**
+ * The three parts of a block key, or null for a string that is not one.
+ *
+ * A story key holds colons of its own (`comment:4`), so the key is read from both ends rather
+ * than split: the first segment is the document, the last is the place in the story, and
+ * everything between them is the story itself.
+ */
+export declare function splitBlockKey(key: string): BlockKey | null;
+/**
+ * Finds which original block a node came from. undefined for a node newly created during editing,
+ * and for one that came in from another document, whose original is in that file and not this one.
+ */
 export declare function originalBlock(node: PMNode, session: SessionStore): ImportedBlock | undefined;