@fluid-experimental/property-changeset 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/dist/changeset_operations/array.js

@@ -1,27 +1,26 @@
 "use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChangeSetArrayFunctions = void 0;
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
 /**
  * @fileoverview Helper functions and classes to work with array ChangeSets
  */
-const fastest_json_copy_1 = require("fastest-json-copy");
-const isNumber_1 = __importDefault(require("lodash/isNumber"));
-const isString_1 = __importDefault(require("lodash/isString"));
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-// @ts-ignore
 const property_common_1 = require("@fluid-experimental/property-common");
-const typeidHelper_1 = require("../helpers/typeidHelper");
-const arrayChangesetIterator_1 = require("./arrayChangesetIterator");
-const changesetConflictTypes_1 = require("./changesetConflictTypes");
+const fastest_json_copy_1 = require("fastest-json-copy");
+const isEqual_js_1 = __importDefault(require("lodash/isEqual.js"));
+const isNumber_js_1 = __importDefault(require("lodash/isNumber.js"));
+const isString_js_1 = __importDefault(require("lodash/isString.js"));
+const typeidHelper_js_1 = require("../helpers/typeidHelper.js");
+const arrayChangesetIterator_js_1 = require("./arrayChangesetIterator.js");
+const changesetConflictTypes_js_1 = require("./changesetConflictTypes.js");
 const { MSG } = property_common_1.constants;
-const { isPrimitiveType } = typeidHelper_1.TypeIdHelper;
+const { isPrimitiveType } = typeidHelper_js_1.TypeIdHelper;
 /**
  * The range combinations of two change sets (A and B)
  * This can either be complete operations, parts of complete operations or overlapping segments
@@ -72,9 +71,9 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
     if (!io_operation) {
         return;
     }
-    if (io_operation.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP) {
+    if (io_operation.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP) {
         const dummyOp = {
-            type: arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP,
+            type: arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP,
             offset: in_aOffset,
         };
         io_resultingRange.begin = undefined;
@@ -85,13 +84,13 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
     }
     io_operation.operation[0] += in_aOffset;
     switch (io_operation.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT:
             io_resultingRange.begin = io_operation.operation[0];
             io_resultingRange.end = io_operation.operation[0] + io_operation.operation[1].length;
             io_resultingRange.op = io_operation;
             io_resultingRange.flag = ArrayChangeSetRangeType.completeA;
             return;
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE:
             io_resultingRange.begin = io_operation.operation[0];
             io_resultingRange.end = io_operation.operation[0];
             io_resultingRange.op = io_operation;
@@ -99,7 +98,7 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
             io_resultingRange.removeInsertOperation =
                 io_operation.removeInsertOperation;
             return;
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY:
             io_resultingRange.begin = io_operation.operation[0];
             io_resultingRange.end = io_operation.operation[0] + io_operation.operation[1].length;
             io_resultingRange.op = io_operation;
@@ -109,7 +108,7 @@ const getRangeForCurrentStateOperation = function (io_operation, in_aOffset, io_
             throw new Error(`getRangeForCurrentStateOperation: ${MSG.UNKNOWN_OPERATION}`);
     }
 };
-const getOpLength = (op) => ((0, isNumber_1.default)(op[1]) ? op[1] : op[1].length);
+const getOpLength = (op) => ((0, isNumber_js_1.default)(op[1]) ? op[1] : op[1].length);
 /**
  * Computes the impact range for a given operation of the applied change set
  * @param in_operation - The op
@@ -118,7 +117,7 @@ const getOpLength = (op) => ((0, isNumber_1.default)(op[1]) ? op[1] : op[1].leng
  * @param in_options - Optional additional parameters
  */
 const getRangeForAppliedOperation = function (in_operation, io_resultingRange, in_flag, in_options) {
-    if (!in_operation || in_operation.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP) {
+    if (!in_operation || in_operation.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP) {
         io_resultingRange.begin = undefined;
         io_resultingRange.end = undefined;
         io_resultingRange.op = undefined;
@@ -138,7 +137,7 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
     io_resultingRange.op._absoluteBegin = in_operation.operation[0];
     io_resultingRange.flag = in_flag !== undefined ? in_flag : ArrayChangeSetRangeType.completeB;
     switch (in_operation.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT:
             io_resultingRange.end = in_operation.operation[0];
             io_resultingRange.op.operation[1] = in_operation.operation[1].slice();
             if (in_options && in_options.applyAfterMetaInformation) {
@@ -148,7 +147,7 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
                 }
             }
             return;
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE:
             let numberOfRemovedElements = getOpLength(in_operation.operation);
             io_resultingRange.end = in_operation.operation[0] + numberOfRemovedElements;
             io_resultingRange.op.operation[1] = Array.isArray(in_operation.operation[1])
@@ -156,7 +155,7 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
                 : in_operation.operation[1];
             io_resultingRange.removeInsertOperation = in_operation.removeInsertOperation;
             return;
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY:
             io_resultingRange.end = in_operation.operation[0] + in_operation.operation[1].length;
             io_resultingRange.op.operation[1] = in_operation.operation[1].slice();
             if (in_operation.operation[2] !== undefined) {
@@ -179,13 +178,13 @@ const getRangeForAppliedOperation = function (in_operation, io_resultingRange, i
  */
 const _splitArrayParameter = function (in_firstResult, in_secondResult, in_data, in_start) {
     let firstTmp;
-    if ((0, isString_1.default)(in_data[1])) {
+    if ((0, isString_js_1.default)(in_data[1])) {
         firstTmp = in_data[1].substr(0, in_start);
         in_secondResult[1] = in_data[1].substr(in_start);
         if (in_firstResult) {
             in_firstResult[1] = firstTmp;
         }
-        if (in_data[2] !== undefined && (0, isString_1.default)(in_data[2])) {
+        if (in_data[2] !== undefined && (0, isString_js_1.default)(in_data[2])) {
             firstTmp = in_data[2].substr(0, in_start);
             in_secondResult[2] = in_data[2].substr(in_start);
             if (in_firstResult) {
@@ -225,10 +224,10 @@ const _splitArrayParameter = function (in_firstResult, in_secondResult, in_data,
 const _splitOperation = function (in_targetRange, in_targetOperation, lengthUsedInResultSegment, in_updateOffset) {
     _splitArrayParameter(in_targetOperation.operation, in_targetRange.op.operation, in_targetRange.op.operation, lengthUsedInResultSegment);
     if (in_updateOffset) {
-        if (in_targetRange.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT) {
+        if (in_targetRange.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT) {
             in_targetRange.op.offset += lengthUsedInResultSegment;
         }
-        if (in_targetRange.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE) {
+        if (in_targetRange.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE) {
             in_targetRange.op.offset -= lengthUsedInResultSegment;
         }
     }
@@ -239,7 +238,7 @@ const _splitOperation = function (in_targetRange, in_targetOperation, lengthUsed
  * @param in_targetOperation - The target operation which will be overwritten
  */
 const _copyOperation = function (in_sourceOperation, in_targetOperation) {
-    if (in_sourceOperation.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE) {
+    if (in_sourceOperation.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE) {
         in_targetOperation.operation[1] = in_sourceOperation.operation[1];
     }
     else {
@@ -262,7 +261,6 @@ const _copyOperation = function (in_sourceOperation, in_targetOperation) {
  * overlapping range or
  * (partial) A or B
  */
-// eslint-disable-next-line complexity
 const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in_rebasing, in_options) {
     if (io_rangeA.removeInsertOperation) {
         io_resultingSegment.removeInsertOperationA = io_rangeA.removeInsertOperation;
@@ -284,7 +282,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         return;
     }
     if (io_rangeB.removeInsertOperation &&
-        io_rangeB.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE &&
+        io_rangeB.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE &&
         (io_rangeA.begin === undefined ||
             io_rangeB.removeInsertOperation[0] < io_rangeA.begin - io_rangeA.op.offset) &&
         io_rangeB.removeInsertOperation[0] < io_rangeB.begin &&
@@ -292,7 +290,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         io_resultingSegment.begin = io_rangeB.removeInsertOperation[0];
         io_resultingSegment.end = io_rangeB.removeInsertOperation[0];
         io_resultingSegment.op = {
-            type: arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT,
+            type: arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT,
             operation: io_rangeB.removeInsertOperation,
             offset: io_rangeB.op.offset,
         };
@@ -325,9 +323,9 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
     if (!in_rebasing &&
         io_rangeA.begin <= io_rangeB.begin &&
         io_rangeA.begin + nextInsertOffset >= io_rangeB.begin &&
-        io_rangeA.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE &&
+        io_rangeA.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE &&
         Array.isArray(io_rangeA.op.operation[1]) && // This is a reversible remove operation
-        io_rangeB.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT) {
+        io_rangeB.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT) {
         // Are the two operations canceling out?
         let startOffset = 0;
         let rangeStart = 0;
@@ -355,7 +353,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
                             operationMetaInfo.currentInsertOffset;
                     rangeLength = operationMetaInfo.rebasedRemoveInsertRanges[i].rangeLength;
                     if (io_rangeA.op.operation[1].length - startOffset >= rangeLength &&
-                        (0, isEqual_1.default)(io_rangeA.op.operation[1].slice(startOffset, startOffset + rangeLength), io_rangeB.op.operation[1].slice(rangeStart, rangeStart + rangeLength))) {
+                        (0, isEqual_js_1.default)(io_rangeA.op.operation[1].slice(startOffset, startOffset + rangeLength), io_rangeB.op.operation[1].slice(rangeStart, rangeStart + rangeLength))) {
                         matchFound = true;
                         // If we have an remove / insert operation in the range A we have to make sure,
                         // the insert happens at the correct position within the remove range after canceling
@@ -378,7 +376,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         }
         else {
             if (io_rangeA.op.operation[1].length === rangeLength &&
-                (0, isEqual_1.default)(io_rangeA.op.operation[1], io_rangeB.op.operation[1])) {
+                (0, isEqual_js_1.default)(io_rangeA.op.operation[1], io_rangeB.op.operation[1])) {
                 matchFound = true;
             }
         }
@@ -448,7 +446,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         }
     }
     if (io_rangeA.end < io_rangeB.begin || // please see in_rebasing comments in the function description
-        ((!in_rebasing || io_rangeA.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE) &&
+        ((!in_rebasing || io_rangeA.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE) &&
             io_rangeA.end === io_rangeB.begin)) {
         io_resultingSegment.begin = io_rangeA.begin;
         io_resultingSegment.end = io_rangeA.end;
@@ -456,11 +454,11 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
         io_resultingSegment.flag = io_rangeA.flag;
         // We need to store the length of the adjacent remove operation for later squashes
         if (in_rebasing &&
-            io_rangeA.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE &&
+            io_rangeA.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE &&
             io_rangeA.end === io_rangeB.begin) {
             if (in_options && in_options.applyAfterMetaInformation) {
                 let length = io_rangeB.op.operation[1];
-                if (!(0, isNumber_1.default)(length)) {
+                if (!(0, isNumber_js_1.default)(length)) {
                     length = length.length;
                 }
                 in_options.applyAfterMetaInformation.set(io_rangeB.op.operation[1], {
@@ -581,7 +579,7 @@ const splitOverlapping = function (io_rangeA, io_rangeB, io_resultingSegment, in
 const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, in_options) {
     let lastOp;
     switch (in_op.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
             if (io_changeset.insert.length === 0) {
                 return false;
             }
@@ -611,7 +609,7 @@ const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, i
                     }
                 }
                 // merge with last insert
-                if ((0, isString_1.default)(in_op.operation[1])) {
+                if ((0, isString_js_1.default)(in_op.operation[1])) {
                     for (let i = 0; i < in_op.operation[1].length; i++) {
                         lastOp[1] += in_op.operation[1][i];
                     }
@@ -633,14 +631,14 @@ const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, i
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
             // We cannot perform merges for removes here, as those
             // also depend on the insert positions, which might not
             // yet have been processed when the remove is processed.
             // We handle these in a post processing step instead
             throw new Error("Should never happen");
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY:
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY:
             if (io_changeset.modify.length === 0) {
                 return false;
             }
@@ -672,7 +670,7 @@ const mergeWithLastIfPossible = function (in_op, io_changeset, in_targetIndex, i
  */
 const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_lastIteratorARemove, in_segment) {
     let writeTargetIndex;
-    if (arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP !== in_op.type) {
+    if (arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP !== in_op.type) {
         writeTargetIndex = in_op.operation[0] - in_indexOffset;
         // We have to update the write target index, if we have an insert at the
         // position of a remove. In that case, we have to move the insert to the beginning
@@ -681,7 +679,7 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
         // wouldn't have an effect on rebased changeset and then rebasing it with respect to the
         // insert would move it befind the insert. If we do this rebase with respect to the combined
         // CS, we must have the insert before the remove to make sure it is taken into account)
-        if (arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT === in_op.type &&
+        if (arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT === in_op.type &&
             in_lastIteratorARemove !== undefined &&
             in_segment.flag === ArrayChangeSetRangeType.completeB) {
             if (in_lastIteratorARemove.position == in_op.operation[0] &&
@@ -694,10 +692,10 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
         }
     }
     switch (in_op.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
             if (in_options &&
                 in_options.applyAfterMetaInformation &&
-                !(0, isNumber_1.default)(in_op.operation[1])) {
+                !(0, isNumber_js_1.default)(in_op.operation[1])) {
                 // If we don't have any meta information yet, we add an entry with the correct offset applied
                 const metaInfo = in_options.applyAfterMetaInformation.get(in_op.operation[1]);
                 if (!metaInfo) {
@@ -717,7 +715,7 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
             // Note: we don't merge removes here, since those depend on not yet processed inserts.
             // This is done in a post processing step instead
             // our segmentation method currently can produce length zero remove segments
@@ -728,7 +726,7 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
             if (!mergeWithLastIfPossible(in_op, io_changeset, writeTargetIndex, in_options)) {
                 if (in_op.operation[2] !== undefined) {
                     io_changeset.modify.push([
@@ -743,7 +741,7 @@ const pushOp = function (in_op, io_changeset, in_indexOffset, in_options, in_las
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP: {
             // nothing to do
             break;
         }
@@ -762,31 +760,31 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
     const opA = in_segment.opA;
     const opB = in_segment.opB;
     switch (opA.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
             switch (opB.type) {
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
                     // this combination is not reachable since this case has already been handled before
                     console.error("this combination should not occur in handleCombinations - this is a bug");
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
                     // Attention: B removes A completely, kill A to avoid zero inserts
-                    const opBLen = (0, isNumber_1.default)(opB.operation[1])
+                    const opBLen = (0, isNumber_js_1.default)(opB.operation[1])
                         ? opB.operation[1]
                         : opB.operation[1].length;
                     if (opBLen !== opA.operation[1].length) {
                         throw new Error("handleCombinations: insert-remove: unequal number of affected entries");
                     }
-                    opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
+                    opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP;
                     opB.operation = null;
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
                     // we have to apply modify of B to As insert
                     if (in_isPrimitiveType) {
                         // since the length of A and B is equal in here
                         // we can just insert the modified values instead
-                        opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT;
+                        opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT;
                     }
                     else {
                         // the array element is a complex types
@@ -797,7 +795,7 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
                             this.performApplyAfterOnPropertyWithTypeid(i, opA.operation[1], opB.operation[1], opA.operation[1][i].typeid, false);
                         }
                         opB.operation = opA.operation;
-                        opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT;
+                        opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT;
                     }
                     break;
                 }
@@ -806,12 +804,12 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
             // this combination is not reachable since this case has already been handled before
             console.error("this combination should not occur in handleCombinations - this is a bug");
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
             if (in_isPrimitiveType) {
                 // If we have a reversible changeset, we
                 // have to keep the previous state from before the
@@ -823,7 +821,7 @@ const handleCombinations = function (in_segment, in_isPrimitiveType) {
             }
             else {
                 // we have to deal with complex types here!
-                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY) {
+                if (opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY) {
                     for (let i = 0; i < opB.operation[1].length; ++i) {
                         // TypeIds MUST be stored in the entries
                         property_common_1.ConsoleUtils.assert(opA.operation[1][i].typeid, "Malformed Operation. Missing typeid");
@@ -930,12 +928,12 @@ const arraysHaveSameValues = function (in_arr1, in_arr2) {
 const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePath, in_isPrimitiveType, in_options) {
     const opA = in_segment.opA;
     const opB = in_segment.opB;
-    if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT) {
+    if (opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT) {
         const originalStartPosition = opB.operation[0] + opB.offset;
         if (in_options && in_options.applyAfterMetaInformation) {
             let length;
             const insertEntries = opB.operation[1];
-            if (!(0, isNumber_1.default)(insertEntries)) {
+            if (!(0, isNumber_js_1.default)(insertEntries)) {
                 length = insertEntries.length;
                 in_options.applyAfterMetaInformation.set(insertEntries, {
                     rebasedRemoveInsertRanges: [
@@ -955,7 +953,7 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
         delete baseOp.offset;
         const conflict = {
             path: in_basePath,
-            type: changesetConflictTypes_1.ConflictType.INSERTED_ENTRY_WITH_SAME_KEY,
+            type: changesetConflictTypes_js_1.ConflictType.INSERTED_ENTRY_WITH_SAME_KEY,
             conflictingChange: (0, fastest_json_copy_1.copy)(baseOp),
         };
         out_conflicts.push(conflict);
@@ -963,17 +961,17 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
         baseOp.operation[0] += insertOp.operation[1].length;
     };
     switch (opA.type) {
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
             switch (opB.type) {
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
                     handleInsert(opA, opB);
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
                     // non-conflicting insert - just keep B
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
                     // non-conflicting insert - just keep B
                     break;
                 }
@@ -982,9 +980,9 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
             switch (opB.type) {
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT: {
                     if (opA._absoluteBegin !== opA.operation[0]) {
                         // Move the insert operation to the beginning of the removed range
                         opB.operation[0] -= opA.operation[0] - opA._absoluteBegin;
@@ -1001,23 +999,23 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                     }
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE: {
                     // Remove already in A, no need to add the same again -> write nop
-                    const opBLen = (0, isNumber_1.default)(opB.operation[1])
+                    const opBLen = (0, isNumber_js_1.default)(opB.operation[1])
                         ? opB.operation[1]
                         : opB.operation[1].length;
-                    const opALen = (0, isNumber_1.default)(opA.operation[1])
+                    const opALen = (0, isNumber_js_1.default)(opA.operation[1])
                         ? opA.operation[1]
                         : opA.operation[1].length;
                     if (opBLen !== opALen) {
                         throw new Error("handleRebaseCombinations: remove-remove: unequal number of affected entries, " +
                             "this should never happen! Probably a bug in splitRange.");
                     }
-                    opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
+                    opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP;
                     opB.operation = null;
                     break;
                 }
-                case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+                case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
                     // trying to modify something that was removed ->
                     // replace the modify with a NOP and report a conflict
                     if (opB.operation[1].length > 0) {
@@ -1025,12 +1023,12 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                         delete opB.offset;
                         let conflict = {
                             path: in_basePath,
-                            type: changesetConflictTypes_1.ConflictType.ENTRY_MODIFIED_AFTER_REMOVE,
+                            type: changesetConflictTypes_js_1.ConflictType.ENTRY_MODIFIED_AFTER_REMOVE,
                             conflictingChange: (0, fastest_json_copy_1.copy)(opB),
                         };
                         out_conflicts.push(conflict);
                     }
-                    opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
+                    opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP;
                     opB.operation = null;
                     break;
                 }
@@ -1039,16 +1037,16 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
             }
             break;
         }
-        case arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY: {
+        case arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY: {
             if (in_isPrimitiveType) {
                 // just use opB and notify accordingly
-                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY &&
+                if (opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY &&
                     opB.operation[1].length > 0) {
                     delete opA._absoluteBegin;
                     delete opB.offset;
                     let conflict = {
                         path: in_basePath,
-                        type: changesetConflictTypes_1.ConflictType.COLLIDING_SET,
+                        type: changesetConflictTypes_js_1.ConflictType.COLLIDING_SET,
                         conflictingChange: (0, fastest_json_copy_1.copy)(opB),
                     };
                     out_conflicts.push(conflict);
@@ -1059,7 +1057,7 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                     //       Ex. [[0, [30, 20, 10]]] over [[0, [10, 20, 30]]] should become [[0, [30]], [2, [10]]].
                     //       This does not seem easily doable in the current code.
                     if (arraysHaveSameValues(opA.operation[1], opB.operation[1])) {
-                        opB.type = arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
+                        opB.type = arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP;
                         opB.operation = null;
                         // If any, change the opB old value by the opA new value
                     }
@@ -1069,13 +1067,13 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
                 }
                 // WARNING: 'operation[1]' is 'string | number | genericArray'.  The cast to 'number'
                 //          preserves the JavaScript coercion behavior, which was permitted prior to TS5.
-                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE &&
+                if (opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE &&
                     opB.operation[1] > 0) {
                     delete opA._absoluteBegin;
                     delete opB.offset;
                     let conflict = {
                         path: in_basePath,
-                        type: changesetConflictTypes_1.ConflictType.REMOVE_AFTER_MODIFY,
+                        type: changesetConflictTypes_js_1.ConflictType.REMOVE_AFTER_MODIFY,
                         conflictingChange: (0, fastest_json_copy_1.copy)(opB),
                     };
                     out_conflicts.push(conflict);
@@ -1084,7 +1082,7 @@ const handleRebaseCombinations = function (in_segment, out_conflicts, in_basePat
             }
             else {
                 // we have to deal with complex types here!
-                if (opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.MODIFY) {
+                if (opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.MODIFY) {
                     for (let i = 0; i < opB.operation[1].length; ++i) {
                         property_common_1.ConsoleUtils.assert(opA.operation[1][i].typeid, "Malformed Operation. Missing typeid");
                         this.rebaseChangeSetForPropertyEntryWithTypeid(i, opA.operation[1], opB.operation[1], opA.operation[1][i].typeid, `${in_basePath}[${i}]`, false, out_conflicts, in_options);
@@ -1170,12 +1168,12 @@ var ChangeSetArrayFunctions;
      */
     function _performApplyAfterOnPropertyArray(io_basePropertyChanges, in_appliedPropertyChanges, in_typeid, in_options) {
         property_common_1.ConsoleUtils.assert(in_typeid, "_performApplyAfterOnPropertyArray: typeid missing");
-        property_common_1.ConsoleUtils.assert(!(0, isString_1.default)(io_basePropertyChanges), io_basePropertyChanges);
-        property_common_1.ConsoleUtils.assert(!(0, isString_1.default)(in_appliedPropertyChanges), in_appliedPropertyChanges);
+        property_common_1.ConsoleUtils.assert(!(0, isString_js_1.default)(io_basePropertyChanges), io_basePropertyChanges);
+        property_common_1.ConsoleUtils.assert(!(0, isString_js_1.default)(in_appliedPropertyChanges), in_appliedPropertyChanges);
         const isPrimitiveTypeid = isPrimitiveType(in_typeid);
         // Iterator to process the changes in the ChangeSet in the correct order
-        const iteratorA = new arrayChangesetIterator_1.ArrayChangeSetIterator(io_basePropertyChanges);
-        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator(in_appliedPropertyChanges);
+        const iteratorA = new arrayChangesetIterator_js_1.ArrayChangeSetIterator(io_basePropertyChanges);
+        const iteratorB = new arrayChangesetIterator_js_1.ArrayChangeSetIterator(in_appliedPropertyChanges);
         const rangeA = {};
         const rangeB = {};
         const opA = iteratorA.opDescription;
@@ -1218,13 +1216,13 @@ var ChangeSetArrayFunctions;
             if (lastOpWasNop &&
                 (rangeA.begin === undefined || rangeA.begin >= segment.begin) &&
                 segment.flag === ArrayChangeSetRangeType.completeB &&
-                segment.op.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.INSERT &&
+                segment.op.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.INSERT &&
                 segment.op.operation[0] === canceledSegmentBegin) {
                 indexOffset = lastIndexOffset;
             }
             applySegment.call(this, segment, resultPropertyChanges, indexOffset, lastIteratorARemove, isPrimitiveTypeid);
             lastOpWasNop =
-                segment.opB !== undefined && segment.opB.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.NOP;
+                segment.opB !== undefined && segment.opB.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.NOP;
             if (lastOpWasNop) {
                 canceledSegmentBegin = segment.begin;
             }
@@ -1237,7 +1235,7 @@ var ChangeSetArrayFunctions;
                 // offset has already been incremented by the remove. Therefore, the insert would
                 // be placed behind the remove. We detect this case and correct the offset accordingly
                 // in pushOp
-                if (opA.type === arrayChangesetIterator_1.ArrayChangeSetIterator.types.REMOVE) {
+                if (opA.type === arrayChangesetIterator_js_1.ArrayChangeSetIterator.types.REMOVE) {
                     if (!lastIteratorARemove || lastIteratorARemove.position !== opA.operation[0]) {
                         lastIteratorARemove = {
                             position: opA.operation[0],
@@ -1334,8 +1332,8 @@ var ChangeSetArrayFunctions;
     function _rebaseArrayChangeSetForProperty(in_ownPropertyChangeSet, io_rebasePropertyChangeSet, in_basePath, out_conflicts, in_typeid, in_options) {
         const isPrimitiveTypeid = isPrimitiveType(in_typeid);
         // Iterator to process the changes in the ChangeSet in the correct order
-        const iteratorA = new arrayChangesetIterator_1.ArrayChangeSetIterator(in_ownPropertyChangeSet);
-        const iteratorB = new arrayChangesetIterator_1.ArrayChangeSetIterator(io_rebasePropertyChangeSet);
+        const iteratorA = new arrayChangesetIterator_js_1.ArrayChangeSetIterator(in_ownPropertyChangeSet);
+        const iteratorB = new arrayChangesetIterator_js_1.ArrayChangeSetIterator(io_rebasePropertyChangeSet);
         const opA = iteratorA.opDescription;
         const rangeA = {};
         getRangeForAppliedOperation(opA, rangeA, ArrayChangeSetRangeType.completeA, in_options);
@@ -1471,13 +1469,13 @@ var ChangeSetArrayFunctions;
      * @param out_conflicts - A list of paths that resulted in conflicts together with the type of the conflict
      */
     function _rebaseChangeSetForString(in_ownPropertyChangeSet, io_rebasePropertyChangeSetParent, in_key, in_basePath, out_conflicts, in_options) {
-        if ((0, isString_1.default)(io_rebasePropertyChangeSetParent[in_key]) ||
+        if ((0, isString_js_1.default)(io_rebasePropertyChangeSetParent[in_key]) ||
             (io_rebasePropertyChangeSetParent[in_key] &&
                 io_rebasePropertyChangeSetParent[in_key].hasOwnProperty("value"))) {
             // other overwrites any old changes, we ignore them and report the conflict
             let conflict = {
                 path: in_basePath,
-                type: changesetConflictTypes_1.ConflictType.COLLIDING_SET,
+                type: changesetConflictTypes_js_1.ConflictType.COLLIDING_SET,
                 conflictingChange: (0, fastest_json_copy_1.copy)(in_ownPropertyChangeSet),
             };
             out_conflicts.push(conflict);
@@ -1494,13 +1492,13 @@ var ChangeSetArrayFunctions;
                 delete io_rebasePropertyChangeSetParent[in_key];
             }
         }
-        else if ((0, isString_1.default)(in_ownPropertyChangeSet) ||
+        else if ((0, isString_js_1.default)(in_ownPropertyChangeSet) ||
             (in_ownPropertyChangeSet && in_ownPropertyChangeSet.hasOwnProperty("value"))) {
             // we have a conflict since we cannot allow insert/remove/modify on an unknown state
             // we just ignore other's modifications and take own's set
             let conflict = {
                 path: in_basePath,
-                type: changesetConflictTypes_1.ConflictType.COLLIDING_SET,
+                type: changesetConflictTypes_js_1.ConflictType.COLLIDING_SET,
                 conflictingChange: (0, fastest_json_copy_1.copy)(io_rebasePropertyChangeSetParent[in_key]),
             };
             out_conflicts.push(conflict);