@kerebron/extension-basic-editor 0.0.6 → 0.0.8

package/esm/extension-automerge/src/SchemaAdapter.js

@@ -0,0 +1,188 @@
+export class SchemaAdapter {
+    constructor(schema) {
+        Object.defineProperty(this, "nodeMappings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "markMappings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "unknownBlock", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "unknownLeaf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "unknownMark", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const nodeMappings = [];
+        const markMappings = [];
+        let unknownBlock = null;
+        for (const [nodeName, nodeSpec] of Object.entries(schema.nodes)) {
+            const adaptSpec = nodeSpec.spec.automerge;
+            if (adaptSpec == null) {
+                continue;
+            }
+            if (adaptSpec.unknownBlock) {
+                if (unknownBlock != null) {
+                    throw new Error('only one node can be marked as unknownBlock');
+                }
+                unknownBlock = schema.nodes[nodeName];
+            }
+            if (adaptSpec.block != null) {
+                const nodeMapping = {
+                    blockName: adaptSpec.block,
+                    content: schema.nodes[nodeName],
+                    isEmbed: adaptSpec.isEmbed || false,
+                };
+                if (adaptSpec.attrParsers != null) {
+                    nodeMapping.attrParsers = adaptSpec.attrParsers;
+                }
+                nodeMappings.push(nodeMapping);
+            }
+        }
+        for (const [markName, markSpec] of Object.entries(schema.marks || {})) {
+            const adaptSpec = markSpec.spec.automerge;
+            if (adaptSpec == null) {
+                continue;
+            }
+            if (adaptSpec.markName != null) {
+                let parsers;
+                if (adaptSpec.parsers != null) {
+                    parsers = adaptSpec.parsers;
+                }
+                else {
+                    parsers = {
+                        fromAutomerge: () => ({}),
+                        fromProsemirror: () => true,
+                    };
+                }
+                markMappings.push({
+                    automergeMarkName: adaptSpec.markName,
+                    prosemirrorMark: schema.marks[markName],
+                    parsers,
+                });
+            }
+        }
+        if (unknownBlock == null) {
+            throw new Error(`no unknown block specified: one node must be marked as the unknownblock
+by setting the automerge.unknownBlock property to true`);
+        }
+        this.unknownMark = schema.marks.unknownMark;
+        this.nodeMappings = nodeMappings;
+        this.markMappings = markMappings;
+        this.unknownLeaf = schema.nodes.unknownLeaf;
+        this.unknownBlock = unknownBlock;
+        this.schema = schema;
+    }
+}
+function shallowClone(spec) {
+    const nodes = {};
+    for (const [nodeName, node] of Object.entries(spec.nodes)) {
+        const shallowCopy = Object.assign({}, node);
+        if (node.attrs != null) {
+            shallowCopy.attrs = Object.assign({}, node.attrs);
+        }
+        nodes[nodeName] = shallowCopy;
+    }
+    const marks = {};
+    if (spec.marks != null) {
+        for (const [markName, mark] of Object.entries(spec.marks)) {
+            const shallowCopy = Object.assign({}, mark);
+            if (mark.attrs != null) {
+                shallowCopy.attrs = Object.assign({}, mark.attrs);
+            }
+            marks[markName] = shallowCopy;
+        }
+    }
+    return { nodes, marks };
+}
+export function addAmgNodeStateAttrs(nodes) {
+    for (const [name, nodeSpec] of Object.entries(nodes)) {
+        if (name !== 'text') {
+            if (nodeSpec.attrs == null) {
+                nodeSpec.attrs = {
+                    isAmgBlock: { default: false },
+                    unknownAttrs: { default: null },
+                };
+            }
+            else {
+                nodeSpec.attrs.isAmgBlock = { default: false };
+                nodeSpec.attrs.unknownAttrs = { default: null };
+            }
+        }
+        if (nodeSpec.automerge?.unknownBlock) {
+            if (nodeSpec.attrs == null) {
+                nodeSpec.attrs = {
+                    unknownParentBlock: { default: null },
+                    unknownBlock: { default: null },
+                };
+            }
+            else {
+                nodeSpec.attrs.unknownParentBlock = { default: null };
+                nodeSpec.attrs.unknownBlock = { default: null };
+            }
+        }
+    }
+    return nodes;
+}
+export function amMarksFromPmMarks(adapter, marks) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = {};
+    marks.forEach((mark) => {
+        const markMapping = adapter.markMappings.find((m) => m.prosemirrorMark === mark.type);
+        if (markMapping != null) {
+            result[markMapping.automergeMarkName] = markMapping.parsers
+                .fromProsemirror(mark);
+        }
+        else if (mark.type === adapter.unknownMark) {
+            for (const [key, value] of Object.entries(mark.attrs.unknownMarks)) {
+                result[key] = value;
+            }
+        }
+    });
+    return result;
+}
+export function pmMarksFromAmMarks(adapter, amMarks) {
+    const unknownMarks = {};
+    let hasUnknownMark = false;
+    const pmMarks = [];
+    for (const [markName, markValue] of Object.entries(amMarks)) {
+        // Filter tombstoned marks (https://github.com/automerge/automerge/issues/715).
+        if (markValue == null)
+            continue;
+        const mapping = adapter.markMappings.find((m) => m.automergeMarkName === markName);
+        if (mapping == null) {
+            unknownMarks[markName] = markValue;
+            hasUnknownMark = true;
+        }
+        else {
+            pmMarks.push(mapping.prosemirrorMark.create(mapping.parsers.fromAutomerge(markValue)));
+        }
+    }
+    if (hasUnknownMark) {
+        pmMarks.push(adapter.unknownMark.create({ unknownMarks }));
+    }
+    return pmMarks;
+}

