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

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

@@ -1,15 +1,63 @@
+import { type Node } from "prosemirror-model";
 import { type Locator, type Page } from "@playwright/test";
 export declare class EditorPage {
     readonly page: Page;
+    readonly deletionMarksVisibility: "hidden" | "visible";
     private readonly selectors;
-    constructor(page: Page);
+    constructor(page: Page, deletionMarksVisibility?: "hidden" | "visible");
     get editor(): Locator;
-    getParagraphText(index: number): Promise<string>;
+    getParagraphText(index: number, childIndexes?: number[]): Promise<string>;
+    getParagraphAt(index: number): Locator;
     getParagraphCount(): Promise<number>;
+    getListItems(): Locator;
+    getParagraphs(): Locator;
+    getListItemCount(): Promise<number>;
     getProseMirrorMarkCount(name: string): Promise<number>;
+    getProseMirrorMarksJSON(): Promise<unknown[]>;
     getProseMirrorSelection(): Promise<{
         anchor: number;
         head: number;
     }>;
     getDOMTextContentOfChildAtIndex(index: number): Promise<string>;
+    getDocJSON(): Promise<object>;
+    getCurrentDoc(): Promise<Node>;
+    getCurrentAndExpectedDoc(expectedDocJSON: object): Promise<{
+        currentDoc: Node;
+        expectedDoc: Node;
+    }>;
+    revertSuggestion(suggestionId: number): Promise<void>;
+    revertAll(): Promise<void>;
+    applyAll(): Promise<void>;
+    /**
+     * Perform an action and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    private doActionAndWaitForState;
+    /**
+     * Press a key and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    pressKey(key: string, opts?: {
+        waitForSelectionChange?: boolean;
+    }): Promise<void>;
+    /**
+     * Insert text and wait for ProseMirror state to update.
+     * Stores the current state reference before pressing, then polls until
+     * editor.view.state is a different object (ProseMirror creates a new
+     * immutable state on every transaction).
+     */
+    insertText(text: string, opts?: {
+        waitForSelectionChange?: boolean;
+    }): Promise<void>;
+    /**
+     * Press a key multiple times, waiting for editor state update after each press.
+     */
+    pressKeyMultiple(key: string, count: number, opts?: {
+        waitForSelectionChange?: boolean;
+    }): Promise<void>;
+    setNextNodeId(nextNodeId: number): Promise<void>;
 }

package/dist/commands.js

@@ -5,6 +5,9 @@ import { suggestChangesKey } from "./plugin.js";
 import { getSuggestionMarks } from "./utils.js";
 import { ZWSP } from "./constants.js";
 import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
