@umbraco-cms/backoffice 15.3.0 → 15.4.0-rc

package/dist-cms/monaco-editor/vs/editor/common/model/pieceTreeTextBuffer/rbTreeBase.js

@@ -0,0 +1,360 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export class TreeNode {
+    constructor(piece, color) {
+        this.piece = piece;
+        this.color = color;
+        this.size_left = 0;
+        this.lf_left = 0;
+        this.parent = this;
+        this.left = this;
+        this.right = this;
+    }
+    next() {
+        if (this.right !== SENTINEL) {
+            return leftest(this.right);
+        }
+        let node = this;
+        while (node.parent !== SENTINEL) {
+            if (node.parent.left === node) {
+                break;
+            }
+            node = node.parent;
+        }
+        if (node.parent === SENTINEL) {
+            return SENTINEL;
+        }
+        else {
+            return node.parent;
+        }
+    }
+    prev() {
+        if (this.left !== SENTINEL) {
+            return righttest(this.left);
+        }
+        let node = this;
+        while (node.parent !== SENTINEL) {
+            if (node.parent.right === node) {
+                break;
+            }
+            node = node.parent;
+        }
+        if (node.parent === SENTINEL) {
+            return SENTINEL;
+        }
+        else {
+            return node.parent;
+        }
+    }
+    detach() {
+        this.parent = null;
+        this.left = null;
+        this.right = null;
+    }
+}
+export const SENTINEL = new TreeNode(null, 0 /* NodeColor.Black */);
+SENTINEL.parent = SENTINEL;
+SENTINEL.left = SENTINEL;
+SENTINEL.right = SENTINEL;
+SENTINEL.color = 0 /* NodeColor.Black */;
+export function leftest(node) {
+    while (node.left !== SENTINEL) {
+        node = node.left;
+    }
+    return node;
+}
+export function righttest(node) {
+    while (node.right !== SENTINEL) {
+        node = node.right;
+    }
+    return node;
+}
+function calculateSize(node) {
+    if (node === SENTINEL) {
+        return 0;
+    }
+    return node.size_left + node.piece.length + calculateSize(node.right);
+}
+function calculateLF(node) {
+    if (node === SENTINEL) {
+        return 0;
+    }
+    return node.lf_left + node.piece.lineFeedCnt + calculateLF(node.right);
+}
+function resetSentinel() {
+    SENTINEL.parent = SENTINEL;
+}
+export function leftRotate(tree, x) {
+    const y = x.right;
+    // fix size_left
+    y.size_left += x.size_left + (x.piece ? x.piece.length : 0);
+    y.lf_left += x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);
+    x.right = y.left;
+    if (y.left !== SENTINEL) {
+        y.left.parent = x;
+    }
+    y.parent = x.parent;
+    if (x.parent === SENTINEL) {
+        tree.root = y;
+    }
+    else if (x.parent.left === x) {
+        x.parent.left = y;
+    }
+    else {
+        x.parent.right = y;
+    }
+    y.left = x;
+    x.parent = y;
+}
+export function rightRotate(tree, y) {
+    const x = y.left;
+    y.left = x.right;
+    if (x.right !== SENTINEL) {
+        x.right.parent = y;
+    }
+    x.parent = y.parent;
+    // fix size_left
+    y.size_left -= x.size_left + (x.piece ? x.piece.length : 0);
+    y.lf_left -= x.lf_left + (x.piece ? x.piece.lineFeedCnt : 0);
+    if (y.parent === SENTINEL) {
+        tree.root = x;
+    }
+    else if (y === y.parent.right) {
+        y.parent.right = x;
+    }
+    else {
+        y.parent.left = x;
+    }
+    x.right = y;
+    y.parent = x;
+}
+export function rbDelete(tree, z) {
+    let x;
+    let y;
+    if (z.left === SENTINEL) {
+        y = z;
+        x = y.right;
+    }
+    else if (z.right === SENTINEL) {
+        y = z;
+        x = y.left;
+    }
+    else {
+        y = leftest(z.right);
+        x = y.right;
+    }
+    if (y === tree.root) {
+        tree.root = x;
+        // if x is null, we are removing the only node
+        x.color = 0 /* NodeColor.Black */;
+        z.detach();
+        resetSentinel();
+        tree.root.parent = SENTINEL;
+        return;
+    }
+    const yWasRed = (y.color === 1 /* NodeColor.Red */);
+    if (y === y.parent.left) {
+        y.parent.left = x;
+    }
+    else {
+        y.parent.right = x;
+    }
+    if (y === z) {
+        x.parent = y.parent;
+        recomputeTreeMetadata(tree, x);
+    }
+    else {
+        if (y.parent === z) {
+            x.parent = y;
+        }
+        else {
+            x.parent = y.parent;
+        }
+        // as we make changes to x's hierarchy, update size_left of subtree first
+        recomputeTreeMetadata(tree, x);
+        y.left = z.left;
+        y.right = z.right;
+        y.parent = z.parent;
+        y.color = z.color;
+        if (z === tree.root) {
+            tree.root = y;
+        }
+        else {
+            if (z === z.parent.left) {
+                z.parent.left = y;
+            }
+            else {
+                z.parent.right = y;
+            }
+        }
+        if (y.left !== SENTINEL) {
+            y.left.parent = y;
+        }
+        if (y.right !== SENTINEL) {
+            y.right.parent = y;
+        }
+        // update metadata
+        // we replace z with y, so in this sub tree, the length change is z.item.length
+        y.size_left = z.size_left;
+        y.lf_left = z.lf_left;
+        recomputeTreeMetadata(tree, y);
+    }
+    z.detach();
+    if (x.parent.left === x) {
+        const newSizeLeft = calculateSize(x);
+        const newLFLeft = calculateLF(x);
+        if (newSizeLeft !== x.parent.size_left || newLFLeft !== x.parent.lf_left) {
+            const delta = newSizeLeft - x.parent.size_left;
+            const lf_delta = newLFLeft - x.parent.lf_left;
+            x.parent.size_left = newSizeLeft;
+            x.parent.lf_left = newLFLeft;
+            updateTreeMetadata(tree, x.parent, delta, lf_delta);
+        }
+    }
+    recomputeTreeMetadata(tree, x.parent);
+    if (yWasRed) {
+        resetSentinel();
+        return;
+    }
+    // RB-DELETE-FIXUP
+    let w;
+    while (x !== tree.root && x.color === 0 /* NodeColor.Black */) {
+        if (x === x.parent.left) {
+            w = x.parent.right;
+            if (w.color === 1 /* NodeColor.Red */) {
+                w.color = 0 /* NodeColor.Black */;
+                x.parent.color = 1 /* NodeColor.Red */;
+                leftRotate(tree, x.parent);
+                w = x.parent.right;
+            }
+            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {
+                w.color = 1 /* NodeColor.Red */;
+                x = x.parent;
+            }
+            else {
+                if (w.right.color === 0 /* NodeColor.Black */) {
+                    w.left.color = 0 /* NodeColor.Black */;
+                    w.color = 1 /* NodeColor.Red */;
+                    rightRotate(tree, w);
+                    w = x.parent.right;
+                }
+                w.color = x.parent.color;
+                x.parent.color = 0 /* NodeColor.Black */;
+                w.right.color = 0 /* NodeColor.Black */;
+                leftRotate(tree, x.parent);
+                x = tree.root;
+            }
+        }
+        else {
+            w = x.parent.left;
+            if (w.color === 1 /* NodeColor.Red */) {
+                w.color = 0 /* NodeColor.Black */;
+                x.parent.color = 1 /* NodeColor.Red */;
+                rightRotate(tree, x.parent);
+                w = x.parent.left;
+            }
+            if (w.left.color === 0 /* NodeColor.Black */ && w.right.color === 0 /* NodeColor.Black */) {
+                w.color = 1 /* NodeColor.Red */;
+                x = x.parent;
+            }
+            else {
+                if (w.left.color === 0 /* NodeColor.Black */) {
+                    w.right.color = 0 /* NodeColor.Black */;
+                    w.color = 1 /* NodeColor.Red */;
+                    leftRotate(tree, w);
+                    w = x.parent.left;
+                }
+                w.color = x.parent.color;
+                x.parent.color = 0 /* NodeColor.Black */;
+                w.left.color = 0 /* NodeColor.Black */;
+                rightRotate(tree, x.parent);
+                x = tree.root;
+            }
+        }
+    }
+    x.color = 0 /* NodeColor.Black */;
+    resetSentinel();
+}
+export function fixInsert(tree, x) {
+    recomputeTreeMetadata(tree, x);
+    while (x !== tree.root && x.parent.color === 1 /* NodeColor.Red */) {
+        if (x.parent === x.parent.parent.left) {
+            const y = x.parent.parent.right;
+            if (y.color === 1 /* NodeColor.Red */) {
+                x.parent.color = 0 /* NodeColor.Black */;
+                y.color = 0 /* NodeColor.Black */;
+                x.parent.parent.color = 1 /* NodeColor.Red */;
+                x = x.parent.parent;
+            }
+            else {
+                if (x === x.parent.right) {
+                    x = x.parent;
+                    leftRotate(tree, x);
+                }
+                x.parent.color = 0 /* NodeColor.Black */;
+                x.parent.parent.color = 1 /* NodeColor.Red */;
+                rightRotate(tree, x.parent.parent);
+            }
+        }
+        else {
+            const y = x.parent.parent.left;
+            if (y.color === 1 /* NodeColor.Red */) {
+                x.parent.color = 0 /* NodeColor.Black */;
+                y.color = 0 /* NodeColor.Black */;
+                x.parent.parent.color = 1 /* NodeColor.Red */;
+                x = x.parent.parent;
+            }
+            else {
+                if (x === x.parent.left) {
+                    x = x.parent;
+                    rightRotate(tree, x);
+                }
+                x.parent.color = 0 /* NodeColor.Black */;
+                x.parent.parent.color = 1 /* NodeColor.Red */;
+                leftRotate(tree, x.parent.parent);
+            }
+        }
+    }
+    tree.root.color = 0 /* NodeColor.Black */;
+}
+export function updateTreeMetadata(tree, x, delta, lineFeedCntDelta) {
+    // node length change or line feed count change
+    while (x !== tree.root && x !== SENTINEL) {
+        if (x.parent.left === x) {
+            x.parent.size_left += delta;
+            x.parent.lf_left += lineFeedCntDelta;
+        }
+        x = x.parent;
+    }
+}
+export function recomputeTreeMetadata(tree, x) {
+    let delta = 0;
+    let lf_delta = 0;
+    if (x === tree.root) {
+        return;
+    }
+    // go upwards till the node whose left subtree is changed.
+    while (x !== tree.root && x === x.parent.right) {
+        x = x.parent;
+    }
+    if (x === tree.root) {
+        // well, it means we add a node to the end (inorder)
+        return;
+    }
+    // x is the node whose right subtree is changed.
+    x = x.parent;
+    delta = calculateSize(x.left) - x.size_left;
+    lf_delta = calculateLF(x.left) - x.lf_left;
+    x.size_left += delta;
+    x.lf_left += lf_delta;
+    // go upwards till root. O(logN)
+    while (x !== tree.root && (delta !== 0 || lf_delta !== 0)) {
+        if (x.parent.left === x) {
+            x.parent.size_left += delta;
+            x.parent.lf_left += lf_delta;
+        }
+        x = x.parent;
+    }
+}

