monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/cancellation.js

@@ -0,0 +1,116 @@
+import { Event, Emitter } from './event.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const shortcutEvent = Object.freeze(function (callback, context) {
+    const handle = setTimeout(callback.bind(context), 0);
+    return { dispose() { clearTimeout(handle); } };
+});
+var CancellationToken;
+(function (CancellationToken) {
+    function isCancellationToken(thing) {
+        if (thing === CancellationToken.None || thing === CancellationToken.Cancelled) {
+            return true;
+        }
+        if (thing instanceof MutableToken) {
+            return true;
+        }
+        if (!thing || typeof thing !== 'object') {
+            return false;
+        }
+        return typeof thing.isCancellationRequested === 'boolean'
+            && typeof thing.onCancellationRequested === 'function';
+    }
+    CancellationToken.isCancellationToken = isCancellationToken;
+    CancellationToken.None = Object.freeze({
+        isCancellationRequested: false,
+        onCancellationRequested: Event.None
+    });
+    CancellationToken.Cancelled = Object.freeze({
+        isCancellationRequested: true,
+        onCancellationRequested: shortcutEvent
+    });
+})(CancellationToken || (CancellationToken = {}));
+class MutableToken {
+    constructor() {
+        this._isCancelled = false;
+        this._emitter = null;
+    }
+    cancel() {
+        if (!this._isCancelled) {
+            this._isCancelled = true;
+            if (this._emitter) {
+                this._emitter.fire(undefined);
+                this.dispose();
+            }
+        }
+    }
+    get isCancellationRequested() {
+        return this._isCancelled;
+    }
+    get onCancellationRequested() {
+        if (this._isCancelled) {
+            return shortcutEvent;
+        }
+        if (!this._emitter) {
+            this._emitter = new Emitter();
+        }
+        return this._emitter.event;
+    }
+    dispose() {
+        if (this._emitter) {
+            this._emitter.dispose();
+            this._emitter = null;
+        }
+    }
+}
+class CancellationTokenSource {
+    constructor(parent) {
+        this._token = undefined;
+        this._parentListener = undefined;
+        this._parentListener = parent && parent.onCancellationRequested(this.cancel, this);
+    }
+    get token() {
+        if (!this._token) {
+            // be lazy and create the token only when
+            // actually needed
+            this._token = new MutableToken();
+        }
+        return this._token;
+    }
+    cancel() {
+        if (!this._token) {
+            // save an object by returning the default
+            // cancelled token when cancellation happens
+            // before someone asks for the token
+            this._token = CancellationToken.Cancelled;
+        }
+        else if (this._token instanceof MutableToken) {
+            // actually cancel
+            this._token.cancel();
+        }
+    }
+    dispose(cancel = false) {
+        if (cancel) {
+            this.cancel();
+        }
+        this._parentListener?.dispose();
+        if (!this._token) {
+            // ensure to initialize with an empty token if we had none
+            this._token = CancellationToken.None;
+        }
+        else if (this._token instanceof MutableToken) {
+            // actually dispose
+            this._token.dispose();
+        }
+    }
+}
+function cancelOnDispose(store) {
+    const source = new CancellationTokenSource();
+    store.add({ dispose() { source.cancel(); } });
+    return source.token;
+}
+
+export { CancellationToken, CancellationTokenSource, cancelOnDispose };

package/dist/workers/caretOperations.js

