@magic-marker/prosemirror-suggest-changes 0.4.0 → 0.4.1-wrap-unwrap.1

package/dist/features/wrapUnwrap/uniqueNodeIdsPlugin.js

@@ -0,0 +1,106 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { getNodeId } from "./getNodeId.js";
+import { Transform } from "prosemirror-transform";
+// unique ids plugin
+// https://discuss.prosemirror.net/t/how-to-avoid-copying-attributes-to-new-paragraph/4568/2
+// (also checks and fix duplicates that inevitably appear)
+export const uniqueNodeIdsPluginKey = new PluginKey("@handlewithcare/prosemirror-suggest-changes-unique-node-ids");
+export const UNIQUE_NODE_IDS_PLUGIN_META = "unique-node-ids-plugin";
+const TRACE_ENABLED = false;
+function trace(...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!TRACE_ENABLED) return;
+    console.log("[uniqueNodeIdsPlugin]", ...args);
+}
+export function uniqueNodeIdsPlugin({ attributeName, generateID }) {
+    return new Plugin({
+        key: uniqueNodeIdsPluginKey,
+        appendTransaction (transactions, oldState, newState) {
+            trace("appendTransaction");
+            const pluginState = uniqueNodeIdsPluginKey.getState(newState);
+            // do nothing if doc hasn't changed (but make sure it runs initially)
+            const docChanged = transactions.some((transaction)=>transaction.docChanged);
+            if (!docChanged && pluginState?.completedInitialRun) {
+                trace("doc not changed, skipping", [
+                    ...transactions
+                ]);
+                return;
+            }
+            trace("appendTransaction", [
+                ...transactions
+            ]);
+            const tr = newState.tr;
+            const transform = ensureUniqueNodeIds(transactions, oldState.doc, newState.doc, {
+                attributeName,
+                generateID
+            });
+            transform.steps.forEach((step)=>{
+                tr.step(step);
+            });
+            trace("tr steps", tr.steps);
+            if (!tr.steps.length) return;
+            tr.setMeta(uniqueNodeIdsPluginKey, UNIQUE_NODE_IDS_PLUGIN_META);
+            return tr;
+        },
+        state: {
+            init () {
+                return {
+                    completedInitialRun: false
+                };
+            },
+            apply (tr, value) {
+                const meta = tr.getMeta(uniqueNodeIdsPluginKey);
+                if (meta === UNIQUE_NODE_IDS_PLUGIN_META && !value.completedInitialRun) {
+                    return {
+                        completedInitialRun: true
+                    };
+                }
+                return value;
+            }
+        }
+    });
+}
+export function ensureUniqueNodeIds(_transactions, _oldDoc, newDoc, options) {
+    const tr = new Transform(newDoc);
+    const nodeIds = new Set();
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupCollapsed("ensureUniqueNodeIds");
+    tr.doc.descendants((node, pos)=>{
+        if (node.isText) return false;
+        const nodeId = getNodeId(node);
+        // nodeId is set and is not duplicated
+        if (nodeId != null && !nodeIds.has(nodeId)) {
+            nodeIds.add(nodeId);
+            return true;
+        }
+        // nodeId is set and it is duplicated
+        if (nodeId != null && nodeIds.has(nodeId)) {
+            const id = options.generateID();
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                [options.attributeName]: id
+            }, node.marks);
+            trace("fixed duplicate id", id, "for node", node.type.name, "at pos", pos, {
+                was: nodeId,
+                is: id
+            });
+            return true;
+        }
+        // node id is not set
+        if (nodeId == null) {
+            const id = options.generateID();
+            nodeIds.add(id);
+            tr.setNodeMarkup(pos, node.type, {
+                ...node.attrs,
+                [options.attributeName]: id
+            }, node.marks);
+            trace("set unique id", id, "for node", node.type.name, "at pos", pos);
+            return true;
+        }
+        return true;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (TRACE_ENABLED) console.groupEnd();
+    return tr;
+}

package/dist/generateId.js

@@ -1,4 +1,6 @@
 import { getSuggestionMarks } from "./utils.js";
+import { isJoinMark } from "./features/joinOnDelete/types.js";
+import { normalizeJoinNodesMetadata } from "./features/joinOnDelete/normalizeJoinNodesMetadata.js";
 export const suggestionIdValidate = "number|string";
 export function parseSuggestionId(id) {
     const parsed = parseInt(id, 10);
@@ -8,14 +10,39 @@ 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);
-        if (mark) {
-            suggestionId = Math.max(suggestionId, mark.attrs["id"]);
+        // find max suggestion id across all suggestion marks and across all suggestion marks that are serialized into metadata of the join marks
+        const marks = node.marks.filter((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification || mark.type === structure);
+        const markIds = marks.map((mark)=>mark.attrs["id"]);
+        // collect suggestion ids of marks that are serialized into join marks metadata
+        const joinMarks = marks.filter((mark)=>isJoinMark(mark));
+        const joinMetadataMarkIds = [];
+        joinMarks.forEach((mark)=>{
+            const joinMetadata = normalizeJoinNodesMetadata(mark.attrs);
+            if (!joinMetadata) return;
+            joinMetadata.leftNodes.forEach((node)=>{
+                node.marks.forEach((mark)=>{
+                    if (!mark.attrs["id"]) return;
+                    joinMetadataMarkIds.push(mark.attrs["id"]);
+                });
+            });
+            joinMetadata.rightNodes.forEach((node)=>{
+                node.marks.forEach((mark)=>{
+                    if (!mark.attrs["id"]) return;
+                    joinMetadataMarkIds.push(mark.attrs["id"]);
+                });
+            });
+        });
+        const allMarkIds = [
+            ...markIds,
+            ...joinMetadataMarkIds
+        ];
+        if (allMarkIds.length > 0) {
+            suggestionId = Math.max(suggestionId, ...allMarkIds);
             return false;
         }
         return true;

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-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";
+export { withSuggestChanges, transformToSuggestionTransaction, suggestStructureChanges as experimental_suggestStructureChanges, } 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, StructuralContextPath, } from "./features/wrapUnwrap/types.js";
+export { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/index.js

@@ -1,5 +1,7 @@
-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";
+export { withSuggestChanges, transformToSuggestionTransaction, suggestStructureChanges as experimental_suggestStructureChanges } 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 { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

package/dist/listInputRules.d.ts

@@ -0,0 +1,2 @@
+import { type NodeType } from "prosemirror-model";
+export declare function listInputRules(bulletListNodeType: NodeType, orderedListNodeType: NodeType): import("prosemirror-inputrules").InputRule[];

package/dist/listInputRules.js

@@ -0,0 +1,14 @@
+import { wrappingInputRule } from "./wrappingInputRule.js";
+import { ZWSP } from "./constants.js";
+export function listInputRules(bulletListNodeType, orderedListNodeType) {
+    const bulletListInputRule = wrappingInputRule(// ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([-+*]) one of -+* , \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    new RegExp(`^[${ZWSP}\\s]*([-+*])\\s$`, "u"), bulletListNodeType);
+    // ^ string start, [${ZWSP}\\s]* zero or more ZWSP or whitespace, ([0-9]+\\.) digit followed by dot, \\s one whitespace, $ end of string
+    // "u" flag treats \u as unicode code points instead of literal "u"
+    const orderedListInputRule = wrappingInputRule(new RegExp(`^[${ZWSP}\\s]*([0-9]+\\.)\\s$`, "u"), orderedListNodeType);
+    return [
+        bulletListInputRule,
+        orderedListInputRule
+    ];
+}

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/replaceStep.d.ts

@@ -1,6 +1,6 @@
 import { type Node } from "prosemirror-model";
 import { type EditorState, type Transaction } from "prosemirror-state";
-import { type Step, type ReplaceStep } from "prosemirror-transform";
+import { type ReplaceStep, type Step } from "prosemirror-transform";
 import { type SuggestionId } from "./generateId.js";
 /**
  * Transform a replace step into its equivalent tracked steps.

package/dist/replaceStep.js

@@ -5,6 +5,7 @@ import { getSuggestionMarks } from "./utils.js";
 import { joinBlocks } from "./features/joinBlocks/index.js";
 import { collapseZWSPNodes, findJoinMark, joinNodesAndMarkJoinPoints, removeZWSPDeletions } from "./features/joinOnDelete/index.js";
 import { adjustForStartToStartTextblockDeletion } from "./features/startToStartTextblockDeletion/index.js";
+// import { rebaseStep } from "./rebaseStep.js";
 /**
  * Transform a replace step into its equivalent tracked steps.
  *

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/e2eTestSchema.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "prosemirror-model";
+export declare function createSchema(deletionMarksVisibility?: "hidden" | "visible"): Schema<"blockquote" | "text" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem" | "hardBreak", "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";
-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" | "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;
 };
@@ -8,4 +8,3 @@ export type TaggedNode = Node & {
     flat: Node;
     tag: Record<string, number>;
 };
-export {};

package/dist/transformToSuggestionTransaction.d.ts

@@ -0,0 +1,22 @@
+import { type Node, type Schema } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type SuggestionId } from "./generateId.js";
+interface PreserveTransactionDataOptions {
+    selection?: "mapFromOriginalTransaction" | "currentDocument" | false;
+    preserveScroll?: boolean;
+    preserveStoredMarks?: boolean;
+    preserveMeta?: boolean;
+}
+export declare function preserveTransactionData(transaction: Transaction, originalTransaction: Transaction, options?: PreserveTransactionDataOptions): void;
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */
+export declare function transformToSuggestionTransaction(originalTransaction: Transaction, state: EditorState, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transaction;
+export {};

package/dist/transformToSuggestionTransaction.js

@@ -0,0 +1,101 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
+import { trackAddMarkStep } from "./addMarkStep.js";
+import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
+import { trackAttrStep } from "./attrStep.js";
+import { generateNextNumberId } from "./generateId.js";
+import { suggestRemoveMarkStep } from "./removeMarkStep.js";
+import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
+import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
+import { suggestReplaceStep } from "./replaceStep.js";
+import { getSuggestionMarks } from "./utils.js";
+function getStepHandler(step) {
+    if (step instanceof ReplaceStep) {
+        return suggestReplaceStep;
+    }
+    if (step instanceof ReplaceAroundStep) {
+        return suggestReplaceAroundStep;
+    }
+    if (step instanceof AddMarkStep) {
+        return trackAddMarkStep;
+    }
+    if (step instanceof RemoveMarkStep) {
+        return suggestRemoveMarkStep;
+    }
+    if (step instanceof AddNodeMarkStep) {
+        return trackAddNodeMarkStep;
+    }
+    if (step instanceof RemoveNodeMarkStep) {
+        return suggestRemoveNodeMarkStep;
+    }
+    if (step instanceof AttrStep) {
+        return trackAttrStep;
+    }
+    // Default handler — simply rebase the step onto the
+    // tracked transaction and apply it.
+    return (trackedTransaction, _state, _doc, step, prevSteps)=>{
+        const reset = prevSteps.slice().reverse().reduce((acc, step)=>acc?.map(step.getMap().invert()) ?? null, step);
+        const rebased = trackedTransaction.steps.reduce((acc, step)=>acc?.map(step.getMap()) ?? null, reset);
+        if (rebased) {
+            trackedTransaction.step(rebased);
+        }
+        return false;
+    };
+}
+export function preserveTransactionData(transaction, originalTransaction, options = {}) {
+    const { selection = "mapFromOriginalTransaction", preserveScroll = true, preserveStoredMarks = true, preserveMeta = true } = options;
+    if (selection && originalTransaction.selectionSet && !transaction.selectionSet) {
+        if (selection === "currentDocument") {
+            transaction.setSelection(originalTransaction.selection.map(transaction.doc, new Mapping()));
+        } else {
+            const originalBaseDoc = originalTransaction.docs[0];
+            const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
+            transaction.setSelection(base.map(transaction.doc, transaction.mapping));
+        }
+    }
+    if (preserveScroll && originalTransaction.scrolledIntoView) {
+        transaction.scrollIntoView();
+    }
+    if (preserveStoredMarks && originalTransaction.storedMarksSet) {
+        transaction.setStoredMarks(originalTransaction.storedMarks);
+    }
+    if (preserveMeta) {
+        // @ts-expect-error Preserve original transaction meta exactly as-is
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        transaction.meta = originalTransaction.meta;
+    }
+}
+/**
+ * Given a standard transaction from ProseMirror, produce
+ * a new transaction that tracks the changes from the original,
+ * rather than applying them.
+ *
+ * For each type of step, we implement custom behavior to prevent
+ * deletions from being removed from the document, instead adding
+ * deletion marks, and ensuring that all insertions have insertion
+ * marks.
+ */ export function transformToSuggestionTransaction(originalTransaction, state, generateId) {
+    getSuggestionMarks(state.schema);
+    let suggestionId = generateId ? generateId(state.schema, originalTransaction.docs[0]) : generateNextNumberId(state.schema, originalTransaction.docs[0]);
+    // Create a new transaction from scratch. The original transaction
+    // is going to be dropped in favor of this one.
+    const trackedTransaction = state.tr;
+    for(let i = 0; i < originalTransaction.steps.length; i++){
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const step = originalTransaction.steps[i];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const doc = originalTransaction.docs[i];
+        const stepTracker = getStepHandler(step);
+        if (stepTracker(trackedTransaction, state, doc, step, originalTransaction.steps.slice(0, i), suggestionId) && i < originalTransaction.steps.length - 1) {
+            // If the suggestionId was used by one of the step handlers,
+            // increment it so that it's not reused.
+            if (generateId) {
+                suggestionId = generateId(state.schema, trackedTransaction.doc);
+            } else if (typeof suggestionId === "number") {
+                suggestionId = suggestionId + 1;
+            }
+        }
+        continue;
+    }
+    preserveTransactionData(trackedTransaction, originalTransaction);
+    return trackedTransaction;
+}

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/dist/withSuggestChanges.d.ts

@@ -1,18 +1,11 @@
-import { type Schema, type Node } from "prosemirror-model";
-import { type EditorState, type Transaction } from "prosemirror-state";
+import { type Node, type Schema } from "prosemirror-model";
+import { type Transaction } from "prosemirror-state";
+import { type Transform } from "prosemirror-transform";
 import { type EditorView } from "prosemirror-view";
 import { type SuggestionId } from "./generateId.js";
-/**
- * Given a standard transaction from ProseMirror, produce
- * a new transaction that tracks the changes from the original,
- * rather than applying them.
- *
- * For each type of step, we implement custom behavior to prevent
- * deletions from being removed from the document, instead adding
- * deletion marks, and ensuring that all insertions have insertion
- * marks.
- */
-export declare function transformToSuggestionTransaction(originalTransaction: Transaction, state: EditorState, generateId?: (schema: Schema, doc?: Node) => SuggestionId): Transaction;
+import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
+export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
  * function with `withSuggestChanges`, or pass no arguments to use the default
@@ -24,4 +17,8 @@ export declare function transformToSuggestionTransaction(originalTransaction: Tr
  * applying them, e.g. by marking a range with the deletion mark rather
  * than removing it from the document.
  */
-export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId): EditorView["dispatch"];
+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"];