@manuscripts/track-changes-plugin 1.7.2 → 1.7.3-LEAN-2832-v3

package/dist/index.js

@@ -1,2013 +0,0 @@
-import { NodeSelection, 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["refreshChanges"] = "track-changes-refresh-changes";
-    TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
-    TrackChangesAction["updateMetaNode"] = "track-changes-update-meta-node";
-})(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);
-}
-/**
- * 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.
-
-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_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) {
-    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_instances, _ChangeSet_changes, _ChangeSet_isSameNodeChange, _ChangeSet_isNotPendingOrDeleted;
-/**
- * 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_instances.add(this);
-        _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.dataTracked.id) && ChangeSet.isValidDataTracked(c.dataTracked);
-            iteratedIds.add(c.dataTracked.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 (currentNodeChange &&
-                c.from < currentNodeChange.to &&
-                !(__classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isSameNodeChange).call(this, currentNodeChange, c) &&
-                    __classPrivateFieldGet(this, _ChangeSet_instances, "m", _ChangeSet_isNotPendingOrDeleted).call(this, currentNodeChange))) {
-                currentNodeChange.children.push(c);
-            }
-            else if (c.type === 'node-change') {
-                currentNodeChange = { ...c, children: [] };
-            }
-            else {
-                rootNodes.push(c);
-            }
-        });
-        if (currentNodeChange) {
-            rootNodes.push(currentNodeChange);
-        }
-        return rootNodes;
-    }
-    get pending() {
-        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.pending);
-    }
-    get accepted() {
-        return this.changeTree.filter((c) => c.dataTracked.status === CHANGE_STATUS.accepted);
-    }
-    get rejected() {
-        return this.changeTree.filter((c) => c.dataTracked.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 nodeAttrChanges() {
-        return this.changes.filter((c) => c.type === 'node-attr-change');
-    }
-    get bothNodeChanges() {
-        return this.changes.filter((c) => c.type === 'node-change' || c.type === 'node-attr-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.isValidDataTracked(c.dataTracked));
-    }
-    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 be deleted when applying it to the document.
-     * @param change
-     */
-    static shouldDeleteChange(change) {
-        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 dataTracked
-     */
-    static isValidDataTracked(dataTracked = {}) {
-        if ('dataTracked' in dataTracked) {
-            log.warn('passed "dataTracked" as property to isValidTrackedAttrs()', dataTracked);
-        }
-        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) &&
-            optionalEntries.every(([key, val]) => optionalKeys.includes(key) && val !== undefined) &&
-            (dataTracked.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';
-    }
-    static isNodeAttrChange(change) {
-        return change.type === 'node-attr-change';
-    }
-}
-_ChangeSet_changes = new WeakMap(), _ChangeSet_instances = new WeakSet(), _ChangeSet_isSameNodeChange = function _ChangeSet_isSameNodeChange(currentChange, nextChange) {
-    return currentChange.from === nextChange.from && currentChange.to === nextChange.to;
-}, _ChangeSet_isNotPendingOrDeleted = function _ChangeSet_isNotPendingOrDeleted(change) {
-    return (change.dataTracked.operation !== CHANGE_OPERATION.delete &&
-        change.dataTracked.status !== CHANGE_STATUS.pending);
-};
-
-/*!
- * © 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) {
-    const { 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
- *
- * 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 && liftTarget(range);
-    // Check with typeof since with prosemirror-transform pre 1.6.0 targetDepth is undefined
-    if (range && typeof targetDepth === 'number') {
-        return tr.lift(range, targetDepth);
-    }
-    const resPos = tr.doc.resolve(pos);
-    // Block nodes can be deleted by just removing their start token which should then merge the text
-    // content to above node's content (if there is one)
-    // this will work just for the node after the first child
-    const canMergeToNodeAbove = resPos.parent !== tr.doc && resPos.nodeBefore && node.isBlock && ((_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);
-    }
-}
-/**
- * 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);
-}
-
-/*!
- * © 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 (!tr.doc.resolve(pos).nodeBefore) {
-        // for this case will just delete that node in `deleteNode.ts` as the join will not work
-        return undefined;
-    }
-    // TODO is this the same thing as join to above?
-    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;
-}
-
-function updateChangeAttrs(tr, change, trackedAttrs, schema) {
-    const node = tr.doc.nodeAt(change.from);
-    if (!node) {
-        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 } }));
-    }
-    else if ((change.type === 'node-change' || change.type === 'node-attr-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' || change.type === 'node-attr-change') {
-        const trackedDataSource = getBlockInlineTrackedData(node) || [];
-        const targetDataTracked = trackedDataSource.find((t) => change.id === t.id);
-        const newDataTracked = trackedDataSource.map((oldTrack) => {
-            if (targetDataTracked) {
-                if (oldTrack.id === targetDataTracked.id) {
-                    return { ...oldTrack, ...trackedAttrs };
-                }
-                return 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.shouldDeleteChange(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);
-        }
-    });
-}
-
-function getUpdatedDataTracked(dataTracked, changeId) {
-    if (!dataTracked) {
-        return null;
-    }
-    const newDataTracked = dataTracked.filter((c) => c.id !== changeId);
-    return newDataTracked.length ? newDataTracked : null;
-}
-/**
- * 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()) {
-    const attrsChangesLog = new Map(); // map of node ids and applied change updatedAt timestamp
-    function addAttrLog(nodeId, changeId) {
-        const arr = attrsChangesLog.get(nodeId) || attrsChangesLog.set(nodeId, []).get(nodeId);
-        arr.push(changeId);
-    }
-    changes.forEach((change) => {
-        // 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.shouldDeleteChange(change);
-        if (!node) {
-            !deleted && log.warn('no node found to update for change', change);
-            return;
-        }
-        if (change.dataTracked.status === CHANGE_STATUS.pending) {
-            if (ChangeSet.isNodeAttrChange(change)) {
-                /*
-                  Apply pending changes for attributes as well because applying accepted/rejected changes may override
-                  pending because we store the most recent change directly on the node attributes. But in case of pending attributes
-                  we don't need to remove dataTracked record. We need, however, to make sure we don't restore dataTracked records for
-                  the previously applied changes. To check for already applied changes we log them into "attrsChangesLog" Map.
-                */
-                const { dataTracked, ...attrs } = change.newAttrs;
-                const changeLog = attrsChangesLog.get(node.attrs.id);
-                const newDataTracked = changeLog && changeLog.length ? dataTracked.filter((c) => !changeLog.includes(c.id)) : dataTracked;
-                tr.setNodeMarkup(from, undefined, { ...attrs, dataTracked: newDataTracked.length ? newDataTracked : null }, node.marks);
-                // default is "null" for dataTracked in attrs in pm schema, so codebase generally relies on it being null when empty
-            }
-            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());
-        }
-        else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === CHANGE_STATUS.accepted) {
-            tr.setNodeMarkup(from, undefined, { ...change.newAttrs, dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }, node.marks);
-            addAttrLog(node.attrs.id, change.dataTracked.id);
-        }
-        else if (ChangeSet.isNodeAttrChange(change) && change.dataTracked.status === CHANGE_STATUS.rejected) {
-            tr.setNodeMarkup(from, undefined, { ...change.oldAttrs, dataTracked: getUpdatedDataTracked(node.attrs.dataTracked, change.id) }, node.marks);
-            addAttrLog(node.attrs.id, change.dataTracked.id);
-        }
-    });
-    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 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
-            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;
-                continue;
-            }
-            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 {
-                change = {
-                    id,
-                    type: 'node-change',
-                    from: pos,
-                    to: pos + node.nodeSize,
-                    dataTracked,
-                    nodeType: node.type.name,
-                    children: [],
-                };
-            }
-            current = {
-                change,
-                node,
-            };
-        }
-        if (tracked.length === 0 && 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, currentUserID, newTr, schema) {
-    const iteratedIds = new Set();
-    let changed = false;
-    changeSet.invalidChanges.forEach((c) => {
-        const { id, authorID, operation, reviewedByID, status, createdAt, updatedAt } = c.dataTracked;
-        const newAttrs = {
-            ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
-            ...(!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.dataTracked, ...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.
- */
-/**
- * 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,
-    };
-}
-
-/*!
- * © 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));
-}
-/**
- * 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 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);
-        }
-    }
-    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(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) {
-    // Omit dataTracked
-    const { dataTracked, ...restAttrs } = oldAttrs;
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.set_node_attributes,
-        oldAttrs: JSON.parse(JSON.stringify(restAttrs)),
-    };
-}
-
-/*!
- * © 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
- *
- * 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 steps = [];
-    // No deletion applied, return default values
-    if (from === to) {
-        return {
-            newSliceContent: insertSlice.content,
-            sliceWasSplit: false,
-            steps,
-        };
-    }
-    const { openStart, openEnd } = insertSlice;
-    const { updatedSliceNodes, firstMergedNode, lastMergedNode } = splitSliceIntoMergedParts(insertSlice, gap !== undefined);
-    let mergingStartSide = true;
-    startDoc.nodesBetween(from, to, (node, pos) => {
-        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).
-        // For them we can just check whether the start token is within the gap eg pos is 10 when gap (8, 18) to
-        // determine whether it should be skipped.
-        // For text nodes though, since they are continous, they might only partially be enclosed in the gap
-        // eg. pos 10 when gap is (8, 18) BUT if their nodeEnd goes past the gap's end eg nodeEnd 20 they actually
-        // 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 && pos >= gap.start) ||
-                (node.isText && pos >= gap.start && nodeEnd <= gap.end));
-        // nodeEnd > offsetFrom -> delete touches this node
-        // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
-        if (nodeEnd > from && !wasWithinGap) {
-            // |<p>asdf</p>| -> node deleted completely
-            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)
-            // (<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 <= 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 = pos >= from; // && 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(pos).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) {
-                    // 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.
-                    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.
-                    // 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)
-                    steps.push({
-                        type: 'delete-text',
-                        pos,
-                        from: Math.max(pos, from),
-                        to: Math.min(nodeEnd, to),
-                        node,
-                    });
-                }
-                else ;
-            }
-            else if (nodeCompletelyDeleted) {
-                steps.push({
-                    type: 'delete-node',
-                    pos,
-                    nodeEnd,
-                    node,
-                });
-            }
-        }
-    });
-    return {
-        sliceWasSplit: !!(firstMergedNode || lastMergedNode),
-        newSliceContent: updatedSliceNodes
-            ? Fragment.fromArray(updatedSliceNodes)
-            : insertSlice.content,
-        steps,
-    };
-}
-
-/*!
- * © 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, tr, newTr, attrs) {
-    log.info('###### ReplaceAroundStep ######');
-    // @ts-ignore
-    const { from, to, gapFrom, gapTo, insert, slice, structure, } = 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(`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 { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
-    const 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)
-    // ^^answering above comment we could have meta node like(bibliography_item, contributor) will not have content at all,
-    // and that case gap will be 0, for that will use updateMetaNode to indicate that we are going just to update that node
-    if (gap.size > 0 ||
-        (!structure && newSliceContent.size > 0) ||
-        tr.getMeta(TrackChangesAction.updateMetaNode)) {
-        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 || tr.getMeta(TrackChangesAction.updateMetaNode)) {
-            log.info('insertedSlice before inserted gap', insertedSlice);
-            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
-            log.info('insertedSlice after inserted gap', insertedSlice);
-        }
-        deleteSteps.push({
-            type: 'insert-slice',
-            from: gapFrom,
-            to: gapTo,
-            slice: insertedSlice,
-            sliceWasSplit,
-        });
-    }
-    return steps;
-}
-
-/*!
- * © 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, stepResult, currentStepDoc) {
-    log.info('###### ReplaceStep ######');
-    let selectionPos = 0;
-    const changeSteps = [];
-    // Invert the transaction step to prevent it from actually deleting or inserting anything
-    step.getMap().forEach((fromA, toA, fromB, toB) => {
-        var _a, _b;
-        log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
-        const { slice } = step;
-        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
-        if (stepResult.failed) {
-            log.error(`invert ReplaceStep failed: "${stepResult.failed}"`);
-            return;
-        }
-        const { sliceWasSplit, newSliceContent, steps: deleteSteps, } = deleteAndMergeSplitNodes(fromA, toA, undefined, currentStepDoc, newTr, oldState.schema, attrs, slice);
-        changeSteps.push(...deleteSteps);
-        log.info('TR: steps after applying delete', [...newTr.steps]);
-        log.info('DELETE STEPS: ', changeSteps);
-        // console.log('CHANGE STEPS AT THIS POINT:')
-        // console.log(JSON.parse(JSON.stringify(changeSteps)))
-        function sameThingBackSpaced() {
-            /*
-            When deleting text with backspace and getting to the point of when a space and a character before a deleted piece of text is deleted
-            the prosemirror would interpret it as moving the <del> node (this is a tracked deletion) one characted behind.
-            It normally results in [delete, delete, insert] set of ChangSteps where the 1st delete is for the delete done by
-            the backspace key, the second delete and the insert are a misinterpretation of the moved text. So these last 2 steps have to be caught
-            and removed as they are not meaningful.
-            */
-            if (changeSteps.length == 2 && newSliceContent.size > 0) {
-                const correspondingDeletion = changeSteps.find(
-                // @ts-ignore
-                (step) => step.node.text === newSliceContent.content[0].text //  @TODO - get more precise proof of match. E.g.: position approximation
-                );
-                return correspondingDeletion;
-            }
-            return undefined;
-        }
-        const backSpacedText = sameThingBackSpaced();
-        if (backSpacedText) {
-            changeSteps.splice(changeSteps.indexOf(backSpacedText));
-        }
-        const textWasDeleted = !!changeSteps.length;
-        if (!backSpacedText && 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;
-            changeSteps.push({
-                type: 'insert-slice',
-                from: textWasDeleted ? fromB : toA,
-                to: textWasDeleted ? toB - 1 : toA,
-                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)
-            // When DEL is used, the selection is set to the end of the deleted content
-            // TODO: 'window.event' is deprecated, find a better way to detect the key used for deletion
-            // @ts-ignore
-            selectionPos = ((_a = window.event) === null || _a === void 0 ? void 0 : _a.code) === 'Delete' || ((_b = window.event) === null || _b === void 0 ? void 0 : _b.inputType) === 'deleteContentForward' ? toA : 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
- * @returns position at the end of the possibly deleted text
- */
-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;
-    }
-}
-
-/**
- * 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 leftDataTracked = leftMark.attrs.dataTracked;
-    const rightDataTracked = rightMark.attrs.dataTracked;
-    if (!shouldMergeTrackedAttributes(leftDataTracked, rightDataTracked)) {
-        return;
-    }
-    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({ ...leftMark.attrs, dataTracked }));
-}
-
-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(`processChangeSteps: insert-slice ReplaceStep failed "${stepResult.failed}"`, newStep);
-                return;
-            }
-            mergeTrackedMarks(mapping.map(c.from), newTr.doc, newTr, schema);
-            const to = mapping.map(c.to) + c.slice.size;
-            mergeTrackedMarks(mapping.map(c.to) + (to < newTr.doc.nodeSize ? c.slice.size : 0), 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.reverse().find((d) => {
-                // reversing to start from the most recent change
-                if (d.operation === CHANGE_OPERATION.set_node_attributes &&
-                    (d.status === CHANGE_STATUS.pending || d.status === CHANGE_STATUS.rejected)) {
-                    return true;
-                }
-                return false;
-            });
-            // if the selected last change is with status "rejected" we need to use oldAttrs from it because
-            // node's actual attributes represent the "rejected" values
-            const lastChangeRejected = oldUpdate && oldUpdate.status === CHANGE_STATUS.rejected;
-            const sourceAttrs = (oldUpdate === null || oldUpdate === void 0 ? void 0 : oldUpdate.oldAttrs) || c.node.attrs;
-            const { dataTracked, ...restAttrs } = sourceAttrs;
-            const oldAttrs = lastChangeRejected ? oldUpdate.oldAttrs : restAttrs;
-            const newDataTracked = [
-                ...oldDataTracked.filter((d) => !oldUpdate || d.id !== oldUpdate.id || lastChangeRejected),
-            ];
-            const newUpdate = oldUpdate && oldUpdate.status !== CHANGE_STATUS.rejected
-                ? {
-                    ...oldUpdate,
-                    updatedAt: emptyAttrs.updatedAt,
-                }
-                : addTrackIdIfDoesntExist(createNewUpdateAttrs(emptyAttrs, lastChangeRejected ? oldAttrs : c.node.attrs));
-            // Dont add update changes if there exists already an insert change for this node
-            if ((JSON.stringify(oldAttrs) !== JSON.stringify(c.newAttrs) ||
-                c.node.type === c.node.type.schema.nodes.citation) &&
-                !oldDataTracked.find((d) => d.operation === CHANGE_OPERATION.insert && d.status === CHANGE_STATUS.pending)) {
-                newDataTracked.push(newUpdate);
-            }
-            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];
-}
-
-/**
- * Matches deleted-text recursively to inserted text
- *
- * This is needed as text containing various marks is split into multiple parts even though it's
- * continously deleted. Therefore, we need to find the next part if there is any and keep going until
- * we've reached the end of the deleted text or inserted content.
- * @param adjDeleted
- * @param insNode
- * @param offset
- * @param matchedDeleted
- * @param deleted
- * @returns
- */
-function matchText(adjDeleted, insNode, offset, matchedDeleted, deleted) {
-    const { pos, from, to, node: delNode } = adjDeleted;
-    let j = offset, 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) {
-        matchedDeleted += 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 || {},
-    // })
-    deleted = deleted.filter((d) => d !== adjDeleted);
-    if (maxSteps !== j) {
-        deleted.push({
-            pos,
-            from: from + j - offset,
-            to,
-            type: 'delete-text',
-            node: delNode,
-        });
-        return [matchedDeleted, deleted];
-    }
-    const nextTextDelete = deleted.find((d) => d.type === 'delete-text' && d.pos === to);
-    if (nextTextDelete) {
-        return matchText(nextTextDelete, insNode, j, matchedDeleted, deleted);
-    }
-    return [matchedDeleted, deleted];
-}
-/**
- * Matches deleted to inserted content and returns the first pos they differ and the updated
- * ChangeStep list.
- *
- * Based on https://github.com/ProseMirror/prosemirror-model/blob/master/src/diff.ts
- * @param matchedDeleted
- * @param deleted
- * @param inserted
- * @returns
- */
-function matchInserted(matchedDeleted, deleted, inserted) {
-    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
-        const 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)) {
-            matched = matchText(adjDeleted, insNode, 0, matched[0], matched[1]);
-            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 {
-            matched = [matched[0] + insNode.nodeSize, matched[1].filter((d) => d !== adjDeleted)];
-        }
-        // Omit dataTracked
-        const { dataTracked, ...newAttrs } = insNode.attrs || {};
-        matched[1].push({
-            pos: adjDeleted.pos,
-            type: 'update-node-attrs',
-            node: adjDeleted.node,
-            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.
- */
-/**
- * Cuts a fragment similar to Fragment.cut but also removes the parent node.
- *
- * @param matched
- * @param deleted
- * @param content
- * @returns
- */
-function cutFragment(matched, deleted, content) {
-    const 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 (deleted - matched > 0) {
-                newContent.push(child.cut(deleted - matched));
-            }
-            else {
-                newContent.push(child);
-            }
-            matched = deleted + 1;
-        }
-        else {
-            matched += child.nodeSize;
-        }
-    }
-    return [matched, Fragment.fromArray(newContent)];
-}
-function diffChangeSteps(deleted, inserted) {
-    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 = updatedDeleted.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 [matchedDeleted, updatedDel] = matchInserted(deleteStart, updatedDeleted, ins.slice.content);
-        if (matchedDeleted === deleteStart) {
-            updated.push(ins);
-            return;
-        }
-        updatedDeleted = updatedDel;
-        const [_, newInserted] = cutFragment(0, matchedDeleted - deleteStart, ins.slice.content);
-        if (newInserted.size > 0) {
-            updated.push({
-                ...ins,
-                slice: new Slice(newInserted, ins.slice.openStart, ins.slice.openEnd),
-            });
-        }
-    });
-    log.info('FINISH DIFF: ', [...updatedDeleted, ...updated]);
-    return [...updatedDeleted, ...updated];
-}
-
-/**
- * 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
- * @returns
- */
-const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
-const isHighlightMarkerNode = (node) => node && node.type === node.type.schema.nodes.highlight_marker;
-/**
- * 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 authorID User id
- * @returns newTr that inverts the initial tr and applies track attributes/marks
- */
-function trackTransaction(tr, oldState, newTr, authorID) {
-    var _a, _b, _c, _d;
-    const emptyAttrs = {
-        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
-    // difficult than prosemirror-transform
-    const wasNodeSelection = tr.selection instanceof NodeSelection;
-    let iters = 0;
-    log.info('ORIGINAL transaction', tr);
-    for (let i = tr.steps.length - 1; i >= 0; i--) {
-        const step = tr.steps[i];
-        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);
-            continue;
-        }
-        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');
-            continue;
-        }
-        else if (step instanceof ReplaceStep) {
-            const { slice } = step;
-            if (((_b = (_a = slice === null || slice === void 0 ? void 0 : slice.content) === null || _a === void 0 ? void 0 : _a.content) === null || _b === void 0 ? void 0 : _b.length) === 1 &&
-                isHighlightMarkerNode(slice.content.content[0])) {
-                // don't track highlight marker nodes
-                continue;
-            }
-            const newStep = step.invert(tr.docs[i]);
-            const stepResult = newTr.maybeStep(newStep);
-            let [steps, startPos] = trackReplaceStep(step, oldState, newTr, emptyAttrs, stepResult, tr.docs[i]);
-            if (steps.length === 1) {
-                const step = steps[0]; // eslint-disable-line @typescript-eslint/no-explicit-any
-                if (isHighlightMarkerNode((step === null || step === void 0 ? void 0 : step.node) || ((_d = (_c = step === null || step === void 0 ? void 0 : step.slice) === null || _c === void 0 ? void 0 : _c.content) === null || _d === void 0 ? void 0 : _d.content[0]))) {
-                    // don't track deleted highlight marker nodes
-                    continue;
-                }
-            }
-            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);
-            log.info('DIFFED STEPS: ', steps);
-            const [mapping, selectionPos] = processChangeSteps(steps, startPos || tr.selection.head, // Incase startPos is it's default value 0, use the old selection head
-            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
-                // eg when inserting a complete new paragraph. -1 finds the first valid position moving backwards
-                // inside the content
-                const near = sel.near(newTr.doc.resolve(selectionPos), -1);
-                newTr.setSelection(near);
-            }
-        }
-        else if (step instanceof ReplaceAroundStep) {
-            let steps = trackReplaceAroundStep(step, oldState, tr, 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);
-            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.
-        // The old meta keys are not copied to the new transaction since this will cause race-conditions
-        // when a single meta-field is expected to having been processed / removed. Generic input meta keys,
-        // inputType and uiEvent, are re-added since some plugins might depend on them and process the transaction
-        // after track-changes plugin.
-        tr.getMeta('inputType') && newTr.setMeta('inputType', tr.getMeta('inputType'));
-        tr.getMeta('uiEvent') && newTr.setMeta('uiEvent', tr.getMeta('uiEvent'));
-    }
-    // This is kinda hacky solution at the moment to maintain NodeSelections over transactions
-    // These are required by at least cross-references and links to activate their selector pop-ups
-    if (wasNodeSelection) {
-        console.log('%c Getting into node select! ', 'background: #222; color: #bada55');
-        // And -1 here is necessary to keep the selection pointing at the start of the node
-        // (or something, breaks with cross-references otherwise)
-        const mappedPos = newTr.mapping.map(tr.selection.from, -1);
-        const sel = getSelectionStaticConstructor(tr.selection);
-        newTr.setSelection(sel.create(newTr.doc, mappedPos));
-    }
-    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');
-/**
- * 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) {
-                var _a;
-                return ((_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.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: setStatus === TrackChangesStatus.disabled ? new ChangeSet() : findChanges(newState),
-                    };
-                }
-                else if (pluginState.status === TrackChangesStatus.disabled) {
-                    return { ...pluginState, changeSet: new ChangeSet() };
-                }
-                let { changeSet, ...rest } = pluginState;
-                if (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;
-            }
-            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$') && !(wasAppended && tr.getMeta('origin') === 'paragraphs')) {
-                    createdTr = trackTransaction(tr, oldState, createdTr, userID);
-                }
-                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, { ...change.dataTracked, status, reviewedByID: userID }, oldState.schema);
-                        }
-                    });
-                }
-                else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
-                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.bothNodeChanges);
-                    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) {
-                createdTr.setMeta('origin', trackChangesPluginKey);
-                return setAction(createdTr, TrackChangesAction.refreshChanges, true);
-            }
-            return null;
-        },
-    });
-};
-
-/**
- * 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.refreshChanges, true));
-    return true;
-};
-
-var commands = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setTrackingStatus: setTrackingStatus,
-  setChangeStatuses: setChangeStatuses,
-  setUserID: setUserID,
-  applyAndRemoveChanges: applyAndRemoveChanges,
-  refreshChanges: refreshChanges
-});
-
-export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesStatus, enableDebug, skipTracking, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };