monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,127 +0,0 @@
-import { lengthZero, lengthLessThan, lengthAdd } from './length.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Allows to efficiently find a longest child at a given offset in a fixed node.
- * The requested offsets must increase monotonously.
-*/
-class NodeReader {
-    constructor(node) {
-        this.lastOffset = lengthZero;
-        this.nextNodes = [node];
-        this.offsets = [lengthZero];
-        this.idxs = [];
-    }
-    /**
-     * Returns the longest node at `offset` that satisfies the predicate.
-     * @param offset must be greater than or equal to the last offset this method has been called with!
-    */
-    readLongestNodeAt(offset, predicate) {
-        if (lengthLessThan(offset, this.lastOffset)) {
-            throw new Error('Invalid offset');
-        }
-        this.lastOffset = offset;
-        // Find the longest node of all those that are closest to the current offset.
-        while (true) {
-            const curNode = lastOrUndefined(this.nextNodes);
-            if (!curNode) {
-                return undefined;
-            }
-            const curNodeOffset = lastOrUndefined(this.offsets);
-            if (lengthLessThan(offset, curNodeOffset)) {
-                // The next best node is not here yet.
-                // The reader must advance before a cached node is hit.
-                return undefined;
-            }
-            if (lengthLessThan(curNodeOffset, offset)) {
-                // The reader is ahead of the current node.
-                if (lengthAdd(curNodeOffset, curNode.length) <= offset) {
-                    // The reader is after the end of the current node.
-                    this.nextNodeAfterCurrent();
-                }
-                else {
-                    // The reader is somewhere in the current node.
-                    const nextChildIdx = getNextChildIdx(curNode);
-                    if (nextChildIdx !== -1) {
-                        // Go to the first child and repeat.
-                        this.nextNodes.push(curNode.getChild(nextChildIdx));
-                        this.offsets.push(curNodeOffset);
-                        this.idxs.push(nextChildIdx);
-                    }
-                    else {
-                        // We don't have children
-                        this.nextNodeAfterCurrent();
-                    }
-                }
-            }
-            else {
-                // readerOffsetBeforeChange === curNodeOffset
-                if (predicate(curNode)) {
-                    this.nextNodeAfterCurrent();
-                    return curNode;
-                }
-                else {
-                    const nextChildIdx = getNextChildIdx(curNode);
-                    // look for shorter node
-                    if (nextChildIdx === -1) {
-                        // There is no shorter node.
-                        this.nextNodeAfterCurrent();
-                        return undefined;
-                    }
-                    else {
-                        // Descend into first child & repeat.
-                        this.nextNodes.push(curNode.getChild(nextChildIdx));
-                        this.offsets.push(curNodeOffset);
-                        this.idxs.push(nextChildIdx);
-                    }
-                }
-            }
-        }
-    }
-    // Navigates to the longest node that continues after the current node.
-    nextNodeAfterCurrent() {
-        while (true) {
-            const currentOffset = lastOrUndefined(this.offsets);
-            const currentNode = lastOrUndefined(this.nextNodes);
-            this.nextNodes.pop();
-            this.offsets.pop();
-            if (this.idxs.length === 0) {
-                // We just popped the root node, there is no next node.
-                break;
-            }
-            // Parent is not undefined, because idxs is not empty
-            const parent = lastOrUndefined(this.nextNodes);
-            const nextChildIdx = getNextChildIdx(parent, this.idxs[this.idxs.length - 1]);
-            if (nextChildIdx !== -1) {
-                this.nextNodes.push(parent.getChild(nextChildIdx));
-                this.offsets.push(lengthAdd(currentOffset, currentNode.length));
-                this.idxs[this.idxs.length - 1] = nextChildIdx;
-                break;
-            }
-            else {
-                this.idxs.pop();
-            }
-            // We fully consumed the parent.
-            // Current node is now parent, so call nextNodeAfterCurrent again
-        }
-    }
-}
-function getNextChildIdx(node, curIdx = -1) {
-    while (true) {
-        curIdx++;
-        if (curIdx >= node.childrenLength) {
-            return -1;
-        }
-        if (node.getChild(curIdx)) {
-            return curIdx;
-        }
-    }
-}
-function lastOrUndefined(arr) {
-    return arr.length > 0 ? arr[arr.length - 1] : undefined;
-}
-
-export { NodeReader };

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

