monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/network.js

@@ -0,0 +1,267 @@
+import { onUnexpectedError } from './errors.js';
+import { isWeb, isNative, webWorkerOrigin } from './platform.js';
+import { equalsIgnoreCase, startsWithIgnoreCase } from './strings.js';
+import { URI } from './uri.js';
+import { posix } from './path.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var Schemas;
+(function (Schemas) {
+    /**
+     * A schema that is used for models that exist in memory
+     * only and that have no correspondence on a server or such.
+     */
+    Schemas.inMemory = 'inmemory';
+    /**
+     * A schema that is used for setting files
+     */
+    Schemas.vscode = 'vscode';
+    /**
+     * A schema that is used for internal private files
+     */
+    Schemas.internal = 'private';
+    /**
+     * A walk-through document.
+     */
+    Schemas.walkThrough = 'walkThrough';
+    /**
+     * An embedded code snippet.
+     */
+    Schemas.walkThroughSnippet = 'walkThroughSnippet';
+    Schemas.http = 'http';
+    Schemas.https = 'https';
+    Schemas.file = 'file';
+    Schemas.mailto = 'mailto';
+    Schemas.untitled = 'untitled';
+    Schemas.data = 'data';
+    Schemas.command = 'command';
+    Schemas.vscodeRemote = 'vscode-remote';
+    Schemas.vscodeRemoteResource = 'vscode-remote-resource';
+    Schemas.vscodeManagedRemoteResource = 'vscode-managed-remote-resource';
+    Schemas.vscodeUserData = 'vscode-userdata';
+    Schemas.vscodeCustomEditor = 'vscode-custom-editor';
+    Schemas.vscodeNotebookCell = 'vscode-notebook-cell';
+    Schemas.vscodeNotebookCellMetadata = 'vscode-notebook-cell-metadata';
+    Schemas.vscodeNotebookCellMetadataDiff = 'vscode-notebook-cell-metadata-diff';
+    Schemas.vscodeNotebookCellOutput = 'vscode-notebook-cell-output';
+    Schemas.vscodeNotebookCellOutputDiff = 'vscode-notebook-cell-output-diff';
+    Schemas.vscodeNotebookMetadata = 'vscode-notebook-metadata';
+    Schemas.vscodeInteractiveInput = 'vscode-interactive-input';
+    Schemas.vscodeSettings = 'vscode-settings';
+    Schemas.vscodeWorkspaceTrust = 'vscode-workspace-trust';
+    Schemas.vscodeTerminal = 'vscode-terminal';
+    /** Scheme used for code blocks in chat. */
+    Schemas.vscodeChatCodeBlock = 'vscode-chat-code-block';
+    /** Scheme used for LHS of code compare (aka diff) blocks in chat. */
+    Schemas.vscodeChatCodeCompareBlock = 'vscode-chat-code-compare-block';
+    /** Scheme used for the chat input editor. */
+    Schemas.vscodeChatEditor = 'vscode-chat-editor';
+    /** Scheme used for the chat input part */
+    Schemas.vscodeChatInput = 'chatSessionInput';
+    /** Scheme used for local chat session content */
+    Schemas.vscodeLocalChatSession = 'vscode-chat-session';
+    /**
+     * Scheme used internally for webviews that aren't linked to a resource (i.e. not custom editors)
+     */
+    Schemas.webviewPanel = 'webview-panel';
+    /**
+     * Scheme used for loading the wrapper html and script in webviews.
+     */
+    Schemas.vscodeWebview = 'vscode-webview';
+    /**
+     * Scheme used for extension pages
+     */
+    Schemas.extension = 'extension';
+    /**
+     * Scheme used as a replacement of `file` scheme to load
+     * files with our custom protocol handler (desktop only).
+     */
+    Schemas.vscodeFileResource = 'vscode-file';
+    /**
+     * Scheme used for temporary resources
+     */
+    Schemas.tmp = 'tmp';
+    /**
+     * Scheme used vs live share
+     */
+    Schemas.vsls = 'vsls';
+    /**
+     * Scheme used for the Source Control commit input's text document
+     */
+    Schemas.vscodeSourceControl = 'vscode-scm';
+    /**
+     * Scheme used for input box for creating comments.
+     */
+    Schemas.commentsInput = 'comment';
+    /**
+     * Scheme used for special rendering of settings in the release notes
+     */
+    Schemas.codeSetting = 'code-setting';
+    /**
+     * Scheme used for output panel resources
+     */
+    Schemas.outputChannel = 'output';
+    /**
+     * Scheme used for the accessible view
+     */
+    Schemas.accessibleView = 'accessible-view';
+    /**
+     * Used for snapshots of chat edits
+     */
+    Schemas.chatEditingSnapshotScheme = 'chat-editing-snapshot-text-model';
+    Schemas.chatEditingModel = 'chat-editing-text-model';
+    /**
+     * Used for rendering multidiffs in copilot agent sessions
+     */
+    Schemas.copilotPr = 'copilot-pr';
+})(Schemas || (Schemas = {}));
+function matchesScheme(target, scheme) {
+    if (URI.isUri(target)) {
+        return equalsIgnoreCase(target.scheme, scheme);
+    }
+    else {
+        return startsWithIgnoreCase(target, scheme + ':');
+    }
+}
+function matchesSomeScheme(target, ...schemes) {
+    return schemes.some(scheme => matchesScheme(target, scheme));
+}
+const connectionTokenQueryName = 'tkn';
+class RemoteAuthoritiesImpl {
+    constructor() {
+        this._hosts = Object.create(null);
+        this._ports = Object.create(null);
+        this._connectionTokens = Object.create(null);
+        this._preferredWebSchema = 'http';
+        this._delegate = null;
+        this._serverRootPath = '/';
+    }
+    setPreferredWebSchema(schema) {
+        this._preferredWebSchema = schema;
+    }
+    get _remoteResourcesPath() {
+        return posix.join(this._serverRootPath, Schemas.vscodeRemoteResource);
+    }
+    rewrite(uri) {
+        if (this._delegate) {
+            try {
+                return this._delegate(uri);
+            }
+            catch (err) {
+                onUnexpectedError(err);
+                return uri;
+            }
+        }
+        const authority = uri.authority;
+        let host = this._hosts[authority];
+        if (host && host.indexOf(':') !== -1 && host.indexOf('[') === -1) {
+            host = `[${host}]`;
+        }
+        const port = this._ports[authority];
+        const connectionToken = this._connectionTokens[authority];
+        let query = `path=${encodeURIComponent(uri.path)}`;
+        if (typeof connectionToken === 'string') {
+            query += `&${connectionTokenQueryName}=${encodeURIComponent(connectionToken)}`;
+        }
+        return URI.from({
+            scheme: isWeb ? this._preferredWebSchema : Schemas.vscodeRemoteResource,
+            authority: `${host}:${port}`,
+            path: this._remoteResourcesPath,
+            query
+        });
+    }
+}
+const RemoteAuthorities = new RemoteAuthoritiesImpl();
+const VSCODE_AUTHORITY = 'vscode-app';
+class FileAccessImpl {
+    static { this.FALLBACK_AUTHORITY = VSCODE_AUTHORITY; }
+    /**
+     * Returns a URI to use in contexts where the browser is responsible
+     * for loading (e.g. fetch()) or when used within the DOM.
+     *
+     * **Note:** use `dom.ts#asCSSUrl` whenever the URL is to be used in CSS context.
+     */
+    uriToBrowserUri(uri) {
+        // Handle remote URIs via `RemoteAuthorities`
+        if (uri.scheme === Schemas.vscodeRemote) {
+            return RemoteAuthorities.rewrite(uri);
+        }
+        // Convert to `vscode-file` resource..
+        if (
+        // ...only ever for `file` resources
+        uri.scheme === Schemas.file &&
+            (
+            // ...and we run in native environments
+            isNative ||
+                // ...or web worker extensions on desktop
+                (webWorkerOrigin === `${Schemas.vscodeFileResource}://${FileAccessImpl.FALLBACK_AUTHORITY}`))) {
+            return uri.with({
+                scheme: Schemas.vscodeFileResource,
+                // We need to provide an authority here so that it can serve
+                // as origin for network and loading matters in chromium.
+                // If the URI is not coming with an authority already, we
+                // add our own
+                authority: uri.authority || FileAccessImpl.FALLBACK_AUTHORITY,
+                query: null,
+                fragment: null
+            });
+        }
+        return uri;
+    }
+}
+const FileAccess = new FileAccessImpl();
+var COI;
+(function (COI) {
+    const coiHeaders = new Map([
+        ['1', { 'Cross-Origin-Opener-Policy': 'same-origin' }],
+        ['2', { 'Cross-Origin-Embedder-Policy': 'require-corp' }],
+        ['3', { 'Cross-Origin-Opener-Policy': 'same-origin', 'Cross-Origin-Embedder-Policy': 'require-corp' }],
+    ]);
+    COI.CoopAndCoep = Object.freeze(coiHeaders.get('3'));
+    const coiSearchParamName = 'vscode-coi';
+    /**
+     * Extract desired headers from `vscode-coi` invocation
+     */
+    function getHeadersFromQuery(url) {
+        let params;
+        if (typeof url === 'string') {
+            params = new URL(url).searchParams;
+        }
+        else if (url instanceof URL) {
+            params = url.searchParams;
+        }
+        else if (URI.isUri(url)) {
+            params = new URL(url.toString(true)).searchParams;
+        }
+        const value = params?.get(coiSearchParamName);
+        if (!value) {
+            return undefined;
+        }
+        return coiHeaders.get(value);
+    }
+    COI.getHeadersFromQuery = getHeadersFromQuery;
+    /**
+     * Add the `vscode-coi` query attribute based on wanting `COOP` and `COEP`. Will be a noop when `crossOriginIsolated`
+     * isn't enabled the current context
+     */
+    function addSearchParam(urlOrSearch, coop, coep) {
+        // eslint-disable-next-line local/code-no-any-casts
+        if (!globalThis.crossOriginIsolated) {
+            // depends on the current context being COI
+            return;
+        }
+        const value = coop && coep ? '3' : coep ? '2' : '1';
+        if (urlOrSearch instanceof URLSearchParams) {
+            urlOrSearch.set(coiSearchParamName, value);
+        }
+        else {
+            urlOrSearch[coiSearchParamName] = value;
+        }
+    }
+    COI.addSearchParam = addSearchParam;
+})(COI || (COI = {}));
+
+export { COI, FileAccess, RemoteAuthorities, Schemas, VSCODE_AUTHORITY, connectionTokenQueryName, matchesScheme, matchesSomeScheme };

package/dist/workers/nls.js

@@ -0,0 +1,76 @@
+import { getNLSLanguage, getNLSMessages } from './nls.messages.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// eslint-disable-next-line local/code-import-patterns
+const isPseudo = getNLSLanguage() === 'pseudo' || (typeof document !== 'undefined' && document.location && typeof document.location.hash === 'string' && document.location.hash.indexOf('pseudo=true') >= 0);
+function _format(message, args) {
+    let result;
+    if (args.length === 0) {
+        result = message;
+    }
+    else {
+        result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+            const index = rest[0];
+            const arg = args[index];
+            let result = match;
+            if (typeof arg === 'string') {
+                result = arg;
+            }
+            else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {
+                result = String(arg);
+            }
+            return result;
+        });
+    }
+    if (isPseudo) {
+        // FF3B and FF3D is the Unicode zenkaku representation for [ and ]
+        result = '\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\uFF3D';
+    }
+    return result;
+}
+/**
+ * @skipMangle
+ */
+function localize(data /* | number when built */, message /* | null when built */, ...args) {
+    if (typeof data === 'number') {
+        return _format(lookupMessage(data, message), args);
+    }
+    return _format(message, args);
+}
+/**
+ * Only used when built: Looks up the message in the global NLS table.
+ * This table is being made available as a global through bootstrapping
+ * depending on the target context.
+ */
+function lookupMessage(index, fallback) {
+    const message = getNLSMessages()?.[index];
+    if (typeof message !== 'string') {
+        if (typeof fallback === 'string') {
+            return fallback;
+        }
+        throw new Error(`!!! NLS MISSING: ${index} !!!`);
+    }
+    return message;
+}
+/**
+ * @skipMangle
+ */
+function localize2(data /* | number when built */, originalMessage, ...args) {
+    let message;
+    if (typeof data === 'number') {
+        message = lookupMessage(data, originalMessage);
+    }
+    else {
+        message = originalMessage;
+    }
+    const value = _format(message, args);
+    return {
+        value,
+        original: originalMessage === message ? value : _format(originalMessage, args)
+    };
+}
+
+export { getNLSLanguage, getNLSMessages, localize, localize2 };