package/esm/extension-automerge/src/SyncPlugin.d.ts

@@ -0,0 +1,16 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { next as automerge } from '@automerge/automerge/slim';
+import { SchemaAdapter } from './SchemaAdapter.js';
+import { DocHandle, DocHandleChangePayload } from './types.js';
+export declare const syncPluginKey: PluginKey<any>;
+export declare class SyncPlugin<T> extends Plugin {
+    private adapter;
+    private path;
+    ignoreTr: boolean;
+    onAutoMergeChange: (args: DocHandleChangePayload<unknown>) => void;
+    private handle;
+    private view;
+    constructor(adapter: SchemaAdapter, path: automerge.Prop[], handle: DocHandle<T>);
+    changeHandle(handle: DocHandle<any>): void;
+}
+//# sourceMappingURL=SyncPlugin.d.ts.map

package/esm/extension-automerge/src/SyncPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncPlugin.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/SyncPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAa,MAAM,mBAAmB,CAAC;AAGjE,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAI9D,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAG/D,eAAO,MAAM,aAAa,gBAAkC,CAAC;AAE7D,qBAAa,UAAU,CAAC,CAAC,CAAE,SAAQ,MAAM;IAQrC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,IAAI;IARd,QAAQ,UAAS;IACjB,iBAAiB,EAAG,CAAC,IAAI,EAAE,sBAAsB,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IAEpE,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,IAAI,CAAc;gBAGhB,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,EAC9B,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAiGtB,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC;CAwCpC"}

package/esm/extension-automerge/src/SyncPlugin.js

@@ -0,0 +1,147 @@
+import { Plugin, PluginKey, Selection } from 'prosemirror-state';
+import { ChangeSet } from 'prosemirror-changeset';
+import { next as automerge } from '@automerge/automerge/slim';
+import { pmToAm } from './pmToAm.js';
+import { amToPm } from './amToPm.js';
+import { amSpansToDoc } from './amTraversal.js';
+import { isArrayEqual } from './utils.js';
+export const syncPluginKey = new PluginKey('automerge-sync');
+export class SyncPlugin extends Plugin {
+    constructor(adapter, path, handle) {
+        super({
+            key: syncPluginKey,
+            view: (view) => {
+                this.view = view;
+                this.changeHandle(handle);
+                return {
+                    destroy: () => {
+                        if (this.handle) {
+                            this.handle.off('change', this.onAutoMergeChange);
+                        }
+                    },
+                };
+            },
+            appendTransaction(transactions, oldState, state) {
+                if (this.ignoreTr)
+                    return;
+                transactions = transactions.filter((tx) => tx.docChanged);
+                if (transactions.length === 0)
+                    return undefined;
+                //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const docBefore = this.handle.docSync();
+                const headsBefore = automerge.getHeads(docBefore);
+                const spansBefore = automerge.spans(docBefore, path);
+                // Apply transactions to the automerge doc
+                this.ignoreTr = true;
+                this.handle.change((doc) => {
+                    for (const tx of transactions) {
+                        const spans = automerge.spans(doc, path);
+                        pmToAm(adapter, spans, tx.steps, doc, tx.docs[0], path);
+                    }
+                });
+                this.ignoreTr = false;
+                //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const docAfter = this.handle.docSync();
+                const headsAfter = automerge.getHeads(docAfter);
+                const spansAfter = automerge.spans(docAfter, path);
+                // Ignore if nothing changed.
+                if (isArrayEqual(headsBefore, headsAfter))
+                    return undefined;
+                // Check if ProseMirror doc matches the AutoMerge doc
+                // by comparing changesets between the two transactions.
+                const patches = automerge.diff(docAfter, headsBefore, headsAfter);
+                const tx = amToPm(adapter, spansBefore, patches, path, oldState.tr);
+                let amChangeSet = ChangeSet.create(oldState.doc);
+                amChangeSet = amChangeSet.addSteps(oldState.doc, tx.mapping.maps, undefined);
+                let pmChangeSet = ChangeSet.create(oldState.doc);
+                for (const tr of transactions) {
+                    pmChangeSet = pmChangeSet.addSteps(tr.docs[0], tr.mapping.maps, undefined);
+                }
+                const diff = pmChangeSet.changedRange(amChangeSet);
+                if (!diff || diff.from === diff.to)
+                    return undefined;
+                console.warn("Warning: ProseMirror doc doesn't match AutoMerge spans.\n\n" +
+                    'State will be automatically fixed with a tr. File an issue at https://github.com/automerge/automerge-repo.\n', {
+                    spansBefore,
+                    steps: transactions.map((tr) => tr.steps.map((s) => s.toJSON())),
+                });
+                // Replace the diff range in ProseMirror doc from the AutoMerge doc.
+                const doc = amSpansToDoc(adapter, spansAfter);
+                const slice = doc.slice(diff.from, diff.to);
+                const tr = state.tr;
+                tr.replace(diff.from, diff.to, slice);
+                try {
+                    tr.setSelection(Selection.fromJSON(tr.doc, state.selection.toJSON()));
+                }
+                catch (e) {
+                    if (e instanceof RangeError) {
+                        // Sometimes the selection can't be mapped for some reason, so we just give up and hope for the best
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+                tr.setStoredMarks(state.storedMarks);
+                return tr;
+            },
+        });
+        Object.defineProperty(this, "adapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: adapter
+        });
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: path
+        });
+        Object.defineProperty(this, "ignoreTr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "onAutoMergeChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "handle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "view", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    changeHandle(handle) {
+        if (!this.view) {
+            return;
+        }
+        if (this.handle) {
+            this.handle.off('change', this.onAutoMergeChange);
+        }
+        const onAutoMergeChange = ({ doc, patches, patchInfo, }) => {
+            if (this.ignoreTr)
+                return;
+            const headsBefore = automerge.getHeads(patchInfo.before);
+            const spans = automerge.spans(automerge.view(doc, headsBefore), this.path);
+            const tr = amToPm(this.adapter, spans, patches, this.path, this.view.state.tr);
+            tr.setMeta('addToHistory', false); // remote changes should not be added to local stack
+            this.ignoreTr = true;
+            this.view.dispatch(tr);
+            this.ignoreTr = false;
+        };
+        this.onAutoMergeChange = onAutoMergeChange;
+        handle.on('change', this.onAutoMergeChange);
+        this.handle = handle;
+    }
+}