@@ -1,29 +0,0 @@
-import { EncodedTokenizationResult, TokenizationResult, Token } from '../languages.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const NullState = new class {
-    clone() {
-        return this;
-    }
-    equals(other) {
-        return (this === other);
-    }
-};
-function nullTokenize(languageId, state) {
-    return new TokenizationResult([new Token(0, '', languageId)], state);
-}
-function nullTokenizeEncoded(languageId, state) {
-    const tokens = new Uint32Array(2);
-    tokens[0] = 0;
-    tokens[1] = ((languageId << 0 /* MetadataConsts.LANGUAGEID_OFFSET */)
-        | (0 /* StandardTokenType.Other */ << 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */)
-        | (0 /* FontStyle.None */ << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)
-        | (1 /* ColorId.DefaultForeground */ << 15 /* MetadataConsts.FOREGROUND_OFFSET */)
-        | (2 /* ColorId.DefaultBackground */ << 24 /* MetadataConsts.BACKGROUND_OFFSET */)) >>> 0;
-    return new EncodedTokenizationResult(tokens, state === null ? NullState : state);
-}
-
-export { NullState, nullTokenize, nullTokenizeEncoded };

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

@@ -1,225 +0,0 @@
-import { BugIndicatingError } from '../../../../base/common/errors.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * A range of offsets (0-based).
-*/
-class OffsetRange {
-    static fromTo(start, endExclusive) {
-        return new OffsetRange(start, endExclusive);
-    }
-    static addRange(range, sortedRanges) {
-        let i = 0;
-        while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {
-            i++;
-        }
-        let j = i;
-        while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) {
-            j++;
-        }
-        if (i === j) {
-            sortedRanges.splice(i, 0, range);
-        }
-        else {
-            const start = Math.min(range.start, sortedRanges[i].start);
-            const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive);
-            sortedRanges.splice(i, j - i, new OffsetRange(start, end));
-        }
-    }
-    static tryCreate(start, endExclusive) {
-        if (start > endExclusive) {
-            return undefined;
-        }
-        return new OffsetRange(start, endExclusive);
-    }
-    static ofLength(length) {
-        return new OffsetRange(0, length);
-    }
-    static ofStartAndLength(start, length) {
-        return new OffsetRange(start, start + length);
-    }
-    static emptyAt(offset) {
-        return new OffsetRange(offset, offset);
-    }
-    constructor(start, endExclusive) {
-        this.start = start;
-        this.endExclusive = endExclusive;
-        if (start > endExclusive) {
-            throw new BugIndicatingError(`Invalid range: ${this.toString()}`);
-        }
-    }
-    get isEmpty() {
-        return this.start === this.endExclusive;
-    }
-    delta(offset) {
-        return new OffsetRange(this.start + offset, this.endExclusive + offset);
-    }
-    deltaStart(offset) {
-        return new OffsetRange(this.start + offset, this.endExclusive);
-    }
-    deltaEnd(offset) {
-        return new OffsetRange(this.start, this.endExclusive + offset);
-    }
-    get length() {
-        return this.endExclusive - this.start;
-    }
-    toString() {
-        return `[${this.start}, ${this.endExclusive})`;
-    }
-    equals(other) {
-        return this.start === other.start && this.endExclusive === other.endExclusive;
-    }
-    contains(offset) {
-        return this.start <= offset && offset < this.endExclusive;
-    }
-    /**
-     * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)
-     * The joined range is the smallest range that contains both ranges.
-     */
-    join(other) {
-        return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));
-    }
-    /**
-     * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)
-     *
-     * The resulting range is empty if the ranges do not intersect, but touch.
-     * If the ranges don't even touch, the result is undefined.
-     */
-    intersect(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        if (start <= end) {
-            return new OffsetRange(start, end);
-        }
-        return undefined;
-    }
-    intersectionLength(range) {
-        const start = Math.max(this.start, range.start);
-        const end = Math.min(this.endExclusive, range.endExclusive);
-        return Math.max(0, end - start);
-    }
-    intersects(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        return start < end;
-    }
-    intersectsOrTouches(other) {
-        const start = Math.max(this.start, other.start);
-        const end = Math.min(this.endExclusive, other.endExclusive);
-        return start <= end;
-    }
-    isBefore(other) {
-        return this.endExclusive <= other.start;
-    }
-    isAfter(other) {
-        return this.start >= other.endExclusive;
-    }
-    slice(arr) {
-        return arr.slice(this.start, this.endExclusive);
-    }
-    substring(str) {
-        return str.substring(this.start, this.endExclusive);
-    }
-    /**
-     * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.
-     * The range must not be empty.
-     */
-    clip(value) {
-        if (this.isEmpty) {
-            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
-        }
-        return Math.max(this.start, Math.min(this.endExclusive - 1, value));
-    }
-    /**
-     * Returns `r := value + k * length` such that `r` is contained in this range.
-     * The range must not be empty.
-     *
-     * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.
-     */
-    clipCyclic(value) {
-        if (this.isEmpty) {
-            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);
-        }
-        if (value < this.start) {
-            return this.endExclusive - ((this.start - value) % this.length);
-        }
-        if (value >= this.endExclusive) {
-            return this.start + ((value - this.start) % this.length);
-        }
-        return value;
-    }
-    forEach(f) {
-        for (let i = this.start; i < this.endExclusive; i++) {
-            f(i);
-        }
-    }
-    /**
-     * this: [ 5, 10), range: [10, 15) => [5, 15)]
-     * Throws if the ranges are not touching.
-    */
-    joinRightTouching(range) {
-        if (this.endExclusive !== range.start) {
-            throw new BugIndicatingError(`Invalid join: ${this.toString()} and ${range.toString()}`);
-        }
-        return new OffsetRange(this.start, range.endExclusive);
-    }
-}
-class OffsetRangeSet {
-    constructor() {
-        this._sortedRanges = [];
-    }
-    addRange(range) {
-        let i = 0;
-        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {
-            i++;
-        }
-        let j = i;
-        while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) {
-            j++;
-        }
-        if (i === j) {
-            this._sortedRanges.splice(i, 0, range);
-        }
-        else {
-            const start = Math.min(range.start, this._sortedRanges[i].start);
-            const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive);
-            this._sortedRanges.splice(i, j - i, new OffsetRange(start, end));
-        }
-    }
-    toString() {
-        return this._sortedRanges.map(r => r.toString()).join(', ');
-    }
-    /**
-     * Returns of there is a value that is contained in this instance and the given range.
-     */
-    intersectsStrict(other) {
-        // TODO use binary search
-        let i = 0;
-        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) {
-            i++;
-        }
-        return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive;
-    }
-    intersectWithRange(other) {
-        // TODO use binary search + slice
-        const result = new OffsetRangeSet();
-        for (const range of this._sortedRanges) {
-            const intersection = range.intersect(other);
-            if (intersection) {
-                result.addRange(intersection);
-            }
-        }
-        return result;
-    }
-    intersectWithRangeLength(other) {
-        return this.intersectWithRange(other).length;
-    }
-    get length() {
-        return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0);
-    }
-}
-
-export { OffsetRange, OffsetRangeSet };

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

