monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,142 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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

@@ -1,17 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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 };