@fluidframework/sequence 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/lib/intervalCollection.js

@@ -2,53 +2,15 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 /* eslint-disable no-bitwise */
-import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { UsageError } from "@fluidframework/container-utils";
-import { addProperties, compareReferencePositions, createMap, MergeTreeDeltaType, minReferencePosition, PropertiesManager, RedBlackTree, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, maxReferencePosition, createDetachedLocalReferencePosition, DetachedReferencePosition, SlidingPreference, } from "@fluidframework/merge-tree";
-import { LoggingError } from "@fluidframework/telemetry-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import { addProperties, createMap, getSlideToSegoff, MergeTreeDeltaType, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, DetachedReferencePosition, } from "@fluidframework/merge-tree";
+import { LoggingError, UsageError } from "@fluidframework/telemetry-utils";
 import { v4 as uuid } from "uuid";
-import { IntervalTree } from "./intervalTree";
+import { IntervalOpType, IntervalStickiness, IntervalType, SequenceInterval, createPositionReferenceFromSegoff, endReferenceSlidingPreference, startReferenceSlidingPreference, sequenceIntervalHelpers, createInterval, } from "./intervals";
+import { createEndpointIndex, createIdIntervalIndex, createOverlappingIntervalsIndex, } from "./intervalIndex";
 const reservedIntervalIdKey = "intervalId";