@@ -1,109 +0,0 @@
-import { onUnexpectedError } from '../../../../base/common/errors.js';
-import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
-import { IndentAction } from '../languageConfiguration.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class OnEnterSupport {
-    constructor(opts) {
-        opts = opts || {};
-        opts.brackets = opts.brackets || [
-            ['(', ')'],
-            ['{', '}'],
-            ['[', ']']
-        ];
-        this._brackets = [];
-        opts.brackets.forEach((bracket) => {
-            const openRegExp = OnEnterSupport._createOpenBracketRegExp(bracket[0]);
-            const closeRegExp = OnEnterSupport._createCloseBracketRegExp(bracket[1]);
-            if (openRegExp && closeRegExp) {
-                this._brackets.push({
-                    open: bracket[0],
-                    openRegExp: openRegExp,
-                    close: bracket[1],
-                    closeRegExp: closeRegExp,
-                });
-            }
-        });
-        this._regExpRules = opts.onEnterRules || [];
-    }
-    onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText) {
-        // (1): `regExpRules`
-        if (autoIndent >= 3 /* EditorAutoIndentStrategy.Advanced */) {
-            for (let i = 0, len = this._regExpRules.length; i < len; i++) {
-                const rule = this._regExpRules[i];
-                const regResult = [{
-                        reg: rule.beforeText,
-                        text: beforeEnterText
-                    }, {
-                        reg: rule.afterText,
-                        text: afterEnterText
-                    }, {
-                        reg: rule.previousLineText,
-                        text: previousLineText
-                    }].every((obj) => {
-                    if (!obj.reg) {
-                        return true;
-                    }
-                    obj.reg.lastIndex = 0; // To disable the effect of the "g" flag.
-                    return obj.reg.test(obj.text);
-                });
-                if (regResult) {
-                    return rule.action;
-                }
-            }
-        }
-        // (2): Special indent-outdent
-        if (autoIndent >= 2 /* EditorAutoIndentStrategy.Brackets */) {
-            if (beforeEnterText.length > 0 && afterEnterText.length > 0) {
-                for (let i = 0, len = this._brackets.length; i < len; i++) {
-                    const bracket = this._brackets[i];
-                    if (bracket.openRegExp.test(beforeEnterText) && bracket.closeRegExp.test(afterEnterText)) {
-                        return { indentAction: IndentAction.IndentOutdent };
-                    }
-                }
-            }
-        }
-        // (4): Open bracket based logic
-        if (autoIndent >= 2 /* EditorAutoIndentStrategy.Brackets */) {
-            if (beforeEnterText.length > 0) {
-                for (let i = 0, len = this._brackets.length; i < len; i++) {
-                    const bracket = this._brackets[i];
-                    if (bracket.openRegExp.test(beforeEnterText)) {
-                        return { indentAction: IndentAction.Indent };
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    static _createOpenBracketRegExp(bracket) {
-        let str = escapeRegExpCharacters(bracket);
-        if (!/\B/.test(str.charAt(0))) {
-            str = '\\b' + str;
-        }
-        str += '\\s*$';
-        return OnEnterSupport._safeRegExp(str);
-    }
-    static _createCloseBracketRegExp(bracket) {
-        let str = escapeRegExpCharacters(bracket);
-        if (!/\B/.test(str.charAt(str.length - 1))) {
-            str = str + '\\b';
-        }
-        str = '^\\s*' + str;
-        return OnEnterSupport._safeRegExp(str);
-    }
-    static _safeRegExp(def) {
-        try {
-            return new RegExp(def);
-        }
-        catch (err) {
-            onUnexpectedError(err);
-            return null;
-        }
-    }
-}
-
-export { OnEnterSupport };

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

@@ -1,117 +0,0 @@
-import { SingleCursorState, CursorState } from '../cursorCommon.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * Represents a single cursor.
-*/
-class Cursor {
-    constructor(context) {
-        this._selTrackedRange = null;
-        this._trackSelection = true;
-        this._setState(context, new SingleCursorState(new Range(1, 1, 1, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(1, 1), 0), new SingleCursorState(new Range(1, 1, 1, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(1, 1), 0));
-    }
-    dispose(context) {
-        this._removeTrackedRange(context);
-    }
-    startTrackingSelection(context) {
-        this._trackSelection = true;
-        this._updateTrackedRange(context);
-    }
-    stopTrackingSelection(context) {
-        this._trackSelection = false;
-        this._removeTrackedRange(context);
-    }
-    _updateTrackedRange(context) {
-        if (!this._trackSelection) {
-            // don't track the selection
-            return;
-        }
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, this.modelState.selection, 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */);
-    }
-    _removeTrackedRange(context) {
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, null, 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */);
-    }
-    asCursorState() {
-        return new CursorState(this.modelState, this.viewState);
-    }
-    readSelectionFromMarkers(context) {
-        const range = context.model._getTrackedRange(this._selTrackedRange);
-        if (this.modelState.selection.isEmpty() && !range.isEmpty()) {
-            // Avoid selecting text when recovering from markers
-            return Selection.fromRange(range.collapseToEnd(), this.modelState.selection.getDirection());
-        }
-        return Selection.fromRange(range, this.modelState.selection.getDirection());
-    }
-    ensureValidState(context) {
-        this._setState(context, this.modelState, this.viewState);
-    }
-    setState(context, modelState, viewState) {
-        this._setState(context, modelState, viewState);
-    }
-    static _validatePositionWithCache(viewModel, position, cacheInput, cacheOutput) {
-        if (position.equals(cacheInput)) {
-            return cacheOutput;
-        }
-        return viewModel.normalizePosition(position, 2 /* PositionAffinity.None */);
-    }
-    static _validateViewState(viewModel, viewState) {
-        const position = viewState.position;
-        const sStartPosition = viewState.selectionStart.getStartPosition();
-        const sEndPosition = viewState.selectionStart.getEndPosition();
-        const validPosition = viewModel.normalizePosition(position, 2 /* PositionAffinity.None */);
-        const validSStartPosition = this._validatePositionWithCache(viewModel, sStartPosition, position, validPosition);
-        const validSEndPosition = this._validatePositionWithCache(viewModel, sEndPosition, sStartPosition, validSStartPosition);
-        if (position.equals(validPosition) && sStartPosition.equals(validSStartPosition) && sEndPosition.equals(validSEndPosition)) {
-            // fast path: the state is valid
-            return viewState;
-        }
-        return new SingleCursorState(Range.fromPositions(validSStartPosition, validSEndPosition), viewState.selectionStartKind, viewState.selectionStartLeftoverVisibleColumns + sStartPosition.column - validSStartPosition.column, validPosition, viewState.leftoverVisibleColumns + position.column - validPosition.column);
-    }
-    _setState(context, modelState, viewState) {
-        if (viewState) {
-            viewState = Cursor._validateViewState(context.viewModel, viewState);
-        }
-        if (!modelState) {
-            if (!viewState) {
-                return;
-            }
-            // We only have the view state => compute the model state
-            const selectionStart = context.model.validateRange(context.coordinatesConverter.convertViewRangeToModelRange(viewState.selectionStart));
-            const position = context.model.validatePosition(context.coordinatesConverter.convertViewPositionToModelPosition(viewState.position));
-            modelState = new SingleCursorState(selectionStart, viewState.selectionStartKind, viewState.selectionStartLeftoverVisibleColumns, position, viewState.leftoverVisibleColumns);
-        }
-        else {
-            // Validate new model state
-            const selectionStart = context.model.validateRange(modelState.selectionStart);
-            const selectionStartLeftoverVisibleColumns = modelState.selectionStart.equalsRange(selectionStart) ? modelState.selectionStartLeftoverVisibleColumns : 0;
-            const position = context.model.validatePosition(modelState.position);
-            const leftoverVisibleColumns = modelState.position.equals(position) ? modelState.leftoverVisibleColumns : 0;
-            modelState = new SingleCursorState(selectionStart, modelState.selectionStartKind, selectionStartLeftoverVisibleColumns, position, leftoverVisibleColumns);
-        }
-        if (!viewState) {
-            // We only have the model state => compute the view state
-            const viewSelectionStart1 = context.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelState.selectionStart.startLineNumber, modelState.selectionStart.startColumn));
-            const viewSelectionStart2 = context.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelState.selectionStart.endLineNumber, modelState.selectionStart.endColumn));
-            const viewSelectionStart = new Range(viewSelectionStart1.lineNumber, viewSelectionStart1.column, viewSelectionStart2.lineNumber, viewSelectionStart2.column);
-            const viewPosition = context.coordinatesConverter.convertModelPositionToViewPosition(modelState.position);
-            viewState = new SingleCursorState(viewSelectionStart, modelState.selectionStartKind, modelState.selectionStartLeftoverVisibleColumns, viewPosition, modelState.leftoverVisibleColumns);
-        }
-        else {
-            // Validate new view state
-            const viewSelectionStart = context.coordinatesConverter.validateViewRange(viewState.selectionStart, modelState.selectionStart);
-            const viewPosition = context.coordinatesConverter.validateViewPosition(viewState.position, modelState.position);
-            viewState = new SingleCursorState(viewSelectionStart, modelState.selectionStartKind, modelState.selectionStartLeftoverVisibleColumns, viewPosition, modelState.leftoverVisibleColumns);
-        }
-        this.modelState = modelState;
-        this.viewState = viewState;
-        this._updateTrackedRange(context);
-    }
-}
-
-export { Cursor };