@fluidframework/sequence 2.0.0-internal.8.0.1 → 2.0.0-rc.1.0.0

package/lib/{intervalCollection.js → intervalCollection.mjs}

@@ -1,50 +1,44 @@
-"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.computeStickinessFromSide = exports.endpointPosAndSide = exports.sidesFromStickiness = exports.Side = void 0;
-/* eslint-disable no-bitwise */
-/* eslint-disable import/no-deprecated */
-const client_utils_1 = require("@fluid-internal/client-utils");
-const core_utils_1 = require("@fluidframework/core-utils");
-const merge_tree_1 = require("@fluidframework/merge-tree");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
-const uuid_1 = require("uuid");
-const intervals_1 = require("./intervals");
-const intervalIndex_1 = require("./intervalIndex");
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { addProperties, createMap, getSlideToSegoff, MergeTreeDeltaType, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, DetachedReferencePosition, UniversalSequenceNumber, SlidingPreference, } from "@fluidframework/merge-tree";
+import { LoggingError, UsageError } from "@fluidframework/telemetry-utils";
+import { v4 as uuid } from "uuid";
+import { IntervalOpType, IntervalStickiness, IntervalType, SequenceInterval, createPositionReferenceFromSegoff, endReferenceSlidingPreference, startReferenceSlidingPreference, sequenceIntervalHelpers, createInterval, IntervalDeltaOpType, } from "./intervals/index.mjs";
+import { EndpointIndex, OverlappingIntervalsIndex, createIdIntervalIndex, } from "./intervalIndex/index.mjs";
 /**
  * Defines a side relative to a character in a sequence.
  *
  * @remarks See {@link SequencePlace} for additional context on usage.
  * @alpha
  */
-var Side;
+export var Side;
 (function (Side) {
     Side[Side["Before"] = 0] = "Before";
     Side[Side["After"] = 1] = "After";
-})(Side || (exports.Side = Side = {}));
+})(Side || (Side = {}));
 const reservedIntervalIdKey = "intervalId";
