@manuscripts/track-changes-plugin 0.2.0 → 0.4.1

package/dist/index.js

@@ -30,7 +30,14 @@ function getAction(tr, action) {
  */
 function setAction(tr, action, payload) {
     return tr.setMeta(action, payload);
-}
+}
+/**
+ * Skip tracking for a transaction, use this with caution to avoid race-conditions or just to otherwise
+ * omitting applying of track attributes or marks.
+ * @param tr
+ * @returns
+ */
+const skipTracking = (tr) => setAction(tr, TrackChangesAction.skipTrack, true);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -79,11 +86,11 @@ var CHANGE_OPERATION;
 (function (CHANGE_OPERATION) {
     CHANGE_OPERATION["insert"] = "insert";
     CHANGE_OPERATION["delete"] = "delete";
-    CHANGE_OPERATION["set_node_attributes"] = "set_node_attributes";
-    CHANGE_OPERATION["wrap_with_node"] = "wrap_with_node";
-    CHANGE_OPERATION["unwrap_from_node"] = "unwrap_from_node";
-    CHANGE_OPERATION["add_mark"] = "add_mark";
-    CHANGE_OPERATION["remove_mark"] = "remove_mark";
+    CHANGE_OPERATION["set_node_attributes"] = "set_attrs";
+    // wrap_with_node = 'wrap_with_node',
+    // unwrap_from_node = 'unwrap_from_node',
+    // add_mark = 'add_mark',
+    // remove_mark = 'remove_mark',
 })(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
 var CHANGE_STATUS;
 (function (CHANGE_STATUS) {
@@ -164,8 +171,8 @@ class ChangeSet {
     get changes() {
         const iteratedIds = new Set();
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => {
-            const valid = !iteratedIds.has(c.attrs.id) && ChangeSet.isValidTrackedAttrs(c.attrs);
-            iteratedIds.add(c.attrs.id);
+            const valid = !iteratedIds.has(c.dataTracked.id) && ChangeSet.isValidDataTracked(c.dataTracked);
+            iteratedIds.add(c.dataTracked.id);
             return valid;
         });
     }
@@ -184,16 +191,13 @@ class ChangeSet {
                 rootNodes.push(currentNodeChange);
                 currentNodeChange = undefined;
             }
-            if (c.type === 'node-change' && currentNodeChange && c.from < currentNodeChange.to) {
+            if (currentNodeChange && c.from < currentNodeChange.to) {
                 currentNodeChange.children.push(c);
             }
             else if (c.type === 'node-change') {
                 currentNodeChange = { ...c, children: [] };
             }
-            else if (c.type === 'text-change' && currentNodeChange && c.from < currentNodeChange.to) {
-                currentNodeChange.children.push(c);
-            }
-            else if (c.type === 'text-change') {
+            else {
                 rootNodes.push(c);
             }
         });
@@ -203,13 +207,13 @@ class ChangeSet {
         return rootNodes;
     }
     get pending() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.pending);
     }
     get accepted() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.accepted);
     }
     get rejected() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
+        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.rejected);
     }
     get textChanges() {
         return this.changes.filter((c) => c.type === 'text-change');
@@ -217,6 +221,9 @@ class ChangeSet {
     get nodeChanges() {
         return this.changes.filter((c) => c.type === 'node-change');
     }
+    get nodeAttrChanges() {
+        return this.changes.filter((c) => c.type === 'node-attr-change');
+    }
     get isEmpty() {
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
     }
@@ -237,7 +244,7 @@ class ChangeSet {
         });
     }
     get hasIncompleteAttrs() {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidTrackedAttrs(c.attrs));
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidDataTracked(c.dataTracked));
     }
     get(id) {
         return __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id);
