@portone/docx-editor 0.4.0 → 0.5.0

package/dist/schema/docxSchema.js

@@ -1,5 +1,7 @@
 // src/schema/docxSchema.ts
-import { Schema } from "prosemirror-model";
+import {
+  Schema
+} from "prosemirror-model";
 import {
   spanCount,
   toBandSizes,
@@ -17,6 +19,7 @@ import {
 } from "../model/format.js";
 import {
   ANY_ELEMENT,
+  ANY_ELEMENTS,
   ATTRIBUTES,
   acceptRawXml,
   ELEMENT
@@ -33,6 +36,7 @@ import {
 } from "../styles/inlineStyle.js";
 import { imageNodeSpec, runMarkSpec } from "./rendering.js";
 import { imageNodeSpec as imageNodeSpec2, runMarkSpec as runMarkSpec2 } from "./rendering.js";
+var NO_STORIES = Object.freeze({});
 function isRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -78,7 +82,7 @@ function repliesHoldTheirXml(value) {
   const replies = value;
   return replies.every((reply) => {
     if (!isRecord(reply)) return true;
-    return acceptRawXml(ELEMENT("comment"), text(reply.commentXml) ?? null) !== false && acceptRawXml(ANY_ELEMENT, text(reply.extensionXml) ?? null) !== false;
+    return acceptRawXml(ANY_ELEMENT, text(reply.extensionXml) ?? null) !== false;
   });
 }
 var SDT_PREFIX = {
@@ -96,22 +100,65 @@ var LINK_PREFIX = {
 function rawXml(dom, attribute, shape) {
   return acceptRawXml(shape, dom.getAttribute(attribute));
 }
+function preservedDisplayOf(value) {
+  switch (value) {
+    case "text":
+      return "text";
+    case "break":
+      return "break";
+    case "chip":
+      return "chip";
+    default:
+      return "hidden";
+  }
+}
+function preservedAttributes(node, className) {
+  return {
+    class: className,
+    "data-xml": text(node.attrs.xml),
+    "data-element": text(node.attrs.element),
+    "data-display": preservedDisplayOf(node.attrs.display),
+    "data-text": text(node.attrs.text),
+    "data-guarded": node.attrs.guarded === true ? "1" : void 0
+  };
+}
+function preservedDom(node, className) {
+  const attributes = preservedAttributes(node, className);
+  const display = preservedDisplayOf(node.attrs.display);
+  const preview = text(node.attrs.text);
+  const element = text(node.attrs.element);
+  if (display === "break") return ["span", attributes, ["br"]];
+  if (display === "text") return ["span", attributes, preview ?? ""];
+  if (display === "chip") {
+    return [
+      "span",
+      { ...attributes, title: element ?? UNKNOWN_PLACEHOLDER },
+      preview !== void 0 && preview !== "" ? preview : element ?? "?"
+    ];
+  }
+  return ["span", attributes];
+}
+function preservedAttrs(dom) {
+  const xml = rawXml(dom, "data-xml", ANY_ELEMENT);
+  if (xml === false) return false;
+  return {
+    xml,
+    element: dom.getAttribute("data-element"),
+    display: preservedDisplayOf(dom.getAttribute("data-display")),
+    text: dom.getAttribute("data-text"),
+    guarded: dom.getAttribute("data-guarded") === "1"
+  };
+}
 var TABLE_PLACEHOLDER = "Table (unsupported layout, original is preserved)";
 var UNKNOWN_PLACEHOLDER = "Unsupported content (not editable, original is preserved)";
 var TABLE_NAMES = ["w:tbl", "tbl"];
-function rawBlockDom(name) {
-  if (name !== void 0 && TABLE_NAMES.includes(name)) {
-    return {
-      className: editorClassNames.tablePlaceholder,
-      label: TABLE_PLACEHOLDER
-    };
-  }
-  return { className: editorClassNames.rawBlock, label: UNKNOWN_PLACEHOLDER };
+function placeholderLabel(name) {
+  return name !== void 0 && TABLE_NAMES.includes(name) ? TABLE_PLACEHOLDER : UNKNOWN_PLACEHOLDER;
+}
+function preservedNameOf(dom) {
+  const name = dom.getAttribute("data-name");
+  return name === null || name === "" ? null : name;
 }
-var DOCX_RAW_SELECTOR = [
-  editorClassNames.rawBlock,
-  editorClassNames.tablePlaceholder
-].map((className) => `div[data-src].${className}`).join(", ");
 var docxSchema = new Schema({
   nodes: {
     doc: {
@@ -121,7 +168,20 @@ var docxSchema = new Schema({
          * The definitions of the lists started while editing, which the export writes into
          * numbering.xml. Read back through `numbering/listRegistry`.
          */
-        newLists: { default: null }
+        newLists: { default: null },
+        /**
+         * The section properties that close the body: the paper the document's last section is
+         * written on, its headers and its page numbering (§17.6.18). Held as the fragment the
+         * document wrote, so an untouched document goes back out as the bytes it arrived as.
+         * Read through `docx/sections`.
+         */
+        sectPr: { default: null },
+        /**
+         * What each side story - a comment's body, a footnote's - currently says, under the key
+         * naming it (`./stories`). Read and written through `docx/story`; it never reaches the
+         * DOM, so a copy out of the editor carries none of it.
+         */
+        stories: { default: NO_STORIES }
       }
     },
     paragraph: {
@@ -221,7 +281,13 @@ var docxSchema = new Schema({
          */
         styleConditions: { default: null },
         /** How many rows and columns one band of the table style is made of */
-        styleBands: { default: null }
+        styleBands: { default: null },
+        /**
+         * The markers that stood between this table's rows: the ones ahead of the first row
+         * (`docx/importTable`). They are invisible and belong to no row, so they ride along on
+         * the table and go back where they stood
+         */
+        leadingXml: { default: null }
       },
       toDOM(node) {
         const format = toTableFormat(node.attrs.format);
@@ -246,7 +312,8 @@ var docxSchema = new Schema({
           "data-style-conditions": formatJson(
             toTableStyleConditions(node.attrs.styleConditions)
           ),
-          "data-style-bands": formatJson(toBandSizes(node.attrs.styleBands))
+          "data-style-bands": formatJson(toBandSizes(node.attrs.styleBands)),
+          "data-leading": text(node.attrs.leadingXml)
         };
         const body = ["tbody", 0];
         if (gridCols.length === 0) return ["table", attrs, body];
@@ -269,7 +336,8 @@ var docxSchema = new Schema({
               "data-gridchange",
               ELEMENT("tblGridChange")
             );
-            if (tblAttrs === false || tblPr === false || gridChange === false) {
+            const leadingXml = rawXml(dom, "data-leading", ANY_ELEMENTS);
+            if (tblAttrs === false || tblPr === false || gridChange === false || leadingXml === false) {
               return false;
             }
             return {
@@ -291,7 +359,8 @@ var docxSchema = new Schema({
               ),
               styleBands: toBandSizes(
                 parseJson(dom.getAttribute("data-style-bands"))
-              )
+              ),
+              leadingXml
             };
           }
         }
@@ -307,7 +376,11 @@ var docxSchema = new Schema({
         tblPrEx: { default: null },
         /** The whole `<w:trPr>...</w:trPr>` XML */
         trPr: { default: null },
-        format: { default: null }
+        format: { default: null },
+        /** The markers that stood ahead of this row's first cell (`docx/importTable`) */
+        leadingXml: { default: null },
+        /** The markers that stood between this row and the next one, under the table */
+        trailingXml: { default: null }
       },
       toDOM(node) {
         const format = toRowFormat(node.attrs.format);
@@ -319,7 +392,9 @@ var docxSchema = new Schema({
             "data-trattrs": text(node.attrs.trAttrs),
             "data-tblprex": text(node.attrs.tblPrEx),
             "data-trpr": text(node.attrs.trPr),
-            "data-fmt": formatJson(format)
+            "data-fmt": formatJson(format),
+            "data-leading": text(node.attrs.leadingXml),
+            "data-trailing": text(node.attrs.trailingXml)
           },
           0
         ];
@@ -331,14 +406,18 @@ var docxSchema = new Schema({
             const trAttrs = rawXml(dom, "data-trattrs", ATTRIBUTES);
             const tblPrEx = rawXml(dom, "data-tblprex", ELEMENT("tblPrEx"));
             const trPr = rawXml(dom, "data-trpr", ELEMENT("trPr"));
-            if (trAttrs === false || tblPrEx === false || trPr === false) {
+            const leadingXml = rawXml(dom, "data-leading", ANY_ELEMENTS);
+            const trailingXml = rawXml(dom, "data-trailing", ANY_ELEMENTS);
+            if (trAttrs === false || tblPrEx === false || trPr === false || leadingXml === false || trailingXml === false) {
               return false;
             }
             return {
               trAttrs,
               tblPrEx,
               trPr,
-              format: toRowFormat(parseJson(dom.getAttribute("data-fmt")))
+              format: toRowFormat(parseJson(dom.getAttribute("data-fmt"))),
+              leadingXml,
+              trailingXml
             };
           }
         }
@@ -372,7 +451,9 @@ var docxSchema = new Schema({
          * the lock lives inside that very XML.
          */
         sdtContentsLocked: { default: false },
-        sdtDeletionLocked: { default: false }
+        sdtDeletionLocked: { default: false },
+        /** The markers that stood between this cell and the next one, under the row */
+        trailingXml: { default: null }
       },
       toDOM(node) {
         const format = toCellFormat(node.attrs.format);
@@ -394,7 +475,8 @@ var docxSchema = new Schema({
             "data-fmt": formatJson(format),
             "data-sdt-prefix": text(node.attrs.sdtPrefix),
             "data-sdt-contents-locked": locked ? "1" : void 0,
-            "data-sdt-deletion-locked": node.attrs.sdtDeletionLocked === true ? "1" : void 0
+            "data-sdt-deletion-locked": node.attrs.sdtDeletionLocked === true ? "1" : void 0,
+            "data-trailing": text(node.attrs.trailingXml)
           },
           0
         ];
@@ -406,7 +488,8 @@ var docxSchema = new Schema({
             const tcAttrs = rawXml(dom, "data-tcattrs", ATTRIBUTES);
             const tcPr = rawXml(dom, "data-tcpr", ELEMENT("tcPr"));
             const sdtPrefix = rawXml(dom, "data-sdt-prefix", SDT_PREFIX);
-            if (tcAttrs === false || tcPr === false || sdtPrefix === false) {
+            const trailingXml = rawXml(dom, "data-trailing", ANY_ELEMENTS);
+            if (tcAttrs === false || tcPr === false || sdtPrefix === false || trailingXml === false) {
               return false;
             }
             return {
@@ -421,109 +504,68 @@ var docxSchema = new Schema({
               format: toCellFormat(parseJson(dom.getAttribute("data-fmt"))),
               sdtPrefix,
               sdtContentsLocked: dom.getAttribute("data-sdt-contents-locked") === "1",
-              sdtDeletionLocked: dom.getAttribute("data-sdt-deletion-locked") === "1"
+              sdtDeletionLocked: dom.getAttribute("data-sdt-deletion-locked") === "1",
+              trailingXml
             };
           }
         }
       ]
     },
     /**
-     * The node that carries, as original XML, a block inside a table cell that we do
-     * not model (a nested table, for instance).
-     * Unlike a body block it has no original fragment number, so it carries its own
-     * XML around with it.
+     * The one node a block the editor has no model for stands as, wherever it stood: under the
+     * body, or inside a table cell.
+     *
+     * Which of the two it came from is what it carries the original as. A body block is one of the
+     * fragments the session holds, so it names that fragment and the bytes go back out untouched;
+     * a block inside a cell was never a fragment of its own, so it carries its XML with it.
+     *
+     * `display` says whether anything of it is on screen. A range marker draws nothing - it stands
+     * between blocks and marks a spot rather than holding content - while a table nobody could take
+     * apart draws a box saying so.
      */
     rawBlock: {
       group: "block preserved",
       atom: true,
       selectable: false,
       attrs: {
+        /** The element, verbatim, for a block the session holds no fragment of */
         xml: { default: null },
+        /** The fragment of the session this block was opened from */
+        srcId: { default: null },
         /** The original element name (for example `w:tbl`) */
-        name: { default: null }
+        name: { default: null },
+        display: { default: "chip" },
+        /** Whether the deletion guard answers for this block (`./preservedGuards`) */
+        guarded: { default: false }
       },
       toDOM(node) {
-        return [
-          "div",
-          {
-            class: `${editorClassNames.rawBlock} ${editorClassNames.rawXmlBlock}`,
-            "data-xml": text(node.attrs.xml),
-            "data-name": text(node.attrs.name)
-          },
-          UNKNOWN_PLACEHOLDER
-        ];
+        const name = text(node.attrs.name);
+        const display = preservedDisplayOf(node.attrs.display);
+        const attributes = {
+          class: editorClassNames.rawBlock,
+          "data-xml": text(node.attrs.xml),
+          "data-src": text(node.attrs.srcId) ?? "",
+          "data-name": name ?? "",
+          "data-display": display,
+          "data-guarded": node.attrs.guarded === true ? "1" : void 0
+        };
+        if (display !== "chip") return ["div", attributes];
+        return ["div", attributes, placeholderLabel(name)];
       },
       parseDOM: [
         {
-          tag: `div.${editorClassNames.rawXmlBlock}`,
+          tag: `div.${editorClassNames.rawBlock}[data-name]`,
           getAttrs: (dom) => {
             const xml = rawXml(dom, "data-xml", ANY_ELEMENT);
             if (xml === false) return false;
-            return { xml, name: dom.getAttribute("data-name") };
-          }
-        }
-      ]
-    },
-    /** The node that carries a non-paragraph body block (a table we could not model, sectPr, an unknown element) exactly as it came */
-    docxRaw: {
-      group: "block preserved",
-      atom: true,
-      selectable: false,
-      attrs: {
-        srcId: { default: null },
-        /** The original element name (for example `w:tbl`) */
-        name: { default: null }
-      },
-      toDOM(node) {
-        const { className, label } = rawBlockDom(text(node.attrs.name));
-        return [
-          "div",
-          {
-            class: className,
-            "data-src": text(node.attrs.srcId) ?? "",
-            "data-name": text(node.attrs.name)
-          },
-          label
-        ];
-      },
-      parseDOM: [
-        {
-          tag: DOCX_RAW_SELECTOR,
-          getAttrs: (dom) => ({
-            srcId: srcIdOf(dom),
-            name: dom.getAttribute("data-name")
-          })
-        }
-      ]
-    },
-    /** A bookmark range marker that occurs directly under w:body rather than inside a paragraph */
-    bookmarkBlock: {
-      group: "block preserved",
-      atom: true,
-      isolating: true,
-      selectable: false,
-      attrs: {
-        srcId: { default: null },
-        name: { default: null }
-      },
-      toDOM(node) {
-        return [
-          "div",
-          {
-            class: editorClassNames.bookmarkBlock,
-            "data-src": text(node.attrs.srcId) ?? "",
-            "data-name": text(node.attrs.name),
-            hidden: "hidden"
+            return {
+              xml,
+              srcId: srcIdOf(dom),
+              name: preservedNameOf(dom),
+              display: preservedDisplayOf(dom.getAttribute("data-display")),
+              guarded: dom.getAttribute("data-guarded") === "1"
+            };
           }
-        ];
-      },
-      parseDOM: [
-        {
-          tag: `div.${editorClassNames.bookmarkBlock}`,
-          getAttrs: (dom) => ({
-            srcId: srcIdOf(dom),
-            name: dom.getAttribute("data-name")
-          })
         }
       ]
     },
@@ -672,9 +714,6 @@ var docxSchema = new Schema({
         authorId: { default: null },
         initials: { default: null },
         date: { default: null },
-        text: { default: "" },
-        commentXml: { default: null },
-        imported: { default: false },
         paraId: { default: null },
         resolved: { default: false },
         extensionXml: { default: null },
@@ -693,9 +732,6 @@ var docxSchema = new Schema({
             "data-comment-author-id": text(node.attrs.authorId),
             "data-comment-initials": text(node.attrs.initials),
             "data-comment-date": text(node.attrs.date),
-            "data-comment-text": text(node.attrs.text),
-            "data-comment-xml": text(node.attrs.commentXml),
-            "data-comment-imported": node.attrs.imported === true ? "1" : void 0,
             "data-comment-para-id": text(node.attrs.paraId),
             "data-comment-resolved": node.attrs.resolved === true ? "1" : void 0,
             "data-comment-extension-xml": text(node.attrs.extensionXml),
@@ -713,18 +749,13 @@ var docxSchema = new Schema({
               "data-reference-xml",
               ELEMENT("commentReference")
             );
-            const commentXml = rawXml(
-              dom,
-              "data-comment-xml",
-              ELEMENT("comment")
-            );
             const extensionXml = rawXml(
               dom,
               "data-comment-extension-xml",
               ANY_ELEMENT
             );
             const replies = parseJson(dom.getAttribute("data-comment-replies")) ?? [];
-            if (referenceXml === false || commentXml === false || extensionXml === false || !repliesHoldTheirXml(replies)) {
+            if (referenceXml === false || extensionXml === false || !repliesHoldTheirXml(replies)) {
               return false;
             }
             return {
@@ -734,9 +765,6 @@ var docxSchema = new Schema({
               authorId: dom.getAttribute("data-comment-author-id"),
               initials: dom.getAttribute("data-comment-initials"),
               date: dom.getAttribute("data-comment-date"),
-              text: dom.getAttribute("data-comment-text") ?? "",
-              commentXml,
-              imported: dom.getAttribute("data-comment-imported") === "1",
               paraId: dom.getAttribute("data-comment-para-id"),
               resolved: dom.getAttribute("data-comment-resolved") === "1",
               extensionXml,
@@ -757,14 +785,12 @@ var docxSchema = new Schema({
         kind: { default: "footnote" },
         id: { default: null },
         label: { default: "?" },
-        text: { default: "" },
         customMarkFollows: { default: false },
         referenceXml: { default: null }
       },
       toDOM(node) {
         const kind = node.attrs.kind === "endnote" ? "Endnote" : "Footnote";
         const label = text(node.attrs.label) ?? "?";
-        const body = text(node.attrs.text) ?? "";
         return [
           "sup",
           {
@@ -772,11 +798,9 @@ var docxSchema = new Schema({
             "data-note-kind": text(node.attrs.kind),
             "data-note-id": text(node.attrs.id),
             "data-note-label": label,
-            "data-note-text": body,
             "data-custom-mark-follows": node.attrs.customMarkFollows === true ? "1" : void 0,
             "data-reference-xml": text(node.attrs.referenceXml),
-            "aria-label": `${kind} ${label}`,
-            title: body
+            "aria-label": `${kind} ${label}`
           },
           node.attrs.customMarkFollows === true ? "" : label
         ];
@@ -795,7 +819,6 @@ var docxSchema = new Schema({
               kind: dom.getAttribute("data-note-kind") === "endnote" ? "endnote" : "footnote",
               id: dom.getAttribute("data-note-id"),
               label: dom.getAttribute("data-note-label") ?? "?",
-              text: dom.getAttribute("data-note-text") ?? "",
               customMarkFollows: dom.getAttribute("data-custom-mark-follows") === "1",
               referenceXml
             };
@@ -803,29 +826,58 @@ var docxSchema = new Schema({
         }
       ]
     },
+    /**
+     * One child of a run the editor has no node for, kept as the XML it came as.
+     *
+     * It wears the run mark, so it is written back inside the same `<w:r>` as the text beside it,
+     * which is where `EG_RunInnerContent` says it may stand.
+     */
+    rawRunContent: {
+      group: "inline",
+      inline: true,
+      atom: true,
+      marks: "run sdt link",
+      attrs: {
+        xml: { default: null },
+        /** The local name of the element, for example `fldChar` */
+        element: { default: null },
+        display: { default: "hidden" },
+        /** What a `text` display draws, and the preview a chip shows */
+        text: { default: null },
+        /** Whether the deletion guard answers for this fragment (`schema/preservedGuards`) */
+        guarded: { default: false }
+      },
+      toDOM(node) {
+        return preservedDom(node, editorClassNames.rawRunContent);
+      },
+      parseDOM: [
+        {
+          tag: `span.${editorClassNames.rawRunContent}`,
+          getAttrs: preservedAttrs
+        }
+      ]
+    },
     /** The node that carries a non-run element inside a paragraph (a bookmark, for instance) exactly as it came */
     rawInline: {
       group: "inline",
       inline: true,
       atom: true,
       marks: "sdt link",
-      attrs: { xml: { default: null } },
+      attrs: {
+        xml: { default: null },
+        /** The local name of the element; `r` for a run with no content, kept whole */
+        element: { default: null },
+        display: { default: "hidden" },
+        text: { default: null },
+        guarded: { default: false }
+      },
       toDOM(node) {
-        return [
-          "span",
-          {
-            class: editorClassNames.rawInline,
-            "data-xml": text(node.attrs.xml)
-          }
-        ];
+        return preservedDom(node, editorClassNames.rawInline);
       },
       parseDOM: [
         {
           tag: `span.${editorClassNames.rawInline}`,
-          getAttrs: (dom) => {
-            const xml = rawXml(dom, "data-xml", ANY_ELEMENT);
-            return xml === false ? false : { xml };
-          }
+          getAttrs: preservedAttrs
         }
       ]
     },

package/dist/schema/editGuard.d.ts

@@ -46,7 +46,7 @@ export type EditIntent =
  * against the places it puts that guard to the test, and a place naming a guard that no longer
  * stands has to be a mistake the compiler catches rather than an annotation answering for nothing.
  */
-export type EditGuardName = "protection" | "lock" | "bookmark" | "note" | "section";
+export type EditGuardName = "protection" | "lock" | "preserved" | "note" | "section";
 /** What every guard answers, whichever of the two judgements it is written as */
 interface GuardCommon {
     readonly name: EditGuardName;

package/dist/schema/guards.js

@@ -4,7 +4,7 @@ import {
   transactionReaches
 } from "./editGuard.js";
 import { lockGuard } from "./locks.js";
-import { bookmarkGuard, noteGuard, sectionGuard } from "./preservedGuards.js";
+import { noteGuard, preservedGuard, sectionGuard } from "./preservedGuards.js";
 import {
   isCommentNode,
   protectionAllows
@@ -36,7 +36,7 @@ var protectionGuard = {
 var EDIT_GUARDS = [
   protectionGuard,
   lockGuard,
-  bookmarkGuard,
+  preservedGuard,
   noteGuard,
   sectionGuard
 ];

package/dist/schema/index.d.ts

@@ -1,4 +1,5 @@
 export type { AttrClass } from "./attrRoles";
 export { attrsOfClass } from "./attrRoles";
+export type { PreservedDisplay } from "./docxSchema";
 export { docxSchema, isPageBreak } from "./docxSchema";
 export { imageNodeSpec, runMarkSpec } from "./rendering";

package/dist/schema/preservedFragments.d.ts

@@ -0,0 +1,12 @@
+import type { Node as PMNode } from "prosemirror-model";
+type MarkerAttr = "leadingXml" | "trailingXml";
+/**
+ * Whether this node is content the editor keeps as it came rather than one it models.
+ *
+ * The block placeholder declares it as a group; the two inline ones cannot, since their group says
+ * where they may stand, so they are named here and asked for by name everywhere else.
+ */
+export declare function isPreservedNode(node: PMNode): boolean;
+/** Visit preserved XML in the order the writer places it around editable content. */
+export declare function visitPreservedFragments(doc: PMNode, visit: (node: PMNode, pos: number, xml: string | null, attr?: MarkerAttr) => void): void;
+export {};

package/dist/schema/preservedFragments.js

@@ -0,0 +1,38 @@
+// src/schema/preservedFragments.ts
+function isPreservedNode(node) {
+  return node.type.name === "rawInline" || node.type.name === "rawRunContent" || node.type.isInGroup("preserved");
+}
+function visitPreservedFragments(doc, visit) {
+  const visitAttr = (node, pos, attr) => {
+    const xml = node.attrs[attr];
+    if (typeof xml === "string" && xml.length > 0) {
+      visit(node, pos, xml, attr);
+    }
+  };
+  const walk = (node, pos) => {
+    if (isPreservedNode(node)) {
+      visit(
+        node,
+        pos,
+        typeof node.attrs.xml === "string" ? node.attrs.xml : null
+      );
+    }
+    if (node.type.name === "table" || node.type.name === "tableRow") {
+      visitAttr(node, pos, "leadingXml");
+    }
+    node.forEach((child, offset) => {
+      walk(child, pos + 1 + offset);
+    });
+    if (node.type.name === "tableRow" || node.type.name === "tableCell") {
+      visitAttr(node, pos, "trailingXml");
+    }
+  };
+  doc.descendants((node, pos) => {
+    walk(node, pos);
+    return false;
+  });
+}
+export {
+  isPreservedNode,
+  visitPreservedFragments
+};

package/dist/schema/preservedGuards.d.ts

@@ -1,11 +1,13 @@
 /**
- * The guards over what a document is opened with and the editor only preserves: the two ends of a
- * bookmark range, the reference standing where a footnote or an endnote is called, and the
- * paragraph that ends a section.
+ * The guards over what a document is opened with and the editor only preserves: the fragments a
+ * file falls apart without, the reference standing where a footnote or an endnote is called, and
+ * the paragraph that ends a section.
  *
- * None of it is content the editor writes, so nothing in it can put such a thing back once it is
- * gone, and a document that lost one of a bookmark's two ends cannot be written back as a file at
- * all (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
+ * The first of those is the two ends of a bookmark range, the two ends of a permission or move
+ * range, and the pieces of a field, which say what they say only in the order they stand in. None
+ * of it is content the editor writes, so nothing in it can put such a thing back once it is gone,
+ * and a document that lost one of a bookmark's two ends cannot be written back as a file at all
+ * (`docx/exportDocx` refuses it). What the first two guards hold is therefore the whole list of
  * the nodes they answer for, in the order the document carries them; a section break, which an
  * edit may legitimately move from one paragraph to another, is held by its number instead.
  */
@@ -27,7 +29,7 @@ type Signature = (node: PMNode) => string;
  * was.
  */
 export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
-export declare const bookmarkGuard: ChangeGuard;
+export declare const preservedGuard: ChangeGuard;
 export declare const noteGuard: ChangeGuard;
 /**
  * A guard that lets a change through only while it leaves at least as many section breaks standing