@fluidframework/sequence 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/.eslintrc.js

@@ -4,15 +4,12 @@
  */
 
 module.exports = {
-    "extends": [
-        require.resolve("@fluidframework/eslint-config-fluid/minimal"),
-        "prettier"
-    ],
-    "parserOptions": {
-        "project": ["./tsconfig.json", "./src/test/tsconfig.json"]
-    },
-    "rules": {
-        "@typescript-eslint/no-use-before-define": "off",
-        "@typescript-eslint/strict-boolean-expressions": "off"
-    }
-}
+	extends: [require.resolve("@fluidframework/eslint-config-fluid/minimal"), "prettier"],
+	parserOptions: {
+		project: ["./tsconfig.json", "./src/test/tsconfig.json"],
+	},
+	rules: {
+		"@typescript-eslint/no-use-before-define": "off",
+		"@typescript-eslint/strict-boolean-expressions": "off",
+	},
+};

package/.mocharc.js

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-'use strict';
+"use strict";
 
-const getFluidTestMochaConfig = require('@fluidframework/mocha-test-setup/mocharc-common');
+const getFluidTestMochaConfig = require("@fluidframework/mocha-test-setup/mocharc-common");
 
 const packageDir = __dirname;
 const config = getFluidTestMochaConfig(packageDir);

package/.vscode/launch.json

@@ -1,15 +1,16 @@
 {
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Sequence Test",
-            "type": "node",
-            "request": "launch",
-            "program": "${workspaceRoot}/../../../node_modules/mocha/bin/_mocha",
-            "args": ["dist/test", "--no-timeouts", "--exit"],
-            "cwd": "${workspaceRoot}",        }
-    ]
-}
+	// Use IntelliSense to learn about possible attributes.
+	// Hover to view descriptions of existing attributes.
+	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+	"version": "0.2.0",
+	"configurations": [
+		{
+			"name": "Sequence Test",
+			"type": "node",
+			"request": "launch",
+			"program": "${workspaceRoot}/../../../node_modules/mocha/bin/_mocha",
+			"args": ["dist/test", "--no-timeouts", "--exit"],
+			"cwd": "${workspaceRoot}"
+		}
+	]
+}

package/README.md

@@ -6,20 +6,20 @@ Its main export is [SharedString][], a DDS for storing and simultaneously editin
 Note that SharedString is a sequence DDS but it has additional specialized features and behaviors for working with text.
 
 This package historically contained several other sequence-based DDSes, but because they have unintuitive behaviors,
-they are deprecated and being moved to the *experimental* folder.
+they are deprecated and being moved to the _experimental_ folder.
 
-The main reason for this is the lack of *move* semantics within the sequence, which becomes crucial when dealing with sequences of
+The main reason for this is the lack of _move_ semantics within the sequence, which becomes crucial when dealing with sequences of
 complex content.
 For that reason, all of the examples in this README use `SharedString`. However, the APIs discussed are available on the common base class: `SharedSegmentSequence`.
 
-For the remainder of this document, the term *sequence* will refer to this base class.
+For the remainder of this document, the term _sequence_ will refer to this base class.
 
 *Item*s are the individual units that are stored within the sequence (e.g. in a SharedString, the items are characters),
-but regardless of the type of data stored in the sequence, every item in a sequence is at a specific *position* starting
+but regardless of the type of data stored in the sequence, every item in a sequence is at a specific _position_ starting
 at 0, similar to an array. However, sequences differ from arrays in that the positions can move as local and remote
 editors make modifications to the sequence.
 
-As its name suggests, SharedSegmentSequence is composed of *segments*. Segments are the unit that the sequence works
+As its name suggests, SharedSegmentSequence is composed of _segments_. Segments are the unit that the sequence works
 with internally, and contain items within them. Thus, every segment has a length of at least 1 -- that is, it contains
 at least one item -- and segments may be split and merged arbitrarily as the sequence is edited. This means the length
 of the sequence is not the number of segments, but rather the sum of the length of all the segments.
