@manuscripts/track-changes-plugin 2.1.1 → 2.2.0

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

@@ -1,15 +1,26 @@
 import { Slice } from 'prosemirror-model';
-import { getAction, TrackChangesAction } from '../actions';
-import { setFragmentAsInserted, setFragmentAsMoveChange, setFragmentAsNodeSplit, } from '../compute/setFragmentAsInserted';
-import { deleteAndMergeSplitNodes } from '../mutate/deleteAndMergeSplitNodes';
-import { joinStructureChanges } from '../mutate/dropStructureChange';
-import { log } from '../utils/logger';
-import * as trackUtils from '../utils/track-utils';
-import { isSplitStep, isStructureSteps } from './utils';
-export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResult, currentStepDoc, tr, moveID) {
+import { ReplaceStep } from 'prosemirror-transform';
+import { getAction, TrackChangesAction } from '../../actions';
+import { isStructuralChange, joinStructureChanges } from '../../changeHelpers/structureChange';
+import { createNewInsertAttrs, createNewMoveAttrs } from '../../helpers/attributes';
+import { setFragmentAsInserted, setFragmentAsMoveChange, setFragmentAsNodeSplit, } from '../../helpers/fragment';
+import { log } from '../../utils/logger';
+import { mapChangeSteps } from '../change-step/mapChangeSteps';
+import { deleteAndMergeSplitNodes } from '../lib/deleteAndMergeSplitNodes';
+import { isSplitStep } from './qualifiers';
+export function trackReplaceStep(i, oldState, newTr, attrsTemplate, tr, deletedNodeMapping, trContext) {
+    const step = tr.steps[i];
+    const moveID = trContext.stepsByGroupIDMap.get(step);
+    const invertedStep = step.invert(tr.docs[i]);
+    const newStep = new ReplaceStep(deletedNodeMapping.map(invertedStep.from), deletedNodeMapping.map(invertedStep.to), invertedStep.slice);
+    const stepResult = newTr.maybeStep(newStep);
     log.info('###### ReplaceStep ######');
     let selectionPos = 0;
     const changeSteps = [];
+    if (stepResult.failed) {
+        log.error(`invert ReplaceStep failed: "${stepResult.failed}"`);
+        return [changeSteps, undefined];
+    }
     const attrs = Object.assign({}, attrsTemplate);
     if (moveID) {
         attrs.moveNodeId = moveID;
@@ -19,30 +30,18 @@ export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResul
         log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
         const { slice } = step;
         log.info('TR: steps before applying delete', [...newTr.steps]);
-        if (stepResult.failed) {
-            log.error(`invert ReplaceStep failed: "${stepResult.failed}"`);
-            return;
-        }
-        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, currentStepDoc, newTr, oldState.schema, attrs, slice);
+        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, tr.docs[i], oldState.schema, attrs, slice);
         changeSteps.push(...deleteSteps);
         log.info('TR: steps after applying delete', [...newTr.steps]);
         log.info('DELETE STEPS: ', [...changeSteps]);
-        function sameThingBackSpaced() {
-            if (changeSteps.length == 2 && newSliceContent.size > 0) {
-                const correspondingDeletion = changeSteps.find((step) => step.type === 'delete-text' && step.node.text === newSliceContent.content[0].text);
-                return correspondingDeletion;
-            }
-            return undefined;
-        }
-        const backSpacedText = sameThingBackSpaced();
+        const backSpacedText = sameThingBackSpaced(changeSteps, newSliceContent);
         if (backSpacedText) {
-            console.log('Detected backspacing');
             changeSteps.splice(changeSteps.indexOf(backSpacedText));
         }
         if (!backSpacedText && newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
-            let fragment = setFragmentAsInserted(newSliceContent, trackUtils.createNewInsertAttrs(attrs), oldState.schema);
-            if (isStructureSteps(tr)) {
+            let fragment = setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema);
+            if (isStructuralChange(tr)) {
                 fragment = joinStructureChanges(attrs, newSliceContent, fragment, tr, newTr);
             }
             else if (isSplitStep(step, oldState.selection, tr.getMeta('uiEvent'))) {
@@ -50,7 +49,7 @@ export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResul
             }
             else if (moveID) {
                 const indentationType = (_a = getAction(tr, TrackChangesAction.indentationAction)) === null || _a === void 0 ? void 0 : _a.action;
-                fragment = setFragmentAsMoveChange(newSliceContent, trackUtils.createNewMoveAttrs(attrs, indentationType));
+                fragment = setFragmentAsMoveChange(newSliceContent, createNewMoveAttrs(attrs, indentationType));
             }
             const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
             const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
@@ -70,5 +69,14 @@ export function trackReplaceStep(step, oldState, newTr, attrsTemplate, stepResul
             selectionPos = isDeleteEvent || isDeleteContentForward ? toA : fromA;
         }
     });