-/**
- * Values are used in persisted formats (ops) and revertibles.
- * @alpha
- */
-export const IntervalOpType = {
-    ADD: "add",
-    DELETE: "delete",
-    CHANGE: "change",
-    PROPERTY_CHANGED: "propertyChanged",
-    POSITION_REMOVE: "positionRemove",
-};
-export var IntervalType;
-(function (IntervalType) {
-    IntervalType[IntervalType["Simple"] = 0] = "Simple";
-    IntervalType[IntervalType["Nest"] = 1] = "Nest";
-    /**
-     * SlideOnRemove indicates that the ends of the interval will slide if the segment
-     * they reference is removed and acked.
-     * See `packages\dds\merge-tree\docs\REFERENCEPOSITIONS.md` for details
-     * SlideOnRemove is the default interval behavior and does not need to be specified.
-     */
-    IntervalType[IntervalType["SlideOnRemove"] = 2] = "SlideOnRemove";
-    /**
-     * A temporary interval, used internally
-     * @internal
-     */
-    IntervalType[IntervalType["Transient"] = 4] = "Transient";
-})(IntervalType || (IntervalType = {}));
 /**
  * Decompress an interval after loading a summary from JSON. The exact format
  * of this compression is unspecified and subject to change
@@ -59,7 +21,7 @@ function decompressInterval(interval, label) {
         end: interval[1],
         sequenceNumber: interval[2],
         intervalType: interval[3],
-        properties: Object.assign(Object.assign({}, interval[4]), { [reservedRangeLabelsKey]: [label] }),
+        properties: { ...interval[4], [reservedRangeLabelsKey]: [label] },
         stickiness: interval[5],
     };
 }
@@ -74,764 +36,23 @@ function compressInterval(interval) {
         end,
         sequenceNumber,
         intervalType,
-        Object.assign(Object.assign({}, properties), { [reservedRangeLabelsKey]: undefined }),
+        // remove the `referenceRangeLabels` property as it is already stored
+        // in the `label` field of the summary
+        { ...properties, [reservedRangeLabelsKey]: undefined },
     ];
     if (interval.stickiness !== undefined && interval.stickiness !== IntervalStickiness.END) {
         base.push(interval.stickiness);
     }
     return base;
 }
-function startReferenceSlidingPreference(stickiness) {
-    // if any start stickiness, prefer sliding backwards
-    return (stickiness & IntervalStickiness.START) !== 0
-        ? SlidingPreference.BACKWARD
-        : SlidingPreference.FORWARD;
-}
-function endReferenceSlidingPreference(stickiness) {
-    // if any end stickiness, prefer sliding forwards
-    return (stickiness & IntervalStickiness.END) !== 0
-        ? SlidingPreference.FORWARD
-        : SlidingPreference.BACKWARD;
-}
-/**
- * Determines how an interval should expand when segments are inserted adjacent
- * to the range it spans
- *
- * Note that interval stickiness is currently an experimental feature and must
- * be explicitly enabled with the `intervalStickinessEnabled` flag
- */
-export const IntervalStickiness = {
-    /**
-     * Interval does not expand to include adjacent segments
-     */
-    NONE: 0b00,
-    /**
-     * Interval expands to include segments inserted adjacent to the start
-     */
-    START: 0b01,
-    /**
-     * Interval expands to include segments inserted adjacent to the end
-     *
-     * This is the default stickiness
-     */
-    END: 0b10,
-    /**
-     * Interval expands to include all segments inserted adjacent to it
-     */
-    FULL: 0b11,
-};
-/**
- * Serializable interval whose endpoints are plain-old numbers.
- */
-export class Interval {
-    constructor(start, end, props) {
-        this.start = start;
-        this.end = end;
-        this.propertyManager = new PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        assert(id !== undefined, 0x5e1 /* interval ID should not be undefined */);
-        return `${id}`;
-    }
-    /**
-     * @returns an array containing any auxiliary property sets added with `addPropertySet`.
-     */
-    getAdditionalPropertySets() {
-        var _a;
-        return (_a = this.auxProps) !== null && _a !== void 0 ? _a : [];
-    }
-    /**
-     * Adds an auxiliary set of properties to this interval.
-     * These properties can be recovered using `getAdditionalPropertySets`
-     * @param props - set of properties to add
-     * @remarks - This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
-     * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
-     * This functionality seems half-baked.
-     */
-    addPropertySet(props) {
-        if (this.auxProps === undefined) {
-            this.auxProps = [];
-        }
-        this.auxProps.push(props);
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.serialize}
-     * @internal
-     */
-    serialize() {
-        const serializedInterval = {
-            end: this.end,
-            intervalType: 0,
-            sequenceNumber: 0,
-            start: this.start,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        return serializedInterval;
-    }
-    /**
-     * {@inheritDoc IInterval.clone}
-     */
-    clone() {
-        return new Interval(this.start, this.end, this.properties);
-    }
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b) {
-        return this.start - b.start;
-    }
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b) {
-        return this.end - b.end;
-    }
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b) {
-        const result = this.start <= b.end && this.end >= b.start;
-        return result;
-    }
-    /**
-     * {@inheritDoc IInterval.union}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    union(b) {
-        return new Interval(Math.min(this.start, b.start), Math.max(this.end, b.end), this.properties);
-    }
-    getProperties() {
-        return this.properties;
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.addProperties}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    addProperties(newProps, collaborating = false, seq, op) {
-        if (newProps) {
-            this.initializeProperties();
-            return this.propertyManager.addProperties(this.properties, newProps, op, seq, collaborating);
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.modify}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    modify(label, start, end, op) {
-        const startPos = start !== null && start !== void 0 ? start : this.start;
-        const endPos = end !== null && end !== void 0 ? end : this.end;
-        if (this.start === startPos && this.end === endPos) {
-            // Return undefined to indicate that no change is necessary.
-            return;
-        }
-        const newInterval = new Interval(startPos, endPos);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = createMap();
-        }
-    }
-}
-/**
- * Interval implementation whose ends are associated with positions in a mutatable sequence.
- * As such, when content is inserted into the middle of the interval, the interval expands to
- * include that content.
- *
- * @remarks - The endpoint's position should be treated exclusively to get reasonable behavior--i.e.
- * an interval referring to "hello" in "hello world" should have a start position of 0 and an end
- * position of 5.
- *
- * To see why, consider what happens if "llo wor" is removed from the string to make "held".
- * The interval's startpoint remains on the "h" (it isn't altered), but the interval's endpoint
- * slides forward to the next unremoved position, which is the "l" in "held".
- * Users would generally expect the interval to now refer to "he" (as it is the subset of content
- * remaining after the removal), hence the "l" should be excluded.
- * If the interval endpoint was treated inclusively, the interval would now refer to "hel", which
- * is undesirable.
- *
- * Since the end of an interval is treated exclusively but cannot be greater than or equal to the
- * length of the associated sequence, application models which leverage interval collections should
- * consider inserting a marker at the end of the sequence to represent the end of the content.
- */
-export class SequenceInterval {
-    constructor(client, 
-    /**
-     * Start endpoint of this interval.
-     * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    start, 
-    /**
-     * End endpoint of this interval.
-     * @remarks - This endpoint can be resolved into a character position using the SharedString it's a part of.
-     */
-    end, intervalType, props, stickiness = IntervalStickiness.END) {
-        this.client = client;
-        this.start = start;
-        this.end = end;
-        this.intervalType = intervalType;
-        this.stickiness = stickiness;
-        this.propertyManager = new PropertiesManager();
-        this.properties = {};
-        if (props) {
-            this.addProperties(props);
-        }
-    }
-    /**
-     * Subscribes to position change events on this interval if there are no current listeners.
-     * @internal
-     */
-    addPositionChangeListeners(beforePositionChange, afterPositionChange) {
-        var _a, _b;
-        var _c, _d;
-        if (this.callbacks === undefined) {
-            this.callbacks = {
-                beforePositionChange,
-                afterPositionChange,
-            };
-            const startCbs = ((_a = (_c = this.start).callbacks) !== null && _a !== void 0 ? _a : (_c.callbacks = {}));
-            const endCbs = ((_b = (_d = this.end).callbacks) !== null && _b !== void 0 ? _b : (_d.callbacks = {}));
-            startCbs.beforeSlide = endCbs.beforeSlide = beforePositionChange;
-            startCbs.afterSlide = endCbs.afterSlide = afterPositionChange;
-        }
-    }
-    /**
-     * Removes the currently subscribed position change listeners.
-     * @internal
-     */
-    removePositionChangeListeners() {
-        if (this.callbacks) {
-            this.callbacks = undefined;
-            this.start.callbacks = undefined;
-            this.end.callbacks = undefined;
-        }
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.serialize}
-     * @internal
-     */
-    serialize() {
-        const startPosition = this.client.localReferencePositionToPosition(this.start);
-        const endPosition = this.client.localReferencePositionToPosition(this.end);
-        const serializedInterval = {
-            end: endPosition,
-            intervalType: this.intervalType,
-            sequenceNumber: this.client.getCurrentSeq(),
-            start: startPosition,
-        };
-        if (this.properties) {
-            serializedInterval.properties = this.properties;
-        }
-        if (this.stickiness !== IntervalStickiness.END) {
-            serializedInterval.stickiness = this.stickiness;
-        }
-        return serializedInterval;
-    }
-    /**
-     * {@inheritDoc IInterval.clone}
-     */
-    clone() {
-        return new SequenceInterval(this.client, this.start, this.end, this.intervalType, this.properties, this.stickiness);
-    }
-    /**
-     * {@inheritDoc IInterval.compare}
-     */
-    compare(b) {
-        const startResult = this.compareStart(b);
-        if (startResult === 0) {
-            const endResult = this.compareEnd(b);
-            if (endResult === 0) {
-                const thisId = this.getIntervalId();
-                if (thisId) {
-                    const bId = b.getIntervalId();
-                    if (bId) {
-                        return thisId > bId ? 1 : thisId < bId ? -1 : 0;
-                    }
-                    return 0;
-                }
-                return 0;
-            }
-            else {
-                return endResult;
-            }
-        }
-        else {
-            return startResult;
-        }
-    }
-    /**
-     * {@inheritDoc IInterval.compareStart}
-     */
-    compareStart(b) {
-        return compareReferencePositions(this.start, b.start);
-    }
-    /**
-     * {@inheritDoc IInterval.compareEnd}
-     */
-    compareEnd(b) {
-        return compareReferencePositions(this.end, b.end);
-    }
-    /**
-     * {@inheritDoc IInterval.overlaps}
-     */
-    overlaps(b) {
-        const result = compareReferencePositions(this.start, b.end) <= 0 &&
-            compareReferencePositions(this.end, b.start) >= 0;
-        return result;
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.getIntervalId}
-     */
-    getIntervalId() {
-        var _a;
-        const id = (_a = this.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
-        assert(id !== undefined, 0x5e2 /* interval ID should not be undefined */);
-        return `${id}`;
-    }
-    /**
-     * {@inheritDoc IInterval.union}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    union(b) {
-        return new SequenceInterval(this.client, minReferencePosition(this.start, b.start), maxReferencePosition(this.end, b.end), this.intervalType);
-    }
-    /**
-     * {@inheritDoc ISerializableInterval.addProperties}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    addProperties(newProps, collab = false, seq, op) {
-        this.initializeProperties();
-        return this.propertyManager.addProperties(this.properties, newProps, op, seq, collab);
-    }
-    /**
-     * @returns whether this interval overlaps two numerical positions.
-     */
-    overlapsPos(bstart, bend) {
-        const startPos = this.client.localReferencePositionToPosition(this.start);
-        const endPos = this.client.localReferencePositionToPosition(this.end);
-        return endPos > bstart && startPos < bend;
-    }
-    /**
-     * {@inheritDoc IInterval.modify}
-     * @deprecated - This API was never intended to be public and will be marked internal in a future release.
-     */
-    modify(label, start, end, op, localSeq, stickiness = IntervalStickiness.END) {
-        const getRefType = (baseType) => {
-            let refType = baseType;
-            if (op === undefined) {
-                refType &= ~ReferenceType.SlideOnRemove;
-                refType |= ReferenceType.StayOnRemove;
-            }
-            return refType;
-        };
-        let startRef = this.start;
-        if (start !== undefined) {
-            startRef = createPositionReference(this.client, start, getRefType(this.start.refType), op, undefined, localSeq, startReferenceSlidingPreference(stickiness));
-            if (this.start.properties) {
-                startRef.addProperties(this.start.properties);
-            }
-        }
-        let endRef = this.end;
-        if (end !== undefined) {
-            endRef = createPositionReference(this.client, end, getRefType(this.end.refType), op, undefined, localSeq, endReferenceSlidingPreference(stickiness));
-            if (this.end.properties) {
-                endRef.addProperties(this.end.properties);
-            }
-        }
-        const newInterval = new SequenceInterval(this.client, startRef, endRef, this.intervalType);
-        if (this.properties) {
-            newInterval.initializeProperties();
-            this.propertyManager.copyTo(this.properties, newInterval.properties, newInterval.propertyManager);
-        }
-        return newInterval;
-    }
-    initializeProperties() {
-        if (!this.propertyManager) {
-            this.propertyManager = new PropertiesManager();
-        }
-        if (!this.properties) {
-            this.properties = createMap();
-        }
-    }
-}
-function createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference) {
-    if (segoff.segment) {
-        const ref = client.createLocalReferencePosition(segoff.segment, segoff.offset, refType, undefined, slidingPreference);
-        return ref;
-    }
-    // Creating references on detached segments is allowed for:
-    // - Transient segments
-    // - References coming from a remote client (location may have been concurrently removed)
-    // - References being rebased to a new sequence number
-    //   (segment they originally referred to may have been removed with no suitable replacement)
-    if (!op &&
-        !localSeq &&
-        !fromSnapshot &&
-        !refTypeIncludesFlag(refType, ReferenceType.Transient)) {
-        throw new UsageError("Non-transient references need segment");
-    }
-    return createDetachedLocalReferencePosition(refType);
-}
-function createPositionReference(client, pos, refType, op, fromSnapshot, localSeq, slidingPreference) {
-    let segoff;
-    if (op) {
-        assert((refType & ReferenceType.SlideOnRemove) !== 0, 0x2f5 /* op create references must be SlideOnRemove */);
-        segoff = client.getContainingSegment(pos, {
-            referenceSequenceNumber: op.referenceSequenceNumber,
-            clientId: op.clientId,
-        });
-        segoff = client.getSlideToSegment(segoff);
-    }
-    else {
-        assert((refType & ReferenceType.SlideOnRemove) === 0 || !!fromSnapshot, 0x2f6 /* SlideOnRemove references must be op created */);
-        segoff = client.getContainingSegment(pos, undefined, localSeq);
-    }
-    return createPositionReferenceFromSegoff(client, segoff, refType, op, localSeq, fromSnapshot, slidingPreference);
-}
-export function createSequenceInterval(label, start, end, client, intervalType, op, fromSnapshot, stickiness = IntervalStickiness.END) {
-    let beginRefType = ReferenceType.RangeBegin;
-    let endRefType = ReferenceType.RangeEnd;
-    if (intervalType === IntervalType.Transient) {
-        beginRefType = ReferenceType.Transient;
-        endRefType = ReferenceType.Transient;
-    }
-    else {
-        if (intervalType === IntervalType.Nest) {
-            beginRefType = ReferenceType.NestBegin;
-            endRefType = ReferenceType.NestEnd;
-        }
-        // All non-transient interval references must eventually be SlideOnRemove
-        // To ensure eventual consistency, they must start as StayOnRemove when
-        // pending (created locally and creation op is not acked)
-        if (op || fromSnapshot) {
-            beginRefType |= ReferenceType.SlideOnRemove;
-            endRefType |= ReferenceType.SlideOnRemove;
-        }
-        else {
-            beginRefType |= ReferenceType.StayOnRemove;
-            endRefType |= ReferenceType.StayOnRemove;
-        }
-    }
-    const startLref = createPositionReference(client, start, beginRefType, op, fromSnapshot, undefined, startReferenceSlidingPreference(stickiness));
-    const endLref = createPositionReference(client, end, endRefType, op, fromSnapshot, undefined, endReferenceSlidingPreference(stickiness));
-    const rangeProp = {
-        [reservedRangeLabelsKey]: [label],
-    };
-    startLref.addProperties(rangeProp);
-    endLref.addProperties(rangeProp);
-    const ival = new SequenceInterval(client, startLref, endLref, intervalType, rangeProp, stickiness);
-    return ival;
-}
 export function createIntervalIndex() {
     const helpers = {
-        compareEnds: compareIntervalEnds,
+        compareEnds: (a, b) => a.end - b.end,
         create: createInterval,
     };
     const lc = new LocalIntervalCollection(undefined, "", helpers);
     return lc;
 }
