@manuscripts/track-changes-plugin 2.1.1 → 2.2.0

package/dist/es/helpers/mark.js

@@ -0,0 +1,15 @@
+export 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;
+}
+export function equalMarks(n1, n2) {
+    return (n1.marks.length === n2.marks.length &&
+        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
+}

package/dist/es/plugin.js

@@ -11,14 +11,14 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 import { Plugin, PluginKey } from 'prosemirror-state';
 import { getAction, hasAction, setAction, TrackChangesAction } from './actions';
-import { findChanges } from './changes/findChanges';
-import { fixInconsistentChanges } from './changes/fixInconsistentChanges';
-import { updateChangesStatus } from './changes/updateChangesStatus';
+import { fixInconsistentChanges } from './changeHelpers/fixInconsistentChanges';
+import { updateChangesStatus } from './changeHelpers/updateChangesStatus';
 import { ChangeSet } from './ChangeSet';
-import { trackTransaction } from './steps/trackTransaction';
+import { findChanges } from './findChanges';
+import { trackChanges } from './trackChanges';
+import { trFromHistory } from './tracking/transactionProcessing';
 import { TrackChangesStatus } from './types/track';
 import { enableDebug, log } from './utils/logger';
-import { trFromHistory } from './utils/track-utils';
 export const trackChangesPluginKey = new PluginKey('track-changes');
 export const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initialStatus: TrackChangesStatus.enabled }) => {
     const { userID, debug, skipTrsWithMetas = [] } = opts;
@@ -80,31 +80,22 @@ export const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initi
             let createdTr = newState.tr, docChanged = false;
             log.info('TRS', trs);
             trs.forEach((tr) => {
-                const wasAppended = tr.getMeta('appendedTransaction');
-                const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
                 const collabRebased = tr.getMeta('rebased');
                 if (collabRebased !== undefined) {
                     setAction(createdTr, TrackChangesAction.refreshChanges, true);
                     docChanged = true;
                     return;
                 }
-                const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
-                const skipTrackUsed = getAction(tr, TrackChangesAction.skipTrack) ||
-                    (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
-                if (!setChangeStatuses &&
-                    tr.docChanged &&
-                    !skipMetaUsed &&
-                    !skipTrackUsed &&
-                    !trFromHistory(tr) &&
-                    !(wasAppended && tr.getMeta('origin') === 'paragraphs')) {
-                    createdTr = trackTransaction(tr, oldState, createdTr, userID, changeSet);
-                }
-                docChanged = docChanged || tr.docChanged;
-                if (setChangeStatuses) {
-                    const { status, ids } = setChangeStatuses;
+                const setsChangeStatus = getAction(tr, TrackChangesAction.setChangeStatuses);
+                if (setsChangeStatus) {
+                    const { status, ids } = setsChangeStatus;
                     updateChangesStatus(createdTr, changeSet, ids, status, userID, oldState);
                     setAction(createdTr, TrackChangesAction.refreshChanges, true);
                 }
+                else {
+                    createdTr = trackChanges(tr, createdTr, oldState, userID, skipTrsWithMetas) || createdTr;
+                }
+                docChanged = docChanged || tr.docChanged;
             });
             const changed = pluginState.changeSet.hasInconsistentData &&
                 fixInconsistentChanges(pluginState.changeSet, userID, createdTr, oldState.schema);

package/dist/es/trackChanges.js

@@ -0,0 +1,44 @@
+/*!
+ * © 2025 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.
+ */
+import { getAction, TrackChangesAction } from './actions';
+import { processStepsBeforeTracking } from './tracking/lib/processStepsBeforeTracking';
+import { trackTransaction } from './tracking/trackTransaction';
+import { changeMovedToInsertsOnSourceDeletion, filterMeaninglessMoveSteps, getIndentationOperationSteps, getMoveOperationsSteps, trFromHistory, } from './tracking/transactionProcessing';
+export function trackChanges(tr, createdTr, oldState, userID, skipTrsWithMetas) {
+    var _a;
+    const wasAppended = tr.getMeta('appendedTransaction');
+    const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
+    const skipTrackUsed = getAction(tr, TrackChangesAction.skipTrack) ||
+        (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
+    if (tr.docChanged &&
+        !skipMetaUsed &&
+        !skipTrackUsed &&
+        !trFromHistory(tr) &&
+        !(wasAppended && tr.getMeta('origin') === 'paragraphs')) {
+        const action = (_a = getAction(tr, TrackChangesAction.indentationAction)) === null || _a === void 0 ? void 0 : _a.action;
+        const trContext = {
+            action,
+            stepsByGroupIDMap: new Map(),
+        };
+        const clearedSteps = processStepsBeforeTracking(tr, trContext, [
+            getMoveOperationsSteps,
+            getIndentationOperationSteps,
+            filterMeaninglessMoveSteps,
+        ]);
+        changeMovedToInsertsOnSourceDeletion(tr, createdTr, trContext);
+        return trackTransaction(tr, oldState, createdTr, userID, clearedSteps, trContext);
+    }
+}

package/dist/es/{change-steps → tracking/change-step}/diffChangeSteps.js

@@ -1,31 +1,26 @@
-import { Fragment, Slice } from 'prosemirror-model';
-import { log } from '../utils/logger';
-import { matchInserted } from './matchInserted';
-function cutFragment(matched, deleted, content) {
-    const newContent = [];
-    for (let i = 0; matched <= deleted && i < content.childCount; i += 1) {
-        const child = content.child(i);
-        if (!child.isText && child.content.size > 0) {
-            const cut = cutFragment(matched + 1, deleted, child.content);
-            matched = cut[0];
-            newContent.push(...cut[1].content);
-        }
-        else if (child.isText && matched + child.nodeSize > deleted) {
-            if (deleted - matched > 0) {
-                newContent.push(child.cut(deleted - matched));
-            }
-            else {
-                newContent.push(child);
-            }
-            matched = deleted + 1;
-        }
-        else {
-            matched += child.nodeSize;
-        }
-    }
-    return [matched, Fragment.fromArray(newContent)];
-}
-export function diffChangeSteps(deleted, inserted) {
+/*!
+ * © 2025 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.
+ */
+import { Slice } from 'prosemirror-model';
+import { cutFragment } from '../../helpers/fragment';
+import { log } from '../../utils/logger';
+import { matchInserted } from '../lib/matchInserted';
+export function diffChangeSteps(steps) {
+    const deleted = steps.filter((s) => s.type !== 'insert-slice');
+    const inserted = steps.filter((s) => s.type === 'insert-slice');
+    log.info('INSERT STEPS: ', inserted);
     const updated = [];
     let updatedDeleted = [...deleted];
     inserted.forEach((ins) => {

package/dist/es/{utils/mapChangeStep.js → tracking/change-step/mapChangeSteps.js}

@@ -1,5 +1,5 @@
 /*!
- * © 2023 Atypon Systems LLC
+ * © 2025 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.

package/dist/es/{change-steps → tracking/change-step}/processChangeSteps.js

@@ -10,17 +10,16 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import { Mapping, ReplaceStep } from 'prosemirror-transform';
-import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { deleteOrSetNodeDeleted } from '../mutate/deleteNode';
-import { deleteTextIfInserted } from '../mutate/deleteText';
-import { mergeTrackedMarks } from '../mutate/mergeTrackedMarks';
-import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
-import { log } from '../utils/logger';
-import * as trackUtils from '../utils/track-utils';
-export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema, deletedNodeMapping) {
+import { addTrackIdIfDoesntExist, createNewDeleteAttrs, createNewUpdateAttrs, getBlockInlineTrackedData, } from '../../helpers/attributes';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../../types/change';
+import { log } from '../../utils/logger';
+import { deleteOrSetNodeDeleted } from '../lib/deleteNode';
+import { deleteTextIfInserted } from '../lib/deleteTextIfInserted';
+import { mergeTrackedMarks } from '../lib/mergeTrackedMarks';
+export function processChangeSteps(changes, newTr, emptyAttrs, schema, deletedNodeMapping) {
     const mapping = new Mapping();
-    const deleteAttrs = trackUtils.createNewDeleteAttrs(emptyAttrs);
-    let selectionPos = startPos;
+    const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
+    let selectionPos = undefined;
     let deletesCounter = 0;
     let isInserted = false;
     let prevDelete;
@@ -130,7 +129,7 @@ export function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema,
                 const oldAttrs = restAttrs;
                 const newDataTracked = [...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id)];
                 const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
-                    ? Object.assign(Object.assign({}, oldUpdate), { updatedAt: emptyAttrs.updatedAt }) : addTrackIdIfDoesntExist(trackUtils.createNewUpdateAttrs(emptyAttrs, c.node.attrs));
+                    ? Object.assign(Object.assign({}, oldUpdate), { updatedAt: emptyAttrs.updatedAt }) : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, c.node.attrs));
                 if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
                     c.node.type === c.node.type.schema.nodes.citation) &&
                     !oldDataTracked.find((d) => (d.operation === CHANGE_OPERATION.insert || d.operation === CHANGE_OPERATION.wrap_with_node) &&

package/dist/es/tracking/fixAndHandleSelection.js

@@ -0,0 +1,49 @@
+/*!
+ * © 2025 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.
+ */
+import { NodeSelection as NodeSelectionClass, TextSelection } from 'prosemirror-state';
+import { Mapping, ReplaceStep } from 'prosemirror-transform';
+import { isStructuralChange } from '../changeHelpers/structureChange';
+export const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
+export function fixAndSetSelectionAfterTracking(newTr, oldTr, deletedNodeMapping, trContext) {
+    const wasNodeSelection = oldTr.selection instanceof NodeSelectionClass;
+    if (!wasNodeSelection && !oldTr.selectionSet && trContext.selectionPosFromInsertion) {
+        const sel = getSelectionStaticConstructor(oldTr.selection);
+        const near = sel.near(newTr.doc.resolve(trContext.selectionPosFromInsertion), -1);
+        newTr.setSelection(near);
+    }
+    if (oldTr.selectionSet && oldTr.selection instanceof TextSelection) {
+        let from = oldTr.selection.from;
+        if (isStructuralChange(oldTr)) {
+            const selectionMapping = new Mapping();
+            oldTr.steps.map((step) => {
+                const isDeleteStep = step instanceof ReplaceStep && step.from !== step.to && step.slice.size === 0;
+                if (isDeleteStep) {
+                    selectionMapping.appendMap(step.getMap().invert());
+                }
+            });
+            selectionMapping.appendMapping(deletedNodeMapping);
+            from = selectionMapping.map(oldTr.selection.from);
+        }
+        const newPos = newTr.doc.resolve(from);
+        newTr.setSelection(new TextSelection(newPos));
+    }
+    if (wasNodeSelection) {
+        const mappedPos = newTr.mapping.map(oldTr.selection.from, -1);
+        const sel = getSelectionStaticConstructor(oldTr.selection);
+        newTr.setSelection(sel.create(newTr.doc, mappedPos));
+    }
+    return newTr;
+}

package/dist/es/{mutate → tracking/lib}/deleteAndMergeSplitNodes.js

@@ -1,9 +1,9 @@
 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) {
+import { createNewInsertAttrs } from '../../helpers/attributes';
+import { setFragmentAsInserted } from '../../helpers/fragment';
+import { isLiftStepForGap } from '../steps-trackers/qualifiers';
+import { splitSliceIntoMergedParts } from './splitSliceIntoMergedParts';
+export function deleteAndMergeSplitNodes(from, to, gap, startDoc, schema, trackAttrs, insertSlice) {
     const steps = [];
     if (from === to) {
         return {
@@ -34,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 (stepIsLift(gap, node, to)) {
+                    if (isLiftStepForGap(gap, node, to)) {
                         gap.slice.content.forEach((node, offset) => {
                             steps.push({
                                 type: 'delete-node',
@@ -53,7 +53,7 @@ export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema,
                         from,
                         to,
                         node,
-                        fragment: setFragmentAsInserted(mergeContent, trackUtils.createNewInsertAttrs(trackAttrs), schema),
+                        fragment: setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema),
                     });
                 }
                 else if (node.isText) {

package/dist/es/{mutate → tracking/lib}/deleteNode.js

@@ -1,11 +1,10 @@
 import { Fragment } from 'prosemirror-model';
-import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../compute/nodeHelpers';
-import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
-import { log } from '../utils/logger';
-import { dropStructuralChangeShadow } from './dropStructureChange';
+import { dropStructuralChangeShadow } from '../../changeHelpers/structureChange';
+import { addTrackIdIfDoesntExist, getBlockInlineTrackedData } from '../../helpers/attributes';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../../types/change';
+import { log } from '../../utils/logger';
 export function deleteNode(node, pos, tr) {
     var _a;
-    const startPos = tr.doc.resolve(pos + 1);
     const resPos = tr.doc.resolve(pos);
     const canMergeToNodeAbove = resPos.parent !== tr.doc && resPos.nodeBefore && node.isBlock && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
     if (canMergeToNodeAbove) {

package/dist/es/{mutate/deleteText.js → tracking/lib/deleteTextIfInserted.js}

@@ -1,5 +1,5 @@
 import { Fragment } from 'prosemirror-model';
-import { addTrackIdIfDoesntExist, getMergeableMarkTrackedAttrs } from '../compute/nodeHelpers';
+import { addTrackIdIfDoesntExist, getMergeableMarkTrackedAttrs, } from '../../helpers/attributes';
 export function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
     const start = from ? Math.max(pos, from) : pos;
     const nodeEnd = pos + node.nodeSize;

package/dist/es/{change-steps → tracking/lib}/matchInserted.js

@@ -1,3 +1,18 @@
+/*!
+ * © 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.
+ */
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -9,29 +24,6 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
-    const { pos, from, to, node: delNode } = adjDeleted;
-    let j = offset, d = from - pos, maxSteps = to - Math.max(pos, from);
-    for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
-        matchedDeleted += 1;
-    }
-    deleted = deleted.filter((d) => d !== adjDeleted);
-    if (maxSteps !== j) {
-        deleted.push({
-            pos,
-            from: from + j - offset,
-            to,
-            type: 'delete-text',
-            node: delNode,
-        });
-        return [matchedDeleted, deleted];
-    }
-    const nextTextDelete = deleted.find((d) => d.type === 'delete-text' && d.pos === to);
-    if (nextTextDelete) {
-        return matchText(nextTextDelete, insNode, j, matchedDeleted, deleted);
-    }
-    return [matchedDeleted, deleted];
-}
 export function matchInserted(matchedDeleted, deleted, inserted) {
     var _a;
     let matched = [matchedDeleted, deleted];

package/dist/es/{mutate → tracking/lib}/mergeTrackedMarks.js

@@ -1,5 +1,5 @@
-import { shouldMergeTrackedAttributes } from '../compute/nodeHelpers';
-import { uuidv4 } from '../utils/uuidv4';
+import { shouldMergeTrackedAttributes } from '../../helpers/attributes';
+import { uuidv4 } from '../../utils/uuidv4';
 const assignId = (attrs, leftDataTracked, rightDataTracked) => {
     if (attrs.id === leftDataTracked.id || attrs.id === rightDataTracked.id) {
         return Object.assign(Object.assign({}, attrs), { id: uuidv4() });

package/dist/es/tracking/lib/processStepsBeforeTracking.js

@@ -0,0 +1,14 @@
+import { log } from '../../utils/logger';
+export function processStepsBeforeTracking(tr, trContext, processors) {
+    let steps = [];
+    processors.forEach((p) => {
+        const res = p(tr, trContext);
+        if (res) {
+            steps = res;
+            if (steps.length < tr.steps.length) {
+                log.warn('Bug! A processor function filtered steps incorrectly. Filtered out steps should be replaced with null and not popped out of the array. Length and order has to be preserved');
+            }
+        }
+    });
+    return steps;
+}

package/dist/es/{steps/utils.js → tracking/steps-trackers/qualifiers.js}

@@ -13,8 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ReplaceStep } from 'prosemirror-transform';
-import { TrackChangesAction } from '../actions';
+import { ChangeSet } from '../../ChangeSet';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../../types/change';
+export const isDeleteStep = (step) => step.from !== step.to && step.slice.content.size < step.to - step.from;
 export const isSplitStep = (step, selection, uiEvent) => {
     var _a, _b, _c, _d;
     const { from, to, slice } = step;
@@ -53,10 +54,34 @@ export const isLiftStep = (step) => {
     }
     return false;
 };
-export function stepIsLift(gap, node, to) {
+export function isLiftStepForGap(gap, node, to) {
     return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
 }
-export const isStructureSteps = (tr) => tr.getMeta(TrackChangesAction.structuralChangeAction) &&
-    tr.steps.length === 2 &&
-    tr.steps[0] instanceof ReplaceStep &&
-    tr.steps[1] instanceof ReplaceStep;
+export const isDirectPendingMoveDeletion = (step, doc, movingSteps) => {
+    if (step.from === step.to || step.slice.content.size > 0) {
+        return false;
+    }
+    if (movingSteps.has(step)) {
+        return false;
+    }
+    const node = doc.nodeAt(step.from);
+    if (!node) {
+        return false;
+    }
+    return ChangeSet.isPendingChange(node.attrs.dataTracked, CHANGE_OPERATION.move);
+};
+export const isDeletingPendingMovedNode = (step, doc) => {
+    if (!step.slice || step.from === step.to || step.slice.content.size > 0) {
+        return undefined;
+    }
+    const node = doc.nodeAt(step.from);
+    if (!node) {
+        return undefined;
+    }
+    const trackedAttrs = node.attrs.dataTracked;
+    const found = trackedAttrs === null || trackedAttrs === void 0 ? void 0 : trackedAttrs.find((tracked) => tracked.operation === CHANGE_OPERATION.move && tracked.status === CHANGE_STATUS.pending);
+    if (found === null || found === void 0 ? void 0 : found.moveNodeId) {
+        return found.moveNodeId;
+    }
+    return undefined;
+};

package/dist/es/{steps/trackAttrsChange.js → tracking/steps-trackers/trackAttrsChangeStep.js}

@@ -24,8 +24,8 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { log } from '../utils/logger';
-function trackAttrsChange(step, oldState, tr, newTr, attrs, currentStepDoc) {
+import { log } from '../../utils/logger';
+function trackAttrsChangeStep(step, oldState, tr, newTr, attrs, currentStepDoc) {
     const newStep = step.invert(currentStepDoc);
     const stepResult = newTr.maybeStep(newStep);
     if (stepResult.failed) {
@@ -45,4 +45,4 @@ function trackAttrsChange(step, oldState, tr, newTr, attrs, currentStepDoc) {
     };
     return [changeStep];
 }
-export default trackAttrsChange;
+export default trackAttrsChangeStep;

package/dist/es/{steps → tracking/steps-trackers}/trackMarkSteps.js

@@ -1,7 +1,8 @@
 import { AddMarkStep, AddNodeMarkStep, RemoveMarkStep } from 'prosemirror-transform';
-import { CHANGE_OPERATION } from '../types/change';
-import { createNewDeleteAttrs, createNewInsertAttrs, isValidTrackableMark } from '../utils/track-utils';
-import { uuidv4 } from '../utils/uuidv4';
+import { createNewDeleteAttrs, createNewInsertAttrs } from '../../helpers/attributes';
+import { isValidTrackableMark } from '../../helpers/mark';
+import { CHANGE_OPERATION } from '../../types/change';
+import { uuidv4 } from '../../utils/uuidv4';
 function markHasOp(mark, operation) {
     if (mark.attrs.dataTracked && Array.isArray(mark.attrs.dataTracked)) {
         const dtAttrs = mark.attrs.dataTracked;
@@ -88,6 +89,8 @@ export function trackRemoveNodeMarkStep(step, emptyAttrs, newTr, doc) {
             }
         }
         try {
+            const inverted = step.invert(doc);
+            newTr.step(inverted);
             newTr.step(newStep);
         }
         catch (e) {

package/dist/es/{steps → tracking/steps-trackers}/trackReplaceAroundStep.js

@@ -1,10 +1,10 @@
 import { Slice } from 'prosemirror-model';
-import { TrackChangesAction } from '../actions';
-import { setFragmentAsInserted, setFragmentAsWrapChange } from '../compute/setFragmentAsInserted';
-import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
-import { log } from '../utils/logger';
-import * as trackUtils from '../utils/track-utils';
-import { isLiftStep, isWrapStep } from './utils';
+import { TrackChangesAction } from '../../actions';
+import { createNewInsertAttrs } from '../../helpers/attributes';
+import { setFragmentAsInserted, setFragmentAsWrapChange } from '../../helpers/fragment';
+import { log } from '../../utils/logger';
+import { deleteAndMergeSplitNodes } from '../lib/deleteAndMergeSplitNodes';
+import { isLiftStep, isWrapStep } from './qualifiers';
 function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
     const prevDoc = newTr.docs[newTr.docs.length - 2];
     if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {
@@ -30,16 +30,15 @@ export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, current
     preserveDataTrackedFromPreviousStep(newTr, step, newStep);
     const gap = currentStepDoc.slice(gapFrom, gapTo);
     log.info('RETAINED GAP CONTENT', gap);
-    let { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo, slice: gap, insert }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    let { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo, slice: gap, insert }, newTr.doc, oldState.schema, attrs, slice);
     let fragment;
     if (isWrapStep(step)) {
         fragment = setFragmentAsWrapChange(newSliceContent, attrs, oldState.schema);
     }
     else {
-        fragment = setFragmentAsInserted(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
+        fragment = setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema);
     }
     let steps = deleteSteps;
-    log.info('TR: new steps after applying delete', [...newTr.steps]);
     log.info('DELETE STEPS: ', deleteSteps);
     let liftStep = isLiftStep(step);
     if (liftStep) {
@@ -71,7 +70,7 @@ export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, current
                 ? insertedSlice.content.append(trContext.liftFragment)
                 : insertedSlice.content;
             if (tr.steps.indexOf(step) === 0) {
-                const fragmentTracked = setFragmentAsInserted(trContext.liftFragment, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
+                const fragmentTracked = setFragmentAsInserted(trContext.liftFragment, createNewInsertAttrs(attrs), oldState.schema);
                 steps.push({
                     type: 'insert-slice',
                     from: from,