@manuscripts/track-changes-plugin 2.0.12 → 2.1.0

package/dist/cjs/steps/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+/*!
+ * © 2023 Atypon Systems LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStructureSteps = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = void 0;
+exports.stepIsLift = stepIsLift;
+const prosemirror_transform_1 = require("prosemirror-transform");
+const actions_1 = require("../actions");
+const isSplitStep = (step, selection, uiEvent) => {
+    var _a, _b, _c, _d;
+    const { from, to, slice } = step;
+    if (from !== to ||
+        slice.content.childCount < 2 ||
+        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
+        return false;
+    }
+    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
+    const parentSize = $from.node().content.size;
+    if (uiEvent === 'paste') {
+        return !((startOffset === 0 && endOffset === 0) ||
+            (startOffset === parentSize && endOffset === parentSize));
+    }
+    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
+    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
+        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
+        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
+    }
+    return (openStart === openEnd &&
+        firstChild.type === lastChild.type &&
+        firstChild.inlineContent &&
+        lastChild.inlineContent &&
+        !(startOffset === parentSize && endOffset === parentSize));
+};
+exports.isSplitStep = isSplitStep;
+const isWrapStep = (step) => step.from === step.gapFrom &&
+    step.to === step.gapTo &&
+    step.slice.openStart === 0 &&
+    step.slice.openEnd === 0;
+exports.isWrapStep = isWrapStep;
+const isLiftStep = (step) => {
+    if (step.from < step.gapFrom &&
+        step.to > step.gapTo &&
+        step.slice.size === 0 &&
+        step.gapTo - step.gapFrom > 0) {
+        return true;
+    }
+    return false;
+};
+exports.isLiftStep = isLiftStep;
+function stepIsLift(gap, node, to) {
+    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
+}
+const isStructureSteps = (tr) => tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction) &&
+    tr.steps.length === 2 &&
+    tr.steps[0] instanceof prosemirror_transform_1.ReplaceStep &&
+    tr.steps[1] instanceof prosemirror_transform_1.ReplaceStep;
+exports.isStructureSteps = isStructureSteps;

package/dist/cjs/utils/track-utils.js

@@ -11,7 +11,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateBlockNodesAttrs = exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = exports.isStructureSteps = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = void 0;
+exports.updateBlockNodesAttrs = exports.filterMeaninglessMoveSteps = exports.handleDirectPendingMoveDeletions = exports.isDirectPendingMoveDeletion = exports.isDeletingPendingMovedNode = exports.isPendingChange = exports.HasMoveOperations = exports.trFromHistory = void 0;
 exports.createNewInsertAttrs = createNewInsertAttrs;
 exports.createNewWrapAttrs = createNewWrapAttrs;
 exports.createNewSplitAttrs = createNewSplitAttrs;
@@ -20,7 +20,9 @@ exports.createNewDeleteAttrs = createNewDeleteAttrs;
 exports.createNewMoveAttrs = createNewMoveAttrs;
 exports.createNewUpdateAttrs = createNewUpdateAttrs;
 exports.createNewStructureAttrs = createNewStructureAttrs;
-exports.stepIsLift = stepIsLift;
+exports.isValidTrackableMark = isValidTrackableMark;
+exports.excludeFromTracked = excludeFromTracked;
+exports.isInlineMarkChange = isInlineMarkChange;
 const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_transform_1 = require("prosemirror-transform");
 const actions_1 = require("../actions");
@@ -51,55 +53,6 @@ function createNewUpdateAttrs(attrs, oldAttrs) {
 function createNewStructureAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.structure });
 }
-const isSplitStep = (step, selection, uiEvent) => {
-    var _a, _b, _c, _d;
-    const { from, to, slice } = step;
-    if (from !== to ||
-        slice.content.childCount < 2 ||
-        (((_a = slice.content.firstChild) === null || _a === void 0 ? void 0 : _a.isInline) && ((_b = slice.content.lastChild) === null || _b === void 0 ? void 0 : _b.isInline))) {
-        return false;
-    }
-    const { $anchor: { parentOffset: startOffset }, $head: { parentOffset: endOffset }, $from, } = selection;
-    const parentSize = $from.node().content.size;
-    if (uiEvent === 'paste') {
-        return !((startOffset === 0 && endOffset === 0) ||
-            (startOffset === parentSize && endOffset === parentSize));
-    }
-    const { content: { firstChild, lastChild }, openStart, openEnd, } = slice;
-    if ((((_c = window.event) === null || _c === void 0 ? void 0 : _c.code) === 'Enter' || ((_d = window.event) === null || _d === void 0 ? void 0 : _d.code) === 'NumpadEnter') &&
-        (firstChild === null || firstChild === void 0 ? void 0 : firstChild.type.name) === 'list_item') {
-        return !(parentSize === startOffset && parentSize === endOffset) && (lastChild === null || lastChild === void 0 ? void 0 : lastChild.type.name) === 'list_item';
-    }
-    return (openStart === openEnd &&
-        firstChild.type === lastChild.type &&
-        firstChild.inlineContent &&
-        lastChild.inlineContent &&
-        !(startOffset === parentSize && endOffset === parentSize));
-};
-exports.isSplitStep = isSplitStep;
-const isWrapStep = (step) => step.from === step.gapFrom &&
-    step.to === step.gapTo &&
-    step.slice.openStart === 0 &&
-    step.slice.openEnd === 0;
-exports.isWrapStep = isWrapStep;
-const isLiftStep = (step) => {
-    if (step.from < step.gapFrom &&
-        step.to > step.gapTo &&
-        step.slice.size === 0 &&
-        step.gapTo - step.gapFrom > 0) {
-        return true;
-    }
-    return false;
-};
-exports.isLiftStep = isLiftStep;
-function stepIsLift(gap, node, to) {
-    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
-}
-const isStructureSteps = (tr) => tr.getMeta(actions_1.TrackChangesAction.structuralChangeAction) &&
-    tr.steps.length === 2 &&
-    tr.steps[0] instanceof prosemirror_transform_1.ReplaceStep &&
-    tr.steps[1] instanceof prosemirror_transform_1.ReplaceStep;
-exports.isStructureSteps = isStructureSteps;
 const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 exports.trFromHistory = trFromHistory;
 const HasMoveOperations = (tr) => {
@@ -260,3 +213,27 @@ const updateBlockNodesAttrs = (fragment, predicate) => {
     return prosemirror_model_1.Fragment.fromArray(updatedNodes);
 };
 exports.updateBlockNodesAttrs = updateBlockNodesAttrs;
+function isValidTrackableMark(mark) {
+    var _a, _b;
+    const spec = mark.type.spec;
+    const name = mark.type.name;
+    if (!name.startsWith('tracked_') &&
+        ((_a = spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) &&
+        typeof ((_b = spec.attrs) === null || _b === void 0 ? void 0 : _b.dataTracked) === 'object') {
+        return true;
+    }
+    return false;
+}
+function excludeFromTracked(dataTracked, changeIdToExclude) {
+    if (!dataTracked) {
+        return null;
+    }
+    const newDataTracked = dataTracked.filter((c) => c.id !== changeIdToExclude);
+    return newDataTracked.length ? newDataTracked : null;
+}
+function isInlineMarkChange(change) {
+    if (change.type == 'mark-change') {
+        return change.nodeType.isInline || change.nodeType.isText;
+    }
+    return false;
+}

package/dist/cjs/utils/uuidv4.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.uuidv4 = uuidv4;
 function uuidv4() {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
         const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
         return v.toString(16);

package/dist/es/ChangeSet.js

@@ -12,6 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ChangeSet_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
 import { CHANGE_OPERATION, CHANGE_STATUS, } from './types/change';
 import { log } from './utils/logger';
+import { isInlineMarkChange } from './utils/track-utils';
 export class ChangeSet {
     constructor(changes = []) {
         _ChangeSet_instances.add(this);
@@ -147,19 +148,34 @@ export class ChangeSet {
             }
         }
     }
+    areMatchingWrapOperations(c1, c2) {
+        const op1 = c1.dataTracked.operation;
+        const op2 = c2.dataTracked.operation;
+        return ((op1 === 'wrap_with_node' && (op2 === 'insert' || op2 === 'set_attrs')) ||
+            (op2 === 'wrap_with_node' && (op1 === 'insert' || op1 === 'set_attrs')));
+    }
+    areMatchingMarkOperations(c1, c2) {
+        if (ChangeSet.isMarkChange(c1) && ChangeSet.isMarkChange(c2)) {
+            const op1 = c1.dataTracked.operation;
+            const op2 = c2.dataTracked.operation;
+            if (op1 == op2 && c1.mark.type === c2.mark.type) {
+                return true;
+            }
+        }
+        return false;
+    }
     canJoinAdjacentInlineChanges(change, index) {
         const nextChange = this.changeTree.at(index + 1);
-        const isInline = (c) => c.type === 'text-change' || (c.type === 'node-change' && c.node.isInline);
-        const hasMatchingOperation = (c1, c2) => c1.dataTracked.operation === c2.dataTracked.operation ||
-            (c1.dataTracked.operation === 'wrap_with_node' &&
-                (c2.dataTracked.operation === 'insert' || c2.dataTracked.operation === 'set_attrs')) ||
-            (c2.dataTracked.operation === 'wrap_with_node' &&
-                (c1.dataTracked.operation === 'insert' || c1.dataTracked.operation === 'set_attrs'));
+        if (!nextChange) {
+            return false;
+        }
+        const isInline = (c) => c.type === 'text-change' || (c.type === 'node-change' && c.node.isInline) || isInlineMarkChange(c);
         return (isInline(change) &&
-            nextChange &&
             isInline(nextChange) &&
             change.to === nextChange.from &&
-            hasMatchingOperation(change, nextChange));
+            (change.dataTracked.operation === nextChange.dataTracked.operation ||
+                this.areMatchingWrapOperations(change, nextChange) ||
+                this.areMatchingMarkOperations(change, nextChange)));
     }
     joinRelatedStructuralChanges(rootNodes, change) {
         if (change.dataTracked.operation !== CHANGE_OPERATION.structure) {
@@ -210,6 +226,9 @@ export class ChangeSet {
     static isTextChange(change) {
         return change.type === 'text-change';
     }
+    static isMarkChange(change) {
+        return change.type === 'mark-change';
+    }
     static isNodeChange(change) {
         return change.type === 'node-change';
     }

package/dist/es/changes/applyChanges.js

@@ -1,9 +1,10 @@
 import { Mapping } from 'prosemirror-transform';
 import { ChangeSet } from '../ChangeSet';
-import { deleteNode, keepDeleteWithMoveNodeId } from '../mutate/deleteNode';
+import { deleteNode, keepPairedChanges } from '../mutate/deleteNode';
 import { mergeNode } from '../mutate/mergeNode';
 import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
 import { log } from '../utils/logger';
+import { excludeFromTracked, isInlineMarkChange } from '../utils/track-utils';
 import { revertSplitNodeChange, revertWrapNodeChange } from './revertChange';
 import { restoreNode, updateChangeChildrenAttributes } from './updateChangeAttrs';
 function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
@@ -21,13 +22,6 @@ function collectMoveNodeIds(containerNode, primaryMoveNodeId) {
     });
     return moveNodeIds;
 }
-export function getUpdatedDataTracked(dataTracked, changeId) {
-    if (!dataTracked) {
-        return null;
-    }
-    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
-    return newDataTracked.length ? newDataTracked : null;
-}
 export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, deleteMap = new Mapping()) {
     changes.sort((c1, c2) => {
         if ((c1.type === 'node-change' && c1.node.type === schema.nodes.list) ||
@@ -71,7 +65,7 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet.isNodeChange(change) && noChangeNeeded) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: keepDeleteWithMoveNodeId(node) });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: keepPairedChanges(node) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             if (node.isAtom) {
                 tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
@@ -87,13 +81,34 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
         else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === CHANGE_STATUS.accepted) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.newAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.newAttrs), { dataTracked: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === CHANGE_STATUS.rejected) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.oldAttrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, change.oldAttrs), { dataTracked: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
         }
         else if (ChangeSet.isReferenceChange(change)) {
-            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }), node.marks);
+            tr.setNodeMarkup(from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: excludeFromTracked(node.attrs.dataTracked, change.id) }), node.marks);
+        }
+        else if (ChangeSet.isMarkChange(change)) {
+            const newMark = change.mark.type.create({
+                dataTracked: excludeFromTracked(change.mark.attrs.dataTracked, change.id),
+            });
+            const isInsert = change.dataTracked.operation === CHANGE_OPERATION.insert;
+            const isDelete = change.dataTracked.operation === CHANGE_OPERATION.delete;
+            const toBeRestored = (change.dataTracked.status === CHANGE_STATUS.accepted && isInsert) ||
+                (change.dataTracked.status === CHANGE_STATUS.rejected && isDelete);
+            if (isInlineMarkChange(change)) {
+                tr.removeMark(change.from, change.to, change.mark);
+                if (toBeRestored) {
+                    tr.addMark(change.from, change.to, newMark);
+                }
+            }
+            else {
+                tr.removeNodeMark(change.from, change.mark);
+                if (toBeRestored) {
+                    tr.addNodeMark(change.from, newMark);
+                }
+            }
         }
     });
     changes.forEach((change) => {
@@ -110,7 +125,7 @@ export function applyAcceptedRejectedChanges(tr, schema, changes, changeSet, del
             return;
         }
         if (change.dataTracked.status === CHANGE_STATUS.accepted) {
-            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) });
+            const attrs = Object.assign(Object.assign({}, node.attrs), { dataTracked: excludeFromTracked(node.attrs.dataTracked, change.id) });
             tr.setNodeMarkup(from, undefined, attrs, node.marks);
             const originalChanges = changeSet.changes.filter((c) => c.dataTracked.moveNodeId === change.dataTracked.moveNodeId &&
                 c.dataTracked.operation === CHANGE_OPERATION.delete);

package/dist/es/changes/findChanges.js

@@ -1,11 +1,27 @@
 import { ChangeSet } from '../ChangeSet';
-import { getNodeTrackedData } from '../compute/nodeHelpers';
+import { getMarkTrackedData, getNodeTrackedData } from '../compute/nodeHelpers';
 import { CHANGE_OPERATION, } from '../types/change';
 export function findChanges(state) {
     const changes = [];
     let current;
     state.doc.descendants((node, pos) => {
         const tracked = getNodeTrackedData(node, state.schema) || [];
+        const marksWithTrackChanges = getMarkTrackedData(node);
+        marksWithTrackChanges === null || marksWithTrackChanges === void 0 ? void 0 : marksWithTrackChanges.forEach((trackAttrs, mark) => {
+            trackAttrs.forEach((c) => {
+                const ch = {
+                    id: c.id,
+                    type: 'mark-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked: Object.assign({}, c),
+                    nodeType: node.type,
+                    node: node,
+                    mark: mark,
+                };
+                changes.push(ch);
+            });
+        });
         for (let i = 0; i < tracked.length; i += 1) {
             const dataTracked = tracked[i];
             const id = dataTracked.id || '';

package/dist/es/changes/revertChange.js

@@ -1,7 +1,7 @@
 import { Slice } from 'prosemirror-model';
 import { liftTarget, ReplaceAroundStep } from 'prosemirror-transform';
 import { getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { getUpdatedDataTracked } from './applyChanges';
+import { excludeFromTracked } from '../utils/track-utils';
 export function revertSplitNodeChange(tr, change, changeSet) {
     const sourceChange = changeSet.changes.find((c) => c.dataTracked.operation === 'reference' && c.dataTracked.referenceId === change.id);
     const node = tr.doc.nodeAt(tr.mapping.map(change.from));
@@ -20,7 +20,7 @@ export function revertSplitNodeChange(tr, change, changeSet) {
     const deleteChange = changeSet.changes.find((c) => c.dataTracked.operation == 'delete' && c.from === sourceChange.from);
     if (deleteChange) {
         const node = tr.doc.nodeAt(tr.mapping.map(deleteChange.from));
-        tr.setNodeMarkup(tr.mapping.map(deleteChange.from), undefined, getUpdatedDataTracked(node.attrs.dataTracked, deleteChange.id));
+        tr.setNodeMarkup(tr.mapping.map(deleteChange.from), undefined, excludeFromTracked(node.attrs.dataTracked, deleteChange.id));
     }
 }
 export function revertWrapNodeChange(tr, change, deleteMap) {

package/dist/es/changes/updateChangeAttrs.js

@@ -2,6 +2,7 @@ import { ChangeSet } from '../ChangeSet';
 import { getBlockInlineTrackedData, getTextNodeTrackedMarkData } from '../compute/nodeHelpers';
 import { CHANGE_OPERATION, CHANGE_STATUS, } from '../types/change';
 import { log } from '../utils/logger';
+import { isInlineMarkChange } from '../utils/track-utils';
 export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
@@ -64,6 +65,32 @@ export function updateChangeAttrs(tr, change, trackedAttrs, schema) {
             .filter(Boolean);
         tr.setNodeMarkup(change.from, undefined, Object.assign(Object.assign({}, (restoredAttrs || node.attrs)), { dataTracked: newDataTracked.length === 0 ? null : newDataTracked }), node.marks);
     }
+    else if (change.type === 'mark-change') {
+        const markChange = change;
+        if (markChange.mark && markChange.from && markChange.to) {
+            const markDataTracked = Array.isArray(markChange.mark.attrs.dataTracked)
+                ? markChange.mark.attrs.dataTracked
+                : [];
+            const newDT = markDataTracked === null || markDataTracked === void 0 ? void 0 : markDataTracked.map((dt) => {
+                if (dt.createdAt === change.dataTracked.createdAt && dt.operation === change.dataTracked.operation) {
+                    return Object.assign(Object.assign({}, dt), trackedAttrs);
+                }
+                return dt;
+            });
+            const newMark = markChange.mark.type.create(Object.assign(Object.assign({}, markChange.mark.attrs), { dataTracked: newDT }));
+            if (isInlineMarkChange(markChange)) {
+                tr.removeMark(markChange.from, markChange.to, markChange.mark);
+                tr.addMark(markChange.from, markChange.to, newMark);
+            }
+            else {
+                tr.removeNodeMark(markChange.from, markChange.mark);
+                tr.addNodeMark(markChange.from, newMark);
+            }
+        }
+        else {
+            console.warn('Unable to update a mark change because the mark change data are incomplete');
+        }
+    }
     return tr;
 }
 export function updateChangeChildrenAttributes(changes, tr, mapping) {

package/dist/es/compute/nodeHelpers.js

@@ -1,5 +1,6 @@
 import { CHANGE_OPERATION } from '../types/change';
 import { log } from '../utils/logger';
+import { isValidTrackableMark } from '../utils/track-utils';
 import { uuidv4 } from '../utils/uuidv4';
 export function addTrackIdIfDoesntExist(attrs) {
     if (!attrs.id) {
@@ -30,6 +31,15 @@ export function getBlockInlineTrackedData(node) {
     }
     return dataTracked || [];
 }
+export function getMarkTrackedData(node) {
+    const tracked = node === null || node === void 0 ? void 0 : node.marks.reduce((acc, current) => {
+        if (isValidTrackableMark(current) && current.attrs.dataTracked) {
+            acc.set(current, current.attrs.dataTracked);
+        }
+        return acc;
+    }, new Map());
+    return tracked || new Map();
+}
 export function getNodeTrackedData(node, schema) {
     let tracked;
     if (node && !node.isText) {

package/dist/es/mutate/deleteAndMergeSplitNodes.js

@@ -1,6 +1,7 @@
 import { Fragment } from 'prosemirror-model';
 import { setFragmentAsInserted } from '../compute/setFragmentAsInserted';
 import { splitSliceIntoMergedParts } from '../compute/splitSliceIntoMergedParts';
+import { stepIsLift } from '../steps/utils';
 import * as trackUtils from '../utils/track-utils';
 export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
     const steps = [];
@@ -33,7 +34,7 @@ export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema,
                 const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent;
                 const mergeEndNodeNotEmpty = mergeEndNode && mergeContent.size;
                 if (mergeEndNode && !mergeEndNodeNotEmpty && gap) {
-                    if (trackUtils.stepIsLift(gap, node, to)) {
+                    if (stepIsLift(gap, node, to)) {
                         gap.slice.content.forEach((node, offset) => {
                             steps.push({
                                 type: 'delete-node',

package/dist/es/mutate/deleteNode.js

@@ -44,8 +44,8 @@ export function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
         dropStructuralChangeShadow(structure.moveNodeId, newTr);
     }
 }
-export const keepDeleteWithMoveNodeId = (node) => {
+export const keepPairedChanges = (node) => {
     var _a;
-    const dataTracked = (_a = getBlockInlineTrackedData(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => c.operation === CHANGE_OPERATION.delete && c.moveNodeId);
+    const dataTracked = (_a = getBlockInlineTrackedData(node)) === null || _a === void 0 ? void 0 : _a.filter((c) => (c.operation === CHANGE_OPERATION.delete && c.moveNodeId) || c.operation === CHANGE_OPERATION.reference);
     return (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.length) ? dataTracked : null;
 };

package/dist/es/mutate/dropStructureChange.js

@@ -30,9 +30,10 @@ export const dropStructuralChangeShadow = (moveNodeId, tr) => {
     }
     return tr;
 };
-export const dropOrphanChanges = (newTr, dropDataTracked) => {
+export const dropOrphanChanges = (newTr) => {
     const changeSet = findChanges(EditorState.create({ doc: newTr.doc }));
     const shadowIds = new Set();
+    const referenceIds = new Set();
     const changesIds = new Set();
     changeSet.changes.forEach((c) => {
         if (c.dataTracked.moveNodeId && c.dataTracked.operation === CHANGE_OPERATION.delete) {
@@ -42,14 +43,38 @@ export const dropOrphanChanges = (newTr, dropDataTracked) => {
             c.dataTracked.operation === CHANGE_OPERATION.move) {
             changesIds.add(c.dataTracked.moveNodeId);
         }
+        if (c.dataTracked.operation === CHANGE_OPERATION.node_split) {
+            changesIds.add(c.dataTracked.id);
+        }
+        if (c.dataTracked.operation === CHANGE_OPERATION.reference) {
+            referenceIds.add(c.dataTracked.referenceId);
+        }
     });
-    if (!shadowIds.size && !changesIds.size) {
+    if (!shadowIds.size && !referenceIds.size && !changesIds.size) {
         return;
     }
     changeSet.changes.forEach((c) => {
+        if (c.dataTracked.operation === CHANGE_OPERATION.reference &&
+            !changesIds.has(c.dataTracked.referenceId)) {
+            const node = newTr.doc.nodeAt(c.from);
+            const dataTracked = node && (getBlockInlineTrackedData(node) || []).filter((d) => d.id !== c.id);
+            newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked }));
+        }
+        if (c.type === 'node-change' &&
+            c.dataTracked.operation === CHANGE_OPERATION.node_split &&
+            !referenceIds.has(c.id)) {
+            const _a = c.dataTracked, { id } = _a, attrs = __rest(_a, ["id"]);
+            newTr.replaceWith(c.from, c.to, setFragmentAsInserted(Fragment.from(c.node), createNewInsertAttrs(attrs), newTr.doc.type.schema));
+            const referenceChanges = (getBlockInlineTrackedData(c.node) || []).filter((d) => d.operation === CHANGE_OPERATION.reference);
+            if (referenceChanges.length) {
+                const node = newTr.doc.nodeAt(c.from);
+                const dataTracked = (node && getBlockInlineTrackedData(node)) || [];
+                newTr.setNodeMarkup(c.from, undefined, Object.assign(Object.assign({}, node === null || node === void 0 ? void 0 : node.attrs), { dataTracked: [...dataTracked, ...referenceChanges] }));
+            }
+        }
         if (c.dataTracked.moveNodeId &&
             !(shadowIds.has(c.dataTracked.moveNodeId) && changesIds.has(c.dataTracked.moveNodeId))) {
-            if (c.dataTracked.operation === CHANGE_OPERATION.delete || dropDataTracked) {
+            if (c.dataTracked.operation === CHANGE_OPERATION.delete) {
                 if (c.type === 'text-change') {
                     newTr.removeMark(c.from, c.to, newTr.doc.type.schema.marks.tracked_delete);
                 }
@@ -58,7 +83,7 @@ export const dropOrphanChanges = (newTr, dropDataTracked) => {
                 }
             }
             else if (c.type === 'node-change') {
-                const _a = c.dataTracked, { id, moveNodeId } = _a, attrs = __rest(_a, ["id", "moveNodeId"]);
+                const _b = c.dataTracked, { id, moveNodeId } = _b, attrs = __rest(_b, ["id", "moveNodeId"]);
                 newTr.replaceWith(c.from, c.to, setFragmentAsInserted(Fragment.from(c.node), createNewInsertAttrs(attrs), newTr.doc.type.schema));
             }
         }