@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.30 → 0.4.0

package/dist/features/joinOnDelete/index.js

@@ -2,104 +2,41 @@ import { Mark } from "prosemirror-model";
 import { canJoin, Transform } from "prosemirror-transform";
 import { ZWSP } from "../../constants.js";
 import { getSuggestionMarks } from "../../utils.js";
-import { areEquivalentStructureMarks } from "../wrapUnwrap/areEquivalentStructureMarks.js";
-import { guardStructureMarkAttrs } from "../wrapUnwrap/types.js";
-import { MAX_BLOCK_JOIN_DEPTH, normalizeJoinNodesMetadata } from "./normalizeJoinNodesMetadata.js";
-import { isJoinMark } from "./types.js";
-function serializeJoinNode(node) {
-    return {
-        type: node.type.name,
-        attrs: node.attrs,
-        marks: node.marks.map((mark)=>mark.toJSON())
-    };
-}
-function marksFromJSON(schema, markData) {
-    return markData.map((markData)=>Mark.fromJSON(schema, markData));
-}
-// when we revert a block join deletion mark, we restore nodes on both sides of the mark using leftNodes rightNodes metadata
-// but existing left and right nodes may have structure marks that we need to preserve
-function mergeSerializedMarksWithCurrentStructureMarks(tr, pos, serializedMarks) {
-    const currentNode = tr.doc.nodeAt(pos);
-    if (!currentNode) return serializedMarks;
-    const { structure } = getSuggestionMarks(tr.doc.type.schema);
-    const mergedMarks = [
-        ...serializedMarks
-    ];
-    for (const currentMark of currentNode.marks){
-        if (currentMark.type !== structure) continue;
-        const alreadyIncluded = mergedMarks.some((mark)=>mark.type === structure && areEquivalentStructureMarks(mark, currentMark));
-        if (!alreadyIncluded) {
-            mergedMarks.push(currentMark);
-        }
-    }
-    return mergedMarks;
-}
-function restoreNodeMarkup(tr, pos, node) {
-    const nodeType = tr.doc.type.schema.nodes[node.type];
-    if (!nodeType) return false;
-    const marks = mergeSerializedMarksWithCurrentStructureMarks(tr, pos, marksFromJSON(tr.doc.type.schema, node.marks));
-    tr.setNodeMarkup(pos, nodeType, node.attrs, marks);
+export function isJoinMarkAttrs(attrs) {
+    if (attrs["type"] !== "join") return false;
+    if (attrs["data"] == null) return false;
+    const data = attrs["data"];
+    if (data.leftNode == null || data.rightNode == null) return false;
+    if (typeof data.leftNode.type !== "string" || typeof data.rightNode.type !== "string") return false;
+    if (typeof data.leftNode.attrs !== "object" || typeof data.rightNode.attrs !== "object") return false;
+    if (!Array.isArray(data.leftNode.marks) || !Array.isArray(data.rightNode.marks)) return false;
     return true;
 }
-// collect structure suggestion IDs that will be re-introduced into the document after the join is reverted
-function getRestoredStructureSuggestionIds(joinNodes, schema) {
-    const { structure } = getSuggestionMarks(schema);
-    const restoredStructureSuggestionIds = new Set();
-    for (const node of [
-        ...joinNodes.leftNodes,
-        ...joinNodes.rightNodes
-    ]){
-        const marks = marksFromJSON(schema, node.marks);
-        for (const mark of marks){
-            if (mark.type !== structure) continue;
-            if (!guardStructureMarkAttrs(mark.attrs)) continue;
-            restoredStructureSuggestionIds.add(mark.attrs.id);
-        }
-    }
-    return restoredStructureSuggestionIds;
-}
 export function maybeRevertJoinMark(tr, from, to, node, markType) {
     const mark = node.marks.find((mark)=>mark.type === markType);
-    if (!mark || !isJoinMark(mark) || node.text !== ZWSP) return false;
-    const joinNodes = normalizeJoinNodesMetadata(mark.attrs);
-    if (!joinNodes) return false;
-    for (const node of [
-        ...joinNodes.leftNodes,
-        ...joinNodes.rightNodes
-    ]){
-        const nodeType = tr.doc.type.schema.nodes[node.type];
-        if (!nodeType) return false;
-        try {
-            marksFromJSON(tr.doc.type.schema, node.marks);
-        } catch  {
-            return false;
-        }
-    }
-    const restoredStructureSuggestionIds = getRestoredStructureSuggestionIds(joinNodes, tr.doc.type.schema);
-    // Reverting a join marker removes its ZWSP anchor, splits at that position,
-    // and restores markup because ProseMirror split creates nodes with defaults.
-    const joinDepth = joinNodes.leftNodes.length;
+    if (!mark || mark.attrs["type"] !== "join" || node.text !== ZWSP) return false;
+    // this is a mark of type join
+    // split the current node at this mark position
+    // delete this mark together with its zwsp content
+    // assign left and right node (after the split) properties from the mark's data
     tr.delete(from, to);
-    tr.split(from, joinDepth);
-    const $splitFrom = tr.doc.resolve(from);
-    const baseDepth = $splitFrom.depth;
-    let rightPos = $splitFrom.after(baseDepth - joinDepth + 1);
-    // Metadata is stored child-first, but markup must be restored outer-first so
-    // positions inside the newly split structure remain addressable.
-    for(let index = joinDepth - 1; index >= 0; index -= 1){
-        const leftNode = joinNodes.leftNodes[index];
-        const rightNode = joinNodes.rightNodes[index];
-        if (!leftNode || !rightNode) return false;
-        const leftPos = $splitFrom.before(baseDepth - index);
-        if (!restoreNodeMarkup(tr, leftPos, leftNode) || !restoreNodeMarkup(tr, rightPos, rightNode)) {
-            return false;
-        }
-        // Each deeper right node starts one position inside the right node restored before it.
-        rightPos += 1;
-    }
-    return {
-        restoredStructureSuggestionIds
-    };
+    tr.split(from);
+    // insertionFrom is now at the end of the left node (but before the closing token)
+    // after() will give us the position after the closing token (but before the next opening token) - exactly the split pos
+    const $insertionFrom = tr.doc.resolve(from);
+    const $splitPos = tr.doc.resolve($insertionFrom.after());
+    const { attrs } = mark;
+    if (!isJoinMarkAttrs(attrs) || !$splitPos.nodeBefore || !$splitPos.nodeAfter) return false;
+    // restore left and right node type, attrs and marks, as they were before the join
+    const { leftNode, rightNode } = attrs.data;
+    const leftNodeType = tr.doc.type.schema.nodes[leftNode.type];
+    const rightNodeType = tr.doc.type.schema.nodes[rightNode.type];
+    const leftNodeMarks = leftNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
+    const rightNodeMarks = rightNode.marks.map((markData)=>Mark.fromJSON(tr.doc.type.schema, markData));
+    if (!leftNodeType || !rightNodeType) return false;
+    tr.setNodeMarkup($splitPos.pos - $splitPos.nodeBefore.nodeSize, leftNodeType, leftNode.attrs, leftNodeMarks);
+    tr.setNodeMarkup($splitPos.pos, rightNodeType, rightNode.attrs, rightNodeMarks);
+    return true;
 }
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
@@ -135,95 +72,45 @@ export function maybeRevertJoinMark(tr, from, to, node, markType) {
     doc.nodesBetween(blockRange.start, blockRange.end, (node, pos)=>{
         if (node.isInline) return false;
         const endOfNode = pos + node.nodeSize;
+        // make sure the node ends within the range
         if (endOfNode >= blockRange.$to.pos) return true;
-        // List-item joins can start between non-textblock nodes; expand inward to
-        // capture the visible textblock pair and its structural parent pair.
-        const joinCandidate = getJoinCandidateAtBoundary(doc, endOfNode, from, to, MAX_BLOCK_JOIN_DEPTH);
-        if (!joinCandidate) return true;
-        const mappedJoinPos = transform.mapping.map(joinCandidate.joinPos);
-        if (!canApplyJoinCandidate(transform.doc, mappedJoinPos, joinCandidate.leftNodes.length)) {
+        const $endOfNode = doc.resolve(endOfNode);
+        // make sure we are between two nodes
+        if (!$endOfNode.nodeBefore || !$endOfNode.nodeAfter) return false;
+        // we cannot insert zwsp text nodes into non-textblock nodes
+        if (!$endOfNode.nodeBefore.isTextblock || !$endOfNode.nodeAfter.isTextblock) return true;
+        const mappedEndOfNode = transform.mapping.map(endOfNode);
+        const $mappedEndOfNode = transform.doc.resolve(mappedEndOfNode);
+        if (!canJoin(transform.doc, mappedEndOfNode) || !$mappedEndOfNode.nodeBefore || !$mappedEndOfNode.nodeAfter) {
             return true;
         }
-        const shouldSuppressJoinMark = [
-            ...joinCandidate.leftNodes,
-            ...joinCandidate.rightNodes
-        ].some((node)=>hasStructureAddMark(node));
-        transform.join(mappedJoinPos, joinCandidate.leftNodes.length);
-        // Joining provisional structure cancels its pending add instead of creating
-        // a second review artifact for the same user action.
-        if (shouldSuppressJoinMark) return false;
+        const leftNode = {
+            type: $endOfNode.nodeBefore.type.name,
+            attrs: $endOfNode.nodeBefore.attrs,
+            marks: $endOfNode.nodeBefore.marks.map((mark)=>mark.toJSON())
+        };
+        const rightNode = {
+            type: $endOfNode.nodeAfter.type.name,
+            attrs: $endOfNode.nodeAfter.attrs,
+            marks: $endOfNode.nodeAfter.marks.map((mark)=>mark.toJSON())
+        };
+        transform.join(mappedEndOfNode);
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         const joinStep = transform.steps[transform.steps.length - 1];
-        const joinPos = joinStep.getMap().map(mappedJoinPos);
+        const joinPos = joinStep.getMap().map(mappedEndOfNode);
         transform.insert(joinPos, transform.doc.type.schema.text(ZWSP));
         transform.addMark(joinPos, joinPos + 1, deletion.create({
             id: markId,
             type: "join",
             data: {
-                leftNodes: joinCandidate.leftNodes.map(serializeJoinNode),
-                rightNodes: joinCandidate.rightNodes.map(serializeJoinNode)
+                leftNode,
+                rightNode
             }
         }));
         return false;
     });
     return transform;
 }
-function getJoinCandidateAtBoundary(doc, boundaryPos, from, to, maxJoinDepth) {
-    const $boundary = doc.resolve(boundaryPos);
-    const leftNode = $boundary.nodeBefore;
-    const rightNode = $boundary.nodeAfter;
-    // Multi-depth list joins can begin between structural nodes, not just textblocks.
-    if (!leftNode || !rightNode) return null;
-    if (leftNode.isInline || rightNode.isInline) return null;
-    if (!canJoin(doc, boundaryPos)) return null;
-    const pairs = [
-        {
-            leftNode,
-            rightNode
-        }
-    ];
-    for(let expandBy = 1; pairs.length < maxJoinDepth; expandBy += 1){
-        const left = boundaryPos - expandBy;
-        const right = boundaryPos + expandBy;
-        if (left < from || right > to) break;
-        const $left = doc.resolve(left);
-        const $right = doc.resolve(right);
-        // Once text is adjacent, there is no deeper block pair to capture.
-        if ($left.nodeBefore?.isText || $right.nodeAfter?.isText) break;
-        if ($left.nodeAfter === null && $left.nodeBefore && !$left.nodeBefore.isInline && $right.nodeBefore === null && $right.nodeAfter && !$right.nodeAfter.isInline) {
-            pairs.push({
-                leftNode: $left.nodeBefore,
-                rightNode: $right.nodeAfter
-            });
-            continue;
-        }
-        break;
-    }
-    // canJoin only checks the boundary; the temporary transform verifies depth.
-    if (!canApplyJoinCandidate(doc, boundaryPos, pairs.length)) return null;
-    return {
-        joinPos: boundaryPos,
-        leftNodes: pairs.map((pair)=>pair.leftNode).reverse(),
-        rightNodes: pairs.map((pair)=>pair.rightNode).reverse()
-    };
-}
-function canApplyJoinCandidate(doc, joinPos, depth) {
-    if (!canJoin(doc, joinPos)) return false;
-    try {
-        new Transform(doc).join(joinPos, depth);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-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/generateId.js

@@ -1,6 +1,4 @@
 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);
@@ -10,39 +8,14 @@ export function parseSuggestionId(id) {
     return parsed;
 }
 export function generateNextNumberId(schema, doc) {
-    const { deletion, insertion, modification, structure } = getSuggestionMarks(schema);
+    const { deletion, insertion, modification } = 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)=>{
-        // 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);
+        const mark = node.marks.find((mark)=>mark.type === insertion || mark.type === deletion || mark.type === modification);
+        if (mark) {
+            suggestionId = Math.max(suggestionId, mark.attrs["id"]);
             return false;
         }
         return true;

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,7 +1,5 @@
-export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion, structure } from "./schema.js";
+export { addSuggestionMarks, insertion, deletion, modification, hiddenDeletion } 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, suggestStructureChanges as experimental_suggestStructureChanges } from "./withSuggestChanges.js";
+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 { wrappingInputRule as experimental_wrappingInputRule } from "./wrappingInputRule.js";

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 ReplaceStep, type Step } from "prosemirror-transform";
+import { type Step, type ReplaceStep } from "prosemirror-transform";
 import { type SuggestionId } from "./generateId.js";
 /**
  * Transform a replace step into its equivalent tracked steps.

package/dist/schema.d.ts

@@ -3,11 +3,10 @@ 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" | "structure", MarkSpec>;
+}): Record<Marks | "deletion" | "insertion" | "modification", MarkSpec>;

package/dist/schema.js

@@ -166,41 +166,6 @@ 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.
@@ -209,7 +174,6 @@ export const structure = {
         ...marks,
         deletion: opts?.experimental_deletions === "hidden" ? hiddenDeletion : deletion,
         insertion,
-        modification,
-        structure
+        modification
     };
 }

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" | "doc" | "paragraph" | "horizontal_rule" | "heading" | "code_block" | "image" | "hard_break" | "orderedList" | "bulletList" | "listItem", "insertion" | "deletion" | "modification" | "structure" | "code" | "em" | "link" | "strong" | "difficulty">;
+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 testBuilders: { [NodeTypeName in keyof (typeof schema)["nodes"]]: NodeBuilder; } & { [MarkTypeName in keyof (typeof schema)["marks"]]: MarkBuilder; } & {
     schema: typeof schema;
 };
@@ -8,3 +8,4 @@ export type TaggedNode = Node & {
     flat: Node;
     tag: Record<string, number>;
 };
+export {};

package/dist/utils.d.ts

@@ -3,7 +3,6 @@ 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, structure } = schema.marks;
+    const { insertion, deletion, modification } = schema.marks;
     if (!insertion) {
         throw new Error("Failed to find insertion mark in schema. Did you forget to add it?");
     }
@@ -12,13 +12,9 @@
     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,
-        structure
+        modification
     };
 }

package/dist/withSuggestChanges.d.ts

@@ -1,11 +1,18 @@
-import { type Node, type Schema } from "prosemirror-model";
-import { type Transaction } from "prosemirror-state";
-import { type Transform } from "prosemirror-transform";
+import { type Schema, type Node } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
 import { type EditorView } from "prosemirror-view";
 import { type SuggestionId } from "./generateId.js";
-import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
-export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
-export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.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;
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
  * function with `withSuggestChanges`, or pass no arguments to use the default
@@ -17,8 +24,4 @@ export { suggestStructureChanges } from "./features/wrapUnwrap/structureChangesP
  * 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, opts?: {
-    experimental_trackStructureChanges?: boolean;
-    experimental_trackStructures?: StructuralContextPath[];
-    experimental_ensureUniqueNodeIds?: (transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform;
-}): EditorView["dispatch"];
+export declare function withSuggestChanges(dispatchTransaction?: EditorView["dispatch"], generateId?: (schema: Schema, doc?: Node) => SuggestionId): EditorView["dispatch"];