-    return [changeSteps, selectionPos];
+    selectionPos = deletedNodeMapping.map(selectionPos);
+    const doneSteps = mapChangeSteps(changeSteps, deletedNodeMapping);
+    return [doneSteps, selectionPos];
+}
+function sameThingBackSpaced(changeSteps, newSliceContent) {
+    if (changeSteps.length == 2 && newSliceContent.size > 0) {
+        const correspondingDeletion = changeSteps.find((step) => step.type === 'delete-text' && step.node.text === newSliceContent.content[0].text);
+        return correspondingDeletion;
+    }
+    return undefined;
 }

package/dist/es/tracking/trackTransaction.js

@@ -0,0 +1,87 @@
+import { AddMarkStep, AddNodeMarkStep, AttrStep, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, } from 'prosemirror-transform';
+import { isStructuralChange } from '../changeHelpers/structureChange';
+import { updateChangeAttrs } from '../changeHelpers/updateChangeAttrs';
+import { createNewPendingAttrs, getNodeTrackedData } from '../helpers/attributes';
+import { log } from '../utils/logger';
+import { uuidv4 } from '../utils/uuidv4';
+import { diffChangeSteps } from './change-step/diffChangeSteps';
+import { processChangeSteps } from './change-step/processChangeSteps';
+import { fixAndSetSelectionAfterTracking } from './fixAndHandleSelection';
+import { isDeleteStep } from './steps-trackers/qualifiers';
+import trackAttrsChangeStep from './steps-trackers/trackAttrsChangeStep';
+import { trackAddMarkStep, trackAddNodeMarkStep, trackRemoveMarkStep, trackRemoveNodeMarkStep, } from './steps-trackers/trackMarkSteps';
+import { trackReplaceAroundStep } from './steps-trackers/trackReplaceAroundStep';
+import { trackReplaceStep } from './steps-trackers/trackReplaceStep';
+import { excludeFromTracking, iterationIsValid, passThroughMeta } from './transactionProcessing';
+export function trackTransaction(tr, oldState, newTr, authorID, clearedSteps, trContext) {
+    var _a, _b, _c, _d, _e;
+    const emptyAttrs = createNewPendingAttrs(tr.time, authorID);
+    const deletedNodeMapping = new Mapping();
+    trContext = Object.assign(Object.assign({}, trContext), { deletedNodeMapping });
+    let iterations = 0;
+    log.info('ORIGINAL transaction', tr);
+    for (let i = clearedSteps.length - 1; i >= 0; i--) {
+        const step = clearedSteps[i];
+        if (!step) {
+            continue;
+        }
+        log.info('transaction step', step);
+        iterations++;
+        if (!iterationIsValid(iterations, tr, newTr, step)) {
+            continue;
+        }
+        else if (step instanceof ReplaceStep) {
+            const { slice } = step;
+            if (((_b = (_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.length) === 1 && excludeFromTracking(slice.content.content[0])) {
+                continue;
+            }
+            let thisStepMapping = tr.mapping.slice(i + 1, i + 1);
+            if (isDeleteStep(step) || isStructuralChange(tr)) {
+                thisStepMapping = deletedNodeMapping;
+            }
+            let [steps, newSelectionPos] = trackReplaceStep(i, oldState, newTr, emptyAttrs, tr, thisStepMapping, trContext);
+            if (steps.length === 1) {
+                const step = steps[0];
+                if (excludeFromTracking((step === null || step === void 0 ? void 0 : step.node) || ((_d = (_c = step === null || step === void 0 ? void 0 : step.slice) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.content[0]))) {
+                    continue;
+                }
+            }
+            log.info('TRACK REPLACE CHANGES: ', [...steps]);
+            steps = diffChangeSteps(steps);
+            log.info('DIFFED STEPS: ', steps);
+            const [_, updatedSelectionPos] = processChangeSteps(steps, newTr, trContext.stepsByGroupIDMap.has(step)
+                ? Object.assign(Object.assign({}, emptyAttrs), { moveNodeId: trContext.stepsByGroupIDMap.get(step) }) : emptyAttrs, oldState.schema, deletedNodeMapping);
+            trContext.selectionPosFromInsertion = updatedSelectionPos || newSelectionPos || tr.selection.head;
+        }
+        else if (step instanceof ReplaceAroundStep) {
+            let steps = trackReplaceAroundStep(step, oldState, tr, newTr, emptyAttrs, tr.docs[i], trContext);
+            steps = diffChangeSteps(steps);
+            log.info('DIFFED STEPS: ', steps);
+            processChangeSteps(steps, newTr, emptyAttrs, oldState.schema, deletedNodeMapping);
+        }
+        else if (step instanceof AttrStep) {
+            const changeSteps = trackAttrsChangeStep(step, oldState, tr, newTr, emptyAttrs, tr.docs[i]);
+            processChangeSteps(changeSteps, newTr, emptyAttrs, oldState.schema, deletedNodeMapping);
+        }
+        else if (step instanceof AddMarkStep) {
+            trackAddMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+            const dataTracked = (_e = getNodeTrackedData(newTr.doc.nodeAt(step.from), oldState.schema)) === null || _e === void 0 ? void 0 : _e.pop();
+            if (dataTracked) {
+                updateChangeAttrs(newTr, { id: dataTracked.id, from: step.from, to: step.to, type: 'text-change', dataTracked }, Object.assign(Object.assign({}, dataTracked), { id: uuidv4() }), oldState.schema);
+            }
+        }
+        else if (step instanceof RemoveMarkStep) {
+            trackRemoveMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof RemoveNodeMarkStep) {
+            trackRemoveNodeMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+        else if (step instanceof AddNodeMarkStep) {
+            trackAddNodeMarkStep(step, emptyAttrs, newTr, tr.docs[i]);
+        }
+    }
+    newTr = passThroughMeta(tr, newTr);
+    newTr = fixAndSetSelectionAfterTracking(newTr, tr, deletedNodeMapping, trContext);
+    log.info('NEW transaction', newTr);
+    return newTr;
+}

package/dist/es/tracking/transactionProcessing.js

@@ -0,0 +1,153 @@
+import { ReplaceStep } from 'prosemirror-transform';
+import { isIndentationAction, TrackChangesAction } from '../actions';
+import { ChangeSet } from '../ChangeSet';
+import { CHANGE_OPERATION, CHANGE_STATUS } from '../types/change';
+import { uuidv4 } from '../utils/uuidv4';
+import { isDeletingPendingMovedNode, isDirectPendingMoveDeletion } from './steps-trackers/qualifiers';
+export function getIndentationOperationSteps(tr, trContext) {
+    if (isIndentationAction(trContext.action)) {
+        const moveId = uuidv4();
+        for (let i = 0; i < tr.steps.length; i++) {
+            const step = tr.steps[i];
+            if (step instanceof ReplaceStep) {
+                trContext.stepsByGroupIDMap.set(step, moveId);
+            }
+        }
+    }
+}
+export const excludeFromTracking = (node) => {
+    var _a;
+    if (node.isText) {
+        return false;
+    }
+    return node && !((_a = node.type.spec.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked);
+};
+export function passThroughMeta(oldTr, newTr) {
+    oldTr.getMeta('inputType') && newTr.setMeta('inputType', oldTr.getMeta('inputType'));
+    oldTr.getMeta('uiEvent') && newTr.setMeta('uiEvent', oldTr.getMeta('uiEvent'));
+    return newTr;
+}
+export function iterationIsValid(iterations, oldTr, newTr, step) {
+    const uiEvent = oldTr.getMeta('uiEvent');
+    const isMassReplace = oldTr.getMeta('massSearchReplace');
+    if (iterations > 20 && uiEvent != 'cut' && !isMassReplace) {
+        console.error('@manuscripts/track-changes-plugin: Possible infinite loop in iterating tr.steps, tracking skipped!\n' +
+            'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
+        return false;
+    }
+    else if (!(step instanceof ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+        console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
+            'or instanceof checks fail as well as creating new steps');
+        return false;
+    }
+    return true;
+}
+export const getMoveOperationsSteps = (tr, context) => {
+    const movingAssoc = context.stepsByGroupIDMap;
+    if (tr.steps.length < 2) {
+        return movingAssoc;
+    }
+    if (tr.getMeta(TrackChangesAction.structuralChangeAction)) {
+        const commonID = uuidv4();
+        movingAssoc.set(tr.steps[0], commonID);
+        movingAssoc.set(tr.steps[1], commonID);
+        return movingAssoc;
+    }
+    const matched = [];
+    for (let i = 0; i < tr.steps.length; i++) {
+        if (matched.includes(i)) {
+            continue;
+        }
+        const step = tr.steps[i];
+        const doc = tr.docs[i];
+        if (!step.slice) {
+            continue;
+        }
+        const stepDeletesContent = step.from !== step.to && step.slice.size === 0;
+        const stepInsertsContent = step.slice.size && step.slice.content.firstChild ? true : false;
+        for (let g = 0; g < tr.steps.length; g++) {
+            if (g === i || matched.includes(g)) {
+                continue;
+            }
+            const peerStep = tr.steps[g];
+            if (!peerStep.slice) {
+                continue;
+            }
+            const peerStepInsertsContent = peerStep.slice.size && peerStep.slice.content.firstChild;
+            const peerStepDeletesContent = peerStep.from !== peerStep.to && peerStep.slice.size === 0;
+            if (stepDeletesContent) {
+                const deletedContent = doc.slice(step.from, step.to);
+                if (peerStepInsertsContent &&
+                    deletedContent.content.firstChild &&
+                    peerStep.slice.content.firstChild.toString() === deletedContent.content.firstChild.toString()) {
+                    const commonID = uuidv4();
+                    movingAssoc.set(peerStep, commonID);
+                    movingAssoc.set(step, commonID);
+                    matched.push(i, g);
+                }
+                continue;
+            }
+            if (stepInsertsContent && peerStepDeletesContent) {
+                const insertedContent = step.slice;
+                const deletedPeerContent = tr.docs[g].slice(peerStep.from, peerStep.to);
+                if (insertedContent.content.firstChild &&
+                    deletedPeerContent.content.firstChild &&
+                    insertedContent.content.firstChild.toString() === deletedPeerContent.content.firstChild.toString()) {
+                    const commonID = uuidv4();
+                    movingAssoc.set(peerStep, commonID);
+                    movingAssoc.set(step, commonID);
+                }
+                matched.push(i, g);
+            }
+        }
+    }
+};
+export const changeMovedToInsertsOnSourceDeletion = (tr, newTr, trContext) => {
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        if (step instanceof ReplaceStep) {
+            const doc = tr.docs[tr.steps.indexOf(step)];
+            if (isDirectPendingMoveDeletion(step, doc, trContext.stepsByGroupIDMap)) {
+                const node = doc.nodeAt(step.from);
+                if (node === null || node === void 0 ? void 0 : node.attrs.dataTracked) {
+                    newTr.setNodeMarkup(step.from, undefined, Object.assign(Object.assign({}, node.attrs), { dataTracked: node.attrs.dataTracked.filter((t) => !(t.operation === CHANGE_OPERATION.move && t.status === CHANGE_STATUS.pending)) }));
+                }
+            }
+        }
+    }
+};
+export const filterMeaninglessMoveSteps = (tr, context) => {
+    var _a;
+    const cleanSteps = [];
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        const moveID = context.stepsByGroupIDMap.get(step);
+        if (moveID) {
+            const prevMoveID = isDeletingPendingMovedNode(step, tr.docs[i]);
+            if (prevMoveID) {
+                context.stepsByGroupIDMap.forEach((replaceStepMoveID, replaceStep) => {
+                    if (replaceStep !== step && moveID === replaceStepMoveID) {
+                        context.stepsByGroupIDMap.set(replaceStep, prevMoveID);
+                    }
+                });
+                cleanSteps.push(null);
+                continue;
+            }
+            if (step instanceof ReplaceStep && !tr.getMeta(TrackChangesAction.structuralChangeAction)) {
+                const { slice } = step;
+                if ((_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.firstChild) {
+                    const insertedNode = slice.content.firstChild;
+                    if (insertedNode.attrs.dataTracked) {
+                        const isPendingInsert = ChangeSet.isPendingChange(insertedNode.attrs.dataTracked, CHANGE_OPERATION.insert);
+                        if (isPendingInsert) {
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        cleanSteps.push(step);
+    }
+    return cleanSteps;
+};
+export const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));

package/dist/es/tracking/types.js

@@ -0,0 +1,16 @@
+/*!
+ * © 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.
+ */
+export {};

package/dist/types/ChangeSet.d.ts

@@ -1,4 +1,4 @@
-import { IncompleteChange, MarkChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+import { CHANGE_OPERATION, IncompleteChange, MarkChange, NodeAttrChange, NodeChange, ReferenceChange, RootChanges, TextChange, TrackedAttrs, TrackedChange } from './types/change';
 export declare class ChangeSet {
     #private;
     constructor(changes?: (TrackedChange | IncompleteChange)[]);
@@ -29,9 +29,12 @@ export declare class ChangeSet {
     static flattenTreeToIds(changes: TrackedChange[]): string[];
     static shouldDeleteChange(change: TrackedChange): boolean;
     static isValidDataTracked(dataTracked?: Partial<TrackedAttrs>): boolean;
+    static isInlineMarkChange(change: TrackedChange): boolean;
+    static isInline(c: TrackedChange): boolean;
     static isTextChange(change: TrackedChange): change is TextChange;
     static isMarkChange(change: TrackedChange): change is MarkChange;
     static isNodeChange(change: TrackedChange): change is NodeChange;
     static isNodeAttrChange(change: TrackedChange): change is NodeAttrChange;
     static isReferenceChange(change: TrackedChange): change is ReferenceChange;
+    static isPendingChange(trackedAttrs: TrackedAttrs[] | undefined, operation: CHANGE_OPERATION): boolean;
 }

package/dist/types/actions.d.ts

@@ -30,3 +30,4 @@ export declare function hasAction(tr: Transaction): boolean;
 export declare function getAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K): TrackChangesActionParams[K] | undefined;
 export declare function setAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K, payload: TrackChangesActionParams[K]): Transaction;
 export declare const skipTracking: (tr: Transaction) => Transaction;
+export declare const isIndentationAction: (action: ReturnType<typeof getAction>) => action is "indent" | "unindent";

package/dist/types/applyChanges.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { ChangeSet } from './ChangeSet';
+import { TrackedChange } from './types/change';
+export declare function applyChanges(tr: Transaction, schema: Schema, changes: TrackedChange[], changeSet: ChangeSet, deleteMap?: Mapping): Mapping;

package/dist/types/{mutate/dropStructureChange.d.ts → changeHelpers/structureChange.d.ts}

@@ -1,6 +1,7 @@
 import { Fragment } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
-import { NewEmptyAttrs } from '../types/track';
+import { NewEmptyAttrs } from '../helpers/attributes';
 export declare const dropStructuralChangeShadow: (moveNodeId: string | undefined, tr: Transaction) => Transaction;
 export declare const dropOrphanChanges: (newTr: Transaction) => void;
 export declare const joinStructureChanges: (attrs: NewEmptyAttrs, sliceContent: Fragment, content: Fragment, tr: Transaction, newTr: Transaction) => Fragment;
+export declare const isStructuralChange: (tr: Transaction) => any;

package/dist/types/{changes/findChanges.d.ts → findChanges.d.ts}

@@ -1,3 +1,3 @@
 import { EditorState } from 'prosemirror-state';
-import { ChangeSet } from '../ChangeSet';
+import { ChangeSet } from './ChangeSet';
 export declare function findChanges(state: EditorState): ChangeSet;

package/dist/types/helpers/attributes.d.ts

@@ -0,0 +1,47 @@
+import { Attrs, Fragment, Mark, Node as PMNode, Schema } from 'prosemirror-model';
+import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
+export type NewEmptyAttrs = Omit<TrackedAttrs, 'id' | 'operation'>;
+export type NewInsertAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.wrap_with_node | CHANGE_OPERATION.structure;
+};
+export type NewDeleteAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.delete;
+};
+export type NewUpdateAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.set_node_attributes;
+    oldAttrs: Record<string, any>;
+};
+export type NewSplitNodeAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.node_split;
+};
+export type NewMoveAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.move;
+    indentationType?: 'indent' | 'unindent';
+};
+export type NewReferenceAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.reference;
+    referenceId: string;
+};
+export type NewTrackedAttrs = NewInsertAttrs | NewDeleteAttrs | NewUpdateAttrs | NewMoveAttrs;
+export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
+export declare function createNewWrapAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
+export declare function createNewSplitAttrs(attrs: NewEmptyAttrs): NewSplitNodeAttrs;
+export declare function createNewReferenceAttrs(attrs: NewEmptyAttrs, id: string): NewReferenceAttrs;
+export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
+export declare function createNewMoveAttrs(attrs: NewEmptyAttrs, indentationType?: 'indent' | 'unindent'): NewMoveAttrs;
+export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
+export declare function createNewStructureAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
+export declare function createNewPendingAttrs(time: number, authorID: string): NewEmptyAttrs;
+export declare function addTrackIdIfDoesntExist(attrs: Partial<TrackedAttrs>): Partial<TrackedAttrs>;
+export declare function getTextNodeTrackedMarkData(node: PMNode | null, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
+    operation: CHANGE_OPERATION;
+}) | undefined;
+export declare function getBlockInlineTrackedData(node: PMNode): Partial<TrackedAttrs>[] | undefined;
+export declare function getMarkTrackedData(node: PMNode | undefined | null): Map<Mark, Partial<TrackedAttrs>[]>;
+export declare function getNodeTrackedData(node: PMNode | undefined | null, schema: Schema): Partial<TrackedAttrs>[] | undefined;
+export declare function shouldMergeTrackedAttributes(left?: Partial<TrackedAttrs>, right?: Partial<TrackedAttrs>): boolean;
+export declare function getMergeableMarkTrackedAttrs(node: PMNode | null, attrs: Partial<TrackedAttrs>, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
+    operation: CHANGE_OPERATION;
+}) | null;
+export declare const updateBlockNodesAttrs: (fragment: Fragment, predicate: (attrs: Attrs, node: PMNode) => Attrs) => Fragment;
+export declare function excludeFromTracked(dataTracked: TrackedAttrs[] | null, changeIdToExclude: string): TrackedAttrs[] | null;

