@portone/docx-editor 0.2.0 → 0.2.1

package/dist/schema/docxSchema.js

@@ -13,6 +13,12 @@ import {
   toTableFormat,
   toTableWidth
 } from "../model/format.js";
+import {
+  ANY_ELEMENT,
+  ATTRIBUTES,
+  acceptRawXml,
+  ELEMENT
+} from "../ooxml/fragment.js";
 import { toImageExtent, toImageSrc } from "../ooxml/image.js";
 import { editorAttributes, editorClassNames } from "../styles/classNames.js";
 import { DEFAULT_FONT_FALLBACKS } from "../styles/fontStack.js";
@@ -25,6 +31,9 @@ import {
 } from "../styles/inlineStyle.js";
 import { imageNodeSpec, runMarkSpec } from "./rendering.js";
 import { imageNodeSpec as imageNodeSpec2, runMarkSpec as runMarkSpec2 } from "./rendering.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
 function text(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -64,6 +73,29 @@ function srcIdOf(dom) {
   const parsed = Number.parseInt(raw, 10);
   return Number.isNaN(parsed) ? null : parsed;
 }
+function repliesHoldTheirXml(value) {
+  if (!Array.isArray(value)) return true;
+  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;
+  });
+}
+var SDT_PREFIX = {
+  kind: "openTag",
+  name: "sdt",
+  closedBy: "<w:sdtContent/></w:sdt>",
+  head: ["sdtPr", "sdtEndPr"]
+};
+var LINK_PREFIX = {
+  kind: "openTag",
+  name: "hyperlink",
+  closedBy: "</w:hyperlink>",
+  head: []
+};
+function rawXml(dom, attribute, shape) {
+  return acceptRawXml(shape, dom.getAttribute(attribute));
+}
 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"];
@@ -84,7 +116,7 @@ var docxSchema = new Schema({
   nodes: {
     doc: { content: "block+" },
     paragraph: {
-      group: "block",
+      group: "block modelled",
       content: "inline*",
       // Leading and trailing whitespace carries meaning in docx text, so it is not stripped when the DOM is read back
       whitespace: "pre",
@@ -125,15 +157,22 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `p.${editorClassNames.paragraph}`,
-          getAttrs: (dom) => ({
-            srcId: srcIdOf(dom),
-            pAttrs: dom.getAttribute("data-pattrs"),
-            pPr: dom.getAttribute("data-ppr"),
-            format: toParagraphFormat(parseJson(dom.getAttribute("data-fmt"))),
-            styleRun: toRunFormat(
-              parseJson(dom.getAttribute("data-style-run"))
-            )
-          })
+          getAttrs: (dom) => {
+            const pAttrs = rawXml(dom, "data-pattrs", ATTRIBUTES);
+            const pPr = rawXml(dom, "data-ppr", ELEMENT("pPr"));
+            if (pAttrs === false || pPr === false) return false;
+            return {
+              srcId: srcIdOf(dom),
+              pAttrs,
+              pPr,
+              format: toParagraphFormat(
+                parseJson(dom.getAttribute("data-fmt"))
+              ),
+              styleRun: toRunFormat(
+                parseJson(dom.getAttribute("data-style-run"))
+              )
+            };
+          }
         }
       ]
     },
@@ -142,7 +181,7 @@ var docxSchema = new Schema({
      * edited table is written back the new XML is built from those two.
      */
     table: {
-      group: "block",
+      group: "block modelled",
       content: "tableRow+",
       tableRole: "table",
       isolating: true,
@@ -195,20 +234,25 @@ var docxSchema = new Schema({
         { tag: "colgroup", ignore: true },
         {
           tag: `table.${editorClassNames.table}`,
-          getAttrs: (dom) => ({
-            srcId: srcIdOf(dom),
-            tblAttrs: dom.getAttribute("data-tblattrs"),
-            tblPr: dom.getAttribute("data-tblpr"),
-            tblW: toTableWidth(parseJson(dom.getAttribute("data-tblw"))),
-            gridCols: parseNumberList(dom.getAttribute("data-cols")),
-            format: toTableFormat(parseJson(dom.getAttribute("data-fmt"))),
-            styleInside: toInsideBorders(
-              parseJson(dom.getAttribute("data-style-inside"))
-            ),
-            styleCellMargins: toCellMargins(
-              parseJson(dom.getAttribute("data-style-margins"))
-            )
-          })
+          getAttrs: (dom) => {
+            const tblAttrs = rawXml(dom, "data-tblattrs", ATTRIBUTES);
+            const tblPr = rawXml(dom, "data-tblpr", ELEMENT("tblPr"));
+            if (tblAttrs === false || tblPr === false) return false;
+            return {
+              srcId: srcIdOf(dom),
+              tblAttrs,
+              tblPr,
+              tblW: toTableWidth(parseJson(dom.getAttribute("data-tblw"))),
+              gridCols: parseNumberList(dom.getAttribute("data-cols")),
+              format: toTableFormat(parseJson(dom.getAttribute("data-fmt"))),
+              styleInside: toInsideBorders(
+                parseJson(dom.getAttribute("data-style-inside"))
+              ),
+              styleCellMargins: toCellMargins(
+                parseJson(dom.getAttribute("data-style-margins"))
+              )
+            };
+          }
         }
       ]
     },
@@ -242,12 +286,20 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: "tr",
-          getAttrs: (dom) => ({
-            trAttrs: dom.getAttribute("data-trattrs"),
-            tblPrEx: dom.getAttribute("data-tblprex"),
-            trPr: dom.getAttribute("data-trpr"),
-            format: toRowFormat(parseJson(dom.getAttribute("data-fmt")))
-          })
+          getAttrs: (dom) => {
+            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) {
+              return false;
+            }
+            return {
+              trAttrs,
+              tblPrEx,
+              trPr,
+              format: toRowFormat(parseJson(dom.getAttribute("data-fmt")))
+            };
+          }
         }
       ]
     },
