@manuscripts/track-changes-plugin 2.3.7 → 2.3.9

package/README.md

@@ -13,7 +13,7 @@ ProseMirror plugin designed to track changes within a document, similar to the t
 
 ### Main design points 
 
-- Intercept transactions (insert/delete).
+- Intercept transactions (insert/delete). 
   Transactions are intercepted and reverted using default plugins lifecycle, unless transaction has meta commanding to skip tracking.
 
 - Annotate changes with metadata using node attributes and marks.

package/dist/cjs/index.js

@@ -51,3 +51,5 @@ var ChangeSet_1 = require("./ChangeSet");
 Object.defineProperty(exports, "ChangeSet", { enumerable: true, get: function () { return ChangeSet_1.ChangeSet; } });
 __exportStar(require("./types/change"), exports);
 __exportStar(require("./types/track"), exports);
+__exportStar(require("./utils/shared-utils"), exports);
+__exportStar(require("./utils/shadow-utils"), exports);

package/dist/cjs/plugin.js

@@ -22,6 +22,7 @@ const trackChanges_1 = require("./trackChanges");
 const transactionProcessing_1 = require("./tracking/transactionProcessing");
 const track_1 = require("./types/track");
 const logger_1 = require("./utils/logger");
+const normalizeShadowIds_1 = require("./tracking/normalizeShadowIds");
 exports.trackChangesPluginKey = new prosemirror_state_1.PluginKey('track-changes');
 const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initialStatus: track_1.TrackChangesStatus.enabled }) => {
     const { userID, debug, skipTrsWithMetas = [] } = opts;
@@ -105,6 +106,9 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initialStatu
             if (changed) {
                 logger_1.log.warn('had to fix inconsistent changes in', createdTr);
             }
+            if (createdTr.docChanged) {
+                createdTr = (0, normalizeShadowIds_1.normalizeShadowIds)(createdTr);
+            }
             if (docChanged || createdTr.docChanged || changed) {
                 createdTr.setMeta('origin', exports.trackChangesPluginKey);
                 return (0, actions_1.setAction)(createdTr, actions_1.TrackChangesAction.refreshChanges, true);

package/dist/cjs/trackChanges.js

@@ -1,6 +1,6 @@
 "use strict";
 /*!
- * © 2025 Atypon Systems LLC
+ * © 2026 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.
@@ -42,6 +42,7 @@ function trackChanges(tr, createdTr, oldState, userID, skipTrsWithMetas) {
             transactionProcessing_1.filterMeaninglessMoveSteps,
         ]);
         (0, transactionProcessing_1.changeMovedToInsertsOnSourceDeletion)(tr, createdTr, trContext);
-        return (0, trackTransaction_1.trackTransaction)(tr, oldState, createdTr, userID, clearedSteps, trContext);
+        const clearTr = (0, transactionProcessing_1.clearShadowsFromNewlyInserted)(tr, oldState);
+        return (0, trackTransaction_1.trackTransaction)(clearTr, oldState, createdTr, userID, clearedSteps, trContext);
     }
 }

package/dist/cjs/tracking/normalizeShadowIds.js

@@ -0,0 +1,50 @@
+"use strict";
+/*!
+ * © 2026 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.SHADOW_ID_PREFIX = void 0;
+exports.normalizeShadowIds = normalizeShadowIds;
+const qualifiers_1 = require("./steps-trackers/qualifiers");
+exports.SHADOW_ID_PREFIX = '__track__changes_shadow__';
+function normalizeShadowIds(tr) {
+    const changes = [];
+    const shadowRanges = [];
+    function isInShadowRange(pos) {
+        return shadowRanges.some((range) => pos >= range.from && pos < range.to);
+    }
+    tr.doc.descendants((node, pos) => {
+        if ((0, qualifiers_1.isShadowDelete)(node) || (0, qualifiers_1.isMoved)(node)) {
+            shadowRanges.push({ from: pos, to: pos + node.nodeSize });
+        }
+        if (typeof node.attrs.id === 'string' && node.attrs.id) {
+            const currentId = node.attrs.id;
+            const hasShadowPrefix = currentId.startsWith(exports.SHADOW_ID_PREFIX);
+            const inShadow = isInShadowRange(pos);
+            if (inShadow && !hasShadowPrefix) {
+                changes.push({ pos, node, newId: exports.SHADOW_ID_PREFIX + currentId });
+            }
+            else if (!inShadow && hasShadowPrefix) {
+                changes.push({ pos, node, newId: currentId.slice(exports.SHADOW_ID_PREFIX.length) });
+            }
+        }
+        return true;
+    });
+    for (let i = changes.length - 1; i >= 0; i--) {
+        const { pos, node, newId } = changes[i];
+        tr.setNodeMarkup(pos, null, Object.assign(Object.assign({}, node.attrs), { id: newId }));
+    }
+    return tr;
+}

package/dist/cjs/tracking/steps-trackers/qualifiers.js

@@ -17,6 +17,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDeletingPendingMovedNode = exports.isDirectPendingMoveDeletion = exports.isLiftStep = exports.isWrapStep = exports.isSplitStep = exports.isDeleteStep = void 0;
 exports.isLiftStepForGap = isLiftStepForGap;
+exports.isShadowDelete = isShadowDelete;
+exports.isMoved = isMoved;
 const ChangeSet_1 = require("../../ChangeSet");
 const change_1 = require("../../types/change");
 const isDeleteStep = (step) => step.from !== step.to && step.slice.content.size < step.to - step.from;
@@ -97,3 +99,17 @@ const isDeletingPendingMovedNode = (step, doc) => {
     return undefined;
 };
 exports.isDeletingPendingMovedNode = isDeletingPendingMovedNode;
+function isShadowDelete(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, moveNodeId }) => operation === 'delete' && moveNodeId);
+    }
+    return false;
+}
+function isMoved(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status, moveNodeId }) => operation === change_1.CHANGE_OPERATION.delete && status === change_1.CHANGE_STATUS.pending && moveNodeId);
+    }
+    return false;
+}

package/dist/cjs/tracking/transactionProcessing.js

@@ -4,6 +4,8 @@ exports.trFromHistory = exports.filterMeaninglessMoveSteps = exports.changeMoved
 exports.getIndentationOperationSteps = getIndentationOperationSteps;
 exports.passThroughMeta = passThroughMeta;
 exports.iterationIsValid = iterationIsValid;
+exports.clearShadowsFromNewlyInserted = clearShadowsFromNewlyInserted;
+const prosemirror_model_1 = require("prosemirror-model");
 const prosemirror_transform_1 = require("prosemirror-transform");
 const actions_1 = require("../actions");
 const ChangeSet_1 = require("../ChangeSet");
@@ -162,3 +164,62 @@ const filterMeaninglessMoveSteps = (tr, context) => {
 exports.filterMeaninglessMoveSteps = filterMeaninglessMoveSteps;
 const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
 exports.trFromHistory = trFromHistory;
+function clearShadowsFromNewlyInserted(tr, baseState) {
+    let hasShadowContent = false;
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        if (step instanceof prosemirror_transform_1.ReplaceStep && step.slice.content.size) {
+            step.slice.content.descendants((node) => {
+                if ((0, qualifiers_1.isShadowDelete)(node)) {
+                    hasShadowContent = true;
+                    return false;
+                }
+            });
+            if (hasShadowContent)
+                break;
+        }
+    }
+    if (!hasShadowContent) {
+        return tr;
+    }
+    const newTr = baseState.tr;
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        const clearStep = clearShadowContent(step);
+        const remapped = clearStep.map(newTr.mapping);
+        if (remapped) {
+            newTr.step(remapped);
+        }
+    }
+    Object.keys(tr.meta).forEach((k) => {
+        newTr.setMeta(k, tr.getMeta(k));
+    });
+    return newTr;
+}
+function filterNodes(fragment, predicate) {
+    if (fragment.childCount === 0) {
+        return fragment;
+    }
+    const checked = [];
+    for (let i = 0; i < fragment.childCount; i++) {
+        const node = fragment.child(i);
+        if (predicate(node)) {
+            const newContent = filterNodes(node.content, predicate);
+            if (newContent !== node.content) {
+                const newNode = node.type.create(node.attrs, newContent, node.marks);
+                checked.push(newNode);
+                continue;
+            }
+            checked.push(node);
+        }
+    }
+    return prosemirror_model_1.Fragment.fromArray(checked);
+}
+function clearShadowContent(step) {
+    if (step instanceof prosemirror_transform_1.ReplaceStep && step.slice.content.size) {
+        const newContent = filterNodes(step.slice.content, (node) => !(0, qualifiers_1.isShadowDelete)(node));
+        const newSlice = new prosemirror_model_1.Slice(newContent, step.slice.openStart, step.slice.openEnd);
+        return new prosemirror_transform_1.ReplaceStep(step.from, step.to, newSlice);
+    }
+    return step;
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+/*!
+ * © 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Include = void 0;
+exports.isValid = isValid;
+exports.clear = clear;
+const qualifiers_1 = require("../tracking/steps-trackers/qualifiers");
+const shared_utils_1 = require("./shared-utils");
+var Include;
+(function (Include) {
+    Include[Include["CLEAN"] = 0] = "CLEAN";
+    Include[Include["PENDING"] = 1] = "PENDING";
+    Include[Include["ALL"] = 2] = "ALL";
+})(Include || (exports.Include = Include = {}));
+function isValid(node, include = Include.PENDING) {
+    if (include == Include.CLEAN &&
+        ((0, qualifiers_1.isShadowDelete)(node) || (0, qualifiers_1.isMoved)(node) || (0, shared_utils_1.isDeleted)(node) || (0, shared_utils_1.isDeletedText)(node))) {
+        return false;
+    }
+    if (include == Include.PENDING && ((0, qualifiers_1.isShadowDelete)(node) || (0, qualifiers_1.isMoved)(node))) {
+        return false;
+    }
+    return true;
+}
+function clear(node, include = Include.PENDING) {
+    return {
+        descendants: (fn) => {
+            node.descendants((node, pos, parent, index) => {
+                if (!isValid(node, include)) {
+                    return false;
+                }
+                return fn(node, pos, parent, index);
+            });
+        },
+        forEach: (fn) => {
+            node.forEach((node, offset, index) => {
+                if (!isValid(node, include)) {
+                    return;
+                }
+                fn(node, offset, index);
+            });
+        },
+        nodesBetween: (from, to, fn, startPos) => {
+            node.nodesBetween(from, to, (node, pos, parent, index) => {
+                if (!isValid(node, include)) {
+                    return;
+                }
+                fn(node, pos, parent, index);
+            }, startPos);
+        },
+    };
+}

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTrackChangesClassNames = exports.addTrackChangesAttributes = void 0;
+exports.isDeleted = isDeleted;
+exports.isPendingInsert = isPendingInsert;
+exports.isPending = isPending;
+exports.isPendingSetAttrs = isPendingSetAttrs;
+exports.getChangeClasses = getChangeClasses;
+exports.isTracked = isTracked;
+exports.isDeletedText = isDeletedText;
+exports.getActualTextContent = getActualTextContent;
+exports.sanitizeAttrsChange = sanitizeAttrsChange;
+const transform_1 = require("@manuscripts/transform");
+const change_1 = require("../types/change");
+function isDeleted(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation }) => operation === 'delete');
+    }
+    return false;
+}
+function isPendingInsert(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status }) => operation === 'insert' && status == 'pending');
+    }
+    return false;
+}
+function isPending(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ status }) => status == 'pending');
+    }
+    return false;
+}
+function isPendingSetAttrs(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status }) => operation === 'set_attrs' && status == 'pending');
+    }
+    return false;
+}
+function getChangeClasses(dataTracked) {
+    const classes = [];
+    if (dataTracked) {
+        const changes = dataTracked;
+        const operationClasses = new Map([
+            ['insert', 'inserted'],
+            ['delete', 'deleted'],
+            ['set_attrs', 'set_attrs'],
+        ]);
+        changes.forEach(({ operation, status }) => classes.push(operationClasses.get(operation) || '', status));
+    }
+    return classes;
+}
+function isTracked(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation }) => operation === 'insert' || operation === 'delete' || operation === 'set_attrs');
+    }
+    return false;
+}
+function isDeletedText(node) {
+    var _a, _b, _c, _d;
+    if (node.type === transform_1.schema.nodes.text && node.marks.length) {
+        const deleteMark = node.marks.find((mark) => mark.type === transform_1.schema.marks.tracked_delete);
+        if (deleteMark &&
+            ((_b = (_a = deleteMark.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) === null || _b === void 0 ? void 0 : _b.status) &&
+            'pending' === ((_d = (_c = deleteMark.attrs) === null || _c === void 0 ? void 0 : _c.dataTracked) === null || _d === void 0 ? void 0 : _d.status)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getActualTextContent(fragment) {
+    let finalContent = '';
+    function getContent(fragment) {
+        fragment.forEach((node) => {
+            if (node.type !== transform_1.schema.nodes.text) {
+                finalContent += getContent(node.content);
+            }
+            if (!isDeletedText(node)) {
+                finalContent += node.textContent;
+            }
+        });
+    }
+    getContent(fragment);
+    return finalContent;
+}
+function sanitizeAttrsChange(newAttr, currentAttrs) {
+    return Object.keys(newAttr).reduce((acc, attr) => {
+        const key = attr;
+        if (!currentAttrs[key] && currentAttrs[key] !== 0 && !newAttr[key] && newAttr[key] !== 0) {
+            return acc;
+        }
+        acc[key] = newAttr[key];
+        return acc;
+    }, {});
+}
+const addTrackChangesAttributes = (attrs, dom) => {
+    dom.removeAttribute('data-track-id');
+    dom.removeAttribute('data-track-op');
+    dom.removeAttribute('data-track-status');
+    const changes = attrs.dataTracked;
+    if (!changes || !changes.length) {
+        return;
+    }
+    const change = changes[0];
+    dom.setAttribute('data-track-id', change.id);
+    dom.setAttribute('data-track-op', change.operation);
+    dom.setAttribute('data-track-status', change.status);
+};
+exports.addTrackChangesAttributes = addTrackChangesAttributes;
+const classNames = new Map([
+    [change_1.CHANGE_OPERATION.insert, 'inserted'],
+    [change_1.CHANGE_OPERATION.delete, 'deleted'],
+    [change_1.CHANGE_OPERATION.set_node_attributes, 'set_attrs'],
+]);
+const addTrackChangesClassNames = (attrs, dom) => {
+    dom.classList.remove(...classNames.values());
+    const changes = attrs.dataTracked;
+    if (!changes || !changes.length) {
+        return;
+    }
+    const change = changes[0];
+    const className = classNames.get(change.operation);
+    className && dom.classList.add(className);
+};
+exports.addTrackChangesClassNames = addTrackChangesClassNames;

package/dist/es/index.js

@@ -5,3 +5,5 @@ export { enableDebug } from './utils/logger';
 export { ChangeSet } from './ChangeSet';
 export * from './types/change';
 export * from './types/track';
+export * from './utils/shared-utils';
+export * from './utils/shadow-utils';

package/dist/es/plugin.js

@@ -19,6 +19,7 @@ import { trackChanges } from './trackChanges';
 import { trFromHistory } from './tracking/transactionProcessing';
 import { TrackChangesStatus } from './types/track';
 import { enableDebug, log } from './utils/logger';
+import { normalizeShadowIds } from './tracking/normalizeShadowIds';
 export const trackChangesPluginKey = new PluginKey('track-changes');
 export const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initialStatus: TrackChangesStatus.enabled }) => {
     const { userID, debug, skipTrsWithMetas = [] } = opts;
@@ -102,6 +103,9 @@ export const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous', initi
             if (changed) {
                 log.warn('had to fix inconsistent changes in', createdTr);
             }
+            if (createdTr.docChanged) {
+                createdTr = normalizeShadowIds(createdTr);
+            }
             if (docChanged || createdTr.docChanged || changed) {
                 createdTr.setMeta('origin', trackChangesPluginKey);
                 return setAction(createdTr, TrackChangesAction.refreshChanges, true);

package/dist/es/trackChanges.js

@@ -1,5 +1,5 @@
 /*!
- * © 2025 Atypon Systems LLC
+ * © 2026 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.
@@ -16,7 +16,7 @@
 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';
+import { changeMovedToInsertsOnSourceDeletion, clearShadowsFromNewlyInserted, filterMeaninglessMoveSteps, getIndentationOperationSteps, getMoveOperationsSteps, trFromHistory, } from './tracking/transactionProcessing';
 export function trackChanges(tr, createdTr, oldState, userID, skipTrsWithMetas) {
     var _a;
     const wasAppended = tr.getMeta('appendedTransaction');
@@ -39,6 +39,7 @@ export function trackChanges(tr, createdTr, oldState, userID, skipTrsWithMetas)
             filterMeaninglessMoveSteps,
         ]);
         changeMovedToInsertsOnSourceDeletion(tr, createdTr, trContext);
-        return trackTransaction(tr, oldState, createdTr, userID, clearedSteps, trContext);
+        const clearTr = clearShadowsFromNewlyInserted(tr, oldState);
+        return trackTransaction(clearTr, oldState, createdTr, userID, clearedSteps, trContext);
     }
 }

package/dist/es/tracking/normalizeShadowIds.js

@@ -0,0 +1,46 @@
+/*!
+ * © 2026 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 { isMoved, isShadowDelete } from './steps-trackers/qualifiers';
+export const SHADOW_ID_PREFIX = '__track__changes_shadow__';
+export function normalizeShadowIds(tr) {
+    const changes = [];
+    const shadowRanges = [];
+    function isInShadowRange(pos) {
+        return shadowRanges.some((range) => pos >= range.from && pos < range.to);
+    }
+    tr.doc.descendants((node, pos) => {
+        if (isShadowDelete(node) || isMoved(node)) {
+            shadowRanges.push({ from: pos, to: pos + node.nodeSize });
+        }
+        if (typeof node.attrs.id === 'string' && node.attrs.id) {
+            const currentId = node.attrs.id;
+            const hasShadowPrefix = currentId.startsWith(SHADOW_ID_PREFIX);
+            const inShadow = isInShadowRange(pos);
+            if (inShadow && !hasShadowPrefix) {
+                changes.push({ pos, node, newId: SHADOW_ID_PREFIX + currentId });
+            }
+            else if (!inShadow && hasShadowPrefix) {
+                changes.push({ pos, node, newId: currentId.slice(SHADOW_ID_PREFIX.length) });
+            }
+        }
+        return true;
+    });
+    for (let i = changes.length - 1; i >= 0; i--) {
+        const { pos, node, newId } = changes[i];
+        tr.setNodeMarkup(pos, null, Object.assign(Object.assign({}, node.attrs), { id: newId }));
+    }
+    return tr;
+}

package/dist/es/tracking/steps-trackers/qualifiers.js

@@ -87,3 +87,17 @@ export const isDeletingPendingMovedNode = (step, doc) => {
     }
     return undefined;
 };
+export function isShadowDelete(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, moveNodeId }) => operation === 'delete' && moveNodeId);
+    }
+    return false;
+}
+export function isMoved(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status, moveNodeId }) => operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.pending && moveNodeId);
+    }
+    return false;
+}

package/dist/es/tracking/transactionProcessing.js

@@ -1,9 +1,10 @@
+import { Fragment, Slice } from 'prosemirror-model';
 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';
+import { isDeletingPendingMovedNode, isDirectPendingMoveDeletion, isShadowDelete, } from './steps-trackers/qualifiers';
 export function getIndentationOperationSteps(tr, trContext) {
     if (isIndentationAction(trContext.action)) {
         const moveId = uuidv4();
@@ -151,3 +152,62 @@ export const filterMeaninglessMoveSteps = (tr, context) => {
     return cleanSteps;
 };
 export const trFromHistory = (tr) => Object.keys(tr.meta).find((s) => s.startsWith('history$'));
+export function clearShadowsFromNewlyInserted(tr, baseState) {
+    let hasShadowContent = false;
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        if (step instanceof ReplaceStep && step.slice.content.size) {
+            step.slice.content.descendants((node) => {
+                if (isShadowDelete(node)) {
+                    hasShadowContent = true;
+                    return false;
+                }
+            });
+            if (hasShadowContent)
+                break;
+        }
+    }
+    if (!hasShadowContent) {
+        return tr;
+    }
+    const newTr = baseState.tr;
+    for (let i = 0; i < tr.steps.length; i++) {
+        const step = tr.steps[i];
+        const clearStep = clearShadowContent(step);
+        const remapped = clearStep.map(newTr.mapping);
+        if (remapped) {
+            newTr.step(remapped);
+        }
+    }
+    Object.keys(tr.meta).forEach((k) => {
+        newTr.setMeta(k, tr.getMeta(k));
+    });
+    return newTr;
+}
+function filterNodes(fragment, predicate) {
+    if (fragment.childCount === 0) {
+        return fragment;
+    }
+    const checked = [];
+    for (let i = 0; i < fragment.childCount; i++) {
+        const node = fragment.child(i);
+        if (predicate(node)) {
+            const newContent = filterNodes(node.content, predicate);
+            if (newContent !== node.content) {
+                const newNode = node.type.create(node.attrs, newContent, node.marks);
+                checked.push(newNode);
+                continue;
+            }
+            checked.push(node);
+        }
+    }
+    return Fragment.fromArray(checked);
+}
+function clearShadowContent(step) {
+    if (step instanceof ReplaceStep && step.slice.content.size) {
+        const newContent = filterNodes(step.slice.content, (node) => !isShadowDelete(node));
+        const newSlice = new Slice(newContent, step.slice.openStart, step.slice.openEnd);
+        return new ReplaceStep(step.from, step.to, newSlice);
+    }
+    return step;
+}

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

@@ -0,0 +1,61 @@
+/*!
+ * © 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 { isMoved, isShadowDelete } from '../tracking/steps-trackers/qualifiers';
+import { isDeleted, isDeletedText } from './shared-utils';
+export var Include;
+(function (Include) {
+    Include[Include["CLEAN"] = 0] = "CLEAN";
+    Include[Include["PENDING"] = 1] = "PENDING";
+    Include[Include["ALL"] = 2] = "ALL";
+})(Include || (Include = {}));
+export function isValid(node, include = Include.PENDING) {
+    if (include == Include.CLEAN &&
+        (isShadowDelete(node) || isMoved(node) || isDeleted(node) || isDeletedText(node))) {
+        return false;
+    }
+    if (include == Include.PENDING && (isShadowDelete(node) || isMoved(node))) {
+        return false;
+    }
+    return true;
+}
+export function clear(node, include = Include.PENDING) {
+    return {
+        descendants: (fn) => {
+            node.descendants((node, pos, parent, index) => {
+                if (!isValid(node, include)) {
+                    return false;
+                }
+                return fn(node, pos, parent, index);
+            });
+        },
+        forEach: (fn) => {
+            node.forEach((node, offset, index) => {
+                if (!isValid(node, include)) {
+                    return;
+                }
+                fn(node, offset, index);
+            });
+        },
+        nodesBetween: (from, to, fn, startPos) => {
+            node.nodesBetween(from, to, (node, pos, parent, index) => {
+                if (!isValid(node, include)) {
+                    return;
+                }
+                fn(node, pos, parent, index);
+            }, startPos);
+        },
+    };
+}

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

@@ -0,0 +1,115 @@
+import { schema } from '@manuscripts/transform';
+import { CHANGE_OPERATION } from '../types/change';
+export function isDeleted(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation }) => operation === 'delete');
+    }
+    return false;
+}
+export function isPendingInsert(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status }) => operation === 'insert' && status == 'pending');
+    }
+    return false;
+}
+export function isPending(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ status }) => status == 'pending');
+    }
+    return false;
+}
+export function isPendingSetAttrs(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation, status }) => operation === 'set_attrs' && status == 'pending');
+    }
+    return false;
+}
+export function getChangeClasses(dataTracked) {
+    const classes = [];
+    if (dataTracked) {
+        const changes = dataTracked;
+        const operationClasses = new Map([
+            ['insert', 'inserted'],
+            ['delete', 'deleted'],
+            ['set_attrs', 'set_attrs'],
+        ]);
+        changes.forEach(({ operation, status }) => classes.push(operationClasses.get(operation) || '', status));
+    }
+    return classes;
+}
+export function isTracked(node) {
+    if (node.attrs.dataTracked) {
+        const changes = node.attrs.dataTracked;
+        return changes.some(({ operation }) => operation === 'insert' || operation === 'delete' || operation === 'set_attrs');
+    }
+    return false;
+}
+export function isDeletedText(node) {
+    var _a, _b, _c, _d;
+    if (node.type === schema.nodes.text && node.marks.length) {
+        const deleteMark = node.marks.find((mark) => mark.type === schema.marks.tracked_delete);
+        if (deleteMark &&
+            ((_b = (_a = deleteMark.attrs) === null || _a === void 0 ? void 0 : _a.dataTracked) === null || _b === void 0 ? void 0 : _b.status) &&
+            'pending' === ((_d = (_c = deleteMark.attrs) === null || _c === void 0 ? void 0 : _c.dataTracked) === null || _d === void 0 ? void 0 : _d.status)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function getActualTextContent(fragment) {
+    let finalContent = '';
+    function getContent(fragment) {
+        fragment.forEach((node) => {
+            if (node.type !== schema.nodes.text) {
+                finalContent += getContent(node.content);
+            }
+            if (!isDeletedText(node)) {
+                finalContent += node.textContent;
+            }
+        });
+    }
+    getContent(fragment);
+    return finalContent;
+}
+export function sanitizeAttrsChange(newAttr, currentAttrs) {
+    return Object.keys(newAttr).reduce((acc, attr) => {
+        const key = attr;
+        if (!currentAttrs[key] && currentAttrs[key] !== 0 && !newAttr[key] && newAttr[key] !== 0) {
+            return acc;
+        }
+        acc[key] = newAttr[key];
+        return acc;
+    }, {});
+}
+export const addTrackChangesAttributes = (attrs, dom) => {
+    dom.removeAttribute('data-track-id');
+    dom.removeAttribute('data-track-op');
+    dom.removeAttribute('data-track-status');
+    const changes = attrs.dataTracked;
+    if (!changes || !changes.length) {
+        return;
+    }
+    const change = changes[0];
+    dom.setAttribute('data-track-id', change.id);
+    dom.setAttribute('data-track-op', change.operation);
+    dom.setAttribute('data-track-status', change.status);
+};
+const classNames = new Map([
+    [CHANGE_OPERATION.insert, 'inserted'],
+    [CHANGE_OPERATION.delete, 'deleted'],
+    [CHANGE_OPERATION.set_node_attributes, 'set_attrs'],
+]);
+export const addTrackChangesClassNames = (attrs, dom) => {
+    dom.classList.remove(...classNames.values());
+    const changes = attrs.dataTracked;
+    if (!changes || !changes.length) {
+        return;
+    }
+    const change = changes[0];
+    const className = classNames.get(change.operation);
+    className && dom.classList.add(className);
+};

package/dist/types/index.d.ts

@@ -5,3 +5,5 @@ export { enableDebug } from './utils/logger';
 export { ChangeSet } from './ChangeSet';
 export * from './types/change';
 export * from './types/track';
+export * from './utils/shared-utils';
+export * from './utils/shadow-utils';

package/dist/types/trackChanges.d.ts

@@ -1,5 +1,5 @@
 /*!
- * © 2025 Atypon Systems LLC
+ * © 2026 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/types/tracking/normalizeShadowIds.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * © 2026 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 { Transaction } from 'prosemirror-state';
+export declare const SHADOW_ID_PREFIX = "__track__changes_shadow__";
+export declare function normalizeShadowIds(tr: Transaction): Transaction;

package/dist/types/tracking/steps-trackers/qualifiers.d.ts

@@ -28,3 +28,5 @@ export declare function isLiftStepForGap(gap: {
 }, node: PMNode, to: number): boolean;
 export declare const isDirectPendingMoveDeletion: (step: ReplaceStep, doc: PMNode, movingSteps: Map<ReplaceStep, string>) => boolean;
 export declare const isDeletingPendingMovedNode: (step: ReplaceStep, doc: PMNode) => string | undefined;
+export declare function isShadowDelete(node: PMNode): boolean;
+export declare function isMoved(node: PMNode): boolean;

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

@@ -1,5 +1,5 @@
 import { Node as PMNode } from 'prosemirror-model';
-import { Transaction } from 'prosemirror-state';
+import { EditorState, Transaction } from 'prosemirror-state';
 import { ReplaceStep, Step } from 'prosemirror-transform';
 import { TrTrackingContext } from './types';
 export declare function getIndentationOperationSteps(tr: Transaction, trContext: TrTrackingContext): void;
@@ -10,3 +10,4 @@ export declare const getMoveOperationsSteps: (tr: Transaction, context: TrTracki
 export declare const changeMovedToInsertsOnSourceDeletion: (tr: Transaction, newTr: Transaction, trContext: TrTrackingContext) => void;
 export declare const filterMeaninglessMoveSteps: (tr: Transaction, context: TrTrackingContext) => (Step | null)[];
 export declare const trFromHistory: (tr: Transaction) => string | undefined;
+export declare function clearShadowsFromNewlyInserted(tr: Transaction, baseState: EditorState): Transaction;

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

@@ -0,0 +1,30 @@
+/*!
+ * © 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 { Node as PMNode } from 'prosemirror-model';
+type callback = (node: PMNode, pos: number, parent: PMNode | null, index: number) => void | boolean;
+type forEachCallback = (node: PMNode, offset: number, index: number) => void;
+export declare enum Include {
+    CLEAN = 0,
+    PENDING = 1,
+    ALL = 2
+}
+export declare function isValid(node: PMNode, include?: Include): boolean;
+export declare function clear(node: PMNode, include?: Include): {
+    descendants: (fn: callback) => void;
+    forEach: (fn: forEachCallback) => void;
+    nodesBetween: (from: number, to: number, fn: (node: PMNode, pos: number, parent: PMNode | null, index: number) => void | boolean, startPos?: number) => void;
+};
+export {};

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

@@ -0,0 +1,13 @@
+import { Attrs, Fragment, Mark, Node as ProsemirrorNode } from 'prosemirror-model';
+import { TrackedAttrs } from '../types/change';
+export declare function isDeleted(node: ProsemirrorNode | Mark): boolean;
+export declare function isPendingInsert(node: ProsemirrorNode): boolean;
+export declare function isPending(node: ProsemirrorNode): boolean;
+export declare function isPendingSetAttrs(node: ProsemirrorNode): boolean;
+export declare function getChangeClasses(dataTracked?: TrackedAttrs[]): string[];
+export declare function isTracked(node: ProsemirrorNode | Mark): boolean;
+export declare function isDeletedText(node: ProsemirrorNode): boolean;
+export declare function getActualTextContent(fragment: Fragment): string;
+export declare function sanitizeAttrsChange<T extends ProsemirrorNode>(newAttr: T['attrs'], currentAttrs: T['attrs']): T["attrs"];
+export declare const addTrackChangesAttributes: (attrs: Attrs, dom: Element) => void;
+export declare const addTrackChangesClassNames: (attrs: Attrs, dom: Element) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@manuscripts/track-changes-plugin",
-  "version": "2.3.7",
+  "version": "2.3.9",
   "author": "Atypon Systems LLC",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Atypon-OpenSource/manuscripts-track-changes-plugin",
@@ -17,7 +17,7 @@
     "build:es": "tsc --outDir dist/es --declarationDir dist/types --declaration",
     "dev": "npm-run-all --parallel 'build:* --watch'",
     "test": "jest --runInBand",
-    "test-rs": "jest -i test/nodes/nodes.test.ts",
+    "test-rs": "jest -i test/text/text.test.ts",
     "format": "prettier --write \"*.+(js|json|yml|yaml|ts|md|graphql|mdx)\" src/ test/",
     "typecheck": "tsc --project tsconfig.test.json --noEmit",
     "lint": "eslint --cache --ext .js,.ts, ./src ./test",