package/dist/workers/nls.messages.js

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * This module exists so that the AMD build of the monaco editor can replace this with an async loader plugin.
+ * If you add new functions to this module make sure that they are also provided in the AMD build of the monaco editor.
+ *
+ * TODO@esm remove me once we no longer ship an AMD build.
+ */
+function getNLSMessages() {
+    return globalThis._VSCODE_NLS_MESSAGES;
+}
+function getNLSLanguage() {
+    return globalThis._VSCODE_NLS_LANGUAGE;
+}
+
+export { getNLSLanguage, getNLSMessages };

package/dist/workers/nodeReader.js

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

@@ -0,0 +1,41 @@
+import { LRUCache } from './map.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+new LRUCache(10000);
+const nfdCache = new LRUCache(10000); // bounded to 10000 elements
+function normalizeNFD(str) {
+    return normalize(str, 'NFD', nfdCache);
+}
+const nonAsciiCharactersPattern = /[^\u0000-\u0080]/;
+function normalize(str, form, normalizedCache) {
+    if (!str) {
+        return str;
+    }
+    const cached = normalizedCache.get(str);
+    if (cached) {
+        return cached;
+    }
+    let res;
+    if (nonAsciiCharactersPattern.test(str)) {
+        res = str.normalize(form);
+    }
+    else {
+        res = str;
+    }
+    // Use the cache for fast lookup
+    normalizedCache.set(str, res);
+    return res;
+}
+const removeAccents = (function () {
+    // transform into NFD form and remove accents
+    // see: https://stackoverflow.com/questions/990904/remove-accents-diacritics-in-a-string-in-javascript/37511463#37511463
+    const regex = /[\u0300-\u036f]/g;
+    return function (str) {
+        return normalizeNFD(str).replace(regex, '');
+    };
+})();
+
+export { normalizeNFD, removeAccents };