package/dist-cms/monaco-editor/vs/editor/common/model/prefixSumComputer.js

@@ -0,0 +1,223 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { arrayInsert } from '../../../base/common/arrays.js';
+import { toUint32 } from '../../../base/common/uint.js';
+export class PrefixSumComputer {
+    constructor(values) {
+        this.values = values;
+        this.prefixSum = new Uint32Array(values.length);
+        this.prefixSumValidIndex = new Int32Array(1);
+        this.prefixSumValidIndex[0] = -1;
+    }
+    insertValues(insertIndex, insertValues) {
+        insertIndex = toUint32(insertIndex);
+        const oldValues = this.values;
+        const oldPrefixSum = this.prefixSum;
+        const insertValuesLen = insertValues.length;
+        if (insertValuesLen === 0) {
+            return false;
+        }
+        this.values = new Uint32Array(oldValues.length + insertValuesLen);
+        this.values.set(oldValues.subarray(0, insertIndex), 0);
+        this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);
+        this.values.set(insertValues, insertIndex);
+        if (insertIndex - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = insertIndex - 1;
+        }
+        this.prefixSum = new Uint32Array(this.values.length);
+        if (this.prefixSumValidIndex[0] >= 0) {
+            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+        }
+        return true;
+    }
+    setValue(index, value) {
+        index = toUint32(index);
+        value = toUint32(value);
+        if (this.values[index] === value) {
+            return false;
+        }
+        this.values[index] = value;
+        if (index - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = index - 1;
+        }
+        return true;
+    }
+    removeValues(startIndex, count) {
+        startIndex = toUint32(startIndex);
+        count = toUint32(count);
+        const oldValues = this.values;
+        const oldPrefixSum = this.prefixSum;
+        if (startIndex >= oldValues.length) {
+            return false;
+        }
+        const maxCount = oldValues.length - startIndex;
+        if (count >= maxCount) {
+            count = maxCount;
+        }
+        if (count === 0) {
+            return false;
+        }
+        this.values = new Uint32Array(oldValues.length - count);
+        this.values.set(oldValues.subarray(0, startIndex), 0);
+        this.values.set(oldValues.subarray(startIndex + count), startIndex);
+        this.prefixSum = new Uint32Array(this.values.length);
+        if (startIndex - 1 < this.prefixSumValidIndex[0]) {
+            this.prefixSumValidIndex[0] = startIndex - 1;
+        }
+        if (this.prefixSumValidIndex[0] >= 0) {
+            this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+        }
+        return true;
+    }
+    getTotalSum() {
+        if (this.values.length === 0) {
+            return 0;
+        }
+        return this._getPrefixSum(this.values.length - 1);
+    }
+    /**
+     * Returns the sum of the first `index + 1` many items.
+     * @returns `SUM(0 <= j <= index, values[j])`.
+     */
+    getPrefixSum(index) {
+        if (index < 0) {
+            return 0;
+        }
+        index = toUint32(index);
+        return this._getPrefixSum(index);
+    }
+    _getPrefixSum(index) {
+        if (index <= this.prefixSumValidIndex[0]) {
+            return this.prefixSum[index];
+        }
+        let startIndex = this.prefixSumValidIndex[0] + 1;
+        if (startIndex === 0) {
+            this.prefixSum[0] = this.values[0];
+            startIndex++;
+        }
+        if (index >= this.values.length) {
+            index = this.values.length - 1;
+        }
+        for (let i = startIndex; i <= index; i++) {
+            this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];
+        }
+        this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);
+        return this.prefixSum[index];
+    }
+    getIndexOf(sum) {
+        sum = Math.floor(sum);
+        // Compute all sums (to get a fully valid prefixSum)
+        this.getTotalSum();
+        let low = 0;
+        let high = this.values.length - 1;
+        let mid = 0;
+        let midStop = 0;
+        let midStart = 0;
+        while (low <= high) {
+            mid = low + ((high - low) / 2) | 0;
+            midStop = this.prefixSum[mid];
+            midStart = midStop - this.values[mid];
+            if (sum < midStart) {
+                high = mid - 1;
+            }
+            else if (sum >= midStop) {
+                low = mid + 1;
+            }
+            else {
+                break;
+            }
+        }
+        return new PrefixSumIndexOfResult(mid, sum - midStart);
+    }
+}
+/**
+ * {@link getIndexOf} has an amortized runtime complexity of O(1).
+ *
+ * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))
+*/
+export class ConstantTimePrefixSumComputer {
+    constructor(values) {
+        this._values = values;
+        this._isValid = false;
+        this._validEndIndex = -1;
+        this._prefixSum = [];
+        this._indexBySum = [];
+    }
+    /**
+     * @returns SUM(0 <= j < values.length, values[j])
+     */
+    getTotalSum() {
+        this._ensureValid();
+        return this._indexBySum.length;
+    }
+    /**
+     * Returns the sum of the first `count` many items.
+     * @returns `SUM(0 <= j < count, values[j])`.
+     */
+    getPrefixSum(count) {
+        this._ensureValid();
+        if (count === 0) {
+            return 0;
+        }
+        return this._prefixSum[count - 1];
+    }
+    /**
+     * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`
+     */
+    getIndexOf(sum) {
+        this._ensureValid();
+        const idx = this._indexBySum[sum];
+        const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;
+        return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);
+    }
+    removeValues(start, deleteCount) {
+        this._values.splice(start, deleteCount);
+        this._invalidate(start);
+    }
+    insertValues(insertIndex, insertArr) {
+        this._values = arrayInsert(this._values, insertIndex, insertArr);
+        this._invalidate(insertIndex);
+    }
+    _invalidate(index) {
+        this._isValid = false;
+        this._validEndIndex = Math.min(this._validEndIndex, index - 1);
+    }
+    _ensureValid() {
+        if (this._isValid) {
+            return;
+        }
+        for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {
+            const value = this._values[i];
+            const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;
+            this._prefixSum[i] = sumAbove + value;
+            for (let j = 0; j < value; j++) {
+                this._indexBySum[sumAbove + j] = i;
+            }
+        }
+        // trim things
+        this._prefixSum.length = this._values.length;
+        this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];
+        // mark as valid
+        this._isValid = true;
+        this._validEndIndex = this._values.length - 1;
+    }
+    setValue(index, value) {
+        if (this._values[index] === value) {
+            // no change
+            return;
+        }
+        this._values[index] = value;
+        this._invalidate(index);
+    }
+}
+export class PrefixSumIndexOfResult {
+    constructor(index, remainder) {
+        this.index = index;
+        this.remainder = remainder;
+        this._prefixSumIndexOfResultBrand = undefined;
+        this.index = index;
+        this.remainder = remainder;
+    }
+}