claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/suggest/browser/completionModel.js

@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { quickSelect } from '../../../../base/common/arrays.js';
+import { anyScore, fuzzyScore, FuzzyScore, fuzzyScoreGracefulAggressive, FuzzyScoreOptions } from '../../../../base/common/filters.js';
+import { compareIgnoreCase } from '../../../../base/common/strings.js';
+export class LineContext {
+    constructor(leadingLineContent, characterCountDelta) {
+        this.leadingLineContent = leadingLineContent;
+        this.characterCountDelta = characterCountDelta;
+    }
+}
+/**
+ * Sorted, filtered completion view model
+ * */
+export class CompletionModel {
+    constructor(items, column, lineContext, wordDistance, options, snippetSuggestions, fuzzyScoreOptions = FuzzyScoreOptions.default, clipboardText = undefined) {
+        this.clipboardText = clipboardText;
+        this._snippetCompareFn = CompletionModel._compareCompletionItems;
+        this._items = items;
+        this._column = column;
+        this._wordDistance = wordDistance;
+        this._options = options;
+        this._refilterKind = 1 /* Refilter.All */;
+        this._lineContext = lineContext;
+        this._fuzzyScoreOptions = fuzzyScoreOptions;
+        if (snippetSuggestions === 'top') {
+            this._snippetCompareFn = CompletionModel._compareCompletionItemsSnippetsUp;
+        }
+        else if (snippetSuggestions === 'bottom') {
+            this._snippetCompareFn = CompletionModel._compareCompletionItemsSnippetsDown;
+        }
+    }
+    get lineContext() {
+        return this._lineContext;
+    }
+    set lineContext(value) {
+        if (this._lineContext.leadingLineContent !== value.leadingLineContent
+            || this._lineContext.characterCountDelta !== value.characterCountDelta) {
+            this._refilterKind = this._lineContext.characterCountDelta < value.characterCountDelta && this._filteredItems ? 2 /* Refilter.Incr */ : 1 /* Refilter.All */;
+            this._lineContext = value;
+        }
+    }
+    get items() {
+        this._ensureCachedState();
+        return this._filteredItems;
+    }
+    getItemsByProvider() {
+        this._ensureCachedState();
+        return this._itemsByProvider;
+    }
+    getIncompleteProvider() {
+        this._ensureCachedState();
+        const result = new Set();
+        for (const [provider, items] of this.getItemsByProvider()) {
+            if (items.length > 0 && items[0].container.incomplete) {
+                result.add(provider);
+            }
+        }
+        return result;
+    }
+    get stats() {
+        this._ensureCachedState();
+        return this._stats;
+    }
+    _ensureCachedState() {
+        if (this._refilterKind !== 0 /* Refilter.Nothing */) {
+            this._createCachedState();
+        }
+    }
+    _createCachedState() {
+        this._itemsByProvider = new Map();
+        const labelLengths = [];
+        const { leadingLineContent, characterCountDelta } = this._lineContext;
+        let word = '';
+        let wordLow = '';
+        // incrementally filter less
+        const source = this._refilterKind === 1 /* Refilter.All */ ? this._items : this._filteredItems;
+        const target = [];
+        // picks a score function based on the number of
+        // items that we have to score/filter and based on the
+        // user-configuration
+        const scoreFn = (!this._options.filterGraceful || source.length > 2000) ? fuzzyScore : fuzzyScoreGracefulAggressive;
+        for (let i = 0; i < source.length; i++) {
+            const item = source[i];
+            if (item.isInvalid) {
+                continue; // SKIP invalid items
+            }
+            // keep all items by their provider
+            const arr = this._itemsByProvider.get(item.provider);
+            if (arr) {
+                arr.push(item);
+            }
+            else {
+                this._itemsByProvider.set(item.provider, [item]);
+            }
+            // 'word' is that remainder of the current line that we
+            // filter and score against. In theory each suggestion uses a
+            // different word, but in practice not - that's why we cache
+            const overwriteBefore = item.position.column - item.editStart.column;
+            const wordLen = overwriteBefore + characterCountDelta - (item.position.column - this._column);
+            if (word.length !== wordLen) {
+                word = wordLen === 0 ? '' : leadingLineContent.slice(-wordLen);
+                wordLow = word.toLowerCase();
+            }
+            // remember the word against which this item was
+            // scored
+            item.word = word;
+            if (wordLen === 0) {
+                // when there is nothing to score against, don't
+                // event try to do. Use a const rank and rely on
+                // the fallback-sort using the initial sort order.
+                // use a score of `-100` because that is out of the
+                // bound of values `fuzzyScore` will return
+                item.score = FuzzyScore.Default;
+            }
+            else {
+                // skip word characters that are whitespace until
+                // we have hit the replace range (overwriteBefore)
+                let wordPos = 0;
+                while (wordPos < overwriteBefore) {
+                    const ch = word.charCodeAt(wordPos);
+                    if (ch === 32 /* CharCode.Space */ || ch === 9 /* CharCode.Tab */) {
+                        wordPos += 1;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                if (wordPos >= wordLen) {
+                    // the wordPos at which scoring starts is the whole word
+                    // and therefore the same rules as not having a word apply
+                    item.score = FuzzyScore.Default;
+                }
+                else if (typeof item.completion.filterText === 'string') {
+                    // when there is a `filterText` it must match the `word`.
+                    // if it matches we check with the label to compute highlights
+                    // and if that doesn't yield a result we have no highlights,
+                    // despite having the match
+                    const match = scoreFn(word, wordLow, wordPos, item.completion.filterText, item.filterTextLow, 0, this._fuzzyScoreOptions);
+                    if (!match) {
+                        continue; // NO match
+                    }
+                    if (compareIgnoreCase(item.completion.filterText, item.textLabel) === 0) {
+                        // filterText and label are actually the same -> use good highlights
+                        item.score = match;
+                    }
+                    else {
+                        // re-run the scorer on the label in the hope of a result BUT use the rank
+                        // of the filterText-match
+                        item.score = anyScore(word, wordLow, wordPos, item.textLabel, item.labelLow, 0);
+                        item.score[0] = match[0]; // use score from filterText
+                    }
+                }
+                else {
+                    // by default match `word` against the `label`
+                    const match = scoreFn(word, wordLow, wordPos, item.textLabel, item.labelLow, 0, this._fuzzyScoreOptions);
+                    if (!match) {
+                        continue; // NO match
+                    }
+                    item.score = match;
+                }
+            }
+            item.idx = i;
+            item.distance = this._wordDistance.distance(item.position, item.completion);
+            target.push(item);
+            // update stats
+            labelLengths.push(item.textLabel.length);
+        }
+        this._filteredItems = target.sort(this._snippetCompareFn);
+        this._refilterKind = 0 /* Refilter.Nothing */;
+        this._stats = {
+            pLabelLen: labelLengths.length ?
+                quickSelect(labelLengths.length - .85, labelLengths, (a, b) => a - b)
+                : 0
+        };
+    }
+    static _compareCompletionItems(a, b) {
+        if (a.score[0] > b.score[0]) {
+            return -1;
+        }
+        else if (a.score[0] < b.score[0]) {
+            return 1;
+        }
+        else if (a.distance < b.distance) {
+            return -1;
+        }
+        else if (a.distance > b.distance) {
+            return 1;
+        }
+        else if (a.idx < b.idx) {
+            return -1;
+        }
+        else if (a.idx > b.idx) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    }
+    static _compareCompletionItemsSnippetsDown(a, b) {
+        if (a.completion.kind !== b.completion.kind) {
+            if (a.completion.kind === 27 /* CompletionItemKind.Snippet */) {
+                return 1;
+            }
+            else if (b.completion.kind === 27 /* CompletionItemKind.Snippet */) {
+                return -1;
+            }
+        }
+        return CompletionModel._compareCompletionItems(a, b);
+    }
+    static _compareCompletionItemsSnippetsUp(a, b) {
+        if (a.completion.kind !== b.completion.kind) {
+            if (a.completion.kind === 27 /* CompletionItemKind.Snippet */) {
+                return -1;
+            }
+            else if (b.completion.kind === 27 /* CompletionItemKind.Snippet */) {
+                return 1;
+            }
+        }
+        return CompletionModel._compareCompletionItems(a, b);
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/unicodeHighlighter/browser/bannerController.js

@@ -0,0 +1,119 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import './bannerController.css';
+import { $, append, clearNode } from '../../../../base/browser/dom.js';
+import { ActionBar } from '../../../../base/browser/ui/actionbar/actionbar.js';
+import { Action } from '../../../../base/common/actions.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { MarkdownRenderer } from '../../markdownRenderer/browser/markdownRenderer.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Link } from '../../../../platform/opener/browser/link.js';
+import { widgetClose } from '../../../../platform/theme/common/iconRegistry.js';
+import { ThemeIcon } from '../../../../base/common/themables.js';
+const BANNER_ELEMENT_HEIGHT = 26;
+let BannerController = class BannerController extends Disposable {
+    constructor(_editor, instantiationService) {
+        super();
+        this._editor = _editor;
+        this.instantiationService = instantiationService;
+        this.banner = this._register(this.instantiationService.createInstance(Banner));
+    }
+    hide() {
+        this._editor.setBanner(null, 0);
+        this.banner.clear();
+    }
+    show(item) {
+        this.banner.show({
+            ...item,
+            onClose: () => {
+                var _a;
+                this.hide();
+                (_a = item.onClose) === null || _a === void 0 ? void 0 : _a.call(item);
+            }
+        });
+        this._editor.setBanner(this.banner.element, BANNER_ELEMENT_HEIGHT);
+    }
+};
+BannerController = __decorate([
+    __param(1, IInstantiationService)
+], BannerController);
+export { BannerController };
+// TODO@hediet: Investigate if this can be reused by the workspace banner (bannerPart.ts).
+let Banner = class Banner extends Disposable {
+    constructor(instantiationService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.markdownRenderer = this.instantiationService.createInstance(MarkdownRenderer, {});
+        this.element = $('div.editor-banner');
+        this.element.tabIndex = 0;
+    }
+    getAriaLabel(item) {
+        if (item.ariaLabel) {
+            return item.ariaLabel;
+        }
+        if (typeof item.message === 'string') {
+            return item.message;
+        }
+        return undefined;
+    }
+    getBannerMessage(message) {
+        if (typeof message === 'string') {
+            const element = $('span');
+            element.innerText = message;
+            return element;
+        }
+        return this.markdownRenderer.render(message).element;
+    }
+    clear() {
+        clearNode(this.element);
+    }
+    show(item) {
+        // Clear previous item
+        clearNode(this.element);
+        // Banner aria label
+        const ariaLabel = this.getAriaLabel(item);
+        if (ariaLabel) {
+            this.element.setAttribute('aria-label', ariaLabel);
+        }
+        // Icon
+        const iconContainer = append(this.element, $('div.icon-container'));
+        iconContainer.setAttribute('aria-hidden', 'true');
+        if (item.icon) {
+            iconContainer.appendChild($(`div${ThemeIcon.asCSSSelector(item.icon)}`));
+        }
+        // Message
+        const messageContainer = append(this.element, $('div.message-container'));
+        messageContainer.setAttribute('aria-hidden', 'true');
+        messageContainer.appendChild(this.getBannerMessage(item.message));
+        // Message Actions
+        this.messageActionsContainer = append(this.element, $('div.message-actions-container'));
+        if (item.actions) {
+            for (const action of item.actions) {
+                this._register(this.instantiationService.createInstance(Link, this.messageActionsContainer, { ...action, tabIndex: -1 }, {}));
+            }
+        }
+        // Action
+        const actionBarContainer = append(this.element, $('div.action-container'));
+        this.actionBar = this._register(new ActionBar(actionBarContainer));
+        this.actionBar.push(this._register(new Action('banner.close', 'Close Banner', ThemeIcon.asClassName(widgetClose), true, () => {
+            if (typeof item.onClose === 'function') {
+                item.onClose();
+            }
+        })), { icon: true, label: false });
+        this.actionBar.setFocusable(false);
+    }
+};
+Banner = __decorate([
+    __param(0, IInstantiationService)
+], Banner);

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/edcore.main.js

@@ -0,0 +1,14 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import './editor.all.js';
+import './standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
+import './standalone/browser/inspectTokens/inspectTokens.js';
+import './standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
+import './standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
+import './standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
+import './standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import './standalone/browser/referenceSearch/standaloneReferenceSearch.js';
+import './standalone/browser/toggleHighContrast/toggleHighContrast.js';
+export * from './editor.api.js';

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/editor.all.js

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import './browser/coreCommands.js';
+import './browser/widget/codeEditorWidget.js';
+import './browser/widget/diffEditor/diffEditor.contribution.js';
+import './contrib/anchorSelect/browser/anchorSelect.js';
+import './contrib/bracketMatching/browser/bracketMatching.js';
+import './contrib/caretOperations/browser/caretOperations.js';
+import './contrib/caretOperations/browser/transpose.js';
+import './contrib/clipboard/browser/clipboard.js';
+import './contrib/codeAction/browser/codeActionContributions.js';
+import './contrib/codelens/browser/codelensController.js';
+import './contrib/colorPicker/browser/colorContributions.js';
+import './contrib/colorPicker/browser/standaloneColorPickerActions.js';
+import './contrib/comment/browser/comment.js';
+import './contrib/contextmenu/browser/contextmenu.js';
+import './contrib/cursorUndo/browser/cursorUndo.js';
+import './contrib/dnd/browser/dnd.js';
+import './contrib/dropOrPasteInto/browser/copyPasteContribution.js';
+import './contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
+import './contrib/find/browser/findController.js';
+import './contrib/folding/browser/folding.js';
+import './contrib/fontZoom/browser/fontZoom.js';
+import './contrib/format/browser/formatActions.js';
+import './contrib/documentSymbols/browser/documentSymbols.js';
+import './contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
+import './contrib/inlineProgress/browser/inlineProgress.js';
+import './contrib/gotoSymbol/browser/goToCommands.js';
+import './contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import './contrib/gotoError/browser/gotoError.js';
+import './contrib/hover/browser/hover.js';
+import './contrib/indentation/browser/indentation.js';
+import './contrib/inlayHints/browser/inlayHintsContribution.js';
+import './contrib/inPlaceReplace/browser/inPlaceReplace.js';
+import './contrib/lineSelection/browser/lineSelection.js';
+import './contrib/linesOperations/browser/linesOperations.js';
+import './contrib/linkedEditing/browser/linkedEditing.js';
+import './contrib/links/browser/links.js';
+import './contrib/longLinesHelper/browser/longLinesHelper.js';
+import './contrib/multicursor/browser/multicursor.js';
+import './contrib/parameterHints/browser/parameterHints.js';
+import './contrib/rename/browser/rename.js';
+import './contrib/semanticTokens/browser/documentSemanticTokens.js';
+import './contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import './contrib/smartSelect/browser/smartSelect.js';
+import './contrib/snippet/browser/snippetController2.js';
+import './contrib/stickyScroll/browser/stickyScrollContribution.js';
+import './contrib/suggest/browser/suggestController.js';
+import './contrib/suggest/browser/suggestInlineCompletions.js';
+import './contrib/tokenization/browser/tokenization.js';
+import './contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import './contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
+import './contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import './contrib/wordHighlighter/browser/wordHighlighter.js';
+import './contrib/wordOperations/browser/wordOperations.js';
+import './contrib/wordPartOperations/browser/wordPartOperations.js';
+import './contrib/readOnlyMessage/browser/contribution.js';
+// Load up these strings even in VSCode, even if they are not used
+// in order to get them translated
+import './common/standaloneStrings.js';
+import '../base/browser/ui/codicons/codiconStyles.js'; // The codicons are defined here and must be loaded

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/editor.api.js

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { EditorOptions } from './common/config/editorOptions.js';
+import { createMonacoBaseAPI } from './common/services/editorBaseApi.js';
+import { createMonacoEditorAPI } from './standalone/browser/standaloneEditor.js';
+import { createMonacoLanguagesAPI } from './standalone/browser/standaloneLanguages.js';
+import { FormattingConflicts } from './contrib/format/browser/format.js';
+// Set defaults for standalone editor
+EditorOptions.wrappingIndent.defaultValue = 0 /* WrappingIndent.None */;
+EditorOptions.glyphMargin.defaultValue = false;
+EditorOptions.autoIndent.defaultValue = 3 /* EditorAutoIndentStrategy.Advanced */;
+EditorOptions.overviewRulerLanes.defaultValue = 2;
+// We need to register a formatter selector which simply picks the first available formatter.
+// See https://github.com/microsoft/monaco-editor/issues/2327
+FormattingConflicts.setFormatterSelector((formatter, document, mode) => Promise.resolve(formatter[0]));
+const api = createMonacoBaseAPI();
+api.editor = createMonacoEditorAPI();
+api.languages = createMonacoLanguagesAPI();
+export const CancellationTokenSource = api.CancellationTokenSource;
+export const Emitter = api.Emitter;
+export const KeyCode = api.KeyCode;
+export const KeyMod = api.KeyMod;
+export const Position = api.Position;
+export const Range = api.Range;
+export const Selection = api.Selection;
+export const SelectionDirection = api.SelectionDirection;
+export const MarkerSeverity = api.MarkerSeverity;
+export const MarkerTag = api.MarkerTag;
+export const Uri = api.Uri;
+export const Token = api.Token;
+export const editor = api.editor;
+export const languages = api.languages;
+const monacoEnvironment = globalThis.MonacoEnvironment;
+if ((monacoEnvironment === null || monacoEnvironment === void 0 ? void 0 : monacoEnvironment.globalAPI) || (typeof define === 'function' && define.amd)) {
+    globalThis.monaco = api;
+}
+if (typeof globalThis.require !== 'undefined' && typeof globalThis.require.config === 'function') {
+    globalThis.require.config({
+        ignoreDuplicateModules: [
+            'vscode-languageserver-types',
+            'vscode-languageserver-types/main',
+            'vscode-languageserver-textdocument',
+            'vscode-languageserver-textdocument/main',
+            'vscode-nls',
+            'vscode-nls/vscode-nls',
+            'jsonc-parser',
+            'jsonc-parser/main',
+            'vscode-uri',
+            'vscode-uri/index',
+            'vs/basic-languages/typescript/typescript'
+        ]
+    });
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/editor.main.js

@@ -0,0 +1,7 @@
+import '../basic-languages/monaco.contribution';
+import '../language/css/monaco.contribution';
+import '../language/html/monaco.contribution';
+import '../language/json/monaco.contribution';
+import '../language/typescript/monaco.contribution';
+
+export * from './edcore.main';

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/editor.worker.js

@@ -0,0 +1,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { SimpleWorkerServer } from '../base/common/worker/simpleWorker.js';
+import { EditorSimpleWorker } from './common/services/editorSimpleWorker.js';
+let initialized = false;
+export function initialize(foreignModule) {
+    if (initialized) {
+        return;
+    }
+    initialized = true;
+    const simpleWorker = new SimpleWorkerServer((msg) => {
+        globalThis.postMessage(msg);
+    }, (host) => new EditorSimpleWorker(host, foreignModule));
+    globalThis.onmessage = (e) => {
+        simpleWorker.onmessage(e.data);
+    };
+}
+globalThis.onmessage = (e) => {
+    // Ignore first message in this case and initialize if not yet initialized
+    if (!initialized) {
+        initialize(null);
+    }
+};

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/standalone/browser/colorizer.js

@@ -0,0 +1,118 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createTrustedTypesPolicy } from '../../../base/browser/trustedTypes.js';
+import * as strings from '../../../base/common/strings.js';
+import { TokenizationRegistry } from '../../common/languages.js';
+import { LineTokens } from '../../common/tokens/lineTokens.js';
+import { RenderLineInput, renderViewLine2 as renderViewLine } from '../../common/viewLayout/viewLineRenderer.js';
+import { ViewLineRenderingData } from '../../common/viewModel.js';
+import { MonarchTokenizer } from '../common/monarch/monarchLexer.js';
+const ttPolicy = createTrustedTypesPolicy('standaloneColorizer', { createHTML: value => value });
+export 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) => {
+            var _a;
+            const trustedhtml = (_a = ttPolicy === null || ttPolicy === void 0 ? void 0 : ttPolicy.createHTML(str)) !== null && _a !== void 0 ? _a : 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 (strings.startsWithUTF8BOM(text)) {
+            text = text.substr(1);
+        }
+        const lines = strings.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 = renderViewLine(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 /* FontStyle.None */ << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)
+        | (1 /* ColorId.DefaultForeground */ << 15 /* MetadataConsts.FOREGROUND_OFFSET */)
+        | (2 /* ColorId.DefaultBackground */ << 24 /* 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, /* check for basic ASCII */ true);
+        const containsRTL = ViewLineRenderingData.containsRTL(line, isBasicASCII, /* check for RTL */ true);
+        const renderResult = renderViewLine(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, /* check for basic ASCII */ true);
+        const containsRTL = ViewLineRenderingData.containsRTL(line, isBasicASCII, /* check for RTL */ true);
+        const renderResult = renderViewLine(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('');
+}