package/dist/types/{compute/setFragmentAsInserted.d.ts → helpers/fragment.d.ts}

@@ -1,7 +1,9 @@
 import { Fragment, ResolvedPos, Schema } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
-import { NewEmptyAttrs, NewInsertAttrs, NewMoveAttrs } from '../types/track';
+import { ExposedFragment } from '../types/pm';
+import { NewEmptyAttrs, NewInsertAttrs, NewMoveAttrs } from './attributes';
 export declare function setFragmentAsInserted(inserted: Fragment, insertAttrs: NewInsertAttrs, schema: Schema): Fragment;
 export declare function setFragmentAsWrapChange(inserted: Fragment, attrs: NewEmptyAttrs, schema: Schema): Fragment;
 export declare function setFragmentAsMoveChange(fragment: Fragment, moveAttrs: NewMoveAttrs): Fragment;
 export declare function setFragmentAsNodeSplit($pos: ResolvedPos, newTr: Transaction, inserted: Fragment, attrs: NewEmptyAttrs): Fragment;
+export declare function cutFragment(matched: number, deleted: number, content: Fragment): [number, ExposedFragment];

package/dist/types/helpers/mark.d.ts

@@ -0,0 +1,3 @@
+import { Mark, Node as PMNode } from 'prosemirror-model';
+export declare function isValidTrackableMark(mark: Mark): boolean;
+export declare function equalMarks(n1: PMNode, n2: PMNode): boolean;

