monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/position.js

@@ -0,0 +1,142 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A position in the editor.
+ */
+class Position {
+    constructor(lineNumber, column) {
+        this.lineNumber = lineNumber;
+        this.column = column;
+    }
+    /**
+     * Create a new position from this position.
+     *
+     * @param newLineNumber new line number
+     * @param newColumn new column
+     */
+    with(newLineNumber = this.lineNumber, newColumn = this.column) {
+        if (newLineNumber === this.lineNumber && newColumn === this.column) {
+            return this;
+        }
+        else {
+            return new Position(newLineNumber, newColumn);
+        }
+    }
+    /**
+     * Derive a new position from this position.
+     *
+     * @param deltaLineNumber line number delta
+     * @param deltaColumn column delta
+     */
+    delta(deltaLineNumber = 0, deltaColumn = 0) {
+        return this.with(Math.max(1, this.lineNumber + deltaLineNumber), Math.max(1, this.column + deltaColumn));
+    }
+    /**
+     * Test if this position equals other position
+     */
+    equals(other) {
+        return Position.equals(this, other);
+    }
+    /**
+     * Test if position `a` equals position `b`
+     */
+    static equals(a, b) {
+        if (!a && !b) {
+            return true;
+        }
+        return (!!a &&
+            !!b &&
+            a.lineNumber === b.lineNumber &&
+            a.column === b.column);
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be false.
+     */
+    isBefore(other) {
+        return Position.isBefore(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be false.
+     */
+    static isBefore(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column < b.column;
+    }
+    /**
+     * Test if this position is before other position.
+     * If the two positions are equal, the result will be true.
+     */
+    isBeforeOrEqual(other) {
+        return Position.isBeforeOrEqual(this, other);
+    }
+    /**
+     * Test if position `a` is before position `b`.
+     * If the two positions are equal, the result will be true.
+     */
+    static isBeforeOrEqual(a, b) {
+        if (a.lineNumber < b.lineNumber) {
+            return true;
+        }
+        if (b.lineNumber < a.lineNumber) {
+            return false;
+        }
+        return a.column <= b.column;
+    }
+    /**
+     * A function that compares positions, useful for sorting
+     */
+    static compare(a, b) {
+        const aLineNumber = a.lineNumber | 0;
+        const bLineNumber = b.lineNumber | 0;
+        if (aLineNumber === bLineNumber) {
+            const aColumn = a.column | 0;
+            const bColumn = b.column | 0;
+            return aColumn - bColumn;
+        }
+        return aLineNumber - bLineNumber;
+    }
+    /**
+     * Clone this position.
+     */
+    clone() {
+        return new Position(this.lineNumber, this.column);
+    }
+    /**
+     * Convert to a human-readable representation.
+     */
+    toString() {
+        return '(' + this.lineNumber + ',' + this.column + ')';
+    }
+    // ---
+    /**
+     * Create a `Position` from an `IPosition`.
+     */
+    static lift(pos) {
+        return new Position(pos.lineNumber, pos.column);
+    }
+    /**
+     * Test if `obj` is an `IPosition`.
+     */
+    static isIPosition(obj) {
+        return (!!obj
+            && (typeof obj.lineNumber === 'number')
+            && (typeof obj.column === 'number'));
+    }
+    toJSON() {
+        return {
+            lineNumber: this.lineNumber,
+            column: this.column
+        };
+    }
+}
+
+export { Position };

package/dist/workers/editor/common/positionToOffset.js

@@ -0,0 +1,17 @@
+import { StringReplacement, StringEdit } from '../edits/stringEdit.js';
+import { TextEdit, TextReplacement } from '../edits/textEdit.js';
+import { _setPositionOffsetTransformerDependencies } from './positionToOffsetImpl.js';
+export { PositionOffsetTransformer, PositionOffsetTransformerBase } from './positionToOffsetImpl.js';
+import { TextLength } from './textLength.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+_setPositionOffsetTransformerDependencies({
+    StringEdit: StringEdit,
+    StringReplacement: StringReplacement,
+    TextReplacement: TextReplacement,
+    TextEdit: TextEdit,
+    TextLength: TextLength,
+});

package/dist/workers/editor/common/positionToOffsetImpl.js

@@ -0,0 +1,98 @@
+import { findLastIdxMonotonous } from '../../../../base/common/arraysFind.js';
+import { OffsetRange } from '../ranges/offsetRange.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class PositionOffsetTransformerBase {
+    getOffsetRange(range) {
+        return new OffsetRange(this.getOffset(range.getStartPosition()), this.getOffset(range.getEndPosition()));
+    }
+    getRange(offsetRange) {
+        return Range.fromPositions(this.getPosition(offsetRange.start), this.getPosition(offsetRange.endExclusive));
+    }
+    getStringReplacement(edit) {
+        return new Deps.deps.StringReplacement(this.getOffsetRange(edit.range), edit.text);
+    }
+    getTextReplacement(edit) {
+        return new Deps.deps.TextReplacement(this.getRange(edit.replaceRange), edit.newText);
+    }
+    getTextEdit(edit) {
+        const edits = edit.replacements.map(e => this.getTextReplacement(e));
+        return new Deps.deps.TextEdit(edits);
+    }
+}
+class Deps {
+    static { this._deps = undefined; }
+    static get deps() {
+        if (!this._deps) {
+            throw new Error('Dependencies not set. Call _setDependencies first.');
+        }
+        return this._deps;
+    }
+}
+/** This is to break circular module dependencies. */
+function _setPositionOffsetTransformerDependencies(deps) {
+    Deps._deps = deps;
+}
+class PositionOffsetTransformer extends PositionOffsetTransformerBase {
+    constructor(text) {
+        super();
+        this.text = text;
+        this.lineStartOffsetByLineIdx = [];
+        this.lineEndOffsetByLineIdx = [];
+        this.lineStartOffsetByLineIdx.push(0);
+        for (let i = 0; i < text.length; i++) {
+            if (text.charAt(i) === '\n') {
+                this.lineStartOffsetByLineIdx.push(i + 1);
+                if (i > 0 && text.charAt(i - 1) === '\r') {
+                    this.lineEndOffsetByLineIdx.push(i - 1);
+                }
+                else {
+                    this.lineEndOffsetByLineIdx.push(i);
+                }
+            }
+        }
+        this.lineEndOffsetByLineIdx.push(text.length);
+    }
+    getOffset(position) {
+        const valPos = this._validatePosition(position);
+        return this.lineStartOffsetByLineIdx[valPos.lineNumber - 1] + valPos.column - 1;
+    }
+    _validatePosition(position) {
+        if (position.lineNumber < 1) {
+            return new Position(1, 1);
+        }
+        const lineCount = this.textLength.lineCount + 1;
+        if (position.lineNumber > lineCount) {
+            const lineLength = this.getLineLength(lineCount);
+            return new Position(lineCount, lineLength + 1);
+        }
+        if (position.column < 1) {
+            return new Position(position.lineNumber, 1);
+        }
+        const lineLength = this.getLineLength(position.lineNumber);
+        if (position.column - 1 > lineLength) {
+            return new Position(position.lineNumber, lineLength + 1);
+        }
+        return position;
+    }
+    getPosition(offset) {
+        const idx = findLastIdxMonotonous(this.lineStartOffsetByLineIdx, i => i <= offset);
+        const lineNumber = idx + 1;
+        const column = offset - this.lineStartOffsetByLineIdx[idx] + 1;
+        return new Position(lineNumber, column);
+    }
+    get textLength() {
+        const lineIdx = this.lineStartOffsetByLineIdx.length - 1;
+        return new Deps.deps.TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]);
+    }
+    getLineLength(lineNumber) {
+        return this.lineEndOffsetByLineIdx[lineNumber - 1] - this.lineStartOffsetByLineIdx[lineNumber - 1];
+    }
+}
+
+export { PositionOffsetTransformer, PositionOffsetTransformerBase, _setPositionOffsetTransformerDependencies };

package/dist/workers/editor/common/prefixSumComputer.js

@@ -0,0 +1,226 @@
+import { arrayInsert } from '../../../base/common/arrays.js';
+import { toUint32 } from '../../../base/common/uint.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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))
+*/
+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);
+    }
+}
+class PrefixSumIndexOfResult {
+    constructor(index, remainder) {
+        this.index = index;
+        this.remainder = remainder;
+        this._prefixSumIndexOfResultBrand = undefined;
+        this.index = index;
+        this.remainder = remainder;
+    }
+}
+
+export { ConstantTimePrefixSumComputer, PrefixSumComputer, PrefixSumIndexOfResult };