@magic-marker/prosemirror-suggest-changes 0.3.3-wrap-unwrap.17 → 0.3.3-wrap-unwrap.19

package/dist/__tests__/playwrightPage.d.ts

@@ -24,4 +24,35 @@ export declare class EditorPage {
     }>;
     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>;
 }

package/dist/commands.js

@@ -146,6 +146,10 @@ export function applySuggestionsToNode(node) {
     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) {
@@ -163,6 +167,10 @@ export function applySuggestionsToRange(doc, from, to) {
     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));
 }
 /**
@@ -183,6 +191,10 @@ export function applySuggestionsToRange(doc, from, to) {
     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)=>{
@@ -214,6 +226,10 @@ export function applySuggestionsToRange(doc, from, to) {
         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)=>{
@@ -277,6 +293,10 @@ export function applySuggestionsToRange(doc, from, to) {
     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)=>{
@@ -308,6 +328,10 @@ export function applySuggestionsToRange(doc, from, to) {
         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)=>{

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

@@ -1,22 +1,7 @@
-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 SerializedJoinNode {
-    type: string;
-    attrs: object;
-    marks: object[];
-}
-interface JoinMarkAttrs {
-    type: "join";
-    data: {
-        leftNode?: SerializedJoinNode;
-        rightNode?: SerializedJoinNode;
-        leftNodes?: SerializedJoinNode[];
-        rightNodes?: SerializedJoinNode[];
-    };
-}
-export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
 export declare function maybeRevertJoinMark(tr: Transform, from: number, to: number, node: Node, markType: MarkType): boolean;
 /**
  * Remove ZWSP text nodes marked as deletions (except for type=join) from the given range
@@ -33,4 +18,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 {};

package/dist/features/joinOnDelete/index.js

@@ -2,40 +2,10 @@ 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";
-// Block join suggestion metadata/revert currently supports the depth TipTap uses
-// when Backspace joins both list-item paragraphs and their parent list items.
-const MAX_BLOCK_JOIN_DEPTH = 2;
-function isSerializedJoinNode(node) {
-    if (node === null || typeof node !== "object") return false;
-    const data = node;
-    return typeof data.type === "string" && typeof data.attrs === "object" && data.attrs !== null && Array.isArray(data.marks);
-}
-function normalizeJoinNodes(attrs) {
-    if (attrs["type"] !== "join") return false;
-    if (attrs["data"] == null) return false;
-    const data = attrs["data"];
-    // Normalize legacy metadata so revert can use the same array path.
-    const leftNodes = data.leftNodes ?? (data.leftNode ? [
-        data.leftNode
-    ] : null);
-    const rightNodes = data.rightNodes ?? (data.rightNode ? [
-        data.rightNode
-    ] : null);
-    if (!Array.isArray(leftNodes) || !Array.isArray(rightNodes)) return false;
-    if (leftNodes.length === 0 || leftNodes.length !== rightNodes.length) return false;
-    // Reject unsupported depths instead of partially reverting unknown structure.
-    if (leftNodes.length > MAX_BLOCK_JOIN_DEPTH) return false;
-    if (!leftNodes.every(isSerializedJoinNode)) return false;
-    if (!rightNodes.every(isSerializedJoinNode)) return false;
-    return {
-        leftNodes,
-        rightNodes
-    };
-}
-export function isJoinMarkAttrs(attrs) {
-    return normalizeJoinNodes(attrs) !== false;
-}
+import { MAX_BLOCK_JOIN_DEPTH, normalizeJoinNodesMetadata } from "./normalizeJoinNodesMetadata.js";
+import { isJoinMark } from "./types.js";
 function serializeJoinNode(node) {
     return {
         type: node.type.name,
@@ -46,16 +16,35 @@ function serializeJoinNode(node) {
 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;
-    tr.setNodeMarkup(pos, nodeType, node.attrs, marksFromJSON(tr.doc.type.schema, node.marks));
+    const marks = mergeSerializedMarksWithCurrentStructureMarks(tr, pos, marksFromJSON(tr.doc.type.schema, node.marks));
+    tr.setNodeMarkup(pos, nodeType, node.attrs, marks);
     return true;
 }
 export function maybeRevertJoinMark(tr, from, to, node, markType) {
     const mark = node.marks.find((mark)=>mark.type === markType);
-    if (!mark || mark.attrs["type"] !== "join" || node.text !== ZWSP) return false;
-    const joinNodes = normalizeJoinNodes(mark.attrs);
+    if (!mark || !isJoinMark(mark) || node.text !== ZWSP) return false;
+    const joinNodes = normalizeJoinNodesMetadata(mark.attrs);
     if (!joinNodes) return false;
     for (const node of [
         ...joinNodes.leftNodes,

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

@@ -0,0 +1,6 @@
+import { type JoinMarkAttrs } from "./types.js";
+export declare const MAX_BLOCK_JOIN_DEPTH = 2;
+export declare function normalizeJoinNodesMetadata(attrs: JoinMarkAttrs): false | {
+    leftNodes: import("./types.js").SerializedJoinNode[];
+    rightNodes: import("./types.js").SerializedJoinNode[];
+};

package/dist/features/joinOnDelete/normalizeJoinNodesMetadata.js

@@ -0,0 +1,24 @@
+import { isSerializedJoinNode } from "./types.js";
+// Block join suggestion metadata/revert currently supports the depth TipTap uses
+// when Backspace joins both list-item paragraphs and their parent list items.
+export const MAX_BLOCK_JOIN_DEPTH = 2;
+export function normalizeJoinNodesMetadata(attrs) {
+    const data = attrs.data;
+    // Normalize legacy metadata so revert can use the same array path.
+    const leftNodes = data.leftNodes ?? (data.leftNode ? [
+        data.leftNode
+    ] : null);
+    const rightNodes = data.rightNodes ?? (data.rightNode ? [
+        data.rightNode
+    ] : null);
+    if (!Array.isArray(leftNodes) || !Array.isArray(rightNodes)) return false;
+    if (leftNodes.length === 0 || leftNodes.length !== rightNodes.length) return false;
+    // Reject unsupported depths instead of partially reverting unknown structure.
+    if (leftNodes.length > MAX_BLOCK_JOIN_DEPTH) return false;
+    if (!leftNodes.every(isSerializedJoinNode)) return false;
+    if (!rightNodes.every(isSerializedJoinNode)) return false;
+    return {
+        leftNodes,
+        rightNodes
+    };
+}

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

@@ -0,0 +1,34 @@
+import { type Mark, type Attrs, type Node } from "prosemirror-model";
+export interface SerializedJoinNode {
+    type: string;
+    attrs: object;
+    marks: {
+        attrs: Record<string, unknown>;
+    }[];
+}
+export interface JoinMarkAttrs {
+    type: "join";
+    data: {
+        leftNode?: SerializedJoinNode;
+        rightNode?: SerializedJoinNode;
+        leftNodes?: SerializedJoinNode[];
+        rightNodes?: SerializedJoinNode[];
+    };
+}
+export interface JoinPair {
+    leftNode: Node;
+    rightNode: Node;
+}
+export interface JoinCandidate {
+    joinPos: number;
+    leftNodes: Node[];
+    rightNodes: Node[];
+}
+export declare function isSerializedJoinNode(node: unknown): node is SerializedJoinNode;
+export declare function isJoinMarkAttrs(attrs: Attrs): attrs is JoinMarkAttrs;
+export declare function isJoinMarkObject(mark: unknown): mark is Omit<Mark, "attrs"> & {
+    attrs: JoinMarkAttrs;
+};
+export declare function isJoinMark(mark: Mark): mark is Omit<Mark, "attrs"> & {
+    attrs: JoinMarkAttrs;
+};

package/dist/features/joinOnDelete/types.js

@@ -0,0 +1,20 @@
+import { getSuggestionMarks } from "../../utils.js";
+export function isSerializedJoinNode(node) {
+    if (node === null || typeof node !== "object") return false;
+    const data = node;
+    return typeof data.type === "string" && typeof data.attrs === "object" && data.attrs !== null && Array.isArray(data.marks);
+}
+export function isJoinMarkAttrs(attrs) {
+    if (attrs["type"] !== "join") return false;
+    if (attrs["data"] == null) return false;
+    return true;
+}
+export function isJoinMarkObject(mark) {
+    if (mark === null || typeof mark !== "object") return false;
+    if (!("attrs" in mark)) return false;
+    return isJoinMarkAttrs(mark.attrs);
+}
+export function isJoinMark(mark) {
+    const { deletion } = getSuggestionMarks(mark.type.schema);
+    return mark.type === deletion && isJoinMarkAttrs(mark.attrs);
+}

package/dist/features/transactionShaping/detectSpecialTransactionShape.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type SpecialTransactionShape } from "./types.js";
+export declare function detectSpecialTransactionShape(transaction: Transaction): SpecialTransactionShape | null;

package/dist/features/transactionShaping/detectSpecialTransactionShape.js

@@ -0,0 +1,4 @@
+import { detectTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js";
+export function detectSpecialTransactionShape(transaction) {
+    return detectTipTapParagraphIntoListJoin(transaction);
+}

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

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type HandleSpecialTransactionShapeArgs } from "./types.js";
+export declare function handleSpecialTransactionShape(args: HandleSpecialTransactionShapeArgs): Transaction | null;

package/dist/features/transactionShaping/index.js

@@ -0,0 +1,11 @@
+import { handleTipTapParagraphIntoListJoin } from "./tipTapParagraphIntoListJoin/index.js";
+const specialTransactionShapeHandlers = [
+    handleTipTapParagraphIntoListJoin
+];
+export function handleSpecialTransactionShape(args) {
+    for (const handler of specialTransactionShapeHandlers){
+        const transaction = handler(args);
+        if (transaction) return transaction;
+    }
+    return null;
+}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type TipTapParagraphIntoListJoinShape } from "../types.js";
+export declare function detectTipTapParagraphIntoListJoin(transaction: Transaction): TipTapParagraphIntoListJoinShape | null;

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.js

@@ -0,0 +1,48 @@
+import { ReplaceStep, Transform } from "prosemirror-transform";
+import { getNodeId } from "../../wrapUnwrap/getNodeId.js";
+// detect a very specific TipTap pattern where joining a paragraph into a list above it
+// causes a 3-step transaction, which is different from normal prosemirror where you just get 1 step
+// see unit test for details
+export function detectTipTapParagraphIntoListJoin(transaction) {
+    if (transaction.steps.length !== 3) return null;
+    const [deleteStep, insertStep, joinStep] = transaction.steps;
+    if (!(deleteStep instanceof ReplaceStep) || !(insertStep instanceof ReplaceStep) || !(joinStep instanceof ReplaceStep)) {
+        return null;
+    }
+    if (deleteStep.slice.content.size !== 0) return null;
+    if (insertStep.from !== insertStep.to) return null;
+    if (insertStep.slice.openStart !== 0 || insertStep.slice.openEnd !== 0) return null;
+    if (insertStep.slice.content.childCount !== 1) return null;
+    if (joinStep.slice.content.size !== 0) return null;
+    if (joinStep.structure !== true) return null;
+    const docBefore = transaction.docs[0];
+    if (!docBefore) return null;
+    const movedNode = docBefore.nodeAt(deleteStep.from);
+    if (!movedNode || !movedNode.isTextblock || movedNode.nodeSize !== deleteStep.to - deleteStep.from) {
+        return null;
+    }
+    const insertedNode = insertStep.slice.content.firstChild;
+    if (!insertedNode?.isTextblock) return null;
+    if (insertedNode.type !== movedNode.type) return null;
+    if (insertedNode.textContent !== movedNode.textContent) return null;
+    const movedNodeId = getNodeId(movedNode);
+    if (!movedNodeId || getNodeId(insertedNode) !== movedNodeId) return null;
+    const previousSibling = docBefore.resolve(deleteStep.from).nodeBefore;
+    if (!previousSibling || previousSibling.isInline) return null;
+    try {
+        const preview = new Transform(docBefore);
+        preview.step(deleteStep);
+        preview.step(insertStep);
+        new Transform(preview.doc).step(joinStep);
+    } catch  {
+        return null;
+    }
+    console.warn("[prosemirror-suggest-changes]", "detected TipTap paragraph into list join shape");
+    return {
+        type: "tipTapParagraphIntoListJoin",
+        deleteStep,
+        insertStep,
+        joinStep,
+        movedNode
+    };
+}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.test.d.ts

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

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/detectTipTapParagraphIntoListJoin.test.js

@@ -0,0 +1,188 @@
+import { EditorState } from "prosemirror-state";
+import { Step } from "prosemirror-transform";
+import { describe, expect, it } from "vitest";
+import { createSchema } from "../../../testing/e2eTestSchema.js";
+import { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+const schema = createSchema();
+// when joining a paragraph into a list above it,
+// TipTap List extension overrides the default ProseMirror behavior
+// by default, ProseMirror puts the paragraph to the end of list as a separate list item
+// TipTap instead joins the paragraph with the paragraph of the last list item
+const TIPTAP_PARAGRAPH_INTO_LIST_STEPS = [
+    // first step deletes the paragraph that we're joining
+    {
+        stepType: "replace",
+        from: 42,
+        to: 60
+    },
+    // second step inserts that paragraph into the last list item
+    {
+        stepType: "replace",
+        from: 40,
+        to: 40,
+        slice: {
+            content: [
+                {
+                    type: "paragraph",
+                    attrs: {
+                        id: "node-9",
+                        textAlign: null
+                    },
+                    content: [
+                        {
+                            type: "text",
+                            text: "sample paragraph"
+                        }
+                    ]
+                }
+            ]
+        }
+    },
+    // third step joins the two paragraphs in the list item
+    {
+        stepType: "replace",
+        from: 39,
+        to: 41,
+        structure: true
+    }
+];
+const TIPTAP_PARAGRAPH_INTO_LIST_DOC = {
+    type: "doc",
+    content: [
+        {
+            type: "orderedList",
+            attrs: {
+                order: 1,
+                id: "node-0"
+            },
+            content: [
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-1"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-2"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 1"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-3"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-4"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 2"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-5"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-6"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 3"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: "listItem",
+                    attrs: {
+                        id: "node-7"
+                    },
+                    content: [
+                        {
+                            type: "paragraph",
+                            attrs: {
+                                id: "node-8"
+                            },
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Item 4"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            type: "paragraph",
+            attrs: {
+                id: "node-9"
+            },
+            content: [
+                {
+                    type: "text",
+                    text: "sample paragraph"
+                }
+            ]
+        }
+    ]
+};
+describe("detectTipTapParagraphIntoListJoin", ()=>{
+    it("detects TipTap's three-step paragraph-into-list join shape", ()=>{
+        const doc = schema.nodeFromJSON(TIPTAP_PARAGRAPH_INTO_LIST_DOC);
+        const state = EditorState.create({
+            doc
+        });
+        const transaction = state.tr;
+        TIPTAP_PARAGRAPH_INTO_LIST_STEPS.forEach((stepJSON)=>{
+            transaction.step(Step.fromJSON(schema, stepJSON));
+        });
+        const shape = detectTipTapParagraphIntoListJoin(transaction);
+        expect(shape).toMatchObject({
+            type: "tipTapParagraphIntoListJoin",
+            deleteStep: {
+                from: 42,
+                to: 60
+            },
+            insertStep: {
+                from: 40,
+                to: 40
+            },
+            joinStep: {
+                from: 39,
+                to: 41
+            },
+            movedNode: {
+                attrs: {
+                    id: "node-9"
+                }
+            }
+        });
+        expect(shape?.movedNode.textContent).toBe("sample paragraph");
+    });
+});

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/handleTipTapParagraphIntoListJoin.d.ts

@@ -0,0 +1,3 @@
+import { type Transaction } from "prosemirror-state";
+import { type HandleSpecialTransactionShapeArgs } from "../types.js";
+export declare function handleTipTapParagraphIntoListJoin(args: HandleSpecialTransactionShapeArgs): Transaction | null;

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/handleTipTapParagraphIntoListJoin.js

@@ -0,0 +1,80 @@
+import { EditorState } from "prosemirror-state";
+import { preserveTransactionData, transformToSuggestionTransaction } from "../../../transformToSuggestionTransaction.js";
+import { getSuggestionMarks } from "../../../utils.js";
+import { getNodeId } from "../../wrapUnwrap/getNodeId.js";
+import { suggestStructureChanges } from "../../wrapUnwrap/structureChangesPlugin.js";
+import { guardStructureMarkAttrs } from "../../wrapUnwrap/types.js";
+import { detectSpecialTransactionShape } from "../detectSpecialTransactionShape.js";
+// handle the specific TipTap pattern when backspacing from a paragraph into a list above
+// causes a transaction with 3 steps
+// "slice" the transaction into two pieces, first piece is the first 2 steps, second piece is the last step
+// first piece "moves" the paragraph - handled by structure change tracking - a structure "move" suggestion
+// second piece joins two paragraphs - handled by the main plugin join-on-delete feature - deletion type="join" mark
+export function handleTipTapParagraphIntoListJoin(args) {
+    const shape = detectSpecialTransactionShape(args.transaction);
+    if (!isTipTapParagraphIntoListJoinShape(shape)) return null;
+    if (!args.structuralContextPaths || !args.ensureUniqueNodeIds) return null;
+    const docBefore = args.transaction.docs[0];
+    if (!docBefore) return null;
+    const movedNodeId = getNodeId(shape.movedNode);
+    if (!movedNodeId) return null;
+    const trackedTransaction = args.state.tr;
+    try {
+        trackedTransaction.step(shape.deleteStep);
+        trackedTransaction.step(shape.insertStep);
+    } catch  {
+        return null;
+    }
+    const uniqueNodeIdsTransform = args.ensureUniqueNodeIds([
+        args.transaction
+    ], docBefore, trackedTransaction.doc);
+    uniqueNodeIdsTransform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    const structureChangesResult = suggestStructureChanges(docBefore, uniqueNodeIdsTransform.doc, args.structuralContextPaths, args.generateId);
+    if (!structureChangesResult.handled || !hasMoveStructureMark(structureChangesResult, movedNodeId)) {
+        return null;
+    }
+    structureChangesResult.transform.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    const intermediateState = EditorState.create({
+        schema: args.state.schema,
+        doc: trackedTransaction.doc
+    });
+    const joinTransaction = intermediateState.tr;
+    try {
+        joinTransaction.step(shape.joinStep);
+    } catch  {
+        return null;
+    }
+    const trackedJoinTransaction = transformToSuggestionTransaction(joinTransaction, intermediateState, args.generateId);
+    trackedJoinTransaction.steps.forEach((step)=>{
+        trackedTransaction.step(step);
+    });
+    preserveTransactionData(trackedTransaction, trackedJoinTransaction, {
+        selection: "currentDocument",
+        preserveScroll: false,
+        preserveStoredMarks: false,
+        preserveMeta: false
+    });
+    preserveTransactionData(trackedTransaction, args.transaction);
+    return trackedTransaction;
+}
+function isTipTapParagraphIntoListJoinShape(shape) {
+    return shape?.type === "tipTapParagraphIntoListJoin";
+}
+function hasMoveStructureMark(structureChangesResult, movedNodeId) {
+    const { structure } = getSuggestionMarks(structureChangesResult.transform.doc.type.schema);
+    let found = false;
+    structureChangesResult.transform.doc.descendants((node)=>{
+        if (getNodeId(node) !== movedNodeId) return true;
+        found = node.marks.some((mark)=>{
+            if (mark.type !== structure) return false;
+            if (!guardStructureMarkAttrs(mark.attrs)) return false;
+            return mark.attrs.data.op.op === "move";
+        });
+        return !found;
+    });
+    return found;
+}

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/index.d.ts

@@ -0,0 +1,2 @@
+export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";

package/dist/features/transactionShaping/tipTapParagraphIntoListJoin/index.js

@@ -0,0 +1,2 @@
+export { detectTipTapParagraphIntoListJoin } from "./detectTipTapParagraphIntoListJoin.js";
+export { handleTipTapParagraphIntoListJoin } from "./handleTipTapParagraphIntoListJoin.js";

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

@@ -0,0 +1,20 @@
+import { type Node, type Schema } from "prosemirror-model";
+import { type EditorState, type Transaction } from "prosemirror-state";
+import { type ReplaceStep, type Transform } from "prosemirror-transform";
+import { type SuggestionId } from "../../generateId.js";
+import { type StructuralContextPath } from "../wrapUnwrap/types.js";
+export interface TipTapParagraphIntoListJoinShape {
+    type: "tipTapParagraphIntoListJoin";
+    deleteStep: ReplaceStep;
+    insertStep: ReplaceStep;
+    joinStep: ReplaceStep;
+    movedNode: Node;
+}
+export type SpecialTransactionShape = TipTapParagraphIntoListJoinShape;
+export interface HandleSpecialTransactionShapeArgs {
+    transaction: Transaction;
+    state: EditorState;
+    generateId: ((schema: Schema, doc?: Node) => SuggestionId) | undefined;
+    structuralContextPaths: StructuralContextPath[] | null;
+    ensureUniqueNodeIds: ((transactions: Transaction[], oldDoc: Node, newDoc: Node) => Transform) | undefined;
+}

package/dist/features/transactionShaping/types.js

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

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

@@ -0,0 +1,2 @@
+import { type Mark } from "prosemirror-model";
+export declare function areEquivalentStructureMarks(a: Mark, b: Mark): boolean;

package/dist/features/wrapUnwrap/areEquivalentStructureMarks.js

@@ -0,0 +1,17 @@
+import { sameParentChain } from "./sameParentChain.js";
+import { guardStructureMarkAttrs } from "./types.js";
+export function areEquivalentStructureMarks(a, b) {
+    if (a.type !== b.type) return false;
+    if (!guardStructureMarkAttrs(a.attrs)) return false;
+    if (!guardStructureMarkAttrs(b.attrs)) return false;
+    const aOp = a.attrs.data.op;
+    const bOp = b.attrs.data.op;
+    if (aOp.op !== bOp.op) return false;
+    if (aOp.op === "add" && bOp.op === "add") {
+        return a.attrs.id === b.attrs.id;
+    }
+    if (aOp.op === "move" && bOp.op === "move") {
+        return sameParentChain(aOp.from, bOp.from) && sameParentChain(aOp.to, bOp.to);
+    }
+    return false;
+}

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

@@ -37,4 +37,9 @@ export type MaterializedPaths = Map<string, {
 }>;
 export declare function guardDocParent(parent: Parent | undefined): parent is DocParent;
 export declare function guardStructureMarkAttrs(attrs: Attrs): attrs is StructureMarkAttrs;
+export interface StructureMarkObject {
+    type: "structure";
+    attrs: StructureMarkAttrs;
+}
+export declare function isStructureMarkObject(mark: unknown): mark is StructureMarkObject;
 export {};

package/dist/features/wrapUnwrap/types.js

@@ -9,3 +9,9 @@ export function guardStructureMarkAttrs(attrs) {
     if (!("op" in data)) return false;
     return true;
 }
+export function isStructureMarkObject(mark) {
+    if (mark === null || typeof mark !== "object") return false;
+    if (!("type" in mark) || mark.type !== "structure") return false;
+    if (!("attrs" in mark)) return false;
+    return guardStructureMarkAttrs(mark.attrs);
+}

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);
@@ -13,9 +15,34 @@ export function generateNextNumberId(schema, doc) {
     // 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 || mark.type === structure);
-        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/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/withSuggestChanges.d.ts

@@ -1,20 +1,10 @@
-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";
 import { type StructuralContextPath } from "./features/wrapUnwrap/types.js";
-/**
- * Given a standard transaction from ProseMirror, produce
- * a new transaction that tracks the changes from the original,
- * 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 { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
  * function with `withSuggestChanges`, or pass no arguments to use the default

package/dist/withSuggestChanges.js

@@ -1,105 +1,15 @@
-import { AddMarkStep, AddNodeMarkStep, AttrStep, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep } from "prosemirror-transform";
-import { trackAddMarkStep } from "./addMarkStep.js";
-import { trackAddNodeMarkStep } from "./addNodeMarkStep.js";
-import { trackAttrStep } from "./attrStep.js";
-import { suggestRemoveMarkStep } from "./removeMarkStep.js";
-import { suggestRemoveNodeMarkStep } from "./removeNodeMarkStep.js";
-import { suggestReplaceAroundStep } from "./replaceAroundStep.js";
-import { suggestReplaceStep } from "./replaceStep.js";
 import { isSuggestChangesEnabled, suggestChangesKey } from "./plugin.js";
-import { generateNextNumberId } from "./generateId.js";
-import { getSuggestionMarks } from "./utils.js";
 import { prependDeletionsWithZWSP } from "./prependDeletionsWithZWSP.js";
 import { getRequiredStructuralContextPaths, suggestStructureChanges } from "./features/wrapUnwrap/structureChangesPlugin.js";
+import { handleSpecialTransactionShape } from "./features/transactionShaping/index.js";
+import { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
+export { transformToSuggestionTransaction } from "./transformToSuggestionTransaction.js";
 const TRACE_ENABLED = true;
 function trace(...args) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!TRACE_ENABLED) return;
     console.log("[withSuggestChanges]", ...args);
 }
-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;
-    };
-}
-/**
- * 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;
-    }
-    if (originalTransaction.selectionSet && !trackedTransaction.selectionSet) {
-        // Map the original selection backwards through the original transaction,
-        // and then forwards through the new one.
-        const originalBaseDoc = originalTransaction.docs[0];
-        const base = originalBaseDoc ? originalTransaction.selection.map(originalBaseDoc, originalTransaction.mapping.invert()) : originalTransaction.selection;
-        trackedTransaction.setSelection(base.map(trackedTransaction.doc, trackedTransaction.mapping));
-    }
-    if (originalTransaction.scrolledIntoView) {
-        trackedTransaction.scrollIntoView();
-    }
-    if (originalTransaction.storedMarksSet) {
-        trackedTransaction.setStoredMarks(originalTransaction.storedMarks);
-    }
-    // @ts-expect-error Preserve original transaction meta exactly as-is
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    trackedTransaction.meta = originalTransaction.meta;
-    return trackedTransaction;
-}
 /**
  * A `dispatchTransaction` decorator. Wrap your existing `dispatchTransaction`
  * function with `withSuggestChanges`, or pass no arguments to use the default
@@ -123,7 +33,14 @@ function getStepHandler(step) {
             const docBefore = transaction.docs[0];
             const structuralContextPaths = opts?.experimental_trackStructureChanges ? getRequiredStructuralContextPaths(opts.experimental_trackStructures) : null;
             const ensureUniqueNodeIds = opts?.experimental_ensureUniqueNodeIds;
-            if (transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
+            const shapedTransaction = transaction.docChanged ? handleSpecialTransactionShape({
+                transaction,
+                state: this.state,
+                generateId,
+                structuralContextPaths,
+                ensureUniqueNodeIds
+            }) : null;
+            if (!shapedTransaction && transaction.docChanged && docBefore && structuralContextPaths && typeof ensureUniqueNodeIds === "function") {
                 trace("trying to track structure changes first...");
                 // after a transaction, some nodes may not yet have unique ids (they were just added, and the unique id plugin has not yet run)
                 // this hook allows to "post-process" the transaction and add the missing ids
@@ -152,7 +69,9 @@ function getStepHandler(step) {
                     trace("applied unique id transform and structure changes transform to the transaction", transaction);
                 }
             }
-            if (transaction.docChanged && structureChangesResult?.handled !== true) {
+            if (shapedTransaction) {
+                transaction = shapedTransaction;
+            } else if (transaction.docChanged && structureChangesResult?.handled !== true) {
                 trace("running the main suggestions plugin...");
                 const perfSuggestions = performance.now();
                 transaction = transformToSuggestionTransaction(tr, this.state, generateId);

package/package.json

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