package/esm/extension-automerge/src/amToPm.d.ts

@@ -0,0 +1,9 @@
+import { next as automerge, Patch, type Prop } from '@automerge/automerge/slim';
+import { Transaction } from 'prosemirror-state';
+import { SchemaAdapter } from './SchemaAdapter.js';
+type SpliceTextPatch = automerge.SpliceTextPatch;
+export declare function amToPm(adapter: SchemaAdapter, spansAtStart: automerge.Span[], patches: Array<Patch>, path: Prop[], tx: Transaction): Transaction;
+export declare function handleSplice(adapter: SchemaAdapter, spans: automerge.Span[], patch: SpliceTextPatch, path: Prop[], tx: Transaction): Transaction;
+export declare function handleBlockChange(adapter: SchemaAdapter, atPath: automerge.Prop[], spans: automerge.Span[], _blockIdx: number, patches: automerge.Patch[], tx: Transaction): Transaction;
+export {};
+//# sourceMappingURL=amToPm.d.ts.map

package/esm/extension-automerge/src/amToPm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amToPm.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/amToPm.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,IAAI,IAAI,SAAS,EACjB,KAAK,EACL,KAAK,IAAI,EACV,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMhD,OAAO,EAAsB,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEvE,KAAK,eAAe,GAAG,SAAS,CAAC,eAAe,CAAC;AAQjD,wBAAgB,MAAM,CACpB,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,SAAS,CAAC,IAAI,EAAE,EAC9B,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,EACrB,IAAI,EAAE,IAAI,EAAE,EACZ,EAAE,EAAE,WAAW,GACd,WAAW,CA0Cb;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,IAAI,EAAE,EACZ,EAAE,EAAE,WAAW,GACd,WAAW,CAQb;AAkDD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,EACxB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,SAAS,CAAC,KAAK,EAAE,EAC1B,EAAE,EAAE,WAAW,GACd,WAAW,CA0Cb"}

package/esm/extension-automerge/src/amToPm.js