package/dist/types/trackChanges.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * © 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 { EditorState, PluginKey, Transaction } from 'prosemirror-state';
+export declare function trackChanges(tr: Transaction, createdTr: Transaction, oldState: EditorState, userID: string, skipTrsWithMetas: (string | PluginKey<any>)[]): Transaction | undefined;

package/dist/types/tracking/change-step/diffChangeSteps.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * © 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 { ChangeStep } from '../types';
+export declare function diffChangeSteps(steps: ChangeStep[]): ChangeStep[];

package/dist/types/{utils/mapChangeStep.d.ts → tracking/change-step/mapChangeSteps.d.ts}

@@ -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.
@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import { Mapping } from 'prosemirror-transform';
-import { ChangeStep } from '../types/step';
+import { ChangeStep } from '../types';
 export declare function mapChangeSteps(steps: ChangeStep[], mapping: Mapping): ChangeStep[];

package/dist/types/tracking/change-step/processChangeSteps.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { NewEmptyAttrs } from '../../helpers/attributes';
+import { ChangeStep } from '../types';
+export declare function processChangeSteps(changes: ChangeStep[], newTr: Transaction, emptyAttrs: NewEmptyAttrs, schema: Schema, deletedNodeMapping: Mapping): [Mapping, number | undefined];

