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

package/vscode/src/vs/editor/editor.api.js

@@ -0,0 +1,35 @@
+
+import { EditorOptions, WrappingIndent, EditorAutoIndentStrategy } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+import { createMonacoBaseAPI } from 'vscode/vscode/vs/editor/common/services/editorBaseApi';
+import { createMonacoEditorAPI } from './standalone/browser/standaloneEditor.js';
+import { createMonacoLanguagesAPI } from './standalone/browser/standaloneLanguages.js';
+import { FormattingConflicts } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
+
+EditorOptions.wrappingIndent.defaultValue = WrappingIndent.None;
+EditorOptions.glyphMargin.defaultValue = false;
+EditorOptions.autoIndent.defaultValue = EditorAutoIndentStrategy.Advanced;
+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;
+}
+
+export { CancellationTokenSource, Emitter, KeyCode, KeyMod, MarkerSeverity, MarkerTag, Position, Range, Selection, SelectionDirection, Token, Uri, editor, languages };

package/vscode/src/vs/editor/standalone/browser/colorizer.d.ts

@@ -0,0 +1,17 @@
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { IViewLineTokens } from "vscode/vscode/vs/editor/common/tokens/lineTokens";
+import { IStandaloneThemeService } from "vscode/vscode/vs/editor/standalone/common/standaloneTheme";
+export interface IColorizerOptions {
+    tabSize?: number;
+}
+export interface IColorizerElementOptions extends IColorizerOptions {
+    theme?: string;
+    mimeType?: string;
+}
+export declare class Colorizer {
+    static colorizeElement(themeService: IStandaloneThemeService, languageService: ILanguageService, domNode: HTMLElement, options: IColorizerElementOptions): Promise<void>;
+    static colorize(languageService: ILanguageService, text: string, languageId: string, options: IColorizerOptions | null | undefined): Promise<string>;
+    static colorizeLine(line: string, mightContainNonBasicASCII: boolean, mightContainRTL: boolean, tokens: IViewLineTokens, tabSize?: number): string;
+    static colorizeModelLine(model: ITextModel, lineNumber: number, tabSize?: number): string;
+}

package/vscode/src/vs/editor/standalone/browser/colorizer.js

@@ -0,0 +1,178 @@
+
+import { createTrustedTypesPolicy } from 'vscode/vscode/vs/base/browser/trustedTypes';
+import { startsWithUTF8BOM, splitLines } from 'vscode/vscode/vs/base/common/strings';
+import { FontStyle, MetadataConsts, ColorId } from 'vscode/vscode/vs/editor/common/encodedTokenAttributes';
+import { TokenizationRegistry } from 'vscode/vscode/vs/editor/common/languages';
+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 { MonarchTokenizer } from '../common/monarch/monarchLexer.js';
+
+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 = ((FontStyle.None << MetadataConsts.FONT_STYLE_OFFSET)
+        | (ColorId.DefaultForeground << MetadataConsts.FOREGROUND_OFFSET)
+        | (ColorId.DefaultBackground << MetadataConsts.BACKGROUND_OFFSET)) >>> 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('');
+}
+
+export { Colorizer };

package/vscode/src/vs/editor/standalone/browser/standalone-tokens.css.js

@@ -0,0 +1,6 @@
+import n from 'vscode/external/rollup-plugin-styles/dist/runtime/inject-css';
+
+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,{});
+
+export { css, css as default };

package/vscode/src/vs/editor/standalone/browser/standaloneEditor.d.ts