+import { isJoinMark } from "./features/joinOnDelete/types.js";
+import { revertAllStructureSuggestions, revertStructureSuggestion } from "./features/wrapUnwrap/revert/index.js";
+import { applyAllStructureSuggestions, applyStructureSuggestion } from "./features/wrapUnwrap/apply/index.js";
 /**
  * Given a node and a transform, add a set of steps to the
  * transform that applies all marks of type markTypeToApply
@@ -29,6 +32,7 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
             tr.removeNodeMark(0, markTypeToApply);
         }
     }
+    const restoredStructureSuggestionIds = new Set();
     node.descendants((child, pos)=>{
         if (from !== undefined && pos < from) {
             return true;
@@ -60,8 +64,12 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
         const insertionTo = insertionFrom + child.nodeSize;
         if (child.isInline) {
             tr.removeMark(insertionFrom, insertionTo, markTypeToApply);
-            const reverted = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
-            if (!reverted && child.text === ZWSP) {
+            const joinRevertResult = maybeRevertJoinMark(tr, insertionFrom, insertionTo, child, markTypeToApply);
+            // reverting a join mark may produce new structure marks that were serialized in the join metadata
+            if (joinRevertResult) {
+                joinRevertResult.restoredStructureSuggestionIds.forEach((id)=>restoredStructureSuggestionIds.add(id));
+            }
+            if (!joinRevertResult && child.text === ZWSP) {
                 tr.delete(insertionFrom, insertionTo);
             }
         } else {
@@ -69,6 +77,50 @@ import { maybeRevertJoinMark } from "./features/joinOnDelete/index.js";
         }
         return true;
     });
+    return {
+        restoredStructureSuggestionIds
+    };
+}
+/**
+ * Collect suggestion IDs of join marks in the node
+ *
+ * @param node
+ * @param deletion
+ * @returns an array of suggestion IDs
+ */ function findJoinSuggestionIds(node, deletion) {
+    const joinSuggestionIds = [];
+    node.descendants((child)=>{
+        const mark = deletion.isInSet(child.marks);
+        if (!mark || !isJoinMark(mark)) return true;
+        if (!child.isText || child.text !== ZWSP) return true;
+        joinSuggestionIds.push(mark.attrs.id);
+        return true;
+    });
+    return joinSuggestionIds.reverse();
+}
+/**
+ * Revert suggestions revealed by reverting a join mark
+ * Prioritize reverting revealed suggestions with the same id as the join mark
+ * (that means they are linked to the join mark and has to be reverted together as one)
+ * Revert other revealed suggestions as well so the user doesn't have to revert multiple times at the same place
+ *
+ * @param tr
+ * @param suggestionId
+ * @param restoredStructureSuggestionIds
+ */ function revertRestoredStructureSuggestions(tr, suggestionId, restoredStructureSuggestionIds) {
+    if (restoredStructureSuggestionIds.has(suggestionId)) {
+        const restoredStructureTransform = revertStructureSuggestion(tr.doc, suggestionId);
+        restoredStructureTransform.steps.forEach((step)=>{
+            tr.step(step);
+        });
+    }
+    restoredStructureSuggestionIds.forEach((restoredSuggestionId)=>{
+        if (restoredSuggestionId === suggestionId) return;
+        const restoredStructureTransform = revertStructureSuggestion(tr.doc, restoredSuggestionId);
+        restoredStructureTransform.steps.forEach((step)=>{
+            tr.step(step);
+        });
+    });
 }
 function revertModifications(node, pos, tr) {
     const { modification } = getSuggestionMarks(node.type.schema);
@@ -134,20 +186,42 @@ function applyModificationsToTransform(node, tr, dir, suggestionId, from, to) {
 }
 export function applySuggestionsToNode(node) {
     const { deletion, insertion } = getSuggestionMarks(node.type.schema);
-    const transform = new Transform(node);
-    applySuggestionsToTransform(node, transform, insertion, deletion);
-    applyModificationsToTransform(node, transform, 1);
-    return transform.doc;
+    // first, create a structure transform that applies all structure changes on the given node
+    const structureTransform = applyAllStructureSuggestions(node);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    return structureTransform.doc;
 }
 export function applySuggestionsToRange(doc, from, to) {
+    const { deletion, insertion } = getSuggestionMarks(doc.type.schema);
     // blockRange can only return null if a predicate is provided
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const nodeRange = doc.resolve(from).blockRange(doc.resolve(to));
-    const { deletion, insertion } = getSuggestionMarks(doc.type.schema);
-    const transform = new Transform(doc);
-    applySuggestionsToTransform(doc, transform, insertion, deletion, undefined, nodeRange.start, nodeRange.end);
-    applyModificationsToTransform(doc, transform, 1, undefined, nodeRange.start, nodeRange.end);
-    return transform.doc.slice(transform.mapping.map(from), transform.mapping.map(to));
+    // create a structure transform that applies all structure changes on the given node range
+    const structureTransform = applyAllStructureSuggestions(doc, nodeRange.start, nodeRange.end);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, nodeRange.start, nodeRange.end);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, nodeRange.start, nodeRange.end);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc, structureTransform.mapping.map(from), structureTransform.mapping.map(to));
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    return structureTransform.doc.slice(structureTransform.mapping.map(from), structureTransform.mapping.map(to));
 }
 /**
  * Command that applies all tracked changes in a document.
@@ -157,13 +231,30 @@ export function applySuggestionsToRange(doc, from, to) {
  * contents left in the doc.
  */ export function applySuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