-class OverlappingIntervalsIndex {
-    constructor(client, helpers) {
-        this.client = client;
-        this.helpers = helpers;
-        this.intervalTree = new IntervalTree();
-    }
-    map(fn) {
-        this.intervalTree.map(fn);
-    }
-    mapUntil(fn) {
-        this.intervalTree.mapUntil(fn);
-    }
-    gatherIterationResults(results, iteratesForward, start, end) {
-        if (this.intervalTree.intervals.isEmpty()) {
-            return;
-        }
-        if (start === undefined && end === undefined) {
-            // No start/end provided. Gather the whole tree in the specified order.
-            if (iteratesForward) {
-                this.intervalTree.map((interval) => {
-                    results.push(interval);
-                });
-            }
-            else {
-                this.intervalTree.mapBackward((interval) => {
-                    results.push(interval);
-                });
-            }
-        }
-        else {
-            const transientInterval = this.helpers.create("transient", start, end, this.client, IntervalType.Transient);
-            if (start === undefined) {
-                // Only end position provided. Since the tree is not sorted by end position,
-                // walk the whole tree in the specified order, gathering intervals that match the end.
-                if (iteratesForward) {
-                    this.intervalTree.map((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-                else {
-                    this.intervalTree.mapBackward((interval) => {
-                        if (transientInterval.compareEnd(interval) === 0) {
-                            results.push(interval);
-                        }
-                    });
-                }
-            }
-            else {
-                // Start and (possibly) end provided. Walk the subtrees that may contain
-                // this start position.
-                const compareFn = end === undefined
-                    ? (node) => {
-                        return transientInterval.compareStart(node.key);
-                    }
-                    : (node) => {
-                        return transientInterval.compare(node.key);
-                    };
-                const continueLeftFn = (cmpResult) => cmpResult <= 0;
-                const continueRightFn = (cmpResult) => cmpResult >= 0;
-                const actionFn = (node) => {
-                    results.push(node.key);
-                };
-                if (iteratesForward) {
-                    this.intervalTree.intervals.walkExactMatchesForward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-                else {
-                    this.intervalTree.intervals.walkExactMatchesBackward(compareFn, actionFn, continueLeftFn, continueRightFn);
-                }
-            }
-        }
-    }
-    /**
-     * @returns an array of all intervals contained in this collection that overlap the range
-     * `[startPosition, endPosition)`.
-     */
-    findOverlappingIntervals(startPosition, endPosition) {
-        if (endPosition < startPosition || this.intervalTree.intervals.isEmpty()) {
-            return [];
-        }
-        const transientInterval = this.helpers.create("transient", startPosition, endPosition, this.client, IntervalType.Transient);
-        const overlappingIntervalNodes = this.intervalTree.match(transientInterval);
-        return overlappingIntervalNodes.map((node) => node.key);
-    }
-    remove(interval) {
-        this.intervalTree.removeExisting(interval);
-    }
-    add(interval) {
-        this.intervalTree.put(interval);
-    }
-}
-class IdIntervalIndex {
-    constructor() {
-        this.intervalIdMap = new Map();
-    }
-    add(interval) {
-        const id = interval.getIntervalId();
-        assert(id !== undefined, 0x2c0 /* "ID must be created before adding interval to collection" */);
-        // Make the ID immutable.
-        Object.defineProperty(interval.properties, reservedIntervalIdKey, {
-            configurable: false,
-            enumerable: true,
-            writable: false,
-        });
-        this.intervalIdMap.set(id, interval);
-    }
-    remove(interval) {
-        const id = interval.getIntervalId();
-        assert(id !== undefined, 0x311 /* expected id to exist on interval */);
-        this.intervalIdMap.delete(id);
-    }
-    getIntervalById(id) {
-        return this.intervalIdMap.get(id);
-    }
-    [Symbol.iterator]() {
-        return this.intervalIdMap.values();
-    }
-}
-class EndpointIndex {
-    constructor(client, helpers) {
-        this.client = client;
-        this.helpers = helpers;
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        this.endIntervalTree = new RedBlackTree(helpers.compareEnds);
-    }
-    previousInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.floor(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    nextInterval(pos) {
-        const transientInterval = this.helpers.create("transient", pos, pos, this.client, IntervalType.Transient);
-        const rbNode = this.endIntervalTree.ceil(transientInterval);
-        if (rbNode) {
-            return rbNode.data;
-        }
-    }
-    add(interval) {
-        this.endIntervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.endIntervalTree.remove(interval);
-    }
-}
-/**
- * Interface for intervals that have comparison override properties.
- */
-const forceCompare = Symbol();
-/**
- * Compares two objects based on their comparison override properties.
- * @returns A number indicating the order of the intervals (negative for a is lower than b, 0 for tie, positive for a is greater than b).
- */
-function compareOverrideables(a, b) {
-    var _a, _b;
-    const forceCompareA = (_a = a[forceCompare]) !== null && _a !== void 0 ? _a : 0;
-    const forceCompareB = (_b = b[forceCompare]) !== null && _b !== void 0 ? _b : 0;
-    return forceCompareA - forceCompareB;
-}
-class EndpointInRangeIndex {
-    constructor(helpers, client) {
-        this.helpers = helpers;
-        this.client = client;
-        this.intervalTree = new RedBlackTree((a, b) => {
-            const compareEndsResult = helpers.compareEnds(a, b);
-            if (compareEndsResult !== 0) {
-                return compareEndsResult;
-            }
-            const overrideablesComparison = compareOverrideables(a, b);
-            if (overrideablesComparison !== 0) {
-                return overrideablesComparison;
-            }
-            const aId = a.getIntervalId();
-            const bId = b.getIntervalId();
-            if (aId !== undefined && bId !== undefined) {
-                return aId.localeCompare(bId);
-            }
-            return 0;
-        });
-    }
-    add(interval) {
-        this.intervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.intervalTree.remove(interval);
-    }
-    findIntervalsWithEndpointInRange(start, end) {
-        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
-            return [];
-        }
-        const results = [];
-        const action = (node) => {
-            results.push(node.data);
-            return true;
-        };
-        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
-        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
-        // Add comparison overrides to the transient intervals
-        transientStartInterval[forceCompare] = -1;
-        transientEndInterval[forceCompare] = 1;
-        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
-        return results;
-    }
-}
-class StartpointInRangeIndex {
-    constructor(helpers, client) {
-        this.helpers = helpers;
-        this.client = client;
-        this.intervalTree = new RedBlackTree((a, b) => {
-            assert(typeof helpers.compareStarts === "function", 0x6d1 /* compareStarts does not exist in the helpers */);
-            const compareStartsResult = helpers.compareStarts(a, b);
-            if (compareStartsResult !== 0) {
-                return compareStartsResult;
-            }
-            const overrideablesComparison = compareOverrideables(a, b);
-            if (overrideablesComparison !== 0) {
-                return overrideablesComparison;
-            }
-            const aId = a.getIntervalId();
-            const bId = b.getIntervalId();
-            if (aId !== undefined && bId !== undefined) {
-                return aId.localeCompare(bId);
-            }
-            return 0;
-        });
-    }
-    add(interval) {
-        this.intervalTree.put(interval, interval);
-    }
-    remove(interval) {
-        this.intervalTree.remove(interval);
-    }
-    findIntervalsWithStartpointInRange(start, end) {
-        if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
-            return [];
-        }
-        const results = [];
-        const action = (node) => {
-            results.push(node.data);
-            return true;
-        };
-        const transientStartInterval = this.helpers.create("transient", start, start, this.client, IntervalType.Transient);
-        const transientEndInterval = this.helpers.create("transient", end, end, this.client, IntervalType.Transient);
-        // Add comparison overrides to the transient intervals
-        transientStartInterval[forceCompare] = -1;
-        transientEndInterval[forceCompare] = 1;
-        this.intervalTree.mapRange(action, results, transientStartInterval, transientEndInterval);
-        return results;
-    }
-}
-export function createEndpointInRangeIndex(helpers, client) {
-    return new EndpointInRangeIndex(helpers, client);
-}
-export function createStartpointInRangeIndex(helpers, client) {
-    return new StartpointInRangeIndex(helpers, client);
-}
 export class LocalIntervalCollection {
     constructor(client, label, helpers, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
@@ -840,9 +61,9 @@ export class LocalIntervalCollection {
         this.label = label;
         this.helpers = helpers;
         this.onPositionChange = onPositionChange;
-        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
-        this.idIntervalIndex = new IdIntervalIndex();
-        this.endIntervalIndex = new EndpointIndex(client, helpers);
+        this.overlappingIntervalsIndex = createOverlappingIntervalsIndex(client, helpers);
+        this.idIntervalIndex = createIdIntervalIndex();
+        this.endIntervalIndex = createEndpointIndex(client, helpers);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -862,8 +83,7 @@ export class LocalIntervalCollection {
      * @returns The interval's existing or newly created id
      */
     ensureSerializedId(serializedInterval) {
-        var _a;
-        let id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+        let id = serializedInterval.properties?.[reservedIntervalIdKey];
         if (id === undefined) {
             // Back-compat: 0.39 and earlier did not have IDs on intervals. If an interval from such a client
             // comes over the wire, create a non-unique one based on start/end.
@@ -902,16 +122,22 @@ export class LocalIntervalCollection {
     }
     addInterval(start, end, intervalType, props, op, stickiness = IntervalStickiness.END) {
         var _a;
-        var _b;
         const interval = this.createInterval(start, end, intervalType, op, stickiness);
         if (interval) {
             if (!interval.properties) {
                 interval.properties = createMap();
             }
             if (props) {
+                // This check is intended to prevent scenarios where a random interval is created and then
+                // inserted into a collection. The aim is to ensure that the collection is created first
+                // then the user can create/add intervals based on the collection
+                if (props[reservedRangeLabelsKey] !== undefined &&
+                    props[reservedRangeLabelsKey][0] !== this.label) {
+                    throw new LoggingError("Adding an interval that belongs to another interval collection is not permitted");
+                }
                 interval.addProperties(props);
             }
-            (_a = (_b = interval.properties)[reservedIntervalIdKey]) !== null && _a !== void 0 ? _a : (_b[reservedIntervalIdKey] = uuid());
+            (_a = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = uuid());
             this.add(interval);
         }
         return interval;
@@ -971,12 +197,11 @@ export class LocalIntervalCollection {
                     this.removeIntervalFromIndexes(interval);
                 }
             }, () => {
-                var _a;
                 assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
                 pendingChanges--;
                 if (pendingChanges === 0) {
                     this.addIntervalToIndexes(interval);
-                    (_a = this.onPositionChange) === null || _a === void 0 ? void 0 : _a.call(this, interval, previousInterval);
+                    this.onPositionChange?.(interval, previousInterval);
                     previousInterval = undefined;
                 }
             });
@@ -989,18 +214,6 @@ export class LocalIntervalCollection {
     }
 }
 LocalIntervalCollection.legacyIdPrefix = "legacy";
-export const compareSequenceIntervalEnds = (a, b) => compareReferencePositions(a.end, b.end);
-export const compareSequenceIntervalStarts = (a, b) => compareReferencePositions(a.start, b.start);
-export const sequenceIntervalHelpers = {
-    compareEnds: compareSequenceIntervalEnds,
-    compareStarts: compareSequenceIntervalStarts,
-    create: createSequenceInterval,
-};
-export const intervalHelpers = {
-    compareEnds: (a, b) => a.end - b.end,
-    compareStarts: (a, b) => a.start - b.start,
-    create: createInterval,
-};
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = [], options) {
         return new IntervalCollection(sequenceIntervalHelpers, true, emitter, raw, options);
@@ -1023,18 +236,10 @@ export class SequenceIntervalCollectionValueType {
 SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
-const compareIntervalEnds = (a, b) => a.end - b.end;
-function createInterval(label, start, end, client, intervalType, op, fromSnapshot) {
-    const rangeProp = {};
-    if (label && label.length > 0) {
-        rangeProp[reservedRangeLabelsKey] = [label];
-    }
-    return new Interval(start, end, rangeProp);
-}
 class IntervalCollectionFactory {
     load(emitter, raw = [], options) {
         const helpers = {
-            compareEnds: compareIntervalEnds,
+            compareEnds: (a, b) => a.end - b.end,
             create: createInterval,
         };
         const collection = new IntervalCollection(helpers, false, emitter, raw, options);
@@ -1063,7 +268,7 @@ export function makeOpsMap() {
     const rebase = (collection, op, localOpMetadata) => {
         const { localSeq } = localOpMetadata;
         const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-        const rebasedOp = Object.assign(Object.assign({}, op), { value: rebasedValue });
+        const rebasedOp = { ...op, value: rebasedValue };
         return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
     };
     return new Map([
@@ -1157,25 +362,23 @@ export class IntervalCollection extends TypedEventEmitter {
      * {@inheritdoc IIntervalCollection.attachIndex}
      */
     attachIndex(index) {
-        var _a;
         if (!this.attached) {
             throw new LoggingError("The local interval collection must exist");
         }
         for (const interval of this) {
             index.add(interval);
         }
-        (_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.appendIndex(index);
+        this.localCollection?.appendIndex(index);
     }
     /**
      * {@inheritdoc IIntervalCollection.detachIndex}
      */
     detachIndex(index) {
-        var _a;
         if (!this.attached) {
             throw new LoggingError("The local interval collection must exist");
         }
         // Avoid removing intervals if the index does not exist
-        if (!((_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.removeIndex(index))) {
+        if (!this.localCollection?.removeIndex(index)) {
             return false;
         }
         for (const interval of this) {
@@ -1184,7 +387,6 @@ export class IntervalCollection extends TypedEventEmitter {
         return true;
     }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
-        var _a;
         if (!this.client) {
             throw new LoggingError("mergeTree client must exist");
         }
@@ -1195,7 +397,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }, localSeq);
         // if segment is undefined, it slid off the string
         assert(segment !== undefined, 0x54e /* No segment found */);
-        const segoff = (_a = this.client.getSlideToSegment({ segment, offset })) !== null && _a !== void 0 ? _a : segment;
+        const segoff = getSlideToSegoff({ segment, offset }) ?? segment;
         // case happens when rebasing op, but concurrently entire string has been deleted
         if (segoff.segment === undefined || segoff.offset === undefined) {
             return DetachedReferencePosition;
@@ -1207,7 +409,7 @@ export class IntervalCollection extends TypedEventEmitter {
         assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
         const original = this.localSeqToSerializedInterval.get(localSeq);
         assert(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
-        const rebased = Object.assign({}, original);
+        const rebased = { ...original };
         const { start, end, sequenceNumber } = original;
         if (start !== undefined) {
             rebased.start = this.rebasePositionWithSegmentSlide(start, sequenceNumber, localSeq);
@@ -1234,7 +436,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 }
             });
         }
-        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval, previousInterval) => this.emitChange(interval, previousInterval, true));
+        this.localCollection = new LocalIntervalCollection(client, label, this.helpers, (interval, previousInterval) => this.emitChange(interval, previousInterval, true, true));
         if (this.savedSerializedIntervals) {
             for (const serializedInterval of this.savedSerializedIntervals) {
                 this.localCollection.ensureSerializedId(serializedInterval);
@@ -1257,7 +459,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         return 0;
     }
-    emitChange(interval, previousInterval, local, op) {
+    emitChange(interval, previousInterval, local, slide, op) {
         // Temporarily make references transient so that positional queries work (non-transient refs
         // on resolve to DetachedPosition on any segments that don't contain them). The original refType
         // is restored as single-endpoint changes re-use previous references.
@@ -1268,12 +470,12 @@ export class IntervalCollection extends TypedEventEmitter {
             endRefType = previousInterval.end.refType;
             previousInterval.start.refType = ReferenceType.Transient;
             previousInterval.end.refType = ReferenceType.Transient;
-            this.emit("changeInterval", interval, previousInterval, local, op);
+            this.emit("changeInterval", interval, previousInterval, local, op, slide);
             previousInterval.start.refType = startRefType;
             previousInterval.end.refType = endRefType;
         }
         else {
-            this.emit("changeInterval", interval, previousInterval, local, op);
+            this.emit("changeInterval", interval, previousInterval, local, op, slide);
         }
     }
     /**
@@ -1289,7 +491,6 @@ export class IntervalCollection extends TypedEventEmitter {
      * {@inheritdoc IIntervalCollection.add}
      */
     add(start, end, intervalType, props, stickiness = IntervalStickiness.END) {
-        var _a, _b;
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
@@ -1305,7 +506,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 end,
                 intervalType,
                 properties: interval.properties,
-                sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
+                sequenceNumber: this.client?.getCurrentSeq() ?? 0,
                 start,
                 stickiness,
             };
@@ -1364,6 +565,11 @@ export class IntervalCollection extends TypedEventEmitter {
         if (!props) {
             throw new LoggingError("changeProperties should be called with a property set");
         }
+        // prevent the overwriting of an interval label, it should remain unchanged
+        // once it has been inserted into the collection.
+        if (props[reservedRangeLabelsKey] !== undefined) {
+            throw new LoggingError("The label property should not be modified once inserted to the collection");
+        }
         const interval = this.getIntervalById(id);
         if (interval) {
             // Pass Unassigned as the sequence number to indicate that this is a local op that is waiting for an ack.
@@ -1409,7 +615,7 @@ export class IntervalCollection extends TypedEventEmitter {
             this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             this.emitter.emit("change", undefined, serializedInterval, { localSeq });
             this.addPendingChange(id, serializedInterval);
-            this.emitChange(newInterval, interval, true);
+            this.emitChange(newInterval, interval, true, false);
             return newInterval;
         }
         // No interval to change
@@ -1432,9 +638,8 @@ export class IntervalCollection extends TypedEventEmitter {
         entries.push(serializedInterval);
     }
     removePendingChange(serializedInterval) {
-        var _a;
         // Change ops always have an ID.
-        const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+        const id = serializedInterval.properties?.[reservedIntervalIdKey];
         if (serializedInterval.start !== undefined) {
             this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
@@ -1449,8 +654,8 @@ export class IntervalCollection extends TypedEventEmitter {
             if (entries.length === 0) {
                 pendingChanges.delete(id);
             }
-            if ((pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.start) !== serializedInterval.start ||
-                (pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.end) !== serializedInterval.end) {
+            if (pendingChange?.start !== serializedInterval.start ||
+                pendingChange?.end !== serializedInterval.end) {
                 throw new LoggingError("Mismatch in pending changes");
             }
         }
@@ -1465,20 +670,19 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /** @internal */
     ackChange(serializedInterval, local, op, localOpMetadata) {
-        var _a, _b, _c, _d;
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
             assert(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
-            this.localSeqToSerializedInterval.delete(localOpMetadata === null || localOpMetadata === void 0 ? void 0 : localOpMetadata.localSeq);
+            this.localSeqToSerializedInterval.delete(localOpMetadata?.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
         }
         // Note that the ID is in the property bag only to allow us to find the interval.
         // This API cannot change the ID, and writing to the ID property will result in an exception. So we
         // strip it out of the properties here.
-        const _e = (_a = serializedInterval.properties) !== null && _a !== void 0 ? _a : {}, _f = reservedIntervalIdKey, id = _e[_f], newProps = __rest(_e, [typeof _f === "symbol" ? _f : _f + ""]);
+        const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
         assert(id !== undefined, 0x3fe /* id must exist on the interval */);
         const interval = this.getIntervalById(id);
         if (!interval) {
@@ -1487,9 +691,9 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         if (local) {
             // Let the propertyManager prune its pending change-properties set.
-            (_b = interval.propertyManager) === null || _b === void 0 ? void 0 : _b.ackPendingProperties({
+            interval.propertyManager?.ackPendingProperties({
                 type: MergeTreeDeltaType.ANNOTATE,
-                props: (_c = serializedInterval.properties) !== null && _c !== void 0 ? _c : {},
+                props: serializedInterval.properties ?? {},
             });
             this.ackInterval(interval, op);
         }
@@ -1510,14 +714,14 @@ export class IntervalCollection extends TypedEventEmitter {
                 // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
                 // the one we originally found in the tree.
                 newInterval =
-                    (_d = this.localCollection.changeInterval(interval, start, end, op)) !== null && _d !== void 0 ? _d : interval;
+                    this.localCollection.changeInterval(interval, start, end, op) ?? interval;
             }
             const deltaProps = newInterval.addProperties(newProps, true, op.sequenceNumber);
             if (this.onDeserialize) {
                 this.onDeserialize(newInterval);
             }
             if (newInterval !== interval) {
-                this.emitChange(newInterval, interval, local, op);
+                this.emitChange(newInterval, interval, local, false, op);
             }
             const changedProperties = Object.keys(newProps).length > 0;
             if (changedProperties) {
@@ -1525,18 +729,6 @@ export class IntervalCollection extends TypedEventEmitter {
             }
         }
     }
-    /**
-     * @deprecated - This functionality was useful when adding two intervals at the same start/end positions resulted
-     * in a conflict. This is no longer the case (as of PR#6407), as interval collections support multiple intervals
-     * at the same location and gives each interval a unique id.
-     *
-     * As such, the conflict resolver is never invoked and unnecessary. This API will be removed in an upcoming release.
-     */
-    addConflictResolver(_) {
-        if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
-        }
-    }
     /**
      * {@inheritdoc IIntervalCollection.attachDeserializer}
      */
@@ -1560,7 +752,6 @@ export class IntervalCollection extends TypedEventEmitter {
      * @internal
      */
     rebaseLocalInterval(opName, serializedInterval, localSeq) {
-        var _a, _b, _c, _d, _e, _f;
         if (!this.client) {
             // If there's no associated mergeTree client, the originally submitted op is still correct.
             return serializedInterval;
@@ -1569,14 +760,14 @@ export class IntervalCollection extends TypedEventEmitter {
             throw new LoggingError("attachSequence must be called");
         }
         const { intervalType, properties } = serializedInterval;
-        const { start: startRebased, end: endRebased } = (_a = this.localSeqToRebasedInterval.get(localSeq)) !== null && _a !== void 0 ? _a : this.computeRebasedPositions(localSeq);
-        const intervalId = properties === null || properties === void 0 ? void 0 : properties[reservedIntervalIdKey];
-        const localInterval = (_b = this.localCollection) === null || _b === void 0 ? void 0 : _b.idIntervalIndex.getIntervalById(intervalId);
+        const { start: startRebased, end: endRebased } = this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
+        const intervalId = properties?.[reservedIntervalIdKey];
+        const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(intervalId);
         const rebased = {
             start: startRebased,
             end: endRebased,
             intervalType,
-            sequenceNumber: (_d = (_c = this.client) === null || _c === void 0 ? void 0 : _c.getCurrentSeq()) !== null && _d !== void 0 ? _d : 0,
+            sequenceNumber: this.client?.getCurrentSeq() ?? 0,
             properties,
         };
         if (opName === "change" &&
@@ -1588,7 +779,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (startRebased === DetachedReferencePosition ||
             endRebased === DetachedReferencePosition) {
             if (localInterval) {
-                (_e = this.localCollection) === null || _e === void 0 ? void 0 : _e.removeExistingInterval(localInterval);
+                this.localCollection?.removeExistingInterval(localInterval);
             }
             return undefined;
         }
@@ -1597,20 +788,19 @@ export class IntervalCollection extends TypedEventEmitter {
             assert(localInterval instanceof SequenceInterval, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
             // The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
             // updates the local client's state to be consistent with the emitted op.
-            (_f = this.localCollection) === null || _f === void 0 ? void 0 : _f.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
+            this.localCollection?.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
         }
         return rebased;
     }
     getSlideToSegment(lref) {
-        var _a, _b;
         if (!this.client) {
             throw new LoggingError("client does not exist");
         }
         const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
-        if (((_b = (_a = segoff.segment) === null || _a === void 0 ? void 0 : _a.localRefs) === null || _b === void 0 ? void 0 : _b.has(lref)) !== true) {
+        if (segoff.segment?.localRefs?.has(lref) !== true) {
             return undefined;
         }
-        const newSegoff = this.client.getSlideToSegment(segoff);
+        const newSegoff = getSlideToSegoff(segoff);
         const value = segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
             ? undefined
             : newSegoff;
@@ -1623,7 +813,6 @@ export class IntervalCollection extends TypedEventEmitter {
         lref.refType = refType;
     }
     ackInterval(interval, op) {
-        var _a, _b;
         // Only SequenceIntervals need potential sliding
         if (!(interval instanceof SequenceInterval)) {
             return;
@@ -1668,7 +857,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 // remove and rebuild start interval as transient for event
                 this.client.removeLocalReferencePosition(oldInterval.start);
                 oldInterval.start.refType = ReferenceType.Transient;
-                (_a = oldSeg === null || oldSeg === void 0 ? void 0 : oldSeg.localRefs) === null || _a === void 0 ? void 0 : _a.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
+                oldSeg?.localRefs?.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
@@ -1680,19 +869,18 @@ export class IntervalCollection extends TypedEventEmitter {
                 const oldSeg = oldInterval.end.getSegment();
                 this.client.removeLocalReferencePosition(oldInterval.end);
                 oldInterval.end.refType = ReferenceType.Transient;
-                (_b = oldSeg === null || oldSeg === void 0 ? void 0 : oldSeg.localRefs) === null || _b === void 0 ? void 0 : _b.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
+                oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
-            this.emitChange(interval, oldInterval, true, op);
+            this.emitChange(interval, oldInterval, true, true, op);
         }
     }
     /** @internal */
     ackAdd(serializedInterval, local, op, localOpMetadata) {
-        var _a;
         if (local) {
             assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
-            const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+            const id = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
             if (localInterval) {
                 this.ackInterval(localInterval, op);
@@ -1828,9 +1016,8 @@ export class IntervalCollection extends TypedEventEmitter {
  * endpoint is a part of.
  */
 export function intervalLocatorFromEndpoint(potentialEndpoint) {
-    var _a;
-    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = (_a = potentialEndpoint.properties) !== null && _a !== void 0 ? _a : {};
-    return interval && (collectionNameArray === null || collectionNameArray === void 0 ? void 0 : collectionNameArray.length) === 1
+    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
+    return interval && collectionNameArray?.length === 1
         ? { label: collectionNameArray[0], interval }
         : undefined;
 }