@manuscripts/track-changes-plugin 1.8.6 → 1.8.7-LEAN-4145.1

package/dist/cjs/compute/setFragmentAsInserted.js

@@ -92,7 +92,7 @@ function setFragmentAsNodeSplit($pos, newTr, inserted, attrs) {
     const oldDataTracked = (0, nodeHelpers_1.getBlockInlineTrackedData)(parent) || [];
     newTr.setNodeMarkup(parentPos, undefined, Object.assign(Object.assign({}, parent.attrs), { dataTracked: [
             ...oldDataTracked.filter((c) => c.operation !== 'reference'),
-            Object.assign({}, (0, nodeHelpers_1.addTrackIdIfDoesntExist)(trackUtils.createNewSplitSourceAttrs(Object.assign(Object.assign({}, attrs), { status: change_1.CHANGE_STATUS.pending }), referenceId))),
+            Object.assign({}, (0, nodeHelpers_1.addTrackIdIfDoesntExist)(trackUtils.createNewReferenceAttrs(Object.assign(Object.assign({}, attrs), { status: change_1.CHANGE_STATUS.pending }), referenceId))),
         ] }));
     const splitSource = oldDataTracked.find((c) => c.operation === 'reference');
     const dataTracked = Object.assign(Object.assign({}, trackUtils.createNewSplitAttrs(Object.assign({}, attrs))), { id: referenceId });

package/dist/cjs/mutate/deleteAndMergeSplitNodes.js

@@ -56,8 +56,21 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                     ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
                     : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
                 const mergeStartNode = endTokenDeleted && openStart > 0 && depth === openStart && mergeContent && mergeContent.size;
-                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent && mergeContent.size;
-                if (mergeStartNode || mergeEndNode) {
+                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent;
+                const mergeEndNodeNotEmpty = mergeEndNode && mergeContent.size;
+                if (mergeEndNode && !mergeEndNodeNotEmpty && gap) {
+                    if (trackUtils.stepIsLift(gap, node, to)) {
+                        gap.slice.content.forEach((node, offset) => {
+                            steps.push({
+                                type: 'delete-node',
+                                pos: gap.start + offset,
+                                nodeEnd: gap.start + offset + node.nodeSize,
+                                node,
+                            });
+                        });
+                    }
+                }
+                if (mergeStartNode || mergeEndNodeNotEmpty) {
                     steps.push({
                         type: 'merge-fragment',
                         pos,

package/dist/cjs/steps/trackReplaceAroundStep.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trackReplaceAroundStep = void 0;
+exports.trackReplaceAroundStep = exports.fakef = void 0;
 const prosemirror_model_1 = require("prosemirror-model");
 const actions_1 = require("../actions");
 const setFragmentAsInserted_1 = require("../compute/setFragmentAsInserted");
@@ -31,18 +31,36 @@ const deleteAndMergeSplitNodes_1 = require("../mutate/deleteAndMergeSplitNodes")
 const logger_1 = require("../utils/logger");
 const trackUtils = __importStar(require("../utils/track-utils"));
 const track_utils_1 = require("../utils/track-utils");
-function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc) {
+function fakef() {
+    return 0;
+}
+exports.fakef = fakef;
+function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
+    const prevDoc = newTr.docs[newTr.docs.length - 2];
+    if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {
+        prevDoc.nodesBetween(newStep.from, newStep.to, (node, pos) => {
+            newStep.slice.content.forEach((n, offset) => {
+                if (n.type === node.type && !node.isText && n.attrs.id === node.attrs.id) {
+                    newTr.setNodeAttribute(newStep.from + offset, 'dataTracked', node.attrs.dataTracked);
+                }
+            });
+        });
+    }
+    return newTr;
+}
+function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc, trContext) {
     logger_1.log.info('###### ReplaceAroundStep ######');
     const { from, to, gapFrom, gapTo, insert, slice, structure, } = step;
     const newStep = step.invert(currentStepDoc);
-    const stepResult = newTr.maybeStep(newStep);
+    let stepResult = newTr.maybeStep(newStep);
     if (stepResult.failed) {
         logger_1.log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
         return [];
     }
+    preserveDataTrackedFromPreviousStep(newTr, step, newStep);
     const gap = currentStepDoc.slice(gapFrom, gapTo);
     logger_1.log.info('RETAINED GAP CONTENT', gap);
-    const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = (0, deleteAndMergeSplitNodes_1.deleteAndMergeSplitNodes)(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    let { sliceWasSplit, newSliceContent, steps: deleteSteps, } = (0, deleteAndMergeSplitNodes_1.deleteAndMergeSplitNodes)(from, to, { start: gapFrom, end: gapTo, slice: gap, insert }, newTr.doc, newTr, oldState.schema, attrs, slice);
     let fragment;
     if ((0, track_utils_1.isWrapStep)(step)) {
         fragment = (0, setFragmentAsInserted_1.setFragmentAsWrapChange)(newSliceContent, attrs, oldState.schema);
@@ -50,9 +68,21 @@ function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc
     else {
         fragment = (0, setFragmentAsInserted_1.setFragmentAsInserted)(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
     }
-    const steps = deleteSteps;
+    let steps = deleteSteps;
     logger_1.log.info('TR: new steps after applying delete', [...newTr.steps]);
     logger_1.log.info('DELETE STEPS: ', deleteSteps);
+    let liftStep = (0, track_utils_1.isLiftStep)(step);
+    if (liftStep) {
+        logger_1.log.info('DETECTING INIT LIFT STEP: ', step);
+        trContext.prevLiftStep = step;
+    }
+    else if (trContext.prevLiftStep && trContext.prevLiftStep.gapFrom === step.gapTo) {
+        logger_1.log.info('DETECTING CHAIN LIFT STEP');
+        trContext.prevLiftStep = step;
+    }
+    else {
+        trContext.prevLiftStep = undefined;
+    }
     if (gap.size > 0 ||
         (!structure && newSliceContent.size > 0) ||
         tr.getMeta(actions_1.TrackChangesAction.updateMetaNode)) {
@@ -62,16 +92,34 @@ function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc
         let insertedSlice = new prosemirror_model_1.Slice(fragment, openStart, openEnd);
         if (gap.size > 0 || tr.getMeta(actions_1.TrackChangesAction.updateMetaNode)) {
             logger_1.log.info('insertedSlice before inserted gap', insertedSlice);
-            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
+            let sliceContent = gap.content;
+            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, sliceContent);
             logger_1.log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        deleteSteps.push({
-            type: 'insert-slice',
-            from: gapFrom,
-            to: gapTo,
-            slice: insertedSlice,
-            sliceWasSplit,
-        });
+        if (trContext.prevLiftStep) {
+            trContext.liftFragment = trContext.liftFragment
+                ? insertedSlice.content.append(trContext.liftFragment)
+                : insertedSlice.content;
+            if (tr.steps.indexOf(step) === 0) {
+                const fragmentTracked = (0, setFragmentAsInserted_1.setFragmentAsInserted)(trContext.liftFragment, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
+                steps.push({
+                    type: 'insert-slice',
+                    from: from,
+                    to: from,
+                    slice: new prosemirror_model_1.Slice(fragmentTracked, 0, 0),
+                    sliceWasSplit: true,
+                });
+            }
+        }
+        else {
+            steps.push({
+                type: 'insert-slice',
+                from: gapFrom,
+                to: gapTo,
+                slice: insertedSlice,
+                sliceWasSplit,
+            });
+        }
     }
     else {
     }

package/dist/cjs/steps/trackTransaction.js

@@ -33,6 +33,7 @@ function trackTransaction(tr, oldState, newTr, authorID) {
     const setsNewSelection = tr.selectionSet;
     let iters = 0;
     logger_1.log.info('ORIGINAL transaction', tr);
+    let trContext = {};
     for (let i = tr.steps.length - 1; i >= 0; i--) {
         const step = tr.steps[i];
         logger_1.log.info('transaction step', step);
@@ -82,7 +83,7 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             }
         }
         else if (step instanceof prosemirror_transform_1.ReplaceAroundStep) {
-            let steps = (0, trackReplaceAroundStep_1.trackReplaceAroundStep)(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
+            let steps = (0, trackReplaceAroundStep_1.trackReplaceAroundStep)(step, oldState, tr, newTr, emptyAttrs, tr.docs[i], trContext);
             const deleted = steps.filter((s) => s.type !== 'insert-slice');
             const inserted = steps.filter((s) => s.type === 'insert-slice');
             logger_1.log.info('INSERT STEPS: ', inserted);
@@ -91,8 +92,8 @@ function trackTransaction(tr, oldState, newTr, authorID) {
             const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
         else if (step instanceof prosemirror_transform_1.AttrStep) {
-            const chnageSteps = (0, trackAttrsChange_1.default)(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
-            const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(chnageSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
+            const changeSteps = (0, trackAttrsChange_1.default)(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
+            const [mapping, selectionPos] = (0, processChangeSteps_1.processChangeSteps)(changeSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
         else if (step instanceof prosemirror_transform_1.AddMarkStep) {
             const dataTracked = (_e = (0, nodeHelpers_1.getNodeTrackedData)(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _e === void 0 ? void 0 : _e.pop();

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.isWrapStep = exports.isSplitStep = exports.createNewUpdateAttrs = exports.createNewDeleteAttrs = exports.createNewSplitSourceAttrs = exports.createNewSplitAttrs = exports.createNewWrapAttrs = exports.createNewInsertAttrs = void 0;
+exports.stepIsLift = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = exports.createNewUpdateAttrs = exports.createNewDeleteAttrs = exports.createNewReferenceAttrs = exports.createNewSplitAttrs = exports.createNewWrapAttrs = exports.createNewInsertAttrs = void 0;
 const change_1 = require("../types/change");
 function createNewInsertAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.insert });
@@ -25,10 +25,10 @@ function createNewSplitAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.node_split });
 }
 exports.createNewSplitAttrs = createNewSplitAttrs;
-function createNewSplitSourceAttrs(attrs, id) {
+function createNewReferenceAttrs(attrs, id) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.reference, referenceId: id });
 }
-exports.createNewSplitSourceAttrs = createNewSplitSourceAttrs;
+exports.createNewReferenceAttrs = createNewReferenceAttrs;
 function createNewDeleteAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: change_1.CHANGE_OPERATION.delete });
 }
@@ -68,3 +68,17 @@ const isWrapStep = (step) => step.from === step.gapFrom &&
     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;
+}
+exports.stepIsLift = stepIsLift;

package/dist/es/compute/setFragmentAsInserted.js

@@ -64,7 +64,7 @@ export function setFragmentAsNodeSplit($pos, newTr, inserted, attrs) {
     const oldDataTracked = getBlockInlineTrackedData(parent) || [];
     newTr.setNodeMarkup(parentPos, undefined, Object.assign(Object.assign({}, parent.attrs), { dataTracked: [
             ...oldDataTracked.filter((c) => c.operation !== 'reference'),
-            Object.assign({}, addTrackIdIfDoesntExist(trackUtils.createNewSplitSourceAttrs(Object.assign(Object.assign({}, attrs), { status: CHANGE_STATUS.pending }), referenceId))),
+            Object.assign({}, addTrackIdIfDoesntExist(trackUtils.createNewReferenceAttrs(Object.assign(Object.assign({}, attrs), { status: CHANGE_STATUS.pending }), referenceId))),
         ] }));
     const splitSource = oldDataTracked.find((c) => c.operation === 'reference');
     const dataTracked = Object.assign(Object.assign({}, trackUtils.createNewSplitAttrs(Object.assign({}, attrs))), { id: referenceId });

package/dist/es/mutate/deleteAndMergeSplitNodes.js

@@ -30,8 +30,21 @@ export function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema,
                     ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
                     : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
                 const mergeStartNode = endTokenDeleted && openStart > 0 && depth === openStart && mergeContent && mergeContent.size;
-                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent && mergeContent.size;
-                if (mergeStartNode || mergeEndNode) {
+                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent;
+                const mergeEndNodeNotEmpty = mergeEndNode && mergeContent.size;
+                if (mergeEndNode && !mergeEndNodeNotEmpty && gap) {
+                    if (trackUtils.stepIsLift(gap, node, to)) {
+                        gap.slice.content.forEach((node, offset) => {
+                            steps.push({
+                                type: 'delete-node',
+                                pos: gap.start + offset,
+                                nodeEnd: gap.start + offset + node.nodeSize,
+                                node,
+                            });
+                        });
+                    }
+                }
+                if (mergeStartNode || mergeEndNodeNotEmpty) {
                     steps.push({
                         type: 'merge-fragment',
                         pos,

package/dist/es/steps/trackReplaceAroundStep.js

@@ -4,19 +4,36 @@ import { setFragmentAsInserted, setFragmentAsWrapChange } from '../compute/setFr
 import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
 import { log } from '../utils/logger';
 import * as trackUtils from '../utils/track-utils';
-import { isWrapStep } from '../utils/track-utils';
-export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc) {
+import { isLiftStep, isWrapStep } from '../utils/track-utils';
+export function fakef() {
+    return 0;
+}
+function preserveDataTrackedFromPreviousStep(newTr, step, newStep) {
+    const prevDoc = newTr.docs[newTr.docs.length - 2];
+    if (prevDoc && (step.slice.openEnd || step.slice.openStart)) {
+        prevDoc.nodesBetween(newStep.from, newStep.to, (node, pos) => {
+            newStep.slice.content.forEach((n, offset) => {
+                if (n.type === node.type && !node.isText && n.attrs.id === node.attrs.id) {
+                    newTr.setNodeAttribute(newStep.from + offset, 'dataTracked', node.attrs.dataTracked);
+                }
+            });
+        });
+    }
+    return newTr;
+}
+export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, currentStepDoc, trContext) {
     log.info('###### ReplaceAroundStep ######');
     const { from, to, gapFrom, gapTo, insert, slice, structure, } = step;
     const newStep = step.invert(currentStepDoc);
-    const stepResult = newTr.maybeStep(newStep);
+    let stepResult = newTr.maybeStep(newStep);
     if (stepResult.failed) {
         log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
         return [];
     }
+    preserveDataTrackedFromPreviousStep(newTr, step, newStep);
     const gap = currentStepDoc.slice(gapFrom, gapTo);
     log.info('RETAINED GAP CONTENT', gap);
-    const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    let { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo, slice: gap, insert }, newTr.doc, newTr, oldState.schema, attrs, slice);
     let fragment;
     if (isWrapStep(step)) {
         fragment = setFragmentAsWrapChange(newSliceContent, attrs, oldState.schema);
@@ -24,9 +41,21 @@ export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, current
     else {
         fragment = setFragmentAsInserted(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
     }
-    const steps = deleteSteps;
+    let steps = deleteSteps;
     log.info('TR: new steps after applying delete', [...newTr.steps]);
     log.info('DELETE STEPS: ', deleteSteps);
+    let liftStep = isLiftStep(step);
+    if (liftStep) {
+        log.info('DETECTING INIT LIFT STEP: ', step);
+        trContext.prevLiftStep = step;
+    }
+    else if (trContext.prevLiftStep && trContext.prevLiftStep.gapFrom === step.gapTo) {
+        log.info('DETECTING CHAIN LIFT STEP');
+        trContext.prevLiftStep = step;
+    }
+    else {
+        trContext.prevLiftStep = undefined;
+    }
     if (gap.size > 0 ||
         (!structure && newSliceContent.size > 0) ||
         tr.getMeta(TrackChangesAction.updateMetaNode)) {
@@ -36,16 +65,34 @@ export function trackReplaceAroundStep(step, oldState, tr, newTr, attrs, current
         let insertedSlice = new Slice(fragment, openStart, openEnd);
         if (gap.size > 0 || tr.getMeta(TrackChangesAction.updateMetaNode)) {
             log.info('insertedSlice before inserted gap', insertedSlice);
-            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
+            let sliceContent = gap.content;
+            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, sliceContent);
             log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        deleteSteps.push({
-            type: 'insert-slice',
-            from: gapFrom,
-            to: gapTo,
-            slice: insertedSlice,
-            sliceWasSplit,
-        });
+        if (trContext.prevLiftStep) {
+            trContext.liftFragment = trContext.liftFragment
+                ? insertedSlice.content.append(trContext.liftFragment)
+                : insertedSlice.content;
+            if (tr.steps.indexOf(step) === 0) {
+                const fragmentTracked = setFragmentAsInserted(trContext.liftFragment, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
+                steps.push({
+                    type: 'insert-slice',
+                    from: from,
+                    to: from,
+                    slice: new Slice(fragmentTracked, 0, 0),
+                    sliceWasSplit: true,
+                });
+            }
+        }
+        else {
+            steps.push({
+                type: 'insert-slice',
+                from: gapFrom,
+                to: gapTo,
+                slice: insertedSlice,
+                sliceWasSplit,
+            });
+        }
     }
     else {
     }

package/dist/es/steps/trackTransaction.js

@@ -27,6 +27,7 @@ export function trackTransaction(tr, oldState, newTr, authorID) {
     const setsNewSelection = tr.selectionSet;
     let iters = 0;
     log.info('ORIGINAL transaction', tr);
+    let trContext = {};
     for (let i = tr.steps.length - 1; i >= 0; i--) {
         const step = tr.steps[i];
         log.info('transaction step', step);
@@ -76,7 +77,7 @@ export function trackTransaction(tr, oldState, newTr, authorID) {
             }
         }
         else if (step instanceof ReplaceAroundStep) {
-            let steps = trackReplaceAroundStep(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
+            let steps = trackReplaceAroundStep(step, oldState, tr, newTr, emptyAttrs, tr.docs[i], trContext);
             const deleted = steps.filter((s) => s.type !== 'insert-slice');
             const inserted = steps.filter((s) => s.type === 'insert-slice');
             log.info('INSERT STEPS: ', inserted);
@@ -85,8 +86,8 @@ export function trackTransaction(tr, oldState, newTr, authorID) {
             const [mapping, selectionPos] = processChangeSteps(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
         else if (step instanceof AttrStep) {
-            const chnageSteps = trackAttrsChange(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
-            const [mapping, selectionPos] = processChangeSteps(chnageSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
+            const changeSteps = trackAttrsChange(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
+            const [mapping, selectionPos] = processChangeSteps(changeSteps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
         else if (step instanceof AddMarkStep) {
             const dataTracked = (_e = getNodeTrackedData(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _e === void 0 ? void 0 : _e.pop();

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

@@ -19,7 +19,7 @@ export function createNewWrapAttrs(attrs) {
 export function createNewSplitAttrs(attrs) {
     return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.node_split });
 }
-export function createNewSplitSourceAttrs(attrs, id) {
+export function createNewReferenceAttrs(attrs, id) {
     return Object.assign(Object.assign({}, attrs), { operation: CHANGE_OPERATION.reference, referenceId: id });
 }
 export function createNewDeleteAttrs(attrs) {
@@ -57,3 +57,15 @@ export const isWrapStep = (step) => step.from === step.gapFrom &&
     step.to === step.gapTo &&
     step.slice.openStart === 0 &&
     step.slice.openEnd === 0;
+export 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;
+};
+export function stepIsLift(gap, node, to) {
+    return gap.start < gap.end && gap.insert === 0 && gap.end === to && !node.isText;
+}

package/dist/types/mutate/deleteAndMergeSplitNodes.d.ts

@@ -1,4 +1,4 @@
-import { Fragment, Node as PMNode, Schema } from 'prosemirror-model';
+import { Fragment, Node as PMNode, Schema, Slice } from 'prosemirror-model';
 import type { Transaction } from 'prosemirror-state';
 import { ExposedSlice } from '../types/pm';
 import { ChangeStep } from '../types/step';
@@ -6,6 +6,8 @@ import { NewEmptyAttrs } from '../types/track';
 export declare function deleteAndMergeSplitNodes(from: number, to: number, gap: {
     start: number;
     end: number;
+    slice: Slice;
+    insert: number;
 } | undefined, startDoc: PMNode, newTr: Transaction, schema: Schema, trackAttrs: NewEmptyAttrs, insertSlice: ExposedSlice): {
     sliceWasSplit: boolean;
     newSliceContent: Fragment;

package/dist/types/steps/trackReplaceAroundStep.d.ts

@@ -2,5 +2,6 @@ import { Node as PMNode } from 'prosemirror-model';
 import type { EditorState, Transaction } from 'prosemirror-state';
 import { ReplaceAroundStep } from 'prosemirror-transform';
 import { ChangeStep } from '../types/step';
-import { NewEmptyAttrs } from '../types/track';
-export declare function trackReplaceAroundStep(step: ReplaceAroundStep, oldState: EditorState, tr: Transaction, newTr: Transaction, attrs: NewEmptyAttrs, currentStepDoc: PMNode): ChangeStep[];
+import { NewEmptyAttrs, TrTrackingContext } from '../types/track';
+export declare function fakef(): number;
+export declare function trackReplaceAroundStep(step: ReplaceAroundStep, oldState: EditorState, tr: Transaction, newTr: Transaction, attrs: NewEmptyAttrs, currentStepDoc: PMNode, trContext: TrTrackingContext): ChangeStep[];

package/dist/types/types/step.d.ts

@@ -5,6 +5,7 @@ export interface DeleteNodeStep {
     nodeEnd: number;
     type: 'delete-node';
     node: PMNode;
+    ref?: string;
 }
 export interface DeleteTextStep {
     pos: number;
@@ -12,6 +13,7 @@ export interface DeleteTextStep {
     to: number;
     type: 'delete-text';
     node: PMNode;
+    ref?: string;
 }
 export interface MergeFragmentStep {
     pos: number;

package/dist/types/types/track.d.ts

@@ -1,4 +1,6 @@
+import { Fragment } from 'prosemirror-model';
 import type { PluginKey } from 'prosemirror-state';
+import { ReplaceAroundStep } from 'prosemirror-transform';
 import { ChangeSet } from '../ChangeSet';
 import { CHANGE_OPERATION, TrackedAttrs } from './change';
 export interface TrackChangesOptions {
@@ -36,3 +38,7 @@ export declare enum TrackChangesStatus {
     viewSnapshots = "view-snapshots",
     disabled = "disabled"
 }
+export type TrTrackingContext = {
+    prevLiftStep?: ReplaceAroundStep;
+    liftFragment?: Fragment;
+};

package/dist/types/utils/track-utils.d.ts

@@ -1,11 +1,19 @@
+import { Node as PMNode, Slice } from 'prosemirror-model';
 import { Selection } from 'prosemirror-state';
 import { ReplaceAroundStep, ReplaceStep } from 'prosemirror-transform';
 import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewReferenceAttrs, NewSplitNodeAttrs, NewUpdateAttrs } from '../types/track';
 export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
 export declare function createNewWrapAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
 export declare function createNewSplitAttrs(attrs: NewEmptyAttrs): NewSplitNodeAttrs;
-export declare function createNewSplitSourceAttrs(attrs: NewEmptyAttrs, id: string): NewReferenceAttrs;
+export declare function createNewReferenceAttrs(attrs: NewEmptyAttrs, id: string): NewReferenceAttrs;
 export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
 export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
 export declare const isSplitStep: (step: ReplaceStep, selection: Selection, uiEvent: string) => boolean;
 export declare const isWrapStep: (step: ReplaceAroundStep) => boolean;
+export declare const isLiftStep: (step: ReplaceAroundStep) => boolean;
+export declare function stepIsLift(gap: {
+    start: number;
+    end: number;
+    slice: Slice;
+    insert: number;
+}, node: PMNode, to: number): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "1.8.6",
+  "version": "1.8.7-LEAN-4145.1",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",