@@ -63,49 +63,45 @@ can be any position in the sequence including 0, to insert at the beginning of t
 sequence, to insert at the end.
 
 ```typescript
-    //   content:
-    // positions:
-
-    // insert text at position 0
-    sharedString.insertText(0, "hi");
-    //   content: hi
-    // positions: 01
-
-    // insert text at the end position
-    sharedString.insertText(
-        sharedString.getLength(),
-        "!");
-    //   content: hi!
-    // positions: 012
-
-    // insert text at position 2
-    sharedString.insertText(
-        2,
-        " world");
-    //   content: hi world!
-    // positions: 012345678
+//   content:
+// positions:
+
+// insert text at position 0
+sharedString.insertText(0, "hi");
+//   content: hi
+// positions: 01
+
+// insert text at the end position
+sharedString.insertText(sharedString.getLength(), "!");
+//   content: hi!
+// positions: 012
+
+// insert text at position 2
+sharedString.insertText(2, " world");
+//   content: hi world!
+// positions: 012345678
 ```
 
 ### Remove
 
-Remove operations take a start and an end position, referred to as a *range*. The start position is inclusive and can be
+Remove operations take a start and an end position, referred to as a _range_. The start position is inclusive and can be
 any position in the sequence from 0 to its `length - 1`. The start position cannot be the length of the sequence like it
 can in insert, because there is nothing at that position. The end position is exclusive and must be greater than the
-start, so it can be any value from 1 to *n* (where *n* is the length of the sequence).
+start, so it can be any value from 1 to _n_ (where _n_ is the length of the sequence).
 
 ```typescript
-    //   content: hi world!
-    // positions: 012345678
-
-    // remove the first 3 characters
-    sharedString.removeRange(0, 3);
-    //   content: world!
-    // positions: 012345
-
-    // remove all the characters
-    sharedString.removeRange(0, sharedString.getLength());
-    //   content:
-    // positions:
+//   content: hi world!
+// positions: 012345678
+
+// remove the first 3 characters
+sharedString.removeRange(0, 3);
+//   content: world!
+// positions: 012345
+
+// remove all the characters
+sharedString.removeRange(0, sharedString.getLength());
+//   content:
+// positions:
 ```
 
 ### Annotate
@@ -117,64 +113,58 @@ also takes a map-like properties object. Each key of the provided properties obj
 specified range. Setting a property key to null will remove that property from the positions in the range.
 
 ```typescript
-    //   content: hi world
-    // positions: 01234567
-
-    let props1 = sharedString.getPropertiesAtPosition(1);
-    let props5 = sharedString.getPropertiesAtPosition(5);
-    // props1 = {}
-    // props5 = {}
-
-    // set property called weight on positions 0 and 1
-    sharedString.annotateRange(0, 2, { weight: 5 });
-    props1 = sharedString.getPropertiesAtPosition(1);
-    props5 = sharedString.getPropertiesAtPosition(5);
-    // props1 = { weight: 5 }
-    // props5 = {}
-
-    // set property called decoration on all positions
-    sharedString.annotateRange(
-        0,
-        sharedString.getLength(),
-        { decoration: "underline" });
-    props1 = sharedString.getPropertiesAtPosition(1);
-    props5 = sharedString.getPropertiesAtPosition(5);
-    // props1 = { weight: 5, decoration: "underline" }
-    // props5 = { decoration: "underline" }
-
-    // remove property called weight on all positions
-    sharedString.annotateRange(
-        0,
-        sharedString.getLength(),
-        { weight: null });
-    props1 = sharedString.getPropertiesAtPosition(1);
-    props5 = sharedString.getPropertiesAtPosition(5);
-    // props1 = { decoration: "underline" }
-    // props5 = { decoration: "underline" }
+//   content: hi world
+// positions: 01234567
+
+let props1 = sharedString.getPropertiesAtPosition(1);
+let props5 = sharedString.getPropertiesAtPosition(5);
+// props1 = {}
+// props5 = {}
+
+// set property called weight on positions 0 and 1
+sharedString.annotateRange(0, 2, { weight: 5 });
+props1 = sharedString.getPropertiesAtPosition(1);
+props5 = sharedString.getPropertiesAtPosition(5);
+// props1 = { weight: 5 }
+// props5 = {}
+
+// set property called decoration on all positions
+sharedString.annotateRange(0, sharedString.getLength(), { decoration: "underline" });
+props1 = sharedString.getPropertiesAtPosition(1);
+props5 = sharedString.getPropertiesAtPosition(5);
+// props1 = { weight: 5, decoration: "underline" }
+// props5 = { decoration: "underline" }
+
+// remove property called weight on all positions
+sharedString.annotateRange(0, sharedString.getLength(), { weight: null });
+props1 = sharedString.getPropertiesAtPosition(1);
+props5 = sharedString.getPropertiesAtPosition(5);
+// props1 = { decoration: "underline" }
+// props5 = { decoration: "underline" }
 ```
 
 ### Sequence delta event
 
