@fluid-experimental/property-changeset 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/dist/test/array.spec.js

@@ -24,7 +24,7 @@ describe("Array Operations", function () {
         if (type === undefined) {
             return {
                 String: {
-                    guid: `00000000-0000-0000-0000-${(`000000000000${id}`).substr(-12)}`,
+                    guid: `00000000-0000-0000-0000-${`000000000000${id}`.substr(-12)}`,
                 },
                 typeid: "test:namedEntry-1.0.0",
             };
@@ -60,17 +60,11 @@ describe("Array Operations", function () {
         // as otherwise overlapping ranges would be created in the result, which are not allowed
         // by the spec
         const op1 = createArrayCS({
-            insert: [
-                [1, generateNamedEntities(3)],
-            ],
-            remove: [
-                [1, generateNamedEntities(1)],
-            ],
+            insert: [[1, generateNamedEntities(3)]],
+            remove: [[1, generateNamedEntities(1)]],
         });
         const op2 = createArrayCS({
-            remove: [
-                [0, generateNamedEntities(2)],
-            ],
+            remove: [[0, generateNamedEntities(2)]],
         });
         const result = new changeset_1.ChangeSet(op1);
         result.applyChangeSet(op2);
@@ -83,17 +77,11 @@ describe("Array Operations", function () {
     });
     it("Rebasing with a base changeset containing adjacent removes and inserts", () => {
         const base = createArrayCS({
-            insert: [
-                [1, generateNamedEntities(3)],
-            ],
-            remove: [
-                [0, generateNamedEntities(1)],
-            ],
+            insert: [[1, generateNamedEntities(3)]],
+            remove: [[0, generateNamedEntities(1)]],
         });
         const rebaseCS = createArrayCS({
-            insert: [
-                [0, generateNamedEntities(1)],
-            ],
+            insert: [[0, generateNamedEntities(1)]],
         });
         const conflicts = [];
         const CS = new changeset_1.ChangeSet(base);
@@ -105,22 +93,17 @@ describe("Array Operations", function () {
         // the rebase this way. The CS above could have been generated by a combination of a
         // I(1,3) followed by a R(0,1). If the rebase CS would have been rebased separately
         // with respect to those two CS, it would have remained a I(0,3).
-        (0, chai_1.expect)(rebaseCS.modify["array<test:namedEntry-1.0.0>"].array.insert[0][0]).to.equal(0);
+        (0, chai_1.expect)(rebaseCS.modify["array<test:namedEntry-1.0.0>"].array
+            .insert[0][0]).to.equal(0);
     });
     for (const i of [0, 3]) {
         it(`Rebasing an insert behind a remove insert base changeset with insert position ${i}`, () => {
             const base = createArrayCS({
-                insert: [
-                    [i, generateNamedEntities(3)],
-                ],
-                remove: [
-                    [0, generateNamedEntities(3)],
-                ],
+                insert: [[i, generateNamedEntities(3)]],
+                remove: [[0, generateNamedEntities(3)]],
             });
             const rebaseCS = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(1)],
-                ],
+                insert: [[0, generateNamedEntities(1)]],
             });
             const originalRebaseCS = (0, fastest_json_copy_1.copy)(rebaseCS);
             const conflicts = [];
@@ -146,17 +129,11 @@ describe("Array Operations", function () {
     }
     it("Inserts should happen at the beginning of a remove range", () => {
         const op1 = createArrayCS({
-            insert: [
-                [1, generateNamedEntities(3)],
-            ],
-            remove: [
-                [1, generateNamedEntities(1)],
-            ],
+            insert: [[1, generateNamedEntities(3)]],
+            remove: [[1, generateNamedEntities(1)]],
         });
         const op2 = createArrayCS({
-            insert: [
-                [4, generateNamedEntities(2)],
-            ],
+            insert: [[4, generateNamedEntities(2)]],
         });
         const combinedCS = new changeset_1.ChangeSet(op1);
         combinedCS.applyChangeSet(op2);
@@ -195,10 +172,7 @@ describe("Array Operations", function () {
         return deltaChangeSet;
     }
     function runTestApplyingReverseAndRebasedChangesetForIndependentModifications(baseInsertPositions, rebasedInsertPositions, baseOperation = "insert", baseCount = 1) {
-        const createInserts = (positions, count) => positions.map((x) => [
-            x,
-            generateNamedEntities(count),
-        ]);
+        const createInserts = (positions, count) => positions.map((x) => [x, generateNamedEntities(count)]);
         const baseChangeSet = createArrayCS({
             [baseOperation]: createInserts(baseInsertPositions, baseCount),
         });
@@ -220,12 +194,8 @@ describe("Array Operations", function () {
         (0, chai_1.expect)(arrayChangeSet).to.not.have.property(baseOperation === "insert" ? "remove" : "insert");
     }
     describe("Rebase test applying the reverse, base and then rebased changeset", () => {
-        for (const basePositions of [
-            [0], [1], [2], [5], [13], [0, 2], [0, 5], [0, 5, 13],
-        ]) {
-            for (const rebasePositions of [
-                [0], [1], [5, 9], [5, 9, 12],
-            ]) {
+        for (const basePositions of [[0], [1], [2], [5], [13], [0, 2], [0, 5], [0, 5, 13]]) {
+            for (const rebasePositions of [[0], [1], [5, 9], [5, 9, 12]]) {
                 it(`with base positions ${basePositions} and rebase positions ${rebasePositions}`, () => {
                     runTestApplyingReverseAndRebasedChangesetForIndependentModifications(basePositions, rebasePositions);
                 });
@@ -242,7 +212,7 @@ describe("Array Operations", function () {
         const rebasedCS1 = (0, fastest_json_copy_1.copy)(rebaseChangeSet);
         for (const baseChangeSet of baseChangesets) {
             const conflicts = [];
-            (new changeset_1.ChangeSet(baseChangeSet))._rebaseChangeSet(rebasedCS1, conflicts);
+            new changeset_1.ChangeSet(baseChangeSet)._rebaseChangeSet(rebasedCS1, conflicts);
             validateChangeSet(rebasedCS1);
         }
         // Now rebase with respect to the squashed base ChangeSets
@@ -260,7 +230,7 @@ describe("Array Operations", function () {
         (0, chai_1.expect)(directApplication.getSerializedChangeSet()).to.deep.equal(squashApplication.getSerializedChangeSet());
         const conflicts2 = [];
         const rebasedCS2 = (0, fastest_json_copy_1.copy)(rebaseChangeSet);
-        (new changeset_1.ChangeSet(squashedBaseChangeSets))._rebaseChangeSet(rebasedCS2, conflicts2);
+        new changeset_1.ChangeSet(squashedBaseChangeSets)._rebaseChangeSet(rebasedCS2, conflicts2);
         validateChangeSet(rebasedCS2);
         (0, chai_1.expect)(rebasedCS1).to.deep.equal(rebasedCS2);
         return testRebasedApplies((0, fastest_json_copy_1.copy)(rebaseChangeSet), squashedBaseChangeSets, base);
@@ -271,19 +241,13 @@ describe("Array Operations", function () {
                 it(`Position ${insertPosition}`, () => {
                     testRebaseDistributivity([
                         createArrayCS({
-                            insert: [
-                                [1, generateNamedEntities(1)],
-                            ],
+                            insert: [[1, generateNamedEntities(1)]],
                         }),
                         createArrayCS({
-                            insert: [
-                                [6, generateNamedEntities(1)],
-                            ],
+                            insert: [[6, generateNamedEntities(1)]],
                         }),
                         createArrayCS({
-                            insert: [
-                                [9, generateNamedEntities(1)],
-                            ],
+                            insert: [[9, generateNamedEntities(1)]],
                         }),
                         createArrayCS({
                             remove: [
@@ -293,13 +257,9 @@ describe("Array Operations", function () {
                             ],
                         }),
                     ], createArrayCS({
-                        insert: [
-                            [insertPosition, generateNamedEntities(1)],
-                        ],
+                        insert: [[insertPosition, generateNamedEntities(1)]],
                     }), createArrayCS({
-                        insert: [
-                            [0, generateNamedEntities(10)],
-                        ],
+                        insert: [[0, generateNamedEntities(10)]],
                     }));
                 });
             }
@@ -307,87 +267,55 @@ describe("Array Operations", function () {
         it("Rebasing an insert with respect to a remove + insert", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    remove: [[0, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    insert: [[0, generateNamedEntities(3)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(3)],
-                ],
+                insert: [[0, generateNamedEntities(3)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    remove: [[0, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    insert: [[0, generateNamedEntities(3)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [3, generateNamedEntities(3)],
-                ],
+                insert: [[3, generateNamedEntities(3)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("remove + insert at start of array", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    remove: [[0, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    insert: [[0, generateNamedEntities(3)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [3, generateNamedEntities(1)],
-                ],
+                insert: [[3, generateNamedEntities(1)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("Rebased remove that cancels out", () => {
             const deltacS = testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    remove: [[0, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(3)],
-                    ],
+                    insert: [[0, generateNamedEntities(3)]],
                 }),
             ], createArrayCS({
-                remove: [
-                    [1, generateNamedEntities(2)],
-                ],
+                remove: [[1, generateNamedEntities(2)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
             const arrayCS = getArrayCS(deltacS);
             (0, chai_1.expect)(arrayCS.insert[0][1].length).to.equal(3);
@@ -396,159 +324,101 @@ describe("Array Operations", function () {
         it("Insert in between two removes 1", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    insert: [
-                        [2, generateNamedEntities(1)],
-                    ],
+                    insert: [[2, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(2)],
-                    ],
+                    remove: [[0, generateNamedEntities(2)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [1, generateNamedEntities(1)],
-                    ],
+                    remove: [[1, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(2)],
-                    ],
+                    insert: [[0, generateNamedEntities(2)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [1, generateNamedEntities(1)],
-                ],
+                insert: [[1, generateNamedEntities(1)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("Insert in between two removes 2", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    insert: [
-                        [4, generateNamedEntities(1)],
-                    ],
+                    insert: [[4, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [2, generateNamedEntities(2)],
-                    ],
+                    remove: [[2, generateNamedEntities(2)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [3, generateNamedEntities(1)],
-                    ],
+                    remove: [[3, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [2, generateNamedEntities(2)],
-                    ],
+                    insert: [[2, generateNamedEntities(2)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [3, generateNamedEntities(1)],
-                ],
+                insert: [[3, generateNamedEntities(1)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("Inserts in between three removes", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    insert: [
-                        [4, generateNamedEntities(1)],
-                    ],
+                    insert: [[4, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [6, generateNamedEntities(1)],
-                    ],
+                    insert: [[6, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [2, generateNamedEntities(2)],
-                    ],
+                    remove: [[2, generateNamedEntities(2)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [3, generateNamedEntities(1)],
-                    ],
+                    remove: [[3, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [4, generateNamedEntities(1)],
-                    ],
+                    remove: [[4, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [2, generateNamedEntities(2)],
-                    ],
+                    insert: [[2, generateNamedEntities(2)]],
                 }),
             ], createArrayCS({
-                insert: [
-                    [3, generateNamedEntities(1)],
-                ],
+                insert: [[3, generateNamedEntities(1)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("Adjacent remove with insert at the beginning of the remove range", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [1, generateNamedEntities(1)],
-                    ],
+                    remove: [[1, generateNamedEntities(1)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [1, generateNamedEntities(2)],
-                    ],
+                    insert: [[1, generateNamedEntities(2)]],
                 }),
             ], createArrayCS({
-                remove: [
-                    [1, generateNamedEntities(1, [3])],
-                ],
+                remove: [[1, generateNamedEntities(1, [3])]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }));
         });
         it("Remove operation that cancels out", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [8, generateNamedEntities(2)],
-                    ],
+                    remove: [[8, generateNamedEntities(2)]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [8, generateNamedEntities(1)],
-                    ],
+                    insert: [[8, generateNamedEntities(1)]],
                 }),
             ], createArrayCS({
-                remove: [
-                    [8, generateNamedEntities(1, [3])],
-                ],
+                remove: [[8, generateNamedEntities(1, [3])]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(14)],
-                ],
+                insert: [[0, generateNamedEntities(14)]],
             }));
         });
         it("Remove operation that cancels out 2", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [8, generateNamedEntities(3)],
-                    ],
+                    remove: [[8, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
                     insert: [
@@ -558,30 +428,20 @@ describe("Array Operations", function () {
                     ],
                 }),
             ], createArrayCS({
-                remove: [
-                    [8, generateNamedEntities(1, [3])],
-                ],
+                remove: [[8, generateNamedEntities(1, [3])]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(14)],
-                ],
+                insert: [[0, generateNamedEntities(14)]],
             }));
         });
         it("Remove operation that cancels out in the middle of a range", () => {
             testRebaseDistributivity([
                 createArrayCS({
-                    remove: [
-                        [4, generateNamedEntities(1)],
-                    ],
+                    remove: [[4, generateNamedEntities(1)]],
                 }),
             ], createArrayCS({
-                remove: [
-                    [3, generateNamedEntities(3)],
-                ],
+                remove: [[3, generateNamedEntities(3)]],
             }), createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(14)],
-                ],
+                insert: [[0, generateNamedEntities(14)]],
             }));
         });
     });
@@ -632,89 +492,65 @@ describe("Array Operations", function () {
         if (customValidator !== undefined) {
             customValidator(combinedCS, separateApplysResult, combinedApplyResult);
         }
-        (0, chai_1.expect)(separateApplysResult.getSerializedChangeSet())
-            .to.deep.equal(combinedApplyResult.getSerializedChangeSet());
+        (0, chai_1.expect)(separateApplysResult.getSerializedChangeSet()).to.deep.equal(combinedApplyResult.getSerializedChangeSet());
     }
     describe("Apply Associativity", () => {
         it("insert + remove + insert", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(3)],
-                ],
+                insert: [[0, generateNamedEntities(3)]],
             }, "insert");
             const ops = [
                 createArrayCS({
-                    insert: [
-                        [2, generateNamedEntities(2)],
-                    ],
+                    insert: [[2, generateNamedEntities(2)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [3, generateNamedEntities(2, [1, 3])],
-                    ],
+                    remove: [[3, generateNamedEntities(2, [1, 3])]],
                 }),
                 createArrayCS({
-                    insert: [
-                        [2, generateNamedEntities(1)],
-                    ],
+                    insert: [[2, generateNamedEntities(1)]],
                 }),
             ];
             testApplyAssociativity(initial, ops);
         });
         describe("Inserting into a remove range with deletes on both sides", () => {
-            for (const additionalInserts of ["", " with insert at the beginning", " with insert at the end"]) {
+            for (const additionalInserts of [
+                "",
+                " with insert at the beginning",
+                " with insert at the end",
+            ]) {
                 const offset = additionalInserts === " with insert at the beginning" ? 2 : 0;
                 for (const i of (0, range_1.default)(1, 9)) {
                     it(`at position ${i + offset}${additionalInserts}`, () => {
                         const initial = createArrayCS({
-                            insert: [
-                                [0, generateNamedEntities(10, undefined, "number")],
-                            ],
+                            insert: [[0, generateNamedEntities(10, undefined, "number")]],
                         }, "insert", "array<Float64>");
                         let initialInserts = [];
                         let finalInserts = [];
                         if (additionalInserts === " with insert at the beginning") {
-                            initialInserts = [
-                                [0, generateNamedEntities(2, undefined, "number")],
-                            ];
+                            initialInserts = [[0, generateNamedEntities(2, undefined, "number")]];
                         }
                         if (additionalInserts === " with insert at the end") {
-                            finalInserts = [
-                                [10, generateNamedEntities(2, undefined, "number")],
-                            ];
+                            finalInserts = [[10, generateNamedEntities(2, undefined, "number")]];
                         }
-                        const ops = [createArrayCS({
+                        const ops = [
+                            createArrayCS({
                                 insert: [
-                                    ...initialInserts, [
-                                        2,
-                                        generateNamedEntities(2, undefined, "number"),
-                                    ],
-                                    [
-                                        7,
-                                        generateNamedEntities(3, undefined, "number"),
-                                    ],
+                                    ...initialInserts,
+                                    [2, generateNamedEntities(2, undefined, "number")],
+                                    [7, generateNamedEntities(3, undefined, "number")],
                                     ...finalInserts,
                                 ],
-                                remove: [
-                                    [
-                                        2,
-                                        generateNamedEntities(5, undefined, "number"),
-                                    ],
-                                ],
+                                remove: [[2, generateNamedEntities(5, undefined, "number")]],
                             }, undefined, "array<Float64>"),
                             createArrayCS({
                                 insert: [
-                                    [
-                                        i + offset,
-                                        generateNamedEntities(2, undefined, "number"),
-                                    ],
+                                    [i + offset, generateNamedEntities(2, undefined, "number")],
                                 ],
                             }, undefined, "array<Float64>"),
                         ];
                         testApplyAssociativity(initial, ops, (combinedCS) => {
                             const arrayCS = getArrayCS(combinedCS);
-                            (0, chai_1.expect)(arrayCS.insert.length).to.equal((i >= 2 && i < 8 ? 2 : 3) +
-                                (additionalInserts !== "" ? 1 : 0));
+                            (0, chai_1.expect)(arrayCS.insert.length).to.equal((i >= 2 && i < 8 ? 2 : 3) + (additionalInserts !== "" ? 1 : 0));
                             const insertOffset = additionalInserts == " with insert at the beginning" ? 1 : 0;
                             if (i >= 2 && i <= 4) {
                                 (0, chai_1.expect)(arrayCS.insert[0 + insertOffset][1].length).to.equal(4);
@@ -731,11 +567,10 @@ describe("Array Operations", function () {
         });
         it("remove overlapping insert and remove ranges", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10, undefined, "number")],
-                ],
+                insert: [[0, generateNamedEntities(10, undefined, "number")]],
             }, "insert", "array<Float64>");
-            const ops = [createArrayCS({
+            const ops = [
+                createArrayCS({
                     insert: [
                         [0, generateNamedEntities(1, undefined, "number")],
                         [1, generateNamedEntities(1, undefined, "number")],
@@ -748,46 +583,35 @@ describe("Array Operations", function () {
                     ],
                 }, undefined, "array<Float64>"),
                 createArrayCS({
-                    remove: [
-                        [
-                            0,
-                            generateNamedEntities(2, undefined, "number"),
-                        ],
-                    ],
+                    remove: [[0, generateNamedEntities(2, undefined, "number")]],
                 }, undefined, "array<Float64>"),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Overlapping remove / insert", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10, undefined, "number")],
-                ],
+                insert: [[0, generateNamedEntities(10, undefined, "number")]],
             }, "insert", "array<Float64>");
-            const ops = [createArrayCS({
+            const ops = [
+                createArrayCS({
                     insert: [
                         [0, generateNamedEntities(2, undefined, "number")],
                         [4, generateNamedEntities(2, undefined, "number")],
                     ],
-                    remove: [
-                        [4, generateNamedEntities(5, undefined, "number")],
-                    ],
+                    remove: [[4, generateNamedEntities(5, undefined, "number")]],
                 }, undefined, "array<Float64>"),
                 createArrayCS({
-                    remove: [
-                        [4, generateNamedEntities(2, undefined, "number")],
-                    ],
+                    remove: [[4, generateNamedEntities(2, undefined, "number")]],
                 }, undefined, "array<Float64>"),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Removing multiple inserts and removes", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10, undefined, "number")],
-                ],
+                insert: [[0, generateNamedEntities(10, undefined, "number")]],
             }, "insert", "array<Float64>");
-            const ops = [createArrayCS({
+            const ops = [
+                createArrayCS({
                     insert: [
                         [1, generateNamedEntities(2, undefined, "number")],
                         [4, generateNamedEntities(4, undefined, "number")],
@@ -799,20 +623,17 @@ describe("Array Operations", function () {
                     ],
                 }, undefined, "array<Float64>"),
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(6, undefined, "number")],
-                    ],
+                    remove: [[0, generateNamedEntities(6, undefined, "number")]],
                 }, undefined, "array<Float64>"),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Removing insert/removes at the end", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10, undefined, "number")],
-                ],
+                insert: [[0, generateNamedEntities(10, undefined, "number")]],
             }, "insert", "array<Float64>");
-            const ops = [createArrayCS({
+            const ops = [
+                createArrayCS({
                     insert: [
                         [0, generateNamedEntities(2, undefined, "number")],
                         [1, generateNamedEntities(1, undefined, "number")],
@@ -824,75 +645,52 @@ describe("Array Operations", function () {
                     ],
                 }, undefined, "array<Float64>"),
                 createArrayCS({
-                    remove: [
-                        [6, generateNamedEntities(2, undefined, "number")],
-                    ],
+                    remove: [[6, generateNamedEntities(2, undefined, "number")]],
                 }, undefined, "array<Float64>"),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Insert with overlapping remove", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }, "insert");
-            const ops = [createArrayCS({
-                    insert: [
-                        [1, generateNamedEntities(3)],
-                    ],
+            const ops = [
+                createArrayCS({
+                    insert: [[1, generateNamedEntities(3)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [1, generateNamedEntities(1)],
-                    ],
-                    insert: [
-                        [1, generateNamedEntities(3)],
-                    ],
+                    remove: [[1, generateNamedEntities(1)]],
+                    insert: [[1, generateNamedEntities(3)]],
                 }),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Failed case", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }, "insert");
-            const ops = [createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(7)],
-                    ],
+            const ops = [
+                createArrayCS({
+                    insert: [[0, generateNamedEntities(7)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [0, generateNamedEntities(1)],
-                    ],
-                    insert: [
-                        [1, generateNamedEntities(2)],
-                    ],
+                    remove: [[0, generateNamedEntities(1)]],
+                    insert: [[1, generateNamedEntities(2)]],
                 }),
             ];
             testApplyAssociativity(initial, ops);
         });
         it("Failed case", () => {
             const initial = createArrayCS({
-                insert: [
-                    [0, generateNamedEntities(10)],
-                ],
+                insert: [[0, generateNamedEntities(10)]],
             }, "insert");
-            const ops = [createArrayCS({
-                    insert: [
-                        [0, generateNamedEntities(5)],
-                    ],
+            const ops = [
+                createArrayCS({
+                    insert: [[0, generateNamedEntities(5)]],
                 }),
                 createArrayCS({
-                    remove: [
-                        [4, generateNamedEntities(1)],
-                    ],
-                    insert: [
-                        [5, generateNamedEntities(3)],
-                    ],
+                    remove: [[4, generateNamedEntities(1)]],
+                    insert: [[5, generateNamedEntities(3)]],
                 }),
             ];
             testApplyAssociativity(initial, ops);
@@ -921,9 +719,10 @@ describe("Array Operations", function () {
                                 insertNames.push(`inside remove range in B (${removeInsideInsertB})`);
                             }
                             let title = "with ";
-                            title += insertNames.length === 0
-                                ? "no inserts"
-                                : `inserts ${insertNames.join(", ")}`;
+                            title +=
+                                insertNames.length === 0
+                                    ? "no inserts"
+                                    : `inserts ${insertNames.join(", ")}`;
                             it(title, () => {
                                 const insertsA = [];
                                 const insertsB = [];
@@ -936,9 +735,7 @@ describe("Array Operations", function () {
                                     insertsA.push([5, generateNamedEntities(1)]);
                                     offset += 1;
                                 }
-                                let removesB = [
-                                    [5 + offset, generateNamedEntities(3)],
-                                ];
+                                let removesB = [[5 + offset, generateNamedEntities(3)]];
                                 if (startInsertB) {
                                     insertsB.push([0, generateNamedEntities(1)]);
                                 }
@@ -947,7 +744,10 @@ describe("Array Operations", function () {
                                 }
                                 if (removeInsideInsertB) {
                                     const removeOffset = removeInsideInsertB === "separate" ? 1 : 0;
-                                    insertsB.push([6 + offset + removeOffset, generateNamedEntities(1)]);
+                                    insertsB.push([
+                                        6 + offset + removeOffset,
+                                        generateNamedEntities(1),
+                                    ]);
                                     removesB = [
                                         [5 + offset + removeOffset, generateNamedEntities(1)],
                                         [6 + offset + removeOffset, generateNamedEntities(1)],
@@ -955,9 +755,7 @@ describe("Array Operations", function () {
                                 }
                                 const CS1 = createArrayCS({
                                     insert: insertsA,
-                                    remove: [
-                                        [5, generateNamedEntities(3)],
-                                    ],
+                                    remove: [[5, generateNamedEntities(3)]],
                                 });
                                 const CS2 = createArrayCS({
                                     insert: insertsB,