@@ -0,0 +1,48 @@
+import { registerEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { MoveCaretCommand } from './moveCaretCommand.js';
+import { localize2 } from '../../../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class MoveCaretAction extends EditorAction {
+    constructor(left, opts) {
+        super(opts);
+        this.left = left;
+    }
+    run(accessor, editor) {
+        if (!editor.hasModel()) {
+            return;
+        }
+        const commands = [];
+        const selections = editor.getSelections();
+        for (const selection of selections) {
+            commands.push(new MoveCaretCommand(selection, this.left));
+        }
+        editor.pushUndoStop();
+        editor.executeCommands(this.id, commands);
+        editor.pushUndoStop();
+    }
+}
+class MoveCaretLeftAction extends MoveCaretAction {
+    constructor() {
+        super(true, {
+            id: 'editor.action.moveCarretLeftAction',
+            label: localize2(810, "Move Selected Text Left"),
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+class MoveCaretRightAction extends MoveCaretAction {
+    constructor() {
+        super(false, {
+            id: 'editor.action.moveCarretRightAction',
+            label: localize2(811, "Move Selected Text Right"),
+            precondition: EditorContextKeys.writable
+        });
+    }
+}
+registerEditorAction(MoveCaretLeftAction);
+registerEditorAction(MoveCaretRightAction);

package/dist/workers/changeRecorder.js

@@ -0,0 +1,78 @@
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { ILoggerService, canLog, LogLevel } from '../../../../../platform/log/common/log.js';
+import { CodeEditorWidget } from '../../../../browser/widget/codeEditor/codeEditorWidget.js';
+import { StructuredLogger } from '../structuredLogger.js';
+import { observableFromEvent } from '../../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let TextModelChangeRecorder = class TextModelChangeRecorder extends Disposable {
+    constructor(_editor, _instantiationService, _loggerService) {
+        super();
+        this._editor = _editor;
+        this._instantiationService = _instantiationService;
+        this._loggerService = _loggerService;
+        this._structuredLogger = this._register(this._instantiationService.createInstance(StructuredLogger.cast(), 'editor.inlineSuggest.logChangeReason.commandId'));
+        const logger = this._loggerService?.createLogger('textModelChanges', { hidden: false, name: 'Text Model Changes Reason' });
+        const loggingLevel = observableFromEvent(this, logger.onDidChangeLogLevel, () => logger.getLevel());
+        this._register(autorun(reader => {
+            if (!canLog(loggingLevel.read(reader), LogLevel.Trace)) {
+                return;
+            }
+            reader.store.add(this._editor.onDidChangeModelContent((e) => {
+                if (this._editor.getModel()?.uri.scheme === 'output') {
+                    return;
+                }
+                logger.trace('onDidChangeModelContent: ' + e.detailedReasons.map(r => r.toKey(Number.MAX_VALUE)).join(', '));
+            }));
+        }));
+        this._register(autorun(reader => {
+            if (!(this._editor instanceof CodeEditorWidget)) {
+                return;
+            }
+            if (!this._structuredLogger.isEnabled.read(reader)) {
+                return;
+            }
+            reader.store.add(this._editor.onDidChangeModelContent(e => {
+                const tm = this._editor.getModel();
+                if (!tm) {
+                    return;
+                }
+                const reason = e.detailedReasons[0];
+                const data = {
+                    ...reason.metadata,
+                    sourceId: 'TextModel.setChangeReason',
+                    source: reason.metadata.source,
+                    time: Date.now(),
+                    modelUri: tm.uri,
+                    modelVersion: tm.getVersionId(),
+                };
+                setTimeout(() => {
+                    // To ensure that this reaches the extension host after the content change event.
+                    // (Without the setTimeout, I observed this command being called before the content change event arrived)
+                    this._structuredLogger.log(data);
+                }, 0);
+            }));
+        }));
+    }
+};
+TextModelChangeRecorder = __decorate([
+    __param(1, IInstantiationService),
+    __param(2, ILoggerService)
+], TextModelChangeRecorder);
+
+export { TextModelChangeRecorder };

package/dist/workers/changeTracker.js

@@ -0,0 +1,80 @@
+import { BugIndicatingError } from '../errors.js';
+import '../arrays.js';
+import '../event.js';
+import '../lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+function recordChanges(obs) {
+    return {
+        createChangeSummary: (_previousChangeSummary) => {
+            // eslint-disable-next-line local/code-no-any-casts
+            return {
+                changes: [],
+            };
+        },
+        handleChange(ctx, changeSummary) {
+            for (const key in obs) {
+                if (ctx.didChange(obs[key])) {
+                    // eslint-disable-next-line local/code-no-any-casts
+                    changeSummary.changes.push({ key, change: ctx.change });
+                }
+            }
+            return true;
+        },
+        beforeUpdate(reader, changeSummary) {
+            for (const key in obs) {
+                if (key === 'changes') {
+                    throw new BugIndicatingError('property name "changes" is reserved for change tracking');
+                }
+                changeSummary[key] = obs[key].read(reader);
+            }
+        }
+    };
+}
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+function recordChangesLazy(getObs) {
+    let obs = undefined;
+    return {
+        createChangeSummary: (_previousChangeSummary) => {
+            // eslint-disable-next-line local/code-no-any-casts
+            return {
+                changes: [],
+            };
+        },
+        handleChange(ctx, changeSummary) {
+            if (!obs) {
+                obs = getObs();
+            }
+            for (const key in obs) {
+                if (ctx.didChange(obs[key])) {
+                    // eslint-disable-next-line local/code-no-any-casts
+                    changeSummary.changes.push({ key, change: ctx.change });
+                }
+            }
+            return true;
+        },
+        beforeUpdate(reader, changeSummary) {
+            if (!obs) {
+                obs = getObs();
+            }
+            for (const key in obs) {
+                if (key === 'changes') {
+                    throw new BugIndicatingError('property name "changes" is reserved for change tracking');
+                }
+                changeSummary[key] = obs[key].read(reader);
+            }
+        }
+    };
+}
+
+export { recordChanges, recordChangesLazy };

package/dist/workers/charWidthReader.js

@@ -0,0 +1,104 @@
+import { applyFontInfo } from './domFontInfo.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class CharWidthRequest {
+    constructor(chr, type) {
+        this.chr = chr;
+        this.type = type;
+        this.width = 0;
+    }
+    fulfill(width) {
+        this.width = width;
+    }
+}
+class DomCharWidthReader {
+    constructor(bareFontInfo, requests) {
+        this._bareFontInfo = bareFontInfo;
+        this._requests = requests;
+        this._container = null;
+        this._testElements = null;
+    }
+    read(targetWindow) {
+        // Create a test container with all these test elements
+        this._createDomElements();
+        // Add the container to the DOM
+        targetWindow.document.body.appendChild(this._container);
+        // Read character widths
+        this._readFromDomElements();
+        // Remove the container from the DOM
+        this._container?.remove();
+        this._container = null;
+        this._testElements = null;
+    }
+    _createDomElements() {
+        const container = document.createElement('div');
+        container.style.position = 'absolute';
+        container.style.top = '-50000px';
+        container.style.width = '50000px';
+        const regularDomNode = document.createElement('div');
+        applyFontInfo(regularDomNode, this._bareFontInfo);
+        container.appendChild(regularDomNode);
+        const boldDomNode = document.createElement('div');
+        applyFontInfo(boldDomNode, this._bareFontInfo);
+        boldDomNode.style.fontWeight = 'bold';
+        container.appendChild(boldDomNode);
+        const italicDomNode = document.createElement('div');
+        applyFontInfo(italicDomNode, this._bareFontInfo);
+        italicDomNode.style.fontStyle = 'italic';
+        container.appendChild(italicDomNode);
+        const testElements = [];
+        for (const request of this._requests) {
+            let parent;
+            if (request.type === 0 /* CharWidthRequestType.Regular */) {
+                parent = regularDomNode;
+            }
+            if (request.type === 2 /* CharWidthRequestType.Bold */) {
+                parent = boldDomNode;
+            }
+            if (request.type === 1 /* CharWidthRequestType.Italic */) {
+                parent = italicDomNode;
+            }
+            parent.appendChild(document.createElement('br'));
+            const testElement = document.createElement('span');
+            DomCharWidthReader._render(testElement, request);
+            parent.appendChild(testElement);
+            testElements.push(testElement);
+        }
+        this._container = container;
+        this._testElements = testElements;
+    }
+    static _render(testElement, request) {
+        if (request.chr === ' ') {
+            let htmlString = '\u00a0';
+            // Repeat character 256 (2^8) times
+            for (let i = 0; i < 8; i++) {
+                htmlString += htmlString;
+            }
+            testElement.innerText = htmlString;
+        }
+        else {
+            let testString = request.chr;
+            // Repeat character 256 (2^8) times
+            for (let i = 0; i < 8; i++) {
+                testString += testString;
+            }
+            testElement.textContent = testString;
+        }
+    }
+    _readFromDomElements() {
+        for (let i = 0, len = this._requests.length; i < len; i++) {
+            const request = this._requests[i];
+            const testElement = this._testElements[i];
+            request.fulfill(testElement.offsetWidth / 256);
+        }
+    }
+}
+function readCharWidths(targetWindow, bareFontInfo, requests) {
+    const reader = new DomCharWidthReader(bareFontInfo, requests);
+    reader.read(targetWindow);
+}
+
+export { CharWidthRequest, readCharWidths };

package/dist/workers/characterClassifier.js

@@ -0,0 +1,59 @@
+import { toUint8 } 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.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A fast character classifier that uses a compact array for ASCII values.
+ */
+class CharacterClassifier {
+    constructor(_defaultValue) {
+        const defaultValue = toUint8(_defaultValue);
+        this._defaultValue = defaultValue;
+        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
+        this._map = new Map();
+    }
+    static _createAsciiMap(defaultValue) {
+        const asciiMap = new Uint8Array(256);
+        asciiMap.fill(defaultValue);
+        return asciiMap;
+    }
+    set(charCode, _value) {
+        const value = toUint8(_value);
+        if (charCode >= 0 && charCode < 256) {
+            this._asciiMap[charCode] = value;
+        }
+        else {
+            this._map.set(charCode, value);
+        }
+    }
+    get(charCode) {
+        if (charCode >= 0 && charCode < 256) {
+            return this._asciiMap[charCode];
+        }
+        else {
+            return (this._map.get(charCode) || this._defaultValue);
+        }
+    }
+    clear() {
+        this._asciiMap.fill(this._defaultValue);
+        this._map.clear();
+    }
+}
+class CharacterSet {
+    constructor() {
+        this._actual = new CharacterClassifier(0 /* Boolean.False */);
+    }
+    add(charCode) {
+        this._actual.set(charCode, 1 /* Boolean.True */);
+    }
+    has(charCode) {
+        return (this._actual.get(charCode) === 1 /* Boolean.True */);
+    }
+    clear() {
+        return this._actual.clear();
+    }
+}
+
+export { CharacterClassifier, CharacterSet };

package/dist/workers/characterPair.js

@@ -0,0 +1,40 @@
+import { StandardAutoClosingPairConditional } 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 CharacterPairSupport {
+    static { this.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES = ';:.,=}])> \n\t'; }
+    static { this.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = '\'"`;:.,=}])> \n\t'; }
+    constructor(config) {
+        if (config.autoClosingPairs) {
+            this._autoClosingPairs = config.autoClosingPairs.map(el => new StandardAutoClosingPairConditional(el));
+        }
+        else if (config.brackets) {
+            this._autoClosingPairs = config.brackets.map(b => new StandardAutoClosingPairConditional({ open: b[0], close: b[1] }));
+        }
+        else {
+            this._autoClosingPairs = [];
+        }
+        if (config.__electricCharacterSupport && config.__electricCharacterSupport.docComment) {
+            const docComment = config.__electricCharacterSupport.docComment;
+            // IDocComment is legacy, only partially supported
+            this._autoClosingPairs.push(new StandardAutoClosingPairConditional({ open: docComment.open, close: docComment.close || '' }));
+        }
+        this._autoCloseBeforeForQuotes = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES;
+        this._autoCloseBeforeForBrackets = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS;
+        this._surroundingPairs = config.surroundingPairs || this._autoClosingPairs;
+    }
+    getAutoClosingPairs() {
+        return this._autoClosingPairs;
+    }
+    getAutoCloseBeforeSet(forQuotes) {
+        return (forQuotes ? this._autoCloseBeforeForQuotes : this._autoCloseBeforeForBrackets);
+    }
+    getSurroundingPairs() {
+        return this._surroundingPairs;
+    }
+}
+
+export { CharacterPairSupport };

package/dist/workers/chartsColors.js

@@ -0,0 +1,18 @@
+import { localize } from '../../../../nls.js';
+import { registerColor, transparent } from '../colorUtils.js';
+import { foreground } from './baseColors.js';
+import { editorErrorForeground, editorInfoForeground, editorWarningForeground } from './editorColors.js';
+import { minimapFindMatch } from './minimapColors.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+registerColor('charts.foreground', foreground, localize(1790, "The foreground color used in charts."));
+registerColor('charts.lines', transparent(foreground, .5), localize(1791, "The color used for horizontal lines in charts."));
+registerColor('charts.red', editorErrorForeground, localize(1792, "The red color used in chart visualizations."));
+registerColor('charts.blue', editorInfoForeground, localize(1793, "The blue color used in chart visualizations."));
+registerColor('charts.yellow', editorWarningForeground, localize(1794, "The yellow color used in chart visualizations."));
+registerColor('charts.orange', minimapFindMatch, localize(1795, "The orange color used in chart visualizations."));
+registerColor('charts.green', { dark: '#89D185', light: '#388A34', hcDark: '#89D185', hcLight: '#374e06' }, localize(1796, "The green color used in chart visualizations."));
+registerColor('charts.purple', { dark: '#B180D7', light: '#652D90', hcDark: '#B180D7', hcLight: '#652D90' }, localize(1797, "The purple color used in chart visualizations."));