-Whenever an operation is performed on a sequence a *sequenceDelta* event will be raised. This event provides the ranges
+Whenever an operation is performed on a sequence a _sequenceDelta_ event will be raised. This event provides the ranges
 affected by the operation, the type of the operation, and the properties that were changed by the operation.
 
 ```typescript
 sharedString.on("sequenceDelta", ({ deltaOperation, ranges, isLocal }) => {
-    if (isLocal) {
-        // undo-redo implementations frequently will only concern themselves with local ops: only operations submitted
-        // by the local client should be undoable by the current user
-        addOperationToUndoStack(deltaOperation, ranges);
-    }
+	if (isLocal) {
+		// undo-redo implementations frequently will only concern themselves with local ops: only operations submitted
+		// by the local client should be undoable by the current user
+		addOperationToUndoStack(deltaOperation, ranges);
+	}
 
-    if (deltaOperation === MergeTreeDeltaType.INSERT) {
-        syncInsertSegmentToModel(deltaOperation, ranges);
-    }
+	if (deltaOperation === MergeTreeDeltaType.INSERT) {
+		syncInsertSegmentToModel(deltaOperation, ranges);
+	}
 
-    // realistic app code would likely handle the other deltaOperation types as well here.
+	// realistic app code would likely handle the other deltaOperation types as well here.
 });
 ```
 
-Internally, the sequence package depends on `@fluidframework/merge-tree`, and also raises `MergeTreeMaintenance` events on that tree as *maintenance* events.
+Internally, the sequence package depends on `@fluidframework/merge-tree`, and also raises `MergeTreeMaintenance` events on that tree as _maintenance_ events.
 These events don't correspond directly to APIs invoked on a sequence DDS, but may be useful for advanced users.
 
 Both sequenceDelta and maintenance events are commonly used to synchronize or invalidate a view an application might have over a backing sequence DDS.
@@ -196,7 +186,7 @@ Consider a sequence like this:
 ```
 
 Now two users simultaneously insert characters at the end of the sequence. One inserts `k` and the other inserts a `c`.
-This is an *insert conflict*. The basic strategy for insert conflict resolution in the sequence is to merge *far*,
+This is an _insert conflict_. The basic strategy for insert conflict resolution in the sequence is to merge _far_,
 closer to the end of the sequence.
 
 This merge strategy is possible because of a fundamental property of the Fluid Framework, which is guaranteed ordering.
@@ -278,53 +268,53 @@ determine the value.
 
 ## Local references
 
-Sequences support addition and manipulation of *local references* to locally track positions in the sequence over time.
+Sequences support addition and manipulation of _local references_ to locally track positions in the sequence over time.
 As the name suggests, any created references will only exist locally; other clients will not see them.
 This can be used to implement user interactions with sequence data in a way that is robust to concurrent editing.
 For example, consider a text editor which tracks a user's cursor state.
 The application can store a local reference to the character after the cursor position:
 
 ```typescript
