@magic-marker/prosemirror-suggest-changes 0.3.1 → 0.3.3-wrap-unwrap.0

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

@@ -0,0 +1,44 @@
+import { type Transaction, type Command } from "prosemirror-state";
+import { type SuggestionId } from "../../generateId.js";
+import { type Node, type Mark } from "prosemirror-model";
+import { type Transform } from "prosemirror-transform";
+export declare function isStructureSuggestion(suggestionId: SuggestionId, tr: Transaction): boolean;
+export declare function revertAllStructureSuggestions(doc: Node, tr: Transaction): void;
+export declare function revertStructureSuggestion(suggestionId: SuggestionId): Command;
+export declare function applyStructureSuggestion(suggestionId: SuggestionId): Command;
+export declare function revertStructureSuggestions(suggestionIds: SuggestionId[]): Command;
+export declare function applyStructureMarkGroup(group: {
+    type: "replaceAround";
+    markFrom: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+    markTo: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+    markGapFrom: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+    markGapTo: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+} | {
+    type: "replace";
+    markFrom: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+    markTo: {
+        pos: number;
+        node: Node;
+        mark: Mark;
+    };
+}, tr: Transform): void;

package/dist/features/wrapUnwrap/revertStructureSuggestion.js

@@ -0,0 +1,374 @@
+import { suggestChangesKey } from "../../plugin.js";
+import { getSuggestionMarks } from "../../utils.js";
+import { Slice } from "prosemirror-model";
+import { ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
+export function isStructureSuggestion(suggestionId, tr) {
+    try {
+        findStructureMarkGroupBySuggestionId(suggestionId, tr);
+        return true;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        return false;
+    }
+}
+export function revertAllStructureSuggestions(doc, tr) {
+    const { structure } = getSuggestionMarks(doc.type.schema);
+    // find structure mark in the doc
+    // if found, revert it, produce a new doc
+    // find next structure mark in the new doc
+    // easier than going nodesBetween on the original doc, and then mapping the position, figuring out if the node is present in the new doc or was deleted
+    const findStructureMark = (doc)=>{
+        let structureMark = null;
+        doc.nodesBetween(0, doc.content.size, (node)=>{
+            structureMark = structureMark ?? structure.isInSet(node.marks) ?? null;
+            return structureMark === null;
+        });
+        return structureMark;
+    };
+    let curDoc = doc;
+    let structureMark = findStructureMark(doc);
+    while(structureMark !== null){
+        const suggestionId = structureMark.attrs["id"];
+        performStructureRevert(suggestionId, tr);
+        curDoc = tr.doc;
+        structureMark = findStructureMark(curDoc);
+    }
+}
+export function revertStructureSuggestion(suggestionId) {
+    return (state, dispatch)=>{
+        const tr = state.tr;
+        performStructureRevert(suggestionId, tr);
+        if (!tr.steps.length) return false;
+        tr.setMeta(suggestChangesKey, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+export function applyStructureSuggestion(suggestionId) {
+    return (state, dispatch)=>{
+        const tr = state.tr;
+        performStructureRevert(suggestionId, tr, "apply");
+        if (!tr.steps.length) return false;
+        tr.setMeta(suggestChangesKey, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+export function revertStructureSuggestions(suggestionIds) {
+    return (state, dispatch)=>{
+        const tr = state.tr;
+        suggestionIds.forEach((suggestionId)=>{
+            performStructureRevert(suggestionId, tr);
+        });
+        if (!tr.steps.length) return false;
+        tr.setMeta(suggestChangesKey, {
+            skip: true
+        });
+        dispatch?.(tr);
+        return true;
+    };
+}
+function performStructureRevert(suggestionId, tr, direction = "revert") {
+    console.groupCollapsed(// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    `performStructureRevert, suggestionId = ${suggestionId}`);
+    const { structure } = getSuggestionMarks(tr.doc.type.schema);
+    // find main suggestion from and to
+    const { markFrom, markTo, markGapFrom, markGapTo } = findStructureMarkGroupBySuggestionId(suggestionId, tr);
+    console.log("found main suggestion", {
+        markFrom,
+        markTo,
+        markGapFrom,
+        markGapTo,
+        suggestionId
+    });
+    let from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
+    let to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
+    console.log("main suggestion positions", {
+        from,
+        to
+    });
+    if (from == null || to == null) {
+        throw new Error(`Could not find all positions for suggestion`);
+    }
+    [from, to] = from > to ? [
+        to,
+        from
+    ] : [
+        from,
+        to
+    ];
+    // find all other structure suggestions within from and to interval of the main suggestion
+    const structureMarkGroups = new Set();
+    structureMarkGroups.add(suggestionId);
+    let gapFrom = null;
+    let gapTo = null;
+    if (markGapFrom != null) {
+        gapFrom = getPosFromMark(markGapFrom.mark, markGapFrom.pos, markGapFrom.node);
+        gapTo = getPosFromMark(markGapTo.mark, markGapTo.pos, markGapTo.node);
+        if (gapFrom != null && gapTo != null) {
+            [gapFrom, gapTo] = gapFrom > gapTo ? [
+                gapTo,
+                gapFrom
+            ] : [
+                gapFrom,
+                gapTo
+            ];
+        }
+    }
+    tr.doc.nodesBetween(from, to, (node, pos)=>{
+        node.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            const markData = mark.attrs["data"];
+            if (!markData) return;
+            const id = mark.attrs["id"];
+            if (id <= suggestionId) return;
+            let startsInGap = false;
+            let endsInGap = false;
+            if (gapFrom != null && gapTo != null) {
+                startsInGap = gapFrom <= pos && pos <= gapTo;
+                endsInGap = gapFrom <= pos + node.nodeSize && pos + node.nodeSize <= gapTo;
+            }
+            // check if mark starts and ends in gap - skip mark if true
+            // for ReplaceStep marks startsInGap and endsInGap is always false
+            if (startsInGap && endsInGap) {
+                console.log("ignored mark - starts and ends in gap", {
+                    startsInGap,
+                    endsInGap,
+                    markId: id,
+                    markData,
+                    node,
+                    pos
+                });
+                return;
+            }
+            let startsInRange = false;
+            let endsInRange = false;
+            if (gapFrom != null && gapTo != null) {
+                // for ReplaceAround marks "startsInRange" means starts in [from, gapFrom] or [gapTo, to] ranges
+                // same for endsInRange
+                startsInRange = from <= pos && pos <= gapFrom || gapTo <= pos && pos <= to;
+                endsInRange = from <= pos + node.nodeSize && pos + node.nodeSize <= gapFrom || gapTo <= pos + node.nodeSize && pos + node.nodeSize <= to;
+            } else {
+                // for ReplaceStep marks "startsInRange" means starts in [from, to] range
+                // same for endsInRange
+                startsInRange = from <= pos && pos <= to;
+                endsInRange = from <= pos + node.nodeSize && pos + node.nodeSize <= to;
+            }
+            if (!startsInRange && !endsInRange) {
+                console.log("ignored mark - does not start or end in range", {
+                    startsInRange,
+                    endsInRange,
+                    markId: id,
+                    markData,
+                    node,
+                    pos
+                });
+                return;
+            }
+            console.log("found nested structure mark", {
+                mark,
+                markId: id,
+                markData,
+                startsInGap,
+                endsInGap,
+                startsInRange,
+                endsInRange,
+                node,
+                pos,
+                mainMark: {
+                    markFrom,
+                    markTo,
+                    markGapFrom,
+                    markGapTo
+                }
+            });
+            structureMarkGroups.add(id);
+        });
+        return true;
+    });
+    // revert structure mark groups in decreasing order of their ids
+    const markIds = Array.from(structureMarkGroups.values()).sort((a, b)=>Number(b) - Number(a));
+    markIds.forEach((id)=>{
+        const group = findStructureMarkGroupBySuggestionId(id, tr);
+        if (direction === "apply") {
+            applyStructureMarkGroup(group, tr);
+        } else {
+            revertStructureMarkGroup(group, tr);
+        }
+    });
+    console.groupEnd();
+}
+function getPosFromMark(mark, pos, node) {
+    const markData = mark.attrs["data"];
+    if (!markData) return null;
+    if (markData.position === "start") {
+        return pos;
+    }
+    if (markData.position === "end") {
+        return pos + node.nodeSize;
+    }
+    if (markData.position === "innerStart") {
+        return pos + 1;
+    }
+    if (markData.position === "innerEnd") {
+        return pos + node.nodeSize - 1;
+    }
+    return null;
+}
+export function applyStructureMarkGroup(group, tr) {
+    console.groupCollapsed("apply structure group, id = ", group.markFrom.mark.attrs["id"]);
+    console.log({
+        group
+    });
+    if (group.type === "replace") {
+        const { markFrom, markTo } = group;
+        tr.removeNodeMark(markFrom.pos, markFrom.mark);
+        tr.removeNodeMark(markTo.pos, markTo.mark);
+        console.groupEnd();
+        return;
+    }
+    const { markFrom, markTo, markGapFrom, markGapTo } = group;
+    tr.removeNodeMark(markFrom.pos, markFrom.mark);
+    tr.removeNodeMark(markTo.pos, markTo.mark);
+    tr.removeNodeMark(markGapFrom.pos, markGapFrom.mark);
+    tr.removeNodeMark(markGapTo.pos, markGapTo.mark);
+    console.groupEnd();
+}
+function revertStructureMarkGroup(group, tr) {
+    console.groupCollapsed("revert structure group, id = ", group.markFrom.mark.attrs["id"]);
+    console.log({
+        group
+    });
+    if (group.type === "replace") {
+        const { markFrom, markTo } = group;
+        // extract positions from, to, gapFrom and gapTo from marks
+        // the positions are either the mark's start, or the mark's end
+        const from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
+        const to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
+        if (from === null || to === null) {
+            throw new Error(`Could not find all positions for suggestion`);
+        }
+        // extract the rest of the data required to reconstruct the step: slice, and structure
+        // any of those 2 marks can be used for that, this data is identical in all of them
+        const mark = markFrom.mark;
+        const markData = mark.attrs["data"];
+        if (!markData) {
+            throw new Error(`Missing mark data for suggestion`);
+        }
+        const slice = markData.slice ? Slice.fromJSON(tr.doc.type.schema, markData.slice) : Slice.empty;
+        const isStepStructural = markData.structure ?? false;
+        // reconstruct the step
+        // this is the inverse step of the step that created this change
+        const step = new ReplaceStep(from, to, slice, isStepStructural);
+        console.log({
+            step
+        });
+        tr.removeNodeMark(markFrom.pos, markFrom.mark);
+        tr.removeNodeMark(markTo.pos, markTo.mark);
+        tr.step(step);
+        console.groupEnd();
+        return;
+    }
+    const { markFrom, markTo, markGapFrom, markGapTo } = group;
+    // extract positions from, to, gapFrom and gapTo from marks
+    // the positions are either the mark's start, or the mark's end
+    const from = getPosFromMark(markFrom.mark, markFrom.pos, markFrom.node);
+    const to = getPosFromMark(markTo.mark, markTo.pos, markTo.node);
+    const gapFrom = getPosFromMark(markGapFrom.mark, markGapFrom.pos, markGapFrom.node);
+    const gapTo = getPosFromMark(markGapTo.mark, markGapTo.pos, markGapTo.node);
+    if (from === null || to === null || gapFrom === null || gapTo === null) {
+        throw new Error(`Could not find all positions for suggestion`);
+    }
+    // extract the rest of the data required to reconstruct the step: insert, slice, and structure
+    // any of those 4 marks can be used for that, this data is identical in all of them
+    const mark = markGapFrom.mark;
+    const markData = mark.attrs["data"];
+    if (markData?.insert == null) {
+        throw new Error(`Missing insert for suggestion`);
+    }
+    const slice = markData.slice ? Slice.fromJSON(tr.doc.type.schema, markData.slice) : Slice.empty;
+    const insert = markData.insert;
+    const isStepStructural = markData.structure ?? false;
+    // reconstruct the step
+    // this is the inverse step of the step that created this change
+    const step = new ReplaceAroundStep(from, to, gapFrom, gapTo, slice, insert, isStepStructural);
+    console.log({
+        step
+    });
+    tr.removeNodeMark(markFrom.pos, markFrom.mark);
+    tr.removeNodeMark(markTo.pos, markTo.mark);
+    tr.removeNodeMark(markGapFrom.pos, markGapFrom.mark);
+    tr.removeNodeMark(markGapTo.pos, markGapTo.mark);
+    tr.step(step);
+    console.groupEnd();
+}
+function findStructureMarkGroupBySuggestionId(suggestionId, tr) {
+    const { structure } = getSuggestionMarks(tr.doc.type.schema);
+    let markFrom = null;
+    let markTo = null;
+    let markGapFrom = null;
+    let markGapTo = null;
+    // using suggestionId, find 4 marks: from, to, gapFrom and gapTo
+    tr.doc.nodesBetween(0, tr.doc.content.size, (node, pos)=>{
+        node.marks.forEach((mark)=>{
+            if (mark.type !== structure) return;
+            if (mark.attrs["id"] !== suggestionId) return;
+            const markData = mark.attrs["data"];
+            if (!markData) return;
+            if (markData.value === "from") {
+                markFrom = {
+                    pos,
+                    node,
+                    mark
+                };
+            }
+            if (markData.value === "to") {
+                markTo = {
+                    pos,
+                    node,
+                    mark
+                };
+            }
+            if (markData.value === "gapFrom") {
+                markGapFrom = {
+                    pos,
+                    node,
+                    mark
+                };
+            }
+            if (markData.value === "gapTo") {
+                markGapTo = {
+                    pos,
+                    node,
+                    mark
+                };
+            }
+        });
+        return markFrom == null || markTo == null || markGapFrom == null || markGapTo == null;
+    });
+    if (markFrom == null || markTo == null) {
+        throw new Error(`Could not find all marks for suggestion id ${suggestionId}`);
+    }
+    const type = markFrom.mark.attrs["data"]?.type;
+    if (type === "replace") {
+        return {
+            type: "replace",
+            markFrom,
+            markTo
+        };
+    }
+    if (markGapFrom == null || markGapTo == null) {
+        throw new Error(`Could not find all gap marks for replace around suggestion id ${suggestionId}`);
+    }
+    return {
+        type: "replaceAround",
+        markFrom,
+        markTo,
+        markGapFrom,
+        markGapTo
+    };
+}

package/dist/generateId.js

@@ -8,12 +8,12 @@ export function parseSuggestionId(id) {
     return parsed;
 }
 export function generateNextNumberId(schema, doc) {
-    const { deletion, insertion, modification } = getSuggestionMarks(schema);
+    const { deletion, insertion, modification, structure } = getSuggestionMarks(schema);
     // Find the highest change id in the document so far,
     // and use that as the starting point for new changes
     let suggestionId = 0;
     doc?.descendants((node)=>{
-        const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification);
+        const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification || mark.type === structure);
         if (mark) {
             suggestionId = Math.max(suggestionId, mark.attrs["id"]);
             return false;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, structure, } from "./schema.js";
 export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges, } from "./commands.js";
 export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled, } from "./plugin.js";
 export { withSuggestChanges, transformToSuggestionTransaction, } from "./withSuggestChanges.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, structure } from "./schema.js";
 export { selectSuggestion, revertSuggestion, revertSuggestions, applySuggestion, applySuggestions, enableSuggestChanges, disableSuggestChanges, toggleSuggestChanges } from "./commands.js";
 export { suggestChanges, suggestChangesKey, isSuggestChangesEnabled } from "./plugin.js";
 export { withSuggestChanges, transformToSuggestionTransaction } from "./withSuggestChanges.js";

package/dist/rebaseStep.d.ts

@@ -0,0 +1,9 @@
+import { type Step } from "prosemirror-transform";
+/**
+ * Rebase a step onto a new lineage of steps
+ *
+ * @param step The step to rebase
+ * @param back The old steps to undo, in the order they were originally applied
+ * @param forth The new steps to map through
+ */
+export declare function rebaseStep(step: Step, back: Step[], forth: Step[]): Step | null;

package/dist/rebaseStep.js

@@ -0,0 +1,11 @@
+/**
+ * Rebase a step onto a new lineage of steps
+ *
+ * @param step The step to rebase
+ * @param back The old steps to undo, in the order they were originally applied
+ * @param forth The new steps to map through
+ */ export function rebaseStep(step, back, forth) {
+    const reset = back.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
+    const rebased = forth.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
+    return rebased;
+}

package/dist/replaceAroundStep.js

@@ -6,6 +6,7 @@ import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
 import { suggestReplaceStep } from "./replaceStep.js";
 import { getSuggestionMarks } from "./utils.js";
 import { applySuggestionsToRange } from "./commands.js";
+import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.js";
 /**
  * This detects and handles changes from `setNodeMarkup` so that these are tracked as a modification
  * instead of a deletion + insertion
@@ -80,7 +81,11 @@ import { applySuggestionsToRange } from "./commands.js";
  * equivalent replace step will be generated, and then processed via
  * trackReplaceStep().
  */ export function suggestReplaceAroundStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
-    const handled = suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId);
+    let handled = handleStructureStep(trackedTransaction, step, prevSteps, suggestionId);
+    if (handled) {
+        return true;
+    }
+    handled = suggestSetNodeMarkup(trackedTransaction, state, doc, step, prevSteps, suggestionId);
     if (handled) {
         return true;
     }

package/dist/replaceStep.js

@@ -4,6 +4,7 @@ import { rebasePos } from "./rebasePos.js";
 import { getSuggestionMarks } from "./utils.js";
 import { joinBlocks } from "./features/joinBlocks/index.js";
 import { collapseZWSPNodes, findJoinMark, joinNodesAndMarkJoinPoints, removeZWSPDeletions } from "./features/joinOnDelete/index.js";
+import { handleStructureStep } from "./features/wrapUnwrap/handleStructureStep.js";
 /**
  * Transform a replace step into its equivalent tracked steps.
  *
@@ -34,6 +35,10 @@ import { collapseZWSPNodes, findJoinMark, joinNodesAndMarkJoinPoints, removeZWSP
  * will be joined and given the same ids. Any no-longer-necessary
  * zero-width spaces will be removed.
  */ export function suggestReplaceStep(trackedTransaction, state, doc, step, prevSteps, suggestionId) {
+    const handled = handleStructureStep(trackedTransaction, step, prevSteps, suggestionId);
+    if (handled) {
+        return true;
+    }
     const { deletion, insertion } = getSuggestionMarks(state.schema);
     // Check for insertion and deletion marks directly
     // adjacent to this step's boundaries. If they exist,

package/dist/schema.d.ts

@@ -3,10 +3,11 @@ export declare const deletion: MarkSpec;
 export declare const hiddenDeletion: MarkSpec;
 export declare const insertion: MarkSpec;
 export declare const modification: MarkSpec;
+export declare const structure: MarkSpec;
 /**
  * Add the deletion, insertion, and modification marks to
  * the provided MarkSpec map.
  */
 export declare function addSuggestionMarks<Marks extends string>(marks: Record<Marks, MarkSpec>, opts?: {
     experimental_deletions?: "hidden" | "visible";
-}): Record<Marks | "deletion" | "insertion" | "modification", MarkSpec>;
+}): Record<Marks | "deletion" | "insertion" | "modification" | "structure", MarkSpec>;

package/dist/schema.js

@@ -166,6 +166,41 @@ export const modification = {
         }
     ]
 };
+export const structure = {
+    inclusive: false,
+    excludes: "deletion insertion modification",
+    attrs: {
+        id: {
+            validate: suggestionIdValidate
+        },
+        data: {
+            default: null
+        }
+    },
+    toDOM (mark) {
+        return [
+            "div",
+            {
+                "data-type": "structure",
+                "data-id": JSON.stringify(mark.attrs["id"]),
+                "data-data": JSON.stringify(mark.attrs["data"])
+            },
+            0
+        ];
+    },
+    parseDOM: [
+        {
+            tag: "div[data-type='structure']",
+            getAttrs (node) {
+                if (!node.dataset["id"]) return false;
+                return {
+                    id: JSON.parse(node.dataset["id"]),
+                    data: JSON.parse(node.dataset["data"] ?? "null")
+                };
+            }
+        }
+    ]
+};
 /**
  * Add the deletion, insertion, and modification marks to
  * the provided MarkSpec map.
@@ -174,6 +209,7 @@ export const modification = {
         ...marks,
         deletion: opts?.experimental_deletions === "hidden" ? hiddenDeletion : deletion,
         insertion,
-        modification
+        modification,
+        structure
     };
 }

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";
-declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "image" | "orderedList" | "bulletList" | "listItem" | "horizontal_rule" | "heading" | "code_block" | "hard_break", "insertion" | "deletion" | "modification" | "code" | "em" | "link" | "strong" | "difficulty">;
+export declare const schema: Schema<"blockquote" | "text" | "doc" | "paragraph" | "bulletList" | "listItem" | "orderedList" | "image" | "horizontal_rule" | "heading" | "code_block" | "hard_break", "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;
 };
@@ -8,4 +8,3 @@ export type TaggedNode = Node & {
     flat: Node;
     tag: Record<string, number>;
 };
-export {};

package/dist/utils.d.ts

@@ -3,6 +3,7 @@ export interface SuggestionMarks {
     insertion: MarkType;
     deletion: MarkType;
     modification: MarkType;
+    structure: MarkType;
 }
 /**
  * Get the suggestion mark types from a schema, with proper error handling.

package/dist/utils.js

@@ -2,7 +2,7 @@
  * Get the suggestion mark types from a schema, with proper error handling.
  * Throws an error if any of the required marks are not found.
  */ export function getSuggestionMarks(schema) {
-    const { insertion, deletion, modification } = schema.marks;
+    const { insertion, deletion, modification, structure } = schema.marks;
     if (!insertion) {
         throw new Error("Failed to find insertion mark in schema. Did you forget to add it?");
     }
@@ -12,9 +12,13 @@
     if (!modification) {
         throw new Error("Failed to find modification mark in schema. Did you forget to add it?");
     }
+    if (!structure) {
+        throw new Error("Failed to find structure mark in schema. Did you forget to add it?");
+    }
     return {
         insertion,
         deletion,
-        modification
+        modification,
+        structure
     };
 }

package/package.json

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