@@ -257,37 +264,40 @@ class ChangeSet {
     static flattenTreeToIds(changes) {
         return changes.flatMap((c) => this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id);
     }
-    /**
-     * Determines whether a change should not be deleted when applying it to the document.
-     * @param change
-     */
-    static shouldNotDelete(change) {
-        const { status, operation } = change.attrs;
-        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.accepted) ||
-            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.rejected));
-    }
     /**
      * Determines whether a change should be deleted when applying it to the document.
      * @param change
      */
     static shouldDeleteChange(change) {
-        const { status, operation } = change.attrs;
+        const { status, operation } = change.dataTracked;
         return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
             (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
     }
     /**
      * Checks whether change attributes contain all TrackedAttrs keys with non-undefined values
-     * @param attrs
+     * @param dataTracked
      */
-    static isValidTrackedAttrs(attrs = {}) {
-        if ('attrs' in attrs) {
-            log.warn('passed "attrs" as property to isValidTrackedAttrs(attrs)', attrs);
+    static isValidDataTracked(dataTracked = {}) {
+        if ('dataTracked' in dataTracked) {
+            log.warn('passed "dataTracked" as property to isValidTrackedAttrs()', dataTracked);
         }
-        const trackedKeys = ['id', 'userID', 'operation', 'status', 'createdAt'];
-        const entries = Object.entries(attrs);
+        const trackedKeys = [
+            'id',
+            'authorID',
+            'operation',
+            'status',
+            'createdAt',
+            'updatedAt',
+        ];
+        // reviewedByID is set optional since either ProseMirror or Yjs doesn't like persisting null values inside attributes objects
+        // So it can be either omitted completely or at least be null or string
+        const optionalKeys = ['reviewedByID'];
+        const entries = Object.entries(dataTracked).filter(([key, val]) => trackedKeys.includes(key));
+        const optionalEntries = Object.entries(dataTracked).filter(([key, val]) => optionalKeys.includes(key));
         return (entries.length === trackedKeys.length &&
             entries.every(([key, val]) => trackedKeys.includes(key) && val !== undefined) &&
-            (attrs.id || '').length > 0 // Changes created with undefined id have '' as placeholder
+            optionalEntries.every(([key, val]) => optionalKeys.includes(key) && val !== undefined) &&
+            (dataTracked.id || '').length > 0 // Changes created with undefined id have '' as placeholder
         );
     }
     static isTextChange(change) {
@@ -296,9 +306,102 @@ class ChangeSet {
     static isNodeChange(change) {
         return change.type === 'node-change';
     }
+    static isNodeAttrChange(change) {
+        return change.type === 'node-attr-change';
+    }
 }
 _ChangeSet_changes = new WeakMap();
 
+/*!
+ * © 2021 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.
+ */
+function uuidv4() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+
+function addTrackIdIfDoesntExist(attrs) {
+    if (!attrs.id) {
+        return {
+            id: uuidv4(),
+            ...attrs,
+        };
+    }
+    return attrs;
+}
+function getTextNodeTrackedMarkData(node, schema) {
+    if (!node || !node.isText) {
+        return undefined;
+    }
+    const marksTrackedData = [];
+    node.marks.forEach((mark) => {
+        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
+            const operation = mark.type === schema.marks.tracked_insert
+                ? CHANGE_OPERATION.insert
+                : CHANGE_OPERATION.delete;
+            marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
+        }
+    });
+    if (marksTrackedData.length > 1) {
+        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
+    }
+    return marksTrackedData[0] || undefined;
+}
+function getBlockInlineTrackedData(node) {
+    let { dataTracked } = node.attrs;
+    if (dataTracked && !Array.isArray(dataTracked)) {
+        return [dataTracked];
+    }
+    return dataTracked;
+}
+function getNodeTrackedData(node, schema) {
+    let tracked;
+    if (node && !node.isText) {
+        tracked = getBlockInlineTrackedData(node);
+    }
+    else if (node === null || node === void 0 ? void 0 : node.isText) {
+        tracked = getTextNodeTrackedMarkData(node, schema);
+    }
+    if (tracked && !Array.isArray(tracked)) {
+        tracked = [tracked];
+    }
+    return tracked;
+}
+function equalMarks(n1, n2) {
+    return (n1.marks.length === n2.marks.length &&
+        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
+}
+function shouldMergeTrackedAttributes(left, right) {
+    if (!left || !right) {
+        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
+            left,
+            right,
+        });
+        return false;
+    }
+    return (left.status === right.status &&
+        left.operation === right.operation &&
+        left.authorID === right.authorID);
+}
+function getMergeableMarkTrackedAttrs(node, attrs, schema) {
+    const nodeAttrs = getTextNodeTrackedMarkData(node, schema);
+    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
+}
+
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -328,7 +431,7 @@ function deleteNode(node, pos, tr) {
     const startPos = tr.doc.resolve(pos + 1);
     const range = startPos.blockRange(tr.doc.resolve(startPos.pos - 2 + node.nodeSize));
     const targetDepth = range && liftTarget(range);
-    // Check with typeof since with old prosemirror-transform targetDepth is undefined
+    // Check with typeof since with prosemirror-transform pre 1.6.0 targetDepth is undefined
     if (range && typeof targetDepth === 'number') {
         return tr.lift(range, targetDepth);
     }
@@ -344,6 +447,29 @@ function deleteNode(node, pos, tr) {
         // child, say some wrapper blockNode, is also deleted the content could be retained. TODO I guess.
         return tr.delete(pos, pos + node.nodeSize);
     }
+}
+/**
+ * Deletes inserted block or inline node, otherwise adds `dataTracked` object with CHANGE_STATUS 'deleted'
+ * @param node
+ * @param pos
+ * @param newTr
+ * @param deleteAttrs
+ */
+function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
+    const dataTracked = getBlockInlineTrackedData(node);
+    const inserted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.insert);
+    const deleted = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.delete);
+    const updated = dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
+    if (inserted && inserted.authorID === deleteAttrs.authorID) {
+        return deleteNode(node, pos, newTr);
+    }
+    const newDeleted = deleted
+        ? { ...deleted, updatedAt: deleteAttrs.updatedAt }
+        : addTrackIdIfDoesntExist(deleteAttrs);
+    newTr.setNodeMarkup(pos, undefined, {
+        ...node.attrs,
+        dataTracked: updated ? [newDeleted, updated] : [newDeleted],
+    }, node.marks);
 }
 
 /*!
@@ -386,101 +512,49 @@ function mergeNode(node, pos, tr) {
     return undefined;
 }
 
-/*!
- * © 2021 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.
- */
-function uuidv4() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-
-function addTrackIdIfDoesntExist(attrs) {
-    if (!attrs.id) {
-        return {
-            id: uuidv4(),
-            ...attrs,
-        };
-    }
-    return attrs;
-}
-function getInlineNodeTrackedMarkData(node, schema) {
-    if (!node || !node.isInline) {
-        return undefined;
-    }
-    const marksTrackedData = [];
-    node.marks.forEach((mark) => {
-        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
-            const operation = mark.type === schema.marks.tracked_insert
-                ? CHANGE_OPERATION.insert
-                : CHANGE_OPERATION.delete;
-            marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
-        }
-    });
-    if (marksTrackedData.length > 1) {
-        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
-    }
-    return marksTrackedData[0] || undefined;
-}
-function getNodeTrackedData(node, schema) {
-    return !node
-        ? undefined
-        : node.isText
-            ? getInlineNodeTrackedMarkData(node, schema)
-            : node.attrs.dataTracked;
-}
-function equalMarks(n1, n2) {
-    return (n1.marks.length === n2.marks.length &&
-        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
-}
-function shouldMergeTrackedAttributes(left, right) {
-    if (!left || !right) {
-        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
-            left,
-            right,
-        });
-        return false;
-    }
-    return (left.status === right.status &&
-        left.operation === right.operation &&
-        left.userID === right.userID);
-}
-function getMergeableMarkTrackedAttrs(node, attrs, schema) {
-    const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
-    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
-}
-
 function updateChangeAttrs(tr, change, trackedAttrs, schema) {
     const node = tr.doc.nodeAt(change.from);
     if (!node) {
-        throw Error('No node at the from of change' + change);
+        log.error('updateChangeAttrs: no node at the from of change ', change);
+        return tr;
+    }
+    const { operation } = trackedAttrs;
+    const oldTrackData = change.type === 'text-change'
+        ? getTextNodeTrackedMarkData(node, schema)
+        : getBlockInlineTrackedData(node);
+    if (!operation) {
+        log.warn('updateChangeAttrs: unable to determine operation of change ', change);
+    }
+    else if (!oldTrackData) {
+        log.warn('updateChangeAttrs: no old dataTracked for change ', change);
+    }
+    if (change.type === 'text-change') {
+        const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
+        if (!oldMark) {
+            log.warn('updateChangeAttrs: no track marks for a text-change ', change);
+            return tr;
+        }
+        // TODO add operation based on mark type if it's undefined?
+        tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked: { ...oldTrackData, ...trackedAttrs } }));
     }