-    //   content: hi world!
-    // positions: 012345678
-    const { segment, offset } = sharedString.getContainingSegment(5)
-    const cursor = sharedString.createLocalReferencePosition(
-        segment,
-        offset,
-        ReferenceType.SlideOnRemove,
-        /* any additional properties */ { cursorColor: 'blue' }
-    );
-
-    //    cursor:      x
-    //   content: hi world!
-    // positions: 012345678
-
-    // ... in some view code, retrieve the position of the local reference for rendering:
-    const pos = sharedString.localReferencePositionToPosition(cursor); // 5
-
-    // meanwhile, some other client submits an edit which gets applied to our string:
-    otherSharedString.replaceText(1, 2, "ello");
-
-    // The local sharedString state will now look like this:
-    //    cursor:         x
-    //   content: hello world!
-    // positions: 0123456789AB (hex)
-
-    // ... in some view code, retrieve the position of the local reference for rendering:
-    const pos = sharedString.localReferencePositionToPosition(cursor); // 8
+//   content: hi world!
+// positions: 012345678
+const { segment, offset } = sharedString.getContainingSegment(5);
+const cursor = sharedString.createLocalReferencePosition(
+	segment,
+	offset,
+	ReferenceType.SlideOnRemove,
+	/* any additional properties */ { cursorColor: "blue" },
+);
+
+//    cursor:      x
+//   content: hi world!
+// positions: 012345678
+
+// ... in some view code, retrieve the position of the local reference for rendering:
+const pos = sharedString.localReferencePositionToPosition(cursor); // 5
+
+// meanwhile, some other client submits an edit which gets applied to our string:
+otherSharedString.replaceText(1, 2, "ello");
+
+// The local sharedString state will now look like this:
+//    cursor:         x
+//   content: hello world!
+// positions: 0123456789AB (hex)
+
+// ... in some view code, retrieve the position of the local reference for rendering:
+const pos = sharedString.localReferencePositionToPosition(cursor); // 8
 ```
 
 Notice that even though another client concurrently edited the string, the local reference representing the cursor is still in the correct location with no further work for the API consumer.
 The `ReferenceType.SlideOnRemove` parameter changes what happens when the segment that reference is associated with is removed.
-`SlideOnRemove` instructs the sequence to attempt to *slide* the reference to the start of the next furthest segment, or if no such segment exists (i.e. the end of the string has been removed), the end of the next nearest one.
+`SlideOnRemove` instructs the sequence to attempt to _slide_ the reference to the start of the next furthest segment, or if no such segment exists (i.e. the end of the string has been removed), the end of the next nearest one.
 
 The [webflow](https://github.com/microsoft/FluidFramework/blob/main/examples/data-objects/webflow/src/editor/caret.ts) example demonstrates this idea in more detail.
 
-Unlike segments, it *is* safe to persist local references in auxiliary data structures, such as an undo-redo stack.
+Unlike segments, it _is_ safe to persist local references in auxiliary data structures, such as an undo-redo stack.
 
 ## Interval collections
 
-Sequences support creation of *interval collections*, an auxiliary collection of intervals associated with positions in the sequence.
+Sequences support creation of _interval collections_, an auxiliary collection of intervals associated with positions in the sequence.
 Like segments, intervals support adding arbitrary properties, including handles (references) to other DDSes.
 The interval collection implementation uses local references, and so benefits from all of the robustness to concurrent editing
 described in the previous section.
@@ -332,47 +322,46 @@ Unlike local references, operations on interval collections are sent to all clie
 This makes them suitable for implementing features like comment threads on a text-based documents.
 The following example illustrates these properties and highlights the major APIs supported by IntervalCollection.
 
-
 ```typescript