@@ -309,20 +361,28 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: "td",
-          getAttrs: (dom) => ({
-            colspan: parseInt10(dom.getAttribute("colspan"), 1),
-            rowspan: parseInt10(dom.getAttribute("rowspan"), 1),
-            colwidth: toColWidth(
-              parseNumberList(dom.getAttribute("data-colwidth"))
-            ),
-            tcAttrs: dom.getAttribute("data-tcattrs"),
-            tcPr: dom.getAttribute("data-tcpr"),
-            tcW: toTableWidth(parseJson(dom.getAttribute("data-tcw"))),
-            format: toCellFormat(parseJson(dom.getAttribute("data-fmt"))),
-            sdtPrefix: dom.getAttribute("data-sdt-prefix"),
-            sdtContentsLocked: dom.getAttribute("data-sdt-contents-locked") === "1",
-            sdtDeletionLocked: dom.getAttribute("data-sdt-deletion-locked") === "1"
-          })
+          getAttrs: (dom) => {
+            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) {
+              return false;
+            }
+            return {
+              colspan: parseInt10(dom.getAttribute("colspan"), 1),
+              rowspan: parseInt10(dom.getAttribute("rowspan"), 1),
+              colwidth: toColWidth(
+                parseNumberList(dom.getAttribute("data-colwidth"))
+              ),
+              tcAttrs,
+              tcPr,
+              tcW: toTableWidth(parseJson(dom.getAttribute("data-tcw"))),
+              format: toCellFormat(parseJson(dom.getAttribute("data-fmt"))),
+              sdtPrefix,
+              sdtContentsLocked: dom.getAttribute("data-sdt-contents-locked") === "1",
+              sdtDeletionLocked: dom.getAttribute("data-sdt-deletion-locked") === "1"
+            };
+          }
         }
       ]
     },
@@ -333,7 +393,7 @@ var docxSchema = new Schema({
      * XML around with it.
      */
     rawBlock: {
-      group: "block",
+      group: "block preserved",
       atom: true,
       selectable: false,
       attrs: {
@@ -355,16 +415,17 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `div.${editorClassNames.rawXmlBlock}`,
-          getAttrs: (dom) => ({
-            xml: dom.getAttribute("data-xml"),
-            name: dom.getAttribute("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",
+      group: "block preserved",
       atom: true,
       selectable: false,
       attrs: {
@@ -396,7 +457,7 @@ var docxSchema = new Schema({
     },
     /** A bookmark range marker that occurs directly under w:body rather than inside a paragraph */
     bookmarkBlock: {
-      group: "block",
+      group: "block preserved",
       atom: true,
       isolating: true,
       selectable: false,
@@ -442,7 +503,10 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: "br",
-          getAttrs: (dom) => ({ brAttrs: dom.getAttribute("data-battrs") })
+          getAttrs: (dom) => {
+            const brAttrs = rawXml(dom, "data-battrs", ATTRIBUTES);
+            return brAttrs === false ? false : { brAttrs };
+          }
         }
       ]
     },
@@ -475,12 +539,16 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `img.${editorClassNames.image}`,
-          getAttrs: (dom) => ({
-            src: toImageSrc(dom.getAttribute("src")),
-            extent: toImageExtent(parseJson(dom.getAttribute("data-extent"))),
-            alt: dom.getAttribute("alt") || null,
-            xml: dom.getAttribute("data-xml")
-          })
+          getAttrs: (dom) => {
+            const xml = rawXml(dom, "data-xml", ELEMENT("drawing"));
+            if (xml === false) return false;
+            return {
+              src: toImageSrc(dom.getAttribute("src")),
+              extent: toImageExtent(parseJson(dom.getAttribute("data-extent"))),
+              alt: dom.getAttribute("alt") || null,
+              xml
+            };
+          }
         }
       ]
     },
@@ -508,10 +576,11 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.commentMarker}[data-comment-marker="start"]`,
-          getAttrs: (dom) => ({
-            id: dom.getAttribute("data-comment-id"),
-            xml: dom.getAttribute("data-xml")
-          })
+          getAttrs: (dom) => {
+            const xml = rawXml(dom, "data-xml", ELEMENT("commentRangeStart"));
+            if (xml === false) return false;
+            return { id: dom.getAttribute("data-comment-id"), xml };
+          }
         }
       ]
     },
@@ -539,10 +608,11 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.commentMarker}[data-comment-marker="end"]`,
-          getAttrs: (dom) => ({
-            id: dom.getAttribute("data-comment-id"),
-            xml: dom.getAttribute("data-xml")
-          })
+          getAttrs: (dom) => {
+            const xml = rawXml(dom, "data-xml", ELEMENT("commentRangeEnd"));
+            if (xml === false) return false;
+            return { id: dom.getAttribute("data-comment-id"), xml };
+          }
         }
       ]
     },
@@ -596,22 +666,43 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.commentMarker}[data-comment-marker="reference"]`,
-          getAttrs: (dom) => ({
-            id: dom.getAttribute("data-comment-id"),
-            referenceXml: dom.getAttribute("data-reference-xml"),
-            author: dom.getAttribute("data-comment-author"),
-            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: dom.getAttribute("data-comment-xml"),
-            imported: dom.getAttribute("data-comment-imported") === "1",
-            paraId: dom.getAttribute("data-comment-para-id"),
-            resolved: dom.getAttribute("data-comment-resolved") === "1",
-            extensionXml: dom.getAttribute("data-comment-extension-xml"),
-            threadImported: dom.getAttribute("data-comment-thread-imported") === "1",
-            replies: parseJson(dom.getAttribute("data-comment-replies")) ?? []
-          })
+          getAttrs: (dom) => {
+            const referenceXml = rawXml(
+              dom,
+              "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)) {
+              return false;
+            }
+            return {
+              id: dom.getAttribute("data-comment-id"),
+              referenceXml,
+              author: dom.getAttribute("data-comment-author"),
+              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,
+              threadImported: dom.getAttribute("data-comment-thread-imported") === "1",
+              replies
+            };
+          }
         }
       ]
     },
@@ -652,14 +743,22 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `sup.${editorClassNames.noteReference}`,
-          getAttrs: (dom) => ({
-            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: dom.getAttribute("data-reference-xml")
-          })
+          getAttrs: (dom) => {
+            const referenceXml = rawXml(
+              dom,
+              "data-reference-xml",
+              ELEMENT("footnoteReference", "endnoteReference")
+            );
+            if (referenceXml === false) return false;
+            return {
+              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
+            };
+          }
         }
       ]
     },
@@ -682,7 +781,10 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.rawInline}`,
-          getAttrs: (dom) => ({ xml: dom.getAttribute("data-xml") })
+          getAttrs: (dom) => {
+            const xml = rawXml(dom, "data-xml", ANY_ELEMENT);
+            return xml === false ? false : { xml };
+          }
         }
       ]
     },
@@ -737,8 +839,8 @@ var docxSchema = new Schema({
         {
           tag: `span.${editorClassNames.sdt}`,
           getAttrs: (dom) => {
-            const prefix = dom.getAttribute("data-sdt-prefix");
-            if (prefix === null) return false;
+            const prefix = rawXml(dom, "data-sdt-prefix", SDT_PREFIX);
+            if (prefix === null || prefix === false) return false;
             return {
               sdtPrefix: prefix,
               sdtKey: parseInt10(dom.getAttribute("data-sdt-key"), 0),
@@ -800,8 +902,9 @@ var docxSchema = new Schema({
         {
           tag: `span.${editorClassNames.link}`,
           getAttrs: (dom) => {
-            const prefix = dom.getAttribute("data-link-prefix");
+            const prefix = rawXml(dom, "data-link-prefix", LINK_PREFIX);
             const href = dom.getAttribute("data-href");
+            if (prefix === false) return false;
             if (prefix === null && href === null) return false;
             return {
               linkPrefix: prefix,
@@ -829,11 +932,16 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.run}`,
-          getAttrs: (dom) => ({
-            rAttrs: dom.getAttribute("data-rattrs"),
-            rPr: dom.getAttribute("data-rpr"),
-            format: toRunFormat(parseJson(dom.getAttribute("data-fmt")))
-          })
+          getAttrs: (dom) => {
+            const rAttrs = rawXml(dom, "data-rattrs", ATTRIBUTES);
+            const rPr = rawXml(dom, "data-rpr", ELEMENT("rPr"));
+            if (rAttrs === false || rPr === false) return false;
+            return {
+              rAttrs,
+              rPr,
+              format: toRunFormat(parseJson(dom.getAttribute("data-fmt")))
+            };
+          }
         }
       ]
     },
@@ -854,7 +962,10 @@ var docxSchema = new Schema({
       parseDOM: [
         {
           tag: `span.${editorClassNames.tab}`,
-          getAttrs: (dom) => ({ tabAttrs: dom.getAttribute("data-tattrs") })
+          getAttrs: (dom) => {
+            const tabAttrs = rawXml(dom, "data-tattrs", ATTRIBUTES);
+            return tabAttrs === false ? false : { tabAttrs };
+          }
         }
       ]
     }

package/dist/schema/editGuard.d.ts

@@ -0,0 +1,99 @@
+/**
+ * What a guard is, and the reach primitives one is written with.
+ *
+ * This module names no guard and imports none, so a module that writes a guard (`./locks`,
+ * `./preservedGuards`) and the list that registers them (`./guards`) can both read it without
+ * pointing at each other. A guard reading its shape off `./guards` instead would put a cycle
+ * there: `EDIT_GUARDS` is built while `./guards` is evaluated, so whenever the guard's own module
+ * happened to be evaluated first the list would be built out of bindings that had not been
+ * assigned yet, and every edit would then be judged against a list holding holes.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { EditorState, PluginKey, Transaction } from "prosemirror-state";
+import { type Step } from "prosemirror-transform";
+/**
+ * What a command means to do, in as much of it as a guard can answer for before anything is built.
+ *
+ * The positions are the ones the command would work over, counted in the document as it stands.
+ */
+export type EditIntent = 
+/** Something goes in at this spot, and nothing there goes away */
+{
+    kind: "insert";
+    at: number;
+}
+/** What stands in this stretch is marked where it stands */
+ | {
+    kind: "mark";
+    from: number;
+    to: number;
+}
+/** What stands in this stretch goes away, whatever takes its place */
+ | {
+    kind: "replace";
+    from: number;
+    to: number;
+}
+/** The block at this spot is rewritten around its content, an alignment or an indent */
+ | {
+    kind: "block";
+    at: number;
+};
+/**
+ * How a guard is named in the honesty test and in a refusal read by a developer.
+ *
+ * The names are written out because the registry is a closed list: `lockHonesty` checks each one
+ * 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";
+/** What every guard answers, whichever of the two judgements it is written as */
+interface GuardCommon {
+    readonly name: EditGuardName;
+    /** Whether the intent is shut where it stands, which is what a command asks before it builds */
+    shuts(intent: EditIntent, state: EditorState): boolean;
+}
+/**
+ * A guard that judges one step at a time, over the document that step was built against.
+ *
+ * Only this form takes a pass. A pass lifts one guard's reading of a step, and a rule that has to
+ * see both documents of the change at once has no single step for it to let through.
+ */
+export interface StepGuard extends GuardCommon {
+    step(step: Step, before: PMNode, after: PMNode, state: EditorState): boolean;
+    /** The passes that lift this guard's step judgement. Omitted: none does */
+    liftedBy?: readonly PluginKey<boolean>[];
+    change?: never;
+}
+/** A guard that needs both documents of the whole change at once */
+export interface ChangeGuard extends GuardCommon {
+    change(tr: Transaction, state: EditorState): boolean;
+    step?: never;
+    liftedBy?: never;
+}
+/**
+ * One rule an edit is judged by: whether it would leave the document in a state the file cannot be
+ * written back from.
+ *
+ * A guard is one judgement or the other, and answers `shuts` either way, so there is no writing
+ * one that judges nothing and no hanging a pass on a judgement no pass can lift.
+ */
+export type EditGuard = StepGuard | ChangeGuard;
+/** Whether this stretch of the document holds a node the question answers for */
+export declare function rangeHolds(doc: PMNode, from: number, to: number, holds: (node: PMNode) => boolean): boolean;
+/**
+ * Whether the step reaches a node the question answers for: puts one in, takes one out, or
+ * rewrites the one where it stands.
+ *
+ * A rule about such nodes cannot have been broken by a change that reaches none of them, which is
+ * what lets a guard settle the common transaction - typing, and nothing more - over the stretches
+ * its own steps 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 stepReaches(step: Step, before: PMNode, after: PMNode, holds: (node: PMNode) => boolean): boolean;
+/** Whether any step of the transaction reaches a node the question answers for */
+export declare function transactionReaches(tr: Transaction, holds: (node: PMNode) => boolean): boolean;
+export {};

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
+};