-    const dataTracked = { ...getNodeTrackedData(node, schema), ...trackedAttrs };
-    const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
-    if (change.type === 'text-change' && oldMark) {
-        tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked }));
+    else if (change.type === 'node-change' && !operation) {
+        // Very weird edge-case if this happens
+        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked: null }, node.marks);
     }
     else if (change.type === 'node-change') {
-        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked }, node.marks);
+        const newDataTracked = (getBlockInlineTrackedData(node) || []).map((oldTrack) => {
+            if (oldTrack.operation === operation) {
+                return { ...oldTrack, ...trackedAttrs };
+            }
+            return oldTrack;
+        });
+        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked: newDataTracked.length === 0 ? null : newDataTracked }, node.marks);
     }
     return tr;
 }
 function updateChangeChildrenAttributes(changes, tr, mapping) {
     changes.forEach((c) => {
-        if (c.type === 'node-change' && ChangeSet.shouldNotDelete(c)) {
+        if (c.type === 'node-change' && !ChangeSet.shouldDeleteChange(c)) {
             const from = mapping.map(c.from);
             const node = tr.doc.nodeAt(from);
             if (!node) {
@@ -502,12 +576,12 @@ function updateChangeChildrenAttributes(changes, tr, mapping) {
  */
 function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
     changes.forEach((change) => {
-        if (change.attrs.status === CHANGE_STATUS.pending) {
+        if (change.dataTracked.status === CHANGE_STATUS.pending) {
             return;
         }
         // Map change.from and skip those which dont need to be applied
         // or were already deleted by an applied block delete
-        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || ChangeSet.shouldNotDelete(change);
+        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || !ChangeSet.shouldDeleteChange(change);
         if (!node) {
             !deleted && log.warn('no node found to update for change', change);
             return;
@@ -535,6 +609,16 @@ function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mappi
             }
             deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
         }
+        else if (ChangeSet.isNodeAttrChange(change) &&
+            change.dataTracked.status === CHANGE_STATUS.accepted) {
+            const attrs = { ...node.attrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
+        else if (ChangeSet.isNodeAttrChange(change) &&
+            change.dataTracked.status === CHANGE_STATUS.rejected) {
+            const attrs = { ...change.oldAttrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
     });
     return deleteMap;
 }
@@ -553,9 +637,10 @@ function findChanges(state) {
     // Store the last iterated change to join adjacent text changes
     let current;
     state.doc.descendants((node, pos) => {
-        const attrs = getNodeTrackedData(node, state.schema);
-        if (attrs) {
-            const id = (attrs === null || attrs === void 0 ? void 0 : attrs.id) || '';
+        const tracked = getNodeTrackedData(node, state.schema) || [];
+        for (let i = 0; i < tracked.length; i += 1) {
+            const dataTracked = tracked[i];
+            const id = dataTracked.id || '';
             // Join adjacent text changes that have been broken up due to different marks
             // eg <ins><b>bold</b>norm<i>italic</i></ins> -> treated as one continuous change
             // Note the !equalMarks to leave changes separate incase the marks are equal to let fixInconsistentChanges to fix them
@@ -567,37 +652,49 @@ function findChanges(state) {
                 current.change.to = pos + node.nodeSize;
                 // Important to update the node as the text changes might contain multiple parts where some marks equal each other
                 current.node = node;
+                continue;
             }
-            else if (node.isText) {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'text-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        attrs,
-                    },
-                    node,
+            current && changes.push(current.change);
+            let change;
+            if (node.isText) {
+                change = {
+                    id,
+                    type: 'text-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    text: node.text,
+                };
+            }
+            else if (dataTracked.operation === CHANGE_OPERATION.set_node_attributes) {
+                change = {
+                    id,
+                    type: 'node-attr-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    newAttrs: node.attrs,
+                    oldAttrs: dataTracked.oldAttrs,
                 };
             }
             else {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'node-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        nodeType: node.type.name,
-                        children: [],
-                        attrs,
-                    },
-                    node,
+                change = {
+                    id,
+                    type: 'node-change',
+                    from: pos,
+                    to: pos + node.nodeSize,
+                    dataTracked,
+                    nodeType: node.type.name,
+                    children: [],
                 };
             }
+            current = {
+                change,
+                node,
+            };
         }
-        else if (current) {
+        if (tracked.length === 0 && current) {
             changes.push(current.change);
             current = undefined;
         }
@@ -616,20 +713,23 @@ function findChanges(state) {
  * @param schema
  * @return docWasChanged, a boolean
  */
-function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
+function fixInconsistentChanges(changeSet, currentUserID, newTr, schema) {
     const iteratedIds = new Set();
     let changed = false;
     changeSet.invalidChanges.forEach((c) => {
-        const { id, userID, operation, status, createdAt } = c.attrs;
+        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.dataTracked;
         const newAttrs = {
             ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
-            ...(!userID && { userID: trackUserID }),
-            ...(!operation && { operation: CHANGE_OPERATION.insert }),
+            ...(!authorID && { authorID: currentUserID }),
+            // Dont add a default operation -> rather have updateChangeAttrs delete the track data
+            // ...(!operation && { operation: CHANGE_OPERATION.insert }),
+            ...(!reviewedByID && { reviewedByID: null }),
             ...(!status && { status: CHANGE_STATUS.pending }),
             ...(!createdAt && { createdAt: Date.now() }),
+            ...(!updatedAt && { updatedAt: Date.now() }),
         };
         if (Object.keys(newAttrs).length > 0) {
-            updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
+            updateChangeAttrs(newTr, c, { ...c.dataTracked, ...newAttrs }, schema);
             changed = true;
         }
         iteratedIds.add(newAttrs.id || id);
@@ -637,87 +737,6 @@ function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
     return changed;
 }
 
-/*!
- * © 2021 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.
- */
-function markInlineNodeChange(node, newTrackAttrs, schema) {
-    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
-    const mark = newTrackAttrs.operation === CHANGE_OPERATION.insert
-        ? schema.marks.tracked_insert
-        : schema.marks.tracked_delete;
-    const createdMark = mark.create({
-        dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-    });
-    return node.mark(filtered.concat(createdMark));
-}
-function recurseNodeContent(node, newTrackAttrs, schema) {
-    if (node.isText) {
-        return markInlineNodeChange(node, newTrackAttrs, schema);
-    }
-    else if (node.isBlock || node.isInline) {
-        const updatedChildren = [];
-        node.content.forEach((child) => {
-            updatedChildren.push(recurseNodeContent(child, newTrackAttrs, schema));
-        });
-        return node.type.create({
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-        }, Fragment.fromArray(updatedChildren), node.marks);
-    }
-    else {
-        log.error(`unhandled node type: "${node.type.name}"`, node);
-        return node;
-    }
-}
-function setFragmentAsInserted(inserted, insertAttrs, schema) {
-    // Recurse the content in the inserted slice and either mark it tracked_insert or set node attrs
-    const updatedInserted = [];
-    inserted.forEach((n) => {
-        updatedInserted.push(recurseNodeContent(n, insertAttrs, schema));
-    });
-    return updatedInserted.length === 0 ? inserted : Fragment.fromArray(updatedInserted);
-}
-
-/*!
- * © 2021 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.
- */
-function createNewInsertAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.insert,
-    };
-}
-function createNewDeleteAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.delete,
-    };
-}
-
 /*!
  * © 2021 Atypon Systems LLC
  *
@@ -813,70 +832,133 @@ function splitSliceIntoMergedParts(insertSlice, mergeEqualSides = false) {
         firstMergedNode,
         lastMergedNode,
     };
-}
-/**
- * Deletes inserted text directly, otherwise wraps it with tracked_delete mark
+}
+
+/*!
+ * © 2021 Atypon Systems LLC
  *
- * This would work for general inline nodes too, but since node marks don't work properly
- * with Yjs, attributes are used instead.
- * @param node
- * @param pos
- * @param newTr
- * @param schema
- * @param deleteAttrs
- * @param from
- * @param to
+ * 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.
  */
-function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
-    const start = from ? Math.max(pos, from) : pos;
-    const nodeEnd = pos + node.nodeSize;
-    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
-    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
-        // Math.max(pos, from) is for picking always the start of the node,
-        // not the start of the change (which might span multiple nodes).
-        // Pos can be less than from as nodesBetween iterates through all nodes starting from the top block node
-        newTr.replaceWith(start, end, Fragment.empty);
-        return start;
-    }
-    else {
-        const leftNode = newTr.doc.resolve(start).nodeBefore;
-        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
-        const rightNode = newTr.doc.resolve(end).nodeAfter;
-        const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
-        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
-        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
-        const dataTracked = addTrackIdIfDoesntExist({
-            ...leftMarks,
-            ...rightMarks,
-            ...deleteAttrs,
-        });
-        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
-            dataTracked,
-        }));
-        return toEndOfMark;
-    }
+function markInlineNodeChange(node, newTrackAttrs, schema) {
+    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
+    const mark = newTrackAttrs.operation === CHANGE_OPERATION.insert
+        ? schema.marks.tracked_insert
+        : schema.marks.tracked_delete;
+    const createdMark = mark.create({
+        dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
+    });
+    return node.mark(filtered.concat(createdMark));
 }
 /**
- * Deletes inserted block or inline node, otherwise adds `dataTracked` object with CHANGE_STATUS 'deleted'
- * @param node
- * @param pos
- * @param newTr
- * @param deleteAttrs
+ * Iterates over fragment's content and joins pasted text with old track marks
+ *
+ * This is not strictly necessary but it's kinda bad UX if the inserted text is split into parts
+ * even when it's authored by the same user.
+ * @param content
+ * @param newTrackAttrs
+ * @param schema
+ * @returns
  */
-function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
-    const dataTracked = node.attrs.dataTracked;
-    const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === CHANGE_OPERATION.insert && dataTracked.userID === deleteAttrs.userID;
-    if (wasInsertedBySameUser) {
-        deleteNode(node, pos, newTr);
+function loopContentAndMergeText(content, newTrackAttrs, schema) {
+    var _a;
+    const updatedChildren = [];
+    for (let i = 0; i < content.childCount; i += 1) {
+        const recursed = recurseNodeContent(content.child(i), newTrackAttrs, schema);
+        const prev = i > 0 ? updatedChildren[i - 1] : null;
+        if ((prev === null || prev === void 0 ? void 0 : prev.isText) &&
+            recursed.isText &&
+            equalMarks(prev, recursed) &&
+            ((_a = getTextNodeTrackedMarkData(prev, schema)) === null || _a === void 0 ? void 0 : _a.operation) === CHANGE_OPERATION.insert) {
+            updatedChildren.splice(i - 1, 1, schema.text('' + prev.text + recursed.text, prev.marks));
+        }
+        else {
+            updatedChildren.push(recursed);
+        }
     }
-    else {
-        const attrs = {
+    return updatedChildren;
+}
+function recurseNodeContent(node, newTrackAttrs, schema) {
+    if (node.isText) {
+        return markInlineNodeChange(node, newTrackAttrs, schema);
+    }
+    else if (node.isBlock || node.isInline) {
+        const updatedChildren = loopContentAndMergeText(node.content, newTrackAttrs, schema);
+        return node.type.create({
             ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
-        };
-        newTr.setNodeMarkup(pos, undefined, attrs, node.marks);
+            dataTracked: [addTrackIdIfDoesntExist(newTrackAttrs)],
+        }, Fragment.fromArray(updatedChildren), node.marks);
+    }
+    else {
+        log.error(`unhandled node type: "${node.type.name}"`, node);
+        return node;
     }
 }
+function setFragmentAsInserted(inserted, insertAttrs, schema) {
+    // Recurse the content in the inserted slice and either mark it tracked_insert or set node attrs
+    const updatedInserted = loopContentAndMergeText(inserted, insertAttrs, schema);
+    return updatedInserted.length === 0 ? Fragment.empty : Fragment.fromArray(updatedInserted);
+}
+
+/*!
+ * © 2021 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.
+ */
+function createNewInsertAttrs(attrs) {
+    return {
+        ...attrs,
+        operation: CHANGE_OPERATION.insert,
+    };
+}
+function createNewDeleteAttrs(attrs) {
+    return {
+        ...attrs,
+        operation: CHANGE_OPERATION.delete,
+    };
+}
+function createNewUpdateAttrs(attrs, oldAttrs) {
+    return {
+        ...attrs,
+        operation: CHANGE_OPERATION.set_node_attributes,
+        oldAttrs,
+    };
+}
+
+/*!
+ * © 2021 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.
+ */
 /**
  * Applies deletion to the doc without actually deleting nodes that have not been inserted
  *
@@ -903,25 +985,20 @@ function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
  * @returns mapping adjusted by the applied operations & modified insert slice
  */
 function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
-    const deleteMap = new Mapping();
-    const mergedInsertPos = undefined;
+    const steps = [];
     // No deletion applied, return default values
     if (from === to) {
         return {
-            deleteMap,
-            mergedInsertPos,
             newSliceContent: insertSlice.content,
+            sliceWasSplit: false,
+            steps,
         };
     }
     const { openStart, openEnd } = insertSlice;
     const { updatedSliceNodes, firstMergedNode, lastMergedNode } = splitSliceIntoMergedParts(insertSlice, gap !== undefined);
-    const deleteAttrs = createNewDeleteAttrs(trackAttrs);
     let mergingStartSide = true;
     startDoc.nodesBetween(from, to, (node, pos) => {
-        const { pos: offsetPos, deleted: nodeWasDeleted } = deleteMap.mapResult(pos, 1);
-        const offsetFrom = deleteMap.map(from, -1);
-        const offsetTo = deleteMap.map(to, 1);
-        const nodeEnd = offsetPos + node.nodeSize;
+        const nodeEnd = pos + node.nodeSize;
         // So this insane boolean checks for ReplaceAroundStep gaps and whether the node should be skipped
         // since the content inside gap should stay unchanged.
         // All other nodes except text nodes consist of one start and end token (or just a single token for atoms).
@@ -932,23 +1009,13 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
         // are altered and should not be skipped.
         // @TODO ATM 20.7.2022 there doesn't seem to be tests that capture this.
         const wasWithinGap = gap &&
-            ((!node.isText && offsetPos >= deleteMap.map(gap.start, -1)) ||
-                (node.isText &&
-                    offsetPos <= deleteMap.map(gap.start, -1) &&
-                    nodeEnd >= deleteMap.map(gap.end, -1)));
-        let step = newTr.steps[newTr.steps.length - 1];
+            ((!node.isText && pos >= gap.start) ||
+                (node.isText && pos <= gap.start && nodeEnd >= gap.start));
         // nodeEnd > offsetFrom -> delete touches this node
         // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
-        //
-        // !nodeWasDeleted -> Check node wasn't already deleted by a previous deleteNode
-        // This is quite tricky to wrap your head around and I've forgotten the nitty-gritty details already.
-        // But from what I remember what it safeguards against is, when you've already deleted a node
-        // say an inserted blockquote that had all its children deleted, nodesBetween still iterates over those
-        // nodes and therefore we have to make this check to ensure they still exist in the doc.
-        //
-        if (nodeEnd > offsetFrom && !nodeWasDeleted && !wasWithinGap) {
+        if (nodeEnd > from && !wasWithinGap) {
             // |<p>asdf</p>| -> node deleted completely
-            const nodeCompletelyDeleted = offsetPos >= offsetFrom && nodeEnd <= offsetTo;
+            const nodeCompletelyDeleted = pos >= from && nodeEnd <= to;
             // The end token deleted eg:
             // <p 1>asdf|</p 7><p 7>bye</p 12>| + [<p>]hello</p> -> <p>asdfhello</p>
             // (del 6 12) + (ins [<p>]hello</p> openStart 1 openEnd 0)
@@ -959,14 +1026,14 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
             //
             // What about:
             // <p 1>asdf|</p 7><p 7 op="inserted">|bye</p 12> + empty -> <p>asdfbye</p>
-            const endTokenDeleted = nodeEnd <= offsetTo;
+            const endTokenDeleted = nodeEnd <= to;
             // The start token deleted eg:
             // |<p1 0>hey</p 6><p2 6>|asdf</p 12> + <p3>hello [</p>] -> <p3>hello asdf</p2>
             // (del 0 7) + (ins <p>hello [</p>] openStart 0 openEnd 1)
             // (<p1> pos 0) >= (from 0) && (nodeEnd 6) - 1 > (to 7) == false???
             // (<p2> pos 6) >= (from 0) && (nodeEnd 12) - 1 > (to 7) == true
             //
-            const startTokenDeleted = offsetPos >= offsetFrom; // && nodeEnd - 1 > offsetTo
+            const startTokenDeleted = pos >= from; // && nodeEnd - 1 > offsetTo
             if (node.isText ||
                 (!endTokenDeleted && startTokenDeleted) ||
                 (endTokenDeleted && !startTokenDeleted)) {
@@ -978,7 +1045,7 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 }
                 // Depth is often 1 when merging paragraphs or 2 for fully open blockquotes.
                 // Incase of merging text within a ReplaceAroundStep the depth might be 1
-                const depth = newTr.doc.resolve(offsetPos).depth;
+                const depth = newTr.doc.resolve(pos).depth;
                 const mergeContent = mergingStartSide
                     ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
                     : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
@@ -991,24 +1058,18 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 // ProseMirror node semantics as start tokens are considered to contain the actual node itself.
                 const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent !== undefined;
                 if (mergeStartNode || mergeEndNode) {
-                    // The default insert position for block nodes is either the start of the merged content or the end.
-                    // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-                    // actual position of the merge. Currently the inserted content is inserted at the start or end
-                    // of the merged content, TODO reverse the start/end when end/start token?
-                    let insertPos = mergeStartNode ? nodeEnd - openStart : offsetPos + openEnd;
-                    if (node.isText) {
-                        // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                        // the text node.
-                        insertPos = deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
-                        deleteMap.appendMap(newTr.steps[newTr.steps.length - 1].getMap());
-                        step = newTr.steps[newTr.steps.length - 1];
-                    }
                     // Just as a fun fact that I found out while debugging this. Inserting text at paragraph position wraps
                     // it into a new paragraph(!). So that's why you always offset your positions to insert it _inside_
                     // the paragraph.
-                    if (mergeContent.size !== 0) {
-                        newTr.insert(insertPos, setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema));
-                    }
+                    steps.push({
+                        type: 'merge-fragment',
+                        pos,
+                        mergePos: mergeStartNode ? nodeEnd - openStart : pos + openEnd,
+                        from,
+                        to,
+                        node,
+                        fragment: setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema),
+                    });
                     // Okay this is a bit ridiculous but it's used to adjust the insert pos when track changes prevents deletions
                     // of merged nodes & content, as just using mapped toA in that case isn't the same.
                     // The calculation is a bit mysterious, I admit.
@@ -1021,25 +1082,32 @@ function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackA
                 else if (node.isText) {
                     // Text deletion is handled even when the deletion doesn't completely wrap the text node
                     // (which is basically the case most of the time)
-                    deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
+                    steps.push({
+                        type: 'delete-text',
+                        pos,
+                        from: Math.max(pos, from),
+                        to: Math.min(nodeEnd, to),
+                        node,
+                    });
                 }
                 else ;
             }
             else if (nodeCompletelyDeleted) {
-                deleteOrSetNodeDeleted(node, offsetPos, newTr, deleteAttrs);
+                steps.push({
+                    type: 'delete-node',
+                    pos,
+                    nodeEnd,
+                    node,
+                });
             }
         }
-        const newestStep = newTr.steps[newTr.steps.length - 1];
-        if (step !== newestStep) {
-            deleteMap.appendMap(newestStep.getMap());
-        }
     });
     return {
-        deleteMap,
-        mergedInsertPos,
+        sliceWasSplit: !!(firstMergedNode || lastMergedNode),
         newSliceContent: updatedSliceNodes
             ? Fragment.fromArray(updatedSliceNodes)
             : insertSlice.content,
+        steps,
     };
 }
 
@@ -1062,18 +1130,20 @@ function mergeTrackedMarks(pos, doc, newTr, schema) {
     if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
         return;
     }
-    const leftAttrs = leftMark.attrs;
-    const rightAttrs = rightMark.attrs;
-    if (!shouldMergeTrackedAttributes(leftAttrs.dataTracked, rightAttrs.dataTracked)) {
+    const leftDataTracked = leftMark.attrs.dataTracked;
+    const rightDataTracked = rightMark.attrs.dataTracked;
+    if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
         return;
     }
-    const newAttrs = {
-        ...leftAttrs,
-        createdAt: Math.max(leftAttrs.createdAt || 0, rightAttrs.createdAt || 0) || Date.now(),
+    const isLeftOlder = (leftDataTracked.createdAt || 0) < (rightDataTracked.createdAt || 0);
+    const ancestorAttrs = isLeftOlder ? leftDataTracked : rightDataTracked;
+    const dataTracked = {
+        ...ancestorAttrs,
+        updatedAt: Date.now(),
     };
     const fromStartOfMark = pos - nodeBefore.nodeSize;
     const toEndOfMark = pos + nodeAfter.nodeSize;
-    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create(newAttrs));
+    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create({ ...leftMark.attrs, dataTracked }));
 }
 
 /*!
@@ -1121,14 +1191,16 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
     const stepResult = newTr.maybeStep(newStep);
     if (stepResult.failed) {
         log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
-        return;
+        return [];
     }
     const gap = oldState.doc.slice(gapFrom, gapTo);
     log.info('RETAINED GAP CONTENT', gap);
     // First apply the deleted range and update the insert slice to not include content that was deleted,
     // eg partial nodes in an open-ended slice
-    const { deleteMap, newSliceContent } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
+    let steps = deleteSteps;
     log.info('TR: new steps after applying delete', [...newTr.steps]);
+    log.info('DELETE STEPS: ', deleteSteps);
     // We only want to insert when there something inside the gap (actually would this be always true?)
     // or insert slice wasn't just start/end tokens (which we already merged inside deleteAndMergeSplitBlockNodes)
     if (gap.size > 0 || (!structure && newSliceContent.size > 0)) {
@@ -1143,21 +1215,20 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
             insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
             log.info('insertedSlice after inserted gap', insertedSlice);
         }
-        const newStep = new ReplaceStep(deleteMap.map(gapFrom), deleteMap.map(gapTo), insertedSlice, false);
-        const stepResult = newTr.maybeStep(newStep);
-        if (stepResult.failed) {
-            log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
-            return;
-        }
-        log.info('new steps after applying insert', [...newTr.steps]);
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
+        deleteSteps.push({
+            type: 'insert-slice',
+            from: gapFrom,
+            to: gapTo,
+            slice: insertedSlice,
+            sliceWasSplit,
+        });
     }
     else {
         // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
+        mergeTrackedMarks(gapFrom, newTr.doc, newTr, oldState.schema);
+        mergeTrackedMarks(gapTo, newTr.doc, newTr, oldState.schema);
     }
+    return steps;
 }
 
 /*!
@@ -1177,7 +1248,7 @@ function trackReplaceAroundStep(step, oldState, newTr, attrs) {
  */
 function trackReplaceStep(step, oldState, newTr, attrs) {
     log.info('###### ReplaceStep ######');
-    let selectionPos = 0;
+    let selectionPos = 0, changeSteps = [];
     step.getMap().forEach((fromA, toA, fromB, toB) => {
         log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
         const { slice } = step;
@@ -1191,34 +1262,340 @@ function trackReplaceStep(step, oldState, newTr, attrs) {
         log.info('TR: steps before applying delete', [...newTr.steps]);
         // First apply the deleted range and update the insert slice to not include content that was deleted,
         // eg partial nodes in an open-ended slice
-        const { deleteMap, mergedInsertPos, newSliceContent } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
+        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
+        changeSteps.push(...deleteSteps);
         log.info('TR: steps after applying delete', [...newTr.steps]);
-        const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : deleteMap.map(toA);
+        log.info('DELETE STEPS: ', changeSteps);
+        const adjustedInsertPos = toA; // deleteMap.map(toA)
         if (newSliceContent.size > 0) {
             log.info('newSliceContent', newSliceContent);
             // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
             // the sides should be equal. TODO can they be other than 0?
             const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
             const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
-            const insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
-            const newStep = new ReplaceStep(adjustedInsertPos, adjustedInsertPos, insertedSlice);
+            changeSteps.push({
+                type: 'insert-slice',
+                from: adjustedInsertPos,
+                to: adjustedInsertPos,
+                sliceWasSplit,
+                slice: new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd),
+            });
+        }
+        else {
+            // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
+            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
+            selectionPos = fromA;
+        }
+    });
+    return [changeSteps, selectionPos];
+}
+
+/*!
+ * © 2021 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.
+ */
+/**
+ * Deletes inserted text directly, otherwise wraps it with tracked_delete mark
+ *
+ * This would work for general inline nodes too, but since node marks don't work properly
+ * with Yjs, attributes are used instead.
+ * @param node
+ * @param pos
+ * @param newTr
+ * @param schema
+ * @param deleteAttrs
+ * @param from
+ * @param to
+ */
+function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
+    const start = from ? Math.max(pos, from) : pos;
+    const nodeEnd = pos + node.nodeSize;
+    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
+    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
+        // Math.max(pos, from) is for picking always the start of the node,
+        // not the start of the change (which might span multiple nodes).
+        // Pos can be less than from as nodesBetween iterates through all nodes starting from the top block node
+        newTr.replaceWith(start, end, Fragment.empty);
+        return start;
+    }
+    else {
+        const leftNode = newTr.doc.resolve(start).nodeBefore;
+        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
+        const rightNode = newTr.doc.resolve(end).nodeAfter;
+        const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
+        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
+        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
+        const createdAt = Math.min((leftMarks === null || leftMarks === void 0 ? void 0 : leftMarks.createdAt) || Number.MAX_VALUE, (rightMarks === null || rightMarks === void 0 ? void 0 : rightMarks.createdAt) || Number.MAX_VALUE, deleteAttrs.createdAt);
+        const dataTracked = addTrackIdIfDoesntExist({
+            ...leftMarks,
+            ...rightMarks,
+            ...deleteAttrs,
+            createdAt,
+        });
+        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
+            dataTracked,
+        }));
+        return toEndOfMark;
+    }
+}
+
+function processChangeSteps(changes, startPos, newTr, emptyAttrs, schema) {
+    const mapping = new Mapping();
+    const deleteAttrs = createNewDeleteAttrs(emptyAttrs);
+    let selectionPos = startPos;
+    // @TODO add custom handler / condition?
+    changes.forEach((c) => {
+        let step = newTr.steps[newTr.steps.length - 1];
+        log.info('process change: ', c);
+        // const handled = customStepHandler(changes, newTr, emptyAttrs) // ChangeStep[] | undefined
+        if (c.type === 'delete-node') {
+            deleteOrSetNodeDeleted(c.node, mapping.map(c.pos), newTr, deleteAttrs);
+            const newestStep = newTr.steps[newTr.steps.length - 1];
+            if (step !== newestStep) {
+                mapping.appendMap(newestStep.getMap());
+                step = newestStep;
+            }
+            mergeTrackedMarks(mapping.map(c.pos), newTr.doc, newTr, schema);
+        }
+        else if (c.type === 'delete-text') {
+            const node = newTr.doc.nodeAt(mapping.map(c.pos));
+            if (!node) {
+                log.error(`processChangeSteps: no text node found for text-change`, c);
+                return;
+            }
+            const where = deleteTextIfInserted(node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+            mergeTrackedMarks(where, newTr.doc, newTr, schema);
+        }
+        else if (c.type === 'merge-fragment') {
+            let insertPos = mapping.map(c.mergePos);
+            // The default insert position for block nodes is either the start of the merged content or the end.
+            // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
+            // actual position of the merge. Currently the inserted content is inserted at the start or end
+            // of the merged content, TODO reverse the start/end when end/start token?
+            if (c.node.isText) {
+                // When merging text we must delete text in the same go as well, as the from/to boundary goes through
+                // the text node.
+                insertPos = deleteTextIfInserted(c.node, mapping.map(c.pos), newTr, schema, deleteAttrs, mapping.map(c.from), mapping.map(c.to));
+                const newestStep = newTr.steps[newTr.steps.length - 1];
+                if (step !== newestStep) {
+                    mapping.appendMap(newestStep.getMap());
+                    step = newestStep;
+                }
+            }
+            if (c.fragment.size > 0) {
+                newTr.insert(insertPos, c.fragment);
+            }
+        }
+        else if (c.type === 'insert-slice') {
+            const newStep = new ReplaceStep(mapping.map(c.from), mapping.map(c.to), c.slice, false);
             const stepResult = newTr.maybeStep(newStep);
             if (stepResult.failed) {
-                log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
+                log.error(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
                 return;
             }
-            log.info('new steps after applying insert', [...newTr.steps]);
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            mergeTrackedMarks(adjustedInsertPos + insertedSlice.size, newTr.doc, newTr, oldState.schema);
-            selectionPos = adjustedInsertPos + insertedSlice.size;
+            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
+            mergeTrackedMarks(mapping.map(c.to), newTr.doc, newTr, schema);
+            selectionPos = mapping.map(c.to) + c.slice.size;
+        }
+        else if (c.type === 'update-node-attrs') {
+            const oldDataTracked = getBlockInlineTrackedData(c.node) || [];
+            const oldUpdate = oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.set_node_attributes);
+            let newDataTracked = oldDataTracked;
+            if (oldUpdate) {
+                newDataTracked = [
+                    ...oldDataTracked.filter((d) => d === oldUpdate),
+                    {
+                        ...oldUpdate,
+                        updatedAt: emptyAttrs.updatedAt,
+                    },
+                ];
+            }
+            else if (oldDataTracked.length === 0 ||
+                oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.delete)) {
+                newDataTracked = [
+                    ...oldDataTracked,
+                    addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, c.node.attrs)),
+                ];
+            }
+            newTr.setNodeMarkup(mapping.map(c.pos), undefined, {
+                ...c.newAttrs,
+                dataTracked: newDataTracked.length > 0 ? newDataTracked : null,
+            }, c.node.marks);
+        }
+        const newestStep = newTr.steps[newTr.steps.length - 1];
+        if (step !== newestStep) {
+            mapping.appendMap(newestStep.getMap());
+        }
+    });
+    return [mapping, selectionPos];
+}
+
+/*!
+ * © 2021 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.
+ */
+function matchInserted(matchedDeleted, deleted, inserted, newTr, schema) {
+    var _a;
+    let matched = [matchedDeleted, deleted];
+    for (let i = 0;; i += 1) {
+        if (inserted.childCount === i)
+            return matched;
+        const insNode = inserted.child(i);
+        // @ts-ignore
+        let adjDeleted = matched[1].find((d) => (d.type === 'delete-text' && Math.max(d.pos, d.from) === matched[0]) ||
+            (d.type === 'delete-node' && d.pos === matched[0]));
+        if (insNode.type !== ((_a = adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node) === null || _a === void 0 ? void 0 : _a.type)) {
+            return matched;
+        }
+        else if (insNode.isText && (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node)) {
+            adjDeleted = adjDeleted;
+            const { pos, from, to, node: delNode } = adjDeleted;
+            let j = 0, d = from - pos, maxSteps = to - Math.max(pos, from);
+            // Match text inside the inserted text node to the deleted text node
+            for (; maxSteps !== j && insNode.text[j] !== undefined && insNode.text[j] === delNode.text[d]; j += 1, d += 1) {
+                matched[0] += 1;
+            }
+            // this is needed incase diffing tr.doc
+            // deleted.push({
+            //   pos: pos,
+            //   type: 'update-node-attrs',
+            //   // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
+            //   oldAttrs: adjDeleted.node.attrs || {},
+            //   newAttrs: child.attrs || {},
+            // })
+            matched = [matched[0], matched[1].filter((d) => d !== adjDeleted)];
+            if (maxSteps !== j) {
+                matched[1].push({
+                    pos,
+                    from: Math.max(pos, from) + j,
+                    to,
+                    type: 'delete-text',
+                    node: delNode,
+                });
+                return matched;
+            }
+            continue;
+        }
+        else if (insNode.content.size > 0 || (adjDeleted === null || adjDeleted === void 0 ? void 0 : adjDeleted.node.content.size) > 0) {
+            // Move the inDeleted inside the block/inline node's boundary
+            matched = matchInserted(matched[0] + 1, matched[1].filter((d) => d !== adjDeleted), insNode.content);
         }
         else {
-            // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            selectionPos = fromA;
+            matched = [matched[0] + insNode.nodeSize, matched[1].filter((d) => d !== adjDeleted)];
+        }
+        matched[1].push({
+            pos: adjDeleted.pos,
+            type: 'update-node-attrs',
+            node: adjDeleted.node,
+            // Should check the attrs for equality in fixInconsistentChanges? to remove dataTracked completely
+            newAttrs: insNode.attrs || {},
+        });
+    }
+}
+/**
+ * Cuts a fragment similar to Fragment.cut but also removes the parent node.
+ *
+ * @TODO there is however, some silly calculation mistake so that I need to use matched - deleted + 1 > 0
+ * inside it to check whether to actually cut a text node. The offset might be cascading, therefore it should
+ * be fixed at some point.
+ * @param matched
+ * @param deleted
+ * @param content
+ * @returns
+ */
+function cutFragment(matched, deleted, content) {
+    let newContent = [];
+    for (let i = 0; matched <= deleted && i < content.childCount; i += 1) {
+        const child = content.child(i);
+        if (!child.isText && child.content.size > 0) {
+            const cut = cutFragment(matched + 1, deleted, child.content);
+            matched = cut[0];
+            newContent.push(...cut[1].content);
+        }
+        else if (child.isText && matched + child.nodeSize > deleted) {
+            if (matched - deleted + 1 > 0) {
+                newContent.push(child.cut(0, matched - deleted + 1));
+            }
+            else {
+                newContent.push(child);
+            }
+            matched = deleted + 1;
+        }
+        else {
+            matched += child.nodeSize;
+        }
+    }
+    return [matched, Fragment.fromArray(newContent)];
+}
+function diffChangeSteps(deleted, inserted, newTr, schema) {
+    const updated = [];
+    let updatedDeleted = [...deleted];
+    inserted.forEach((ins) => {
+        log.info('DIFF ins ', ins);
+        //
+        // @TODO this is a temporary workaround to prevent duplicated diffing between splitSliceIntoMergedParts and
+        // matchInserted.
+        //
+        // As originally authored splitSliceIntoMergedParts splits open slices into their merged parts
+        // leaving out the need to insert the possibly deleted nodes into the doc. However, as matchInserted now
+        // traverses the deleted range checking it against the inserted slice this behaves quite in a same way
+        // where the opened block nodes are traversed but left unmodified. With an openStart > 0 though the
+        // node-attr-updates would additionally have to be filtered out in the processChangeSteps.
+        //
+        // The old logic is still left as it's as refactoring is painful and would probably break something and just
+        // in general, take a lot of time. Therefore, this sliceWasSplit boolean is used to just skip diffing.
+        if (ins.sliceWasSplit) {
+            updated.push(ins);
+            return;
+        }
+        // Start diffing from the start of the deleted range
+        const deleteStart = deleted.reduce((acc, cur) => {
+            if (cur.type === 'delete-node') {
+                return Math.min(acc, cur.pos);
+            }
+            else if (cur.type === 'delete-text') {
+                return Math.min(acc, cur.from);
+            }
+            return acc;
+        }, Number.MAX_SAFE_INTEGER);
+        const [inDeleted, updatedDel] = matchInserted(deleteStart, updatedDeleted, ins.slice.content);
+        if (inDeleted === deleteStart) {
+            updated.push(ins);
+            return;
+        }
+        updatedDeleted = updatedDel;
+        const newInserted = cutFragment(0, inDeleted, ins.slice.content)[1];
+        if (newInserted.size > 0) {
+            updated.push({
+                ...ins,
+                slice: new Slice(newInserted, ins.slice.openStart, ins.slice.openEnd),
+            });
         }
     });
-    return selectionPos;
+    log.info('FINISH DIFF: ', [...updatedDeleted, ...updated]);
+    return [...updatedDeleted, ...updated];
 }
 
 /**
@@ -1242,13 +1619,15 @@ const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constr
  * @param tr Original transaction
  * @param oldState State before transaction
  * @param newTr Transaction created from the new editor state
- * @param userID User id
+ * @param authorID User id
  * @returns newTr that inverts the initial tr and applies track attributes/marks
  */