-    //   content: hi world!
-    // positions: 012345678
-
-    const comments = sharedString.getIntervalCollection("comments");
-    const comment = comments.add(
-        3,
-        7, // (inclusive range): references "world"
-        IntervalType.SlideOnRemove,
-        {
-            creator: 'my-user-id',
-            handle: myCommentThreadDDS.handle
-        }
-    );
-    //   content: hi world!
-    // positions: 012345678
-    //   comment:    [   ]
-
-    // Interval collection supports iterating over all intervals via Symbol.iterator or `.map()`:
-    const allIntervalsInCollection = Array.from(comments);
-    const allProperties = comments.map((comment) => comment.properties);
-    // or iterating over intervals overlapping a region:
-    const intervalsOverlappingFirstHalf = comments.findOverlappingIntervals(0, 4);
-
-    // Interval endpoints are LocalReferencePositions, so all APIs in the above section can be used:
-    const startPosition = sharedString.localReferencePositionToPosition(comment.start);
-    const endPosition = sharedString.localReferencePositionToPosition(comment.end);
-
-    // Intervals can be modified:
-    comments.change(comment.getIntervalId(), 0, 1);
-    //   content: hi world!
-    // positions: 012345678
-    //   comment: []
-
-    // their properties can be changed:
-    comments.changeProperties(comment.getIntervalId(), { status: "resolved" });
-    // comment.properties === { creator: 'my-user-id', handle: <some DDS handle object>, status: "resolved" }
-
-    // and they can be removed:
-    comments.removeIntervalById(comment.getIntervalId());
+//   content: hi world!
+// positions: 012345678
+
+const comments = sharedString.getIntervalCollection("comments");
+const comment = comments.add(
+	3,
+	7, // (inclusive range): references "world"
+	IntervalType.SlideOnRemove,
+	{
+		creator: "my-user-id",
+		handle: myCommentThreadDDS.handle,
+	},
+);
+//   content: hi world!
+// positions: 012345678
+//   comment:    [   ]
+
+// Interval collection supports iterating over all intervals via Symbol.iterator or `.map()`:
+const allIntervalsInCollection = Array.from(comments);
+const allProperties = comments.map((comment) => comment.properties);
+// or iterating over intervals overlapping a region:
+const intervalsOverlappingFirstHalf = comments.findOverlappingIntervals(0, 4);
+
+// Interval endpoints are LocalReferencePositions, so all APIs in the above section can be used:
+const startPosition = sharedString.localReferencePositionToPosition(comment.start);
+const endPosition = sharedString.localReferencePositionToPosition(comment.end);
+
+// Intervals can be modified:
+comments.change(comment.getIntervalId(), 0, 1);
+//   content: hi world!
+// positions: 012345678
+//   comment: []
+
+// their properties can be changed:
+comments.changeProperties(comment.getIntervalId(), { status: "resolved" });
+// comment.properties === { creator: 'my-user-id', handle: <some DDS handle object>, status: "resolved" }
+
+// and they can be removed:
+comments.removeIntervalById(comment.getIntervalId());
 ```
 
 ## SharedString
@@ -395,22 +384,23 @@ When comparing two positions the nearer positions is closer to 0, and the farthe
 
 ### Intervals vs. markers
 
-Interval endpoints and markers both implement *ReferencePosition* and seem to serve a similar function so it's not obvious how they differ and why you would choose one or the other.
+Interval endpoints and markers both implement _ReferencePosition_ and seem to serve a similar function so it's not obvious how they differ and why you would choose one or the other.
 
 Using the interval collection API has two main benefits:
 
 1. Efficient spatial querying
+
     - Interval collections support iterating all intervals overlapping the region `[start, end]` in `O(log N) + O(overlap size)` time, where `N` is the total number of intervals in the collection.
-    This may be critical for applications that display only a small view of the document contents.
-    On the other hand, using markers to implement intervals would require a linear scan from the start or end of the sequence to determine which intervals overlap.
+      This may be critical for applications that display only a small view of the document contents.
+      On the other hand, using markers to implement intervals would require a linear scan from the start or end of the sequence to determine which intervals overlap.
 
 2. More ergonomic modification APIs
     - Interval collections natively support a modify operation on the intervals, which allows moving the endpoints of the interval to a different place in the sequence.
-    This operation is atomic, whereas with markers one would have to submit a delete operation for the existing position and an insert for the new one.
-    In order to achieve the same atomicity, those operations would need to leverage the `SharedSegmentSequence.groupOperation` API,
-    which is less user-friendly.
-    If the ops were submitted using standard insert and delete APIs instead, there would be some potential for data loss if the delete
-    operation ended up acknowledged by the server but the insert operation did not.
+      This operation is atomic, whereas with markers one would have to submit a delete operation for the existing position and an insert for the new one.
+      In order to achieve the same atomicity, those operations would need to leverage the `SharedSegmentSequence.groupOperation` API,
+      which is less user-friendly.
+      If the ops were submitted using standard insert and delete APIs instead, there would be some potential for data loss if the delete
+      operation ended up acknowledged by the server but the insert operation did not.
 
 ### Attribution
 
@@ -418,10 +408,23 @@ Using the interval collection API has two main benefits:
 
 SharedString supports storing information attributing each character position to the user who inserted it and the time at which that insertion happened.
 This functionality is off by default.
-Enable it by setting `{ attribution: { track: true } }` on the `IFluidDataStoreRuntime` options used to initialize the SharedString.
-If the config flag `"Fluid.Attribution.EnableOnNewFile"` is set, its value will override the runtime options one.
+To enable this functionality, first ensure that all clients are created with an attribution policy factory in the loader settings:
 
-Attribution information is stored on the `attribution` field of the SharedString's segments.
+```typescript
+import { createInsertOnlyAttributionPolicy } from "@fluidframework/merge-tree";
+// Use these options in the IContainerContext used to instantiate your container runtime.
+const options: ILoaderOptions = {
+	attribution: {
+		policyFactory: createInsertOnlyAttributionPolicy,
+	},
+};
+```
+
+This ensures that the client is able to load existing documents containing attribution information,
+and specifies which kinds of operations should be attributed at the SharedString level (currently, only insertions).
+The stored attribution information can be found on the `attribution` field of the SharedString's segments.
+
+Next, enable the `"Fluid.Attribution.EnableOnNewFile"` config flag to start tracking attribution information for new files.
 
 ```typescript
 const { segment, offset } = sharedString.getContainingSegment(5);