package/dist/types/tracking/fixAndHandleSelection.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * © 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 { Selection, Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { TrTrackingContext } from './types';
+export declare const getSelectionStaticConstructor: (sel: Selection) => any;
+export declare function fixAndSetSelectionAfterTracking(newTr: Transaction, oldTr: Transaction, deletedNodeMapping: Mapping, trContext: TrTrackingContext): Transaction;

package/dist/types/{mutate → tracking/lib}/deleteAndMergeSplitNodes.d.ts

@@ -1,14 +1,13 @@
 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';
-import { NewEmptyAttrs } from '../types/track';
+import { NewEmptyAttrs } from '../../helpers/attributes';
+import { ExposedSlice } from '../../types/pm';
+import { ChangeStep } from '../types';
 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): {
+} | undefined, startDoc: PMNode, schema: Schema, trackAttrs: NewEmptyAttrs, insertSlice: ExposedSlice): {
     sliceWasSplit: boolean;
     newSliceContent: Fragment;
     steps: ChangeStep[];

package/dist/types/{mutate → tracking/lib}/deleteNode.d.ts

@@ -1,6 +1,6 @@
 import { Node as PMNode } from 'prosemirror-model';
 import { Transaction } from 'prosemirror-state';
-import { NewDeleteAttrs } from '../types/track';
+import { NewDeleteAttrs } from '../../helpers/attributes';
 export declare function deleteNode(node: PMNode, pos: number, tr: Transaction): Transaction;
 export declare function deleteOrSetNodeDeleted(node: PMNode, pos: number, newTr: Transaction, deleteAttrs: NewDeleteAttrs): Transaction | undefined;
-export declare const keepPairedChanges: (node: PMNode) => Partial<import("../types/change").TrackedAttrs>[] | null;
+export declare const keepPairedChanges: (node: PMNode) => Partial<import("../../types/change").TrackedAttrs>[] | null;

package/dist/types/{mutate/deleteText.d.ts → tracking/lib/deleteTextIfInserted.d.ts}

@@ -1,4 +1,4 @@
 import { Node as PMNode, Schema } from 'prosemirror-model';
 import type { Transaction } from 'prosemirror-state';
-import { NewDeleteAttrs } from '../types/track';
+import { NewDeleteAttrs } from '../../helpers/attributes';
 export declare function deleteTextIfInserted(node: PMNode, pos: number, newTr: Transaction, schema: Schema, deleteAttrs: NewDeleteAttrs, from?: number, to?: number): number;

package/dist/types/tracking/lib/matchInserted.d.ts

@@ -0,0 +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.
+ */
+import { ExposedFragment } from '../../types/pm';
+import { ChangeStep } from '../types';
+export declare function matchInserted(matchedDeleted: number, deleted: ChangeStep[], inserted: ExposedFragment): [number, ChangeStep[]];

package/dist/types/tracking/lib/processStepsBeforeTracking.d.ts

@@ -0,0 +1,4 @@
+import { Transaction } from 'prosemirror-state';
+import { Step } from 'prosemirror-transform';
+import { TrTrackingContext } from '../types';
+export declare function processStepsBeforeTracking(tr: Transaction, trContext: TrTrackingContext, processors: Array<(tr: Transaction, context: TrTrackingContext) => Step[] | void>): Step[];

package/dist/types/{compute → tracking/lib}/splitSliceIntoMergedParts.d.ts

@@ -1,5 +1,5 @@
 import { Node as PMNode } from 'prosemirror-model';
-import { ExposedFragment, ExposedSlice } from '../types/pm';
+import { ExposedFragment, ExposedSlice } from '../../types/pm';
 export declare function splitSliceIntoMergedParts(insertSlice: ExposedSlice, mergeEqualSides?: boolean): {
     updatedSliceNodes: readonly PMNode[] & PMNode[];
     firstMergedNode: {