package/dist/workers/notification.js

@@ -0,0 +1,9 @@
+import Severity$1 from '../../../base/common/severity.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+var Severity = Severity$1;
+const INotificationService = createDecorator('notificationService');
+class NoOpNotification {
+}
+
+export { INotificationService, NoOpNotification, Severity };

package/dist/workers/nullTokenize.js

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

@@ -0,0 +1,45 @@
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+class MovingAverage {
+    constructor() {
+        this._n = 1;
+        this._val = 0;
+    }
+    update(value) {
+        this._val = this._val + (value - this._val) / this._n;
+        this._n += 1;
+        return this._val;
+    }
+    get value() {
+        return this._val;
+    }
+}
+class SlidingWindowAverage {
+    constructor(size) {
+        this._n = 0;
+        this._val = 0;
+        this._values = [];
+        this._index = 0;
+        this._sum = 0;
+        this._values = new Array(size);
+        this._values.fill(0, 0, size);
+    }
+    update(value) {
+        const oldValue = this._values[this._index];
+        this._values[this._index] = value;
+        this._index = (this._index + 1) % this._values.length;
+        this._sum -= oldValue;
+        this._sum += value;
+        if (this._n < this._values.length) {
+            this._n += 1;
+        }
+        this._val = this._sum / this._n;
+        return this._val;
+    }
+    get value() {
+        return this._val;
+    }
+}
+
+export { MovingAverage, SlidingWindowAverage, clamp };