monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/observableValueOpts.js

@@ -0,0 +1,20 @@
+import { DebugNameData } from '../debugName.js';
+import { strictEquals } from '../../equals.js';
+import '../../event.js';
+import '../../lifecycle.js';
+import { ObservableValue } from './observableValue.js';
+import { LazyObservableValue } from './lazyObservableValue.js';
+import { DebugLocation } from '../debugLocation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function observableValueOpts(options, initialValue, debugLocation = DebugLocation.ofCaller()) {
+    if (options.lazy) {
+        return new LazyObservableValue(new DebugNameData(options.owner, options.debugName, undefined), initialValue, options.equalsFn ?? strictEquals, debugLocation);
+    }
+    return new ObservableValue(new DebugNameData(options.owner, options.debugName, undefined), initialValue, options.equalsFn ?? strictEquals, debugLocation);
+}
+
+export { observableValueOpts };

package/dist/workers/offsetRange.js

@@ -0,0 +1,225 @@
+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/onEnter.js

@@ -0,0 +1,109 @@
+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/oneCursor.js

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

package/dist/workers/opener.js

@@ -0,0 +1,43 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const IOpenerService = createDecorator('openerService');
+/**
+ * Encodes selection into the `URI`.
+ *
+ * IMPORTANT: you MUST use `extractSelection` to separate the selection
+ * again from the original `URI` before passing the `URI` into any
+ * component that is not aware of selections.
+ */
+function withSelection(uri, selection) {
+    return uri.with({ fragment: `${selection.startLineNumber},${selection.startColumn}${selection.endLineNumber ? `-${selection.endLineNumber}${selection.endColumn ? `,${selection.endColumn}` : ''}` : ''}` });
+}
+/**
+ * file:///some/file.js#73
+ * file:///some/file.js#L73
+ * file:///some/file.js#73,84
+ * file:///some/file.js#L73,84
+ * file:///some/file.js#73-83
+ * file:///some/file.js#L73-L83
+ * file:///some/file.js#73,84-83,52
+ * file:///some/file.js#L73,84-L83,52
+ */
+function extractSelection(uri) {
+    let selection = undefined;
+    const match = /^L?(\d+)(?:,(\d+))?(-L?(\d+)(?:,(\d+))?)?/.exec(uri.fragment);
+    if (match) {
+        selection = {
+            startLineNumber: parseInt(match[1]),
+            startColumn: match[2] ? parseInt(match[2]) : 1,
+            endLineNumber: match[4] ? parseInt(match[4]) : undefined,
+            endColumn: match[4] ? (match[5] ? parseInt(match[5]) : 1) : undefined
+        };
+        uri = uri.with({ fragment: '' });
+    }
+    return { selection, uri };
+}
+
+export { IOpenerService, extractSelection, withSelection };