@codingame/monaco-vscode-editor-api 11.1.1 → 12.0.0

package/esm/vs/editor/editor.api.js

@@ -1,2316 +1,9 @@
-import { ConfigurationChangedEvent, ApplyUpdateResult, EditorOptions } from 'vscode/vscode/vs/editor/common/config/editorOptions';
-import { createMonacoBaseAPI } from 'vscode/vscode/vs/editor/common/services/editorBaseApi';
-import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { startsWithUTF8BOM, splitLines } from 'vscode/vscode/vs/base/common/strings';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css.js';
-import { FontMeasurements } from 'vscode/vscode/vs/editor/browser/config/fontMeasurements';
-import { EditorCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { getAllMethodNames } from 'vscode/vscode/vs/base/common/objects';
-import { EditorWorkerClient } from 'vscode/vscode/vs/editor/browser/services/editorWorkerService';
-import { standaloneEditorWorkerDescriptor, StandaloneServices, StandaloneKeybindingService } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
-import { EditorZoom } from 'vscode/vscode/vs/editor/common/config/editorZoom';
-import { BareFontInfo, FontInfo } from 'vscode/vscode/vs/editor/common/config/fontInfo';
-import { EditorType } from 'vscode/vscode/vs/editor/common/editorCommon';
-import { Token as Token$1, TokenizationRegistry, TokenizationResult, EncodedTokenizationResult, LazyTokenizationSupport, FoldingRangeKind, SelectedSuggestionInfo } from 'vscode/vscode/vs/editor/common/languages';
-import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
-import { PLAINTEXT_LANGUAGE_ID, ModesRegistry } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
-import { nullTokenize, nullTokenizeEncoded, NullState } from 'vscode/vscode/vs/editor/common/languages/nullTokenize';
-import { TextModelResolvedOptions, FindMatch } from 'vscode/vscode/vs/editor/common/model';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { AccessibilitySupport, ContentWidgetPositionPreference, CursorChangeReason, DefaultEndOfLine, EditorAutoIndentStrategy, EditorOption, EndOfLinePreference, EndOfLineSequence, MinimapPosition, MinimapSectionHeaderStyle, MouseTargetType, OverlayWidgetPositionPreference, OverviewRulerLane, GlyphMarginLane, RenderLineNumbersType, RenderMinimap, ScrollbarVisibility, ScrollType, TextEditorCursorBlinkingStyle, TextEditorCursorStyle, TrackedRangeStickiness, WrappingIndent, InjectedTextCursorStops, PositionAffinity, ShowLightbulbIconMode, DocumentHighlightKind, CompletionItemKind, CompletionItemTag, CompletionItemInsertTextRule, SymbolKind, SymbolTag, IndentAction, CompletionTriggerKind, SignatureHelpTriggerKind, InlayHintKind, InlineCompletionTriggerKind, InlineEditTriggerKind, CodeActionTriggerType, NewSymbolNameTag, NewSymbolNameTriggerKind, PartialAcceptTriggerKind, HoverVerbosityAction } from 'vscode/vscode/vs/editor/common/standalone/standaloneEnums';
-import { createTrustedTypesPolicy } from 'vscode/vscode/vs/base/browser/trustedTypes';
-import { LineTokens } from 'vscode/vscode/vs/editor/common/tokens/lineTokens';
-import { renderViewLine2, RenderLineInput } from 'vscode/vscode/vs/editor/common/viewLayout/viewLineRenderer';
-import { ViewLineRenderingData } from 'vscode/vscode/vs/editor/common/viewModel';
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { StandaloneEditor, StandaloneDiffEditor2, createTextModel } from 'vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor';
-import { IStandaloneThemeService } from 'vscode/vscode/vs/editor/standalone/common/standaloneTheme';
-import { MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
-import { IMarkerService } from 'vscode/vscode/vs/platform/markers/common/markers.service';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
-import { MultiDiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget';
-import { Color } from 'vscode/vscode/vs/base/common/color';
-import { Range as Range$1 } from 'vscode/vscode/vs/editor/common/core/range';
-import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { FormattingConflicts } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
+
+import { languages, editor } from '../../../vscode/src/vs/editor/editor.api.js';
+export { CancellationTokenSource, Emitter, KeyCode, KeyMod, MarkerSeverity, MarkerTag, Position, Range, Selection, SelectionDirection, Token, Uri } from '../../../vscode/src/vs/editor/editor.api.js';
 import { createConfiguredEditor, createConfiguredDiffEditor, createModelReference, writeFile } from 'vscode/monaco';
 import { withReadyServices } from 'vscode/services';
 
-var css = ".monaco-editor.standalone{--monaco-monospace-font:\"SF Mono\",Monaco,Menlo,Consolas,\"Ubuntu Mono\",\"Liberation Mono\",\"DejaVu Sans Mono\",\"Courier New\",monospace;font-family:-apple-system,BlinkMacSystemFont,Segoe WPC,Segoe UI,HelveticaNeue-Light,system-ui,Ubuntu,Droid Sans,sans-serif}.monaco-editor.standalone.hc-black .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,.monaco-editor.standalone.hc-light .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,.monaco-editor.standalone.vs-dark .monaco-menu .monaco-action-bar.vertical .action-menu-item:focus .action-label,.monaco-menu .monaco-action-bar.vertical .action-item .action-menu-item:focus .action-label{stroke-width:1.2px}.monaco-hover p{margin:0}.monaco-aria-container{clip:rect(1px,1px,1px,1px);clip-path:inset(50%);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute!important;top:0;width:1px}.monaco-diff-editor.standalone .synthetic-focus,.monaco-diff-editor.standalone [tabindex=\"-1\"]:focus,.monaco-diff-editor.standalone [tabindex=\"0\"]:focus,.monaco-diff-editor.standalone button:focus,.monaco-diff-editor.standalone input[type=button]:focus,.monaco-diff-editor.standalone input[type=checkbox]:focus,.monaco-diff-editor.standalone input[type=search]:focus,.monaco-diff-editor.standalone input[type=text]:focus,.monaco-diff-editor.standalone select:focus,.monaco-diff-editor.standalone textarea:focus,.monaco-editor.standalone .synthetic-focus,.monaco-editor.standalone [tabindex=\"-1\"]:focus,.monaco-editor.standalone [tabindex=\"0\"]:focus,.monaco-editor.standalone button:focus,.monaco-editor.standalone input[type=button]:focus,.monaco-editor.standalone input[type=checkbox]:focus,.monaco-editor.standalone input[type=search]:focus,.monaco-editor.standalone input[type=text]:focus,.monaco-editor.standalone select:focus,.monaco-editor.standalone textarea:focus{opacity:1;outline-color:var(--vscode-focusBorder);outline-offset:-1px;outline-style:solid;outline-width:1px}";
-n(css,{});
-
-function createWebWorker$1(modelService, opts) {
-    return ( new MonacoWebWorkerImpl(modelService, opts));
-}
-class MonacoWebWorkerImpl extends EditorWorkerClient {
-    constructor(modelService, opts) {
-        const workerDescriptor = {
-            moduleId: standaloneEditorWorkerDescriptor.moduleId,
-            esmModuleLocation: standaloneEditorWorkerDescriptor.esmModuleLocation,
-            label: opts.label,
-        };
-        super(workerDescriptor, opts.keepIdleModels || false, modelService);
-        this._foreignModuleId = opts.moduleId;
-        this._foreignModuleCreateData = opts.createData || null;
-        this._foreignModuleHost = opts.host || null;
-        this._foreignProxy = null;
-    }
-    fhr(method, args) {
-        if (!this._foreignModuleHost || typeof this._foreignModuleHost[method] !== 'function') {
-            return Promise.reject(( new Error('Missing method ' + method + ' or missing main thread foreign host.')));
-        }
-        try {
-            return Promise.resolve(this._foreignModuleHost[method].apply(this._foreignModuleHost, args));
-        }
-        catch (e) {
-            return Promise.reject(e);
-        }
-    }
-    _getForeignProxy() {
-        if (!this._foreignProxy) {
-            this._foreignProxy = this._getProxy().then((proxy) => {
-                const foreignHostMethods = this._foreignModuleHost ? getAllMethodNames(this._foreignModuleHost) : [];
-                return proxy.$loadForeignModule(this._foreignModuleId, this._foreignModuleCreateData, foreignHostMethods).then((foreignMethods) => {
-                    this._foreignModuleCreateData = null;
-                    const proxyMethodRequest = (method, args) => {
-                        return proxy.$fmr(method, args);
-                    };
-                    const createProxyMethod = (method, proxyMethodRequest) => {
-                        return function () {
-                            const args = Array.prototype.slice.call(arguments, 0);
-                            return proxyMethodRequest(method, args);
-                        };
-                    };
-                    const foreignProxy = {};
-                    for (const foreignMethod of foreignMethods) {
-                        foreignProxy[foreignMethod] = createProxyMethod(foreignMethod, proxyMethodRequest);
-                    }
-                    return foreignProxy;
-                });
-            });
-        }
-        return this._foreignProxy;
-    }
-    getProxy() {
-        return this._getForeignProxy();
-    }
-    withSyncedResources(resources) {
-        return this.workerWithSyncedResources(resources).then(_ => ( this.getProxy()));
-    }
-}
-
-function isFuzzyActionArr(what) {
-    return (Array.isArray(what));
-}
-function isFuzzyAction(what) {
-    return !isFuzzyActionArr(what);
-}
-function isString(what) {
-    return (typeof what === 'string');
-}
-function isIAction(what) {
-    return !isString(what);
-}
-function empty(s) {
-    return (s ? false : true);
-}
-function fixCase(lexer, str) {
-    return (lexer.ignoreCase && str ? str.toLowerCase() : str);
-}
-function sanitize(s) {
-    return s.replace(/[&<>'"_]/g, '-');
-}
-function log(lexer, msg) {
-    console.log(`${lexer.languageId}: ${msg}`);
-}
-function createError(lexer, msg) {
-    return ( new Error(`${lexer.languageId}: ${msg}`));
-}
-function substituteMatches(lexer, str, id, matches, state) {
-    const re = /\$((\$)|(#)|(\d\d?)|[sS](\d\d?)|@(\w+))/g;
-    let stateMatches = null;
-    return str.replace(re, function (full, sub, dollar, hash, n, s, attr, ofs, total) {
-        if (!empty(dollar)) {
-            return '$';
-        }
-        if (!empty(hash)) {
-            return fixCase(lexer, id);
-        }
-        if (!empty(n) && n < matches.length) {
-            return fixCase(lexer, matches[n]);
-        }
-        if (!empty(attr) && lexer && typeof (lexer[attr]) === 'string') {
-            return lexer[attr];
-        }
-        if (stateMatches === null) {
-            stateMatches = state.split('.');
-            stateMatches.unshift(state);
-        }
-        if (!empty(s) && s < stateMatches.length) {
-            return fixCase(lexer, stateMatches[s]);
-        }
-        return '';
-    });
-}
-function substituteMatchesRe(lexer, str, state) {
-    const re = /\$[sS](\d\d?)/g;
-    let stateMatches = null;
-    return str.replace(re, function (full, s) {
-        if (stateMatches === null) {
-            stateMatches = state.split('.');
-            stateMatches.unshift(state);
-        }
-        if (!empty(s) && s < stateMatches.length) {
-            return fixCase(lexer, stateMatches[s]);
-        }
-        return '';
-    });
-}
-function findRules(lexer, inState) {
-    let state = inState;
-    while (state && state.length > 0) {
-        const rules = lexer.tokenizer[state];
-        if (rules) {
-            return rules;
-        }
-        const idx = state.lastIndexOf('.');
-        if (idx < 0) {
-            state = null;
-        }
-        else {
-            state = state.substr(0, idx);
-        }
-    }
-    return null;
-}
-function stateExists(lexer, inState) {
-    let state = inState;
-    while (state && state.length > 0) {
-        const exist = lexer.stateNames[state];
-        if (exist) {
-            return true;
-        }
-        const idx = state.lastIndexOf('.');
-        if (idx < 0) {
-            state = null;
-        }
-        else {
-            state = state.substr(0, idx);
-        }
-    }
-    return false;
-}
-
-var MonarchTokenizer_1;
-const CACHE_STACK_DEPTH = 5;
-class MonarchStackElementFactory {
-    static { this._INSTANCE = ( new MonarchStackElementFactory(CACHE_STACK_DEPTH)); }
-    static create(parent, state) {
-        return this._INSTANCE.create(parent, state);
-    }
-    constructor(maxCacheDepth) {
-        this._maxCacheDepth = maxCacheDepth;
-        this._entries = Object.create(null);
-    }
-    create(parent, state) {
-        if (parent !== null && parent.depth >= this._maxCacheDepth) {
-            return ( new MonarchStackElement(parent, state));
-        }
-        let stackElementId = MonarchStackElement.getStackElementId(parent);
-        if (stackElementId.length > 0) {
-            stackElementId += '|';
-        }
-        stackElementId += state;
-        let result = this._entries[stackElementId];
-        if (result) {
-            return result;
-        }
-        result = ( new MonarchStackElement(parent, state));
-        this._entries[stackElementId] = result;
-        return result;
-    }
-}
-class MonarchStackElement {
-    constructor(parent, state) {
-        this.parent = parent;
-        this.state = state;
-        this.depth = (this.parent ? this.parent.depth : 0) + 1;
-    }
-    static getStackElementId(element) {
-        let result = '';
-        while (element !== null) {
-            if (result.length > 0) {
-                result += '|';
-            }
-            result += element.state;
-            element = element.parent;
-        }
-        return result;
-    }
-    static _equals(a, b) {
-        while (a !== null && b !== null) {
-            if (a === b) {
-                return true;
-            }
-            if (a.state !== b.state) {
-                return false;
-            }
-            a = a.parent;
-            b = b.parent;
-        }
-        if (a === null && b === null) {
-            return true;
-        }
-        return false;
-    }
-    equals(other) {
-        return MonarchStackElement._equals(this, other);
-    }
-    push(state) {
-        return MonarchStackElementFactory.create(this, state);
-    }
-    pop() {
-        return this.parent;
-    }
-    popall() {
-        let result = this;
-        while (result.parent) {
-            result = result.parent;
-        }
-        return result;
-    }
-    switchTo(state) {
-        return MonarchStackElementFactory.create(this.parent, state);
-    }
-}
-class EmbeddedLanguageData {
-    constructor(languageId, state) {
-        this.languageId = languageId;
-        this.state = state;
-    }
-    equals(other) {
-        return (this.languageId === other.languageId
-            && this.state.equals(other.state));
-    }
-    clone() {
-        const stateClone = this.state.clone();
-        if (stateClone === this.state) {
-            return this;
-        }
-        return ( new EmbeddedLanguageData(this.languageId, this.state));
-    }
-}
-class MonarchLineStateFactory {
-    static { this._INSTANCE = ( new MonarchLineStateFactory(CACHE_STACK_DEPTH)); }
-    static create(stack, embeddedLanguageData) {
-        return this._INSTANCE.create(stack, embeddedLanguageData);
-    }
-    constructor(maxCacheDepth) {
-        this._maxCacheDepth = maxCacheDepth;
-        this._entries = Object.create(null);
-    }
-    create(stack, embeddedLanguageData) {
-        if (embeddedLanguageData !== null) {
-            return ( new MonarchLineState(stack, embeddedLanguageData));
-        }
-        if (stack !== null && stack.depth >= this._maxCacheDepth) {
-            return ( new MonarchLineState(stack, embeddedLanguageData));
-        }
-        const stackElementId = MonarchStackElement.getStackElementId(stack);
-        let result = this._entries[stackElementId];
-        if (result) {
-            return result;
-        }
-        result = ( new MonarchLineState(stack, null));
-        this._entries[stackElementId] = result;
-        return result;
-    }
-}
-class MonarchLineState {
-    constructor(stack, embeddedLanguageData) {
-        this.stack = stack;
-        this.embeddedLanguageData = embeddedLanguageData;
-    }
-    clone() {
-        const embeddedlanguageDataClone = this.embeddedLanguageData ? this.embeddedLanguageData.clone() : null;
-        if (embeddedlanguageDataClone === this.embeddedLanguageData) {
-            return this;
-        }
-        return MonarchLineStateFactory.create(this.stack, this.embeddedLanguageData);
-    }
-    equals(other) {
-        if (!(other instanceof MonarchLineState)) {
-            return false;
-        }
-        if (!this.stack.equals(other.stack)) {
-            return false;
-        }
-        if (this.embeddedLanguageData === null && other.embeddedLanguageData === null) {
-            return true;
-        }
-        if (this.embeddedLanguageData === null || other.embeddedLanguageData === null) {
-            return false;
-        }
-        return this.embeddedLanguageData.equals(other.embeddedLanguageData);
-    }
-}
-class MonarchClassicTokensCollector {
-    constructor() {
-        this._tokens = [];
-        this._languageId = null;
-        this._lastTokenType = null;
-        this._lastTokenLanguage = null;
-    }
-    enterLanguage(languageId) {
-        this._languageId = languageId;
-    }
-    emit(startOffset, type) {
-        if (this._lastTokenType === type && this._lastTokenLanguage === this._languageId) {
-            return;
-        }
-        this._lastTokenType = type;
-        this._lastTokenLanguage = this._languageId;
-        this._tokens.push(new Token$1(startOffset, type, this._languageId));
-    }
-    nestedLanguageTokenize(embeddedLanguageLine, hasEOL, embeddedLanguageData, offsetDelta) {
-        const nestedLanguageId = embeddedLanguageData.languageId;
-        const embeddedModeState = embeddedLanguageData.state;
-        const nestedLanguageTokenizationSupport = TokenizationRegistry.get(nestedLanguageId);
-        if (!nestedLanguageTokenizationSupport) {
-            this.enterLanguage(nestedLanguageId);
-            this.emit(offsetDelta, '');
-            return embeddedModeState;
-        }
-        const nestedResult = nestedLanguageTokenizationSupport.tokenize(embeddedLanguageLine, hasEOL, embeddedModeState);
-        if (offsetDelta !== 0) {
-            for (const token of nestedResult.tokens) {
-                this._tokens.push(new Token$1(token.offset + offsetDelta, token.type, token.language));
-            }
-        }
-        else {
-            this._tokens = this._tokens.concat(nestedResult.tokens);
-        }
-        this._lastTokenType = null;
-        this._lastTokenLanguage = null;
-        this._languageId = null;
-        return nestedResult.endState;
-    }
-    finalize(endState) {
-        return new TokenizationResult(this._tokens, endState);
-    }
-}
-class MonarchModernTokensCollector {
-    constructor(languageService, theme) {
-        this._languageService = languageService;
-        this._theme = theme;
-        this._prependTokens = null;
-        this._tokens = [];
-        this._currentLanguageId = 0 ;
-        this._lastTokenMetadata = 0;
-    }
-    enterLanguage(languageId) {
-        this._currentLanguageId = this._languageService.languageIdCodec.encodeLanguageId(languageId);
-    }
-    emit(startOffset, type) {
-        const metadata = this._theme.match(this._currentLanguageId, type) | 1024 ;
-        if (this._lastTokenMetadata === metadata) {
-            return;
-        }
-        this._lastTokenMetadata = metadata;
-        this._tokens.push(startOffset);
-        this._tokens.push(metadata);
-    }
-    static _merge(a, b, c) {
-        const aLen = (a !== null ? a.length : 0);
-        const bLen = b.length;
-        const cLen = (c !== null ? c.length : 0);
-        if (aLen === 0 && bLen === 0 && cLen === 0) {
-            return ( new Uint32Array(0));
-        }
-        if (aLen === 0 && bLen === 0) {
-            return c;
-        }
-        if (bLen === 0 && cLen === 0) {
-            return a;
-        }
-        const result = ( new Uint32Array(aLen + bLen + cLen));
-        if (a !== null) {
-            result.set(a);
-        }
-        for (let i = 0; i < bLen; i++) {
-            result[aLen + i] = b[i];
-        }
-        if (c !== null) {
-            result.set(c, aLen + bLen);
-        }
-        return result;
-    }
-    nestedLanguageTokenize(embeddedLanguageLine, hasEOL, embeddedLanguageData, offsetDelta) {
-        const nestedLanguageId = embeddedLanguageData.languageId;
-        const embeddedModeState = embeddedLanguageData.state;
-        const nestedLanguageTokenizationSupport = TokenizationRegistry.get(nestedLanguageId);
-        if (!nestedLanguageTokenizationSupport) {
-            this.enterLanguage(nestedLanguageId);
-            this.emit(offsetDelta, '');
-            return embeddedModeState;
-        }
-        const nestedResult = nestedLanguageTokenizationSupport.tokenizeEncoded(embeddedLanguageLine, hasEOL, embeddedModeState);
-        if (offsetDelta !== 0) {
-            for (let i = 0, len = nestedResult.tokens.length; i < len; i += 2) {
-                nestedResult.tokens[i] += offsetDelta;
-            }
-        }
-        this._prependTokens = MonarchModernTokensCollector._merge(this._prependTokens, this._tokens, nestedResult.tokens);
-        this._tokens = [];
-        this._currentLanguageId = 0;
-        this._lastTokenMetadata = 0;
-        return nestedResult.endState;
-    }
-    finalize(endState) {
-        return new EncodedTokenizationResult(MonarchModernTokensCollector._merge(this._prependTokens, this._tokens, null), endState);
-    }
-}
-let MonarchTokenizer = MonarchTokenizer_1 = class MonarchTokenizer extends Disposable {
-    constructor(languageService, standaloneThemeService, languageId, lexer, _configurationService) {
-        super();
-        this._configurationService = _configurationService;
-        this._languageService = languageService;
-        this._standaloneThemeService = standaloneThemeService;
-        this._languageId = languageId;
-        this._lexer = lexer;
-        this._embeddedLanguages = Object.create(null);
-        this.embeddedLoaded = Promise.resolve(undefined);
-        let emitting = false;
-        this._register(TokenizationRegistry.onDidChange((e) => {
-            if (emitting) {
-                return;
-            }
-            let isOneOfMyEmbeddedModes = false;
-            for (let i = 0, len = e.changedLanguages.length; i < len; i++) {
-                const language = e.changedLanguages[i];
-                if (this._embeddedLanguages[language]) {
-                    isOneOfMyEmbeddedModes = true;
-                    break;
-                }
-            }
-            if (isOneOfMyEmbeddedModes) {
-                emitting = true;
-                TokenizationRegistry.handleChange([this._languageId]);
-                emitting = false;
-            }
-        }));
-        this._maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
-            overrideIdentifier: this._languageId
-        });
-        this._register(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('editor.maxTokenizationLineLength')) {
-                this._maxTokenizationLineLength = this._configurationService.getValue('editor.maxTokenizationLineLength', {
-                    overrideIdentifier: this._languageId
-                });
-            }
-        }));
-    }
-    getLoadStatus() {
-        const promises = [];
-        for (const nestedLanguageId in this._embeddedLanguages) {
-            const tokenizationSupport = TokenizationRegistry.get(nestedLanguageId);
-            if (tokenizationSupport) {
-                if (tokenizationSupport instanceof MonarchTokenizer_1) {
-                    const nestedModeStatus = tokenizationSupport.getLoadStatus();
-                    if (nestedModeStatus.loaded === false) {
-                        promises.push(nestedModeStatus.promise);
-                    }
-                }
-                continue;
-            }
-            if (!TokenizationRegistry.isResolved(nestedLanguageId)) {
-                promises.push(TokenizationRegistry.getOrCreate(nestedLanguageId));
-            }
-        }
-        if (promises.length === 0) {
-            return {
-                loaded: true
-            };
-        }
-        return {
-            loaded: false,
-            promise: Promise.all(promises).then(_ => undefined)
-        };
-    }
-    getInitialState() {
-        const rootState = MonarchStackElementFactory.create(null, this._lexer.start);
-        return MonarchLineStateFactory.create(rootState, null);
-    }
-    tokenize(line, hasEOL, lineState) {
-        if (line.length >= this._maxTokenizationLineLength) {
-            return nullTokenize(this._languageId, lineState);
-        }
-        const tokensCollector = ( new MonarchClassicTokensCollector());
-        const endLineState = this._tokenize(line, hasEOL, lineState, tokensCollector);
-        return tokensCollector.finalize(endLineState);
-    }
-    tokenizeEncoded(line, hasEOL, lineState) {
-        if (line.length >= this._maxTokenizationLineLength) {
-            return nullTokenizeEncoded(this._languageService.languageIdCodec.encodeLanguageId(this._languageId), lineState);
-        }
-        const tokensCollector = ( new MonarchModernTokensCollector(
-            this._languageService,
-            this._standaloneThemeService.getColorTheme().tokenTheme
-        ));
-        const endLineState = this._tokenize(line, hasEOL, lineState, tokensCollector);
-        return tokensCollector.finalize(endLineState);
-    }
-    _tokenize(line, hasEOL, lineState, collector) {
-        if (lineState.embeddedLanguageData) {
-            return this._nestedTokenize(line, hasEOL, lineState, 0, collector);
-        }
-        else {
-            return this._myTokenize(line, hasEOL, lineState, 0, collector);
-        }
-    }
-    _findLeavingNestedLanguageOffset(line, state) {
-        let rules = this._lexer.tokenizer[state.stack.state];
-        if (!rules) {
-            rules = findRules(this._lexer, state.stack.state);
-            if (!rules) {
-                throw createError(this._lexer, 'tokenizer state is not defined: ' + state.stack.state);
-            }
-        }
-        let popOffset = -1;
-        let hasEmbeddedPopRule = false;
-        for (const rule of rules) {
-            if (!isIAction(rule.action) || rule.action.nextEmbedded !== '@pop') {
-                continue;
-            }
-            hasEmbeddedPopRule = true;
-            let regex = rule.resolveRegex(state.stack.state);
-            const regexSource = regex.source;
-            if (regexSource.substr(0, 4) === '^(?:' && regexSource.substr(regexSource.length - 1, 1) === ')') {
-                const flags = (regex.ignoreCase ? 'i' : '') + (regex.unicode ? 'u' : '');
-                regex = ( new RegExp(regexSource.substr(4, regexSource.length - 5), flags));
-            }
-            const result = line.search(regex);
-            if (result === -1 || (result !== 0 && rule.matchOnlyAtLineStart)) {
-                continue;
-            }
-            if (popOffset === -1 || result < popOffset) {
-                popOffset = result;
-            }
-        }
-        if (!hasEmbeddedPopRule) {
-            throw createError(this._lexer, 'no rule containing nextEmbedded: "@pop" in tokenizer embedded state: ' + state.stack.state);
-        }
-        return popOffset;
-    }
-    _nestedTokenize(line, hasEOL, lineState, offsetDelta, tokensCollector) {
-        const popOffset = this._findLeavingNestedLanguageOffset(line, lineState);
-        if (popOffset === -1) {
-            const nestedEndState = tokensCollector.nestedLanguageTokenize(line, hasEOL, lineState.embeddedLanguageData, offsetDelta);
-            return MonarchLineStateFactory.create(lineState.stack, ( new EmbeddedLanguageData(lineState.embeddedLanguageData.languageId, nestedEndState)));
-        }
-        const nestedLanguageLine = line.substring(0, popOffset);
-        if (nestedLanguageLine.length > 0) {
-            tokensCollector.nestedLanguageTokenize(nestedLanguageLine, false, lineState.embeddedLanguageData, offsetDelta);
-        }
-        const restOfTheLine = line.substring(popOffset);
-        return this._myTokenize(restOfTheLine, hasEOL, lineState, offsetDelta + popOffset, tokensCollector);
-    }
-    _safeRuleName(rule) {
-        if (rule) {
-            return rule.name;
-        }
-        return '(unknown)';
-    }
-    _myTokenize(lineWithoutLF, hasEOL, lineState, offsetDelta, tokensCollector) {
-        tokensCollector.enterLanguage(this._languageId);
-        const lineWithoutLFLength = lineWithoutLF.length;
-        const line = (hasEOL && this._lexer.includeLF ? lineWithoutLF + '\n' : lineWithoutLF);
-        const lineLength = line.length;
-        let embeddedLanguageData = lineState.embeddedLanguageData;
-        let stack = lineState.stack;
-        let pos = 0;
-        let groupMatching = null;
-        let forceEvaluation = true;
-        while (forceEvaluation || pos < lineLength) {
-            const pos0 = pos;
-            const stackLen0 = stack.depth;
-            const groupLen0 = groupMatching ? groupMatching.groups.length : 0;
-            const state = stack.state;
-            let matches = null;
-            let matched = null;
-            let action = null;
-            let rule = null;
-            let enteringEmbeddedLanguage = null;
-            if (groupMatching) {
-                matches = groupMatching.matches;
-                const groupEntry = groupMatching.groups.shift();
-                matched = groupEntry.matched;
-                action = groupEntry.action;
-                rule = groupMatching.rule;
-                if (groupMatching.groups.length === 0) {
-                    groupMatching = null;
-                }
-            }
-            else {
-                if (!forceEvaluation && pos >= lineLength) {
-                    break;
-                }
-                forceEvaluation = false;
-                let rules = this._lexer.tokenizer[state];
-                if (!rules) {
-                    rules = findRules(this._lexer, state);
-                    if (!rules) {
-                        throw createError(this._lexer, 'tokenizer state is not defined: ' + state);
-                    }
-                }
-                const restOfLine = line.substr(pos);
-                for (const rule of rules) {
-                    if (pos === 0 || !rule.matchOnlyAtLineStart) {
-                        matches = restOfLine.match(rule.resolveRegex(state));
-                        if (matches) {
-                            matched = matches[0];
-                            action = rule.action;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!matches) {
-                matches = [''];
-                matched = '';
-            }
-            if (!action) {
-                if (pos < lineLength) {
-                    matches = [line.charAt(pos)];
-                    matched = matches[0];
-                }
-                action = this._lexer.defaultToken;
-            }
-            if (matched === null) {
-                break;
-            }
-            pos += matched.length;
-            while (isFuzzyAction(action) && isIAction(action) && action.test) {
-                action = action.test(matched, matches, state, pos === lineLength);
-            }
-            let result = null;
-            if (typeof action === 'string' || Array.isArray(action)) {
-                result = action;
-            }
-            else if (action.group) {
-                result = action.group;
-            }
-            else if (action.token !== null && action.token !== undefined) {
-                if (action.tokenSubst) {
-                    result = substituteMatches(this._lexer, action.token, matched, matches, state);
-                }
-                else {
-                    result = action.token;
-                }
-                if (action.nextEmbedded) {
-                    if (action.nextEmbedded === '@pop') {
-                        if (!embeddedLanguageData) {
-                            throw createError(this._lexer, 'cannot pop embedded language if not inside one');
-                        }
-                        embeddedLanguageData = null;
-                    }
-                    else if (embeddedLanguageData) {
-                        throw createError(this._lexer, 'cannot enter embedded language from within an embedded language');
-                    }
-                    else {
-                        enteringEmbeddedLanguage = substituteMatches(this._lexer, action.nextEmbedded, matched, matches, state);
-                    }
-                }
-                if (action.goBack) {
-                    pos = Math.max(0, pos - action.goBack);
-                }
-                if (action.switchTo && typeof action.switchTo === 'string') {
-                    let nextState = substituteMatches(this._lexer, action.switchTo, matched, matches, state);
-                    if (nextState[0] === '@') {
-                        nextState = nextState.substr(1);
-                    }
-                    if (!findRules(this._lexer, nextState)) {
-                        throw createError(this._lexer, 'trying to switch to a state \'' + nextState + '\' that is undefined in rule: ' + this._safeRuleName(rule));
-                    }
-                    else {
-                        stack = stack.switchTo(nextState);
-                    }
-                }
-                else if (action.transform && typeof action.transform === 'function') {
-                    throw createError(this._lexer, 'action.transform not supported');
-                }
-                else if (action.next) {
-                    if (action.next === '@push') {
-                        if (stack.depth >= this._lexer.maxStack) {
-                            throw createError(this._lexer, 'maximum tokenizer stack size reached: [' +
-                                stack.state + ',' + stack.parent.state + ',...]');
-                        }
-                        else {
-                            stack = stack.push(state);
-                        }
-                    }
-                    else if (action.next === '@pop') {
-                        if (stack.depth <= 1) {
-                            throw createError(this._lexer, 'trying to pop an empty stack in rule: ' + this._safeRuleName(rule));
-                        }
-                        else {
-                            stack = stack.pop();
-                        }
-                    }
-                    else if (action.next === '@popall') {
-                        stack = stack.popall();
-                    }
-                    else {
-                        let nextState = substituteMatches(this._lexer, action.next, matched, matches, state);
-                        if (nextState[0] === '@') {
-                            nextState = nextState.substr(1);
-                        }
-                        if (!findRules(this._lexer, nextState)) {
-                            throw createError(this._lexer, 'trying to set a next state \'' + nextState + '\' that is undefined in rule: ' + this._safeRuleName(rule));
-                        }
-                        else {
-                            stack = stack.push(nextState);
-                        }
-                    }
-                }
-                if (action.log && typeof (action.log) === 'string') {
-                    log(this._lexer, this._lexer.languageId + ': ' + substituteMatches(this._lexer, action.log, matched, matches, state));
-                }
-            }
-            if (result === null) {
-                throw createError(this._lexer, 'lexer rule has no well-defined action in rule: ' + this._safeRuleName(rule));
-            }
-            const computeNewStateForEmbeddedLanguage = (enteringEmbeddedLanguage) => {
-                const languageId = (this._languageService.getLanguageIdByLanguageName(enteringEmbeddedLanguage)
-                    || this._languageService.getLanguageIdByMimeType(enteringEmbeddedLanguage)
-                    || enteringEmbeddedLanguage);
-                const embeddedLanguageData = this._getNestedEmbeddedLanguageData(languageId);
-                if (pos < lineLength) {
-                    const restOfLine = lineWithoutLF.substr(pos);
-                    return this._nestedTokenize(restOfLine, hasEOL, MonarchLineStateFactory.create(stack, embeddedLanguageData), offsetDelta + pos, tokensCollector);
-                }
-                else {
-                    return MonarchLineStateFactory.create(stack, embeddedLanguageData);
-                }
-            };
-            if (Array.isArray(result)) {
-                if (groupMatching && groupMatching.groups.length > 0) {
-                    throw createError(this._lexer, 'groups cannot be nested: ' + this._safeRuleName(rule));
-                }
-                if (matches.length !== result.length + 1) {
-                    throw createError(this._lexer, 'matched number of groups does not match the number of actions in rule: ' + this._safeRuleName(rule));
-                }
-                let totalLen = 0;
-                for (let i = 1; i < matches.length; i++) {
-                    totalLen += matches[i].length;
-                }
-                if (totalLen !== matched.length) {
-                    throw createError(this._lexer, 'with groups, all characters should be matched in consecutive groups in rule: ' + this._safeRuleName(rule));
-                }
-                groupMatching = {
-                    rule: rule,
-                    matches: matches,
-                    groups: []
-                };
-                for (let i = 0; i < result.length; i++) {
-                    groupMatching.groups[i] = {
-                        action: result[i],
-                        matched: matches[i + 1]
-                    };
-                }
-                pos -= matched.length;
-                continue;
-            }
-            else {
-                if (result === '@rematch') {
-                    pos -= matched.length;
-                    matched = '';
-                    matches = null;
-                    result = '';
-                    if (enteringEmbeddedLanguage !== null) {
-                        return computeNewStateForEmbeddedLanguage(enteringEmbeddedLanguage);
-                    }
-                }
-                if (matched.length === 0) {
-                    if (lineLength === 0 || stackLen0 !== stack.depth || state !== stack.state || (!groupMatching ? 0 : groupMatching.groups.length) !== groupLen0) {
-                        continue;
-                    }
-                    else {
-                        throw createError(this._lexer, 'no progress in tokenizer in rule: ' + this._safeRuleName(rule));
-                    }
-                }
-                let tokenType = null;
-                if (isString(result) && result.indexOf('@brackets') === 0) {
-                    const rest = result.substr('@brackets'.length);
-                    const bracket = findBracket(this._lexer, matched);
-                    if (!bracket) {
-                        throw createError(this._lexer, '@brackets token returned but no bracket defined as: ' + matched);
-                    }
-                    tokenType = sanitize(bracket.token + rest);
-                }
-                else {
-                    const token = (result === '' ? '' : result + this._lexer.tokenPostfix);
-                    tokenType = sanitize(token);
-                }
-                if (pos0 < lineWithoutLFLength) {
-                    tokensCollector.emit(pos0 + offsetDelta, tokenType);
-                }
-            }
-            if (enteringEmbeddedLanguage !== null) {
-                return computeNewStateForEmbeddedLanguage(enteringEmbeddedLanguage);
-            }
-        }
-        return MonarchLineStateFactory.create(stack, embeddedLanguageData);
-    }
-    _getNestedEmbeddedLanguageData(languageId) {
-        if (!this._languageService.isRegisteredLanguageId(languageId)) {
-            return ( new EmbeddedLanguageData(languageId, NullState));
-        }
-        if (languageId !== this._languageId) {
-            this._languageService.requestBasicLanguageFeatures(languageId);
-            TokenizationRegistry.getOrCreate(languageId);
-            this._embeddedLanguages[languageId] = true;
-        }
-        const tokenizationSupport = TokenizationRegistry.get(languageId);
-        if (tokenizationSupport) {
-            return ( new EmbeddedLanguageData(languageId, tokenizationSupport.getInitialState()));
-        }
-        return ( new EmbeddedLanguageData(languageId, NullState));
-    }
-};
-MonarchTokenizer = MonarchTokenizer_1 = ( __decorate([
-    ( __param(4, IConfigurationService))
-], MonarchTokenizer));
-function findBracket(lexer, matched) {
-    if (!matched) {
-        return null;
-    }
-    matched = fixCase(lexer, matched);
-    const brackets = lexer.brackets;
-    for (const bracket of brackets) {
-        if (bracket.open === matched) {
-            return { token: bracket.token, bracketType: 1  };
-        }
-        else if (bracket.close === matched) {
-            return { token: bracket.token, bracketType: -1  };
-        }
-    }
-    return null;
-}
-
-const ttPolicy = createTrustedTypesPolicy('standaloneColorizer', { createHTML: value => value });
-class Colorizer {
-    static colorizeElement(themeService, languageService, domNode, options) {
-        options = options || {};
-        const theme = options.theme || 'vs';
-        const mimeType = options.mimeType || domNode.getAttribute('lang') || domNode.getAttribute('data-lang');
-        if (!mimeType) {
-            console.error('Mode not detected');
-            return Promise.resolve();
-        }
-        const languageId = languageService.getLanguageIdByMimeType(mimeType) || mimeType;
-        themeService.setTheme(theme);
-        const text = domNode.firstChild ? domNode.firstChild.nodeValue : '';
-        domNode.className += ' ' + theme;
-        const render = (str) => {
-            const trustedhtml = ttPolicy?.createHTML(str) ?? str;
-            domNode.innerHTML = trustedhtml;
-        };
-        return this.colorize(languageService, text || '', languageId, options).then(render, (err) => console.error(err));
-    }
-    static async colorize(languageService, text, languageId, options) {
-        const languageIdCodec = languageService.languageIdCodec;
-        let tabSize = 4;
-        if (options && typeof options.tabSize === 'number') {
-            tabSize = options.tabSize;
-        }
-        if (startsWithUTF8BOM(text)) {
-            text = text.substr(1);
-        }
-        const lines = splitLines(text);
-        if (!languageService.isRegisteredLanguageId(languageId)) {
-            return _fakeColorize(lines, tabSize, languageIdCodec);
-        }
-        const tokenizationSupport = await TokenizationRegistry.getOrCreate(languageId);
-        if (tokenizationSupport) {
-            return _colorize(lines, tabSize, tokenizationSupport, languageIdCodec);
-        }
-        return _fakeColorize(lines, tabSize, languageIdCodec);
-    }
-    static colorizeLine(line, mightContainNonBasicASCII, mightContainRTL, tokens, tabSize = 4) {
-        const isBasicASCII = ViewLineRenderingData.isBasicASCII(line, mightContainNonBasicASCII);
-        const containsRTL = ViewLineRenderingData.containsRTL(line, isBasicASCII, mightContainRTL);
-        const renderResult = renderViewLine2(( new RenderLineInput(
-            false,
-            true,
-            line,
-            false,
-            isBasicASCII,
-            containsRTL,
-            0,
-            tokens,
-            [],
-            tabSize,
-            0,
-            0,
-            0,
-            0,
-            -1,
-            'none',
-            false,
-            false,
-            null
-        )));
-        return renderResult.html;
-    }
-    static colorizeModelLine(model, lineNumber, tabSize = 4) {
-        const content = model.getLineContent(lineNumber);
-        model.tokenization.forceTokenization(lineNumber);
-        const tokens = model.tokenization.getLineTokens(lineNumber);
-        const inflatedTokens = tokens.inflate();
-        return this.colorizeLine(content, model.mightContainNonBasicASCII(), model.mightContainRTL(), inflatedTokens, tabSize);
-    }
-}
-function _colorize(lines, tabSize, tokenizationSupport, languageIdCodec) {
-    return ( new Promise((c, e) => {
-        const execute = () => {
-            const result = _actualColorize(lines, tabSize, tokenizationSupport, languageIdCodec);
-            if (tokenizationSupport instanceof MonarchTokenizer) {
-                const status = tokenizationSupport.getLoadStatus();
-                if (status.loaded === false) {
-                    status.promise.then(execute, e);
-                    return;
-                }
-            }
-            c(result);
-        };
-        execute();
-    }));
-}
-function _fakeColorize(lines, tabSize, languageIdCodec) {
-    let html = [];
-    const defaultMetadata = (((0  << 11) )
-        | ((1  << 15) )
-        | ((2  << 24) )) >>> 0;
-    const tokens = ( new Uint32Array(2));
-    tokens[0] = 0;
-    tokens[1] = defaultMetadata;
-    for (let i = 0, length = lines.length; i < length; i++) {
-        const line = lines[i];
-        tokens[0] = line.length;
-        const lineTokens = ( new LineTokens(tokens, line, languageIdCodec));
-        const isBasicASCII = ViewLineRenderingData.isBasicASCII(line,  true);
-        const containsRTL = ViewLineRenderingData.containsRTL(line, isBasicASCII,  true);
-        const renderResult = renderViewLine2(( new RenderLineInput(
-            false,
-            true,
-            line,
-            false,
-            isBasicASCII,
-            containsRTL,
-            0,
-            lineTokens,
-            [],
-            tabSize,
-            0,
-            0,
-            0,
-            0,
-            -1,
-            'none',
-            false,
-            false,
-            null
-        )));
-        html = html.concat(renderResult.html);
-        html.push('<br/>');
-    }
-    return html.join('');
-}
-function _actualColorize(lines, tabSize, tokenizationSupport, languageIdCodec) {
-    let html = [];
-    let state = tokenizationSupport.getInitialState();
-    for (let i = 0, length = lines.length; i < length; i++) {
-        const line = lines[i];
-        const tokenizeResult = tokenizationSupport.tokenizeEncoded(line, true, state);
-        LineTokens.convertToEndOffset(tokenizeResult.tokens, line.length);
-        const lineTokens = ( new LineTokens(tokenizeResult.tokens, line, languageIdCodec));
-        const isBasicASCII = ViewLineRenderingData.isBasicASCII(line,  true);
-        const containsRTL = ViewLineRenderingData.containsRTL(line, isBasicASCII,  true);
-        const renderResult = renderViewLine2(( new RenderLineInput(
-            false,
-            true,
-            line,
-            false,
-            isBasicASCII,
-            containsRTL,
-            0,
-            lineTokens.inflate(),
-            [],
-            tabSize,
-            0,
-            0,
-            0,
-            0,
-            -1,
-            'none',
-            false,
-            false,
-            null
-        )));
-        html = html.concat(renderResult.html);
-        html.push('<br/>');
-        state = tokenizeResult.endState;
-    }
-    return html.join('');
-}
-
-function create(domElement, options, override) {
-    const instantiationService = StandaloneServices.initialize(override || {});
-    return instantiationService.createInstance(StandaloneEditor, domElement, options);
-}
-function onDidCreateEditor(listener) {
-    const codeEditorService = StandaloneServices.get(ICodeEditorService);
-    return codeEditorService.onCodeEditorAdd((editor) => {
-        listener(editor);
-    });
-}
-function onDidCreateDiffEditor(listener) {
-    const codeEditorService = StandaloneServices.get(ICodeEditorService);
-    return codeEditorService.onDiffEditorAdd((editor) => {
-        listener(editor);
-    });
-}
-function getEditors() {
-    const codeEditorService = StandaloneServices.get(ICodeEditorService);
-    return codeEditorService.listCodeEditors();
-}
-function getDiffEditors() {
-    const codeEditorService = StandaloneServices.get(ICodeEditorService);
-    return codeEditorService.listDiffEditors();
-}
-function createDiffEditor(domElement, options, override) {
-    const instantiationService = StandaloneServices.initialize(override || {});
-    return instantiationService.createInstance(StandaloneDiffEditor2, domElement, options);
-}
-function createMultiFileDiffEditor(domElement, override) {
-    const instantiationService = StandaloneServices.initialize(override || {});
-    return ( new MultiDiffEditorWidget(domElement, {}, instantiationService));
-}
-function addCommand(descriptor) {
-    if ((typeof descriptor.id !== 'string') || (typeof descriptor.run !== 'function')) {
-        throw ( new Error('Invalid command descriptor, `id` and `run` are required properties!'));
-    }
-    return CommandsRegistry.registerCommand(descriptor.id, descriptor.run);
-}
-function addEditorAction(descriptor) {
-    if ((typeof descriptor.id !== 'string') || (typeof descriptor.label !== 'string') || (typeof descriptor.run !== 'function')) {
-        throw ( new Error(
-            'Invalid action descriptor, `id`, `label` and `run` are required properties!'
-        ));
-    }
-    const precondition = ContextKeyExpr.deserialize(descriptor.precondition);
-    const run = (accessor, ...args) => {
-        return EditorCommand.runEditorCommand(accessor, args, precondition, (accessor, editor, args) => Promise.resolve(descriptor.run(editor, ...args)));
-    };
-    const toDispose = ( new DisposableStore());
-    toDispose.add(CommandsRegistry.registerCommand(descriptor.id, run));
-    if (descriptor.contextMenuGroupId) {
-        const menuItem = {
-            command: {
-                id: descriptor.id,
-                title: descriptor.label
-            },
-            when: precondition,
-            group: descriptor.contextMenuGroupId,
-            order: descriptor.contextMenuOrder || 0
-        };
-        toDispose.add(MenuRegistry.appendMenuItem(MenuId.EditorContext, menuItem));
-    }
-    if (Array.isArray(descriptor.keybindings)) {
-        const keybindingService = StandaloneServices.get(IKeybindingService);
-        if (!(keybindingService instanceof StandaloneKeybindingService)) {
-            console.warn('Cannot add keybinding because the editor is configured with an unrecognized KeybindingService');
-        }
-        else {
-            const keybindingsWhen = ( ContextKeyExpr.and(precondition, ContextKeyExpr.deserialize(descriptor.keybindingContext)));
-            toDispose.add(keybindingService.addDynamicKeybindings(( descriptor.keybindings.map((keybinding) => {
-                return {
-                    keybinding,
-                    command: descriptor.id,
-                    when: keybindingsWhen
-                };
-            }))));
-        }
-    }
-    return toDispose;
-}
-function addKeybindingRule(rule) {
-    return addKeybindingRules([rule]);
-}
-function addKeybindingRules(rules) {
-    const keybindingService = StandaloneServices.get(IKeybindingService);
-    if (!(keybindingService instanceof StandaloneKeybindingService)) {
-        console.warn('Cannot add keybinding because the editor is configured with an unrecognized KeybindingService');
-        return Disposable.None;
-    }
-    return keybindingService.addDynamicKeybindings(( rules.map((rule) => {
-        return {
-            keybinding: rule.keybinding,
-            command: rule.command,
-            commandArgs: rule.commandArgs,
-            when: ContextKeyExpr.deserialize(rule.when),
-        };
-    })));
-}
-function createModel(value, language, uri) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    const languageId = languageService.getLanguageIdByMimeType(language) || language;
-    return createTextModel(StandaloneServices.get(IModelService), languageService, value, languageId, uri);
-}
-function setModelLanguage(model, mimeTypeOrLanguageId) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    const languageId = languageService.getLanguageIdByMimeType(mimeTypeOrLanguageId) || mimeTypeOrLanguageId || PLAINTEXT_LANGUAGE_ID;
-    model.setLanguage(languageService.createById(languageId));
-}
-function setModelMarkers(model, owner, markers) {
-    if (model) {
-        const markerService = StandaloneServices.get(IMarkerService);
-        markerService.changeOne(owner, model.uri, markers);
-    }
-}
-function removeAllMarkers(owner) {
-    const markerService = StandaloneServices.get(IMarkerService);
-    markerService.changeAll(owner, []);
-}
-function getModelMarkers(filter) {
-    const markerService = StandaloneServices.get(IMarkerService);
-    return markerService.read(filter);
-}
-function onDidChangeMarkers(listener) {
-    const markerService = StandaloneServices.get(IMarkerService);
-    return markerService.onMarkerChanged(listener);
-}
-function getModel(uri) {
-    const modelService = StandaloneServices.get(IModelService);
-    return modelService.getModel(uri);
-}
-function getModels() {
-    const modelService = StandaloneServices.get(IModelService);
-    return modelService.getModels();
-}
-function onDidCreateModel(listener) {
-    const modelService = StandaloneServices.get(IModelService);
-    return modelService.onModelAdded(listener);
-}
-function onWillDisposeModel(listener) {
-    const modelService = StandaloneServices.get(IModelService);
-    return modelService.onModelRemoved(listener);
-}
-function onDidChangeModelLanguage(listener) {
-    const modelService = StandaloneServices.get(IModelService);
-    return modelService.onModelLanguageChanged((e) => {
-        listener({
-            model: e.model,
-            oldLanguage: e.oldLanguageId
-        });
-    });
-}
-function createWebWorker(opts) {
-    return createWebWorker$1(StandaloneServices.get(IModelService), opts);
-}
-function colorizeElement(domNode, options) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    const themeService = StandaloneServices.get(IStandaloneThemeService);
-    return Colorizer.colorizeElement(themeService, languageService, domNode, options).then(() => {
-        themeService.registerEditorContainer(domNode);
-    });
-}
-function colorize(text, languageId, options) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    const themeService = StandaloneServices.get(IStandaloneThemeService);
-    themeService.registerEditorContainer(mainWindow.document.body);
-    return Colorizer.colorize(languageService, text, languageId, options);
-}
-function colorizeModelLine(model, lineNumber, tabSize = 4) {
-    const themeService = StandaloneServices.get(IStandaloneThemeService);
-    themeService.registerEditorContainer(mainWindow.document.body);
-    return Colorizer.colorizeModelLine(model, lineNumber, tabSize);
-}
-function getSafeTokenizationSupport(language) {
-    const tokenizationSupport = TokenizationRegistry.get(language);
-    if (tokenizationSupport) {
-        return tokenizationSupport;
-    }
-    return {
-        getInitialState: () => NullState,
-        tokenize: (line, hasEOL, state) => nullTokenize(language, state)
-    };
-}
-function tokenize(text, languageId) {
-    TokenizationRegistry.getOrCreate(languageId);
-    const tokenizationSupport = getSafeTokenizationSupport(languageId);
-    const lines = splitLines(text);
-    const result = [];
-    let state = tokenizationSupport.getInitialState();
-    for (let i = 0, len = lines.length; i < len; i++) {
-        const line = lines[i];
-        const tokenizationResult = tokenizationSupport.tokenize(line, true, state);
-        result[i] = tokenizationResult.tokens;
-        state = tokenizationResult.endState;
-    }
-    return result;
-}
-function defineTheme(themeName, themeData) {
-    const standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
-    standaloneThemeService.defineTheme(themeName, themeData);
-}
-function setTheme(themeName) {
-    const standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
-    standaloneThemeService.setTheme(themeName);
-}
-function remeasureFonts() {
-    FontMeasurements.clearAllFontInfos();
-}
-function registerCommand(id, handler) {
-    return CommandsRegistry.registerCommand({ id, handler });
-}
-function registerLinkOpener(opener) {
-    const openerService = StandaloneServices.get(IOpenerService);
-    return openerService.registerOpener({
-        async open(resource) {
-            if (typeof resource === 'string') {
-                resource = ( URI.parse(resource));
-            }
-            return opener.open(resource);
-        }
-    });
-}
-function registerEditorOpener(opener) {
-    const codeEditorService = StandaloneServices.get(ICodeEditorService);
-    return codeEditorService.registerCodeEditorOpenHandler(async (input, source, sideBySide) => {
-        if (!source) {
-            return null;
-        }
-        const selection = input.options?.selection;
-        let selectionOrPosition;
-        if (selection && typeof selection.endLineNumber === 'number' && typeof selection.endColumn === 'number') {
-            selectionOrPosition = selection;
-        }
-        else if (selection) {
-            selectionOrPosition = { lineNumber: selection.startLineNumber, column: selection.startColumn };
-        }
-        if (await opener.openCodeEditor(source, input.resource, selectionOrPosition)) {
-            return source;
-        }
-        return null;
-    });
-}
-function createMonacoEditorAPI() {
-    return {
-        create: create,
-        getEditors: getEditors,
-        getDiffEditors: getDiffEditors,
-        onDidCreateEditor: onDidCreateEditor,
-        onDidCreateDiffEditor: onDidCreateDiffEditor,
-        createDiffEditor: createDiffEditor,
-        addCommand: addCommand,
-        addEditorAction: addEditorAction,
-        addKeybindingRule: addKeybindingRule,
-        addKeybindingRules: addKeybindingRules,
-        createModel: createModel,
-        setModelLanguage: setModelLanguage,
-        setModelMarkers: setModelMarkers,
-        getModelMarkers: getModelMarkers,
-        removeAllMarkers: removeAllMarkers,
-        onDidChangeMarkers: onDidChangeMarkers,
-        getModels: getModels,
-        getModel: getModel,
-        onDidCreateModel: onDidCreateModel,
-        onWillDisposeModel: onWillDisposeModel,
-        onDidChangeModelLanguage: onDidChangeModelLanguage,
-        createWebWorker: createWebWorker,
-        colorizeElement: colorizeElement,
-        colorize: colorize,
-        colorizeModelLine: colorizeModelLine,
-        tokenize: tokenize,
-        defineTheme: defineTheme,
-        setTheme: setTheme,
-        remeasureFonts: remeasureFonts,
-        registerCommand: registerCommand,
-        registerLinkOpener: registerLinkOpener,
-        registerEditorOpener: registerEditorOpener,
-        AccessibilitySupport: AccessibilitySupport,
-        ContentWidgetPositionPreference: ContentWidgetPositionPreference,
-        CursorChangeReason: CursorChangeReason,
-        DefaultEndOfLine: DefaultEndOfLine,
-        EditorAutoIndentStrategy: EditorAutoIndentStrategy,
-        EditorOption: EditorOption,
-        EndOfLinePreference: EndOfLinePreference,
-        EndOfLineSequence: EndOfLineSequence,
-        MinimapPosition: MinimapPosition,
-        MinimapSectionHeaderStyle: MinimapSectionHeaderStyle,
-        MouseTargetType: MouseTargetType,
-        OverlayWidgetPositionPreference: OverlayWidgetPositionPreference,
-        OverviewRulerLane: OverviewRulerLane,
-        GlyphMarginLane: GlyphMarginLane,
-        RenderLineNumbersType: RenderLineNumbersType,
-        RenderMinimap: RenderMinimap,
-        ScrollbarVisibility: ScrollbarVisibility,
-        ScrollType: ScrollType,
-        TextEditorCursorBlinkingStyle: TextEditorCursorBlinkingStyle,
-        TextEditorCursorStyle: TextEditorCursorStyle,
-        TrackedRangeStickiness: TrackedRangeStickiness,
-        WrappingIndent: WrappingIndent,
-        InjectedTextCursorStops: InjectedTextCursorStops,
-        PositionAffinity: PositionAffinity,
-        ShowLightbulbIconMode: ShowLightbulbIconMode,
-        ConfigurationChangedEvent: ConfigurationChangedEvent,
-        BareFontInfo: BareFontInfo,
-        FontInfo: FontInfo,
-        TextModelResolvedOptions: TextModelResolvedOptions,
-        FindMatch: FindMatch,
-        ApplyUpdateResult: ApplyUpdateResult,
-        EditorZoom: EditorZoom,
-        createMultiFileDiffEditor: createMultiFileDiffEditor,
-        EditorType: EditorType,
-        EditorOptions: EditorOptions
-    };
-}
-
-function isArrayOf(elemType, obj) {
-    if (!obj) {
-        return false;
-    }
-    if (!(Array.isArray(obj))) {
-        return false;
-    }
-    for (const el of obj) {
-        if (!(elemType(el))) {
-            return false;
-        }
-    }
-    return true;
-}
-function bool(prop, defValue) {
-    if (typeof prop === 'boolean') {
-        return prop;
-    }
-    return defValue;
-}
-function string(prop, defValue) {
-    if (typeof (prop) === 'string') {
-        return prop;
-    }
-    return defValue;
-}
-function arrayToHash(array) {
-    const result = {};
-    for (const e of array) {
-        result[e] = true;
-    }
-    return result;
-}
-function createKeywordMatcher(arr, caseInsensitive = false) {
-    if (caseInsensitive) {
-        arr = ( arr.map(function (x) { return x.toLowerCase(); }));
-    }
-    const hash = arrayToHash(arr);
-    if (caseInsensitive) {
-        return function (word) {
-            return hash[word.toLowerCase()] !== undefined && hash.hasOwnProperty(word.toLowerCase());
-        };
-    }
-    else {
-        return function (word) {
-            return hash[word] !== undefined && hash.hasOwnProperty(word);
-        };
-    }
-}
-function compileRegExp(lexer, str, handleSn) {
-    str = str.replace(/@@/g, `\x01`);
-    let n = 0;
-    let hadExpansion;
-    do {
-        hadExpansion = false;
-        str = str.replace(/@(\w+)/g, function (s, attr) {
-            hadExpansion = true;
-            let sub = '';
-            if (typeof (lexer[attr]) === 'string') {
-                sub = lexer[attr];
-            }
-            else if (lexer[attr] && lexer[attr] instanceof RegExp) {
-                sub = lexer[attr].source;
-            }
-            else {
-                if (lexer[attr] === undefined) {
-                    throw createError(lexer, 'language definition does not contain attribute \'' + attr + '\', used at: ' + str);
-                }
-                else {
-                    throw createError(lexer, 'attribute reference \'' + attr + '\' must be a string, used at: ' + str);
-                }
-            }
-            return (empty(sub) ? '' : '(?:' + sub + ')');
-        });
-        n++;
-    } while (hadExpansion && n < 5);
-    str = str.replace(/\x01/g, '@');
-    const flags = (lexer.ignoreCase ? 'i' : '') + (lexer.unicode ? 'u' : '');
-    if (handleSn) {
-        const match = str.match(/\$[sS](\d\d?)/g);
-        if (match) {
-            let lastState = null;
-            let lastRegEx = null;
-            return (state) => {
-                if (lastRegEx && lastState === state) {
-                    return lastRegEx;
-                }
-                lastState = state;
-                lastRegEx = ( new RegExp(substituteMatchesRe(lexer, str, state), flags));
-                return lastRegEx;
-            };
-        }
-    }
-    return ( new RegExp(str, flags));
-}
-function selectScrutinee(id, matches, state, num) {
-    if (num < 0) {
-        return id;
-    }
-    if (num < matches.length) {
-        return matches[num];
-    }
-    if (num >= 100) {
-        num = num - 100;
-        const parts = state.split('.');
-        parts.unshift(state);
-        if (num < parts.length) {
-            return parts[num];
-        }
-    }
-    return null;
-}
-function createGuard(lexer, ruleName, tkey, val) {
-    let scrut = -1;
-    let oppat = tkey;
-    let matches = tkey.match(/^\$(([sS]?)(\d\d?)|#)(.*)$/);
-    if (matches) {
-        if (matches[3]) {
-            scrut = parseInt(matches[3]);
-            if (matches[2]) {
-                scrut = scrut + 100;
-            }
-        }
-        oppat = matches[4];
-    }
-    let op = '~';
-    let pat = oppat;
-    if (!oppat || oppat.length === 0) {
-        op = '!=';
-        pat = '';
-    }
-    else if (/^\w*$/.test(pat)) {
-        op = '==';
-    }
-    else {
-        matches = oppat.match(/^(@|!@|~|!~|==|!=)(.*)$/);
-        if (matches) {
-            op = matches[1];
-            pat = matches[2];
-        }
-    }
-    let tester;
-    if ((op === '~' || op === '!~') && /^(\w|\|)*$/.test(pat)) {
-        const inWords = createKeywordMatcher(pat.split('|'), lexer.ignoreCase);
-        tester = function (s) { return (op === '~' ? inWords(s) : !inWords(s)); };
-    }
-    else if (op === '@' || op === '!@') {
-        const words = lexer[pat];
-        if (!words) {
-            throw createError(lexer, 'the @ match target \'' + pat + '\' is not defined, in rule: ' + ruleName);
-        }
-        if (!(isArrayOf(function (elem) { return (typeof (elem) === 'string'); }, words))) {
-            throw createError(lexer, 'the @ match target \'' + pat + '\' must be an array of strings, in rule: ' + ruleName);
-        }
-        const inWords = createKeywordMatcher(words, lexer.ignoreCase);
-        tester = function (s) { return (op === '@' ? inWords(s) : !inWords(s)); };
-    }
-    else if (op === '~' || op === '!~') {
-        if (pat.indexOf('$') < 0) {
-            const re = compileRegExp(lexer, '^' + pat + '$', false);
-            tester = function (s) { return (op === '~' ? re.test(s) : !re.test(s)); };
-        }
-        else {
-            tester = function (s, id, matches, state) {
-                const re = compileRegExp(lexer, '^' + substituteMatches(lexer, pat, id, matches, state) + '$', false);
-                return re.test(s);
-            };
-        }
-    }
-    else {
-        if (pat.indexOf('$') < 0) {
-            const patx = fixCase(lexer, pat);
-            tester = function (s) { return (op === '==' ? s === patx : s !== patx); };
-        }
-        else {
-            const patx = fixCase(lexer, pat);
-            tester = function (s, id, matches, state, eos) {
-                const patexp = substituteMatches(lexer, patx, id, matches, state);
-                return (op === '==' ? s === patexp : s !== patexp);
-            };
-        }
-    }
-    if (scrut === -1) {
-        return {
-            name: tkey, value: val, test: function (id, matches, state, eos) {
-                return tester(id, id, matches, state, eos);
-            }
-        };
-    }
-    else {
-        return {
-            name: tkey, value: val, test: function (id, matches, state, eos) {
-                const scrutinee = selectScrutinee(id, matches, state, scrut);
-                return tester(!scrutinee ? '' : scrutinee, id, matches, state, eos);
-            }
-        };
-    }
-}
-function compileAction(lexer, ruleName, action) {
-    if (!action) {
-        return { token: '' };
-    }
-    else if (typeof (action) === 'string') {
-        return action;
-    }
-    else if (action.token || action.token === '') {
-        if (typeof (action.token) !== 'string') {
-            throw createError(lexer, 'a \'token\' attribute must be of type string, in rule: ' + ruleName);
-        }
-        else {
-            const newAction = { token: action.token };
-            if (action.token.indexOf('$') >= 0) {
-                newAction.tokenSubst = true;
-            }
-            if (typeof (action.bracket) === 'string') {
-                if (action.bracket === '@open') {
-                    newAction.bracket = 1 ;
-                }
-                else if (action.bracket === '@close') {
-                    newAction.bracket = -1 ;
-                }
-                else {
-                    throw createError(lexer, 'a \'bracket\' attribute must be either \'@open\' or \'@close\', in rule: ' + ruleName);
-                }
-            }
-            if (action.next) {
-                if (typeof (action.next) !== 'string') {
-                    throw createError(lexer, 'the next state must be a string value in rule: ' + ruleName);
-                }
-                else {
-                    let next = action.next;
-                    if (!/^(@pop|@push|@popall)$/.test(next)) {
-                        if (next[0] === '@') {
-                            next = next.substr(1);
-                        }
-                        if (next.indexOf('$') < 0) {
-                            if (!stateExists(lexer, substituteMatches(lexer, next, '', [], ''))) {
-                                throw createError(lexer, 'the next state \'' + action.next + '\' is not defined in rule: ' + ruleName);
-                            }
-                        }
-                    }
-                    newAction.next = next;
-                }
-            }
-            if (typeof (action.goBack) === 'number') {
-                newAction.goBack = action.goBack;
-            }
-            if (typeof (action.switchTo) === 'string') {
-                newAction.switchTo = action.switchTo;
-            }
-            if (typeof (action.log) === 'string') {
-                newAction.log = action.log;
-            }
-            if (typeof (action.nextEmbedded) === 'string') {
-                newAction.nextEmbedded = action.nextEmbedded;
-                lexer.usesEmbedded = true;
-            }
-            return newAction;
-        }
-    }
-    else if (Array.isArray(action)) {
-        const results = [];
-        for (let i = 0, len = action.length; i < len; i++) {
-            results[i] = compileAction(lexer, ruleName, action[i]);
-        }
-        return { group: results };
-    }
-    else if (action.cases) {
-        const cases = [];
-        for (const tkey in action.cases) {
-            if (action.cases.hasOwnProperty(tkey)) {
-                const val = compileAction(lexer, ruleName, action.cases[tkey]);
-                if (tkey === '@default' || tkey === '@' || tkey === '') {
-                    cases.push({ test: undefined, value: val, name: tkey });
-                }
-                else if (tkey === '@eos') {
-                    cases.push({ test: function (id, matches, state, eos) { return eos; }, value: val, name: tkey });
-                }
-                else {
-                    cases.push(createGuard(lexer, ruleName, tkey, val));
-                }
-            }
-        }
-        const def = lexer.defaultToken;
-        return {
-            test: function (id, matches, state, eos) {
-                for (const _case of cases) {
-                    const didmatch = (!_case.test || _case.test(id, matches, state, eos));
-                    if (didmatch) {
-                        return _case.value;
-                    }
-                }
-                return def;
-            }
-        };
-    }
-    else {
-        throw createError(lexer, 'an action must be a string, an object with a \'token\' or \'cases\' attribute, or an array of actions; in rule: ' + ruleName);
-    }
-}
-class Rule {
-    constructor(name) {
-        this.regex = ( new RegExp(''));
-        this.action = { token: '' };
-        this.matchOnlyAtLineStart = false;
-        this.name = '';
-        this.name = name;
-    }
-    setRegex(lexer, re) {
-        let sregex;
-        if (typeof (re) === 'string') {
-            sregex = re;
-        }
-        else if (re instanceof RegExp) {
-            sregex = re.source;
-        }
-        else {
-            throw createError(lexer, 'rules must start with a match string or regular expression: ' + this.name);
-        }
-        this.matchOnlyAtLineStart = (sregex.length > 0 && sregex[0] === '^');
-        this.name = this.name + ': ' + sregex;
-        this.regex = compileRegExp(lexer, '^(?:' + (this.matchOnlyAtLineStart ? sregex.substr(1) : sregex) + ')', true);
-    }
-    setAction(lexer, act) {
-        this.action = compileAction(lexer, this.name, act);
-    }
-    resolveRegex(state) {
-        if (this.regex instanceof RegExp) {
-            return this.regex;
-        }
-        else {
-            return this.regex(state);
-        }
-    }
-}
-function compile(languageId, json) {
-    if (!json || typeof (json) !== 'object') {
-        throw ( new Error('Monarch: expecting a language definition object'));
-    }
-    const lexer = {
-        languageId: languageId,
-        includeLF: bool(json.includeLF, false),
-        noThrow: false,
-        maxStack: 100,
-        start: (typeof json.start === 'string' ? json.start : null),
-        ignoreCase: bool(json.ignoreCase, false),
-        unicode: bool(json.unicode, false),
-        tokenPostfix: string(json.tokenPostfix, '.' + languageId),
-        defaultToken: string(json.defaultToken, 'source'),
-        usesEmbedded: false,
-        stateNames: {},
-        tokenizer: {},
-        brackets: []
-    };
-    const lexerMin = json;
-    lexerMin.languageId = languageId;
-    lexerMin.includeLF = lexer.includeLF;
-    lexerMin.ignoreCase = lexer.ignoreCase;
-    lexerMin.unicode = lexer.unicode;
-    lexerMin.noThrow = lexer.noThrow;
-    lexerMin.usesEmbedded = lexer.usesEmbedded;
-    lexerMin.stateNames = json.tokenizer;
-    lexerMin.defaultToken = lexer.defaultToken;
-    function addRules(state, newrules, rules) {
-        for (const rule of rules) {
-            let include = rule.include;
-            if (include) {
-                if (typeof (include) !== 'string') {
-                    throw createError(lexer, 'an \'include\' attribute must be a string at: ' + state);
-                }
-                if (include[0] === '@') {
-                    include = include.substr(1);
-                }
-                if (!json.tokenizer[include]) {
-                    throw createError(lexer, 'include target \'' + include + '\' is not defined at: ' + state);
-                }
-                addRules(state + '.' + include, newrules, json.tokenizer[include]);
-            }
-            else {
-                const newrule = ( new Rule(state));
-                if (Array.isArray(rule) && rule.length >= 1 && rule.length <= 3) {
-                    newrule.setRegex(lexerMin, rule[0]);
-                    if (rule.length >= 3) {
-                        if (typeof (rule[1]) === 'string') {
-                            newrule.setAction(lexerMin, { token: rule[1], next: rule[2] });
-                        }
-                        else if (typeof (rule[1]) === 'object') {
-                            const rule1 = rule[1];
-                            rule1.next = rule[2];
-                            newrule.setAction(lexerMin, rule1);
-                        }
-                        else {
-                            throw createError(lexer, 'a next state as the last element of a rule can only be given if the action is either an object or a string, at: ' + state);
-                        }
-                    }
-                    else {
-                        newrule.setAction(lexerMin, rule[1]);
-                    }
-                }
-                else {
-                    if (!rule.regex) {
-                        throw createError(lexer, 'a rule must either be an array, or an object with a \'regex\' or \'include\' field at: ' + state);
-                    }
-                    if (rule.name) {
-                        if (typeof rule.name === 'string') {
-                            newrule.name = rule.name;
-                        }
-                    }
-                    if (rule.matchOnlyAtStart) {
-                        newrule.matchOnlyAtLineStart = bool(rule.matchOnlyAtLineStart, false);
-                    }
-                    newrule.setRegex(lexerMin, rule.regex);
-                    newrule.setAction(lexerMin, rule.action);
-                }
-                newrules.push(newrule);
-            }
-        }
-    }
-    if (!json.tokenizer || typeof (json.tokenizer) !== 'object') {
-        throw createError(lexer, 'a language definition must define the \'tokenizer\' attribute as an object');
-    }
-    lexer.tokenizer = [];
-    for (const key in json.tokenizer) {
-        if (json.tokenizer.hasOwnProperty(key)) {
-            if (!lexer.start) {
-                lexer.start = key;
-            }
-            const rules = json.tokenizer[key];
-            lexer.tokenizer[key] = ( new Array());
-            addRules('tokenizer.' + key, lexer.tokenizer[key], rules);
-        }
-    }
-    lexer.usesEmbedded = lexerMin.usesEmbedded;
-    if (json.brackets) {
-        if (!(Array.isArray(json.brackets))) {
-            throw createError(lexer, 'the \'brackets\' attribute must be defined as an array');
-        }
-    }
-    else {
-        json.brackets = [
-            { open: '{', close: '}', token: 'delimiter.curly' },
-            { open: '[', close: ']', token: 'delimiter.square' },
-            { open: '(', close: ')', token: 'delimiter.parenthesis' },
-            { open: '<', close: '>', token: 'delimiter.angle' }
-        ];
-    }
-    const brackets = [];
-    for (const el of json.brackets) {
-        let desc = el;
-        if (desc && Array.isArray(desc) && desc.length === 3) {
-            desc = { token: desc[2], open: desc[0], close: desc[1] };
-        }
-        if (desc.open === desc.close) {
-            throw createError(lexer, 'open and close brackets in a \'brackets\' attribute must be different: ' + desc.open +
-                '\n hint: use the \'bracket\' attribute if matching on equal brackets is required.');
-        }
-        if (typeof desc.open === 'string' && typeof desc.token === 'string' && typeof desc.close === 'string') {
-            brackets.push({
-                token: desc.token + lexer.tokenPostfix,
-                open: fixCase(lexer, desc.open),
-                close: fixCase(lexer, desc.close)
-            });
-        }
-        else {
-            throw createError(lexer, 'every element in the \'brackets\' array must be a \'{open,close,token}\' object or array');
-        }
-    }
-    lexer.brackets = brackets;
-    lexer.noThrow = true;
-    return lexer;
-}
-
-function register(language) {
-    ModesRegistry.registerLanguage(language);
-}
-function getLanguages() {
-    let result = [];
-    result = result.concat(ModesRegistry.getLanguages());
-    return result;
-}
-function getEncodedLanguageId(languageId) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    return languageService.languageIdCodec.encodeLanguageId(languageId);
-}
-function onLanguage(languageId, callback) {
-    return StandaloneServices.withServices(() => {
-        const languageService = StandaloneServices.get(ILanguageService);
-        const disposable = languageService.onDidRequestRichLanguageFeatures((encounteredLanguageId) => {
-            if (encounteredLanguageId === languageId) {
-                disposable.dispose();
-                callback();
-            }
-        });
-        return disposable;
-    });
-}
-function onLanguageEncountered(languageId, callback) {
-    return StandaloneServices.withServices(() => {
-        const languageService = StandaloneServices.get(ILanguageService);
-        const disposable = languageService.onDidRequestBasicLanguageFeatures((encounteredLanguageId) => {
-            if (encounteredLanguageId === languageId) {
-                disposable.dispose();
-                callback();
-            }
-        });
-        return disposable;
-    });
-}
-function setLanguageConfiguration(languageId, configuration) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    if (!languageService.isRegisteredLanguageId(languageId)) {
-        throw ( new Error(`Cannot set configuration for unknown language ${languageId}`));
-    }
-    const languageConfigurationService = StandaloneServices.get(ILanguageConfigurationService);
-    return languageConfigurationService.register(languageId, configuration, 100);
-}
-class EncodedTokenizationSupportAdapter {
-    constructor(languageId, actual) {
-        this._languageId = languageId;
-        this._actual = actual;
-    }
-    dispose() {
-    }
-    getInitialState() {
-        return this._actual.getInitialState();
-    }
-    tokenize(line, hasEOL, state) {
-        if (typeof this._actual.tokenize === 'function') {
-            return TokenizationSupportAdapter.adaptTokenize(this._languageId, this._actual, line, state);
-        }
-        throw ( new Error('Not supported!'));
-    }
-    tokenizeEncoded(line, hasEOL, state) {
-        const result = this._actual.tokenizeEncoded(line, state);
-        return new EncodedTokenizationResult(result.tokens, result.endState);
-    }
-}
-class TokenizationSupportAdapter {
-    constructor(_languageId, _actual, _languageService, _standaloneThemeService) {
-        this._languageId = _languageId;
-        this._actual = _actual;
-        this._languageService = _languageService;
-        this._standaloneThemeService = _standaloneThemeService;
-    }
-    dispose() {
-    }
-    getInitialState() {
-        return this._actual.getInitialState();
-    }
-    static _toClassicTokens(tokens, language) {
-        const result = [];
-        let previousStartIndex = 0;
-        for (let i = 0, len = tokens.length; i < len; i++) {
-            const t = tokens[i];
-            let startIndex = t.startIndex;
-            if (i === 0) {
-                startIndex = 0;
-            }
-            else if (startIndex < previousStartIndex) {
-                startIndex = previousStartIndex;
-            }
-            result[i] = new Token$1(startIndex, t.scopes, language);
-            previousStartIndex = startIndex;
-        }
-        return result;
-    }
-    static adaptTokenize(language, actual, line, state) {
-        const actualResult = actual.tokenize(line, state);
-        const tokens = TokenizationSupportAdapter._toClassicTokens(actualResult.tokens, language);
-        let endState;
-        if (actualResult.endState.equals(state)) {
-            endState = state;
-        }
-        else {
-            endState = actualResult.endState;
-        }
-        return new TokenizationResult(tokens, endState);
-    }
-    tokenize(line, hasEOL, state) {
-        return TokenizationSupportAdapter.adaptTokenize(this._languageId, this._actual, line, state);
-    }
-    _toBinaryTokens(languageIdCodec, tokens) {
-        const languageId = languageIdCodec.encodeLanguageId(this._languageId);
-        const tokenTheme = this._standaloneThemeService.getColorTheme().tokenTheme;
-        const result = [];
-        let resultLen = 0;
-        let previousStartIndex = 0;
-        for (let i = 0, len = tokens.length; i < len; i++) {
-            const t = tokens[i];
-            const metadata = tokenTheme.match(languageId, t.scopes) | 1024 ;
-            if (resultLen > 0 && result[resultLen - 1] === metadata) {
-                continue;
-            }
-            let startIndex = t.startIndex;
-            if (i === 0) {
-                startIndex = 0;
-            }
-            else if (startIndex < previousStartIndex) {
-                startIndex = previousStartIndex;
-            }
-            result[resultLen++] = startIndex;
-            result[resultLen++] = metadata;
-            previousStartIndex = startIndex;
-        }
-        const actualResult = ( new Uint32Array(resultLen));
-        for (let i = 0; i < resultLen; i++) {
-            actualResult[i] = result[i];
-        }
-        return actualResult;
-    }
-    tokenizeEncoded(line, hasEOL, state) {
-        const actualResult = this._actual.tokenize(line, state);
-        const tokens = this._toBinaryTokens(this._languageService.languageIdCodec, actualResult.tokens);
-        let endState;
-        if (actualResult.endState.equals(state)) {
-            endState = state;
-        }
-        else {
-            endState = actualResult.endState;
-        }
-        return new EncodedTokenizationResult(tokens, endState);
-    }
-}
-function isATokensProvider(provider) {
-    return (typeof provider.getInitialState === 'function');
-}
-function isEncodedTokensProvider(provider) {
-    return 'tokenizeEncoded' in provider;
-}
-function isThenable(obj) {
-    return obj && typeof obj.then === 'function';
-}
-function setColorMap(colorMap) {
-    const standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
-    if (colorMap) {
-        const result = [null];
-        for (let i = 1, len = colorMap.length; i < len; i++) {
-            result[i] = ( Color.fromHex(colorMap[i]));
-        }
-        standaloneThemeService.setColorMapOverride(result);
-    }
-    else {
-        standaloneThemeService.setColorMapOverride(null);
-    }
-}
-function createTokenizationSupportAdapter(languageId, provider) {
-    if (isEncodedTokensProvider(provider)) {
-        return ( new EncodedTokenizationSupportAdapter(languageId, provider));
-    }
-    else {
-        return ( new TokenizationSupportAdapter(
-            languageId,
-            provider,
-            StandaloneServices.get(ILanguageService),
-            StandaloneServices.get(IStandaloneThemeService)
-        ));
-    }
-}
-function registerTokensProviderFactory(languageId, factory) {
-    const adaptedFactory = new LazyTokenizationSupport(async () => {
-        const result = await Promise.resolve(factory.create());
-        if (!result) {
-            return null;
-        }
-        if (isATokensProvider(result)) {
-            return createTokenizationSupportAdapter(languageId, result);
-        }
-        return ( new MonarchTokenizer(
-            StandaloneServices.get(ILanguageService),
-            StandaloneServices.get(IStandaloneThemeService),
-            languageId,
-            compile(languageId, result),
-            StandaloneServices.get(IConfigurationService)
-        ));
-    });
-    return TokenizationRegistry.registerFactory(languageId, adaptedFactory);
-}
-function setTokensProvider(languageId, provider) {
-    const languageService = StandaloneServices.get(ILanguageService);
-    if (!languageService.isRegisteredLanguageId(languageId)) {
-        throw ( new Error(`Cannot set tokens provider for unknown language ${languageId}`));
-    }
-    if (isThenable(provider)) {
-        return registerTokensProviderFactory(languageId, { create: () => provider });
-    }
-    return TokenizationRegistry.register(languageId, createTokenizationSupportAdapter(languageId, provider));
-}
-function setMonarchTokensProvider(languageId, languageDef) {
-    const create = (languageDef) => {
-        return ( new MonarchTokenizer(
-            StandaloneServices.get(ILanguageService),
-            StandaloneServices.get(IStandaloneThemeService),
-            languageId,
-            compile(languageId, languageDef),
-            StandaloneServices.get(IConfigurationService)
-        ));
-    };
-    if (isThenable(languageDef)) {
-        return registerTokensProviderFactory(languageId, { create: () => languageDef });
-    }
-    return TokenizationRegistry.register(languageId, create(languageDef));
-}
-function registerReferenceProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.referenceProvider.register(languageSelector, provider);
-}
-function registerRenameProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.renameProvider.register(languageSelector, provider);
-}
-function registerNewSymbolNameProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.newSymbolNamesProvider.register(languageSelector, provider);
-}
-function registerSignatureHelpProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.signatureHelpProvider.register(languageSelector, provider);
-}
-function registerHoverProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.hoverProvider.register(languageSelector, {
-        provideHover: async (model, position, token, context) => {
-            const word = model.getWordAtPosition(position);
-            return Promise.resolve(provider.provideHover(model, position, token, context)).then((value) => {
-                if (!value) {
-                    return undefined;
-                }
-                if (!value.range && word) {
-                    value.range = ( new Range$1(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn));
-                }
-                if (!value.range) {
-                    value.range = ( new Range$1(position.lineNumber, position.column, position.lineNumber, position.column));
-                }
-                return value;
-            });
-        }
-    });
-}
-function registerDocumentSymbolProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentSymbolProvider.register(languageSelector, provider);
-}
-function registerDocumentHighlightProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentHighlightProvider.register(languageSelector, provider);
-}
-function registerLinkedEditingRangeProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.linkedEditingRangeProvider.register(languageSelector, provider);
-}
-function registerDefinitionProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.definitionProvider.register(languageSelector, provider);
-}
-function registerImplementationProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.implementationProvider.register(languageSelector, provider);
-}
-function registerTypeDefinitionProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.typeDefinitionProvider.register(languageSelector, provider);
-}
-function registerCodeLensProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.codeLensProvider.register(languageSelector, provider);
-}
-function registerCodeActionProvider(languageSelector, provider, metadata) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.codeActionProvider.register(languageSelector, {
-        providedCodeActionKinds: metadata?.providedCodeActionKinds,
-        documentation: metadata?.documentation,
-        provideCodeActions: (model, range, context, token) => {
-            const markerService = StandaloneServices.get(IMarkerService);
-            const markers = markerService.read({ resource: model.uri }).filter(m => {
-                return Range$1.areIntersectingOrTouching(m, range);
-            });
-            return provider.provideCodeActions(model, range, { markers, only: context.only, trigger: context.trigger }, token);
-        },
-        resolveCodeAction: provider.resolveCodeAction
-    });
-}
-function registerDocumentFormattingEditProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentFormattingEditProvider.register(languageSelector, provider);
-}
-function registerDocumentRangeFormattingEditProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentRangeFormattingEditProvider.register(languageSelector, provider);
-}
-function registerOnTypeFormattingEditProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.onTypeFormattingEditProvider.register(languageSelector, provider);
-}
-function registerLinkProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.linkProvider.register(languageSelector, provider);
-}
-function registerCompletionItemProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.completionProvider.register(languageSelector, provider);
-}
-function registerColorProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.colorProvider.register(languageSelector, provider);
-}
-function registerFoldingRangeProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.foldingRangeProvider.register(languageSelector, provider);
-}
-function registerDeclarationProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.declarationProvider.register(languageSelector, provider);
-}
-function registerSelectionRangeProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.selectionRangeProvider.register(languageSelector, provider);
-}
-function registerDocumentSemanticTokensProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentSemanticTokensProvider.register(languageSelector, provider);
-}
-function registerDocumentRangeSemanticTokensProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.documentRangeSemanticTokensProvider.register(languageSelector, provider);
-}
-function registerInlineCompletionsProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.inlineCompletionsProvider.register(languageSelector, provider);
-}
-function registerInlineEditProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.inlineEditProvider.register(languageSelector, provider);
-}
-function registerInlayHintsProvider(languageSelector, provider) {
-    const languageFeaturesService = StandaloneServices.get(ILanguageFeaturesService);
-    return languageFeaturesService.inlayHintsProvider.register(languageSelector, provider);
-}
-function createMonacoLanguagesAPI() {
-    return {
-        register: register,
-        getLanguages: getLanguages,
-        onLanguage: onLanguage,
-        onLanguageEncountered: onLanguageEncountered,
-        getEncodedLanguageId: getEncodedLanguageId,
-        setLanguageConfiguration: setLanguageConfiguration,
-        setColorMap: setColorMap,
-        registerTokensProviderFactory: registerTokensProviderFactory,
-        setTokensProvider: setTokensProvider,
-        setMonarchTokensProvider: setMonarchTokensProvider,
-        registerReferenceProvider: registerReferenceProvider,
-        registerRenameProvider: registerRenameProvider,
-        registerNewSymbolNameProvider: registerNewSymbolNameProvider,
-        registerCompletionItemProvider: registerCompletionItemProvider,
-        registerSignatureHelpProvider: registerSignatureHelpProvider,
-        registerHoverProvider: registerHoverProvider,
-        registerDocumentSymbolProvider: registerDocumentSymbolProvider,
-        registerDocumentHighlightProvider: registerDocumentHighlightProvider,
-        registerLinkedEditingRangeProvider: registerLinkedEditingRangeProvider,
-        registerDefinitionProvider: registerDefinitionProvider,
-        registerImplementationProvider: registerImplementationProvider,
-        registerTypeDefinitionProvider: registerTypeDefinitionProvider,
-        registerCodeLensProvider: registerCodeLensProvider,
-        registerCodeActionProvider: registerCodeActionProvider,
-        registerDocumentFormattingEditProvider: registerDocumentFormattingEditProvider,
-        registerDocumentRangeFormattingEditProvider: registerDocumentRangeFormattingEditProvider,
-        registerOnTypeFormattingEditProvider: registerOnTypeFormattingEditProvider,
-        registerLinkProvider: registerLinkProvider,
-        registerColorProvider: registerColorProvider,
-        registerFoldingRangeProvider: registerFoldingRangeProvider,
-        registerDeclarationProvider: registerDeclarationProvider,
-        registerSelectionRangeProvider: registerSelectionRangeProvider,
-        registerDocumentSemanticTokensProvider: registerDocumentSemanticTokensProvider,
-        registerDocumentRangeSemanticTokensProvider: registerDocumentRangeSemanticTokensProvider,
-        registerInlineCompletionsProvider: registerInlineCompletionsProvider,
-        registerInlineEditProvider: registerInlineEditProvider,
-        registerInlayHintsProvider: registerInlayHintsProvider,
-        DocumentHighlightKind: DocumentHighlightKind,
-        CompletionItemKind: CompletionItemKind,
-        CompletionItemTag: CompletionItemTag,
-        CompletionItemInsertTextRule: CompletionItemInsertTextRule,
-        SymbolKind: SymbolKind,
-        SymbolTag: SymbolTag,
-        IndentAction: IndentAction,
-        CompletionTriggerKind: CompletionTriggerKind,
-        SignatureHelpTriggerKind: SignatureHelpTriggerKind,
-        InlayHintKind: InlayHintKind,
-        InlineCompletionTriggerKind: InlineCompletionTriggerKind,
-        InlineEditTriggerKind: InlineEditTriggerKind,
-        CodeActionTriggerType: CodeActionTriggerType,
-        NewSymbolNameTag: NewSymbolNameTag,
-        NewSymbolNameTriggerKind: NewSymbolNameTriggerKind,
-        PartialAcceptTriggerKind: PartialAcceptTriggerKind,
-        HoverVerbosityAction: HoverVerbosityAction,
-        FoldingRangeKind: FoldingRangeKind,
-        SelectedSuggestionInfo: SelectedSuggestionInfo,
-    };
-}
-
-EditorOptions.wrappingIndent.defaultValue = 0 ;
-EditorOptions.glyphMargin.defaultValue = false;
-EditorOptions.autoIndent.defaultValue = 3 ;
-EditorOptions.overviewRulerLanes.defaultValue = 2;
-FormattingConflicts.setFormatterSelector((formatter, document, mode) => Promise.resolve(formatter[0]));
-const api = createMonacoBaseAPI();
-api.editor = createMonacoEditorAPI();
-api.languages = createMonacoLanguagesAPI();
-const CancellationTokenSource = api.CancellationTokenSource;
-const Emitter = api.Emitter;
-const KeyCode = api.KeyCode;
-const KeyMod = api.KeyMod;
-const Position = api.Position;
-const Range = api.Range;
-const Selection = api.Selection;
-const SelectionDirection = api.SelectionDirection;
-const MarkerSeverity = api.MarkerSeverity;
-const MarkerTag = api.MarkerTag;
-const Uri = api.Uri;
-const Token = api.Token;
-const editor = api.editor;
-const languages = api.languages;
-const monacoEnvironment = globalThis.MonacoEnvironment;
-if (monacoEnvironment?.globalAPI || (typeof globalThis.define === 'function' && (globalThis.define).amd)) {
-    globalThis.monaco = api;
-}
-
 const originalOnLanguage = languages.onLanguage;
 languages.onLanguage = (languageId, callback) => withReadyServices(() => originalOnLanguage(languageId, callback));
 const originalOnLanguageEncountered = languages.onLanguage;
@@ -2320,4 +13,4 @@ editor.createDiffEditor = createConfiguredDiffEditor;
 editor.createModelReference = createModelReference;
 editor.writeFile = writeFile;
 
-export { CancellationTokenSource, Emitter, KeyCode, KeyMod, MarkerSeverity, MarkerTag, Position, Range, Selection, SelectionDirection, Token, Uri, editor, languages };
+export { editor, languages };