@@ -0,0 +1,245 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { ReplaceStep } from 'prosemirror-transform';
+import { amSpansToDoc, amSpliceIdxToPmIdx } from './amTraversal.js';
+import { findBlockAtCharIdx, patchSpans } from './maintainSpans.js';
+import { isArrayEqual, isPrefixOfArray } from './utils.js';
+import { pmMarksFromAmMarks } from './SchemaAdapter.js';
+export function amToPm(adapter, spansAtStart, patches, path, tx) {
+    const gathered = gatherPatches(path, patches);
+    for (const patchGroup of gathered) {
+        if (patchGroup.type === 'text') {
+            for (const patch of patchGroup.patches) {
+                if (patch.action === 'splice') {
+                    tx = handleSplice(adapter, spansAtStart, patch, path, tx);
+                    patchSpans(path, spansAtStart, patch);
+                }
+                else if (patch.action === 'del') {
+                    const patchIndex = patch.path[patch.path.length - 1];
+                    const block = findBlockAtCharIdx(spansAtStart, patchIndex);
+                    if (block != null) {
+                        tx = handleBlockChange(adapter, path, spansAtStart, patchIndex, [patch], tx);
+                    }
+                    else {
+                        tx = handleDelete(adapter, spansAtStart, patch, path, tx);
+                    }
+                    patchSpans(path, spansAtStart, patch);
+                }
+                else if (patch.action === 'mark') {
+                    tx = handleMark(adapter, spansAtStart, patch, path, tx);
+                    patchSpans(path, spansAtStart, patch);
+                }
+            }
+        }
+        else {
+            tx = handleBlockChange(adapter, path, spansAtStart, patchGroup.index, patchGroup.patches, tx);
+        }
+    }
+    return tx;
+}
+export function handleSplice(adapter, spans, patch, path, tx) {
+    const index = charPath(path, patch.path);
+    if (index === null)
+        return tx;
+    const pmIdx = amSpliceIdxToPmIdx(adapter, spans, index);
+    if (pmIdx == null)
+        throw new Error('Invalid index');
+    const content = patchContentToFragment(adapter, patch.value, patch.marks);
+    tx = tx.step(new ReplaceStep(pmIdx, pmIdx, new Slice(content, 0, 0)));
+    return tx;
+}
+function handleDelete(adapter, spans, patch, path, tx) {
+    const index = charPath(path, patch.path);
+    if (index === null)
+        return tx;
+    const start = amSpliceIdxToPmIdx(adapter, spans, index);
+    if (start == null)
+        throw new Error('Invalid index');
+    const end = start + (patch.length || 1);
+    return tx.delete(start, end);
+}
+function handleMark(adapter, spans, patch, path, tx) {
+    if (isArrayEqual(patch.path, path)) {
+        for (const mark of patch.marks) {
+            const pmStart = amSpliceIdxToPmIdx(adapter, spans, mark.start);
+            const pmEnd = amSpliceIdxToPmIdx(adapter, spans, mark.end);
+            if (pmStart == null || pmEnd == null)
+                throw new Error('Invalid index');
+            if (mark.value == null) {
+                const markMapping = adapter.markMappings.find((m) => m.automergeMarkName === mark.name);
+                const markType = markMapping
+                    ? markMapping.prosemirrorMark
+                    : adapter.unknownMark;
+                tx = tx.removeMark(pmStart, pmEnd, markType);
+            }
+            else {
+                const pmMarks = pmMarksFromAmMarks(adapter, {
+                    [mark.name]: mark.value,
+                });
+                for (const pmMark of pmMarks) {
+                    tx = tx.addMark(pmStart, pmEnd, pmMark);
+                }
+            }
+        }
+    }
+    return tx;
+}
+export function handleBlockChange(adapter, atPath, spans, _blockIdx, patches, tx) {
+    for (const patch of patches) {
+        patchSpans(atPath, spans, patch);
+    }
+    const docAfter = amSpansToDoc(adapter, spans);
+    const change = findDiff(tx.doc.content, docAfter.content);
+    if (change == null)
+        return tx;
+    const $from = docAfter.resolve(change.start);
+    const $to = docAfter.resolve(change.endB);
+    const $fromA = tx.doc.resolve(change.start);
+    const inlineChange = $from.sameParent($to) &&
+        $from.parent.inlineContent &&
+        $fromA.end() >= change.endA;
+    const chFrom = change.start;
+    const chTo = change.endA;
+    let handledByInline = false;
+    if (inlineChange) {
+        if ($from.pos == $to.pos) {
+            // Deletion
+            handledByInline = true;
+            tx = tx.delete(chFrom, chTo);
+        }
+        else if ($from.parent.child($from.index()).isText &&
+            $from.index() == $to.index() - ($to.textOffset ? 0 : 1)) {
+            handledByInline = true;
+            // Both positions in the same text node -- simply insert text
+            const text = $from.parent.textBetween($from.parentOffset, $to.parentOffset);
+            tx = tx.insertText(text, chFrom, chTo);
+        }
+    }
+    if (!handledByInline) {
+        tx = tx.replace(chFrom, chTo, docAfter.slice(change.start, change.endB));
+    }
+    return tx;
+}
+function findDiff(a, b) {
+    let start = a.findDiffStart(b);
+    if (start == null)
+        return null;
+    //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    let { a: endA, b: endB } = a.findDiffEnd(b);
+    if (endA < start && a.size < b.size) {
+        if (start &&
+            start < b.size &&
+            isSurrogatePair(b.textBetween(start - 1, start + 1))) {
+            start -= 1;
+        }
+        endB = start + (endB - endA);
+        endA = start;
+    }
+    else if (endB < start) {
+        if (start &&
+            start < a.size &&
+            isSurrogatePair(a.textBetween(start - 1, start + 1))) {
+            start -= 1;
+        }
+        endA = start + (endA - endB);
+        endB = start;
+    }
+    return { start, endA, endB };
+}
+function isSurrogatePair(str) {
+    if (str.length != 2)
+        return false;
+    const a = str.charCodeAt(0), b = str.charCodeAt(1);
+    return a >= 0xdc00 && a <= 0xdfff && b >= 0xd800 && b <= 0xdbff;
+}
+// If the path of the patch is of the form [path, <index>] then we know this is
+// a path to a character within the sequence given by path
+function charPath(textPath, candidatePath) {
+    if (candidatePath.length !== textPath.length + 1)
+        return null;
+    for (let i = 0; i < textPath.length; i++) {
+        if (textPath[i] !== candidatePath[i])
+            return null;
+    }
+    const index = candidatePath[candidatePath.length - 1];
+    if (typeof index === 'number')
+        return index;
+    return null;
+}
+function patchContentToFragment(adapter, patchContent, marks) {
+    let pmMarks = undefined;
+    if (marks != null) {
+        pmMarks = pmMarksFromAmMarks(adapter, marks);
+    }
+    // Splice is only ever called once a block has already been created so we're
+    // only inserting text. This means we don't have to think about openStart
+    // and openEnd
+    return Fragment.from(adapter.schema.text(patchContent, pmMarks));
+}
+function gatherPatches(textPath, diff) {
+    const result = [];
+    let state = { type: 'gatheringText', gathered: [] };
+    function flush() {
+        if (state.type === 'gatheringBlock') {
+            result.push({
+                type: 'block',
+                index: state.index,
+                patches: state.gathered,
+            });
+        }
+        else if (state.type === 'gatheringText') {
+            result.push({ type: 'text', patches: state.gathered });
+        }
+        state = { type: 'transitioning' };
+    }
+    for (const patch of diff) {
+        if (!isPrefixOfArray(textPath, patch.path)) {
+            continue;
+        }
+        if (isArrayEqual(textPath, patch.path) && patch.action === 'mark') {
+            if (state.type === 'gatheringText') {
+                state.gathered.push(patch);
+            }
+            else {
+                flush();
+                state = { type: 'gatheringText', gathered: [patch] };
+            }
+        }
+        else if (patch.path.length === textPath.length + 1) {
+            const lastElem = patch.path[patch.path.length - 1];
+            if (typeof lastElem === 'number') {
+                if (patch.action === 'splice' || patch.action === 'del') {
+                    if (state.type === 'gatheringText') {
+                        state.gathered.push(patch);
+                    }
+                    else {
+                        flush();
+                        state = { type: 'gatheringText', gathered: [patch] };
+                    }
+                }
+                else if (patch.action === 'insert') {
+                    flush();
+                    state = {
+                        type: 'gatheringBlock',
+                        index: lastElem,
+                        gathered: [patch],
+                    };
+                }
+            }
+        }
+        else {
+            const index = patch.path[textPath.length];
+            if (typeof index !== 'number') {
+                continue;
+            }
+            if (state.type === 'gatheringBlock' && state.index === index) {
+                state.gathered.push(patch);
+            }
+            else {
+                flush();
+                state = { type: 'gatheringBlock', index: index, gathered: [patch] };
+            }
+        }
+    }
+    flush();
+    return result;
+}

