@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/feature-libraries/sequence-field/rebase.js

@@ -0,0 +1,619 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebase = void 0;
+const core_utils_1 = require("@fluidframework/core-utils");
+const util_1 = require("../../util");
+const modular_schema_1 = require("../modular-schema");
+const utils_1 = require("./utils");
+const types_1 = require("./types");
+const markListFactory_1 = require("./markListFactory");
+const moveEffectTable_1 = require("./moveEffectTable");
+const markQueue_1 = require("./markQueue");
+/**
+ * Rebases `change` over `base` assuming they both apply to the same initial state.
+ * @param change - The changeset to rebase.
+ * @param base - The changeset to rebase over.
+ * @returns A changeset that performs the changes in `change` but does so assuming `base` has been applied first.
+ *
+ * WARNING! This implementation is incomplete:
+ * - Some marks that affect existing content are removed instead of marked as conflicted when rebased over the deletion
+ * of that content. This prevents us from then reinstating the mark when rebasing over the revive.
+ * - Tombs are not added when rebasing an insert over a gap that is immediately left of deleted content.
+ * This prevents us from being able to accurately track the position of the insert.
+ * - Tiebreak ordering is not respected.
+ * - Support for moves is not implemented.
+ * - Support for slices is not implemented.
+ */
+function rebase(change, base, rebaseChild, genId, manager, revisionMetadata, nodeExistenceState = modular_schema_1.NodeExistenceState.Alive) {
+    return rebaseMarkList(change, base.change, base.revision, revisionMetadata, rebaseChild, genId, manager, nodeExistenceState);
+}
+exports.rebase = rebase;
+function rebaseMarkList(currMarkList, baseMarkList, baseRevision, metadata, rebaseChild, genId, moveEffects, nodeExistenceState) {
+    const rebasedMarks = [];
+    const queue = new RebaseQueue(baseRevision, baseMarkList, currMarkList, metadata, genId, moveEffects);
+    // Each mark with empty input cells in `currMarkList` should have a lineage event added for all adjacent detaches in the base changeset.
+    // At the time we process an attach we don't know about detaches of later nodes,
+    // so we record marks which should have their lineage updated if we encounter a detach.
+    const rebasedCellBlocks = [];
+    // For each revision, stores a list of IDs of detaches encountered in the base changeset which are adjacent to the current position.
+    const detachBlocks = new Map();
+    while (!queue.isEmpty()) {
+        const { baseMark, newMark: currMark } = queue.pop();
+        const rebasedMark = rebaseMark(currMark, baseMark, baseRevision, metadata, rebaseChild, moveEffects, nodeExistenceState);
+        if ((0, utils_1.markEmptiesCells)(baseMark) || (0, utils_1.isImpactfulCellRename)(baseMark, baseRevision, metadata)) {
+            // Note that we want the revision in the detach ID to be the actual revision, not the intention.
+            // We don't pass a `RevisionMetadataSource` to `getOutputCellId` so that we get the true revision.
+            const detachId = (0, utils_1.getOutputCellId)(baseMark, baseRevision, undefined);
+            (0, core_utils_1.assert)(detachId !== undefined, 0x816 /* Mark which empties cells should have a detach ID */);
+            (0, core_utils_1.assert)(detachId.revision !== undefined, 0x74a /* Detach ID should have a revision */);
+            const detachBlock = (0, util_1.getOrAddEmptyToMap)(detachBlocks, detachId.revision);
+            addIdRange(detachBlock, {
+                id: detachId.localId,
+                count: baseMark.count,
+            });
+            addLineageToRecipients(rebasedCellBlocks, detachId.revision, detachId.localId, baseMark.count, metadata);
+            (0, core_utils_1.assert)((0, utils_1.areInputCellsEmpty)(rebasedMark) && rebasedMark.cellId.revision !== undefined, 0x817 /* Mark should have empty input cells after rebasing over a cell-emptying mark */);
+            // A re-detach sports a cell ID with the adjacent cells from the original detach.
+            // Marks that are rebased over such a re-detach will adopt this cell ID as-is and do not need to have the
+            // adjacent cells be updated. Moreover, the base changeset may not have all the detaches from the original
+            // detach revision, so using such re-detach marks to compile the list of adjacent cells would run the risk
+            // of ending up with incomplete adjacent cell information in the rebased mark.
+            if (!isRedetach(baseMark)) {
+                // BUG#6604:
+                // We track blocks of adjacent cells for rollbacks separately from that of the original revision
+                // that they are a rollback of, but all rebased marks use the original revision in their `CellId`.
+                // This means we assign adjacent cells information for the rollback to a `CellId` that advertises
+                // itself as being about the original revision.
+                // This could lead to a situation where we try to compare two cells and fail to order them correctly
+                // because one sports adjacent cells information for the original revision and the other sports
+                // adjacent cells information for the rollback.
+                setMarkAdjacentCells(rebasedMark, detachBlock);
+            }
+        }
+        if ((0, utils_1.areInputCellsEmpty)(rebasedMark)) {
+            handleLineage(rebasedMark.cellId, detachBlocks, metadata);
+        }
+        rebasedMarks.push(rebasedMark);
+        updateLineageState(rebasedCellBlocks, detachBlocks, baseMark, baseRevision, rebasedMark, metadata);
+    }
+    return mergeMarkList(rebasedMarks);
+}
+function mergeMarkList(marks) {
+    const factory = new markListFactory_1.MarkListFactory();
+    for (const mark of marks) {
+        factory.push(mark);
+    }
+    return factory.list;
+}
+function isRedetach(effect) {
+    switch (effect.type) {
+        case "Delete":
+        case "MoveOut":
+            return effect.redetachId !== undefined;
+        case "AttachAndDetach":
+            return isRedetach(effect.detach);
+        default:
+            return false;
+    }
+}
+/**
+ * Generates a NoOp mark that targets the same cells as the input mark.
+ * @param mark - The mark the NoOp should target.
+ * @param revision - The revision, if available.
+ * @returns A NoOp mark that targets the same cells as the input mark.
+ */
+function generateNoOpWithCellId(mark, revision, metadata) {
+    const length = mark.count;
+    const cellId = (0, utils_1.getInputCellId)(mark, revision, metadata);
+    return cellId === undefined ? { count: length } : { count: length, cellId };
+}
+class RebaseQueue {
+    constructor(baseRevision, baseMarks, newMarks, metadata, genId, moveEffects) {
+        this.metadata = metadata;
+        this.moveEffects = moveEffects;
+        this.baseMarks = new markQueue_1.MarkQueue(baseMarks, baseRevision, moveEffects, false, genId);
+        this.newMarks = new markQueue_1.MarkQueue(newMarks, undefined, moveEffects, false, genId);
+    }
+    isEmpty() {
+        return this.baseMarks.isEmpty() && this.newMarks.isEmpty();
+    }
+    pop() {
+        const baseMark = this.baseMarks.peek();
+        const newMark = this.newMarks.peek();
+        (0, core_utils_1.assert)(!(baseMark === undefined && newMark === undefined), 0x722 /* Cannot pop from empty queue */);
+        if (baseMark === undefined) {
+            const dequeuedNewMark = this.newMarks.dequeue();
+            return {
+                baseMark: generateNoOpWithCellId(dequeuedNewMark, undefined, this.metadata),
+                newMark: dequeuedNewMark,
+            };
+        }
+        else if (newMark === undefined) {
+            return this.dequeueBase();
+        }
+        else if ((0, utils_1.areInputCellsEmpty)(baseMark) && (0, utils_1.areInputCellsEmpty)(newMark)) {
+            const cmp = compareCellPositions(this.baseMarks.revision, baseMark, newMark, this.metadata);
+            if (cmp < 0) {
+                return this.dequeueBase(-cmp);
+            }
+            else if (cmp > 0) {
+                const dequeuedNewMark = this.newMarks.dequeueUpTo(cmp);
+                return {
+                    newMark: dequeuedNewMark,
+                    baseMark: generateNoOpWithCellId(dequeuedNewMark, undefined, this.metadata),
+                };
+            }
+            else {
+                return this.dequeueBoth();
+            }
+        }
+        else if ((0, utils_1.areInputCellsEmpty)(newMark)) {
+            return this.dequeueNew();
+        }
+        else if ((0, utils_1.areInputCellsEmpty)(baseMark)) {
+            return this.dequeueBase();
+        }
+        else {
+            return this.dequeueBoth();
+        }
+    }
+    dequeueBase(length) {
+        const baseMark = length !== undefined ? this.baseMarks.dequeueUpTo(length) : this.baseMarks.dequeue();
+        const movedMark = getMovedMarkFromBaseMark(this.moveEffects, baseMark, this.baseMarks.revision);
+        const newMark = movedMark !== undefined
+            ? withCellId(movedMark, (0, utils_1.getInputCellId)(baseMark, this.baseMarks.revision, undefined))
+            : generateNoOpWithCellId(baseMark, this.baseMarks.revision, this.metadata);
+        return {
+            baseMark,
+            newMark,
+        };
+    }
+    dequeueNew() {
+        const newMark = this.newMarks.dequeue();
+        return { newMark, baseMark: generateNoOpWithCellId(newMark, undefined, this.metadata) };
+    }
+    dequeueBoth() {
+        const baseMark = this.baseMarks.peek();
+        const newMark = this.newMarks.peek();
+        (0, core_utils_1.assert)(baseMark !== undefined && newMark !== undefined, 0x69c /* Cannot dequeue both unless both mark queues are non-empty */);
+        const length = Math.min(newMark.count, baseMark.count);
+        const sizedBaseMark = this.baseMarks.dequeueUpTo(length);
+        const sizedNewMark = this.newMarks.dequeueUpTo(length);
+        const movedMark = getMovedMarkFromBaseMark(this.moveEffects, sizedBaseMark, this.baseMarks.revision);
+        return {
+            baseMark: sizedBaseMark,
+            newMark: movedMark === undefined ? sizedNewMark : fuseMarks(sizedNewMark, movedMark),
+        };
+    }
+}
+function fuseMarks(newMark, movedMark) {
+    if ((0, moveEffectTable_1.isMoveIn)(newMark) && (0, moveEffectTable_1.isMoveOut)(movedMark)) {
+        const fusedMark = {
+            type: "Insert",
+            count: newMark.count,
+            id: newMark.id,
+        };
+        if (movedMark.cellId !== undefined) {
+            fusedMark.cellId = (0, utils_1.cloneCellId)(movedMark.cellId);
+        }
+        if (movedMark.revision !== undefined) {
+            fusedMark.revision = movedMark.revision;
+        }
+        if (movedMark.changes !== undefined) {
+            fusedMark.changes = movedMark.changes;
+        }
+        return fusedMark;
+    }
+    // The only case we expect for two marks from the same changeset to overlap is when one is a move source
+    // and the other is a move destination bringing the nodes back into place.
+    (0, core_utils_1.assert)(false, 0x818 /* Unexpected combination of moved and new marks */);
+}
+function rebaseMark(currMark, baseMark, baseRevision, metadata, rebaseChild, moveEffects, nodeExistenceState) {
+    const rebasedMark = rebaseNodeChange((0, utils_1.cloneMark)(currMark), baseMark, rebaseChild);
+    return rebaseMarkIgnoreChild(rebasedMark, baseMark, baseRevision, metadata, moveEffects, nodeExistenceState);
+}
+function rebaseMarkIgnoreChild(currMark, baseMark, baseRevision, metadata, moveEffects, nodeExistenceState) {
+    let rebasedMark;
+    if ((0, utils_1.isDetach)(baseMark)) {
+        if (baseMark.cellId !== undefined) {
+            // Detaches on empty cells have an implicit revive effect.
+            delete currMark.cellId;
+        }
+        (0, core_utils_1.assert)(!(0, utils_1.isNewAttach)(currMark), 0x69d /* A new attach should not be rebased over its cell being emptied */);
+        const baseCellId = (0, utils_1.getDetachOutputId)(baseMark, baseRevision, metadata);
+        if ((0, moveEffectTable_1.isMoveOut)(baseMark)) {
+            (0, core_utils_1.assert)((0, moveEffectTable_1.isMoveMark)(baseMark), 0x6f0 /* Only move marks have move IDs */);
+            (0, core_utils_1.assert)(!(0, utils_1.isNewAttach)(currMark), 0x819 /* New attaches should not be rebased over moves */);
+            const { remains, follows } = separateEffectsForMove(currMark);
+            if (follows !== undefined || currMark.changes !== undefined) {
+                sendMarkToDest((0, utils_1.withNodeChange)({ ...follows, count: baseMark.count }, currMark.changes), moveEffects, (0, utils_1.getEndpoint)(baseMark, baseRevision), baseMark.count);
+            }
+            rebasedMark = { ...(remains ?? {}), count: baseMark.count };
+        }
+        else {
+            rebasedMark = currMark;
+        }
+        rebasedMark = makeDetachedMark(rebasedMark, (0, utils_1.cloneCellId)(baseCellId));
+    }
+    else if ((0, utils_1.markFillsCells)(baseMark)) {
+        rebasedMark = (0, utils_1.isAttachAndDetachEffect)(currMark)
+            ? (0, utils_1.withNodeChange)({ ...currMark.detach, count: currMark.count }, currMark.changes)
+            : withCellId(currMark, undefined);
+    }
+    else if ((0, utils_1.isAttachAndDetachEffect)(baseMark)) {
+        (0, core_utils_1.assert)(baseMark.cellId !== undefined, 0x81a /* AttachAndDetach mark should target an empty cell */);
+        const halfRebasedMark = rebaseMarkIgnoreChild(currMark, { ...baseMark.attach, cellId: (0, utils_1.cloneCellId)(baseMark.cellId), count: baseMark.count }, baseRevision, metadata, moveEffects, nodeExistenceState);
+        rebasedMark = rebaseMarkIgnoreChild(halfRebasedMark, { ...baseMark.detach, count: baseMark.count }, baseRevision, metadata, moveEffects, nodeExistenceState);
+    }
+    else {
+        rebasedMark = currMark;
+    }
+    return rebasedMark;
+}
+/**
+ * @returns A pair of marks that represent the effects which should remain in place in the face of concurrent move,
+ * and the effects that should be sent to the move destination.
+ */
+function separateEffectsForMove(mark) {
+    const type = mark.type;
+    switch (type) {
+        case "Delete":
+        case "MoveOut":
+            return { follows: mark };
+        case "AttachAndDetach":
+            return { follows: mark.detach, remains: mark.attach };
+        case "MoveIn":
+            return { remains: mark };
+        case types_1.NoopMarkType:
+            return {};
+        case "Insert": {
+            const follows = {
+                type: "MoveOut",
+                id: mark.id,
+            };
+            const remains = {
+                type: "MoveIn",
+                id: mark.id,
+            };
+            if (mark.revision !== undefined) {
+                follows.revision = mark.revision;
+                remains.revision = mark.revision;
+            }
+            return { remains, follows };
+        }
+        default:
+            (0, core_utils_1.unreachableCase)(type);
+    }
+}
+// TODO: Reduce the duplication between this and other MoveEffect helpers
+function sendMarkToDest(mark, moveEffects, { revision, localId: id }, count) {
+    const effect = (0, moveEffectTable_1.getMoveEffect)(moveEffects, modular_schema_1.CrossFieldTarget.Destination, revision, id, count, false);
+    if (effect.length < count) {
+        const [mark1, mark2] = (0, utils_1.splitMark)(mark, effect.length);
+        const newEffect = effect.value !== undefined
+            ? { ...effect.value, movedMark: mark1 }
+            : { movedMark: mark1 };
+        (0, moveEffectTable_1.setMoveEffect)(moveEffects, modular_schema_1.CrossFieldTarget.Destination, revision, id, effect.length, newEffect);
+        sendMarkToDest(mark2, moveEffects, { revision, localId: (0, util_1.brand)(id + effect.length) }, count - effect.length);
+    }
+    else {
+        const newEffect = effect.value !== undefined ? { ...effect.value, movedMark: mark } : { movedMark: mark };
+        (0, moveEffectTable_1.setMoveEffect)(moveEffects, modular_schema_1.CrossFieldTarget.Destination, revision, id, count, newEffect);
+    }
+}
+function rebaseNodeChange(currMark, baseMark, nodeRebaser) {
+    const baseChange = baseMark.changes;
+    const currChange = currMark.changes;
+    if ((0, utils_1.markEmptiesCells)(baseMark) && !(0, moveEffectTable_1.isMoveMark)(baseMark)) {
+        return (0, utils_1.withNodeChange)(currMark, nodeRebaser(currChange, baseChange, modular_schema_1.NodeExistenceState.Dead));
+    }
+    else if ((0, utils_1.markFillsCells)(baseMark) && !(0, moveEffectTable_1.isMoveMark)(baseMark)) {
+        return (0, utils_1.withNodeChange)(currMark, nodeRebaser(currChange, baseChange, modular_schema_1.NodeExistenceState.Alive));
+    }
+    return (0, utils_1.withNodeChange)(currMark, nodeRebaser(currChange, baseChange));
+}
+function makeDetachedMark(mark, cellId) {
+    (0, core_utils_1.assert)(mark.cellId === undefined, 0x69f /* Expected mark to be attached */);
+    return { ...mark, cellId };
+}
+function withCellId(mark, cellId) {
+    const newMark = { ...mark, cellId };
+    if (cellId === undefined) {
+        delete newMark.cellId;
+    }
+    return newMark;
+}
+function getMovedMarkFromBaseMark(moveEffects, baseMark, baseRevision) {
+    if ((0, moveEffectTable_1.isMoveIn)(baseMark)) {
+        return getMovedMark(moveEffects, baseMark.revision ?? baseRevision, baseMark.id, baseMark.count);
+    }
+    else if ((0, utils_1.isAttachAndDetachEffect)(baseMark) && (0, moveEffectTable_1.isMoveIn)(baseMark.attach)) {
+        return getMovedMark(moveEffects, baseMark.attach.revision ?? baseRevision, baseMark.attach.id, baseMark.count);
+    }
+    else {
+        return undefined;
+    }
+}
+// It is expected that the range from `id` to `id + count - 1` has the same move effect.
+// The call sites to this function are making queries about a mark which has already been split by a `MarkQueue`
+// to match the ranges in `moveEffects`.
+// TODO: Reduce the duplication between this and other MoveEffect helpers
+function getMovedMark(moveEffects, revision, id, count) {
+    const effect = (0, moveEffectTable_1.getMoveEffect)(moveEffects, modular_schema_1.CrossFieldTarget.Destination, revision, id, count);
+    (0, core_utils_1.assert)(effect.length === count, 0x6f3 /* Expected effect to cover entire mark */);
+    if (effect.value?.movedMark !== undefined) {
+        const newEffect = { ...effect.value };
+        delete newEffect.movedMark;
+        (0, moveEffectTable_1.setMoveEffect)(moveEffects, modular_schema_1.CrossFieldTarget.Destination, revision, id, count, newEffect, false);
+        if (effect.value.movedMark.count === count) {
+            return effect.value.movedMark;
+        }
+        const [mark1, _mark2] = (0, utils_1.splitMark)(effect.value.movedMark, count);
+        return mark1;
+    }
+    return undefined;
+}
+function handleLineage(cellId, detachBlocks, metadata) {
+    const baseRevisions = metadata
+        .getBaseRevisions()
+        .map((r) => (0, modular_schema_1.getIntention)(r, metadata) ?? (0, util_1.fail)("Intention should be defined"));
+    removeLineageEvents(cellId, new Set(baseRevisions));
+    for (const [revision, detachBlock] of detachBlocks.entries()) {
+        if (shouldReceiveLineage(cellId.revision, revision, metadata)) {
+            const intention = metadata.tryGetInfo(revision)?.rollbackOf ?? revision;
+            for (const entry of detachBlock) {
+                addLineageEntry(cellId, intention, entry.id, entry.count, entry.count);
+            }
+        }
+    }
+}
+function getRevisionIndex(metadata, revision) {
+    const index = metadata.getIndex(revision);
+    if (index !== undefined) {
+        return index;
+    }
+    // This revision is not in the changesets being handled and must be older than them.
+    return -Infinity;
+}
+function updateLineageState(cellBlocks, detachBlocks, baseMark, baseRevision, rebasedMark, metadata) {
+    const attachRevisionIndex = getAttachRevisionIndex(metadata, baseMark, baseRevision);
+    const detachRevisionIndex = getDetachRevisionIndex(metadata, baseMark, baseRevision);
+    for (const revision of detachBlocks.keys()) {
+        const revisionIndex = getRevisionIndex(metadata, revision);
+        // revisionIndex can be -Infinity if it is from a re-detach
+        if (revisionIndex > -Infinity &&
+            attachRevisionIndex <= revisionIndex &&
+            revisionIndex < detachRevisionIndex) {
+            detachBlocks.delete(revision);
+        }
+    }
+    cellBlocks.push({
+        cellId: rebasedMark.cellId,
+        firstAttachedRevisionIndex: attachRevisionIndex,
+        lastAttachedRevisionIndex: detachRevisionIndex - 1,
+    });
+}
+function getAttachRevisionIndex(metadata, baseMark, baseRevision) {
+    if (!(0, utils_1.areInputCellsEmpty)(baseMark)) {
+        return -Infinity;
+    }
+    if ((0, utils_1.markFillsCells)(baseMark)) {
+        (0, core_utils_1.assert)((0, utils_1.isAttach)(baseMark), 0x81b /* Only attach marks can fill cells */);
+        return getRevisionIndex(metadata, baseMark.revision ?? baseRevision ?? (0, util_1.fail)("Mark must have revision"));
+    }
+    if ((0, utils_1.isAttachAndDetachEffect)(baseMark)) {
+        return getRevisionIndex(metadata, baseMark.attach.revision ?? baseRevision ?? (0, util_1.fail)("Mark must have revision"));
+    }
+    return Infinity;
+}
+function getDetachRevisionIndex(metadata, baseMark, baseRevision) {
+    if (!(0, utils_1.areOutputCellsEmpty)(baseMark)) {
+        return Infinity;
+    }
+    if ((0, utils_1.markEmptiesCells)(baseMark)) {
+        (0, core_utils_1.assert)((0, utils_1.isDetach)(baseMark), 0x81c /* Only detach marks can empty cells */);
+        return getRevisionIndex(metadata, baseMark.revision ?? baseRevision ?? (0, util_1.fail)("Mark must have revision"));
+    }
+    if ((0, utils_1.isAttachAndDetachEffect)(baseMark)) {
+        return getRevisionIndex(metadata, baseMark.detach.revision ?? baseRevision ?? (0, util_1.fail)("Mark must have revision"));
+    }
+    return -Infinity;
+}
+function addLineageToRecipients(cellBlocks, revision, id, count, metadata) {
+    const rollbackOf = metadata.tryGetInfo(revision)?.rollbackOf;
+    const intention = rollbackOf ?? revision;
+    const intentionIndex = getRevisionIndex(metadata, intention);
+    for (let i = cellBlocks.length - 1; i >= 0; i--) {
+        const entry = cellBlocks[i];
+        if (entry.firstAttachedRevisionIndex <= intentionIndex &&
+            intentionIndex <= entry.lastAttachedRevisionIndex) {
+            // These cells were full in this revision, so cells earlier in the sequence
+            // do not need to know about this lineage event.
+            return;
+        }
+        // We only add lineage to cells which were detached before the lineage event occurred.
+        if (entry.cellId === undefined) {
+            continue;
+        }
+        if (shouldReceiveLineage(entry.cellId.revision, revision, metadata)) {
+            addLineageEntry(entry.cellId, intention, id, count, 0);
+        }
+    }
+}
+function addLineageEntry(lineageHolder, revision, id, count, offset) {
+    if (lineageHolder.lineage === undefined) {
+        lineageHolder.lineage = [];
+    }
+    if (lineageHolder.lineage.length > 0) {
+        const lastEntry = lineageHolder.lineage[lineageHolder.lineage.length - 1];
+        if (lastEntry.revision === revision && lastEntry.id + lastEntry.count === id) {
+            if (lastEntry.offset === lastEntry.count) {
+                lineageHolder.lineage[lineageHolder.lineage.length - 1] = {
+                    ...lastEntry,
+                    count: lastEntry.count + count,
+                    offset: lastEntry.offset + offset,
+                };
+                return;
+            }
+            else if (offset === 0) {
+                lineageHolder.lineage[lineageHolder.lineage.length - 1] = {
+                    ...lastEntry,
+                    count: lastEntry.count + count,
+                };
+                return;
+            }
+        }
+    }
+    lineageHolder.lineage.push({ revision, id, count, offset });
+}
+function removeLineageEvents(lineageHolder, revisionsToRemove) {
+    if (lineageHolder.lineage === undefined) {
+        return;
+    }
+    lineageHolder.lineage = lineageHolder.lineage.filter((event) => !revisionsToRemove.has(event.revision));
+    if (lineageHolder.lineage.length === 0) {
+        delete lineageHolder.lineage;
+    }
+}
+function addIdRange(lineageEntries, range) {
+    if (lineageEntries.length > 0) {
+        const lastEntry = lineageEntries[lineageEntries.length - 1];
+        if (lastEntry.id + lastEntry.count === range.id) {
+            lastEntry.count += range.count;
+            return;
+        }
+    }
+    lineageEntries.push(range);
+}
+function setMarkAdjacentCells(mark, adjacentCells) {
+    (0, core_utils_1.assert)(mark.cellId !== undefined, 0x74d /* Can only set adjacent cells on a mark with cell ID */);
+    (0, core_utils_1.assert)(mark.cellId.adjacentCells === undefined, 0x74e /* Should not overwrite adjacentCells */);
+    mark.cellId.adjacentCells = adjacentCells;
+}
+function shouldReceiveLineage(cellRevision, detachRevision, metadata) {
+    if (cellRevision === undefined) {
+        // An undefined cell revision means that the cell was created by the changeset we are rebasing.
+        // Since this cell was been empty for all base revisions, it should receive lineage from all of them.
+        // TODO: This cell does not need lineage from roll-forward revisions.
+        return true;
+    }
+    const cellRevisionIndex = getRevisionIndex(metadata, cellRevision);
+    const rollbackOf = metadata.tryGetInfo(detachRevision)?.rollbackOf;
+    const detachIntention = rollbackOf ?? detachRevision;
+    const detachRevisionIndex = getRevisionIndex(metadata, detachIntention);
+    if (detachRevisionIndex === undefined) {
+        // This case means that these cells are being "re-detached" through a `redetachId`.
+        // We could use the revision of the re-detach to determine whether or not this cell needs this lineage entry.
+        // But to be conservative we always add lineage here.
+        return true;
+    }
+    const isRollback = rollbackOf !== undefined;
+    return isRollback
+        ? detachRevisionIndex < cellRevisionIndex
+        : detachRevisionIndex > cellRevisionIndex;
+}
+/**
+ * Returns a number N which encodes how the cells of the two marks are aligned.
+ * - If N is zero, then the first cell of `baseMark` is the same as the first cell of `newMark`.
+ * - If N is positive, then the first N cells of `newMark` (or all its cells if N is greater than its length)
+ * are before the first cell of `baseMark`.
+ * - If N is negative, then the first N cells of `baseMark` (or all its cells if N is greater than its length)
+ * are before the first cell of `newMark`.
+ */
+function compareCellPositions(baseRevision, baseMark, newMark, metadata) {
+    const baseId = (0, utils_1.getInputCellId)(baseMark, baseRevision, metadata);
+    const baseLength = baseMark.count;
+    (0, core_utils_1.assert)(baseId?.revision !== undefined, 0x6a0 /* baseMark should have cell ID */);
+    const newId = (0, utils_1.getInputCellId)(newMark, undefined, metadata);
+    (0, core_utils_1.assert)(newId !== undefined, 0x85a /* newMark should have cell ID */);
+    const newLength = newMark.count;
+    if (newId !== undefined && baseId.revision === newId.revision) {
+        const cmp = (0, utils_1.compareCellsFromSameRevision)(baseId, baseMark.count, newId, newMark.count);
+        if (cmp !== undefined) {
+            return cmp;
+        }
+    }
+    if (newId !== undefined) {
+        const offset = (0, utils_1.getOffsetInCellRange)(baseId.lineage, newId.revision, newId.localId, newLength);
+        if (offset !== undefined) {
+            return offset > 0 ? offset : -Infinity;
+        }
+        const newOffset = (0, utils_1.getOffsetInCellRange)(newId.lineage, baseId.revision, baseId.localId, baseLength);
+        if (newOffset !== undefined) {
+            return newOffset > 0 ? -newOffset : Infinity;
+        }
+    }
+    if (newId !== undefined) {
+        const cmp = (0, utils_1.compareLineages)(baseId, newId);
+        if (cmp !== 0) {
+            return Math.sign(cmp) * Infinity;
+        }
+        const cmp2 = compareMissingLineageEntries(baseId.lineage, newId.lineage, metadata);
+        if (cmp2 !== 0) {
+            return Math.sign(cmp2) * Infinity;
+        }
+    }
+    // Both cells must never have been filled (in their common history), otherwise they would have some common lineage.
+    // A new attach targets a cell that has never been filled.
+    // A mark can also target a cell which was initially filled on another branch, but which has never been filled on the current branch.
+    if (newId.revision === undefined) {
+        // An undefined revision must mean that the cell was created on the branch we are rebasing.
+        // Since it is newer than the `baseMark`'s cell, it should come first.
+        return Infinity;
+    }
+    const baseRevisionIndex = metadata.getIndex(baseId.revision);
+    const newRevisionIndex = metadata.getIndex(newId.revision);
+    if (newRevisionIndex !== undefined && baseRevisionIndex !== undefined) {
+        return newRevisionIndex > baseRevisionIndex ? Infinity : -Infinity;
+    }
+    if (newRevisionIndex !== undefined) {
+        return Infinity;
+    }
+    if (baseRevisionIndex !== undefined) {
+        return -Infinity;
+    }
+    // `newMark` points to cells which were emptied before `baseMark` was created.
+    // We use `baseMark`'s tiebreak policy as if `newMark`'s cells were created concurrently and before `baseMark`.
+    return -Infinity;
+}
+function compareMissingLineageEntries(lineage1, lineage2, metadata) {
+    const events1 = new Map();
+    for (const event of lineage1 ?? []) {
+        events1.set(event.revision, event);
+    }
+    const events2 = new Map();
+    for (const event of lineage2 ?? []) {
+        events2.set(event.revision, event);
+    }
+    for (const revision of events1.keys()) {
+        if (events2.has(revision)) {
+            events1.delete(revision);
+            events2.delete(revision);
+        }
+    }
+    for (const event of events2.values()) {
+        // We've found a cell C that was emptied before the cell1 started tracking lineage.
+        // The cell1 should come before any such cell, so if cell2 comes after C
+        // then we know that cell1 should come before the cell2.
+        // TODO: Account for the cell1's tiebreak policy
+        if (!metadata.hasRollback(event.revision) && event.offset !== 0) {
+            return -1;
+        }
+    }
+    // cell1Events now contains only revisions which were not in cell2's lineage.
+    for (const event of events1.values()) {
+        // We've found a cell C that was emptied before the cell2 started tracking lineage.
+        // The cell2 should come before any such cell, so if cell1 comes after C
+        // then we know that cell2 should come before the cell1.
+        // TODO: Account for the cell2's tiebreak policy
+        if (!metadata.hasRollback(event.revision) && event.offset !== 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=rebase.js.map