@manuscripts/track-changes-plugin 0.3.0 → 0.4.0

package/dist/index.es.js

@@ -1,1547 +0,0 @@
-import { PluginKey, Plugin } from 'prosemirror-state';
-import debug from 'debug';
-import { liftTarget, canJoin, Mapping, ReplaceStep, ReplaceAroundStep } from 'prosemirror-transform';
-import { Fragment, Slice } from 'prosemirror-model';
-
-var TrackChangesAction;
-(function (TrackChangesAction) {
-    TrackChangesAction["skipTrack"] = "track-changes-skip-tracking";
-    TrackChangesAction["setUserID"] = "track-changes-set-user-id";
-    TrackChangesAction["setPluginStatus"] = "track-changes-set-track-status";
-    TrackChangesAction["setChangeStatuses"] = "track-changes-set-change-statuses";
-    TrackChangesAction["updateChanges"] = "track-changes-update-changes";
-    TrackChangesAction["refreshChanges"] = "track-changes-refresh-changes";
-    TrackChangesAction["applyAndRemoveChanges"] = "track-changes-apply-remove-changes";
-})(TrackChangesAction || (TrackChangesAction = {}));
-/**
- * Gets the value of a meta field, action payload, of a defined track-changes action.
- * @param tr
- * @param action
- */
-function getAction(tr, action) {
-    return tr.getMeta(action);
-}
-/**
- * Use this function to set meta keys to transactions that are consumed by the track-changes-plugin.
- * For example, you can skip tracking of a transaction with setAction(tr, TrackChangesAction.skipTrack, true)
- * @param tr
- * @param action
- * @param payload
- */
-function setAction(tr, action, payload) {
-    return tr.setMeta(action, payload);
-}
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-var CHANGE_OPERATION;
-(function (CHANGE_OPERATION) {
-    CHANGE_OPERATION["insert"] = "insert";
-    CHANGE_OPERATION["delete"] = "delete";
-    CHANGE_OPERATION["set_node_attributes"] = "set_node_attributes";
-    CHANGE_OPERATION["wrap_with_node"] = "wrap_with_node";
-    CHANGE_OPERATION["unwrap_from_node"] = "unwrap_from_node";
-    CHANGE_OPERATION["add_mark"] = "add_mark";
-    CHANGE_OPERATION["remove_mark"] = "remove_mark";
-})(CHANGE_OPERATION || (CHANGE_OPERATION = {}));
-var CHANGE_STATUS;
-(function (CHANGE_STATUS) {
-    CHANGE_STATUS["accepted"] = "accepted";
-    CHANGE_STATUS["rejected"] = "rejected";
-    CHANGE_STATUS["pending"] = "pending";
-})(CHANGE_STATUS || (CHANGE_STATUS = {}));
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const logger = debug('track');
-const log = {
-    info(str, obj) {
-        if (obj) {
-            logger(str, obj);
-        }
-        else {
-            logger(str);
-        }
-    },
-    warn(str, obj) {
-        if (obj) {
-            logger(`%c WARNING ${str}`, 'color: #f3f32c', obj);
-        }
-        else {
-            logger(`%c WARNING ${str}`, 'color: #f3f32c');
-        }
-    },
-    error(str, obj) {
-        if (obj) {
-            logger(`%c ERROR ${str}`, 'color: #ff4242', obj);
-        }
-        else {
-            logger(`%c ERROR ${str}`, 'color: #ff4242');
-        }
-    },
-};
-/**
- * Sets debug logging enabled/disabled.
- * @param enabled
- */
-const enableDebug = (enabled) => {
-    if (enabled) {
-        debug.enable('track');
-    }
-    else {
-        debug.disable();
-    }
-};
-
-var _ChangeSet_changes;
-/**
- * ChangeSet is a data structure to contain the tracked changes with some utility methods and computed
- * values to allow easier operability.
- */
-class ChangeSet {
-    constructor(changes = []) {
-        _ChangeSet_changes.set(this, void 0);
-        __classPrivateFieldSet(this, _ChangeSet_changes, changes, "f");
-    }
-    /**
-     * List of all the valid TrackedChanges. This prevents for example changes with duplicate ids being shown
-     * in the UI, causing errors.
-     */
-    get changes() {
-        const iteratedIds = new Set();
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => {
-            const valid = !iteratedIds.has(c.attrs.id) && ChangeSet.isValidTrackedAttrs(c.attrs);
-            iteratedIds.add(c.attrs.id);
-            return valid;
-        });
-    }
-    get invalidChanges() {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => !this.changes.find((cc) => c.id === cc.id));
-    }
-    /**
-     * List of 1-level nested changes where the top-most node change contains all the changes within its start
-     * and end position. This is useful for showing the changes as groups in the UI.
-     */
-    get changeTree() {
-        const rootNodes = [];
-        let currentNodeChange;
-        this.changes.forEach((c) => {
-            if (currentNodeChange && c.from >= currentNodeChange.to) {
-                rootNodes.push(currentNodeChange);
-                currentNodeChange = undefined;
-            }
-            if (c.type === 'node-change' && currentNodeChange && c.from < currentNodeChange.to) {
-                currentNodeChange.children.push(c);
-            }
-            else if (c.type === 'node-change') {
-                currentNodeChange = { ...c, children: [] };
-            }
-            else if (c.type === 'text-change' && currentNodeChange && c.from < currentNodeChange.to) {
-                currentNodeChange.children.push(c);
-            }
-            else if (c.type === 'text-change') {
-                rootNodes.push(c);
-            }
-        });
-        if (currentNodeChange) {
-            rootNodes.push(currentNodeChange);
-        }
-        return rootNodes;
-    }
-    get pending() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.pending);
-    }
-    get accepted() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.accepted);
-    }
-    get rejected() {
-        return this.changeTree.filter((c) => c.attrs.status === CHANGE_STATUS.rejected);
-    }
-    get textChanges() {
-        return this.changes.filter((c) => c.type === 'text-change');
-    }
-    get nodeChanges() {
-        return this.changes.filter((c) => c.type === 'node-change');
-    }
-    get isEmpty() {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").length === 0;
-    }
-    /**
-     * Used to determine whether `fixInconsistentChanges` has to be executed to replace eg duplicate ids or
-     * changes that are missing attributes.
-     */
-    get hasInconsistentData() {
-        return this.hasDuplicateIds || this.hasIncompleteAttrs;
-    }
-    get hasDuplicateIds() {
-        const iterated = new Set();
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => {
-            if (iterated.has(c.id)) {
-                return true;
-            }
-            iterated.add(c.id);
-        });
-    }
-    get hasIncompleteAttrs() {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").some((c) => !ChangeSet.isValidTrackedAttrs(c.attrs));
-    }
-    get(id) {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id);
-    }
-    getIn(ids) {
-        return ids
-            .map((id) => __classPrivateFieldGet(this, _ChangeSet_changes, "f").find((c) => c.id === id))
-            .filter((c) => c !== undefined);
-    }
-    getNotIn(ids) {
-        return __classPrivateFieldGet(this, _ChangeSet_changes, "f").filter((c) => ids.includes(c.id));
-    }
-    /**
-     * Flattens a changeTree into a list of IDs
-     * @param changes
-     */
-    static flattenTreeToIds(changes) {
-        return changes.flatMap((c) => this.isNodeChange(c) ? [c.id, ...c.children.map((c) => c.id)] : c.id);
-    }
-    /**
-     * Determines whether a change should not be deleted when applying it to the document.
-     * @param change
-     */
-    static shouldNotDelete(change) {
-        const { status, operation } = change.attrs;
-        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.accepted) ||
-            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.rejected));
-    }
-    /**
-     * Determines whether a change should be deleted when applying it to the document.
-     * @param change
-     */
-    static shouldDeleteChange(change) {
-        const { status, operation } = change.attrs;
-        return ((operation === CHANGE_OPERATION.insert && status === CHANGE_STATUS.rejected) ||
-            (operation === CHANGE_OPERATION.delete && status === CHANGE_STATUS.accepted));
-    }
-    /**
-     * Checks whether change attributes contain all TrackedAttrs keys with non-undefined values
-     * @param attrs
-     */
-    static isValidTrackedAttrs(attrs = {}) {
-        if ('attrs' in attrs) {
-            log.warn('passed "attrs" as property to isValidTrackedAttrs(attrs)', attrs);
-        }
-        const trackedKeys = ['id', 'userID', 'operation', 'status', 'createdAt'];
-        const entries = Object.entries(attrs);
-        return (entries.length === trackedKeys.length &&
-            entries.every(([key, val]) => trackedKeys.includes(key) && val !== undefined) &&
-            (attrs.id || '').length > 0 // Changes created with undefined id have '' as placeholder
-        );
-    }
-    static isTextChange(change) {
-        return change.type === 'text-change';
-    }
-    static isNodeChange(change) {
-        return change.type === 'node-change';
-    }
-}
-_ChangeSet_changes = new WeakMap();
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Deletes node but tries to leave its content intact by trying to unwrap it first
- *
- * Incase unwrapping doesn't work deletes the whole node.
- * @param node
- * @param pos
- * @param tr
- * @returns
- */
-function deleteNode(node, pos, tr) {
-    var _a;
-    const startPos = tr.doc.resolve(pos + 1);
-    const range = startPos.blockRange(tr.doc.resolve(startPos.pos - 2 + node.nodeSize));
-    const targetDepth = range && liftTarget(range);
-    // Check with typeof since with old prosemirror-transform targetDepth is undefined
-    if (range && typeof targetDepth === 'number') {
-        return tr.lift(range, targetDepth);
-    }
-    const resPos = tr.doc.resolve(pos);
-    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
-    if (canMergeToNodeAbove) {
-        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
-    }
-    else {
-        // NOTE: there's an edge case where moving content is not possible but because the immediate
-        // child, say some wrapper blockNode, is also deleted the content could be retained. TODO I guess.
-        return tr.delete(pos, pos + node.nodeSize);
-    }
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Deletes node but tries to leave its content intact by moving/wrapping it to a node before or after
- * @param node
- * @param pos
- * @param tr
- * @returns
- */
-function mergeNode(node, pos, tr) {
-    var _a;
-    if (canJoin(tr.doc, pos)) {
-        return tr.join(pos);
-    }
-    else if (canJoin(tr.doc, pos + node.nodeSize)) {
-        return tr.join(pos + node.nodeSize);
-    }
-    // TODO is this the same thing as join?
-    const resPos = tr.doc.resolve(pos);
-    const canMergeToNodeAbove = (resPos.parent !== tr.doc || resPos.nodeBefore) && ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.isText);
-    if (canMergeToNodeAbove) {
-        return tr.replaceWith(pos - 1, pos + 1, Fragment.empty);
-    }
-    return undefined;
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function uuidv4() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c == 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-
-function addTrackIdIfDoesntExist(attrs) {
-    if (!attrs.id) {
-        return {
-            id: uuidv4(),
-            ...attrs,
-        };
-    }
-    return attrs;
-}
-function getInlineNodeTrackedMarkData(node, schema) {
-    if (!node || !node.isInline) {
-        return undefined;
-    }
-    const marksTrackedData = [];
-    node.marks.forEach((mark) => {
-        if (mark.type === schema.marks.tracked_insert || mark.type === schema.marks.tracked_delete) {
-            const operation = mark.type === schema.marks.tracked_insert
-                ? CHANGE_OPERATION.insert
-                : CHANGE_OPERATION.delete;
-            marksTrackedData.push({ ...mark.attrs.dataTracked, operation });
-        }
-    });
-    if (marksTrackedData.length > 1) {
-        log.warn('inline node with more than 1 of tracked marks', marksTrackedData);
-    }
-    return marksTrackedData[0] || undefined;
-}
-function getNodeTrackedData(node, schema) {
-    return !node
-        ? undefined
-        : node.isText
-            ? getInlineNodeTrackedMarkData(node, schema)
-            : node.attrs.dataTracked;
-}
-function equalMarks(n1, n2) {
-    return (n1.marks.length === n2.marks.length &&
-        n1.marks.every((mark) => n1.marks.find((m) => m.type === mark.type)));
-}
-function shouldMergeTrackedAttributes(left, right) {
-    if (!left || !right) {
-        log.warn('passed undefined dataTracked attributes to shouldMergeTrackedAttributes', {
-            left,
-            right,
-        });
-        return false;
-    }
-    return (left.status === right.status &&
-        left.operation === right.operation &&
-        left.userID === right.userID);
-}
-function getMergeableMarkTrackedAttrs(node, attrs, schema) {
-    const nodeAttrs = getInlineNodeTrackedMarkData(node, schema);
-    return nodeAttrs && shouldMergeTrackedAttributes(nodeAttrs, attrs) ? nodeAttrs : null;
-}
-
-function updateChangeAttrs(tr, change, trackedAttrs, schema) {
-    const node = tr.doc.nodeAt(change.from);
-    if (!node) {
-        throw Error('No node at the from of change' + change);
-    }
-    const dataTracked = { ...getNodeTrackedData(node, schema), ...trackedAttrs };
-    const oldMark = node.marks.find((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete);
-    if (change.type === 'text-change' && oldMark) {
-        tr.addMark(change.from, change.to, oldMark.type.create({ ...oldMark.attrs, dataTracked }));
-    }
-    else if (change.type === 'node-change') {
-        tr.setNodeMarkup(change.from, undefined, { ...node.attrs, dataTracked }, node.marks);
-    }
-    return tr;
-}
-function updateChangeChildrenAttributes(changes, tr, mapping) {
-    changes.forEach((c) => {
-        if (c.type === 'node-change' && ChangeSet.shouldNotDelete(c)) {
-            const from = mapping.map(c.from);
-            const node = tr.doc.nodeAt(from);
-            if (!node) {
-                return;
-            }
-            const attrs = { ...node.attrs, dataTracked: null };
-            tr.setNodeMarkup(from, undefined, attrs, node.marks);
-        }
-    });
-}
-
-/**
- * Applies the accepted/rejected changes in the current document and sets them untracked
- *
- * @param tr
- * @param schema
- * @param changes
- * @param deleteMap
- */
-function applyAcceptedRejectedChanges(tr, schema, changes, deleteMap = new Mapping()) {
-    changes.forEach((change) => {
-        if (change.attrs.status === CHANGE_STATUS.pending) {
-            return;
-        }
-        // Map change.from and skip those which dont need to be applied
-        // or were already deleted by an applied block delete
-        const { pos: from, deleted } = deleteMap.mapResult(change.from), node = tr.doc.nodeAt(from), noChangeNeeded = deleted || ChangeSet.shouldNotDelete(change);
-        if (!node) {
-            !deleted && log.warn('no node found to update for change', change);
-            return;
-        }
-        if (ChangeSet.isTextChange(change) && noChangeNeeded) {
-            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_insert);
-            tr.removeMark(from, deleteMap.map(change.to), schema.marks.tracked_delete);
-        }
-        else if (ChangeSet.isTextChange(change)) {
-            tr.delete(from, deleteMap.map(change.to));
-            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
-        }
-        else if (ChangeSet.isNodeChange(change) && noChangeNeeded) {
-            const attrs = { ...node.attrs, dataTracked: null };
-            tr.setNodeMarkup(from, undefined, attrs, node.marks);
-            updateChangeChildrenAttributes(change.children, tr, deleteMap);
-        }
-        else if (ChangeSet.isNodeChange(change)) {
-            // Try first moving the node children to either nodeAbove, nodeBelow or its parent.
-            // Then try unwrapping it with lift or just hacky-joining by replacing the border between
-            // it and its parent with Fragment.empty. If none of these apply, delete the content between the change.
-            const merged = mergeNode(node, from, tr);
-            if (merged === undefined) {
-                deleteNode(node, from, tr);
-            }
-            deleteMap.appendMap(tr.steps[tr.steps.length - 1].getMap());
-        }
-    });
-    return deleteMap;
-}
-
-/**
- * Finds all changes (basically text marks or node attributes) from document
- *
- * This could be possibly made more efficient by only iterating the sections of doc
- * where changes have been applied. This could attempted with eg findDiffStart
- * but it might be less robust than just using doc.descendants
- * @param state
- * @returns
- */
-function findChanges(state) {
-    const changes = [];
-    // Store the last iterated change to join adjacent text changes
-    let current;
-    state.doc.descendants((node, pos) => {
-        const attrs = getNodeTrackedData(node, state.schema);
-        if (attrs) {
-            const id = (attrs === null || attrs === void 0 ? void 0 : attrs.id) || '';
-            // Join adjacent text changes that have been broken up due to different marks
-            // eg <ins><b>bold</b>norm<i>italic</i></ins> -> treated as one continuous change
-            // Note the !equalMarks to leave changes separate incase the marks are equal to let fixInconsistentChanges to fix them
-            if (current &&
-                current.change.id === id &&
-                current.node.isText &&
-                node.isText &&
-                !equalMarks(node, current.node)) {
-                current.change.to = pos + node.nodeSize;
-                // Important to update the node as the text changes might contain multiple parts where some marks equal each other
-                current.node = node;
-            }
-            else if (node.isText) {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'text-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        attrs,
-                    },
-                    node,
-                };
-            }
-            else {
-                current && changes.push(current.change);
-                current = {
-                    change: {
-                        id,
-                        type: 'node-change',
-                        from: pos,
-                        to: pos + node.nodeSize,
-                        nodeType: node.type.name,
-                        children: [],
-                        attrs,
-                    },
-                    node,
-                };
-            }
-        }
-        else if (current) {
-            changes.push(current.change);
-            current = undefined;
-        }
-    });
-    current && changes.push(current.change);
-    return new ChangeSet(changes);
-}
-
-/**
- * Iterates over a ChangeSet to check all changes have their required attributes
- *
- * This inconsistency might happen due to a bug in the track changes implementation or by a user somehow applying an empty insert/delete mark that doesn't contain proper data. Also this checks the track IDs for duplicates.
- * @param changeSet
- * @param currentUser
- * @param newTr
- * @param schema
- * @return docWasChanged, a boolean
- */
-function fixInconsistentChanges(changeSet, trackUserID, newTr, schema) {
-    const iteratedIds = new Set();
-    let changed = false;
-    changeSet.invalidChanges.forEach((c) => {
-        const { id, userID, operation, status, createdAt } = c.attrs;
-        const newAttrs = {
-            ...((!id || iteratedIds.has(id) || id.length === 0) && { id: uuidv4() }),
-            ...(!userID && { userID: trackUserID }),
-            ...(!operation && { operation: CHANGE_OPERATION.insert }),
-            ...(!status && { status: CHANGE_STATUS.pending }),
-            ...(!createdAt && { createdAt: Date.now() }),
-        };
-        if (Object.keys(newAttrs).length > 0) {
-            updateChangeAttrs(newTr, c, { ...c.attrs, ...newAttrs }, schema);
-            changed = true;
-        }
-        iteratedIds.add(newAttrs.id || id);
-    });
-    return changed;
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function markInlineNodeChange(node, newTrackAttrs, schema) {
-    const filtered = node.marks.filter((m) => m.type !== schema.marks.tracked_insert && m.type !== schema.marks.tracked_delete);
-    const mark = newTrackAttrs.operation === CHANGE_OPERATION.insert
-        ? schema.marks.tracked_insert
-        : schema.marks.tracked_delete;
-    const createdMark = mark.create({
-        dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-    });
-    return node.mark(filtered.concat(createdMark));
-}
-function recurseNodeContent(node, newTrackAttrs, schema) {
-    if (node.isText) {
-        return markInlineNodeChange(node, newTrackAttrs, schema);
-    }
-    else if (node.isBlock || node.isInline) {
-        const updatedChildren = [];
-        node.content.forEach((child) => {
-            updatedChildren.push(recurseNodeContent(child, newTrackAttrs, schema));
-        });
-        return node.type.create({
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(newTrackAttrs),
-        }, Fragment.fromArray(updatedChildren), node.marks);
-    }
-    else {
-        log.error(`unhandled node type: "${node.type.name}"`, node);
-        return node;
-    }
-}
-function setFragmentAsInserted(inserted, insertAttrs, schema) {
-    // Recurse the content in the inserted slice and either mark it tracked_insert or set node attrs
-    const updatedInserted = [];
-    inserted.forEach((n) => {
-        updatedInserted.push(recurseNodeContent(n, insertAttrs, schema));
-    });
-    return updatedInserted.length === 0 ? inserted : Fragment.fromArray(updatedInserted);
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function createNewInsertAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.insert,
-    };
-}
-function createNewDeleteAttrs(attrs) {
-    return {
-        ...attrs,
-        operation: CHANGE_OPERATION.delete,
-    };
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Recurses node children and returns the merged first/last node's content and the unmerged children
- *
- * For example when merging two blockquotes:
- * <bq><p>old|</p></bq>...| + [<bq><p>] inserted</p><p>2nd p</p></bq> -> <bq><p>old inserted</p><p>2nd p</p></bq>
- * The extracted merged and unmerged content from the insertSlice are:
- * {
- *   mergedNodeContent: <text> inserted</text>
- *   unmergedContent: [<p>2nd p</p>]
- * }
- * @param node
- * @param currentDepth
- * @param depth
- * @param first
- * @returns
- */
-function getMergedNode(node, currentDepth, depth, first) {
-    if (currentDepth === depth) {
-        return {
-            mergedNodeContent: node.content,
-            unmergedContent: undefined,
-        };
-    }
-    const result = [];
-    let merged = Fragment.empty;
-    node.content.forEach((n, _, i) => {
-        if ((first && i === 0) || (!first && i === node.childCount - 1)) {
-            const { mergedNodeContent, unmergedContent } = getMergedNode(n, currentDepth + 1, depth, first);
-            merged = mergedNodeContent;
-            if (unmergedContent) {
-                result.push(...unmergedContent.content);
-            }
-        }
-        else {
-            result.push(n);
-        }
-    });
-    return {
-        mergedNodeContent: merged,
-        unmergedContent: result.length > 0 ? Fragment.fromArray(result) : undefined,
-    };
-}
-/**
- * Filters merged nodes from an open insertSlice to manually merge them to prevent unwanted deletions
- *
- * So instead of joining the slice by its open sides, possibly deleting previous nodes, we can push the
- * changed content manually inside the merged nodes.
- * Eg. instead of doing `|<p>asdf</p><p>|bye</p>` automatically, we extract the merged nodes first:
- * {
- *  updatedSliceNodes: [<p>asdf</p>],
- *  firstMergedNode: <p>bye</p>,
- *  lastMergedNode: undefined,
- * }
- * @param insertSlice inserted slice
- */
-function splitSliceIntoMergedParts(insertSlice, mergeEqualSides = false) {
-    const { openStart, openEnd, content: { firstChild, lastChild, content: nodes }, } = insertSlice;
-    let updatedSliceNodes = nodes;
-    const mergeSides = openStart !== openEnd || mergeEqualSides;
-    const firstMergedNode = openStart > 0 && mergeSides && firstChild
-        ? getMergedNode(firstChild, 1, openStart, true)
-        : undefined;
-    const lastMergedNode = openEnd > 0 && mergeSides && lastChild ? getMergedNode(lastChild, 1, openEnd, false) : undefined;
-    if (firstMergedNode) {
-        updatedSliceNodes = updatedSliceNodes.slice(1);
-        if (firstMergedNode.unmergedContent) {
-            updatedSliceNodes = [...firstMergedNode.unmergedContent.content, ...updatedSliceNodes];
-        }
-    }
-    if (lastMergedNode) {
-        updatedSliceNodes = updatedSliceNodes.slice(0, -1);
-        if (lastMergedNode.unmergedContent) {
-            updatedSliceNodes = [...updatedSliceNodes, ...lastMergedNode.unmergedContent.content];
-        }
-    }
-    return {
-        updatedSliceNodes,
-        firstMergedNode,
-        lastMergedNode,
-    };
-}
-/**
- * Deletes inserted text directly, otherwise wraps it with tracked_delete mark
- *
- * This would work for general inline nodes too, but since node marks don't work properly
- * with Yjs, attributes are used instead.
- * @param node
- * @param pos
- * @param newTr
- * @param schema
- * @param deleteAttrs
- * @param from
- * @param to
- */
-function deleteTextIfInserted(node, pos, newTr, schema, deleteAttrs, from, to) {
-    const start = from ? Math.max(pos, from) : pos;
-    const nodeEnd = pos + node.nodeSize;
-    const end = to ? Math.min(nodeEnd, to) : nodeEnd;
-    if (node.marks.find((m) => m.type === schema.marks.tracked_insert)) {
-        // Math.max(pos, from) is for picking always the start of the node,
-        // not the start of the change (which might span multiple nodes).
-        // Pos can be less than from as nodesBetween iterates through all nodes starting from the top block node
-        newTr.replaceWith(start, end, Fragment.empty);
-        return start;
-    }
-    else {
-        const leftNode = newTr.doc.resolve(start).nodeBefore;
-        const leftMarks = getMergeableMarkTrackedAttrs(leftNode, deleteAttrs, schema);
-        const rightNode = newTr.doc.resolve(end).nodeAfter;
-        const rightMarks = getMergeableMarkTrackedAttrs(rightNode, deleteAttrs, schema);
-        const fromStartOfMark = start - (leftNode && leftMarks ? leftNode.nodeSize : 0);
-        const toEndOfMark = end + (rightNode && rightMarks ? rightNode.nodeSize : 0);
-        const dataTracked = addTrackIdIfDoesntExist({
-            ...leftMarks,
-            ...rightMarks,
-            ...deleteAttrs,
-        });
-        newTr.addMark(fromStartOfMark, toEndOfMark, schema.marks.tracked_delete.create({
-            dataTracked,
-        }));
-        return toEndOfMark;
-    }
-}
-/**
- * Deletes inserted block or inline node, otherwise adds `dataTracked` object with CHANGE_STATUS 'deleted'
- * @param node
- * @param pos
- * @param newTr
- * @param deleteAttrs
- */
-function deleteOrSetNodeDeleted(node, pos, newTr, deleteAttrs) {
-    const dataTracked = node.attrs.dataTracked;
-    const wasInsertedBySameUser = (dataTracked === null || dataTracked === void 0 ? void 0 : dataTracked.operation) === CHANGE_OPERATION.insert && dataTracked.userID === deleteAttrs.userID;
-    if (wasInsertedBySameUser) {
-        deleteNode(node, pos, newTr);
-    }
-    else {
-        const attrs = {
-            ...node.attrs,
-            dataTracked: addTrackIdIfDoesntExist(deleteAttrs),
-        };
-        newTr.setNodeMarkup(pos, undefined, attrs, node.marks);
-    }
-}
-/**
- * Applies deletion to the doc without actually deleting nodes that have not been inserted
- *
- * The hairiest part of this whole library which does a fair bit of magic to split the inserted slice
- * into pieces that can be inserted without deleting nodes in the doc. Basically we first split the
- * inserted slice into merged pieces _if_ the slice was open on either end. Then, we iterate over the deleted
- * range and see if the node in question was completely wrapped in the range (therefore fully deleted)
- * or only partially deleted by the slice. In that case, we merge the content from the inserted slice
- * and keep the original nodes if they do not contain insert attributes.
- *
- * It is definitely a messy function but so far this seems to have been the best approach to prevent
- * deletion of nodes with open slices. Other option would be to allow the deletions to take place but that
- * requires then inserting the deleted nodes back to the doc if their deletion should be prevented, which does
- * not seem trivial either.
- *
- * @param from start of the deleted range
- * @param to end of the deleted range
- * @param gap retained content in a ReplaceAroundStep, not deleted
- * @param startDoc doc before the deletion
- * @param newTr the new track transaction
- * @param schema ProseMirror schema
- * @param deleteAttrs attributes for the dataTracked object
- * @param insertSlice the inserted slice from ReplaceStep
- * @returns mapping adjusted by the applied operations & modified insert slice
- */
-function deleteAndMergeSplitNodes(from, to, gap, startDoc, newTr, schema, trackAttrs, insertSlice) {
-    const deleteMap = new Mapping();
-    const mergedInsertPos = undefined;
-    // No deletion applied, return default values
-    if (from === to) {
-        return {
-            deleteMap,
-            mergedInsertPos,
-            newSliceContent: insertSlice.content,
-        };
-    }
-    const { openStart, openEnd } = insertSlice;
-    const { updatedSliceNodes, firstMergedNode, lastMergedNode } = splitSliceIntoMergedParts(insertSlice, gap !== undefined);
-    const deleteAttrs = createNewDeleteAttrs(trackAttrs);
-    let mergingStartSide = true;
-    startDoc.nodesBetween(from, to, (node, pos) => {
-        const { pos: offsetPos, deleted: nodeWasDeleted } = deleteMap.mapResult(pos, 1);
-        const offsetFrom = deleteMap.map(from, -1);
-        const offsetTo = deleteMap.map(to, 1);
-        const wasWithinGap = gap && offsetPos >= deleteMap.map(gap.start, -1);
-        const nodeEnd = offsetPos + node.nodeSize;
-        let step = newTr.steps[newTr.steps.length - 1];
-        // debugger
-        // nodeEnd > offsetFrom -> delete touches this node
-        // eg (del 6 10) <p 5>|<t 6>cdf</t 9></p 10>| -> <p> nodeEnd 10 > from 6
-        //
-        // !nodeWasDeleted -> Check node wasn't already deleted by a previous deleteNode
-        // This is quite tricky to wrap your head around and I've forgotten the nitty-gritty details already.
-        // But from what I remember what it safeguards against is, when you've already deleted a node
-        // say an inserted blockquote that had all its children deleted, nodesBetween still iterates over those
-        // nodes and therefore we have to make this check to ensure they still exist in the doc.
-        //
-        if (nodeEnd > offsetFrom && !nodeWasDeleted && !wasWithinGap) {
-            // |<p>asdf</p>| -> node deleted completely
-            const nodeCompletelyDeleted = offsetPos >= offsetFrom && nodeEnd <= offsetTo;
-            // The end token deleted eg:
-            // <p 1>asdf|</p 7><p 7>bye</p 12>| + [<p>]hello</p> -> <p>asdfhello</p>
-            // (del 6 12) + (ins [<p>]hello</p> openStart 1 openEnd 0)
-            // (<p> nodeEnd 7) > (from 6) && (nodeEnd 7) <= (to 12)
-            //
-            // How about
-            // <p 1>asdf|</p 7><p 7>|bye</p 12> + [<p>]hello</p><p>good[</p>] -> <p>asdfhello</p><p>goodbye</p>
-            //
-            // What about:
-            // <p 1>asdf|</p 7><p 7 op="inserted">|bye</p 12> + empty -> <p>asdfbye</p>
-            const endTokenDeleted = nodeEnd <= offsetTo;
-            // The start token deleted eg:
-            // |<p1 0>hey</p 6><p2 6>|asdf</p 12> + <p3>hello [</p>] -> <p3>hello asdf</p2>
-            // (del 0 7) + (ins <p>hello [</p>] openStart 0 openEnd 1)
-            // (<p1> pos 0) >= (from 0) && (nodeEnd 6) - 1 > (to 7) == false???
-            // (<p2> pos 6) >= (from 0) && (nodeEnd 12) - 1 > (to 7) == true
-            //
-            const startTokenDeleted = offsetPos >= offsetFrom; // && nodeEnd - 1 > offsetTo
-            if (node.isText ||
-                (!endTokenDeleted && startTokenDeleted) ||
-                (endTokenDeleted && !startTokenDeleted)) {
-                // Since we don't know which side to merge with wholly deleted TextNodes, we use this boolean to remember
-                // whether we have entered the endSide of the mergeable blockNodes. Also applies for partial TextNodes
-                // (which we could determine without this).
-                if (!endTokenDeleted && startTokenDeleted) {
-                    mergingStartSide = false;
-                }
-                // Depth is often 1 when merging paragraphs or 2 for fully open blockquotes.
-                // Incase of merging text within a ReplaceAroundStep the depth might be 1
-                const depth = newTr.doc.resolve(offsetPos).depth;
-                const mergeContent = mergingStartSide
-                    ? firstMergedNode === null || firstMergedNode === void 0 ? void 0 : firstMergedNode.mergedNodeContent
-                    : lastMergedNode === null || lastMergedNode === void 0 ? void 0 : lastMergedNode.mergedNodeContent;
-                // Insert inside a merged node only if the slice was open (openStart > 0) and there exists mergedNodeContent.
-                // Then we only have to ensure the depth is at the right level, so say a fully open blockquote insert will
-                // be merged at the lowest, paragraph level, instead of blockquote level.
-                const mergeStartNode = endTokenDeleted && openStart > 0 && depth === openStart && mergeContent !== undefined;
-                // Same as above, merge nodes manually if there exists an open slice with mergeable content.
-                // Compared to deleting an end token however, the merged block node is set as deleted. This is due to
-                // ProseMirror node semantics as start tokens are considered to contain the actual node itself.
-                const mergeEndNode = startTokenDeleted && openEnd > 0 && depth === openEnd && mergeContent !== undefined;
-                if (mergeStartNode || mergeEndNode) {
-                    // The default insert position for block nodes is either the start of the merged content or the end.
-                    // Incase text was merged, this must be updated as the start or end of the node doesn't map to the
-                    // actual position of the merge. Currently the inserted content is inserted at the start or end
-                    // of the merged content, TODO reverse the start/end when end/start token?
-                    let insertPos = mergeStartNode ? nodeEnd - openStart : offsetPos + openEnd;
-                    if (node.isText) {
-                        // When merging text we must delete text in the same go as well, as the from/to boundary goes through
-                        // the text node.
-                        insertPos = deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
-                        deleteMap.appendMap(newTr.steps[newTr.steps.length - 1].getMap());
-                        step = newTr.steps[newTr.steps.length - 1];
-                    }
-                    // Just as a fun fact that I found out while debugging this. Inserting text at paragraph position wraps
-                    // it into a new paragraph(!). So that's why you always offset your positions to insert it _inside_
-                    // the paragraph.
-                    if (mergeContent.size !== 0) {
-                        newTr.insert(insertPos, setFragmentAsInserted(mergeContent, createNewInsertAttrs(trackAttrs), schema));
-                    }
-                    // Okay this is a bit ridiculous but it's used to adjust the insert pos when track changes prevents deletions
-                    // of merged nodes & content, as just using mapped toA in that case isn't the same.
-                    // The calculation is a bit mysterious, I admit.
-                    // TODO delete/fix this?
-                    // 'should prevent replacing of blockquotes and break the slice into parts instead' test needs this
-                    // if (node.isText) {
-                    //   mergedInsertPos = offsetPos - openEnd
-                    // }
-                }
-                else if (node.isText) {
-                    // Text deletion is handled even when the deletion doesn't completely wrap the text node
-                    // (which is basically the case most of the time)
-                    deleteTextIfInserted(node, offsetPos, newTr, schema, deleteAttrs, offsetFrom, offsetTo);
-                }
-                else ;
-            }
-            else if (nodeCompletelyDeleted) {
-                deleteOrSetNodeDeleted(node, offsetPos, newTr, deleteAttrs);
-            }
-        }
-        const newestStep = newTr.steps[newTr.steps.length - 1];
-        if (step !== newestStep) {
-            deleteMap.appendMap(newestStep.getMap());
-        }
-    });
-    return {
-        deleteMap,
-        mergedInsertPos,
-        newSliceContent: updatedSliceNodes
-            ? Fragment.fromArray(updatedSliceNodes)
-            : insertSlice.content,
-    };
-}
-
-/**
- * Merges tracked marks between text nodes at a position
- *
- * Will work for any nodes that use tracked_insert or tracked_delete marks which may not be preferrable
- * if used for block nodes (since we possibly want to show the individual changed nodes).
- * Merging is done based on the userID, operation type and status.
- * @param pos
- * @param doc
- * @param newTr
- * @param schema
- */
-function mergeTrackedMarks(pos, doc, newTr, schema) {
-    const resolved = doc.resolve(pos);
-    const { nodeAfter, nodeBefore } = resolved;
-    const leftMark = nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
-    const rightMark = nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.marks.filter((m) => m.type === schema.marks.tracked_insert || m.type === schema.marks.tracked_delete)[0];
-    if (!nodeAfter || !nodeBefore || !leftMark || !rightMark || leftMark.type !== rightMark.type) {
-        return;
-    }
-    const leftAttrs = leftMark.attrs;
-    const rightAttrs = rightMark.attrs;
-    if (!shouldMergeTrackedAttributes(leftAttrs.dataTracked, rightAttrs.dataTracked)) {
-        return;
-    }
-    const newAttrs = {
-        ...leftAttrs,
-        createdAt: Math.max(leftAttrs.createdAt || 0, rightAttrs.createdAt || 0) || Date.now(),
-    };
-    const fromStartOfMark = pos - nodeBefore.nodeSize;
-    const toEndOfMark = pos + nodeAfter.nodeSize;
-    newTr.addMark(fromStartOfMark, toEndOfMark, leftMark.type.create(newAttrs));
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function trackReplaceAroundStep(step, oldState, newTr, attrs) {
-    log.info('###### ReplaceAroundStep ######');
-    // @ts-ignore
-    const { from, to, gapFrom, gapTo, insert, slice, structure, } = step;
-    if (from === gapFrom && to === gapTo) {
-        log.info('WRAPPED IN SOMETHING');
-    }
-    else if (!slice.size || slice.content.content.length === 2) {
-        log.info('UNWRAPPED FROM SOMETHING');
-    }
-    else if (slice.size === 2 && gapFrom - from === 1 && to - gapTo === 1) {
-        log.info('REPLACED WRAPPING');
-    }
-    else {
-        log.info('????');
-    }
-    if (gapFrom - from > to - gapTo) {
-        log.info('DELETED BEFORE GAP FROM');
-    }
-    else if (gapFrom - from < to - gapTo) {
-        log.info('DELETED AFTER GAP TO');
-    }
-    else {
-        log.info('EQUAL REPLACE BETWEEN GAPS');
-    }
-    // Invert the transaction step to prevent it from actually deleting or inserting anything
-    const newStep = step.invert(oldState.doc);
-    const stepResult = newTr.maybeStep(newStep);
-    if (stepResult.failed) {
-        log.error(`inverting ReplaceAroundStep failed: "${stepResult.failed}"`, newStep);
-        return;
-    }
-    const gap = oldState.doc.slice(gapFrom, gapTo);
-    log.info('RETAINED GAP CONTENT', gap);
-    // First apply the deleted range and update the insert slice to not include content that was deleted,
-    // eg partial nodes in an open-ended slice
-    const { deleteMap, newSliceContent } = deleteAndMergeSplitNodes(from, to, { start: gapFrom, end: gapTo }, newTr.doc, newTr, oldState.schema, attrs, slice);
-    log.info('TR: new steps after applying delete', [...newTr.steps]);
-    // We only want to insert when there something inside the gap (actually would this be always true?)
-    // or insert slice wasn't just start/end tokens (which we already merged inside deleteAndMergeSplitBlockNodes)
-    if (gap.size > 0 || (!structure && newSliceContent.size > 0)) {
-        log.info('newSliceContent', newSliceContent);
-        // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
-        // the sides should be equal. TODO can they be other than 0?
-        const openStart = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openStart;
-        const openEnd = slice.openStart !== slice.openEnd || newSliceContent.size === 0 ? 0 : slice.openEnd;
-        let insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
-        if (gap.size > 0) {
-            log.info('insertedSlice before inserted gap', insertedSlice);
-            insertedSlice = insertedSlice.insertAt(insertedSlice.size === 0 ? 0 : insert, gap.content);
-            log.info('insertedSlice after inserted gap', insertedSlice);
-        }
-        const newStep = new ReplaceStep(deleteMap.map(gapFrom), deleteMap.map(gapTo), insertedSlice, false);
-        const stepResult = newTr.maybeStep(newStep);
-        if (stepResult.failed) {
-            log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
-            return;
-        }
-        log.info('new steps after applying insert', [...newTr.steps]);
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
-    }
-    else {
-        // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-        mergeTrackedMarks(deleteMap.map(gapFrom), newTr.doc, newTr, oldState.schema);
-        mergeTrackedMarks(deleteMap.map(gapTo), newTr.doc, newTr, oldState.schema);
-    }
-}
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-function trackReplaceStep(step, oldState, newTr, attrs) {
-    log.info('###### ReplaceStep ######');
-    let selectionPos = 0;
-    step.getMap().forEach((fromA, toA, fromB, toB) => {
-        log.info(`changed ranges: ${fromA} ${toA} ${fromB} ${toB}`);
-        const { slice } = step;
-        // Invert the transaction step to prevent it from actually deleting or inserting anything
-        const newStep = step.invert(oldState.doc);
-        const stepResult = newTr.maybeStep(newStep);
-        if (stepResult.failed) {
-            log.error(`invert ReplaceStep failed: "${stepResult.failed}"`, newStep);
-            return;
-        }
-        // First apply the deleted range and update the insert slice to not include content that was deleted,
-        // eg partial nodes in an open-ended slice
-        const { deleteMap, mergedInsertPos, newSliceContent } = deleteAndMergeSplitNodes(fromA, toA, undefined, oldState.doc, newTr, oldState.schema, attrs, slice);
-        log.info('TR: new steps after applying delete', [...newTr.steps]);
-        const adjustedInsertPos = mergedInsertPos !== null && mergedInsertPos !== void 0 ? mergedInsertPos : deleteMap.map(toA);
-        if (newSliceContent.size > 0) {
-            log.info('newSliceContent', newSliceContent);
-            // Since deleteAndMergeSplitBlockNodes modified the slice to not to contain any merged nodes,
-            // the sides should be equal. TODO can they be other than 0?
-            const openStart = slice.openStart !== slice.openEnd ? 0 : slice.openStart;
-            const openEnd = slice.openStart !== slice.openEnd ? 0 : slice.openEnd;
-            const insertedSlice = new Slice(setFragmentAsInserted(newSliceContent, createNewInsertAttrs(attrs), oldState.schema), openStart, openEnd);
-            const newStep = new ReplaceStep(adjustedInsertPos, adjustedInsertPos, insertedSlice);
-            const stepResult = newTr.maybeStep(newStep);
-            if (stepResult.failed) {
-                log.error(`insert ReplaceStep failed: "${stepResult.failed}"`, newStep);
-                return;
-            }
-            log.info('new steps after applying insert', [...newTr.steps]);
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            mergeTrackedMarks(adjustedInsertPos + insertedSlice.size, newTr.doc, newTr, oldState.schema);
-            selectionPos = adjustedInsertPos + insertedSlice.size;
-        }
-        else {
-            // Incase only deletion was applied, check whether tracked marks around deleted content can be merged
-            mergeTrackedMarks(adjustedInsertPos, newTr.doc, newTr, oldState.schema);
-            selectionPos = fromA;
-        }
-    });
-    return selectionPos;
-}
-
-/**
- * Retrieves a static property from Selection class instead of having to use direct imports
- *
- * This skips the direct dependency to prosemirror-state where multiple versions might cause conflicts
- * as the created instances might belong to different prosemirror-state import than one used in the editor.
- * @param sel
- * @returns
- */
-const getSelectionStaticConstructor = (sel) => Object.getPrototypeOf(sel).constructor;
-/**
- * Inverts transactions to wrap their contents/operations with track data instead
- *
- * The main function of track changes that holds the most complex parts of this whole library.
- * Takes in as arguments the data from appendTransaction to reapply it with the track marks/attributes.
- * We could prevent the initial transaction from being applied all together but since invert works just
- * as well and we can use the intermediate doc for checking which nodes are changed, it's not prevented.
- *
- *
- * @param tr Original transaction
- * @param oldState State before transaction
- * @param newTr Transaction created from the new editor state
- * @param userID User id
- * @returns newTr that inverts the initial tr and applies track attributes/marks
- */
-function trackTransaction(tr, oldState, newTr, userID) {
-    var _a;
-    const emptyAttrs = {
-        userID,
-        createdAt: tr.time,
-        status: CHANGE_STATUS.pending,
-    };
-    // Must use constructor.name instead of instanceof as aliasing prosemirror-state is a lot more
-    // difficult than prosemirror-transform
-    const wasNodeSelection = tr.selection.constructor.name === 'NodeSelection';
-    let iters = 0;
-    log.info('ORIGINAL transaction', tr);
-    tr.steps.forEach((step) => {
-        log.info('transaction step', step);
-        iters += 1;
-        if (iters > 20) {
-            console.error('@manuscripts/track-changes-plugin: Possible infinite loop in iterating tr.steps, tracking skipped!\n' +
-                'This is probably an error with the library, please report back to maintainers with a reproduction if possible', newTr);
-            return;
-        }
-        else if (!(step instanceof ReplaceStep) && step.constructor.name === 'ReplaceStep') {
-            console.error('@manuscripts/track-changes-plugin: Multiple prosemirror-transform packages imported, alias/dedupe them ' +
-                'or instanceof checks fail as well as creating new steps');
-            return;
-        }
-        else if (step instanceof ReplaceStep) {
-            const selectionPos = trackReplaceStep(step, oldState, newTr, emptyAttrs);
-            if (!wasNodeSelection) {
-                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) {
-            trackReplaceAroundStep(step, oldState, newTr, emptyAttrs);
-            // } else if (step instanceof AddMarkStep) {
-            // } else if (step instanceof RemoveMarkStep) {
-        }
-        // TODO: here we could check whether adjacent inserts & deletes cancel each other out.
-        // However, this should not be done by diffing and only matching node or char by char instead since
-        // it's A easier and B more intuitive to user.
-        // 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 that need it to activate the selector pop-up
-    if (wasNodeSelection) {
-        const mappedPos = newTr.mapping.map(tr.selection.from);
-        const resPos = newTr.doc.resolve(mappedPos);
-        const nodePos = mappedPos - (((_a = resPos.nodeBefore) === null || _a === void 0 ? void 0 : _a.nodeSize) || 0);
-        const sel = getSelectionStaticConstructor(tr.selection);
-        newTr.setSelection(sel.create(newTr.doc, nodePos));
-    }
-    log.info('NEW transaction', newTr);
-    return newTr;
-}
-
-var TrackChangesStatus;
-(function (TrackChangesStatus) {
-    TrackChangesStatus["enabled"] = "enabled";
-    TrackChangesStatus["viewSnapshots"] = "view-snapshots";
-    TrackChangesStatus["disabled"] = "disabled";
-})(TrackChangesStatus || (TrackChangesStatus = {}));
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const trackChangesPluginKey = new PluginKey('track-changes');
-// TODO remove
-const infiniteLoopCounter = {
-    start: 0,
-    iters: 0,
-};
-/**
- * The ProseMirror plugin needed to enable track-changes.
- *
- * Accepts an empty options object as an argument but note that this uses 'anonymous:Anonymous' as the default userID.
- * @param opts
- */
-const trackChangesPlugin = (opts = { userID: 'anonymous:Anonymous' }) => {
-    const { userID, debug, skipTrsWithMetas = [] } = opts;
-    let editorView;
-    if (debug) {
-        enableDebug(true);
-    }
-    return new Plugin({
-        key: trackChangesPluginKey,
-        props: {
-            editable(state) {
-                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: findChanges(newState),
-                    };
-                }
-                else if (pluginState.status === TrackChangesStatus.disabled) {
-                    return { ...pluginState, changeSet: new ChangeSet() };
-                }
-                let { changeSet, ...rest } = pluginState;
-                const updatedChangeIds = getAction(tr, TrackChangesAction.updateChanges);
-                if (updatedChangeIds || getAction(tr, TrackChangesAction.refreshChanges)) {
-                    changeSet = findChanges(newState);
-                }
-                return {
-                    changeSet,
-                    ...rest,
-                };
-            },
-        },
-        view(p) {
-            editorView = p;
-            return {
-                update: undefined,
-                destroy: undefined,
-            };
-        },
-        appendTransaction(trs, oldState, newState) {
-            const pluginState = trackChangesPluginKey.getState(newState);
-            if (!pluginState ||
-                pluginState.status === TrackChangesStatus.disabled ||
-                !(editorView === null || editorView === void 0 ? void 0 : editorView.editable)) {
-                return null;
-            }
-            if (infiniteLoopCounter.start < Date.now() - 10000) {
-                infiniteLoopCounter.start = Date.now();
-                infiniteLoopCounter.iters = 0;
-            }
-            if (infiniteLoopCounter.iters >= 100) {
-                console.error('Detected probable infinite loop in track changes!');
-                return null;
-            }
-            const { userID, changeSet } = pluginState;
-            let createdTr = newState.tr, docChanged = false;
-            log.info('TRS', trs);
-            trs.forEach((tr) => {
-                const wasAppended = tr.getMeta('appendedTransaction');
-                const skipMetaUsed = skipTrsWithMetas.some((m) => tr.getMeta(m) || (wasAppended === null || wasAppended === void 0 ? void 0 : wasAppended.getMeta(m)));
-                const skipTrackUsed = getAction(tr, TrackChangesAction.skipTrack) ||
-                    (wasAppended && getAction(wasAppended, TrackChangesAction.skipTrack));
-                if (tr.docChanged && !skipMetaUsed && !skipTrackUsed && !tr.getMeta('history$')) {
-                    createdTr = trackTransaction(tr, oldState, createdTr, userID);
-                    infiniteLoopCounter.iters += 1;
-                }
-                docChanged = docChanged || tr.docChanged;
-                const setChangeStatuses = getAction(tr, TrackChangesAction.setChangeStatuses);
-                if (setChangeStatuses) {
-                    const { status, ids } = setChangeStatuses;
-                    ids.forEach((changeId) => {
-                        const change = changeSet === null || changeSet === void 0 ? void 0 : changeSet.get(changeId);
-                        if (change) {
-                            createdTr = updateChangeAttrs(createdTr, change, { status }, oldState.schema);
-                            setAction(createdTr, TrackChangesAction.updateChanges, [change.id]);
-                        }
-                    });
-                }
-                else if (getAction(tr, TrackChangesAction.applyAndRemoveChanges)) {
-                    const mapping = applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.nodeChanges);
-                    applyAcceptedRejectedChanges(createdTr, oldState.schema, changeSet.textChanges, mapping);
-                    setAction(createdTr, TrackChangesAction.refreshChanges, true);
-                }
-            });
-            const changed = pluginState.changeSet.hasInconsistentData &&
-                fixInconsistentChanges(pluginState.changeSet, userID, createdTr, oldState.schema);
-            if (changed) {
-                log.warn('had to fix inconsistent changes in', createdTr);
-            }
-            if (docChanged || createdTr.docChanged || changed) {
-                createdTr.setMeta('origin', trackChangesPluginKey);
-                return setAction(createdTr, TrackChangesAction.refreshChanges, true);
-            }
-            return null;
-        },
-    });
-};
-
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Sets track-changes plugin's status to any of: 'enabled' 'disabled' 'viewSnapshots'. Passing undefined will
- * set 'enabled' status to 'disabled' and 'disabled' | 'viewSnapshots' status to 'enabled'.
- *
- * In disabled view, the plugin is completely inactive and changes are not updated anymore.
- * In viewSnasphots state, editor is set uneditable by editable prop that allows only selection changes
- * to the document.
- * @param status
- */
-const setTrackingStatus = (status) => (state, dispatch) => {
-    var _a;
-    const currentStatus = (_a = trackChangesPluginKey.getState(state)) === null || _a === void 0 ? void 0 : _a.status;
-    if (currentStatus) {
-        let newStatus = status;
-        if (newStatus === undefined) {
-            newStatus =
-                currentStatus === TrackChangesStatus.enabled
-                    ? TrackChangesStatus.disabled
-                    : TrackChangesStatus.enabled;
-        }
-        dispatch && dispatch(setAction(state.tr, TrackChangesAction.setPluginStatus, newStatus));
-        return true;
-    }
-    return false;
-};
-/**
- * Appends a transaction to set change attributes/marks' statuses to any of: 'pending' 'accepted' 'rejected'.
- * @param status
- * @param ids
- */
-const setChangeStatuses = (status, ids) => (state, dispatch) => {
-    dispatch &&
-        dispatch(setAction(state.tr, TrackChangesAction.setChangeStatuses, {
-            status,
-            ids,
-        }));
-    return true;
-};
-/**
- * Sets track-changes plugin's userID.
- * @param userID
- */
-const setUserID = (userID) => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, TrackChangesAction.setUserID, userID));
-    return true;
-};
-/**
- * Appends a transaction that applies all 'accepted' and 'rejected' changes to the document.
- */
-const applyAndRemoveChanges = () => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, TrackChangesAction.applyAndRemoveChanges, true));
-    return true;
-};
-/**
- * Runs `findChanges` to iterate over the document to collect changes into a new ChangeSet.
- */
-const refreshChanges = () => (state, dispatch) => {
-    dispatch && dispatch(setAction(state.tr, TrackChangesAction.updateChanges, []));
-    return true;
-};
-/**
- * Adds track attributes for a block node. For testing puroses
- */
-const setParagraphTestAttribute = (val = 'changed') => (state, dispatch) => {
-    var _a;
-    const cursor = state.selection.head;
-    const blockNodePos = state.doc.resolve(cursor).start(1) - 1;
-    if (((_a = state.doc.resolve(blockNodePos).nodeAfter) === null || _a === void 0 ? void 0 : _a.type) === state.schema.nodes.paragraph &&
-        dispatch) {
-        dispatch(state.tr.setNodeMarkup(blockNodePos, undefined, {
-            testAttribute: val,
-        }));
-        return true;
-    }
-    return false;
-};
-
-var commands = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  setTrackingStatus: setTrackingStatus,
-  setChangeStatuses: setChangeStatuses,
-  setUserID: setUserID,
-  applyAndRemoveChanges: applyAndRemoveChanges,
-  refreshChanges: refreshChanges,
-  setParagraphTestAttribute: setParagraphTestAttribute
-});
-
-export { CHANGE_OPERATION, CHANGE_STATUS, ChangeSet, TrackChangesAction, TrackChangesStatus, enableDebug, getAction, setAction, trackChangesPlugin, trackChangesPluginKey, commands as trackCommands };