-    const tr = state.tr;
-    applySuggestionsToTransform(state.doc, tr, insertion, deletion);
-    applyModificationsToTransform(tr.doc, tr, 1);
-    tr.setMeta(suggestChangesKey, {
+    // create a structure transform that applies all structure changes on the given document
+    const structureTransform = applyAllStructureSuggestions(state.doc);
+    // then start a clear transform from the document where the structure changes are applied
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    // apply the structure transform to the transaction
+    const transaction = state.tr;
+    structureTransform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (!transaction.steps.length) return false;
+    transaction.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(tr);
+    dispatch?.(transaction);
     return true;
 }
 /**
@@ -175,13 +266,30 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, insertion, deletion, undefined, from, to);
-        applyModificationsToTransform(tr.doc, tr, 1, undefined, from, to);
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that applies all structure changes on the given node range
+        const structureTransform = applyAllStructureSuggestions(state.doc, from, to);
+        // then start a clear transform from the document where the structure changes are applied
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, undefined, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        const secondStructureTransform = applyAllStructureSuggestions(structureTransform.doc, from === undefined ? undefined : structureTransform.mapping.map(from), to === undefined ? undefined : structureTransform.mapping.map(to));
+        secondStructureTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -194,14 +302,26 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function applySuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, insertion, deletion, suggestionId, from, to);
-        applyModificationsToTransform(tr.doc, tr, 1, undefined, from, to);
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that applies the given structure change on the given node
+        const structureTransform = applyStructureSuggestion(state.doc, suggestionId);
+        // then start a clear transform from the document where the structure changes are applied
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, insertion, deletion, suggestionId, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, 1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -213,13 +333,40 @@ export function applySuggestionsToRange(doc, from, to) {
  * Modifications tracked in modification marks will be reverted.
  */ export function revertSuggestions(state, dispatch) {
     const { deletion, insertion } = getSuggestionMarks(state.schema);
-    const tr = state.tr;
-    applySuggestionsToTransform(state.doc, tr, deletion, insertion);
-    applyModificationsToTransform(tr.doc, tr, -1);
-    tr.setMeta(suggestChangesKey, {
+    // create a structure transform that reverts all structure changes on the given document
+    const structureTransform = revertAllStructureSuggestions(state.doc);
+    // revert all join marks first as well as any structure marks they contain serialized
+    const joinSuggestionIds = findJoinSuggestionIds(structureTransform.doc, deletion);
+    joinSuggestionIds.forEach((suggestionId)=>{
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        const { restoredStructureSuggestionIds } = applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, suggestionId);
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        revertRestoredStructureSuggestions(structureTransform, suggestionId, restoredStructureSuggestionIds);
+    });
+    // then start a clear transform from the document where the structure changes and join marks are reverted
+    const suggestionsTransform = new Transform(structureTransform.doc);
+    applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion);
+    applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1);
+    // replay suggestion transform on top of the structure transform
+    suggestionsTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    const secondStructureTransform = revertAllStructureSuggestions(structureTransform.doc);
+    secondStructureTransform.steps.forEach((step)=>{
+        structureTransform.step(step);
+    });
+    // apply the structure transform to the transaction
+    const transaction = state.tr;
+    structureTransform.steps.forEach((step)=>{
+        transaction.step(step);
+    });
+    if (!transaction.steps.length) return false;
+    transaction.setMeta(suggestChangesKey, {
         skip: true
     });
-    dispatch?.(tr);
+    dispatch?.(transaction);
     return true;
 }
 /**
@@ -231,13 +378,30 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestionsInRange(from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, deletion, insertion, undefined, from, to);
-        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that reverts all structure changes on the given node range
+        const structureTransform = revertAllStructureSuggestions(state.doc, from, to);
+        // then start a clear transform from the document where the structure changes are reverted
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, undefined, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        const secondStructureTransform = revertAllStructureSuggestions(structureTransform.doc, from === undefined ? undefined : structureTransform.mapping.map(from), to === undefined ? undefined : structureTransform.mapping.map(to));
+        secondStructureTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }
@@ -250,14 +414,29 @@ export function applySuggestionsToRange(doc, from, to) {
  */ export function revertSuggestion(suggestionId, from, to) {
     return (state, dispatch)=>{
         const { deletion, insertion } = getSuggestionMarks(state.schema);
-        const tr = state.tr;
-        applySuggestionsToTransform(state.doc, tr, deletion, insertion, suggestionId, from, to);
-        if (!tr.steps.length) return false;
-        tr.setMeta(suggestChangesKey, {
+        // create a structure transform that reverts the given structure change on the given node
+        const structureTransform = revertStructureSuggestion(state.doc, suggestionId);
+        // then start a clear transform from the document where the structure changes are reverted
+        const suggestionsTransform = new Transform(structureTransform.doc);
+        const { restoredStructureSuggestionIds } = applySuggestionsToTransform(suggestionsTransform.doc, suggestionsTransform, deletion, insertion, suggestionId, from, to);
+        applyModificationsToTransform(suggestionsTransform.doc, suggestionsTransform, -1, undefined, from, to);
+        // replay suggestion transform on top of the structure transform
+        suggestionsTransform.steps.forEach((step)=>{
+            structureTransform.step(step);
+        });
+        // in case there are structure marks revealed after join mark revert,
+        // revert them as well
+        revertRestoredStructureSuggestions(structureTransform, suggestionId, restoredStructureSuggestionIds);
+        // apply the structure transform to the transaction
+        const transaction = state.tr;
+        structureTransform.steps.forEach((step)=>{
+            transaction.step(step);
+        });
+        if (!transaction.steps.length) return false;
+        transaction.setMeta(suggestChangesKey, {
             skip: true
         });
-        applyModificationsToTransform(tr.doc, tr, -1, undefined, from, to);
-        dispatch?.(tr);
+        dispatch?.(transaction);
         return true;
     };
 }

package/dist/ensureSelectionPlugin.js

@@ -63,7 +63,7 @@ export function ensureSelection() {
                 $newAnchor
             });
             trace("appendTransaction", "search for new valid $head...");
-            let $newHead = getNewValidPos(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
+            let $newHead = newState.selection.empty ? $newAnchor : getNewValidPos(newState.selection.$head, getDirection(oldState.selection.$head, newState.selection.$head, pluginState));
             trace("appendTransaction", "new valid $head", $newHead?.pos, {
                 $newHead
             });
@@ -147,8 +147,8 @@ function isPosValid($pos) {
     const insertionBefore = insertion.isInSet($pos.nodeBefore?.marks ?? []);
     const insertionAfter = insertion.isInSet($pos.nodeAfter?.marks ?? []);
     const ZWSP_REGEXP = new RegExp(ZWSP, "g");
-    const isZWSPBefore = $pos.nodeBefore && $pos.nodeBefore.textContent.replace(ZWSP_REGEXP, "") === "";
-    const isZWSPAfter = $pos.nodeAfter && $pos.nodeAfter.textContent.replace(ZWSP_REGEXP, "") === "";
+    const isZWSPBefore = $pos.nodeBefore && $pos.nodeBefore.isText && $pos.nodeBefore.textContent.replace(ZWSP_REGEXP, "") === "";
+    const isZWSPAfter = $pos.nodeAfter && $pos.nodeAfter.isText && $pos.nodeAfter.textContent.replace(ZWSP_REGEXP, "") === "";
     if (insertionBefore && insertionAfter && isZWSPBefore && isZWSPAfter) {
         trace("isPosValid", $pos.pos, "pos invalid", "reason: between two ZWSP insertions", {
             $pos

package/dist/features/joinOnDelete/__tests__/joinOnDeleteInLists.playwright.test.d.ts

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

package/dist/features/joinOnDelete/__tests__/joinOnDeleteInListsTipTapStyle.playwright.test.d.ts

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

package/dist/features/joinOnDelete/__tests__/listWithJoinsAndStructureMarks.playwright.test.d.ts

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

package/dist/features/joinOnDelete/index.d.ts

@@ -1,24 +1,10 @@
-import { Mark, type Node, type Attrs, type MarkType, type ResolvedPos } from "prosemirror-model";
+import { Mark, type Node, type MarkType, type ResolvedPos } from "prosemirror-model";
 import { Transform } from "prosemirror-transform";
 import { type Transaction } from "prosemirror-state";
 import { type SuggestionId } from "../../generateId.js";
-interface JoinMarkAttrs {
-    type: "join";
-    data: {
-        leftNode: {
-            type: string;
-            attrs: object;
-            marks: object[];
-        };
-        rightNode: {
-            type: string;
-            attrs: object;
-            marks: object[];
-        };
-    };
-}
-export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
-export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): boolean;
+export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): false | {
+    restoredStructureSuggestionIds: Set<SuggestionId>;
+};
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
  */
@@ -34,4 +20,3 @@ export declare function joinNodesAndMarkJoinPoints(trackedTransaction: Transacti
  */
 export declare function collapseZWSPNodes(trackedTransaction: Transaction, from: number, to: number): Transform;
 export declare function findJoinMark(pos: ResolvedPos): Mark | null;
-export {};