-function trackTransaction(tr, oldState, newTr, userID) {
+function trackTransaction(tr, oldState, newTr, authorID) {
     const emptyAttrs = {
-        userID,
+        authorID,
+        reviewedByID: null,
         createdAt: tr.time,
+        updatedAt: tr.time,
         status: CHANGE_STATUS.pending,
     };
     // Must use constructor.name instead of instanceof as aliasing prosemirror-state is a lot more
@@ -1270,7 +1649,14 @@ function trackTransaction(tr, oldState, newTr, userID) {
             return;
         }
         else if (step instanceof ReplaceStep) {
-            const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+            let [steps, startPos] = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+            log.info('CHANGES: ', steps);
+            // deleted and merged really...
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            log.info('DIFFED STEPS: ', steps);
+            const [mapping, selectionPos] = processChangeSteps(steps, startPos, newTr, emptyAttrs, oldState.schema);
             if (!wasNodeSelection) {
                 const sel = getSelectionStaticConstructor(tr.selection);
                 // Use Selection.near to fix selections that point to a block node instead of inline content
@@ -1281,10 +1667,16 @@ function trackTransaction(tr, oldState, newTr, userID) {
             }
         }
         else if (step instanceof ReplaceAroundStep) {
-            trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
-            // } else if (step instanceof AddMarkStep) {
-            // } else if (step instanceof RemoveMarkStep) {
+            let steps = trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
+            const deleted = steps.filter((s) => s.type !== 'insert-slice');
+            const inserted = steps.filter((s) => s.type === 'insert-slice');
+            log.info('INSERT STEPS: ', inserted);
+            steps = diffChangeSteps(deleted, inserted, newTr, oldState.schema);
+            log.info('DIFFED STEPS: ', steps);
+            processChangeSteps(steps, tr.selection.from, newTr, emptyAttrs, oldState.schema);
         }
+        // } else if (step instanceof AddMarkStep) {
+        // } else if (step instanceof RemoveMarkStep) {
         // TODO: here we could check whether adjacent inserts & deletes cancel each other out.
         // However, this should not be done by diffing and only matching node or char by char instead since
         // it's A easier and B more intuitive to user.
@@ -1418,10 +1810,10 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
                     ids.forEach((changeId) => {
                         const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
                         if (change) {
-                            createdTr = updateChangeAttrs(createdTr, change, { status }, oldState.schema);
-                            setAction(createdTr, TrackChangesAction.updateChanges, [change.id]);
+                            createdTr = updateChangeAttrs(createdTr, change, { ...change.dataTracked, status, reviewedByID: userID }, oldState.schema);
                         }
                     });
+                    setAction(createdTr, TrackChangesAction.updateChanges, ids);
                 }
                 else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
                     const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);
@@ -1443,21 +1835,6 @@ const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
     });
 };
 
-/*!
- * © 2021 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.
- */
 /**
  * Sets track-changes plugin's status to any of: 'enabled' 'disabled' 'viewSnapshots'. Passing undefined will
  * set 'enabled' status to 'disabled' and 'disabled' | 'viewSnapshots' status to 'enabled'.
@@ -1545,4 +1922,4 @@ var commands = /*#__PURE__*/Object.freeze({
   setParagraphTestAttribute: setParagraphTestAttribute
 });
 
-export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesAction, TrackChangesStatus, enableDebug, getAction, setAction, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };
+export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesStatus, enableDebug, skipTracking, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };