@portone/docx-editor 0.2.0 → 0.3.0

package/dist/schema/editGuard.js

@@ -0,0 +1,43 @@
+// src/schema/editGuard.ts
+import {
+  AddMarkStep,
+  AddNodeMarkStep,
+  AttrStep,
+  RemoveMarkStep,
+  RemoveNodeMarkStep,
+  ReplaceAroundStep,
+  ReplaceStep
+} from "prosemirror-transform";
+function rangeHolds(doc, from, to, holds) {
+  let found = false;
+  doc.nodesBetween(from, to, (node) => {
+    if (found) return false;
+    if (holds(node)) found = true;
+    return !found;
+  });
+  return found;
+}
+function stepReaches(step, before, after, holds) {
+  if (step instanceof AttrStep || step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep) {
+    const node = before.nodeAt(step.pos);
+    return node !== null && holds(node);
+  }
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep || step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
+    return true;
+  }
+  let reached = false;
+  step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
+    reached ||= rangeHolds(before, oldStart, oldEnd, holds) || rangeHolds(after, newStart, newEnd, holds);
+  });
+  return reached;
+}
+function transactionReaches(tr, holds) {
+  return tr.steps.some(
+    (step, index) => stepReaches(step, tr.docs[index], tr.docs[index + 1] ?? tr.doc, holds)
+  );
+}
+export {
+  rangeHolds,
+  stepReaches,
+  transactionReaches
+};

package/dist/schema/guards.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The one list an edit is judged against.
+ *
+ * A guard answers, for one rule, whether an edit would leave the document in a state the file
+ * cannot be written back from. `transactionAllowed` runs the list over a built transaction, both
+ * where an edit is dispatched (`editor/plugins/lockedContent`) and where a command is dry-run
+ * (`editor/commands/canRunCommand`), and `editShut` runs it over the intent a command has before
+ * it builds anything. Both ask the same list, which is what keeps a disabled control and a refused
+ * edit saying the same thing.
+ *
+ * What a guard is written against - `EditGuard`, `EditIntent` and the reach primitives - stands in
+ * `./editGuard` so that a module writing a guard need not read this one, and is handed on from
+ * here so that a caller has one door to the whole seam.
+ *
+ * A command decides nothing of its own about any of this. It takes one of the two shapes an edit
+ * comes in - `guardedCommand`, which builds the whole edit and is refused whole, and
+ * `openStretches`, which leaves the shut stretches out and applies to the rest - and both ask the
+ * list below. A guard registered here therefore reaches every command by being registered, rather
+ * than by each command being taught about it.
+ *
+ * `editsShut` (`./protectionState`) stays what it was, the view-level question of whether the body
+ * is open at all, which is a question about the editor rather than about an edit.
+ */
+import type { Command, EditorState, Selection, Transaction } from "prosemirror-state";
+import { type EditGuard, type EditIntent } from "./editGuard";
+import { type ProtectionState } from "./protection";
+export type { EditGuard, EditGuardName, EditIntent } from "./editGuard";
+export { stepReaches } from "./editGuard";
+/**
+ * Whether the transaction reaches a comment node, which is how a body, a reply and a resolution
+ * change. Every comment lives in its three nodes, so a change that reaches none of them cannot
+ * have changed a comment.
+ */
+export declare function transactionTouchesComments(tr: Transaction): boolean;
+/**
+ * Whether the protection lets this transaction through (`./protection`).
+ *
+ * The whole-document judgement is reached for only when a comment is touched at all
+ * (`transactionTouchesComments`). A change that touches none is a body edit: through under `none`,
+ * refused under `comments`, and nothing about ownership to ask.
+ */
+export declare function protectionAllowsTransaction(tr: Transaction, rules: ProtectionState): boolean;
+export declare const EDIT_GUARDS: readonly EditGuard[];
+/**
+ * Whether every guard would let this transaction through, decided and nothing else.
+ *
+ * The refusal a guard itself answers with carries a side effect - the composition it ends
+ * (`editor/plugins/lockedContent`) - which a query about a button's state may not set off, so the
+ * decision stands apart from it and every caller building an edit asks this rather than handing
+ * the transaction to a state.
+ *
+ * A re-derivation of display values is no edit and is let through before any guard is asked. The
+ * whole-change judgements then come first and take no pass, since a pass lifts one guard's
+ * reading of a step rather than another guard's reading of the change. What is left is judged
+ * step by step, each step over the document it was built against.
+ */
+export declare function transactionAllowed(tr: Transaction, state: EditorState): boolean;
+/**
+ * Whether any guard shuts this intent where it stands.
+ *
+ * This is what a command asks before it reports that it applies: a command reporting true and then
+ * being refused by the guard draws a live control that swallows the click.
+ */
+export declare function editShut(state: EditorState, intent: EditIntent): boolean;
+/** What a command doing this to whatever is selected means to do, one intent per selected stretch */
+export declare function selectionIntents(selection: Selection, kind: "mark" | "replace"): EditIntent[];
+/**
+ * Build, guard, dispatch: the one shape of a command that is refused whole.
+ *
+ * A structural edit has no smaller piece to fall back on - half a row cannot be deleted, and half a
+ * block of cells cannot be merged into one - so the whole transaction is built, handed to the whole
+ * guard list, and dispatched only if it comes back allowed. A character or a paragraph edit does
+ * the opposite and leaves the shut stretches out (`openStretches`).
+ *
+ * The answer is the same whether or not `dispatch` was passed. The transaction is built before
+ * either way, so asking the guard costs nothing more, and a command reporting one thing to a button
+ * and doing another would be worse than the button being wrong.
+ */
+export declare function guardedCommand(build: (state: EditorState) => Transaction | null): Command;
+/**
+ * The stretches the guards leave open, which is the one shape of a command that is trimmed.
+ *
+ * A shut stretch is left out rather than the whole edit refused: a guard turns down the whole
+ * transaction, so asking for the shut stretch as well would leave the rest of the selection
+ * unedited too. A selection the guards leave nothing of edits nothing, and the command reports that
+ * of its own accord, which is the disabled state of the control that runs it.
+ */
+export declare function openStretches<S extends {
+    from: number;
+    to: number;
+}>(state: EditorState, stretches: readonly S[], kind: "mark" | "replace"): S[];