package/esm/extension-automerge/src/amTraversal.d.ts

@@ -0,0 +1,62 @@
+import { next as automerge } from '@automerge/automerge/slim';
+import { Node } from 'prosemirror-model';
+import { BlockMarker } from './types.js';
+import { SchemaAdapter } from './SchemaAdapter.js';
+type RenderRole = 'explicit' | 'render-only';
+export type TraversalEvent = {
+    type: 'openTag';
+    tag: string;
+    role: RenderRole;
+    attrs?: {
+        [key: string]: any;
+    };
+} | {
+    type: 'closeTag';
+    tag: string;
+    role: RenderRole;
+} | {
+    type: 'leafNode';
+    tag: string;
+    role: RenderRole;
+} | {
+    type: 'text';
+    text: string;
+    marks: automerge.MarkSet;
+} | {
+    type: 'block';
+    isUnknown?: boolean;
+    block: {
+        type: string;
+        parents: string[];
+        attrs: {
+            [key: string]: automerge.MaterializeValue;
+        };
+        isEmbed: boolean;
+    };
+};
+/**
+ * Convert an array of AutoMerge spans into a ProseMirror doc.
+ * @param adapter
+ * @param spans
+ * @returns
+ */
+export declare function amSpansToDoc(adapter: SchemaAdapter, spans: automerge.Span[]): Node;
+export declare function amSpliceIdxToPmIdx(adapter: SchemaAdapter, spans: automerge.Span[], target: number): number | null;
+export declare function amIdxToPmBlockIdx(adapter: SchemaAdapter, spans: automerge.Span[], target: number): number | null;
+type Indexes = {
+    amIdx: number;
+    pmIdx: number;
+};
+export declare function eventsWithIndexChanges(events: IterableIterator<TraversalEvent>): IterableIterator<{
+    event: TraversalEvent;
+    before: Indexes;
+    after: Indexes;
+}>;
+export declare function traverseNode(adapter: SchemaAdapter, node: Node): IterableIterator<TraversalEvent>;
+export declare function traverseSpans(adapter: SchemaAdapter, amSpans: automerge.Span[]): IterableIterator<TraversalEvent>;
+export declare function blockAtIdx(spans: automerge.Span[], target: number): {
+    index: number;
+    block: BlockMarker;
+} | null;
+export {};
+//# sourceMappingURL=amTraversal.d.ts.map