-function sidesFromStickiness(stickiness) {
-    const startSide = (stickiness & intervals_1.IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
-    const endSide = (stickiness & intervals_1.IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
+export function sidesFromStickiness(stickiness) {
+    const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
+    const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
     return { startSide, endSide };
 }
-exports.sidesFromStickiness = sidesFromStickiness;
 /**
  * Decompress an interval after loading a summary from JSON. The exact format
  * of this compression is unspecified and subject to change
  */
 function decompressInterval(interval, label) {
-    const stickiness = interval[5] ?? intervals_1.IntervalStickiness.END;
+    const stickiness = interval[5] ?? IntervalStickiness.END;
     const { startSide, endSide } = sidesFromStickiness(stickiness);
     return {
         start: interval[0],
         end: interval[1],
         sequenceNumber: interval[2],
         intervalType: interval[3],
-        properties: { ...interval[4], [merge_tree_1.reservedRangeLabelsKey]: [label] },
+        properties: { ...interval[4], [reservedRangeLabelsKey]: [label] },
         stickiness,
         startSide,
         endSide,
@@ -63,15 +57,15 @@ function compressInterval(interval) {
         intervalType,
         // remove the `referenceRangeLabels` property as it is already stored
         // in the `label` field of the summary
-        { ...properties, [merge_tree_1.reservedRangeLabelsKey]: undefined },
+        { ...properties, [reservedRangeLabelsKey]: undefined },
     ];
-    if (interval.stickiness !== undefined && interval.stickiness !== intervals_1.IntervalStickiness.END) {
+    if (interval.stickiness !== undefined && interval.stickiness !== IntervalStickiness.END) {
         // reassignment to make it easier for typescript to reason about types
         base = [...base, interval.stickiness];
     }
     return base;
 }
-function endpointPosAndSide(start, end) {
+export function endpointPosAndSide(start, end) {
     const startIsPlainEndpoint = typeof start === "number" || start === "start" || start === "end";
     const endIsPlainEndpoint = typeof end === "number" || end === "start" || end === "end";
     const startSide = startIsPlainEndpoint ? Side.Before : start?.side;
@@ -85,33 +79,30 @@ function endpointPosAndSide(start, end) {
         endPos,
     };
 }
-exports.endpointPosAndSide = endpointPosAndSide;
 function toSequencePlace(pos, side) {
     return typeof pos === "number" ? { pos, side } : pos;
 }
 function toOptionalSequencePlace(pos, side = Side.Before) {
     return typeof pos === "number" ? { pos, side } : pos;
 }
-function computeStickinessFromSide(startPos = -1, startSide = Side.Before, endPos = -1, endSide = Side.Before) {
-    let stickiness = intervals_1.IntervalStickiness.NONE;
+export function computeStickinessFromSide(startPos = -1, startSide = Side.Before, endPos = -1, endSide = Side.Before) {
+    let stickiness = IntervalStickiness.NONE;
     if (startSide === Side.After || startPos === "start") {
-        stickiness |= intervals_1.IntervalStickiness.START;
+        stickiness |= IntervalStickiness.START;
     }
     if (endSide === Side.Before || endPos === "end") {
-        stickiness |= intervals_1.IntervalStickiness.END;
+        stickiness |= IntervalStickiness.END;
     }
     return stickiness;
 }
-exports.computeStickinessFromSide = computeStickinessFromSide;
-function createIntervalIndex() {
+export function createIntervalIndex() {
     const helpers = {
-        create: intervals_1.createInterval,
+        create: createInterval,
     };
     const lc = new LocalIntervalCollection(undefined, "", helpers, {});
     return lc;
 }
-exports.createIntervalIndex = createIntervalIndex;
-class LocalIntervalCollection {
+export class LocalIntervalCollection {
     constructor(client, label, helpers, options, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
     onPositionChange) {
@@ -120,9 +111,9 @@ class LocalIntervalCollection {
         this.helpers = helpers;
         this.options = options;
         this.onPositionChange = onPositionChange;
-        this.overlappingIntervalsIndex = new intervalIndex_1.OverlappingIntervalsIndex(client, helpers);
-        this.idIntervalIndex = (0, intervalIndex_1.createIdIntervalIndex)();
-        this.endIntervalIndex = new intervalIndex_1.EndpointIndex(client, helpers);
+        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
+        this.idIntervalIndex = createIdIntervalIndex();
+        this.endIntervalIndex = new EndpointIndex(client, helpers);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -151,7 +142,7 @@ class LocalIntervalCollection {
             const newProps = {
                 [reservedIntervalIdKey]: id,
             };
-            serializedInterval.properties = (0, merge_tree_1.addProperties)(serializedInterval.properties, newProps);
+            serializedInterval.properties = addProperties(serializedInterval.properties, newProps);
         }
         // Make the ID immutable for safety's sake.
         Object.defineProperty(serializedInterval.properties, reservedIntervalIdKey, {
@@ -184,25 +175,25 @@ class LocalIntervalCollection {
         const interval = this.createInterval(start, end, intervalType, op);
         if (interval) {
             if (!interval.properties) {
-                interval.properties = (0, merge_tree_1.createMap)();
+                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[merge_tree_1.reservedRangeLabelsKey] !== undefined &&
-                    props[merge_tree_1.reservedRangeLabelsKey][0] !== this.label) {
-                    throw new telemetry_utils_1.LoggingError("Adding an interval that belongs to another interval collection is not permitted");
+                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 = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = (0, uuid_1.v4)());
+            (_a = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = uuid());
             this.add(interval);
         }
         return interval;
     }
     linkEndpointsToInterval(interval) {
-        if (interval instanceof intervals_1.SequenceInterval) {
+        if (interval instanceof SequenceInterval) {
             interval.start.addProperties({ interval });
             interval.end.addProperties({ interval });
         }
@@ -241,9 +232,9 @@ class LocalIntervalCollection {
                 // either, so this must be special-cased.
                 return ref;
             }
-            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
+            return this.client.createLocalReferencePosition(segment, ref.getOffset(), ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
         };
-        if (interval instanceof intervals_1.SequenceInterval) {
+        if (interval instanceof SequenceInterval) {
             let previousInterval;
             let pendingChanges = 0;
             interval.addPositionChangeListeners(() => {
@@ -256,7 +247,7 @@ class LocalIntervalCollection {
                     this.removeIntervalFromIndexes(interval);
                 }
             }, () => {
-                (0, core_utils_1.assert)(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
+                assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
                 pendingChanges--;
                 if (pendingChanges === 0) {
                     this.addIntervalToIndexes(interval);
@@ -267,22 +258,21 @@ class LocalIntervalCollection {
         }
     }
     removeIntervalListeners(interval) {
-        if (interval instanceof intervals_1.SequenceInterval) {
+        if (interval instanceof SequenceInterval) {
             interval.removePositionChangeListeners();
         }
     }
 }
-exports.LocalIntervalCollection = LocalIntervalCollection;
 LocalIntervalCollection.legacyIdPrefix = "legacy";
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = [], options) {
-        return new IntervalCollection(intervals_1.sequenceIntervalHelpers, true, emitter, raw, options);
+        return new IntervalCollection(sequenceIntervalHelpers, true, emitter, raw, options);
     }
     store(value) {
         return value.serializeInternal();
     }
 }
-class SequenceIntervalCollectionValueType {
+export class SequenceIntervalCollectionValueType {
     get name() {
         return SequenceIntervalCollectionValueType.Name;
     }
@@ -293,14 +283,13 @@ class SequenceIntervalCollectionValueType {
         return SequenceIntervalCollectionValueType._ops;
     }
 }
-exports.SequenceIntervalCollectionValueType = SequenceIntervalCollectionValueType;
 SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
 class IntervalCollectionFactory {
     load(emitter, raw = [], options) {
         const helpers = {
-            create: intervals_1.createInterval,
+            create: createInterval,
         };
         const collection = new IntervalCollection(helpers, false, emitter, raw, options);
         collection.attachGraph(undefined, "");
@@ -310,7 +299,7 @@ class IntervalCollectionFactory {
         return value.serializeInternal();
     }
 }
-class IntervalCollectionValueType {
+export class IntervalCollectionValueType {
     get name() {
         return IntervalCollectionValueType.Name;
     }
@@ -321,11 +310,10 @@ class IntervalCollectionValueType {
         return IntervalCollectionValueType._ops;
     }
 }
-exports.IntervalCollectionValueType = IntervalCollectionValueType;
 IntervalCollectionValueType.Name = "sharedIntervalCollection";
 IntervalCollectionValueType._factory = new IntervalCollectionFactory();
 IntervalCollectionValueType._ops = makeOpsMap();
-function makeOpsMap() {
+export function makeOpsMap() {
     const rebase = (collection, op, localOpMetadata) => {
         const { localSeq } = localOpMetadata;
         const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
@@ -335,9 +323,12 @@ function makeOpsMap() {
         const rebasedOp = { ...op, value: rebasedValue };
         return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
     };
+    const applyStashedOp = (collection, op) => {
+        return collection.applyStashedOp(op);
+    };
     return new Map([
         [
-            intervals_1.IntervalOpType.ADD,
+            IntervalOpType.ADD,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -345,27 +336,29 @@ function makeOpsMap() {
                     if (!params) {
                         return;
                     }
-                    (0, core_utils_1.assert)(op !== undefined, 0x3fb /* op should exist here */);
+                    assert(op !== undefined, 0x3fb /* op should exist here */);
                     collection.ackAdd(params, local, op, localOpMetadata);
                 },
                 rebase,
+                applyStashedOp,
             },
         ],
         [
-            intervals_1.IntervalOpType.DELETE,
+            IntervalOpType.DELETE,
             {
                 process: (collection, params, local, op) => {
-                    (0, core_utils_1.assert)(op !== undefined, 0x3fc /* op should exist here */);
+                    assert(op !== undefined, 0x3fc /* op should exist here */);
                     collection.ackDelete(params, local, op);
                 },
                 rebase: (collection, op, localOpMetadata) => {
                     // Deletion of intervals is based on id, so requires no rebasing.
                     return { rebasedOp: op, rebasedLocalOpMetadata: localOpMetadata };
                 },
+                applyStashedOp,
             },
         ],
         [
-            intervals_1.IntervalOpType.CHANGE,
+            IntervalOpType.CHANGE,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -373,15 +366,15 @@ function makeOpsMap() {
                     if (!params) {
                         return;
                     }
-                    (0, core_utils_1.assert)(op !== undefined, 0x3fd /* op should exist here */);
+                    assert(op !== undefined, 0x3fd /* op should exist here */);
                     collection.ackChange(params, local, op, localOpMetadata);
                 },
                 rebase,
+                applyStashedOp,
             },
         ],
     ]);
 }
-exports.makeOpsMap = makeOpsMap;
 class IntervalCollectionIterator {
     constructor(collection, iteratesForward = true, start, end) {
         this.results = [];
@@ -401,15 +394,10 @@ class IntervalCollectionIterator {
         };
     }
 }
-// solely for type checking in the implementation of add - will be removed once
-// deprecated signatures are removed
-const isSequencePlace = (place) => {
-    return typeof place === "number" || typeof place === "string" || place.pos !== undefined;
-};
 /**
  * {@inheritdoc IIntervalCollection}
  */
-class IntervalCollection extends client_utils_1.TypedEventEmitter {
+export class IntervalCollection extends TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
@@ -433,7 +421,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     attachIndex(index) {
         if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+            throw new LoggingError("The local interval collection must exist");
         }
         for (const interval of this) {
             index.add(interval);
@@ -445,7 +433,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     detachIndex(index) {
         if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
+            throw new LoggingError("The local interval collection must exist");
         }
         // Avoid removing intervals if the index does not exist
         if (!this.localCollection?.removeIndex(index)) {
@@ -458,7 +446,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         if (!this.client) {
-            throw new telemetry_utils_1.LoggingError("mergeTree client must exist");
+            throw new LoggingError("mergeTree client must exist");
         }
         if (pos === "start" || pos === "end") {
             return pos;
@@ -469,19 +457,19 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             clientId: this.client.getLongClientId(clientId),
         }, localSeq);
         // if segment is undefined, it slid off the string
-        (0, core_utils_1.assert)(segment !== undefined, 0x54e /* No segment found */);
-        const segoff = (0, merge_tree_1.getSlideToSegoff)({ segment, offset }, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
+        assert(segment !== undefined, 0x54e /* No segment found */);
+        const segoff = getSlideToSegoff({ segment, offset }, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
         // case happens when rebasing op, but concurrently entire string has been deleted
         if (segoff.segment === undefined || segoff.offset === undefined) {
-            return merge_tree_1.DetachedReferencePosition;
+            return DetachedReferencePosition;
         }
-        (0, core_utils_1.assert)(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
+        assert(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
         return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
     }
     computeRebasedPositions(localSeq) {
-        (0, core_utils_1.assert)(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
+        assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
         const original = this.localSeqToSerializedInterval.get(localSeq);
-        (0, core_utils_1.assert)(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
+        assert(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
         const rebased = { ...original };
         const { start, end, sequenceNumber } = original;
         if (start !== undefined) {
@@ -495,10 +483,10 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     /** @internal */
     attachGraph(client, label) {
         if (this.attached) {
-            throw new telemetry_utils_1.LoggingError("Only supports one Sequence attach");
+            throw new LoggingError("Only supports one Sequence attach");
         }
         if (client === undefined && this.requiresClient) {
-            throw new telemetry_utils_1.LoggingError("Client required for this collection");
+            throw new LoggingError("Client required for this collection");
         }
         // Instantiate the local interval collection based on the saved intervals
         this.client = client;
@@ -544,11 +532,11 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         // is restored as single-endpoint changes re-use previous references.
         let startRefType;
         let endRefType;
-        if (previousInterval instanceof intervals_1.SequenceInterval) {
+        if (previousInterval instanceof SequenceInterval) {
             startRefType = previousInterval.start.refType;
             endRefType = previousInterval.end.refType;
-            previousInterval.start.refType = merge_tree_1.ReferenceType.Transient;
-            previousInterval.end.refType = merge_tree_1.ReferenceType.Transient;
+            previousInterval.start.refType = ReferenceType.Transient;
+            previousInterval.end.refType = ReferenceType.Transient;
             this.emit("changeInterval", interval, previousInterval, local, op, slide);
             previousInterval.start.refType = startRefType;
             previousInterval.end.refType = endRefType;
@@ -562,58 +550,40 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     getIntervalById(id) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attach must be called before accessing intervals");
+            throw new LoggingError("attach must be called before accessing intervals");
         }
         return this.localCollection.idIntervalIndex.getIntervalById(id);
     }
     assertStickinessEnabled(start, end) {
         if (!(typeof start === "number" && typeof end === "number") &&
             !this.options.intervalStickinessEnabled) {
-            throw new telemetry_utils_1.UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
-        }
-    }
-    add(start, end, intervalType, props) {
-        let intStart;
-        let intEnd;
-        let type;
-        let properties;
-        if (isSequencePlace(start)) {
-            intStart = start;
-            (0, core_utils_1.assert)(end !== undefined, 0x7c0 /* end must be defined */);
-            intEnd = end;
-            (0, core_utils_1.assert)(intervalType !== undefined, 0x7c1 /* intervalType must be defined */);
-            type = intervalType;
-            properties = props;
-        }
-        else {
-            intStart = start.start;
-            intEnd = start.end;
-            type = intervals_1.IntervalType.SlideOnRemove;
-            properties = start.props;
+            throw new UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
         }
+    }
+    /**
+     * {@inheritdoc IIntervalCollection.add}
+     */
+    add({ start, end, props, }) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attach must be called prior to adding intervals");
+            throw new LoggingError("attach must be called prior to adding intervals");
         }
-        if (type & intervals_1.IntervalType.Transient) {
-            throw new telemetry_utils_1.LoggingError("Can not add transient intervals");
-        }
-        const { startSide, endSide, startPos, endPos } = endpointPosAndSide(intStart, intEnd);
-        (0, core_utils_1.assert)(startPos !== undefined &&
+        const { startSide, endSide, startPos, endPos } = endpointPosAndSide(start, end);
+        assert(startPos !== undefined &&
             endPos !== undefined &&
             startSide !== undefined &&
             endSide !== undefined, 0x793 /* start and end cannot be undefined because they were not passed in as undefined */);
         const stickiness = computeStickinessFromSide(startPos, startSide, endPos, endSide);
-        this.assertStickinessEnabled(intStart, intEnd);
-        const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), type, properties);
+        this.assertStickinessEnabled(start, end);
+        const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), IntervalType.SlideOnRemove, props);
         if (interval) {
-            if (!this.isCollaborating && interval instanceof intervals_1.SequenceInterval) {
+            if (!this.isCollaborating && interval instanceof SequenceInterval) {
                 setSlideOnRemove(interval.start);
                 setSlideOnRemove(interval.end);
             }
             const serializedInterval = {
                 start: startPos,
                 end: endPos,
-                intervalType: type,
+                intervalType: IntervalType.SlideOnRemove,
                 properties: interval.properties,
                 sequenceNumber: this.client?.getCurrentSeq() ?? 0,
                 stickiness,
@@ -630,7 +600,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     }
     deleteExistingInterval(interval, local, op) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
+            throw new LoggingError("Attach must be called before accessing intervals");
         }
         // The given interval is known to exist in the collection.
         this.localCollection.removeExistingInterval(interval);
@@ -654,7 +624,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     removeIntervalById(id) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
+            throw new LoggingError("Attach must be called before accessing intervals");
         }
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
@@ -663,52 +633,35 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         return interval;
     }
     /**
-     * {@inheritdoc IIntervalCollection.changeProperties}
-     * @deprecated - call change with the id and an object containing the new props values
+     * {@inheritdoc IIntervalCollection.change}
      */
-    changeProperties(id, props) {
-        this.change(id, { props });
-    }
-    change(arg1, arg2, arg3) {
-        const id = arg1;
-        let start;
-        let end;
-        let props;
-        if (isSequencePlace(arg2)) {
-            start = arg2;
-            end = arg3;
-        }
-        else {
-            start = arg2.start;
-            end = arg2.end;
-            props = arg2.props;
-        }
+    change(id, { start, end, props }) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
+            throw new LoggingError("Attach must be called before accessing intervals");
         }
         // Force id to be a string.
         if (typeof id !== "string") {
-            throw new telemetry_utils_1.UsageError("Change API requires an ID that is a string");
+            throw new UsageError("Change API requires an ID that is a string");
         }
         // Ensure that both start and end are defined or both are undefined.
         if ((start === undefined) !== (end === undefined)) {
-            throw new telemetry_utils_1.UsageError("Change API requires both start and end to be defined or undefined");
+            throw new UsageError("Change API requires both start and end to be defined or undefined");
         }
         // prevent the overwriting of an interval label, it should remain unchanged
         // once it has been inserted into the collection.
-        if (props?.[merge_tree_1.reservedRangeLabelsKey] !== undefined) {
-            throw new telemetry_utils_1.UsageError("The label property should not be modified once inserted to the collection");
+        if (props?.[reservedRangeLabelsKey] !== undefined) {
+            throw new UsageError("The label property should not be modified once inserted to the collection");
         }
         const interval = this.getIntervalById(id);
         if (interval) {
             let deltaProps;
             let newInterval;
             if (props !== undefined) {
-                deltaProps = interval.addProperties(props, true, this.isCollaborating ? merge_tree_1.UnassignedSequenceNumber : merge_tree_1.UniversalSequenceNumber);
+                deltaProps = interval.addProperties(props, true, this.isCollaborating ? UnassignedSequenceNumber : UniversalSequenceNumber);
             }
             if (start !== undefined && end !== undefined) {
                 newInterval = this.localCollection.changeInterval(interval, start, end);
-                if (!this.isCollaborating && newInterval instanceof intervals_1.SequenceInterval) {
+                if (!this.isCollaborating && newInterval instanceof SequenceInterval) {
                     setSlideOnRemove(newInterval.start);
                     setSlideOnRemove(newInterval.end);
                 }
@@ -782,7 +735,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             }
             if (pendingChange?.start !== serializedInterval.start ||
                 pendingChange?.end !== serializedInterval.end) {
-                throw new telemetry_utils_1.LoggingError("Mismatch in pending changes");
+                throw new LoggingError("Mismatch in pending changes");
             }
         }
     }
@@ -797,10 +750,10 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     /** @internal */
     ackChange(serializedInterval, local, op, localOpMetadata) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
+            throw new LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
-            (0, core_utils_1.assert)(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
+            assert(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata?.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
@@ -809,7 +762,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         // 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 { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
-        (0, core_utils_1.assert)(id !== undefined, 0x3fe /* id must exist on the interval */);
+        assert(id !== undefined, 0x3fe /* id must exist on the interval */);
         const interval = this.getIntervalById(id);
         if (!interval) {
             // The interval has been removed locally; no-op.
@@ -818,7 +771,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         if (local) {
             // Let the propertyManager prune its pending change-properties set.
             interval.propertyManager?.ackPendingProperties({
-                type: merge_tree_1.MergeTreeDeltaType.ANNOTATE,
+                type: MergeTreeDeltaType.ANNOTATE,
                 props: serializedInterval.properties ?? {},
             });
             this.ackInterval(interval, op);
@@ -883,7 +836,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             return serializedInterval;
         }
         if (!this.attached) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         const { intervalType, properties, stickiness, startSide, endSide } = serializedInterval;
         const { start: startRebased, end: endRebased } = this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
@@ -906,8 +859,8 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             this.addPendingChange(intervalId, rebased);
         }
         // if the interval slid off the string, rebase the op to be a noop and delete the interval.
-        if (startRebased === merge_tree_1.DetachedReferencePosition ||
-            endRebased === merge_tree_1.DetachedReferencePosition) {
+        if (startRebased === DetachedReferencePosition ||
+            endRebased === DetachedReferencePosition) {
             if (localInterval) {
                 this.localCollection?.removeExistingInterval(localInterval);
             }
@@ -915,22 +868,68 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         }
         if (localInterval !== undefined) {
             // we know we must be using `SequenceInterval` because `this.client` exists
-            (0, core_utils_1.assert)(localInterval instanceof intervals_1.SequenceInterval, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
+            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.
             this.localCollection?.changeInterval(localInterval, toOptionalSequencePlace(startRebased, startSide), toOptionalSequencePlace(endRebased, endSide), undefined, localSeq);
         }
         return rebased;
     }
+    applyStashedOp(op) {
+        let interval;
+        let props;
+        let intervalId;
+        switch (op.opName) {
+            case IntervalDeltaOpType.ADD: {
+                assert(op.value.start !== undefined, 0x87a /* start is undefined */);
+                assert(op.value.end !== undefined, 0x87b /* end is undefined */);
+                interval = this.add({
+                    start: op.value.start,
+                    end: op.value.end,
+                    props: op.value.properties,
+                });
+                const metadata = {
+                    localSeq: this.getNextLocalSeq(),
+                };
+                if (interval !== undefined) {
+                    this.localSeqToSerializedInterval.set(metadata.localSeq, interval.serialize());
+                }
+                return metadata;
+            }
+            case IntervalDeltaOpType.DELETE:
+                this.removeIntervalById(op.value.properties?.intervalId);
+                return {
+                    localSeq: this.getNextLocalSeq(),
+                };
+            case IntervalDeltaOpType.CHANGE: {
+                assert(op.value.properties !== undefined, 0x87c /* properties is undefined */);
+                ({ intervalId, ...props } = op.value.properties);
+                interval = this.change(intervalId, {
+                    start: op.value.start,
+                    end: op.value.end,
+                    props,
+                });
+                const metadata = {
+                    localSeq: this.getNextLocalSeq(),
+                };
+                if (interval !== undefined) {
+                    this.localSeqToSerializedInterval.set(metadata.localSeq, interval.serialize());
+                }
+                return metadata;
+            }
+            default:
+                unreachableCase(op.opName, `Unknown interval op type: ${op.opName}`);
+        }
+    }
     getSlideToSegment(lref) {
         if (!this.client) {
-            throw new telemetry_utils_1.LoggingError("client does not exist");
+            throw new LoggingError("client does not exist");
         }
         const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
         if (segoff.segment?.localRefs?.has(lref) !== true) {
             return undefined;
         }
-        const newSegoff = (0, merge_tree_1.getSlideToSegoff)(segoff, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
+        const newSegoff = getSlideToSegoff(segoff, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
         const value = segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
             ? undefined
             : newSegoff;
@@ -938,11 +937,11 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     }
     ackInterval(interval, op) {
         // Only SequenceIntervals need potential sliding
-        if (!(interval instanceof intervals_1.SequenceInterval)) {
+        if (!(interval instanceof SequenceInterval)) {
             return;
         }
-        if (!(0, merge_tree_1.refTypeIncludesFlag)(interval.start, merge_tree_1.ReferenceType.StayOnRemove) &&
-            !(0, merge_tree_1.refTypeIncludesFlag)(interval.end, merge_tree_1.ReferenceType.StayOnRemove)) {
+        if (!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove) &&
+            !refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove)) {
             return;
         }
         const newStart = this.getSlideToSegment(interval.start);
@@ -960,7 +959,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
         const needsEndUpdate = newEnd !== undefined && !hasPendingEndChange;
         if (needsStartUpdate || needsEndUpdate) {
             if (!this.localCollection) {
-                throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
+                throw new LoggingError("Attach must be called before accessing intervals");
             }
             // `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
             const oldInterval = interval.clone();
@@ -969,32 +968,32 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             // This ensures that the correct listeners are added to the LocalReferencePosition.
             this.localCollection.removeExistingInterval(interval);
             if (!this.client) {
-                throw new telemetry_utils_1.LoggingError("client does not exist");
+                throw new LoggingError("client does not exist");
             }
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                interval.start = (0, intervals_1.createPositionReferenceFromSegoff)(this.client, newStart, interval.start.refType, op, undefined, undefined, (0, intervals_1.startReferenceSlidingPreference)(interval.stickiness), (0, intervals_1.startReferenceSlidingPreference)(interval.stickiness) ===
-                    merge_tree_1.SlidingPreference.BACKWARD);
+                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op, undefined, undefined, startReferenceSlidingPreference(interval.stickiness), startReferenceSlidingPreference(interval.stickiness) ===
+                    SlidingPreference.BACKWARD);
                 if (props) {
                     interval.start.addProperties(props);
                 }
                 const oldSeg = oldInterval.start.getSegment();
                 // remove and rebuild start interval as transient for event
                 this.client.removeLocalReferencePosition(oldInterval.start);
-                oldInterval.start.refType = merge_tree_1.ReferenceType.Transient;
+                oldInterval.start.refType = ReferenceType.Transient;
                 oldSeg?.localRefs?.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                interval.end = (0, intervals_1.createPositionReferenceFromSegoff)(this.client, newEnd, interval.end.refType, op, undefined, undefined, (0, intervals_1.endReferenceSlidingPreference)(interval.stickiness), (0, intervals_1.endReferenceSlidingPreference)(interval.stickiness) ===
-                    merge_tree_1.SlidingPreference.FORWARD);
+                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op, undefined, undefined, endReferenceSlidingPreference(interval.stickiness), endReferenceSlidingPreference(interval.stickiness) ===
+                    SlidingPreference.FORWARD);
                 if (props) {
                     interval.end.addProperties(props);
                 }
                 // remove and rebuild end interval as transient for event
                 const oldSeg = oldInterval.end.getSegment();
                 this.client.removeLocalReferencePosition(oldInterval.end);
-                oldInterval.end.refType = merge_tree_1.ReferenceType.Transient;
+                oldInterval.end.refType = ReferenceType.Transient;
                 oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
@@ -1004,7 +1003,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
     /** @internal */
     ackAdd(serializedInterval, local, op, localOpMetadata) {
         if (local) {
-            (0, core_utils_1.assert)(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
+            assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
             const id = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
@@ -1014,7 +1013,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             return;
         }
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         this.localCollection.ensureSerializedId(serializedInterval);
         const interval = this.localCollection.addInterval(toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before), toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before), serializedInterval.intervalType, serializedInterval.properties, op);
@@ -1035,7 +1034,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
             return;
         }
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attach must be called prior to deleting intervals");
+            throw new LoggingError("attach must be called prior to deleting intervals");
         }
         const id = this.localCollection.ensureSerializedId(serializedInterval);
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
@@ -1048,7 +1047,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     serializeInternal() {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         return this.localCollection.serialize();
     }
@@ -1101,7 +1100,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     findOverlappingIntervals(startPosition, endPosition) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         return this.localCollection.overlappingIntervalsIndex.findOverlappingIntervals(startPosition, endPosition);
     }
@@ -1110,7 +1109,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     map(fn) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         for (const interval of this.localCollection.idIntervalIndex) {
             fn(interval);
@@ -1121,7 +1120,7 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     previousInterval(pos) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.previousInterval(pos);
     }
@@ -1130,16 +1129,15 @@ class IntervalCollection extends client_utils_1.TypedEventEmitter {
      */
     nextInterval(pos) {
         if (!this.localCollection) {
-            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
+            throw new LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.nextInterval(pos);
     }
 }
-exports.IntervalCollection = IntervalCollection;
 function setSlideOnRemove(lref) {
     let refType = lref.refType;
-    refType = refType & ~merge_tree_1.ReferenceType.StayOnRemove;
-    refType = refType | merge_tree_1.ReferenceType.SlideOnRemove;
+    refType = refType & ~ReferenceType.StayOnRemove;
+    refType = refType | ReferenceType.SlideOnRemove;
     lref.refType = refType;
 }
 /**
@@ -1149,11 +1147,10 @@ function setSlideOnRemove(lref) {
  * endpoint is a part of.
  * @internal
  */
-function intervalLocatorFromEndpoint(potentialEndpoint) {
-    const { interval, [merge_tree_1.reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
+export function intervalLocatorFromEndpoint(potentialEndpoint) {
+    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
     return interval && collectionNameArray?.length === 1
         ? { label: collectionNameArray[0], interval }
         : undefined;
 }
-exports.intervalLocatorFromEndpoint = intervalLocatorFromEndpoint;
-//# sourceMappingURL=intervalCollection.js.map
+//# sourceMappingURL=intervalCollection.mjs.map