package/dist/schema/guards.js

@@ -0,0 +1,108 @@
+// src/schema/guards.ts
+import { changesOnlyDisplayAttrs, displayOnly } from "./displayDerivation.js";
+import {
+  transactionReaches
+} from "./editGuard.js";
+import { lockGuard } from "./locks.js";
+import { bookmarkGuard, noteGuard, sectionGuard } from "./preservedGuards.js";
+import {
+  isCommentNode,
+  protectionAllows
+} from "./protection.js";
+import { editsShut, protectionOf } from "./protectionState.js";
+import { stepReaches } from "./editGuard.js";
+function transactionTouchesComments(tr) {
+  return transactionReaches(tr, isCommentNode);
+}
+function protectionAllowsTransaction(tr, rules) {
+  switch (rules.protection) {
+    case "readOnly":
+      return false;
+    case "none":
+      return !transactionTouchesComments(tr) || protectionAllows(tr.before, tr.doc, rules);
+    case "comments":
+      return transactionTouchesComments(tr) && protectionAllows(tr.before, tr.doc, rules);
+    default: {
+      const unmodelled = rules.protection;
+      return unmodelled;
+    }
+  }
+}
+var protectionGuard = {
+  name: "protection",
+  change: (tr, state) => protectionAllowsTransaction(tr, protectionOf(state)),
+  shuts: (_intent, state) => editsShut(state)
+};
+var EDIT_GUARDS = [
+  protectionGuard,
+  lockGuard,
+  bookmarkGuard,
+  noteGuard,
+  sectionGuard
+];
+function judgesSteps(guard) {
+  return guard.step !== void 0;
+}
+function lifted(guard, tr) {
+  return guard.liftedBy?.some((pass) => tr.getMeta(pass) === true) === true;
+}
+function displayOnlyTransaction(tr, state) {
+  return tr.getMeta(displayOnly) === true && tr.steps.every(
+    (step, index) => changesOnlyDisplayAttrs(step, tr.docs[index] ?? state.doc)
+  );
+}
+function transactionAllowed(tr, state) {
+  if (!tr.docChanged) return true;
+  if (displayOnlyTransaction(tr, state)) return true;
+  if (EDIT_GUARDS.some((guard) => guard.change?.(tr, state) === false)) {
+    return false;
+  }
+  return EDIT_GUARDS.filter(judgesSteps).filter((guard) => !lifted(guard, tr)).every(
+    (guard) => (
+      // Each step counts positions in the document it was built against, which `docs` holds
+      tr.steps.every(
+        (step, index) => guard.step(
+          step,
+          tr.docs[index] ?? state.doc,
+          tr.docs[index + 1] ?? tr.doc,
+          state
+        )
+      )
+    )
+  );
+}
+function editShut(state, intent) {
+  return EDIT_GUARDS.some((guard) => guard.shuts(intent, state));
+}
+function intentOver(from, to, kind) {
+  return from === to ? { kind: "insert", at: from } : { kind, from, to };
+}
+function selectionIntents(selection, kind) {
+  return selection.ranges.map(
+    (range) => intentOver(range.$from.pos, range.$to.pos, kind)
+  );
+}
+function guardedCommand(build) {
+  return (state, dispatch) => {
+    const tr = build(state);
+    if (tr === null || !transactionAllowed(tr, state)) return false;
+    dispatch?.(tr);
+    return true;
+  };
+}
+function openStretches(state, stretches, kind) {
+  return stretches.filter(
+    (stretch) => !editShut(state, intentOver(stretch.from, stretch.to, kind))
+  );
+}
+export {
+  EDIT_GUARDS,
+  editShut,
+  guardedCommand,
+  openStretches,
+  protectionAllowsTransaction,
+  selectionIntents,
+  stepReaches,
+  transactionAllowed,
+  transactionTouchesComments
+};

package/dist/schema/index.d.ts

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

package/dist/schema/index.js

@@ -1,7 +1,9 @@
 // src/schema/index.ts
+import { attrsOfClass } from "./attrRoles.js";
 import { docxSchema, isPageBreak } from "./docxSchema.js";
 import { imageNodeSpec, runMarkSpec } from "./rendering.js";
 export {
+  attrsOfClass,
   docxSchema,
   imageNodeSpec,
   isPageBreak,

package/dist/schema/locks.d.ts

@@ -1,13 +1,14 @@
 /**
- * Evaluates OOXML content and deletion locks for inline controls and whole table cells. Commands
- * query these predicates before editing; `editor/plugins/lockedContent` enforces them at runtime.
+ * Evaluates OOXML content and deletion locks for inline controls and whole table cells.
  *
- * `transactionAllowed` is the one guard, and it answers for the protection the editor runs under
- * (`./protection`) as well as for the locks, so that a command asking it asks both.
+ * `lockGuard` is what `./guards` registers all of this as, and it is the only way in: a caller
+ * asking about a lock asks the one guard list, which asks the locks along with every other rule an
+ * edit is judged by. What a lock says about a whole document or a whole selection - a question
+ * about the document rather than about an edit - is exported beside it.
  */
 import type { Mark, Node as PMNode } from "prosemirror-model";
-import { type EditorState, PluginKey, type Selection, type Transaction } from "prosemirror-state";
-import { type ProtectionState } from "./protection";
+import { PluginKey, type Selection } from "prosemirror-state";
+import type { StepGuard } from "./editGuard";
 /**
  * The pass that lets a transaction through the guard, which is how a lock can be lifted at all.
  * A plugin key is used as the name so that it cannot collide with a consumer's own metadata.
@@ -58,83 +59,22 @@ export interface ControlSpan extends StepRange {
  */
 export declare function controlSpans(block: Textblock): ControlSpan[];
 /**
- * Whether what stands at this position sits inside a cell a control shuts.
+ * Whether a lock shuts editing where this selection stands, which is what a menu that would lift a
+ * lock is built on (`editor/commands/lockCommands`).
  *
- * This is the question a paragraph edit leaves its locked paragraphs out by
- * (`editor/paragraphEdits`), and it is deliberately not `rangeTouchesLocked` over the paragraph:
- * a paragraph merely holding a locked control keeps its own alignment and indent.
- */
-export declare function insideLockedCell(doc: PMNode, pos: number): boolean;
-/**
- * Whether this stretch reaches contents a lock shuts: text inside a control that shuts its
- * contents, or what a locked cell holds, the cell itself included.
- *
- * This is the question about editing what stands there rather than about taking it away, so every
- * control the stretch meets answers with its contents clause. The lock commands and the formatting
- * commands ask it of the stretch they are about to mark, so it is exported.
- */
-export declare function rangeTouchesLocked(doc: PMNode, from: number, to: number): boolean;
-/**
- * Whether something inserted at this spot would land inside a locked control or a locked cell.
- *
- * Only a spot with the very same control on both sides is inside one. At either edge the other
- * side belongs to a different control or to none, and since the mark is not inclusive what goes
- * in there falls outside the control.
- */
-export declare function insertionInsideLocked(doc: PMNode, pos: number): boolean;
-/**
- * Whether the guard shuts editing where this selection stands.
- *
- * This is the question a command that rewrites whatever is selected has to ask before it reports
- * that it applies (`editor/insertImage`), and the one a menu offering to lift a lock is built on
- * (`editor/commands/lockCommands`). A caret is shut by standing inside a control rather than
- * against its edge, which is the same rule an insertion follows.
+ * This is a reading of the selection rather than of an edit - the lock guard answers an edit
+ * (`./guards`) - and it names the locks alone, which is what the menu says. A caret is shut by
+ * standing inside a control rather than against its edge, which is the same rule an insertion
+ * follows.
  * A control locked against deletion alone shuts nothing here: its contents stand open, so editing
  * where it stands goes through, and only taking the control away is refused.
  */
 export declare function selectionShut(selection: Selection, doc: PMNode): boolean;
 /**
- * Whether the guard would refuse putting something in place of what this selection covers, which
- * is what an image insertion does (`editor/insertImage`).
- *
- * A different question from `selectionShut`: what the selection covers whole goes away rather than
- * being edited, so the deletion clause answers for it. A control that may be taken away whole may
- * therefore be replaced, and one locked against deletion alone may not, even though editing inside
- * it would have gone through.
- */
-export declare function replacementShut(selection: Selection, doc: PMNode): boolean;
-/**
- * Whether any step of the transaction reaches a comment node: puts one in, takes one out, or
- * rewrites the one where it stands, which is how a body, a reply and a resolution change.
- *
- * Every comment lives in its three nodes, so a change that reaches none of them cannot have
- * changed a comment. That is what lets the guard settle the common transaction - typing, and
- * nothing more - over the stretch it rewrote rather than over the whole document.
- *
- * A step of a kind this does not know - one a consumer brought - is answered as reaching one,
- * since what it rewrote is not known either. The whole-document judgement then has the say, and
- * an unknown step costs a comparison rather than a hole in the guard.
- */
-export declare function transactionTouchesComments(tr: Transaction): boolean;
-/**
- * Whether the protection lets this transaction through (`./protection`).
- *
- * The whole-document judgement is reached for only when a comment is touched at all
- * (`transactionTouchesComments`). A change that touches none is a body edit: through under `none`,
- * refused under `comments`, and nothing about ownership to ask.
- */
-export declare function protectionAllowsTransaction(tr: Transaction, rules: ProtectionState): boolean;
-/**
- * Whether the guard would let this transaction through, decided and nothing else.
- *
- * The refusal the guard itself answers with carries a side effect - the composition it ends
- * (`editor/plugins/lockedContent`) - which a query about a button's state may not set off, so the
- * decision stands apart from it and every caller building an edit asks this rather than handing
- * the transaction to a state.
+ * The locks the document carries, as `./guards` registers them.
  *
- * The protection is judged before the passes and without them: a replayed edit is still an edit,
- * and a pass that lifts a lock lifts no protection. Its judgement is over the whole change rather
- * than step by step, which is what lets it tell a comment from everything else.
+ * Both passes lift it: unlocking is the one edit that may reach into a lock, and every step the
+ * history replays is the reverse of a step that passed the guard when it was made.
  */
-export declare function transactionAllowed(tr: Transaction, state: EditorState): boolean;
+export declare const lockGuard: StepGuard;
 export {};

package/dist/schema/locks.js

@@ -1,7 +1,5 @@
 // src/schema/locks.ts
-import {
-  PluginKey
-} from "prosemirror-state";
+import { PluginKey } from "prosemirror-state";
 import {
   AddMarkStep,
   AddNodeMarkStep,
@@ -12,11 +10,6 @@ import {
   ReplaceStep
 } from "prosemirror-transform";
 import { docxSchema } from "./index.js";
-import {
-  isCommentNode,
-  protectionAllows
-} from "./protection.js";
-import { protectionOf } from "./protectionState.js";
 var unlockAllowed = new PluginKey("docxEditorUnlockAllowed");
 var historyReplay = new PluginKey("docxEditorHistoryReplay");
 var OPEN = { contents: false, deletion: false };
@@ -123,18 +116,17 @@ function insertionInsideLocked(doc, pos) {
   const after = lockedMarkOf($pos.nodeAfter);
   return before !== null && after !== null && before.eq(after);
 }
+function markShut(doc, from, to) {
+  return from === to ? insertionInsideLocked(doc, from) : rangeTouchesLocked(doc, from, to);
+}
+function replaceShut(doc, from, to) {
+  return from === to ? insertionInsideLocked(doc, from) : rangeShut(doc, { from, to, takesAway: true });
+}
 function selectionShut(selection, doc) {
   return selection.ranges.some(
-    (range) => range.$from.pos === range.$to.pos ? insertionInsideLocked(doc, range.$from.pos) : rangeTouchesLocked(doc, range.$from.pos, range.$to.pos)
+    (range) => markShut(doc, range.$from.pos, range.$to.pos)
   );
 }
-function replacementShut(selection, doc) {
-  return selection.ranges.some((range) => {
-    const from = range.$from.pos;
-    const to = range.$to.pos;
-    return from === to ? insertionInsideLocked(doc, from) : rangeShut(doc, { from, to, takesAway: true });
-  });
-}
 function editedRanges(step) {
   if (step instanceof ReplaceAroundStep) {
     return [
@@ -192,71 +184,35 @@ function stepAllowed(step, doc) {
   }
   return true;
 }
-function carriesPass(tr) {
-  return tr.getMeta(unlockAllowed) === true || tr.getMeta(historyReplay) === true;
-}
-function rangeHoldsComment(doc, from, to) {
-  let found = false;
-  doc.nodesBetween(from, to, (node) => {
-    if (found) return false;
-    if (isCommentNode(node)) found = true;
-    return !found;
-  });
-  return found;
-}
-function transactionTouchesComments(tr) {
-  return tr.steps.some((step, index) => {
-    const before = tr.docs[index];
-    const after = tr.docs[index + 1] ?? tr.doc;
-    if (step instanceof AttrStep || step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep) {
-      const node = before.nodeAt(step.pos);
-      return node !== null && isCommentNode(node);
-    }
-    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep || step instanceof AddMarkStep || step instanceof RemoveMarkStep)) {
-      return true;
-    }
-    let touched = false;
-    step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
-      touched ||= rangeHoldsComment(before, oldStart, oldEnd) || rangeHoldsComment(after, newStart, newEnd);
-    });
-    return touched;
-  });
-}
-function protectionAllowsTransaction(tr, rules) {
-  switch (rules.protection) {
-    case "readOnly":
-      return false;
-    case "none":
-      return !transactionTouchesComments(tr) || protectionAllows(tr.before, tr.doc, rules);
-    case "comments":
-      return transactionTouchesComments(tr) && protectionAllows(tr.before, tr.doc, rules);
+function intentShut(doc, intent) {
+  switch (intent.kind) {
+    case "insert":
+      return insertionInsideLocked(doc, intent.at);
+    case "block":
+      return insideLockedCell(doc, intent.at);
+    case "mark":
+      return markShut(doc, intent.from, intent.to);
+    case "replace":
+      return replaceShut(doc, intent.from, intent.to);
     default: {
-      const unmodelled = rules.protection;
+      const unmodelled = intent;
       return unmodelled;
     }
   }
 }
-function transactionAllowed(tr, state) {
-  if (!tr.docChanged) return true;
-  if (!protectionAllowsTransaction(tr, protectionOf(state))) return false;
-  if (carriesPass(tr)) return true;
-  return tr.steps.every(
-    (step, index) => stepAllowed(step, tr.docs[index] ?? state.doc)
-  );
-}
+var lockGuard = {
+  name: "lock",
+  liftedBy: [unlockAllowed, historyReplay],
+  step: (step, before) => stepAllowed(step, before),
+  shuts: (intent, state) => intentShut(state.doc, intent)
+};
 export {
   carriesLock,
   controlSpans,
   historyReplay,
-  insertionInsideLocked,
-  insideLockedCell,
   isLockedCell,
+  lockGuard,
   lockedMarkOf,
-  protectionAllowsTransaction,
-  rangeTouchesLocked,
-  replacementShut,
   selectionShut,
-  transactionAllowed,
-  transactionTouchesComments,
   unlockAllowed
 };

package/dist/schema/preservedGuards.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ *
+ * 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.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type ChangeGuard, type EditGuardName } from "./editGuard";
+/** Everything about one preserved node that has to read the same after a change as before it */
+type Signature = (node: PMNode) => string;
+/**
+ * A guard that lets a change through only while it leaves the list of these nodes reading exactly
+ * as it did, which holds their number, their contents and their order at once.
+ *
+ * The comparison walks the whole document, so it is reached for only once a step of the change has
+ * touched such a node: ordinary typing costs the stretches its own steps rewrote and nothing more.
+ * It is judged over the change rather than step by step because a marker moved whole is two steps,
+ * one taking it out and one putting it back, and neither of them alone leaves the list as it was.
+ *
+ * Nothing lifts it. A pass is how an edit reaches past a lock the document put on itself, and
+ * there is no such thing to reach past here: the file simply has no way to say what a lost marker
+ * was.
+ */
+export declare function preservedNodeGuard(name: EditGuardName, holds: (node: PMNode) => boolean, signature: Signature): ChangeGuard;
+export declare const bookmarkGuard: ChangeGuard;
+export declare const noteGuard: ChangeGuard;
+/**
+ * A guard that lets a change through only while it leaves at least as many section breaks standing
+ * as it found.
+ *
+ * A paragraph-level `w:sectPr` is not content: it is where one section of the document ends, and
+ * the section carries the page size, the margins and the headers everything up to it is laid out
+ * under. Joining that paragraph into the one above it - a Backspace at its start, a selection run
+ * across its boundary - would take the whole section away with it, and nothing the editor writes
+ * puts a section back.
+ *
+ * It counts rather than compares, so splitting such a paragraph is still allowed: Enter leaves the
+ * break on the half that ends up last (`docx/cloning`), and one break stands where one stood. An
+ * edit that adds a break is no business of this guard's either.
+ *
+ * The count walks the whole document, so it is reached for only once a step has touched a
+ * paragraph that lays a break down.
+ */
+export declare const sectionGuard: ChangeGuard;
+export {};

package/dist/schema/preservedGuards.js

@@ -0,0 +1,80 @@
+// src/schema/preservedGuards.ts
+import { parseProps, propsChild } from "../ooxml/props.js";
+import {
+  rangeHolds,
+  transactionReaches
+} from "./editGuard.js";
+function signatures(doc, holds, signature) {
+  const found = [];
+  doc.descendants((node) => {
+    if (holds(node)) found.push(signature(node));
+    return true;
+  });
+  return found;
+}
+function same(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function preservedNodeGuard(name, holds, signature) {
+  const listOf = (doc) => signatures(doc, holds, signature);
+  return {
+    name,
+    change: (tr) => !transactionReaches(tr, holds) || same(listOf(tr.before), listOf(tr.doc)),
+    shuts: (intent, state) => intent.kind === "replace" && rangeHolds(state.doc, intent.from, intent.to, holds)
+  };
+}
+var BOOKMARK_XML = /<(?:[\w.-]+:)?bookmark(?:Start|End)\b/;
+function isBookmarkMarker(node) {
+  if (node.type.name === "bookmarkBlock") return true;
+  return node.type.name === "rawInline" && typeof node.attrs.xml === "string" && BOOKMARK_XML.test(node.attrs.xml);
+}
+function bookmarkSignature(node) {
+  return node.type.name === "bookmarkBlock" ? `block:${node.attrs.srcId}:${node.attrs.name}` : `inline:${node.attrs.xml}`;
+}
+var bookmarkGuard = preservedNodeGuard(
+  "bookmark",
+  isBookmarkMarker,
+  bookmarkSignature
+);
+function isNoteReference(node) {
+  return node.type.name === "noteReference";
+}
+var noteGuard = preservedNodeGuard(
+  "note",
+  isNoteReference,
+  (node) => JSON.stringify(node.attrs)
+);
+function endsASection(node) {
+  if (node.type.name !== "paragraph") return false;
+  const pPr = node.attrs.pPr;
+  if (typeof pPr !== "string") return false;
+  const props = parseProps(pPr);
+  return props !== null && propsChild(props.children, "sectPr") !== void 0;
+}
+function sectionBreaks(doc) {
+  let seen = 0;
+  doc.descendants((node) => {
+    if (endsASection(node)) seen += 1;
+    return true;
+  });
+  return seen;
+}
+var sectionGuard = {
+  name: "section",
+  change: (tr) => !transactionReaches(tr, endsASection) || sectionBreaks(tr.doc) >= sectionBreaks(tr.before),
+  shuts: (intent, state) => {
+    if (intent.kind !== "replace") return false;
+    const $from = state.doc.resolve(intent.from);
+    const $to = state.doc.resolve(intent.to);
+    if ($from.parent.type.name === "paragraph" && $from.sameParent($to)) {
+      return false;
+    }
+    return rangeHolds(state.doc, intent.from, intent.to, endsASection);
+  }
+};
+export {
+  bookmarkGuard,
+  noteGuard,
+  preservedNodeGuard,
+  sectionGuard
+};