package/esm/extension-automerge/src/amTraversal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"amTraversal.d.ts","sourceRoot":"","sources":["../../../src/extension-automerge/src/amTraversal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAGL,IAAI,EAGL,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAgB,WAAW,EAAiB,MAAM,YAAY,CAAC;AACtE,OAAO,EAIL,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,KAAK,UAAU,GAAG,UAAU,GAAG,aAAa,CAAC;AAO7C,MAAM,MAAM,cAAc,GACtB;IACA,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,UAAU,CAAC;IAEjB,KAAK,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;CAChC,GACC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACnD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAA;CAAE,GACxD;IACA,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,gBAAgB,CAAA;SAAE,CAAC;QACrD,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC;CACH,CAAC;AAEJ;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,GACtB,IAAI,CAyDN;AAqCD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CAyBf;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,IAAI,CA4Bf;AAED,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wBAAiB,sBAAsB,CACrC,MAAM,EAAE,gBAAgB,CAAC,cAAc,CAAC,GACvC,gBAAgB,CAAC;IAClB,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC,CA2BD;AAED,wBAAiB,YAAY,CAC3B,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,IAAI,GACT,gBAAgB,CAAC,cAAc,CAAC,CA4ElC;AAwPD,wBAAiB,aAAa,CAC5B,OAAO,EAAE,aAAa,EACtB,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE,GACxB,gBAAgB,CAAC,cAAc,CAAC,CAkBlC;AAmOD,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,EACvB,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,CAoB9C"}