@@ -0,0 +1,73 @@
+import { IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ICodeEditor } from "vscode/vscode/vs/editor/browser/editorBrowser";
+import { IWebWorkerOptions, MonacoWebWorker } from "./standaloneWebWorker.js";
+import { IPosition } from "vscode/vscode/vs/editor/common/core/position";
+import { IRange } from "vscode/vscode/vs/editor/common/core/range";
+import { IDiffEditor } from "vscode/vscode/vs/editor/common/editorCommon";
+import * as languages from "vscode/vscode/vs/editor/common/languages";
+import { ITextModel } from "vscode/vscode/vs/editor/common/model";
+import { IColorizerElementOptions, IColorizerOptions } from "./colorizer.js";
+import { IActionDescriptor, IStandaloneCodeEditor, IStandaloneDiffEditor, IStandaloneDiffEditorConstructionOptions, IStandaloneEditorConstructionOptions } from "vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor";
+import { IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+import { IStandaloneThemeData } from "vscode/vscode/vs/editor/standalone/common/standaloneTheme";
+import { ICommandHandler } from "vscode/vscode/vs/platform/commands/common/commands";
+import { IMarker, IMarkerData } from "vscode/vscode/vs/platform/markers/common/markers";
+import { MultiDiffEditorWidget } from "@codingame/monaco-vscode-5452e2b7-9081-5f95-839b-4ab3544ce28f-common/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget";
+export declare function create(domElement: HTMLElement, options?: IStandaloneEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneCodeEditor;
+export declare function onDidCreateEditor(listener: (codeEditor: ICodeEditor) => void): IDisposable;
+export declare function onDidCreateDiffEditor(listener: (diffEditor: IDiffEditor) => void): IDisposable;
+export declare function getEditors(): readonly ICodeEditor[];
+export declare function getDiffEditors(): readonly IDiffEditor[];
+export declare function createDiffEditor(domElement: HTMLElement, options?: IStandaloneDiffEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneDiffEditor;
+export declare function createMultiFileDiffEditor(domElement: HTMLElement, override?: IEditorOverrideServices): MultiDiffEditorWidget;
+export interface ICommandDescriptor {
+    id: string;
+    run: ICommandHandler;
+}
+export declare function addCommand(descriptor: ICommandDescriptor): IDisposable;
+export declare function addEditorAction(descriptor: IActionDescriptor): IDisposable;
+export interface IKeybindingRule {
+    keybinding: number;
+    command?: string | null;
+    commandArgs?: any;
+    when?: string | null;
+}
+export declare function addKeybindingRule(rule: IKeybindingRule): IDisposable;
+export declare function addKeybindingRules(rules: IKeybindingRule[]): IDisposable;
+export declare function createModel(value: string, language?: string, uri?: URI): ITextModel;
+export declare function setModelLanguage(model: ITextModel, mimeTypeOrLanguageId: string): void;
+export declare function setModelMarkers(model: ITextModel, owner: string, markers: IMarkerData[]): void;
+export declare function removeAllMarkers(owner: string): void;
+export declare function getModelMarkers(filter: {
+    owner?: string;
+    resource?: URI;
+    take?: number;
+}): IMarker[];
+export declare function onDidChangeMarkers(listener: (e: readonly URI[]) => void): IDisposable;
+export declare function getModel(uri: URI): ITextModel | null;
+export declare function getModels(): ITextModel[];
+export declare function onDidCreateModel(listener: (model: ITextModel) => void): IDisposable;
+export declare function onWillDisposeModel(listener: (model: ITextModel) => void): IDisposable;
+export declare function onDidChangeModelLanguage(listener: (e: {
+    readonly model: ITextModel;
+    readonly oldLanguage: string;
+}) => void): IDisposable;
+export declare function createWebWorker<T extends object>(opts: IWebWorkerOptions): MonacoWebWorker<T>;
+export declare function colorizeElement(domNode: HTMLElement, options: IColorizerElementOptions): Promise<void>;
+export declare function colorize(text: string, languageId: string, options: IColorizerOptions): Promise<string>;
+export declare function colorizeModelLine(model: ITextModel, lineNumber: number, tabSize?: number): string;
+export declare function tokenize(text: string, languageId: string): languages.Token[][];
+export declare function defineTheme(themeName: string, themeData: IStandaloneThemeData): void;
+export declare function setTheme(themeName: string): void;
+export declare function remeasureFonts(): void;
+export declare function registerCommand(id: string, handler: (accessor: any, ...args: any[]) => void): IDisposable;
+export interface ILinkOpener {
+    open(resource: URI): boolean | Promise<boolean>;
+}
+export declare function registerLinkOpener(opener: ILinkOpener): IDisposable;
+export interface ICodeEditorOpener {
+    openCodeEditor(source: ICodeEditor, resource: URI, selectionOrPosition?: IRange | IPosition): boolean | Promise<boolean>;
+}
+export declare function registerEditorOpener(opener: ICodeEditorOpener): IDisposable;
+export declare function createMonacoEditorAPI(): typeof monaco.editor;

package/vscode/src/vs/editor/standalone/browser/standaloneEditor.js

@@ -0,0 +1,347 @@
+
+import { mainWindow } from 'vscode/vscode/vs/base/browser/window';
+import { DisposableStore, Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { splitLines } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import './standalone-tokens.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 { createWebWorker as createWebWorker$1 } from './standaloneWebWorker.js';
+import { ConfigurationChangedEvent, ApplyUpdateResult, EditorOptions } from 'vscode/vscode/vs/editor/common/config/editorOptions';
+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 { TokenizationRegistry } from 'vscode/vscode/vs/editor/common/languages';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { PLAINTEXT_LANGUAGE_ID } from 'vscode/vscode/vs/editor/common/languages/modesRegistry';
+import { NullState, nullTokenize } 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 } from 'vscode/vscode/vs/editor/common/standalone/standaloneEnums';
+import { Colorizer } from './colorizer.js';
+import { StandaloneEditor, StandaloneDiffEditor2, createTextModel } from 'vscode/vscode/vs/editor/standalone/browser/standaloneCodeEditor';
+import { StandaloneServices, StandaloneKeybindingService } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+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 '@codingame/monaco-vscode-5452e2b7-9081-5f95-839b-4ab3544ce28f-common/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget';
+
+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
+    };
+}
+
+export { addCommand, addEditorAction, addKeybindingRule, addKeybindingRules, colorize, colorizeElement, colorizeModelLine, create, createDiffEditor, createModel, createMonacoEditorAPI, createMultiFileDiffEditor, createWebWorker, defineTheme, getDiffEditors, getEditors, getModel, getModelMarkers, getModels, onDidChangeMarkers, onDidChangeModelLanguage, onDidCreateDiffEditor, onDidCreateEditor, onDidCreateModel, onWillDisposeModel, registerCommand, registerEditorOpener, registerLinkOpener, remeasureFonts, removeAllMarkers, setModelLanguage, setModelMarkers, setTheme, tokenize };