@manuscripts/track-changes-plugin 0.0.1

package/dist/index.es.js

@@ -0,0 +1,1539 @@
+import { PluginKey, Plugin } from 'prosemirror-state';
+import debug from 'debug';
+import { liftTarget, canJoin, Mapping, ReplaceStep, ReplaceAroundStep } from 'prosemirror-transform';
+import { Fragment, Slice } from 'prosemirror-model';
+
+var TrackChangesAction;
+(function (TrackChangesAction) {
+    TrackChangesAction["skipTrack"] = "track-changes-skip-tracking";
+    TrackChangesAction["setUserID"] = "track-changes-set-user-id";
+    TrackChangesAction["setPluginStatus"] = "track-changes-set-track-status";
+    TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
+    TrackChangesAction["updateChanges"] = "track-changes-update-changes";
+    TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
+    TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
+})(TrackChangesAction || (TrackChangesAction = {}));
+/**
+ * Gets the value of a meta field, action payload, of a defined track-changes action.
+ * @param tr
+ * @param action
+ */
+function getAction(tr, action) {
+    return tr.getMeta(action);
+}
+/**
+ * Use this function to set meta keys to transactions that are consumed by the track-changes-plugin.
+ * For example, you can skip tracking of a transaction with setAction(tr, TrackChangesAction.skipTrack, true)
+ * @param tr
+ * @param action
+ * @param payload
+ */
+function setAction(tr, action, payload) {
+    return tr.setMeta(action, payload);
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+/*!
+ * © 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.
+ */
+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 || (CHANGE_OPERATION = {}));
+var CHANGE_STATUS;
+(function (CHANGE_STATUS) {
+    CHANGE_STATUS["accepted"] = "accepted";
+    CHANGE_STATUS["rejected"] = "rejected";
+    CHANGE_STATUS["pending"] = "pending";
+})(CHANGE_STATUS || (CHANGE_STATUS = {}));
+
+/*!
+ * © 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.
+ */
+const logger = debug('track');
+const log = {
+    info(str, obj) {
+        if (obj) {
+            logger(str, obj);
+        }
+        else {
+            logger(str);
+        }
+    },
+    warn(str, obj) {
+        if (obj) {
+            logger(`%c WARNING ${str}`, 'color: #f3f32c', obj);
+        }
+        else {
+            logger(`%c WARNING ${str}`, 'color: #f3f32c');
+        }
+    },
+    error(str, obj) {
+        if (obj) {
+            logger(`%c ERROR ${str}`, 'color: #ff4242', obj);
+        }
+        else {
+            logger(`%c ERROR ${str}`, 'color: #ff4242');
+        }
+    },
+};
+/**
+ * Sets debug logging enabled/disabled.
+ * @param enabled
+ */
+const enableDebug = (enabled) => {
+    if (enabled) {
+        debug.enable('track');
+    }
+    else {
+        debug.disable();
+    }
+};
+
+var _ChangeSet_changes;
+/**
+ * ChangeSet is a data structure to contain the tracked changes with some utility methods and computed
+ * values to allow easier operability.
+ */
+class ChangeSet {
+    constructor(changes = []) {
+        _ChangeSet_changes.set(this, void 0);
+        __classPrivateFieldSet(this, _ChangeSet_changes, changes, "f");
+    }
+    /**
+     * List of all the valid TrackedChanges. This prevents for example changes with duplicate ids being shown
+     * in the UI, causing errors.
+     */
+    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);
+            return valid;
+        });
+    }
+    get invalidChanges() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => !this.changes.find((cc) => c.id === cc.id));
+    }
+    /**
+     * List of 1-level nested changes where the top-most node change contains all the changes within its start
+     * and end position. This is useful for showing the changes as groups in the UI.
+     */
+    get changeTree() {
+        const rootNodes = [];
+        let currentNodeChange;
+        this.changes.forEach((c) => {
+            if (currentNodeChange && c.from >= currentNodeChange.to) {
+                rootNodes.push(currentNodeChange);
+                currentNodeChange = undefined;
+            }
+            if (c.type === 'node-change' && 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') {
+                rootNodes.push(c);
+            }
+        });
+        if (currentNodeChange) {
+            rootNodes.push(currentNodeChange);
+        }
+        return rootNodes;
+    }
+    get pending() {
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
+    }
+    get accepted() {
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
+    }
+    get rejected() {
+        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
+    }
+    get textChanges() {
+        return this.changes.filter((c) => c.type === 'text-change');
+    }
+    get nodeChanges() {
+        return this.changes.filter((c) => c.type === 'node-change');
+    }
+    get isEmpty() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
+    }
+    /**
+     * Used to determine whether `fixInconsistentChanges` has to be executed to replace eg duplicate ids or
+     * changes that are missing attributes.
+     */
+    get hasInconsistentData() {
+        return this.hasDuplicateIds || this.hasIncompleteAttrs;
+    }
+    get hasDuplicateIds() {
+        const iterated = new Set();
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => {
+            if (iterated.has(c.id)) {
+                return true;
+            }
+            iterated.add(c.id);
+        });
+    }
+    get hasIncompleteAttrs() {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidTrackedAttrs(c.attrs));
+    }
+    get(id) {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id);
+    }
+    getIn(ids) {
+        return ids
+            .map((id) => __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id))
+            .filter((c) => c !== undefined);
+    }
+    getNotIn(ids) {
+        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => ids.includes(c.id));
+    }
+    /**
+     * Flattens a changeTree into a list of IDs
+     * @param changes
+     */
+    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;
+        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
+     */
+    static isValidTrackedAttrs(attrs = {}) {
+        if ('attrs' in attrs) {
+            log.warn('passed "attrs" as property to isValidTrackedAttrs(attrs)', attrs);
+        }
+        const trackedKeys = ['id', 'userID', 'operation', 'status', 'createdAt'];
+        const entries = Object.entries(attrs);
+        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
+        );
+    }
+    static isTextChange(change) {
+        return change.type === 'text-change';
+    }
+    static isNodeChange(change) {
+        return change.type === 'node-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.
+ */
+/**
+ * Deletes node but tries to leave its content intact by trying to unwrap it first
+ *
+ * Incase unwrapping doesn't work deletes the whole node.
+ * @param node
+ * @param pos
+ * @param tr
+ * @returns
+ */
+function deleteNode(node, pos, tr) {
+    var _a;
+    const startPos = tr.doc.resolve(pos + 1);
+    const range = startPos.blockRange(tr.doc.resolve(startPos.pos - 2 + node.nodeSize));
+    const targetDepth = range ? Number(liftTarget(range)) : NaN;
+    if (range && !Number.isNaN(targetDepth)) {
+        return tr.lift(range, targetDepth);
+    }
+    const resPos = tr.doc.resolve(pos);
+    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
+    if (canMergeToNodeAbove) {
+        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
+    }
+    else {
+        // NOTE: there's an edge case where moving content is not possible but because the immediate
+        // child, say some wrapper blockNode, is also deleted the content could be retained. TODO I guess.
+        return tr.delete(pos, pos + node.nodeSize);
+    }
+}
+
+/*!
+ * © 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 node but tries to leave its content intact by moving/wrapping it to a node before or after
+ * @param node
+ * @param pos
+ * @param tr
+ * @returns
+ */
+function mergeNode(node, pos, tr) {
+    var _a;
+    if (canJoin(tr.doc, pos)) {
+        return tr.join(pos);
+    }
+    else if (canJoin(tr.doc, pos + node.nodeSize)) {
+        return tr.join(pos + node.nodeSize);
+    }
+    // TODO is this the same thing as join?
+    const resPos = tr.doc.resolve(pos);
+    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
+    if (canMergeToNodeAbove) {
+        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
+    }
+    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);
+    }
+    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') {
+        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked }, node.marks);
+    }
+    return tr;
+}
+function updateChangeChildrenAttributes(changes, tr, mapping) {
+    changes.forEach((c) => {
+        if (c.type === 'node-change' && ChangeSet.shouldNotDelete(c)) {
+            const from = mapping.map(c.from);
+            const node = tr.doc.nodeAt(from);
+            if (!node) {
+                return;
+            }
+            const attrs = { ...node.attrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+        }
+    });
+}
+
+/**
+ * Applies the accepted/rejected changes in the current document and sets them untracked
+ *
+ * @param tr
+ * @param schema
+ * @param changes
+ * @param deleteMap
+ */
+function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
+    changes.forEach((change) => {
+        if (change.attrs.status === CHANGE_STATUS.pending) {
+            return;
+        }
+        const from = deleteMap.map(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = ChangeSet.shouldNotDelete(change);
+        if (!node) {
+            log.warn('no node found to update for change', change);
+            return;
+        }
+        if (ChangeSet.isTextChange(change) && noChangeNeeded) {
+            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
+            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_delete);
+        }
+        else if (ChangeSet.isTextChange(change)) {
+            tr.delete(from, deleteMap.map(change.to));
+            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+        }
+        else if (ChangeSet.isNodeChange(change) && noChangeNeeded) {
+            const attrs = { ...node.attrs, dataTracked: null };
+            tr.setNodeMarkup(from, undefined, attrs, node.marks);
+            updateChangeChildrenAttributes(change.children, tr, deleteMap);
+        }
+        else if (ChangeSet.isNodeChange(change)) {
+            // Try first moving the node children to either nodeAbove, nodeBelow or its parent.
+            // Then try unwrapping it with lift or just hacky-joining by replacing the border between
+            // it and its parent with Fragment.empty. If none of these apply, delete the content between the change.
+            const merged = mergeNode(node, from, tr);
+            if (merged === undefined) {
+                deleteNode(node, from, tr);
+            }
+            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
+        }
+    });
+    return deleteMap;
+}
+
+/**
+ * Finds all changes (basically text marks or node attributes) from document
+ *
+ * This could be possibly made more efficient by only iterating the sections of doc
+ * where changes have been applied. This could attempted with eg findDiffStart
+ * but it might be less robust than just using doc.descendants
+ * @param state
+ * @returns
+ */
+function findChanges(state) {
+    const changes = [];
+    // 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) || '';
+            // 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
+            if (current &&
+                current.change.id === id &&
+                current.node.isText &&
+                node.isText &&
+                !equalMarks(node, current.node)) {
+                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;
+            }
+            else if (node.isText) {
+                current && changes.push(current.change);
+                current = {
+                    change: {
+                        id,
+                        type: 'text-change',
+                        from: pos,
+                        to: pos + node.nodeSize,
+                        attrs,
+                    },
+                    node,
+                };
+            }
+            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,
+                };
+            }
+        }
+        else if (current) {
+            changes.push(current.change);
+            current = undefined;
+        }
+    });
+    current && changes.push(current.change);
+    return new ChangeSet(changes);
+}
+
+/**
+ * Iterates over a ChangeSet to check all changes have their required attributes
+ *
+ * This inconsistency might happen due to a bug in the track changes implementation or by a user somehow applying an empty insert/delete mark that doesn't contain proper data. Also this checks the track IDs for duplicates.
+ * @param changeSet
+ * @param currentUser
+ * @param newTr
+ * @param schema
+ * @return docWasChanged, a boolean
+ */
+function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
+    const iteratedIds = new Set();
+    let changed = false;
+    changeSet.invalidChanges.forEach((c) => {
+        const { id, userID, operation, status, createdAt } = c.attrs;
+        const newAttrs = {
+            ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
+            ...(!userID && { userID: trackUserID }),
+            ...(!operation && { operation: CHANGE_OPERATION.insert }),
+            ...(!status && { status: CHANGE_STATUS.pending }),
+            ...(!createdAt && { createdAt: Date.now() }),
+        };
+        if (Object.keys(newAttrs).length > 0) {
+            updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
+            changed = true;
+        }
+        iteratedIds.add(newAttrs.id || id);
+    });
+    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
+ *
+ * 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.
+ */
+/**
+ * Recurses node children and returns the merged first/last node's content and the unmerged children
+ *
+ * For example when merging two blockquotes:
+ * <bq><p>old|</p></bq>...| + [<bq><p>] inserted</p><p>2nd p</p></bq> -> <bq><p>old inserted</p><p>2nd p</p></bq>
+ * The extracted merged and unmerged content from the insertSlice are:
+ * {
+ *   mergedNodeContent: <text> inserted</text>
+ *   unmergedContent: [<p>2nd p</p>]
+ * }
+ * @param node
+ * @param currentDepth
+ * @param depth
+ * @param first
+ * @returns
+ */
+function getMergedNode(node, currentDepth, depth, first) {
+    if (currentDepth === depth) {
+        return {
+            mergedNodeContent: node.content,
+            unmergedContent: undefined,
+        };
+    }
+    const result = [];
+    let merged = Fragment.empty;
+    node.content.forEach((n, _, i) => {
+        if ((first && i === 0) || (!first && i === node.childCount - 1)) {
+            const { mergedNodeContent, unmergedContent } = getMergedNode(n, currentDepth + 1, depth, first);
+            merged = mergedNodeContent;
+            if (unmergedContent) {
+                result.push(...unmergedContent.content);
+            }
+        }
+        else {
+            result.push(n);
+        }
+    });
+    return {
+        mergedNodeContent: merged,
+        unmergedContent: result.length > 0 ? Fragment.fromArray(result) : undefined,
+    };
+}
+/**
+ * Filters merged nodes from an open insertSlice to manually merge them to prevent unwanted deletions
+ *
+ * So instead of joining the slice by its open sides, possibly deleting previous nodes, we can push the
+ * changed content manually inside the merged nodes.
+ * Eg. instead of doing `|<p>asdf</p><p>|bye</p>` automatically, we extract the merged nodes first:
+ * {
+ *  updatedSliceNodes: [<p>asdf</p>],
+ *  firstMergedNode: <p>bye</p>,
+ *  lastMergedNode: undefined,
+ * }
+ * @param insertSlice inserted slice
+ */
+function splitSliceIntoMergedParts(insertSlice, mergeEqualSides = false) {
+    const { openStart, openEnd, content: { firstChild, lastChild, content: nodes }, } = insertSlice;
+    let updatedSliceNodes = nodes;
+    const mergeSides = openStart !== openEnd || mergeEqualSides;
+    const firstMergedNode = openStart > 0 && mergeSides && firstChild
+        ? getMergedNode(firstChild, 1, openStart, true)
+        : undefined;
+    const lastMergedNode = openEnd > 0 && mergeSides && lastChild ? getMergedNode(lastChild, 1, openEnd, false) : undefined;
+    if (firstMergedNode) {
+        updatedSliceNodes = updatedSliceNodes.slice(1);
+        if (firstMergedNode.unmergedContent) {
+            updatedSliceNodes = [...firstMergedNode.unmergedContent.content, ...updatedSliceNodes];
+        }
+    }
+    if (lastMergedNode) {
+        updatedSliceNodes = updatedSliceNodes.slice(0, -1);
+        if (lastMergedNode.unmergedContent) {
+            updatedSliceNodes = [...updatedSliceNodes, ...lastMergedNode.unmergedContent.content];
+        }
+    }
+    return {
+        updatedSliceNodes,
+        firstMergedNode,
+        lastMergedNode,
+    };
+}
+/**
+ * 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 dataTracked = addTrackIdIfDoesntExist({
+            ...leftMarks,
+            ...rightMarks,
+            ...deleteAttrs,
+        });
+        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
+            dataTracked,
+        }));
+        return toEndOfMark;
+    }
+}
+/**
+ * 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 = 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);
+    }
+    else {
+        const attrs = {
+            ...node.attrs,
+            dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
+        };
+        newTr.setNodeMarkup(pos, undefined, attrs, node.marks);
+    }
+}
+/**
+ * Applies deletion to the doc without actually deleting nodes that have not been inserted
+ *
+ * The hairiest part of this whole library which does a fair bit of magic to split the inserted slice
+ * into pieces that can be inserted without deleting nodes in the doc. Basically we first split the
+ * inserted slice into merged pieces _if_ the slice was open on either end. Then, we iterate over the deleted
+ * range and see if the node in question was completely wrapped in the range (therefore fully deleted)
+ * or only partially deleted by the slice. In that case, we merge the content from the inserted slice
+ * and keep the original nodes if they do not contain insert attributes.
+ *
+ * It is definitely a messy function but so far this seems to have been the best approach to prevent
+ * deletion of nodes with open slices. Other option would be to allow the deletions to take place but that
+ * requires then inserting the deleted nodes back to the doc if their deletion should be prevented, which does
+ * not seem trivial either.
+ *
+ * @param from start of the deleted range
+ * @param to end of the deleted range
+ * @param gap retained content in a ReplaceAroundStep, not deleted
+ * @param startDoc doc before the deletion
+ * @param newTr the new track transaction
+ * @param schema ProseMirror schema
+ * @param deleteAttrs attributes for the dataTracked object
+ * @param insertSlice the inserted slice from ReplaceStep
+ * @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;
+    // No deletion applied, return default values
+    if (from === to) {
+        return {
+            deleteMap,
+            mergedInsertPos,
+            newSliceContent: insertSlice.content,
+        };
+    }
+    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 wasWithinGap = gap && offsetPos >= deleteMap.map(gap.start, -1);
+        const nodeEnd = offsetPos + node.nodeSize;
+        let step = newTr.steps[newTr.steps.length - 1];
+        // debugger
+        // 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) {
+            // |<p>asdf</p>| -> node deleted completely
+            const nodeCompletelyDeleted = offsetPos >= offsetFrom && nodeEnd <= offsetTo;
+            // 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)
+            // (<p> nodeEnd 7) > (from 6) && (nodeEnd 7) <= (to 12)
+            //
+            // How about
+            // <p 1>asdf|</p 7><p 7>|bye</p 12> + [<p>]hello</p><p>good[</p>] -> <p>asdfhello</p><p>goodbye</p>
+            //
+            // What about:
+            // <p 1>asdf|</p 7><p 7 op="inserted">|bye</p 12> + empty -> <p>asdfbye</p>
+            const endTokenDeleted = nodeEnd <= offsetTo;
+            // 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
+            if (node.isText ||
+                (!endTokenDeleted && startTokenDeleted) ||
+                (endTokenDeleted && !startTokenDeleted)) {
+                // Since we don't know which side to merge with wholly deleted TextNodes, we use this boolean to remember
+                // whether we have entered the endSide of the mergeable blockNodes. Also applies for partial TextNodes
+                // (which we could determine without this).
+                if (!endTokenDeleted && startTokenDeleted) {
+                    mergingStartSide = false;
+                }
+                // 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 mergeContent = mergingStartSide
+                    ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
+                    : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
+                // Insert inside a merged node only if the slice was open (openStart > 0) and there exists mergedNodeContent.
+                // Then we only have to ensure the depth is at the right level, so say a fully open blockquote insert will
+                // be merged at the lowest, paragraph level, instead of blockquote level.
+                const mergeStartNode = endTokenDeleted && openStart > 0 && depth === openStart && mergeContent !== undefined;
+                // Same as above, merge nodes manually if there exists an open slice with mergeable content.
+                // Compared to deleting an end token however, the merged block node is set as deleted. This is due to
+                // 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));
+                    }
+                    // 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.
+                    // TODO delete/fix this?
+                    // 'should prevent replacing of blockquotes and break the slice into parts instead' test needs this
+                    // if (node.isText) {
+                    //   mergedInsertPos = offsetPos - openEnd
+                    // }
+                }
+                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);
+                }
+                else ;
+            }
+            else if (nodeCompletelyDeleted) {
+                deleteOrSetNodeDeleted(node, offsetPos, newTr, deleteAttrs);
+            }
+        }
+        const newestStep = newTr.steps[newTr.steps.length - 1];
+        if (step !== newestStep) {
+            deleteMap.appendMap(newestStep.getMap());
+        }
+    });
+    return {
+        deleteMap,
+        mergedInsertPos,
+        newSliceContent: updatedSliceNodes
+            ? Fragment.fromArray(updatedSliceNodes)
+            : insertSlice.content,
+    };
+}
+
+/**
+ * Merges tracked marks between text nodes at a position
+ *
+ * Will work for any nodes that use tracked_insert or tracked_delete marks which may not be preferrable
+ * if used for block nodes (since we possibly want to show the individual changed nodes).
+ * Merging is done based on the userID, operation type and status.
+ * @param pos
+ * @param doc
+ * @param newTr
+ * @param schema
+ */
+function mergeTrackedMarks(pos, doc, newTr, schema) {
+    const resolved = doc.resolve(pos);
+    const { nodeAfter, nodeBefore } = resolved;
+    const leftMark = nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    const rightMark = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
+    if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
+        return;
+    }
+    const leftAttrs = leftMark.attrs;
+    const rightAttrs = rightMark.attrs;
+    if (!shouldMergeTrackedAttributes(leftAttrs.dataTracked, rightAttrs.dataTracked)) {
+        return;
+    }
+    const newAttrs = {
+        ...leftAttrs,
+        createdAt: Math.max(leftAttrs.createdAt || 0, rightAttrs.createdAt || 0) || Date.now(),
+    };
+    const fromStartOfMark = pos - nodeBefore.nodeSize;
+    const toEndOfMark = pos + nodeAfter.nodeSize;
+    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create(newAttrs));
+}
+
+/*!
+ * © 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 trackReplaceAroundStep(step, oldState, newTr, attrs) {
+    log.info('###### ReplaceAroundStep ######');
+    // @ts-ignore
+    const { from, to, gapFrom, gapTo, insert, slice, structure, } = step;
+    if (from === gapFrom && to === gapTo) {
+        log.info('WRAPPED IN SOMETHING');
+    }
+    else if (!slice.size || slice.content.content.length === 2) {
+        log.info('UNWRAPPED FROM SOMETHING');
+    }
+    else if (slice.size === 2 && gapFrom - from === 1 && to - gapTo === 1) {
+        log.info('REPLACED WRAPPING');
+    }
+    else {
+        log.info('????');
+    }
+    if (gapFrom - from > to - gapTo) {
+        log.info('DELETED BEFORE GAP FROM');
+    }
+    else if (gapFrom - from < to - gapTo) {
+        log.info('DELETED AFTER GAP TO');
+    }
+    else {
+        log.info('EQUAL REPLACE BETWEEN GAPS');
+    }
+    // Invert the transaction step to prevent it from actually deleting or inserting anything
+    const newStep = step.invert(oldState.doc);
+    const stepResult = newTr.maybeStep(newStep);
+    if (stepResult.failed) {
+        log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
+        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);
+    log.info('TR: new steps after applying delete', [...newTr.steps]);
+    // 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)) {
+        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 || newSliceContent.size === 0 ? 0 : slice.openStart;
+        const openEnd = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openEnd;
+        let insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
+        if (gap.size > 0) {
+            log.info('insertedSlice before inserted gap', insertedSlice);
+            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);
+    }
+    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);
+    }
+}
+
+/*!
+ * © 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 trackReplaceStep(step, oldState, newTr, attrs) {
+    log.info('###### ReplaceStep ######');
+    let selectionPos = 0;
+    step.getMap().forEach((fromA, toA, fromB, toB) => {
+        log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
+        const { slice } = step;
+        // Invert the transaction step to prevent it from actually deleting or inserting anything
+        const newStep = step.invert(oldState.doc);
+        const stepResult = newTr.maybeStep(newStep);
+        if (stepResult.failed) {
+            log.error(`invert ReplaceStep failed: "${stepResult.failed}"`, newStep);
+            return;
+        }
+        // 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);
+        log.info('TR: new steps after applying delete', [...newTr.steps]);
+        const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : 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);
+            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(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
+            mergeTrackedMarks(adjustedInsertPos + insertedSlice.size, newTr.doc, newTr, oldState.schema);
+            selectionPos = adjustedInsertPos + insertedSlice.size;
+        }
+        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 selectionPos;
+}
+
+/**
+ * Retrieves a static property from Selection class instead of having to use direct imports
+ *
+ * This skips the direct dependency to prosemirror-state where multiple versions might cause conflicts
+ * as the created instances might belong to different prosemirror-state import than one used in the editor.
+ * @param sel
+ * @param doc
+ * @param from
+ * @returns
+ */
+const getSelectionStaticCreate = (sel, doc, from) => Object.getPrototypeOf(sel).constructor.create(doc, from);
+/**
+ * Inverts transactions to wrap their contents/operations with track data instead
+ *
+ * The main function of track changes that holds the most complex parts of this whole library.
+ * Takes in as arguments the data from appendTransaction to reapply it with the track marks/attributes.
+ * We could prevent the initial transaction from being applied all together but since invert works just
+ * as well and we can use the intermediate doc for checking which nodes are changed, it's not prevented.
+ *
+ *
+ * @param tr Original transaction
+ * @param oldState State before transaction
+ * @param newTr Transaction created from the new editor state
+ * @param userID User id
+ * @returns newTr that inverts the initial tr and applies track attributes/marks
+ */
+function trackTransaction(tr, oldState, newTr, userID) {
+    var _a;
+    const emptyAttrs = {
+        userID,
+        createdAt: tr.time,
+        status: CHANGE_STATUS.pending,
+    };
+    // Must use constructor.name instead of instanceof as aliasing prosemirror-state is a lot more
+    // difficult than prosemirror-transform
+    const wasNodeSelection = tr.selection.constructor.name === 'NodeSelection';
+    let iters = 0;
+    log.info('ORIGINAL transaction', tr);
+    tr.steps.forEach((step) => {
+        log.info('transaction step', step);
+        iters += 1;
+        if (iters > 20) {
+            console.error('@manuscripts/track-changes-plugin: Possible infinite loop in iterating tr.steps, tracking skipped!\n' +
+                'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
+            return;
+        }
+        else if (!(step instanceof ReplaceStep) && step.constructor.name === 'ReplaceStep') {
+            console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
+                'or instanceof checks fail as well as creating new steps');
+            return;
+        }
+        else if (step instanceof ReplaceStep) {
+            const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
+            if (!wasNodeSelection) {
+                newTr.setSelection(getSelectionStaticCreate(tr.selection, newTr.doc, selectionPos));
+            }
+        }
+        else if (step instanceof ReplaceAroundStep) {
+            trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
+            // } 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.
+        const { meta } = tr;
+        // This is quite non-optimal in some sense but to ensure no information is lost
+        // we have to re-add all the old meta keys, such as inputType or uiEvent.
+        // This should prevent bugs incase other plugins/widgets rely upon them existing (and they
+        // are not able to process the transactions before track-changes).
+        // TODO: will this cause race-condition if a meta causes another appendTransaction to fire
+        Object.keys(meta).forEach((key) => newTr.setMeta(key, tr.getMeta(key)));
+    });
+    // This is kinda hacky solution at the moment to maintain NodeSelections over transactions
+    // These are required by at least cross-references that need it to activate the selector pop-up
+    if (wasNodeSelection) {
+        const mappedPos = newTr.mapping.map(tr.selection.from);
+        const resPos = newTr.doc.resolve(mappedPos);
+        const nodePos = mappedPos - (((_a = resPos.nodeBefore) === null || _a === void 0 ? void 0 : _a.nodeSize) || 0);
+        newTr.setSelection(getSelectionStaticCreate(tr.selection, newTr.doc, nodePos));
+    }
+    log.info('NEW transaction', newTr);
+    return newTr;
+}
+
+var TrackChangesStatus;
+(function (TrackChangesStatus) {
+    TrackChangesStatus["enabled"] = "enabled";
+    TrackChangesStatus["viewSnapshots"] = "view-snapshots";
+    TrackChangesStatus["disabled"] = "disabled";
+})(TrackChangesStatus || (TrackChangesStatus = {}));
+
+/*!
+ * © 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.
+ */
+const trackChangesPluginKey = new PluginKey('track-changes');
+// TODO remove
+const infiniteLoopCounter = {
+    start: 0,
+    iters: 0,
+};
+/**
+ * The ProseMirror plugin needed to enable track-changes.
+ *
+ * Accepts an empty options object as an argument but note that this uses 'anonymous:Anonymous' as the default userID.
+ * @param opts
+ */
+const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
+    const { userID, debug, skipTrsWithMetas = [] } = opts;
+    let editorView;
+    if (debug) {
+        enableDebug(true);
+    }
+    return new Plugin({
+        key: trackChangesPluginKey,
+        props: {
+            editable(state) {
+                return this.getState(state).status !== TrackChangesStatus.viewSnapshots;
+            },
+        },
+        state: {
+            init(_config, state) {
+                return {
+                    status: TrackChangesStatus.enabled,
+                    userID,
+                    changeSet: findChanges(state),
+                };
+            },
+            apply(tr, pluginState, _oldState, newState) {
+                const setUserID = getAction(tr, TrackChangesAction.setUserID);
+                const setStatus = getAction(tr, TrackChangesAction.setPluginStatus);
+                if (setUserID) {
+                    return { ...pluginState, userID: setUserID };
+                }
+                else if (setStatus) {
+                    return {
+                        ...pluginState,
+                        status: setStatus,
+                        changeSet: findChanges(newState),
+                    };
+                }
+                else if (pluginState.status === TrackChangesStatus.disabled) {
+                    return { ...pluginState, changeSet: new ChangeSet() };
+                }
+                let { changeSet, ...rest } = pluginState;
+                const updatedChangeIds = getAction(tr, TrackChangesAction.updateChanges);
+                if (updatedChangeIds || getAction(tr, TrackChangesAction.refreshChanges)) {
+                    changeSet = findChanges(newState);
+                }
+                return {
+                    changeSet,
+                    ...rest,
+                };
+            },
+        },
+        view(p) {
+            editorView = p;
+            return {
+                update: undefined,
+                destroy: undefined,
+            };
+        },
+        appendTransaction(trs, oldState, newState) {
+            const pluginState = trackChangesPluginKey.getState(newState);
+            if (!pluginState ||
+                pluginState.status === TrackChangesStatus.disabled ||
+                !(editorView === null || editorView === void 0 ? void 0 : editorView.editable)) {
+                return null;
+            }
+            if (infiniteLoopCounter.start < Date.now() - 10000) {
+                infiniteLoopCounter.start = Date.now();
+                infiniteLoopCounter.iters = 0;
+            }
+            if (infiniteLoopCounter.iters >= 100) {
+                console.error('Detected probable infinite loop in track changes!');
+                return null;
+            }
+            const { userID, changeSet } = pluginState;
+            let createdTr = newState.tr, docChanged = false;
+            log.info('TRS', trs);
+            trs.forEach((tr) => {
+                const wasAppended = tr.getMeta('appendedTransaction');
+                const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
+                const skipTrackUsed = getAction(tr, TrackChangesAction.skipTrack) ||
+                    (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
+                if (tr.docChanged && !skipMetaUsed && !skipTrackUsed && !tr.getMeta('history$')) {
+                    createdTr = trackTransaction(tr, oldState, createdTr, userID);
+                    createdTr.setMeta('origin', trackChangesPluginKey);
+                    infiniteLoopCounter.iters += 1;
+                }
+                docChanged = docChanged || tr.docChanged;
+                const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
+                if (setChangeStatuses) {
+                    const { status, ids } = setChangeStatuses;
+                    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]);
+                        }
+                    });
+                }
+                else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
+                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);
+                    applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.textChanges, mapping);
+                    setAction(createdTr, TrackChangesAction.refreshChanges, true);
+                }
+            });
+            const changed = pluginState.changeSet.hasInconsistentData &&
+                fixInconsistentChanges(pluginState.changeSet, userID, createdTr, oldState.schema);
+            if (changed) {
+                log.warn('had to fix inconsistent changes in', createdTr);
+            }
+            if (docChanged || createdTr.docChanged || changed) {
+                return setAction(createdTr, TrackChangesAction.refreshChanges, true);
+            }
+            return null;
+        },
+    });
+};
+
+/*!
+ * © 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'.
+ *
+ * In disabled view, the plugin is completely inactive and changes are not updated anymore.
+ * In viewSnasphots state, editor is set uneditable by editable prop that allows only selection changes
+ * to the document.
+ * @param status
+ */
+const setTrackingStatus = (status) => (state, dispatch) => {
+    var _a;
+    const currentStatus = (_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status;
+    if (currentStatus) {
+        let newStatus = status;
+        if (newStatus === undefined) {
+            newStatus =
+                currentStatus === TrackChangesStatus.enabled
+                    ? TrackChangesStatus.disabled
+                    : TrackChangesStatus.enabled;
+        }
+        dispatch && dispatch(setAction(state.tr, TrackChangesAction.setPluginStatus, newStatus));
+        return true;
+    }
+    return false;
+};
+/**
+ * Appends a transaction to set change attributes/marks' statuses to any of: 'pending' 'accepted' 'rejected'.
+ * @param status
+ * @param ids
+ */
+const setChangeStatuses = (status, ids) => (state, dispatch) => {
+    dispatch &&
+        dispatch(setAction(state.tr, TrackChangesAction.setChangeStatuses, {
+            status,
+            ids,
+        }));
+    return true;
+};
+/**
+ * Sets track-changes plugin's userID.
+ * @param userID
+ */
+const setUserID = (userID) => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.setUserID, userID));
+    return true;
+};
+/**
+ * Appends a transaction that applies all 'accepted' and 'rejected' changes to the document.
+ */
+const applyAndRemoveChanges = () => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.applyAndRemoveChanges, true));
+    return true;
+};
+/**
+ * Runs `findChanges` to iterate over the document to collect changes into a new ChangeSet.
+ */
+const refreshChanges = () => (state, dispatch) => {
+    dispatch && dispatch(setAction(state.tr, TrackChangesAction.updateChanges, []));
+    return true;
+};
+/**
+ * Adds track attributes for a block node. For testing puroses
+ */
+const setParagraphTestAttribute = (val = 'changed') => (state, dispatch) => {
+    var _a;
+    const cursor = state.selection.head;
+    const blockNodePos = state.doc.resolve(cursor).start(1) - 1;
+    if (((_a = state.doc.resolve(blockNodePos).nodeAfter) === null || _a === void 0 ? void 0 : _a.type) === state.schema.nodes.paragraph &&
+        dispatch) {
+        dispatch(state.tr.setNodeMarkup(blockNodePos, undefined, {
+            testAttribute: val,
+        }));
+        return true;
+    }
+    return false;
+};
+
+var commands = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  setTrackingStatus: setTrackingStatus,
+  setChangeStatuses: setChangeStatuses,
+  setUserID: setUserID,
+  applyAndRemoveChanges: applyAndRemoveChanges,
+  refreshChanges: refreshChanges,
+  setParagraphTestAttribute: setParagraphTestAttribute
+});
+
+export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesAction, TrackChangesStatus, enableDebug, getAction, setAction, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };