@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.12 → 0.3.3-wrap-unwrap.14

package/dist/__tests__/playwrightHelpers.d.ts

@@ -140,9 +140,9 @@ export declare function assertReverted(finalState: EditorState, initialState: Ed
  * This helper replaces the editor document with the provided JSON,
  * clears transactions, and returns initial state.
  */
-export declare function setupDocFromJSON(page: Page, docJSON: unknown): Promise<{
+export declare function setupDocFromJSON(page: Page, docJSON: object): Promise<{
     initialState: EditorState;
-    initialDoc: unknown;
+    initialDoc: object;
 }>;
 /**
  * Assert that document fully reverted to initial state.

package/dist/features/joinOnDelete/index.js

@@ -2,6 +2,7 @@ import { Mark } from "prosemirror-model";
 import { canJoin, Transform } from "prosemirror-transform";
 import { ZWSP } from "../../constants.js";
 import { getSuggestionMarks } from "../../utils.js";
+import { guardStructureMarkAttrs } from "../wrapUnwrap/types.js";
 export function isJoinMarkAttrs(attrs) {
     if (attrs["type"] !== "join") return false;
     if (attrs["data"] == null) return false;
@@ -94,7 +95,9 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
             attrs: $endOfNode.nodeAfter.attrs,
             marks: $endOfNode.nodeAfter.marks.map((mark)=>mark.toJSON())
         };
+        const shouldSuppressJoinMark = hasStructureAddMark($endOfNode.nodeBefore) || hasStructureAddMark($endOfNode.nodeAfter);
         transform.join(mappedEndOfNode);
+        if (shouldSuppressJoinMark) return false;
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const joinStep = transform.steps[transform.steps.length - 1];
         const joinPos = joinStep.getMap().map(mappedEndOfNode);
@@ -111,6 +114,14 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
     });
     return transform;
 }
+function hasStructureAddMark(node) {
+    const { structure } = getSuggestionMarks(node.type.schema);
+    return node.marks.some((mark)=>{
+        if (mark.type !== structure) return false;
+        if (!guardStructureMarkAttrs(mark.attrs)) return false;
+        return mark.attrs.data.op.op === "add";
+    });
+}
 /**
  * Find ZWSP nodes marked as insertions and deletions with the same mark id
  * Delete them from the given range

package/dist/features/wrapUnwrap/__tests__/blockquoteStructure.playwright.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/wrapUnwrap/__tests__/splitDetection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/wrapUnwrap/buildMaterializedPaths.js

@@ -1,4 +1,5 @@
 import { getNodeId } from "./getNodeId.js";
+import { DOC_NODE_ID } from "./constants.js";
 const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -17,8 +18,8 @@ export function buildMaterializedPaths(doc) {
         const rightSibling = children[index + 1];
         const rightSiblingId = rightSibling ? getNodeId(rightSibling) : null;
         const parent = {
-            nodeId: "__doc__",
-            nodeType: "__doc__",
+            nodeId: DOC_NODE_ID,
+            nodeType: DOC_NODE_ID,
             nodeAttrs: {},
             nodeMarks: [],
             childSiblingIds: [
@@ -29,6 +30,7 @@ export function buildMaterializedPaths(doc) {
         };
         paths.set(nodeId, {
             nodeType: node.type.name,
+            node,
             chain: [
                 parent
             ]
@@ -70,6 +72,7 @@ export function buildMaterializedPaths(doc) {
         ];
         paths.set(nodeId, {
             nodeType: node.type.name,
+            node,
             chain
         });
         return true;

package/dist/features/wrapUnwrap/constants.d.ts

@@ -1,3 +1,3 @@
+export declare const DOC_NODE_ID = "__doc__";
 export declare const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
 export declare const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
-export declare const LIST_NODES: string[];

package/dist/features/wrapUnwrap/constants.js

@@ -1,7 +1,3 @@
+export const DOC_NODE_ID = "__doc__";
 export const STRUCTURE_CHANGES_ADD_MARKS = "structure-changes-add-mark-type";
 export const STRUCTURE_CHANGES_REVERT_MARKS = "structure-changes-revert-mark-type";
-export const LIST_NODES = [
-    "orderedList",
-    "bulletList",
-    "listItem"
-];

package/dist/features/wrapUnwrap/revert/revertMoveOp.js

@@ -118,5 +118,5 @@ export function findInsertionPos(node, pos, parent, child) {
         return leftSibling.pos + leftSibling.node.nodeSize;
     }
     // insert at end of node
-    return pos != null ? pos + node.nodeSize - 1 : node.nodeSize - 1;
+    return pos != null ? pos + node.nodeSize - 1 : node.content.size;
 }

package/dist/features/wrapUnwrap/structureChangesPlugin.d.ts

@@ -1,10 +1,17 @@
 import { type Schema, type Node } from "prosemirror-model";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { type SuggestionId } from "../../generateId.js";
+import { type StructuralContextPath } from "./types.js";
 import { Transform } from "prosemirror-transform";
 export declare const structureChangesKey: PluginKey<any>;
-export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId): Plugin<any>;
-export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, generateId?: (schema: Schema, doc?: Node) => SuggestionId): {
+export type SuggestStructureChangesReason = "split-derived-add";
+export interface SuggestStructureChangesResult {
     handled: boolean;
     transform: Transform;
-};
+    reason?: SuggestStructureChangesReason;
+}
+export declare function structureChangesPlugin(generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
+    experimental_trackStructures?: StructuralContextPath[];
+}): Plugin<any>;
+export declare function suggestStructureChanges(docBefore: Node, docAfter: Node, structuralContextPaths: StructuralContextPath[], generateId?: (schema: Schema, doc?: Node) => SuggestionId): SuggestStructureChangesResult;
+export declare function getRequiredStructuralContextPaths(structuralContextPaths: StructuralContextPath[] | undefined): StructuralContextPath[];

package/dist/features/wrapUnwrap/structureChangesPlugin.js

@@ -3,7 +3,7 @@ import { getSuggestionMarks } from "../../utils.js";
 import { generateNextNumberId } from "../../generateId.js";
 import { getNodeId } from "./getNodeId.js";
 import { guardStructureMarkAttrs } from "./types.js";
-import { LIST_NODES, STRUCTURE_CHANGES_ADD_MARKS } from "./constants.js";
+import { DOC_NODE_ID, STRUCTURE_CHANGES_ADD_MARKS } from "./constants.js";
 import { Transform } from "prosemirror-transform";
 import { isSuggestChangesEnabled, suggestChangesKey } from "../../plugin.js";
 import { buildMaterializedPaths } from "./buildMaterializedPaths.js";
@@ -15,12 +15,8 @@ function trace(...args) {
     console.log("[structureChanges]", ...args);
 }
 export const structureChangesKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-structure-changes");
-// const listStructure = {
-//   type: [LIST_NODE],
-//   children: [{ type: [LIST_ITEM_NODE] }],
-// };
-// const structures = [listStructure];
-export function structureChangesPlugin(generateId) {
+export function structureChangesPlugin(generateId, opts) {
+    const structuralContextPaths = getRequiredStructuralContextPaths(opts?.experimental_trackStructures);
     return new Plugin({
         key: structureChangesKey,
         appendTransaction (transactions, _oldState, newState) {
@@ -92,7 +88,7 @@ export function structureChangesPlugin(generateId) {
             trace("structureChangesPlugin", "appendTransaction", [
                 ...transactions
             ]);
-            const { transform } = suggestStructureChanges(oldDoc, newDoc, generateId);
+            const { transform } = suggestStructureChanges(oldDoc, newDoc, structuralContextPaths, generateId);
             const tr = newState.tr;
             transform.steps.forEach((step)=>{
                 tr.step(step);
@@ -108,7 +104,7 @@ function isEnabled(tr, editorState) {
     const isEnabled = isSuggestChangesEnabled(editorState) && !tr.getMeta("history$") && !tr.getMeta("collab$") && !ySyncMeta.isUndoRedoOperation && !ySyncMeta.isChangeOrigin && !("skip" in (tr.getMeta(suggestChangesKey) ?? {}));
     return isEnabled;
 }
-export function suggestStructureChanges(docBefore, docAfter, generateId) {
+export function suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId) {
     const suggestionId = generateId ? generateId(docBefore.type.schema, docBefore) : generateNextNumberId(docBefore.type.schema, docBefore);
     const pathsBefore = buildMaterializedPaths(docBefore);
     const pathsAfter = buildMaterializedPaths(docAfter);
@@ -116,17 +112,31 @@ export function suggestStructureChanges(docBefore, docAfter, generateId) {
         pathsBefore: Object.fromEntries(pathsBefore.entries()),
         pathsAfter: Object.fromEntries(pathsAfter.entries())
     });
-    const ops = getOps(pathsBefore, pathsAfter);
+    const { ops, reason } = getOps(pathsBefore, pathsAfter, structuralContextPaths);
     trace("suggestStructureChanges", "ops", {
-        ops: Object.fromEntries(ops.entries())
+        ops: Object.fromEntries(ops.entries()),
+        reason
     });
     const transform = new Transform(docAfter);
+    if (reason) {
+        return {
+            handled: false,
+            transform,
+            reason
+        };
+    }
     addMarks(ops, transform, suggestionId);
     return {
         handled: ops.size > 0,
         transform
     };
 }
+export function getRequiredStructuralContextPaths(structuralContextPaths) {
+    if (!structuralContextPaths?.length) {
+        throw new Error("experimental_trackStructures must be provided when structure tracking is enabled");
+    }
+    return structuralContextPaths;
+}
 function addMarks(ops, tr, suggestionId) {
     const perfAddMarks = performance.now();
     const { structure } = getSuggestionMarks(tr.doc.type.schema);
@@ -172,20 +182,22 @@ function hasStructureAddMark(node) {
         return mark.attrs.data.op.op === "add";
     });
 }
-function getOps(beforePaths, afterPaths) {
+function getOps(beforePaths, afterPaths, structuralContextPaths) {
     const ops = new Map();
+    const contextNodeTypes = getStructuralContextNodeTypes(structuralContextPaths);
     // first take care of nodes that exist in both
     for (const [id, beforePath] of beforePaths){
-        if (LIST_NODES.includes(beforePath.nodeType)) continue;
+        if (contextNodeTypes.has(beforePath.nodeType)) continue;
         const afterPath = afterPaths.get(id);
         // node was removed - do nothing
         if (afterPath == null) continue;
+        if (contextNodeTypes.has(afterPath.nodeType)) continue;
         const sameChain = sameParentChain(beforePath.chain, afterPath.chain);
         // node did not move anywhere - do nothing
         if (sameChain) continue;
-        const hasList = beforePath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType)) || afterPath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType));
-        // node is outside lists
-        if (!hasList) continue;
+        const hasStructuralContext = chainHasStructuralContext(beforePath.chain, structuralContextPaths) || chainHasStructuralContext(afterPath.chain, structuralContextPaths);
+        // node is outside configured structural contexts
+        if (!hasStructuralContext) continue;
         const op = {
             op: "move",
             from: beforePath.chain,
@@ -196,17 +208,87 @@ function getOps(beforePaths, afterPaths) {
     // now take care of nodes that exist only in afterPaths
     // (we don't care about nodes that exist only in beforePaths - they were deleted)
     for (const [id, afterPath] of afterPaths){
-        if (LIST_NODES.includes(afterPath.nodeType)) continue;
+        if (contextNodeTypes.has(afterPath.nodeType)) continue;
         // ignore nodes that also exist in beforePaths - they are already handled
         if (beforePaths.has(id)) continue;
-        const hasList = afterPath.chain.some((parent)=>LIST_NODES.includes(parent.nodeType));
-        // node is outside lists
-        if (!hasList) continue;
+        const hasStructuralContext = chainHasStructuralContext(afterPath.chain, structuralContextPaths);
+        // node is outside configured structural contexts
+        if (!hasStructuralContext) continue;
+        // detect block split - if detected, bail out, and let the main plugin handle it
+        if (isSplitDerivedAdd(id, beforePaths, afterPaths, contextNodeTypes)) {
+            return {
+                ops: new Map(),
+                reason: "split-derived-add"
+            };
+        }
         // node was added
         const op = {
             op: "add"
         };
         ops.set(id, op);
     }
-    return ops;
+    return {
+        ops
+    };
+}
+function getStructuralContextNodeTypes(structuralContextPaths) {
+    return new Set(structuralContextPaths.flat());
+}
+function chainHasStructuralContext(chain, structuralContextPaths) {
+    const topDownChain = [
+        ...chain
+    ].reverse().filter((parent)=>parent.nodeType !== DOC_NODE_ID).map((parent)=>parent.nodeType);
+    return structuralContextPaths.some((path)=>containsContiguousPath(topDownChain, path));
+}
+// does a chain like: __doc__->nodeTypeA->nodeTypeB->nodeTypeC->nodeTypeD
+// contain a structural context path (a "sub chain") like nodeTypeB->nodeTypeC ?
+function containsContiguousPath(chainNodeTypes, structuralContextPath) {
+    if (structuralContextPath.length > chainNodeTypes.length) return false;
+    for(let start = 0; start <= chainNodeTypes.length - structuralContextPath.length; start++){
+        const matches = structuralContextPath.every((nodeType, index)=>chainNodeTypes[start + index] === nodeType);
+        if (matches) return true;
+    }
+    return false;
+}
+// detect block split - try to look at the node above, concatenate two text contents,
+// and see if it combines into a single node in the old document
+function isSplitDerivedAdd(newNodeId, beforePaths, afterPaths, contextNodeTypes) {
+    const newNode = afterPaths.get(newNodeId)?.node;
+    if (!newNode || newNode.textContent === "") return false;
+    if (matchesSplitDerivedPair(newNodeId, newNode.textContent, beforePaths, afterPaths)) {
+        return true;
+    }
+    const afterPath = afterPaths.get(newNodeId);
+    if (!afterPath) return false;
+    for (const parent of afterPath.chain){
+        if (parent.nodeType === DOC_NODE_ID) continue;
+        if (!contextNodeTypes.has(parent.nodeType)) continue;
+        const parentNode = afterPaths.get(parent.nodeId)?.node;
+        if (!parentNode || parentNode.textContent === "") continue;
+        if (matchesSplitDerivedPair(parent.nodeId, parentNode.textContent, beforePaths, afterPaths)) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesSplitDerivedPair(rightNodeId, rightText, beforePaths, afterPaths) {
+    const rightPath = afterPaths.get(rightNodeId);
+    const previousSiblingId = rightPath?.chain[0]?.childSiblingIds[0];
+    if (!previousSiblingId) return false;
+    const previousBefore = beforePaths.has(previousSiblingId) ? beforePaths.get(previousSiblingId)?.node : null;
+    const previousAfter = afterPaths.has(previousSiblingId) ? afterPaths.get(previousSiblingId)?.node : null;
+    if (!previousBefore || !previousAfter) return false;
+    if (hasStructureAddMarkInSubtree(previousBefore)) return false;
+    return previousBefore.textContent === previousAfter.textContent + rightText;
+}
+function hasStructureAddMarkInSubtree(node) {
+    if (hasStructureAddMark(node)) return true;
+    let found = false;
+    node.descendants((descendant)=>{
+        if (descendant.isText) return false;
+        if (!hasStructureAddMark(descendant)) return true;
+        found = true;
+        return false;
+    });
+    return found;
 }

package/dist/features/wrapUnwrap/types.d.ts

@@ -1,5 +1,6 @@
-import { type Attrs } from "prosemirror-model";
+import { type Attrs, type Node } from "prosemirror-model";
 import { type SuggestionId } from "../../generateId.js";
+import { DOC_NODE_ID } from "./constants.js";
 interface NodeParent {
     nodeId: string;
     nodeType: string;
@@ -14,9 +15,10 @@ export interface StructureMarkAttrs {
         op: Op;
     };
 }
+export type StructuralContextPath = readonly [string, ...string[]];
 export interface DocParent extends Omit<NodeParent, "nodeId"> {
-    nodeId: "__doc__";
-    nodeType: "__doc__";
+    nodeId: typeof DOC_NODE_ID;
+    nodeType: typeof DOC_NODE_ID;
 }
 export type Parent = NodeParent | DocParent;
 export interface MoveOp {
@@ -31,6 +33,7 @@ export type Op = MoveOp | AddOp;
 export type MaterializedPaths = Map<string, {
     chain: Parent[];
     nodeType: string;
+    node: Node;
 }>;
 export declare function guardDocParent(parent: Parent | undefined): parent is DocParent;
 export declare function guardStructureMarkAttrs(attrs: Attrs): attrs is StructureMarkAttrs;

package/dist/features/wrapUnwrap/types.js

@@ -1,5 +1,6 @@
+import { DOC_NODE_ID } from "./constants.js";
 export function guardDocParent(parent) {
-    return parent != null && parent.nodeId === "__doc__" && parent.nodeType === "__doc__";
+    return parent != null && parent.nodeId === DOC_NODE_ID && parent.nodeType === DOC_NODE_ID;
 }
 export function guardStructureMarkAttrs(attrs) {
     if (!("data" in attrs)) return false;

package/dist/index.d.ts

@@ -4,5 +4,5 @@ export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled, } from "./p
 export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSuggestChanges.js";
 export { ensureSelection as experimental_ensureSelection, ensureSelectionKey as experimental_ensureSelectionKey, isEnsureSelectionEnabled as experimental_isEnsureSelectionEnabled, } from "./ensureSelectionPlugin.js";
 export { guardStructureMarkAttrs } from "./features/wrapUnwrap/types.js";
-export type { Op as StructureOp, StructureMarkAttrs, } from "./features/wrapUnwrap/types.js";
+export type { Op as StructureOp, StructureMarkAttrs, StructuralContextPath, } from "./features/wrapUnwrap/types.js";
 export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/testing/e2eTestSchema.d.ts

@@ -1,2 +1,2 @@
 import { Schema } from "prosemirror-model";
-export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "orderedList" | "bulletList" | "listItem" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong">;
+export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong">;

package/dist/testing/testBuilders.d.ts

@@ -1,6 +1,6 @@
 import { Schema, type Node } from "prosemirror-model";
 import { type MarkBuilder, type NodeBuilder } from "prosemirror-test-builder";
-export declare const schema: Schema<"blockquote" | "text" | "orderedList" | "bulletList" | "listItem" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
+export declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
 export declare const testBuilders: { [NodeTypeName in keyof (typeof schema)["nodes"]]: NodeBuilder; } & { [MarkTypeName in keyof (typeof schema)["marks"]]: MarkBuilder; } & {
     schema: typeof schema;
 };

package/dist/withSuggestChanges.d.ts

@@ -3,6 +3,7 @@ import { type EditorState, type Transaction } from "prosemirror-state";
 import { type Transform } from "prosemirror-transform";
 import { type EditorView } from "prosemirror-view";
 import { type SuggestionId } from "./generateId.js";
+import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
 /**
  * Given a standard transaction from ProseMirror, produce
  * a new transaction that tracks the changes from the original,
@@ -27,5 +28,6 @@ export declare function transformToSuggestionTransaction(originalTransaction: Tr
  */
 export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId, opts?: {
     experimental_trackStructureChanges?: boolean;
+    experimental_trackStructures?: StructuralContextPath[];
     experimental_ensureUniqueNodeIds?: (transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform;
 }): EditorView["dispatch"];

package/dist/withSuggestChanges.js

@@ -10,7 +10,7 @@ import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
 import { generateNextNumberId } from "./generateId.js";
 import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
-import { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
 const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -121,13 +121,15 @@ function getStepHandler(step) {
         if (isEnabled) {
             let structureChangesResult = null;
             const docBefore = transaction.docs[0];
-            if (transaction.docChanged && docBefore && opts?.experimental_trackStructureChanges && typeof opts.experimental_ensureUniqueNodeIds === "function") {
+            const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
+            const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
+            if (transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
                 trace("trying to track structure changes first...");
                 // after a transaction, some nodes may not yet have unique ids (they were just added, and the unique id plugin has not yet run)
                 // this hook allows to "post-process" the transaction and add the missing ids
                 // basically it allows to run the core logic of the unique ids plugin earlier
                 const perfUid = performance.now();
-                const uniqueNodeIdsTransform = opts.experimental_ensureUniqueNodeIds([
+                const uniqueNodeIdsTransform = ensureUniqueNodeIds([
                     transaction
                 ], docBefore, transaction.doc);
                 trace("perf", "structure", "ensureUniqueNodsIds took", Number((performance.now() - perfUid).toFixed(2)), "ms");
@@ -137,7 +139,7 @@ function getStepHandler(step) {
                 // if handled, then ignore the main plugin
                 // otherwise use the main plugin
                 const perfStructure = performance.now();
-                structureChangesResult = suggestStructureChanges(docBefore, docAfter, generateId);
+                structureChangesResult = suggestStructureChanges(docBefore, docAfter, structuralContextPaths, generateId);
                 trace("perf", "structure", "suggestStructureChanges took", Number((performance.now() - perfStructure).toFixed(2)), "ms");
                 trace("structure changes transform completed", structureChangesResult.transform);
                 if (structureChangesResult.handled) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-marker/prosemirror-suggest-changes",
-  "version": "0.3.3-wrap-unwrap.12",
+  "version": "0.3.3-wrap-unwrap.14",
   "license": "MIT",
   "type": "module",
   "module": "dist/index.js",