@@ -430,19 +433,25 @@ const key = segment.attribution.getAtOffset(offset);
 // See the @fluidframework/attributor package for more details.
 ```
 
+For further reading on attribution, see the [@fluidframework/attributor README](../../framework/attributor/README.md).
+
+There are plans to make attribution policies more flexible, for example tracking attribution of property changes separately from segment insertion.
+
 ### Examples
 
-- Rich Text Editor Implementations
-  - [webflow](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/webflow)
-  - [flowView](https://github.com/microsoft/FluidFramework/blob/main/examples/data-objects/shared-text/src/client-ui-lib/controls/flowView.ts)
+-   Rich Text Editor Implementations
+
+    -   [webflow](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/webflow)
+    -   [flowView](https://github.com/microsoft/FluidFramework/blob/main/examples/data-objects/shared-text/src/client-ui-lib/controls/flowView.ts)
+
+-   Integrations with Open Source Rich Text Editors
 
-- Integrations with Open Source Rich Text Editors
-  - [prosemirror](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/prosemirror)
-  - [smde](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/smde)
+    -   [prosemirror](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/prosemirror)
+    -   [smde](https://github.com/microsoft/FluidFramework/tree/main/examples/data-objects/smde)
 
-- Plain Text Editor Implementations
-  - [collaborativeTextArea](https://github.com/microsoft/FluidFramework/blob/main/experimental/framework/react-inputs/src/CollaborativeTextArea.tsx)
-  - [collaborativeInput](https://github.com/microsoft/FluidFramework/blob/main/experimental/framework/react-inputs/src/CollaborativeInput.tsx)
+-   Plain Text Editor Implementations
+    -   [collaborativeTextArea](https://github.com/microsoft/FluidFramework/blob/main/experimental/framework/react-inputs/src/CollaborativeTextArea.tsx)
+    -   [collaborativeInput](https://github.com/microsoft/FluidFramework/blob/main/experimental/framework/react-inputs/src/CollaborativeInput.tsx)
 
-[SharedMap]: https://fluidframework.com/docs/data-structures/map/
-[SharedString]: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/sequence/src/sharedString.ts
+[sharedmap]: https://fluidframework.com/docs/data-structures/map/
+[sharedstring]: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/sequence/src/sharedString.ts

package/api-extractor.json

@@ -1,4 +1,4 @@
 {
-  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-  "extends": "@fluidframework/build-common/api-extractor-common-strict.json"
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "@fluidframework/build-common/api-extractor-common-strict.json"
 }

package/dist/defaultMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"defaultMap.d.ts","sourceRoot":"","sources":["../src/defaultMap.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"defaultMap.d.ts","sourceRoot":"","sources":["../src/defaultMap.ts"],"names":[],"mappings":"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"}

package/dist/defaultMap.js

@@ -153,8 +153,8 @@ class DefaultMap {
         for (const [key, serializable] of Object.entries(json)) {
             // Back-compat: legacy documents may have handles to an intervalCollection map kernel.
             // These collections should be empty, and ValueTypes are no longer supported.
-            if (serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain]
-                || serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared]) {
+            if (serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain] ||
+                serializable.type === shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared]) {
                 continue;
             }
             // Back-compat: Sequence previously arbitrarily prefixed all interval collection keys with
@@ -238,7 +238,8 @@ class DefaultMap {
      * @returns The local value that was produced
      */
     makeLocal(key, serializable) {
-        (0, common_utils_1.assert)(serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain] && serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared], 0x2e1 /* "Support for plain value types removed." */);
+        (0, common_utils_1.assert)(serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Plain] &&
+            serializable.type !== shared_object_base_1.ValueType[shared_object_base_1.ValueType.Shared], 0x2e1 /* "Support for plain value types removed." */);
         serializable.value = (0, shared_object_base_1.parseHandles)(serializable.value, this.serializer);
         const localValue = this.type.factory.load(this.makeMapValueOpEmitter(key), serializable.value);
         return new localValues_1.ValueTypeLocalValue(localValue, this.type);
@@ -271,7 +272,7 @@ class DefaultMap {
                 const localValue = this.data.get(op.key);
                 (0, common_utils_1.assert)(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
                 const handler = localValue.getOpHandler(op.value.opName);
-                const { rebasedOp, rebasedLocalOpMetadata, } = handler.rebase(localValue.value, op.value, localOpMetadata);
+                const { rebasedOp, rebasedLocalOpMetadata } = handler.rebase(localValue.value, op.value, localOpMetadata);
                 this.submitMessage(Object.assign(Object.assign({}, op), { value: rebasedOp }), rebasedLocalOpMetadata);
             },
             getStashedOpLocalMetadata: (op) => {