{"version":3,"file":"static/js/8637_6e15b02b16652cdf0333.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/encodedTokenAttributes.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languageFeatureRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languageSelector.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/autoIndent.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/defaultDocumentColorsComputer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/enterAction.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/language.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/languageConfiguration.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/characterPair.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/electricCharacter.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/indentRules.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/onEnter.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/languageBracketsConfiguration.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/linkComputer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/modesRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/nullTokenize.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/indentationLineProcessor.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/inplaceReplaceSupport.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/richEditBrackets.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/supports/tokenization.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/languages/textToHtmlTokenizer.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n */\nexport class TokenMetadata {\n    static getLanguageId(metadata) {\n        return (metadata & 255 /* MetadataConsts.LANGUAGEID_MASK */) >>> 0 /* MetadataConsts.LANGUAGEID_OFFSET */;\n    }\n    static getTokenType(metadata) {\n        return (metadata & 768 /* MetadataConsts.TOKEN_TYPE_MASK */) >>> 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */;\n    }\n    static containsBalancedBrackets(metadata) {\n        return (metadata & 1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */) !== 0;\n    }\n    static getFontStyle(metadata) {\n        return (metadata & 30720 /* MetadataConsts.FONT_STYLE_MASK */) >>> 11 /* MetadataConsts.FONT_STYLE_OFFSET */;\n    }\n    static getForeground(metadata) {\n        return (metadata & 16744448 /* MetadataConsts.FOREGROUND_MASK */) >>> 15 /* MetadataConsts.FOREGROUND_OFFSET */;\n    }\n    static getBackground(metadata) {\n        return (metadata & 4278190080 /* MetadataConsts.BACKGROUND_MASK */) >>> 24 /* MetadataConsts.BACKGROUND_OFFSET */;\n    }\n    static getClassNameFromMetadata(metadata) {\n        const foreground = this.getForeground(metadata);\n        let className = 'mtk' + foreground;\n        const fontStyle = this.getFontStyle(metadata);\n        if (fontStyle & 1 /* FontStyle.Italic */) {\n            className += ' mtki';\n        }\n        if (fontStyle & 2 /* FontStyle.Bold */) {\n            className += ' mtkb';\n        }\n        if (fontStyle & 4 /* FontStyle.Underline */) {\n            className += ' mtku';\n        }\n        if (fontStyle & 8 /* FontStyle.Strikethrough */) {\n            className += ' mtks';\n        }\n        return className;\n    }\n    static getInlineStyleFromMetadata(metadata, colorMap) {\n        const foreground = this.getForeground(metadata);\n        const fontStyle = this.getFontStyle(metadata);\n        let result = `color: ${colorMap[foreground]};`;\n        if (fontStyle & 1 /* FontStyle.Italic */) {\n            result += 'font-style: italic;';\n        }\n        if (fontStyle & 2 /* FontStyle.Bold */) {\n            result += 'font-weight: bold;';\n        }\n        let textDecoration = '';\n        if (fontStyle & 4 /* FontStyle.Underline */) {\n            textDecoration += ' underline';\n        }\n        if (fontStyle & 8 /* FontStyle.Strikethrough */) {\n            textDecoration += ' line-through';\n        }\n        if (textDecoration) {\n            result += `text-decoration:${textDecoration};`;\n        }\n        return result;\n    }\n    static getPresentationFromMetadata(metadata) {\n        const foreground = this.getForeground(metadata);\n        const fontStyle = this.getFontStyle(metadata);\n        return {\n            foreground: foreground,\n            italic: Boolean(fontStyle & 1 /* FontStyle.Italic */),\n            bold: Boolean(fontStyle & 2 /* FontStyle.Bold */),\n            underline: Boolean(fontStyle & 4 /* FontStyle.Underline */),\n            strikethrough: Boolean(fontStyle & 8 /* FontStyle.Strikethrough */),\n        };\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../base/common/event.js';\nimport { toDisposable } from '../../base/common/lifecycle.js';\nimport { shouldSynchronizeModel } from './model.js';\nimport { score } from './languageSelector.js';\nfunction isExclusive(selector) {\n    if (typeof selector === 'string') {\n        return false;\n    }\n    else if (Array.isArray(selector)) {\n        return selector.every(isExclusive);\n    }\n    else {\n        return !!selector.exclusive; // TODO: microsoft/TypeScript#42768\n    }\n}\nclass MatchCandidate {\n    constructor(uri, languageId, notebookUri, notebookType) {\n        this.uri = uri;\n        this.languageId = languageId;\n        this.notebookUri = notebookUri;\n        this.notebookType = notebookType;\n    }\n    equals(other) {\n        var _a, _b;\n        return this.notebookType === other.notebookType\n            && this.languageId === other.languageId\n            && this.uri.toString() === other.uri.toString()\n            && ((_a = this.notebookUri) === null || _a === void 0 ? void 0 : _a.toString()) === ((_b = other.notebookUri) === null || _b === void 0 ? void 0 : _b.toString());\n    }\n}\nexport class LanguageFeatureRegistry {\n    constructor(_notebookInfoResolver) {\n        this._notebookInfoResolver = _notebookInfoResolver;\n        this._clock = 0;\n        this._entries = [];\n        this._onDidChange = new Emitter();\n        this.onDidChange = this._onDidChange.event;\n    }\n    register(selector, provider) {\n        let entry = {\n            selector,\n            provider,\n            _score: -1,\n            _time: this._clock++\n        };\n        this._entries.push(entry);\n        this._lastCandidate = undefined;\n        this._onDidChange.fire(this._entries.length);\n        return toDisposable(() => {\n            if (entry) {\n                const idx = this._entries.indexOf(entry);\n                if (idx >= 0) {\n                    this._entries.splice(idx, 1);\n                    this._lastCandidate = undefined;\n                    this._onDidChange.fire(this._entries.length);\n                    entry = undefined;\n                }\n            }\n        });\n    }\n    has(model) {\n        return this.all(model).length > 0;\n    }\n    all(model) {\n        if (!model) {\n            return [];\n        }\n        this._updateScores(model);\n        const result = [];\n        // from registry\n        for (const entry of this._entries) {\n            if (entry._score > 0) {\n                result.push(entry.provider);\n            }\n        }\n        return result;\n    }\n    ordered(model) {\n        const result = [];\n        this._orderedForEach(model, entry => result.push(entry.provider));\n        return result;\n    }\n    orderedGroups(model) {\n        const result = [];\n        let lastBucket;\n        let lastBucketScore;\n        this._orderedForEach(model, entry => {\n            if (lastBucket && lastBucketScore === entry._score) {\n                lastBucket.push(entry.provider);\n            }\n            else {\n                lastBucketScore = entry._score;\n                lastBucket = [entry.provider];\n                result.push(lastBucket);\n            }\n        });\n        return result;\n    }\n    _orderedForEach(model, callback) {\n        this._updateScores(model);\n        for (const entry of this._entries) {\n            if (entry._score > 0) {\n                callback(entry);\n            }\n        }\n    }\n    _updateScores(model) {\n        var _a, _b;\n        const notebookInfo = (_a = this._notebookInfoResolver) === null || _a === void 0 ? void 0 : _a.call(this, model.uri);\n        // use the uri (scheme, pattern) of the notebook info iff we have one\n        // otherwise it's the model's/document's uri\n        const candidate = notebookInfo\n            ? new MatchCandidate(model.uri, model.getLanguageId(), notebookInfo.uri, notebookInfo.type)\n            : new MatchCandidate(model.uri, model.getLanguageId(), undefined, undefined);\n        if ((_b = this._lastCandidate) === null || _b === void 0 ? void 0 : _b.equals(candidate)) {\n            // nothing has changed\n            return;\n        }\n        this._lastCandidate = candidate;\n        for (const entry of this._entries) {\n            entry._score = score(entry.selector, candidate.uri, candidate.languageId, shouldSynchronizeModel(model), candidate.notebookUri, candidate.notebookType);\n            if (isExclusive(entry.selector) && entry._score > 0) {\n                // support for one exclusive selector that overwrites\n                // any other selector\n                for (const entry of this._entries) {\n                    entry._score = 0;\n                }\n                entry._score = 1000;\n                break;\n            }\n        }\n        // needs sorting\n        this._entries.sort(LanguageFeatureRegistry._compareByScoreAndTime);\n    }\n    static _compareByScoreAndTime(a, b) {\n        if (a._score < b._score) {\n            return 1;\n        }\n        else if (a._score > b._score) {\n            return -1;\n        }\n        // De-prioritize built-in providers\n        if (isBuiltinSelector(a.selector) && !isBuiltinSelector(b.selector)) {\n            return 1;\n        }\n        else if (!isBuiltinSelector(a.selector) && isBuiltinSelector(b.selector)) {\n            return -1;\n        }\n        if (a._time < b._time) {\n            return 1;\n        }\n        else if (a._time > b._time) {\n            return -1;\n        }\n        else {\n            return 0;\n        }\n    }\n}\nfunction isBuiltinSelector(selector) {\n    if (typeof selector === 'string') {\n        return false;\n    }\n    if (Array.isArray(selector)) {\n        return selector.some(isBuiltinSelector);\n    }\n    return Boolean(selector.isBuiltin);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { match as matchGlobPattern } from '../../base/common/glob.js';\nimport { normalize } from '../../base/common/path.js';\nexport function score(selector, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType) {\n    if (Array.isArray(selector)) {\n        // array -> take max individual value\n        let ret = 0;\n        for (const filter of selector) {\n            const value = score(filter, candidateUri, candidateLanguage, candidateIsSynchronized, candidateNotebookUri, candidateNotebookType);\n            if (value === 10) {\n                return value; // already at the highest\n            }\n            if (value > ret) {\n                ret = value;\n            }\n        }\n        return ret;\n    }\n    else if (typeof selector === 'string') {\n        if (!candidateIsSynchronized) {\n            return 0;\n        }\n        // short-hand notion, desugars to\n        // 'fooLang' -> { language: 'fooLang'}\n        // '*' -> { language: '*' }\n        if (selector === '*') {\n            return 5;\n        }\n        else if (selector === candidateLanguage) {\n            return 10;\n        }\n        else {\n            return 0;\n        }\n    }\n    else if (selector) {\n        // filter -> select accordingly, use defaults for scheme\n        const { language, pattern, scheme, hasAccessToAllModels, notebookType } = selector; // TODO: microsoft/TypeScript#42768\n        if (!candidateIsSynchronized && !hasAccessToAllModels) {\n            return 0;\n        }\n        // selector targets a notebook -> use the notebook uri instead\n        // of the \"normal\" document uri.\n        if (notebookType && candidateNotebookUri) {\n            candidateUri = candidateNotebookUri;\n        }\n        let ret = 0;\n        if (scheme) {\n            if (scheme === candidateUri.scheme) {\n                ret = 10;\n            }\n            else if (scheme === '*') {\n                ret = 5;\n            }\n            else {\n                return 0;\n            }\n        }\n        if (language) {\n            if (language === candidateLanguage) {\n                ret = 10;\n            }\n            else if (language === '*') {\n                ret = Math.max(ret, 5);\n            }\n            else {\n                return 0;\n            }\n        }\n        if (notebookType) {\n            if (notebookType === candidateNotebookType) {\n                ret = 10;\n            }\n            else if (notebookType === '*' && candidateNotebookType !== undefined) {\n                ret = Math.max(ret, 5);\n            }\n            else {\n                return 0;\n            }\n        }\n        if (pattern) {\n            let normalizedPattern;\n            if (typeof pattern === 'string') {\n                normalizedPattern = pattern;\n            }\n            else {\n                // Since this pattern has a `base` property, we need\n                // to normalize this path first before passing it on\n                // because we will compare it against `Uri.fsPath`\n                // which uses platform specific separators.\n                // Refs: https://github.com/microsoft/vscode/issues/99938\n                normalizedPattern = { ...pattern, base: normalize(pattern.base) };\n            }\n            if (normalizedPattern === candidateUri.fsPath || matchGlobPattern(normalizedPattern, candidateUri.fsPath)) {\n                ret = 10;\n            }\n            else {\n                return 0;\n            }\n        }\n        return ret;\n    }\n    else {\n        return 0;\n    }\n}\n","import { Codicon } from '../../base/common/codicons.js';\nimport { URI } from '../../base/common/uri.js';\nimport { Range } from './core/range.js';\nimport { TokenizationRegistry as TokenizationRegistryImpl } from './tokenizationRegistry.js';\nimport { localize } from '../../nls.js';\nexport class Token {\n    constructor(offset, type, language) {\n        this.offset = offset;\n        this.type = type;\n        this.language = language;\n        this._tokenBrand = undefined;\n    }\n    toString() {\n        return '(' + this.offset + ', ' + this.type + ')';\n    }\n}\n/**\n * @internal\n */\nexport class TokenizationResult {\n    constructor(tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n        this._tokenizationResultBrand = undefined;\n    }\n}\n/**\n * @internal\n */\nexport class EncodedTokenizationResult {\n    constructor(\n    /**\n     * The tokens in binary format. Each token occupies two array indices. For token i:\n     *  - at offset 2*i => startIndex\n     *  - at offset 2*i + 1 => metadata\n     *\n     */\n    tokens, endState) {\n        this.tokens = tokens;\n        this.endState = endState;\n        this._encodedTokenizationResultBrand = undefined;\n    }\n}\nexport var HoverVerbosityAction;\n(function (HoverVerbosityAction) {\n    /**\n     * Increase the verbosity of the hover\n     */\n    HoverVerbosityAction[HoverVerbosityAction[\"Increase\"] = 0] = \"Increase\";\n    /**\n     * Decrease the verbosity of the hover\n     */\n    HoverVerbosityAction[HoverVerbosityAction[\"Decrease\"] = 1] = \"Decrease\";\n})(HoverVerbosityAction || (HoverVerbosityAction = {}));\n/**\n * @internal\n */\nexport var CompletionItemKinds;\n(function (CompletionItemKinds) {\n    const byKind = new Map();\n    byKind.set(0 /* CompletionItemKind.Method */, Codicon.symbolMethod);\n    byKind.set(1 /* CompletionItemKind.Function */, Codicon.symbolFunction);\n    byKind.set(2 /* CompletionItemKind.Constructor */, Codicon.symbolConstructor);\n    byKind.set(3 /* CompletionItemKind.Field */, Codicon.symbolField);\n    byKind.set(4 /* CompletionItemKind.Variable */, Codicon.symbolVariable);\n    byKind.set(5 /* CompletionItemKind.Class */, Codicon.symbolClass);\n    byKind.set(6 /* CompletionItemKind.Struct */, Codicon.symbolStruct);\n    byKind.set(7 /* CompletionItemKind.Interface */, Codicon.symbolInterface);\n    byKind.set(8 /* CompletionItemKind.Module */, Codicon.symbolModule);\n    byKind.set(9 /* CompletionItemKind.Property */, Codicon.symbolProperty);\n    byKind.set(10 /* CompletionItemKind.Event */, Codicon.symbolEvent);\n    byKind.set(11 /* CompletionItemKind.Operator */, Codicon.symbolOperator);\n    byKind.set(12 /* CompletionItemKind.Unit */, Codicon.symbolUnit);\n    byKind.set(13 /* CompletionItemKind.Value */, Codicon.symbolValue);\n    byKind.set(15 /* CompletionItemKind.Enum */, Codicon.symbolEnum);\n    byKind.set(14 /* CompletionItemKind.Constant */, Codicon.symbolConstant);\n    byKind.set(15 /* CompletionItemKind.Enum */, Codicon.symbolEnum);\n    byKind.set(16 /* CompletionItemKind.EnumMember */, Codicon.symbolEnumMember);\n    byKind.set(17 /* CompletionItemKind.Keyword */, Codicon.symbolKeyword);\n    byKind.set(27 /* CompletionItemKind.Snippet */, Codicon.symbolSnippet);\n    byKind.set(18 /* CompletionItemKind.Text */, Codicon.symbolText);\n    byKind.set(19 /* CompletionItemKind.Color */, Codicon.symbolColor);\n    byKind.set(20 /* CompletionItemKind.File */, Codicon.symbolFile);\n    byKind.set(21 /* CompletionItemKind.Reference */, Codicon.symbolReference);\n    byKind.set(22 /* CompletionItemKind.Customcolor */, Codicon.symbolCustomColor);\n    byKind.set(23 /* CompletionItemKind.Folder */, Codicon.symbolFolder);\n    byKind.set(24 /* CompletionItemKind.TypeParameter */, Codicon.symbolTypeParameter);\n    byKind.set(25 /* CompletionItemKind.User */, Codicon.account);\n    byKind.set(26 /* CompletionItemKind.Issue */, Codicon.issues);\n    /**\n     * @internal\n     */\n    function toIcon(kind) {\n        let codicon = byKind.get(kind);\n        if (!codicon) {\n            console.info('No codicon found for CompletionItemKind ' + kind);\n            codicon = Codicon.symbolProperty;\n        }\n        return codicon;\n    }\n    CompletionItemKinds.toIcon = toIcon;\n    const data = new Map();\n    data.set('method', 0 /* CompletionItemKind.Method */);\n    data.set('function', 1 /* CompletionItemKind.Function */);\n    data.set('constructor', 2 /* CompletionItemKind.Constructor */);\n    data.set('field', 3 /* CompletionItemKind.Field */);\n    data.set('variable', 4 /* CompletionItemKind.Variable */);\n    data.set('class', 5 /* CompletionItemKind.Class */);\n    data.set('struct', 6 /* CompletionItemKind.Struct */);\n    data.set('interface', 7 /* CompletionItemKind.Interface */);\n    data.set('module', 8 /* CompletionItemKind.Module */);\n    data.set('property', 9 /* CompletionItemKind.Property */);\n    data.set('event', 10 /* CompletionItemKind.Event */);\n    data.set('operator', 11 /* CompletionItemKind.Operator */);\n    data.set('unit', 12 /* CompletionItemKind.Unit */);\n    data.set('value', 13 /* CompletionItemKind.Value */);\n    data.set('constant', 14 /* CompletionItemKind.Constant */);\n    data.set('enum', 15 /* CompletionItemKind.Enum */);\n    data.set('enum-member', 16 /* CompletionItemKind.EnumMember */);\n    data.set('enumMember', 16 /* CompletionItemKind.EnumMember */);\n    data.set('keyword', 17 /* CompletionItemKind.Keyword */);\n    data.set('snippet', 27 /* CompletionItemKind.Snippet */);\n    data.set('text', 18 /* CompletionItemKind.Text */);\n    data.set('color', 19 /* CompletionItemKind.Color */);\n    data.set('file', 20 /* CompletionItemKind.File */);\n    data.set('reference', 21 /* CompletionItemKind.Reference */);\n    data.set('customcolor', 22 /* CompletionItemKind.Customcolor */);\n    data.set('folder', 23 /* CompletionItemKind.Folder */);\n    data.set('type-parameter', 24 /* CompletionItemKind.TypeParameter */);\n    data.set('typeParameter', 24 /* CompletionItemKind.TypeParameter */);\n    data.set('account', 25 /* CompletionItemKind.User */);\n    data.set('issue', 26 /* CompletionItemKind.Issue */);\n    /**\n     * @internal\n     */\n    function fromString(value, strict) {\n        let res = data.get(value);\n        if (typeof res === 'undefined' && !strict) {\n            res = 9 /* CompletionItemKind.Property */;\n        }\n        return res;\n    }\n    CompletionItemKinds.fromString = fromString;\n})(CompletionItemKinds || (CompletionItemKinds = {}));\n/**\n * How an {@link InlineCompletionsProvider inline completion provider} was triggered.\n */\nexport var InlineCompletionTriggerKind;\n(function (InlineCompletionTriggerKind) {\n    /**\n     * Completion was triggered automatically while editing.\n     * It is sufficient to return a single completion item in this case.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n    /**\n     * Completion was triggered explicitly by a user gesture.\n     * Return multiple completion items to enable cycling through them.\n     */\n    InlineCompletionTriggerKind[InlineCompletionTriggerKind[\"Explicit\"] = 1] = \"Explicit\";\n})(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));\nexport class SelectedSuggestionInfo {\n    constructor(range, text, completionKind, isSnippetText) {\n        this.range = range;\n        this.text = text;\n        this.completionKind = completionKind;\n        this.isSnippetText = isSnippetText;\n    }\n    equals(other) {\n        return Range.lift(this.range).equalsRange(other.range)\n            && this.text === other.text\n            && this.completionKind === other.completionKind\n            && this.isSnippetText === other.isSnippetText;\n    }\n}\n/**\n * @internal\n */\nexport var DocumentPasteTriggerKind;\n(function (DocumentPasteTriggerKind) {\n    DocumentPasteTriggerKind[DocumentPasteTriggerKind[\"Automatic\"] = 0] = \"Automatic\";\n    DocumentPasteTriggerKind[DocumentPasteTriggerKind[\"PasteAs\"] = 1] = \"PasteAs\";\n})(DocumentPasteTriggerKind || (DocumentPasteTriggerKind = {}));\nexport var SignatureHelpTriggerKind;\n(function (SignatureHelpTriggerKind) {\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"Invoke\"] = 1] = \"Invoke\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"TriggerCharacter\"] = 2] = \"TriggerCharacter\";\n    SignatureHelpTriggerKind[SignatureHelpTriggerKind[\"ContentChange\"] = 3] = \"ContentChange\";\n})(SignatureHelpTriggerKind || (SignatureHelpTriggerKind = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Text\"] = 0] = \"Text\";\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Read\"] = 1] = \"Read\";\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind[DocumentHighlightKind[\"Write\"] = 2] = \"Write\";\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * @internal\n */\nexport function isLocationLink(thing) {\n    return thing\n        && URI.isUri(thing.uri)\n        && Range.isIRange(thing.range)\n        && (Range.isIRange(thing.originSelectionRange) || Range.isIRange(thing.targetSelectionRange));\n}\n/**\n * @internal\n */\nexport const symbolKindNames = {\n    [17 /* SymbolKind.Array */]: localize('Array', \"array\"),\n    [16 /* SymbolKind.Boolean */]: localize('Boolean', \"boolean\"),\n    [4 /* SymbolKind.Class */]: localize('Class', \"class\"),\n    [13 /* SymbolKind.Constant */]: localize('Constant', \"constant\"),\n    [8 /* SymbolKind.Constructor */]: localize('Constructor', \"constructor\"),\n    [9 /* SymbolKind.Enum */]: localize('Enum', \"enumeration\"),\n    [21 /* SymbolKind.EnumMember */]: localize('EnumMember', \"enumeration member\"),\n    [23 /* SymbolKind.Event */]: localize('Event', \"event\"),\n    [7 /* SymbolKind.Field */]: localize('Field', \"field\"),\n    [0 /* SymbolKind.File */]: localize('File', \"file\"),\n    [11 /* SymbolKind.Function */]: localize('Function', \"function\"),\n    [10 /* SymbolKind.Interface */]: localize('Interface', \"interface\"),\n    [19 /* SymbolKind.Key */]: localize('Key', \"key\"),\n    [5 /* SymbolKind.Method */]: localize('Method', \"method\"),\n    [1 /* SymbolKind.Module */]: localize('Module', \"module\"),\n    [2 /* SymbolKind.Namespace */]: localize('Namespace', \"namespace\"),\n    [20 /* SymbolKind.Null */]: localize('Null', \"null\"),\n    [15 /* SymbolKind.Number */]: localize('Number', \"number\"),\n    [18 /* SymbolKind.Object */]: localize('Object', \"object\"),\n    [24 /* SymbolKind.Operator */]: localize('Operator', \"operator\"),\n    [3 /* SymbolKind.Package */]: localize('Package', \"package\"),\n    [6 /* SymbolKind.Property */]: localize('Property', \"property\"),\n    [14 /* SymbolKind.String */]: localize('String', \"string\"),\n    [22 /* SymbolKind.Struct */]: localize('Struct', \"struct\"),\n    [25 /* SymbolKind.TypeParameter */]: localize('TypeParameter', \"type parameter\"),\n    [12 /* SymbolKind.Variable */]: localize('Variable', \"variable\"),\n};\n/**\n * @internal\n */\nexport function getAriaLabelForSymbol(symbolName, kind) {\n    return localize('symbolAriaLabel', '{0} ({1})', symbolName, symbolKindNames[kind]);\n}\n/**\n * @internal\n */\nexport var SymbolKinds;\n(function (SymbolKinds) {\n    const byKind = new Map();\n    byKind.set(0 /* SymbolKind.File */, Codicon.symbolFile);\n    byKind.set(1 /* SymbolKind.Module */, Codicon.symbolModule);\n    byKind.set(2 /* SymbolKind.Namespace */, Codicon.symbolNamespace);\n    byKind.set(3 /* SymbolKind.Package */, Codicon.symbolPackage);\n    byKind.set(4 /* SymbolKind.Class */, Codicon.symbolClass);\n    byKind.set(5 /* SymbolKind.Method */, Codicon.symbolMethod);\n    byKind.set(6 /* SymbolKind.Property */, Codicon.symbolProperty);\n    byKind.set(7 /* SymbolKind.Field */, Codicon.symbolField);\n    byKind.set(8 /* SymbolKind.Constructor */, Codicon.symbolConstructor);\n    byKind.set(9 /* SymbolKind.Enum */, Codicon.symbolEnum);\n    byKind.set(10 /* SymbolKind.Interface */, Codicon.symbolInterface);\n    byKind.set(11 /* SymbolKind.Function */, Codicon.symbolFunction);\n    byKind.set(12 /* SymbolKind.Variable */, Codicon.symbolVariable);\n    byKind.set(13 /* SymbolKind.Constant */, Codicon.symbolConstant);\n    byKind.set(14 /* SymbolKind.String */, Codicon.symbolString);\n    byKind.set(15 /* SymbolKind.Number */, Codicon.symbolNumber);\n    byKind.set(16 /* SymbolKind.Boolean */, Codicon.symbolBoolean);\n    byKind.set(17 /* SymbolKind.Array */, Codicon.symbolArray);\n    byKind.set(18 /* SymbolKind.Object */, Codicon.symbolObject);\n    byKind.set(19 /* SymbolKind.Key */, Codicon.symbolKey);\n    byKind.set(20 /* SymbolKind.Null */, Codicon.symbolNull);\n    byKind.set(21 /* SymbolKind.EnumMember */, Codicon.symbolEnumMember);\n    byKind.set(22 /* SymbolKind.Struct */, Codicon.symbolStruct);\n    byKind.set(23 /* SymbolKind.Event */, Codicon.symbolEvent);\n    byKind.set(24 /* SymbolKind.Operator */, Codicon.symbolOperator);\n    byKind.set(25 /* SymbolKind.TypeParameter */, Codicon.symbolTypeParameter);\n    /**\n     * @internal\n     */\n    function toIcon(kind) {\n        let icon = byKind.get(kind);\n        if (!icon) {\n            console.info('No codicon found for SymbolKind ' + kind);\n            icon = Codicon.symbolProperty;\n        }\n        return icon;\n    }\n    SymbolKinds.toIcon = toIcon;\n})(SymbolKinds || (SymbolKinds = {}));\n/** @internal */\nexport class TextEdit {\n}\nexport class FoldingRangeKind {\n    /**\n     * Returns a {@link FoldingRangeKind} for the given value.\n     *\n     * @param value of the kind.\n     */\n    static fromValue(value) {\n        switch (value) {\n            case 'comment': return FoldingRangeKind.Comment;\n            case 'imports': return FoldingRangeKind.Imports;\n            case 'region': return FoldingRangeKind.Region;\n        }\n        return new FoldingRangeKind(value);\n    }\n    /**\n     * Creates a new {@link FoldingRangeKind}.\n     *\n     * @param value of the kind.\n     */\n    constructor(value) {\n        this.value = value;\n    }\n}\n/**\n * Kind for folding range representing a comment. The value of the kind is 'comment'.\n */\nFoldingRangeKind.Comment = new FoldingRangeKind('comment');\n/**\n * Kind for folding range representing a import. The value of the kind is 'imports'.\n */\nFoldingRangeKind.Imports = new FoldingRangeKind('imports');\n/**\n * Kind for folding range representing regions (for example marked by `#region`, `#endregion`).\n * The value of the kind is 'region'.\n */\nFoldingRangeKind.Region = new FoldingRangeKind('region');\nexport var NewSymbolNameTag;\n(function (NewSymbolNameTag) {\n    NewSymbolNameTag[NewSymbolNameTag[\"AIGenerated\"] = 1] = \"AIGenerated\";\n})(NewSymbolNameTag || (NewSymbolNameTag = {}));\nexport var NewSymbolNameTriggerKind;\n(function (NewSymbolNameTriggerKind) {\n    NewSymbolNameTriggerKind[NewSymbolNameTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n    NewSymbolNameTriggerKind[NewSymbolNameTriggerKind[\"Automatic\"] = 1] = \"Automatic\";\n})(NewSymbolNameTriggerKind || (NewSymbolNameTriggerKind = {}));\n/**\n * @internal\n */\nexport var Command;\n(function (Command) {\n    /**\n     * @internal\n     */\n    function is(obj) {\n        if (!obj || typeof obj !== 'object') {\n            return false;\n        }\n        return typeof obj.id === 'string' &&\n            typeof obj.title === 'string';\n    }\n    Command.is = is;\n})(Command || (Command = {}));\nexport var InlayHintKind;\n(function (InlayHintKind) {\n    InlayHintKind[InlayHintKind[\"Type\"] = 1] = \"Type\";\n    InlayHintKind[InlayHintKind[\"Parameter\"] = 2] = \"Parameter\";\n})(InlayHintKind || (InlayHintKind = {}));\n/**\n * @internal\n */\nexport class LazyTokenizationSupport {\n    constructor(createSupport) {\n        this.createSupport = createSupport;\n        this._tokenizationSupport = null;\n    }\n    dispose() {\n        if (this._tokenizationSupport) {\n            this._tokenizationSupport.then((support) => {\n                if (support) {\n                    support.dispose();\n                }\n            });\n        }\n    }\n    get tokenizationSupport() {\n        if (!this._tokenizationSupport) {\n            this._tokenizationSupport = this.createSupport();\n        }\n        return this._tokenizationSupport;\n    }\n}\n/**\n * @internal\n */\nexport const TokenizationRegistry = new TokenizationRegistryImpl();\nexport var InlineEditTriggerKind;\n(function (InlineEditTriggerKind) {\n    InlineEditTriggerKind[InlineEditTriggerKind[\"Invoke\"] = 0] = \"Invoke\";\n    InlineEditTriggerKind[InlineEditTriggerKind[\"Automatic\"] = 1] = \"Automatic\";\n})(InlineEditTriggerKind || (InlineEditTriggerKind = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { IndentAction } from './languageConfiguration.js';\nimport { IndentationContextProcessor, isLanguageDifferentFromLineStart, ProcessedIndentRulesSupport } from './supports/indentationLineProcessor.js';\n/**\n * Get nearest preceding line which doesn't match unIndentPattern or contains all whitespace.\n * Result:\n * -1: run into the boundary of embedded languages\n * 0: every line above are invalid\n * else: nearest preceding line of the same language\n */\nfunction getPrecedingValidLine(model, lineNumber, processedIndentRulesSupport) {\n    const languageId = model.tokenization.getLanguageIdAtPosition(lineNumber, 0);\n    if (lineNumber > 1) {\n        let lastLineNumber;\n        let resultLineNumber = -1;\n        for (lastLineNumber = lineNumber - 1; lastLineNumber >= 1; lastLineNumber--) {\n            if (model.tokenization.getLanguageIdAtPosition(lastLineNumber, 0) !== languageId) {\n                return resultLineNumber;\n            }\n            const text = model.getLineContent(lastLineNumber);\n            if (processedIndentRulesSupport.shouldIgnore(lastLineNumber) || /^\\s+$/.test(text) || text === '') {\n                resultLineNumber = lastLineNumber;\n                continue;\n            }\n            return lastLineNumber;\n        }\n    }\n    return -1;\n}\n/**\n * Get inherited indentation from above lines.\n * 1. Find the nearest preceding line which doesn't match unIndentedLinePattern.\n * 2. If this line matches indentNextLinePattern or increaseIndentPattern, it means that the indent level of `lineNumber` should be 1 greater than this line.\n * 3. If this line doesn't match any indent rules\n *   a. check whether the line above it matches indentNextLinePattern\n *   b. If not, the indent level of this line is the result\n *   c. If so, it means the indent of this line is *temporary*, go upward utill we find a line whose indent is not temporary (the same workflow a -> b -> c).\n * 4. Otherwise, we fail to get an inherited indent from aboves. Return null and we should not touch the indent of `lineNumber`\n *\n * This function only return the inherited indent based on above lines, it doesn't check whether current line should decrease or not.\n */\nexport function getInheritIndentForLine(autoIndent, model, lineNumber, honorIntentialIndent = true, languageConfigurationService) {\n    if (autoIndent < 4 /* EditorAutoIndentStrategy.Full */) {\n        return null;\n    }\n    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(model.tokenization.getLanguageId()).indentRulesSupport;\n    if (!indentRulesSupport) {\n        return null;\n    }\n    const processedIndentRulesSupport = new ProcessedIndentRulesSupport(model, indentRulesSupport, languageConfigurationService);\n    if (lineNumber <= 1) {\n        return {\n            indentation: '',\n            action: null\n        };\n    }\n    // Use no indent if this is the first non-blank line\n    for (let priorLineNumber = lineNumber - 1; priorLineNumber > 0; priorLineNumber--) {\n        if (model.getLineContent(priorLineNumber) !== '') {\n            break;\n        }\n        if (priorLineNumber === 1) {\n            return {\n                indentation: '',\n                action: null\n            };\n        }\n    }\n    const precedingUnIgnoredLine = getPrecedingValidLine(model, lineNumber, processedIndentRulesSupport);\n    if (precedingUnIgnoredLine < 0) {\n        return null;\n    }\n    else if (precedingUnIgnoredLine < 1) {\n        return {\n            indentation: '',\n            action: null\n        };\n    }\n    if (processedIndentRulesSupport.shouldIncrease(precedingUnIgnoredLine) || processedIndentRulesSupport.shouldIndentNextLine(precedingUnIgnoredLine)) {\n        const precedingUnIgnoredLineContent = model.getLineContent(precedingUnIgnoredLine);\n        return {\n            indentation: strings.getLeadingWhitespace(precedingUnIgnoredLineContent),\n            action: IndentAction.Indent,\n            line: precedingUnIgnoredLine\n        };\n    }\n    else if (processedIndentRulesSupport.shouldDecrease(precedingUnIgnoredLine)) {\n        const precedingUnIgnoredLineContent = model.getLineContent(precedingUnIgnoredLine);\n        return {\n            indentation: strings.getLeadingWhitespace(precedingUnIgnoredLineContent),\n            action: null,\n            line: precedingUnIgnoredLine\n        };\n    }\n    else {\n        // precedingUnIgnoredLine can not be ignored.\n        // it doesn't increase indent of following lines\n        // it doesn't increase just next line\n        // so current line is not affect by precedingUnIgnoredLine\n        // and then we should get a correct inheritted indentation from above lines\n        if (precedingUnIgnoredLine === 1) {\n            return {\n                indentation: strings.getLeadingWhitespace(model.getLineContent(precedingUnIgnoredLine)),\n                action: null,\n                line: precedingUnIgnoredLine\n            };\n        }\n        const previousLine = precedingUnIgnoredLine - 1;\n        const previousLineIndentMetadata = indentRulesSupport.getIndentMetadata(model.getLineContent(previousLine));\n        if (!(previousLineIndentMetadata & (1 /* IndentConsts.INCREASE_MASK */ | 2 /* IndentConsts.DECREASE_MASK */)) &&\n            (previousLineIndentMetadata & 4 /* IndentConsts.INDENT_NEXTLINE_MASK */)) {\n            let stopLine = 0;\n            for (let i = previousLine - 1; i > 0; i--) {\n                if (processedIndentRulesSupport.shouldIndentNextLine(i)) {\n                    continue;\n                }\n                stopLine = i;\n                break;\n            }\n            return {\n                indentation: strings.getLeadingWhitespace(model.getLineContent(stopLine + 1)),\n                action: null,\n                line: stopLine + 1\n            };\n        }\n        if (honorIntentialIndent) {\n            return {\n                indentation: strings.getLeadingWhitespace(model.getLineContent(precedingUnIgnoredLine)),\n                action: null,\n                line: precedingUnIgnoredLine\n            };\n        }\n        else {\n            // search from precedingUnIgnoredLine until we find one whose indent is not temporary\n            for (let i = precedingUnIgnoredLine; i > 0; i--) {\n                if (processedIndentRulesSupport.shouldIncrease(i)) {\n                    return {\n                        indentation: strings.getLeadingWhitespace(model.getLineContent(i)),\n                        action: IndentAction.Indent,\n                        line: i\n                    };\n                }\n                else if (processedIndentRulesSupport.shouldIndentNextLine(i)) {\n                    let stopLine = 0;\n                    for (let j = i - 1; j > 0; j--) {\n                        if (processedIndentRulesSupport.shouldIndentNextLine(i)) {\n                            continue;\n                        }\n                        stopLine = j;\n                        break;\n                    }\n                    return {\n                        indentation: strings.getLeadingWhitespace(model.getLineContent(stopLine + 1)),\n                        action: null,\n                        line: stopLine + 1\n                    };\n                }\n                else if (processedIndentRulesSupport.shouldDecrease(i)) {\n                    return {\n                        indentation: strings.getLeadingWhitespace(model.getLineContent(i)),\n                        action: null,\n                        line: i\n                    };\n                }\n            }\n            return {\n                indentation: strings.getLeadingWhitespace(model.getLineContent(1)),\n                action: null,\n                line: 1\n            };\n        }\n    }\n}\nexport function getGoodIndentForLine(autoIndent, virtualModel, languageId, lineNumber, indentConverter, languageConfigurationService) {\n    if (autoIndent < 4 /* EditorAutoIndentStrategy.Full */) {\n        return null;\n    }\n    const richEditSupport = languageConfigurationService.getLanguageConfiguration(languageId);\n    if (!richEditSupport) {\n        return null;\n    }\n    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(languageId).indentRulesSupport;\n    if (!indentRulesSupport) {\n        return null;\n    }\n    const processedIndentRulesSupport = new ProcessedIndentRulesSupport(virtualModel, indentRulesSupport, languageConfigurationService);\n    const indent = getInheritIndentForLine(autoIndent, virtualModel, lineNumber, undefined, languageConfigurationService);\n    if (indent) {\n        const inheritLine = indent.line;\n        if (inheritLine !== undefined) {\n            // Apply enter action as long as there are only whitespace lines between inherited line and this line.\n            let shouldApplyEnterRules = true;\n            for (let inBetweenLine = inheritLine; inBetweenLine < lineNumber - 1; inBetweenLine++) {\n                if (!/^\\s*$/.test(virtualModel.getLineContent(inBetweenLine))) {\n                    shouldApplyEnterRules = false;\n                    break;\n                }\n            }\n            if (shouldApplyEnterRules) {\n                const enterResult = richEditSupport.onEnter(autoIndent, '', virtualModel.getLineContent(inheritLine), '');\n                if (enterResult) {\n                    let indentation = strings.getLeadingWhitespace(virtualModel.getLineContent(inheritLine));\n                    if (enterResult.removeText) {\n                        indentation = indentation.substring(0, indentation.length - enterResult.removeText);\n                    }\n                    if ((enterResult.indentAction === IndentAction.Indent) ||\n                        (enterResult.indentAction === IndentAction.IndentOutdent)) {\n                        indentation = indentConverter.shiftIndent(indentation);\n                    }\n                    else if (enterResult.indentAction === IndentAction.Outdent) {\n                        indentation = indentConverter.unshiftIndent(indentation);\n                    }\n                    if (processedIndentRulesSupport.shouldDecrease(lineNumber)) {\n                        indentation = indentConverter.unshiftIndent(indentation);\n                    }\n                    if (enterResult.appendText) {\n                        indentation += enterResult.appendText;\n                    }\n                    return strings.getLeadingWhitespace(indentation);\n                }\n            }\n        }\n        if (processedIndentRulesSupport.shouldDecrease(lineNumber)) {\n            if (indent.action === IndentAction.Indent) {\n                return indent.indentation;\n            }\n            else {\n                return indentConverter.unshiftIndent(indent.indentation);\n            }\n        }\n        else {\n            if (indent.action === IndentAction.Indent) {\n                return indentConverter.shiftIndent(indent.indentation);\n            }\n            else {\n                return indent.indentation;\n            }\n        }\n    }\n    return null;\n}\nexport function getIndentForEnter(autoIndent, model, range, indentConverter, languageConfigurationService) {\n    if (autoIndent < 4 /* EditorAutoIndentStrategy.Full */) {\n        return null;\n    }\n    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);\n    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(languageId).indentRulesSupport;\n    if (!indentRulesSupport) {\n        return null;\n    }\n    model.tokenization.forceTokenization(range.startLineNumber);\n    const indentationContextProcessor = new IndentationContextProcessor(model, languageConfigurationService);\n    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);\n    const afterEnterProcessedTokens = processedContextTokens.afterRangeProcessedTokens;\n    const beforeEnterProcessedTokens = processedContextTokens.beforeRangeProcessedTokens;\n    const beforeEnterIndent = strings.getLeadingWhitespace(beforeEnterProcessedTokens.getLineContent());\n    const virtualModel = createVirtualModelWithModifiedTokensAtLine(model, range.startLineNumber, beforeEnterProcessedTokens);\n    const languageIsDifferentFromLineStart = isLanguageDifferentFromLineStart(model, range.getStartPosition());\n    const currentLine = model.getLineContent(range.startLineNumber);\n    const currentLineIndent = strings.getLeadingWhitespace(currentLine);\n    const afterEnterAction = getInheritIndentForLine(autoIndent, virtualModel, range.startLineNumber + 1, undefined, languageConfigurationService);\n    if (!afterEnterAction) {\n        const beforeEnter = languageIsDifferentFromLineStart ? currentLineIndent : beforeEnterIndent;\n        return {\n            beforeEnter: beforeEnter,\n            afterEnter: beforeEnter\n        };\n    }\n    let afterEnterIndent = languageIsDifferentFromLineStart ? currentLineIndent : afterEnterAction.indentation;\n    if (afterEnterAction.action === IndentAction.Indent) {\n        afterEnterIndent = indentConverter.shiftIndent(afterEnterIndent);\n    }\n    if (indentRulesSupport.shouldDecrease(afterEnterProcessedTokens.getLineContent())) {\n        afterEnterIndent = indentConverter.unshiftIndent(afterEnterIndent);\n    }\n    return {\n        beforeEnter: languageIsDifferentFromLineStart ? currentLineIndent : beforeEnterIndent,\n        afterEnter: afterEnterIndent\n    };\n}\n/**\n * We should always allow intentional indentation. It means, if users change the indentation of `lineNumber` and the content of\n * this line doesn't match decreaseIndentPattern, we should not adjust the indentation.\n */\nexport function getIndentActionForType(autoIndent, model, range, ch, indentConverter, languageConfigurationService) {\n    if (autoIndent < 4 /* EditorAutoIndentStrategy.Full */) {\n        return null;\n    }\n    const languageIsDifferentFromLineStart = isLanguageDifferentFromLineStart(model, range.getStartPosition());\n    if (languageIsDifferentFromLineStart) {\n        // this line has mixed languages and indentation rules will not work\n        return null;\n    }\n    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);\n    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(languageId).indentRulesSupport;\n    if (!indentRulesSupport) {\n        return null;\n    }\n    const indentationContextProcessor = new IndentationContextProcessor(model, languageConfigurationService);\n    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);\n    const beforeRangeText = processedContextTokens.beforeRangeProcessedTokens.getLineContent();\n    const afterRangeText = processedContextTokens.afterRangeProcessedTokens.getLineContent();\n    const textAroundRange = beforeRangeText + afterRangeText;\n    const textAroundRangeWithCharacter = beforeRangeText + ch + afterRangeText;\n    // If previous content already matches decreaseIndentPattern, it means indentation of this line should already be adjusted\n    // Users might change the indentation by purpose and we should honor that instead of readjusting.\n    if (!indentRulesSupport.shouldDecrease(textAroundRange) && indentRulesSupport.shouldDecrease(textAroundRangeWithCharacter)) {\n        // after typing `ch`, the content matches decreaseIndentPattern, we should adjust the indent to a good manner.\n        // 1. Get inherited indent action\n        const r = getInheritIndentForLine(autoIndent, model, range.startLineNumber, false, languageConfigurationService);\n        if (!r) {\n            return null;\n        }\n        let indentation = r.indentation;\n        if (r.action !== IndentAction.Indent) {\n            indentation = indentConverter.unshiftIndent(indentation);\n        }\n        return indentation;\n    }\n    return null;\n}\nexport function getIndentMetadata(model, lineNumber, languageConfigurationService) {\n    const indentRulesSupport = languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).indentRulesSupport;\n    if (!indentRulesSupport) {\n        return null;\n    }\n    if (lineNumber < 1 || lineNumber > model.getLineCount()) {\n        return null;\n    }\n    return indentRulesSupport.getIndentMetadata(model.getLineContent(lineNumber));\n}\nfunction createVirtualModelWithModifiedTokensAtLine(model, modifiedLineNumber, modifiedTokens) {\n    const virtualModel = {\n        tokenization: {\n            getLineTokens: (lineNumber) => {\n                if (lineNumber === modifiedLineNumber) {\n                    return modifiedTokens;\n                }\n                else {\n                    return model.tokenization.getLineTokens(lineNumber);\n                }\n            },\n            getLanguageId: () => {\n                return model.getLanguageId();\n            },\n            getLanguageIdAtPosition: (lineNumber, column) => {\n                return model.getLanguageIdAtPosition(lineNumber, column);\n            },\n        },\n        getLineContent: (lineNumber) => {\n            if (lineNumber === modifiedLineNumber) {\n                return modifiedTokens.getLineContent();\n            }\n            else {\n                return model.getLineContent(lineNumber);\n            }\n        }\n    };\n    return virtualModel;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Color, HSLA } from '../../../base/common/color.js';\nfunction _parseCaptureGroups(captureGroups) {\n    const values = [];\n    for (const captureGroup of captureGroups) {\n        const parsedNumber = Number(captureGroup);\n        if (parsedNumber || parsedNumber === 0 && captureGroup.replace(/\\s/g, '') !== '') {\n            values.push(parsedNumber);\n        }\n    }\n    return values;\n}\nfunction _toIColor(r, g, b, a) {\n    return {\n        red: r / 255,\n        blue: b / 255,\n        green: g / 255,\n        alpha: a\n    };\n}\nfunction _findRange(model, match) {\n    const index = match.index;\n    const length = match[0].length;\n    if (!index) {\n        return;\n    }\n    const startPosition = model.positionAt(index);\n    const range = {\n        startLineNumber: startPosition.lineNumber,\n        startColumn: startPosition.column,\n        endLineNumber: startPosition.lineNumber,\n        endColumn: startPosition.column + length\n    };\n    return range;\n}\nfunction _findHexColorInformation(range, hexValue) {\n    if (!range) {\n        return;\n    }\n    const parsedHexColor = Color.Format.CSS.parseHex(hexValue);\n    if (!parsedHexColor) {\n        return;\n    }\n    return {\n        range: range,\n        color: _toIColor(parsedHexColor.rgba.r, parsedHexColor.rgba.g, parsedHexColor.rgba.b, parsedHexColor.rgba.a)\n    };\n}\nfunction _findRGBColorInformation(range, matches, isAlpha) {\n    if (!range || matches.length !== 1) {\n        return;\n    }\n    const match = matches[0];\n    const captureGroups = match.values();\n    const parsedRegex = _parseCaptureGroups(captureGroups);\n    return {\n        range: range,\n        color: _toIColor(parsedRegex[0], parsedRegex[1], parsedRegex[2], isAlpha ? parsedRegex[3] : 1)\n    };\n}\nfunction _findHSLColorInformation(range, matches, isAlpha) {\n    if (!range || matches.length !== 1) {\n        return;\n    }\n    const match = matches[0];\n    const captureGroups = match.values();\n    const parsedRegex = _parseCaptureGroups(captureGroups);\n    const colorEquivalent = new Color(new HSLA(parsedRegex[0], parsedRegex[1] / 100, parsedRegex[2] / 100, isAlpha ? parsedRegex[3] : 1));\n    return {\n        range: range,\n        color: _toIColor(colorEquivalent.rgba.r, colorEquivalent.rgba.g, colorEquivalent.rgba.b, colorEquivalent.rgba.a)\n    };\n}\nfunction _findMatches(model, regex) {\n    if (typeof model === 'string') {\n        return [...model.matchAll(regex)];\n    }\n    else {\n        return model.findMatches(regex);\n    }\n}\nfunction computeColors(model) {\n    const result = [];\n    // Early validation for RGB and HSL\n    const initialValidationRegex = /\\b(rgb|rgba|hsl|hsla)(\\([0-9\\s,.\\%]*\\))|(#)([A-Fa-f0-9]{3})\\b|(#)([A-Fa-f0-9]{4})\\b|(#)([A-Fa-f0-9]{6})\\b|(#)([A-Fa-f0-9]{8})\\b/gm;\n    const initialValidationMatches = _findMatches(model, initialValidationRegex);\n    // Potential colors have been found, validate the parameters\n    if (initialValidationMatches.length > 0) {\n        for (const initialMatch of initialValidationMatches) {\n            const initialCaptureGroups = initialMatch.filter(captureGroup => captureGroup !== undefined);\n            const colorScheme = initialCaptureGroups[1];\n            const colorParameters = initialCaptureGroups[2];\n            if (!colorParameters) {\n                continue;\n            }\n            let colorInformation;\n            if (colorScheme === 'rgb') {\n                const regexParameters = /^\\(\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*\\)$/gm;\n                colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);\n            }\n            else if (colorScheme === 'rgba') {\n                const regexParameters = /^\\(\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\\s*,\\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\\s*\\)$/gm;\n                colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);\n            }\n            else if (colorScheme === 'hsl') {\n                const regexParameters = /^\\(\\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*\\)$/gm;\n                colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);\n            }\n            else if (colorScheme === 'hsla') {\n                const regexParameters = /^\\(\\s*(36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(100|\\d{1,2}[.]\\d*|\\d{1,2})%\\s*,\\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\\s*\\)$/gm;\n                colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);\n            }\n            else if (colorScheme === '#') {\n                colorInformation = _findHexColorInformation(_findRange(model, initialMatch), colorScheme + colorParameters);\n            }\n            if (colorInformation) {\n                result.push(colorInformation);\n            }\n        }\n    }\n    return result;\n}\n/**\n * Returns an array of all default document colors in the provided document\n */\nexport function computeDefaultDocumentColors(model) {\n    if (!model || typeof model.getValue !== 'function' || typeof model.positionAt !== 'function') {\n        // Unknown caller!\n        return [];\n    }\n    return computeColors(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { IndentAction } from './languageConfiguration.js';\nimport { getIndentationAtPosition } from './languageConfigurationRegistry.js';\nimport { IndentationContextProcessor } from './supports/indentationLineProcessor.js';\nexport function getEnterAction(autoIndent, model, range, languageConfigurationService) {\n    model.tokenization.forceTokenization(range.startLineNumber);\n    const languageId = model.getLanguageIdAtPosition(range.startLineNumber, range.startColumn);\n    const richEditSupport = languageConfigurationService.getLanguageConfiguration(languageId);\n    if (!richEditSupport) {\n        return null;\n    }\n    const indentationContextProcessor = new IndentationContextProcessor(model, languageConfigurationService);\n    const processedContextTokens = indentationContextProcessor.getProcessedTokenContextAroundRange(range);\n    const previousLineText = processedContextTokens.previousLineProcessedTokens.getLineContent();\n    const beforeEnterText = processedContextTokens.beforeRangeProcessedTokens.getLineContent();\n    const afterEnterText = processedContextTokens.afterRangeProcessedTokens.getLineContent();\n    const enterResult = richEditSupport.onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText);\n    if (!enterResult) {\n        return null;\n    }\n    const indentAction = enterResult.indentAction;\n    let appendText = enterResult.appendText;\n    const removeText = enterResult.removeText || 0;\n    // Here we add `\\t` to appendText first because enterAction is leveraging appendText and removeText to change indentation.\n    if (!appendText) {\n        if ((indentAction === IndentAction.Indent) ||\n            (indentAction === IndentAction.IndentOutdent)) {\n            appendText = '\\t';\n        }\n        else {\n            appendText = '';\n        }\n    }\n    else if (indentAction === IndentAction.Indent) {\n        appendText = '\\t' + appendText;\n    }\n    let indentation = getIndentationAtPosition(model, range.startLineNumber, range.startColumn);\n    if (removeText) {\n        indentation = indentation.substring(0, indentation.length - removeText);\n    }\n    return {\n        indentAction: indentAction,\n        appendText: appendText,\n        removeText: removeText,\n        indentation: indentation\n    };\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { createDecorator } from '../../../platform/instantiation/common/instantiation.js';\nexport const ILanguageService = createDecorator('languageService');\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n/**\n * Describes what to do with the indentation when pressing Enter.\n */\nexport var IndentAction;\n(function (IndentAction) {\n    /**\n     * Insert new line and copy the previous line's indentation.\n     */\n    IndentAction[IndentAction[\"None\"] = 0] = \"None\";\n    /**\n     * Insert new line and indent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Indent\"] = 1] = \"Indent\";\n    /**\n     * Insert two new lines:\n     *  - the first one indented which will hold the cursor\n     *  - the second one at the same indentation level\n     */\n    IndentAction[IndentAction[\"IndentOutdent\"] = 2] = \"IndentOutdent\";\n    /**\n     * Insert new line and outdent once (relative to the previous line's indentation).\n     */\n    IndentAction[IndentAction[\"Outdent\"] = 3] = \"Outdent\";\n})(IndentAction || (IndentAction = {}));\n/**\n * @internal\n */\nexport class StandardAutoClosingPairConditional {\n    constructor(source) {\n        this._neutralCharacter = null;\n        this._neutralCharacterSearched = false;\n        this.open = source.open;\n        this.close = source.close;\n        // initially allowed in all tokens\n        this._inString = true;\n        this._inComment = true;\n        this._inRegEx = true;\n        if (Array.isArray(source.notIn)) {\n            for (let i = 0, len = source.notIn.length; i < len; i++) {\n                const notIn = source.notIn[i];\n                switch (notIn) {\n                    case 'string':\n                        this._inString = false;\n                        break;\n                    case 'comment':\n                        this._inComment = false;\n                        break;\n                    case 'regex':\n                        this._inRegEx = false;\n                        break;\n                }\n            }\n        }\n    }\n    isOK(standardToken) {\n        switch (standardToken) {\n            case 0 /* StandardTokenType.Other */:\n                return true;\n            case 1 /* StandardTokenType.Comment */:\n                return this._inComment;\n            case 2 /* StandardTokenType.String */:\n                return this._inString;\n            case 3 /* StandardTokenType.RegEx */:\n                return this._inRegEx;\n        }\n    }\n    shouldAutoClose(context, column) {\n        // Always complete on empty line\n        if (context.getTokenCount() === 0) {\n            return true;\n        }\n        const tokenIndex = context.findTokenIndexAtOffset(column - 2);\n        const standardTokenType = context.getStandardTokenType(tokenIndex);\n        return this.isOK(standardTokenType);\n    }\n    _findNeutralCharacterInRange(fromCharCode, toCharCode) {\n        for (let charCode = fromCharCode; charCode <= toCharCode; charCode++) {\n            const character = String.fromCharCode(charCode);\n            if (!this.open.includes(character) && !this.close.includes(character)) {\n                return character;\n            }\n        }\n        return null;\n    }\n    /**\n     * Find a character in the range [0-9a-zA-Z] that does not appear in the open or close\n     */\n    findNeutralCharacter() {\n        if (!this._neutralCharacterSearched) {\n            this._neutralCharacterSearched = true;\n            if (!this._neutralCharacter) {\n                this._neutralCharacter = this._findNeutralCharacterInRange(48 /* CharCode.Digit0 */, 57 /* CharCode.Digit9 */);\n            }\n            if (!this._neutralCharacter) {\n                this._neutralCharacter = this._findNeutralCharacterInRange(97 /* CharCode.a */, 122 /* CharCode.z */);\n            }\n            if (!this._neutralCharacter) {\n                this._neutralCharacter = this._findNeutralCharacterInRange(65 /* CharCode.A */, 90 /* CharCode.Z */);\n            }\n        }\n        return this._neutralCharacter;\n    }\n}\n/**\n * @internal\n */\nexport class AutoClosingPairs {\n    constructor(autoClosingPairs) {\n        this.autoClosingPairsOpenByStart = new Map();\n        this.autoClosingPairsOpenByEnd = new Map();\n        this.autoClosingPairsCloseByStart = new Map();\n        this.autoClosingPairsCloseByEnd = new Map();\n        this.autoClosingPairsCloseSingleChar = new Map();\n        for (const pair of autoClosingPairs) {\n            appendEntry(this.autoClosingPairsOpenByStart, pair.open.charAt(0), pair);\n            appendEntry(this.autoClosingPairsOpenByEnd, pair.open.charAt(pair.open.length - 1), pair);\n            appendEntry(this.autoClosingPairsCloseByStart, pair.close.charAt(0), pair);\n            appendEntry(this.autoClosingPairsCloseByEnd, pair.close.charAt(pair.close.length - 1), pair);\n            if (pair.close.length === 1 && pair.open.length === 1) {\n                appendEntry(this.autoClosingPairsCloseSingleChar, pair.close, pair);\n            }\n        }\n    }\n}\nfunction appendEntry(target, key, value) {\n    if (target.has(key)) {\n        target.get(key).push(value);\n    }\n    else {\n        target.set(key, [value]);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { StandardAutoClosingPairConditional } from '../languageConfiguration.js';\nexport class CharacterPairSupport {\n    constructor(config) {\n        if (config.autoClosingPairs) {\n            this._autoClosingPairs = config.autoClosingPairs.map(el => new StandardAutoClosingPairConditional(el));\n        }\n        else if (config.brackets) {\n            this._autoClosingPairs = config.brackets.map(b => new StandardAutoClosingPairConditional({ open: b[0], close: b[1] }));\n        }\n        else {\n            this._autoClosingPairs = [];\n        }\n        if (config.__electricCharacterSupport && config.__electricCharacterSupport.docComment) {\n            const docComment = config.__electricCharacterSupport.docComment;\n            // IDocComment is legacy, only partially supported\n            this._autoClosingPairs.push(new StandardAutoClosingPairConditional({ open: docComment.open, close: docComment.close || '' }));\n        }\n        this._autoCloseBeforeForQuotes = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES;\n        this._autoCloseBeforeForBrackets = typeof config.autoCloseBefore === 'string' ? config.autoCloseBefore : CharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS;\n        this._surroundingPairs = config.surroundingPairs || this._autoClosingPairs;\n    }\n    getAutoClosingPairs() {\n        return this._autoClosingPairs;\n    }\n    getAutoCloseBeforeSet(forQuotes) {\n        return (forQuotes ? this._autoCloseBeforeForQuotes : this._autoCloseBeforeForBrackets);\n    }\n    getSurroundingPairs() {\n        return this._surroundingPairs;\n    }\n}\nCharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES = ';:.,=}])> \\n\\t';\nCharacterPairSupport.DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS = '\\'\"`;:.,=}])> \\n\\t';\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { distinct } from '../../../../base/common/arrays.js';\nimport { ignoreBracketsInToken } from '../supports.js';\nimport { BracketsUtils } from './richEditBrackets.js';\nexport class BracketElectricCharacterSupport {\n    constructor(richEditBrackets) {\n        this._richEditBrackets = richEditBrackets;\n    }\n    getElectricCharacters() {\n        const result = [];\n        if (this._richEditBrackets) {\n            for (const bracket of this._richEditBrackets.brackets) {\n                for (const close of bracket.close) {\n                    const lastChar = close.charAt(close.length - 1);\n                    result.push(lastChar);\n                }\n            }\n        }\n        return distinct(result);\n    }\n    onElectricCharacter(character, context, column) {\n        if (!this._richEditBrackets || this._richEditBrackets.brackets.length === 0) {\n            return null;\n        }\n        const tokenIndex = context.findTokenIndexAtOffset(column - 1);\n        if (ignoreBracketsInToken(context.getStandardTokenType(tokenIndex))) {\n            return null;\n        }\n        const reversedBracketRegex = this._richEditBrackets.reversedRegex;\n        const text = context.getLineContent().substring(0, column - 1) + character;\n        const r = BracketsUtils.findPrevBracketInRange(reversedBracketRegex, 1, text, 0, text.length);\n        if (!r) {\n            return null;\n        }\n        const bracketText = text.substring(r.startColumn - 1, r.endColumn - 1).toLowerCase();\n        const isOpen = this._richEditBrackets.textIsOpenBracket[bracketText];\n        if (isOpen) {\n            return null;\n        }\n        const textBeforeBracket = context.getActualLineContentBefore(r.startColumn - 1);\n        if (!/^\\s*$/.test(textBeforeBracket)) {\n            // There is other text on the line before the bracket\n            return null;\n        }\n        return {\n            matchOpenBracket: bracketText\n        };\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nfunction resetGlobalRegex(reg) {\n    if (reg.global) {\n        reg.lastIndex = 0;\n    }\n    return true;\n}\nexport class IndentRulesSupport {\n    constructor(indentationRules) {\n        this._indentationRules = indentationRules;\n    }\n    shouldIncrease(text) {\n        if (this._indentationRules) {\n            if (this._indentationRules.increaseIndentPattern && resetGlobalRegex(this._indentationRules.increaseIndentPattern) && this._indentationRules.increaseIndentPattern.test(text)) {\n                return true;\n            }\n            // if (this._indentationRules.indentNextLinePattern && this._indentationRules.indentNextLinePattern.test(text)) {\n            // \treturn true;\n            // }\n        }\n        return false;\n    }\n    shouldDecrease(text) {\n        if (this._indentationRules && this._indentationRules.decreaseIndentPattern && resetGlobalRegex(this._indentationRules.decreaseIndentPattern) && this._indentationRules.decreaseIndentPattern.test(text)) {\n            return true;\n        }\n        return false;\n    }\n    shouldIndentNextLine(text) {\n        if (this._indentationRules && this._indentationRules.indentNextLinePattern && resetGlobalRegex(this._indentationRules.indentNextLinePattern) && this._indentationRules.indentNextLinePattern.test(text)) {\n            return true;\n        }\n        return false;\n    }\n    shouldIgnore(text) {\n        // the text matches `unIndentedLinePattern`\n        if (this._indentationRules && this._indentationRules.unIndentedLinePattern && resetGlobalRegex(this._indentationRules.unIndentedLinePattern) && this._indentationRules.unIndentedLinePattern.test(text)) {\n            return true;\n        }\n        return false;\n    }\n    getIndentMetadata(text) {\n        let ret = 0;\n        if (this.shouldIncrease(text)) {\n            ret += 1 /* IndentConsts.INCREASE_MASK */;\n        }\n        if (this.shouldDecrease(text)) {\n            ret += 2 /* IndentConsts.DECREASE_MASK */;\n        }\n        if (this.shouldIndentNextLine(text)) {\n            ret += 4 /* IndentConsts.INDENT_NEXTLINE_MASK */;\n        }\n        if (this.shouldIgnore(text)) {\n            ret += 8 /* IndentConsts.UNINDENT_MASK */;\n        }\n        return ret;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { onUnexpectedError } from '../../../../base/common/errors.js';\nimport * as strings from '../../../../base/common/strings.js';\nimport { IndentAction } from '../languageConfiguration.js';\nexport class OnEnterSupport {\n    constructor(opts) {\n        opts = opts || {};\n        opts.brackets = opts.brackets || [\n            ['(', ')'],\n            ['{', '}'],\n            ['[', ']']\n        ];\n        this._brackets = [];\n        opts.brackets.forEach((bracket) => {\n            const openRegExp = OnEnterSupport._createOpenBracketRegExp(bracket[0]);\n            const closeRegExp = OnEnterSupport._createCloseBracketRegExp(bracket[1]);\n            if (openRegExp && closeRegExp) {\n                this._brackets.push({\n                    open: bracket[0],\n                    openRegExp: openRegExp,\n                    close: bracket[1],\n                    closeRegExp: closeRegExp,\n                });\n            }\n        });\n        this._regExpRules = opts.onEnterRules || [];\n    }\n    onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText) {\n        // (1): `regExpRules`\n        if (autoIndent >= 3 /* EditorAutoIndentStrategy.Advanced */) {\n            for (let i = 0, len = this._regExpRules.length; i < len; i++) {\n                const rule = this._regExpRules[i];\n                const regResult = [{\n                        reg: rule.beforeText,\n                        text: beforeEnterText\n                    }, {\n                        reg: rule.afterText,\n                        text: afterEnterText\n                    }, {\n                        reg: rule.previousLineText,\n                        text: previousLineText\n                    }].every((obj) => {\n                    if (!obj.reg) {\n                        return true;\n                    }\n                    obj.reg.lastIndex = 0; // To disable the effect of the \"g\" flag.\n                    return obj.reg.test(obj.text);\n                });\n                if (regResult) {\n                    return rule.action;\n                }\n            }\n        }\n        // (2): Special indent-outdent\n        if (autoIndent >= 2 /* EditorAutoIndentStrategy.Brackets */) {\n            if (beforeEnterText.length > 0 && afterEnterText.length > 0) {\n                for (let i = 0, len = this._brackets.length; i < len; i++) {\n                    const bracket = this._brackets[i];\n                    if (bracket.openRegExp.test(beforeEnterText) && bracket.closeRegExp.test(afterEnterText)) {\n                        return { indentAction: IndentAction.IndentOutdent };\n                    }\n                }\n            }\n        }\n        // (4): Open bracket based logic\n        if (autoIndent >= 2 /* EditorAutoIndentStrategy.Brackets */) {\n            if (beforeEnterText.length > 0) {\n                for (let i = 0, len = this._brackets.length; i < len; i++) {\n                    const bracket = this._brackets[i];\n                    if (bracket.openRegExp.test(beforeEnterText)) {\n                        return { indentAction: IndentAction.Indent };\n                    }\n                }\n            }\n        }\n        return null;\n    }\n    static _createOpenBracketRegExp(bracket) {\n        let str = strings.escapeRegExpCharacters(bracket);\n        if (!/\\B/.test(str.charAt(0))) {\n            str = '\\\\b' + str;\n        }\n        str += '\\\\s*$';\n        return OnEnterSupport._safeRegExp(str);\n    }\n    static _createCloseBracketRegExp(bracket) {\n        let str = strings.escapeRegExpCharacters(bracket);\n        if (!/\\B/.test(str.charAt(str.length - 1))) {\n            str = str + '\\\\b';\n        }\n        str = '^\\\\s*' + str;\n        return OnEnterSupport._safeRegExp(str);\n    }\n    static _safeRegExp(def) {\n        try {\n            return new RegExp(def);\n        }\n        catch (err) {\n            onUnexpectedError(err);\n            return null;\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CachedFunction } from '../../../../base/common/cache.js';\nimport { createBracketOrRegExp } from './richEditBrackets.js';\n/**\n * Captures all bracket related configurations for a single language.\n * Immutable.\n*/\nexport class LanguageBracketsConfiguration {\n    constructor(languageId, config) {\n        this.languageId = languageId;\n        const bracketPairs = config.brackets ? filterValidBrackets(config.brackets) : [];\n        const openingBracketInfos = new CachedFunction((bracket) => {\n            const closing = new Set();\n            return {\n                info: new OpeningBracketKind(this, bracket, closing),\n                closing,\n            };\n        });\n        const closingBracketInfos = new CachedFunction((bracket) => {\n            const opening = new Set();\n            const openingColorized = new Set();\n            return {\n                info: new ClosingBracketKind(this, bracket, opening, openingColorized),\n                opening,\n                openingColorized,\n            };\n        });\n        for (const [open, close] of bracketPairs) {\n            const opening = openingBracketInfos.get(open);\n            const closing = closingBracketInfos.get(close);\n            opening.closing.add(closing.info);\n            closing.opening.add(opening.info);\n        }\n        // Treat colorized brackets as brackets, and mark them as colorized.\n        const colorizedBracketPairs = config.colorizedBracketPairs\n            ? filterValidBrackets(config.colorizedBracketPairs)\n            // If not configured: Take all brackets except `<` ... `>`\n            // Many languages set < ... > as bracket pair, even though they also use it as comparison operator.\n            // This leads to problems when colorizing this bracket, so we exclude it if not explicitly configured otherwise.\n            // https://github.com/microsoft/vscode/issues/132476\n            : bracketPairs.filter((p) => !(p[0] === '<' && p[1] === '>'));\n        for (const [open, close] of colorizedBracketPairs) {\n            const opening = openingBracketInfos.get(open);\n            const closing = closingBracketInfos.get(close);\n            opening.closing.add(closing.info);\n            closing.openingColorized.add(opening.info);\n            closing.opening.add(opening.info);\n        }\n        this._openingBrackets = new Map([...openingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));\n        this._closingBrackets = new Map([...closingBracketInfos.cachedValues].map(([k, v]) => [k, v.info]));\n    }\n    /**\n     * No two brackets have the same bracket text.\n    */\n    get openingBrackets() {\n        return [...this._openingBrackets.values()];\n    }\n    /**\n     * No two brackets have the same bracket text.\n    */\n    get closingBrackets() {\n        return [...this._closingBrackets.values()];\n    }\n    getOpeningBracketInfo(bracketText) {\n        return this._openingBrackets.get(bracketText);\n    }\n    getClosingBracketInfo(bracketText) {\n        return this._closingBrackets.get(bracketText);\n    }\n    getBracketInfo(bracketText) {\n        return this.getOpeningBracketInfo(bracketText) || this.getClosingBracketInfo(bracketText);\n    }\n    getBracketRegExp(options) {\n        const brackets = Array.from([...this._openingBrackets.keys(), ...this._closingBrackets.keys()]);\n        return createBracketOrRegExp(brackets, options);\n    }\n}\nfunction filterValidBrackets(bracketPairs) {\n    return bracketPairs.filter(([open, close]) => open !== '' && close !== '');\n}\nexport class BracketKindBase {\n    constructor(config, bracketText) {\n        this.config = config;\n        this.bracketText = bracketText;\n    }\n    get languageId() {\n        return this.config.languageId;\n    }\n}\nexport class OpeningBracketKind extends BracketKindBase {\n    constructor(config, bracketText, openedBrackets) {\n        super(config, bracketText);\n        this.openedBrackets = openedBrackets;\n        this.isOpeningBracket = true;\n    }\n}\nexport class ClosingBracketKind extends BracketKindBase {\n    constructor(config, bracketText, \n    /**\n     * Non empty array of all opening brackets this bracket closes.\n    */\n    openingBrackets, openingColorizedBrackets) {\n        super(config, bracketText);\n        this.openingBrackets = openingBrackets;\n        this.openingColorizedBrackets = openingColorizedBrackets;\n        this.isOpeningBracket = false;\n    }\n    /**\n     * Checks if this bracket closes the given other bracket.\n     * If the bracket infos come from different configurations, this method will return false.\n    */\n    closes(other) {\n        if (other['config'] !== this.config) {\n            return false;\n        }\n        return this.openingBrackets.has(other);\n    }\n    closesColorized(other) {\n        if (other['config'] !== this.config) {\n            return false;\n        }\n        return this.openingColorizedBrackets.has(other);\n    }\n    getOpeningBrackets() {\n        return [...this.openingBrackets];\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    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;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport { Emitter } from '../../../base/common/event.js';\nimport { Disposable, toDisposable } from '../../../base/common/lifecycle.js';\nimport * as strings from '../../../base/common/strings.js';\nimport { DEFAULT_WORD_REGEXP, ensureValidWordDefinition } from '../core/wordHelper.js';\nimport { AutoClosingPairs } from './languageConfiguration.js';\nimport { CharacterPairSupport } from './supports/characterPair.js';\nimport { BracketElectricCharacterSupport } from './supports/electricCharacter.js';\nimport { IndentRulesSupport } from './supports/indentRules.js';\nimport { OnEnterSupport } from './supports/onEnter.js';\nimport { RichEditBrackets } from './supports/richEditBrackets.js';\nimport { createDecorator } from '../../../platform/instantiation/common/instantiation.js';\nimport { IConfigurationService } from '../../../platform/configuration/common/configuration.js';\nimport { ILanguageService } from './language.js';\nimport { registerSingleton } from '../../../platform/instantiation/common/extensions.js';\nimport { PLAINTEXT_LANGUAGE_ID } from './modesRegistry.js';\nimport { LanguageBracketsConfiguration } from './supports/languageBracketsConfiguration.js';\nexport class LanguageConfigurationServiceChangeEvent {\n    constructor(languageId) {\n        this.languageId = languageId;\n    }\n    affects(languageId) {\n        return !this.languageId ? true : this.languageId === languageId;\n    }\n}\nexport const ILanguageConfigurationService = createDecorator('languageConfigurationService');\nlet LanguageConfigurationService = class LanguageConfigurationService extends Disposable {\n    constructor(configurationService, languageService) {\n        super();\n        this.configurationService = configurationService;\n        this.languageService = languageService;\n        this._registry = this._register(new LanguageConfigurationRegistry());\n        this.onDidChangeEmitter = this._register(new Emitter());\n        this.onDidChange = this.onDidChangeEmitter.event;\n        this.configurations = new Map();\n        const languageConfigKeys = new Set(Object.values(customizedLanguageConfigKeys));\n        this._register(this.configurationService.onDidChangeConfiguration((e) => {\n            const globalConfigChanged = e.change.keys.some((k) => languageConfigKeys.has(k));\n            const localConfigChanged = e.change.overrides\n                .filter(([overrideLangName, keys]) => keys.some((k) => languageConfigKeys.has(k)))\n                .map(([overrideLangName]) => overrideLangName);\n            if (globalConfigChanged) {\n                this.configurations.clear();\n                this.onDidChangeEmitter.fire(new LanguageConfigurationServiceChangeEvent(undefined));\n            }\n            else {\n                for (const languageId of localConfigChanged) {\n                    if (this.languageService.isRegisteredLanguageId(languageId)) {\n                        this.configurations.delete(languageId);\n                        this.onDidChangeEmitter.fire(new LanguageConfigurationServiceChangeEvent(languageId));\n                    }\n                }\n            }\n        }));\n        this._register(this._registry.onDidChange((e) => {\n            this.configurations.delete(e.languageId);\n            this.onDidChangeEmitter.fire(new LanguageConfigurationServiceChangeEvent(e.languageId));\n        }));\n    }\n    register(languageId, configuration, priority) {\n        return this._registry.register(languageId, configuration, priority);\n    }\n    getLanguageConfiguration(languageId) {\n        let result = this.configurations.get(languageId);\n        if (!result) {\n            result = computeConfig(languageId, this._registry, this.configurationService, this.languageService);\n            this.configurations.set(languageId, result);\n        }\n        return result;\n    }\n};\nLanguageConfigurationService = __decorate([\n    __param(0, IConfigurationService),\n    __param(1, ILanguageService)\n], LanguageConfigurationService);\nexport { LanguageConfigurationService };\nfunction computeConfig(languageId, registry, configurationService, languageService) {\n    let languageConfig = registry.getLanguageConfiguration(languageId);\n    if (!languageConfig) {\n        if (!languageService.isRegisteredLanguageId(languageId)) {\n            // this happens for the null language, which can be returned by monarch.\n            // Instead of throwing an error, we just return a default config.\n            return new ResolvedLanguageConfiguration(languageId, {});\n        }\n        languageConfig = new ResolvedLanguageConfiguration(languageId, {});\n    }\n    const customizedConfig = getCustomizedLanguageConfig(languageConfig.languageId, configurationService);\n    const data = combineLanguageConfigurations([languageConfig.underlyingConfig, customizedConfig]);\n    const config = new ResolvedLanguageConfiguration(languageConfig.languageId, data);\n    return config;\n}\nconst customizedLanguageConfigKeys = {\n    brackets: 'editor.language.brackets',\n    colorizedBracketPairs: 'editor.language.colorizedBracketPairs'\n};\nfunction getCustomizedLanguageConfig(languageId, configurationService) {\n    const brackets = configurationService.getValue(customizedLanguageConfigKeys.brackets, {\n        overrideIdentifier: languageId,\n    });\n    const colorizedBracketPairs = configurationService.getValue(customizedLanguageConfigKeys.colorizedBracketPairs, {\n        overrideIdentifier: languageId,\n    });\n    return {\n        brackets: validateBracketPairs(brackets),\n        colorizedBracketPairs: validateBracketPairs(colorizedBracketPairs),\n    };\n}\nfunction validateBracketPairs(data) {\n    if (!Array.isArray(data)) {\n        return undefined;\n    }\n    return data.map(pair => {\n        if (!Array.isArray(pair) || pair.length !== 2) {\n            return undefined;\n        }\n        return [pair[0], pair[1]];\n    }).filter((p) => !!p);\n}\nexport function getIndentationAtPosition(model, lineNumber, column) {\n    const lineText = model.getLineContent(lineNumber);\n    let indentation = strings.getLeadingWhitespace(lineText);\n    if (indentation.length > column - 1) {\n        indentation = indentation.substring(0, column - 1);\n    }\n    return indentation;\n}\nclass ComposedLanguageConfiguration {\n    constructor(languageId) {\n        this.languageId = languageId;\n        this._resolved = null;\n        this._entries = [];\n        this._order = 0;\n        this._resolved = null;\n    }\n    register(configuration, priority) {\n        const entry = new LanguageConfigurationContribution(configuration, priority, ++this._order);\n        this._entries.push(entry);\n        this._resolved = null;\n        return toDisposable(() => {\n            for (let i = 0; i < this._entries.length; i++) {\n                if (this._entries[i] === entry) {\n                    this._entries.splice(i, 1);\n                    this._resolved = null;\n                    break;\n                }\n            }\n        });\n    }\n    getResolvedConfiguration() {\n        if (!this._resolved) {\n            const config = this._resolve();\n            if (config) {\n                this._resolved = new ResolvedLanguageConfiguration(this.languageId, config);\n            }\n        }\n        return this._resolved;\n    }\n    _resolve() {\n        if (this._entries.length === 0) {\n            return null;\n        }\n        this._entries.sort(LanguageConfigurationContribution.cmp);\n        return combineLanguageConfigurations(this._entries.map(e => e.configuration));\n    }\n}\nfunction combineLanguageConfigurations(configs) {\n    let result = {\n        comments: undefined,\n        brackets: undefined,\n        wordPattern: undefined,\n        indentationRules: undefined,\n        onEnterRules: undefined,\n        autoClosingPairs: undefined,\n        surroundingPairs: undefined,\n        autoCloseBefore: undefined,\n        folding: undefined,\n        colorizedBracketPairs: undefined,\n        __electricCharacterSupport: undefined,\n    };\n    for (const entry of configs) {\n        result = {\n            comments: entry.comments || result.comments,\n            brackets: entry.brackets || result.brackets,\n            wordPattern: entry.wordPattern || result.wordPattern,\n            indentationRules: entry.indentationRules || result.indentationRules,\n            onEnterRules: entry.onEnterRules || result.onEnterRules,\n            autoClosingPairs: entry.autoClosingPairs || result.autoClosingPairs,\n            surroundingPairs: entry.surroundingPairs || result.surroundingPairs,\n            autoCloseBefore: entry.autoCloseBefore || result.autoCloseBefore,\n            folding: entry.folding || result.folding,\n            colorizedBracketPairs: entry.colorizedBracketPairs || result.colorizedBracketPairs,\n            __electricCharacterSupport: entry.__electricCharacterSupport || result.__electricCharacterSupport,\n        };\n    }\n    return result;\n}\nclass LanguageConfigurationContribution {\n    constructor(configuration, priority, order) {\n        this.configuration = configuration;\n        this.priority = priority;\n        this.order = order;\n    }\n    static cmp(a, b) {\n        if (a.priority === b.priority) {\n            // higher order last\n            return a.order - b.order;\n        }\n        // higher priority last\n        return a.priority - b.priority;\n    }\n}\nexport class LanguageConfigurationChangeEvent {\n    constructor(languageId) {\n        this.languageId = languageId;\n    }\n}\nexport class LanguageConfigurationRegistry extends Disposable {\n    constructor() {\n        super();\n        this._entries = new Map();\n        this._onDidChange = this._register(new Emitter());\n        this.onDidChange = this._onDidChange.event;\n        this._register(this.register(PLAINTEXT_LANGUAGE_ID, {\n            brackets: [\n                ['(', ')'],\n                ['[', ']'],\n                ['{', '}'],\n            ],\n            surroundingPairs: [\n                { open: '{', close: '}' },\n                { open: '[', close: ']' },\n                { open: '(', close: ')' },\n                { open: '<', close: '>' },\n                { open: '\\\"', close: '\\\"' },\n                { open: '\\'', close: '\\'' },\n                { open: '`', close: '`' },\n            ],\n            colorizedBracketPairs: [],\n            folding: {\n                offSide: true\n            }\n        }, 0));\n    }\n    /**\n     * @param priority Use a higher number for higher priority\n     */\n    register(languageId, configuration, priority = 0) {\n        let entries = this._entries.get(languageId);\n        if (!entries) {\n            entries = new ComposedLanguageConfiguration(languageId);\n            this._entries.set(languageId, entries);\n        }\n        const disposable = entries.register(configuration, priority);\n        this._onDidChange.fire(new LanguageConfigurationChangeEvent(languageId));\n        return toDisposable(() => {\n            disposable.dispose();\n            this._onDidChange.fire(new LanguageConfigurationChangeEvent(languageId));\n        });\n    }\n    getLanguageConfiguration(languageId) {\n        const entries = this._entries.get(languageId);\n        return (entries === null || entries === void 0 ? void 0 : entries.getResolvedConfiguration()) || null;\n    }\n}\n/**\n * Immutable.\n*/\nexport class ResolvedLanguageConfiguration {\n    constructor(languageId, underlyingConfig) {\n        this.languageId = languageId;\n        this.underlyingConfig = underlyingConfig;\n        this._brackets = null;\n        this._electricCharacter = null;\n        this._onEnterSupport =\n            this.underlyingConfig.brackets ||\n                this.underlyingConfig.indentationRules ||\n                this.underlyingConfig.onEnterRules\n                ? new OnEnterSupport(this.underlyingConfig)\n                : null;\n        this.comments = ResolvedLanguageConfiguration._handleComments(this.underlyingConfig);\n        this.characterPair = new CharacterPairSupport(this.underlyingConfig);\n        this.wordDefinition = this.underlyingConfig.wordPattern || DEFAULT_WORD_REGEXP;\n        this.indentationRules = this.underlyingConfig.indentationRules;\n        if (this.underlyingConfig.indentationRules) {\n            this.indentRulesSupport = new IndentRulesSupport(this.underlyingConfig.indentationRules);\n        }\n        else {\n            this.indentRulesSupport = null;\n        }\n        this.foldingRules = this.underlyingConfig.folding || {};\n        this.bracketsNew = new LanguageBracketsConfiguration(languageId, this.underlyingConfig);\n    }\n    getWordDefinition() {\n        return ensureValidWordDefinition(this.wordDefinition);\n    }\n    get brackets() {\n        if (!this._brackets && this.underlyingConfig.brackets) {\n            this._brackets = new RichEditBrackets(this.languageId, this.underlyingConfig.brackets);\n        }\n        return this._brackets;\n    }\n    get electricCharacter() {\n        if (!this._electricCharacter) {\n            this._electricCharacter = new BracketElectricCharacterSupport(this.brackets);\n        }\n        return this._electricCharacter;\n    }\n    onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText) {\n        if (!this._onEnterSupport) {\n            return null;\n        }\n        return this._onEnterSupport.onEnter(autoIndent, previousLineText, beforeEnterText, afterEnterText);\n    }\n    getAutoClosingPairs() {\n        return new AutoClosingPairs(this.characterPair.getAutoClosingPairs());\n    }\n    getAutoCloseBeforeSet(forQuotes) {\n        return this.characterPair.getAutoCloseBeforeSet(forQuotes);\n    }\n    getSurroundingPairs() {\n        return this.characterPair.getSurroundingPairs();\n    }\n    static _handleComments(conf) {\n        const commentRule = conf.comments;\n        if (!commentRule) {\n            return null;\n        }\n        // comment configuration\n        const comments = {};\n        if (commentRule.lineComment) {\n            comments.lineCommentToken = commentRule.lineComment;\n        }\n        if (commentRule.blockComment) {\n            const [blockStart, blockEnd] = commentRule.blockComment;\n            comments.blockCommentStartToken = blockStart;\n            comments.blockCommentEndToken = blockEnd;\n        }\n        return comments;\n    }\n}\nregisterSingleton(ILanguageConfigurationService, LanguageConfigurationService, 1 /* InstantiationType.Delayed */);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { CharacterClassifier } from '../core/characterClassifier.js';\nclass Uint8Matrix {\n    constructor(rows, cols, defaultValue) {\n        const data = new Uint8Array(rows * cols);\n        for (let i = 0, len = rows * cols; i < len; i++) {\n            data[i] = defaultValue;\n        }\n        this._data = data;\n        this.rows = rows;\n        this.cols = cols;\n    }\n    get(row, col) {\n        return this._data[row * this.cols + col];\n    }\n    set(row, col, value) {\n        this._data[row * this.cols + col] = value;\n    }\n}\nexport class StateMachine {\n    constructor(edges) {\n        let maxCharCode = 0;\n        let maxState = 0 /* State.Invalid */;\n        for (let i = 0, len = edges.length; i < len; i++) {\n            const [from, chCode, to] = edges[i];\n            if (chCode > maxCharCode) {\n                maxCharCode = chCode;\n            }\n            if (from > maxState) {\n                maxState = from;\n            }\n            if (to > maxState) {\n                maxState = to;\n            }\n        }\n        maxCharCode++;\n        maxState++;\n        const states = new Uint8Matrix(maxState, maxCharCode, 0 /* State.Invalid */);\n        for (let i = 0, len = edges.length; i < len; i++) {\n            const [from, chCode, to] = edges[i];\n            states.set(from, chCode, to);\n        }\n        this._states = states;\n        this._maxCharCode = maxCharCode;\n    }\n    nextState(currentState, chCode) {\n        if (chCode < 0 || chCode >= this._maxCharCode) {\n            return 0 /* State.Invalid */;\n        }\n        return this._states.get(currentState, chCode);\n    }\n}\n// State machine for http:// or https:// or file://\nlet _stateMachine = null;\nfunction getStateMachine() {\n    if (_stateMachine === null) {\n        _stateMachine = new StateMachine([\n            [1 /* State.Start */, 104 /* CharCode.h */, 2 /* State.H */],\n            [1 /* State.Start */, 72 /* CharCode.H */, 2 /* State.H */],\n            [1 /* State.Start */, 102 /* CharCode.f */, 6 /* State.F */],\n            [1 /* State.Start */, 70 /* CharCode.F */, 6 /* State.F */],\n            [2 /* State.H */, 116 /* CharCode.t */, 3 /* State.HT */],\n            [2 /* State.H */, 84 /* CharCode.T */, 3 /* State.HT */],\n            [3 /* State.HT */, 116 /* CharCode.t */, 4 /* State.HTT */],\n            [3 /* State.HT */, 84 /* CharCode.T */, 4 /* State.HTT */],\n            [4 /* State.HTT */, 112 /* CharCode.p */, 5 /* State.HTTP */],\n            [4 /* State.HTT */, 80 /* CharCode.P */, 5 /* State.HTTP */],\n            [5 /* State.HTTP */, 115 /* CharCode.s */, 9 /* State.BeforeColon */],\n            [5 /* State.HTTP */, 83 /* CharCode.S */, 9 /* State.BeforeColon */],\n            [5 /* State.HTTP */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],\n            [6 /* State.F */, 105 /* CharCode.i */, 7 /* State.FI */],\n            [6 /* State.F */, 73 /* CharCode.I */, 7 /* State.FI */],\n            [7 /* State.FI */, 108 /* CharCode.l */, 8 /* State.FIL */],\n            [7 /* State.FI */, 76 /* CharCode.L */, 8 /* State.FIL */],\n            [8 /* State.FIL */, 101 /* CharCode.e */, 9 /* State.BeforeColon */],\n            [8 /* State.FIL */, 69 /* CharCode.E */, 9 /* State.BeforeColon */],\n            [9 /* State.BeforeColon */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],\n            [10 /* State.AfterColon */, 47 /* CharCode.Slash */, 11 /* State.AlmostThere */],\n            [11 /* State.AlmostThere */, 47 /* CharCode.Slash */, 12 /* State.End */],\n        ]);\n    }\n    return _stateMachine;\n}\nlet _classifier = null;\nfunction getClassifier() {\n    if (_classifier === null) {\n        _classifier = new CharacterClassifier(0 /* CharacterClass.None */);\n        // allow-any-unicode-next-line\n        const FORCE_TERMINATION_CHARACTERS = ' \\t<>\\'\\\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…';\n        for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {\n            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* CharacterClass.ForceTermination */);\n        }\n        const CANNOT_END_WITH_CHARACTERS = '.,;:';\n        for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {\n            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CharacterClass.CannotEndIn */);\n        }\n    }\n    return _classifier;\n}\nexport class LinkComputer {\n    static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {\n        // Do not allow to end link in certain characters...\n        let lastIncludedCharIndex = linkEndIndex - 1;\n        do {\n            const chCode = line.charCodeAt(lastIncludedCharIndex);\n            const chClass = classifier.get(chCode);\n            if (chClass !== 2 /* CharacterClass.CannotEndIn */) {\n                break;\n            }\n            lastIncludedCharIndex--;\n        } while (lastIncludedCharIndex > linkBeginIndex);\n        // Handle links enclosed in parens, square brackets and curlys.\n        if (linkBeginIndex > 0) {\n            const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);\n            const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);\n            if ((charCodeBeforeLink === 40 /* CharCode.OpenParen */ && lastCharCodeInLink === 41 /* CharCode.CloseParen */)\n                || (charCodeBeforeLink === 91 /* CharCode.OpenSquareBracket */ && lastCharCodeInLink === 93 /* CharCode.CloseSquareBracket */)\n                || (charCodeBeforeLink === 123 /* CharCode.OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CharCode.CloseCurlyBrace */)) {\n                // Do not end in ) if ( is before the link start\n                // Do not end in ] if [ is before the link start\n                // Do not end in } if { is before the link start\n                lastIncludedCharIndex--;\n            }\n        }\n        return {\n            range: {\n                startLineNumber: lineNumber,\n                startColumn: linkBeginIndex + 1,\n                endLineNumber: lineNumber,\n                endColumn: lastIncludedCharIndex + 2\n            },\n            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)\n        };\n    }\n    static computeLinks(model, stateMachine = getStateMachine()) {\n        const classifier = getClassifier();\n        const result = [];\n        for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {\n            const line = model.getLineContent(i);\n            const len = line.length;\n            let j = 0;\n            let linkBeginIndex = 0;\n            let linkBeginChCode = 0;\n            let state = 1 /* State.Start */;\n            let hasOpenParens = false;\n            let hasOpenSquareBracket = false;\n            let inSquareBrackets = false;\n            let hasOpenCurlyBracket = false;\n            while (j < len) {\n                let resetStateMachine = false;\n                const chCode = line.charCodeAt(j);\n                if (state === 13 /* State.Accept */) {\n                    let chClass;\n                    switch (chCode) {\n                        case 40 /* CharCode.OpenParen */:\n                            hasOpenParens = true;\n                            chClass = 0 /* CharacterClass.None */;\n                            break;\n                        case 41 /* CharCode.CloseParen */:\n                            chClass = (hasOpenParens ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n                            break;\n                        case 91 /* CharCode.OpenSquareBracket */:\n                            inSquareBrackets = true;\n                            hasOpenSquareBracket = true;\n                            chClass = 0 /* CharacterClass.None */;\n                            break;\n                        case 93 /* CharCode.CloseSquareBracket */:\n                            inSquareBrackets = false;\n                            chClass = (hasOpenSquareBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n                            break;\n                        case 123 /* CharCode.OpenCurlyBrace */:\n                            hasOpenCurlyBracket = true;\n                            chClass = 0 /* CharacterClass.None */;\n                            break;\n                        case 125 /* CharCode.CloseCurlyBrace */:\n                            chClass = (hasOpenCurlyBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n                            break;\n                        // The following three rules make it that ' or \" or ` are allowed inside links\n                        // only if the link is wrapped by some other quote character\n                        case 39 /* CharCode.SingleQuote */:\n                        case 34 /* CharCode.DoubleQuote */:\n                        case 96 /* CharCode.BackTick */:\n                            if (linkBeginChCode === chCode) {\n                                chClass = 1 /* CharacterClass.ForceTermination */;\n                            }\n                            else if (linkBeginChCode === 39 /* CharCode.SingleQuote */ || linkBeginChCode === 34 /* CharCode.DoubleQuote */ || linkBeginChCode === 96 /* CharCode.BackTick */) {\n                                chClass = 0 /* CharacterClass.None */;\n                            }\n                            else {\n                                chClass = 1 /* CharacterClass.ForceTermination */;\n                            }\n                            break;\n                        case 42 /* CharCode.Asterisk */:\n                            // `*` terminates a link if the link began with `*`\n                            chClass = (linkBeginChCode === 42 /* CharCode.Asterisk */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */;\n                            break;\n                        case 124 /* CharCode.Pipe */:\n                            // `|` terminates a link if the link began with `|`\n                            chClass = (linkBeginChCode === 124 /* CharCode.Pipe */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */;\n                            break;\n                        case 32 /* CharCode.Space */:\n                            // ` ` allow space in between [ and ]\n                            chClass = (inSquareBrackets ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);\n                            break;\n                        default:\n                            chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* CharacterClass.ForceTermination */) {\n                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));\n                        resetStateMachine = true;\n                    }\n                }\n                else if (state === 12 /* State.End */) {\n                    let chClass;\n                    if (chCode === 91 /* CharCode.OpenSquareBracket */) {\n                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]\n                        hasOpenSquareBracket = true;\n                        chClass = 0 /* CharacterClass.None */;\n                    }\n                    else {\n                        chClass = classifier.get(chCode);\n                    }\n                    // Check if character terminates link\n                    if (chClass === 1 /* CharacterClass.ForceTermination */) {\n                        resetStateMachine = true;\n                    }\n                    else {\n                        state = 13 /* State.Accept */;\n                    }\n                }\n                else {\n                    state = stateMachine.nextState(state, chCode);\n                    if (state === 0 /* State.Invalid */) {\n                        resetStateMachine = true;\n                    }\n                }\n                if (resetStateMachine) {\n                    state = 1 /* State.Start */;\n                    hasOpenParens = false;\n                    hasOpenSquareBracket = false;\n                    hasOpenCurlyBracket = false;\n                    // Record where the link started\n                    linkBeginIndex = j + 1;\n                    linkBeginChCode = chCode;\n                }\n                j++;\n            }\n            if (state === 13 /* State.Accept */) {\n                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));\n            }\n        }\n        return result;\n    }\n}\n/**\n * Returns an array of all links contains in the provided\n * document. *Note* that this operation is computational\n * expensive and should not run in the UI thread.\n */\nexport function computeLinks(model) {\n    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {\n        // Unknown caller!\n        return [];\n    }\n    return LinkComputer.computeLinks(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as nls from '../../../nls.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { Registry } from '../../../platform/registry/common/platform.js';\nimport { Mimes } from '../../../base/common/mime.js';\nimport { Extensions as ConfigurationExtensions } from '../../../platform/configuration/common/configurationRegistry.js';\n// Define extension point ids\nexport const Extensions = {\n    ModesRegistry: 'editor.modesRegistry'\n};\nexport class EditorModesRegistry {\n    constructor() {\n        this._onDidChangeLanguages = new Emitter();\n        this.onDidChangeLanguages = this._onDidChangeLanguages.event;\n        this._languages = [];\n    }\n    registerLanguage(def) {\n        this._languages.push(def);\n        this._onDidChangeLanguages.fire(undefined);\n        return {\n            dispose: () => {\n                for (let i = 0, len = this._languages.length; i < len; i++) {\n                    if (this._languages[i] === def) {\n                        this._languages.splice(i, 1);\n                        return;\n                    }\n                }\n            }\n        };\n    }\n    getLanguages() {\n        return this._languages;\n    }\n}\nexport const ModesRegistry = new EditorModesRegistry();\nRegistry.add(Extensions.ModesRegistry, ModesRegistry);\nexport const PLAINTEXT_LANGUAGE_ID = 'plaintext';\nexport const PLAINTEXT_EXTENSION = '.txt';\nModesRegistry.registerLanguage({\n    id: PLAINTEXT_LANGUAGE_ID,\n    extensions: [PLAINTEXT_EXTENSION],\n    aliases: [nls.localize('plainText.alias', \"Plain Text\"), 'text'],\n    mimetypes: [Mimes.text]\n});\nRegistry.as(ConfigurationExtensions.Configuration)\n    .registerDefaultConfigurations([{\n        overrides: {\n            '[plaintext]': {\n                'editor.unicodeHighlight.ambiguousCharacters': false,\n                'editor.unicodeHighlight.invisibleCharacters': false\n            }\n        }\n    }]);\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Token, TokenizationResult, EncodedTokenizationResult } from '../languages.js';\nexport const NullState = new class {\n    clone() {\n        return this;\n    }\n    equals(other) {\n        return (this === other);\n    }\n};\nexport function nullTokenize(languageId, state) {\n    return new TokenizationResult([new Token(0, '', languageId)], state);\n}\nexport function nullTokenizeEncoded(languageId, state) {\n    const tokens = new Uint32Array(2);\n    tokens[0] = 0;\n    tokens[1] = ((languageId << 0 /* MetadataConsts.LANGUAGEID_OFFSET */)\n        | (0 /* StandardTokenType.Other */ << 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */)\n        | (0 /* FontStyle.None */ << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)\n        | (1 /* ColorId.DefaultForeground */ << 15 /* MetadataConsts.FOREGROUND_OFFSET */)\n        | (2 /* ColorId.DefaultBackground */ << 24 /* MetadataConsts.BACKGROUND_OFFSET */)) >>> 0;\n    return new EncodedTokenizationResult(tokens, state === null ? NullState : state);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function createScopedLineTokens(context, offset) {\n    const tokenCount = context.getCount();\n    const tokenIndex = context.findTokenIndexAtOffset(offset);\n    const desiredLanguageId = context.getLanguageId(tokenIndex);\n    let lastTokenIndex = tokenIndex;\n    while (lastTokenIndex + 1 < tokenCount && context.getLanguageId(lastTokenIndex + 1) === desiredLanguageId) {\n        lastTokenIndex++;\n    }\n    let firstTokenIndex = tokenIndex;\n    while (firstTokenIndex > 0 && context.getLanguageId(firstTokenIndex - 1) === desiredLanguageId) {\n        firstTokenIndex--;\n    }\n    return new ScopedLineTokens(context, desiredLanguageId, firstTokenIndex, lastTokenIndex + 1, context.getStartOffset(firstTokenIndex), context.getEndOffset(lastTokenIndex));\n}\nexport class ScopedLineTokens {\n    constructor(actual, languageId, firstTokenIndex, lastTokenIndex, firstCharOffset, lastCharOffset) {\n        this._scopedLineTokensBrand = undefined;\n        this._actual = actual;\n        this.languageId = languageId;\n        this._firstTokenIndex = firstTokenIndex;\n        this._lastTokenIndex = lastTokenIndex;\n        this.firstCharOffset = firstCharOffset;\n        this._lastCharOffset = lastCharOffset;\n        this.languageIdCodec = actual.languageIdCodec;\n    }\n    getLineContent() {\n        const actualLineContent = this._actual.getLineContent();\n        return actualLineContent.substring(this.firstCharOffset, this._lastCharOffset);\n    }\n    getLineLength() {\n        return this._lastCharOffset - this.firstCharOffset;\n    }\n    getActualLineContentBefore(offset) {\n        const actualLineContent = this._actual.getLineContent();\n        return actualLineContent.substring(0, this.firstCharOffset + offset);\n    }\n    getTokenCount() {\n        return this._lastTokenIndex - this._firstTokenIndex;\n    }\n    findTokenIndexAtOffset(offset) {\n        return this._actual.findTokenIndexAtOffset(offset + this.firstCharOffset) - this._firstTokenIndex;\n    }\n    getStandardTokenType(tokenIndex) {\n        return this._actual.getStandardTokenType(tokenIndex + this._firstTokenIndex);\n    }\n    toIViewLineTokens() {\n        return this._actual.sliceAndInflate(this.firstCharOffset, this._lastCharOffset, 0);\n    }\n}\nexport function ignoreBracketsInToken(standardTokenType) {\n    return (standardTokenType & 3 /* IgnoreBracketsInTokens.value */) !== 0;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../../base/common/strings.js';\nimport { createScopedLineTokens } from '../supports.js';\nimport { LineTokens } from '../../tokens/lineTokens.js';\n/**\n * This class is a wrapper class around {@link IndentRulesSupport}.\n * It processes the lines by removing the language configuration brackets from the regex, string and comment tokens.\n * It then calls into the {@link IndentRulesSupport} to validate the indentation conditions.\n */\nexport class ProcessedIndentRulesSupport {\n    constructor(model, indentRulesSupport, languageConfigurationService) {\n        this._indentRulesSupport = indentRulesSupport;\n        this._indentationLineProcessor = new IndentationLineProcessor(model, languageConfigurationService);\n    }\n    /**\n     * Apply the new indentation and return whether the indentation level should be increased after the given line number\n     */\n    shouldIncrease(lineNumber, newIndentation) {\n        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);\n        return this._indentRulesSupport.shouldIncrease(processedLine);\n    }\n    /**\n     * Apply the new indentation and return whether the indentation level should be decreased after the given line number\n     */\n    shouldDecrease(lineNumber, newIndentation) {\n        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);\n        return this._indentRulesSupport.shouldDecrease(processedLine);\n    }\n    /**\n     * Apply the new indentation and return whether the indentation level should remain unchanged at the given line number\n     */\n    shouldIgnore(lineNumber, newIndentation) {\n        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);\n        return this._indentRulesSupport.shouldIgnore(processedLine);\n    }\n    /**\n     * Apply the new indentation and return whether the indentation level should increase on the line after the given line number\n     */\n    shouldIndentNextLine(lineNumber, newIndentation) {\n        const processedLine = this._indentationLineProcessor.getProcessedLine(lineNumber, newIndentation);\n        return this._indentRulesSupport.shouldIndentNextLine(processedLine);\n    }\n}\n/**\n * This class fetches the processed text around a range which can be used for indentation evaluation.\n * It returns:\n * - The processed text before the given range and on the same start line\n * - The processed text after the given range and on the same end line\n * - The processed text on the previous line\n */\nexport class IndentationContextProcessor {\n    constructor(model, languageConfigurationService) {\n        this.model = model;\n        this.indentationLineProcessor = new IndentationLineProcessor(model, languageConfigurationService);\n    }\n    /**\n     * Returns the processed text, stripped from the language configuration brackets within the string, comment and regex tokens, around the given range\n     */\n    getProcessedTokenContextAroundRange(range) {\n        const beforeRangeProcessedTokens = this._getProcessedTokensBeforeRange(range);\n        const afterRangeProcessedTokens = this._getProcessedTokensAfterRange(range);\n        const previousLineProcessedTokens = this._getProcessedPreviousLineTokens(range);\n        return { beforeRangeProcessedTokens, afterRangeProcessedTokens, previousLineProcessedTokens };\n    }\n    _getProcessedTokensBeforeRange(range) {\n        this.model.tokenization.forceTokenization(range.startLineNumber);\n        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);\n        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);\n        let slicedTokens;\n        if (isLanguageDifferentFromLineStart(this.model, range.getStartPosition())) {\n            const columnIndexWithinScope = (range.startColumn - 1) - scopedLineTokens.firstCharOffset;\n            const firstCharacterOffset = scopedLineTokens.firstCharOffset;\n            const lastCharacterOffset = firstCharacterOffset + columnIndexWithinScope;\n            slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);\n        }\n        else {\n            const columnWithinLine = range.startColumn - 1;\n            slicedTokens = lineTokens.sliceAndInflate(0, columnWithinLine, 0);\n        }\n        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);\n        return processedTokens;\n    }\n    _getProcessedTokensAfterRange(range) {\n        const position = range.isEmpty() ? range.getStartPosition() : range.getEndPosition();\n        this.model.tokenization.forceTokenization(position.lineNumber);\n        const lineTokens = this.model.tokenization.getLineTokens(position.lineNumber);\n        const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);\n        const columnIndexWithinScope = position.column - 1 - scopedLineTokens.firstCharOffset;\n        const firstCharacterOffset = scopedLineTokens.firstCharOffset + columnIndexWithinScope;\n        const lastCharacterOffset = scopedLineTokens.firstCharOffset + scopedLineTokens.getLineLength();\n        const slicedTokens = lineTokens.sliceAndInflate(firstCharacterOffset, lastCharacterOffset, 0);\n        const processedTokens = this.indentationLineProcessor.getProcessedTokens(slicedTokens);\n        return processedTokens;\n    }\n    _getProcessedPreviousLineTokens(range) {\n        const getScopedLineTokensAtEndColumnOfLine = (lineNumber) => {\n            this.model.tokenization.forceTokenization(lineNumber);\n            const lineTokens = this.model.tokenization.getLineTokens(lineNumber);\n            const endColumnOfLine = this.model.getLineMaxColumn(lineNumber) - 1;\n            const scopedLineTokensAtEndColumn = createScopedLineTokens(lineTokens, endColumnOfLine);\n            return scopedLineTokensAtEndColumn;\n        };\n        this.model.tokenization.forceTokenization(range.startLineNumber);\n        const lineTokens = this.model.tokenization.getLineTokens(range.startLineNumber);\n        const scopedLineTokens = createScopedLineTokens(lineTokens, range.startColumn - 1);\n        const emptyTokens = LineTokens.createEmpty('', scopedLineTokens.languageIdCodec);\n        const previousLineNumber = range.startLineNumber - 1;\n        const isFirstLine = previousLineNumber === 0;\n        if (isFirstLine) {\n            return emptyTokens;\n        }\n        const canScopeExtendOnPreviousLine = scopedLineTokens.firstCharOffset === 0;\n        if (!canScopeExtendOnPreviousLine) {\n            return emptyTokens;\n        }\n        const scopedLineTokensAtEndColumnOfPreviousLine = getScopedLineTokensAtEndColumnOfLine(previousLineNumber);\n        const doesLanguageContinueOnPreviousLine = scopedLineTokens.languageId === scopedLineTokensAtEndColumnOfPreviousLine.languageId;\n        if (!doesLanguageContinueOnPreviousLine) {\n            return emptyTokens;\n        }\n        const previousSlicedLineTokens = scopedLineTokensAtEndColumnOfPreviousLine.toIViewLineTokens();\n        const processedTokens = this.indentationLineProcessor.getProcessedTokens(previousSlicedLineTokens);\n        return processedTokens;\n    }\n}\n/**\n * This class performs the actual processing of the indentation lines.\n * The brackets of the language configuration are removed from the regex, string and comment tokens.\n */\nclass IndentationLineProcessor {\n    constructor(model, languageConfigurationService) {\n        this.model = model;\n        this.languageConfigurationService = languageConfigurationService;\n    }\n    /**\n     * Get the processed line for the given line number and potentially adjust the indentation level.\n     * Remove the language configuration brackets from the regex, string and comment tokens.\n     */\n    getProcessedLine(lineNumber, newIndentation) {\n        var _a, _b;\n        const replaceIndentation = (line, newIndentation) => {\n            const currentIndentation = strings.getLeadingWhitespace(line);\n            const adjustedLine = newIndentation + line.substring(currentIndentation.length);\n            return adjustedLine;\n        };\n        (_b = (_a = this.model.tokenization).forceTokenization) === null || _b === void 0 ? void 0 : _b.call(_a, lineNumber);\n        const tokens = this.model.tokenization.getLineTokens(lineNumber);\n        let processedLine = this.getProcessedTokens(tokens).getLineContent();\n        if (newIndentation !== undefined) {\n            processedLine = replaceIndentation(processedLine, newIndentation);\n        }\n        return processedLine;\n    }\n    /**\n     * Process the line with the given tokens, remove the language configuration brackets from the regex, string and comment tokens.\n     */\n    getProcessedTokens(tokens) {\n        const shouldRemoveBracketsFromTokenType = (tokenType) => {\n            return tokenType === 2 /* StandardTokenType.String */\n                || tokenType === 3 /* StandardTokenType.RegEx */\n                || tokenType === 1 /* StandardTokenType.Comment */;\n        };\n        const languageId = tokens.getLanguageId(0);\n        const bracketsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).bracketsNew;\n        const bracketsRegExp = bracketsConfiguration.getBracketRegExp({ global: true });\n        const textAndMetadata = [];\n        tokens.forEach((tokenIndex) => {\n            const tokenType = tokens.getStandardTokenType(tokenIndex);\n            let text = tokens.getTokenText(tokenIndex);\n            if (shouldRemoveBracketsFromTokenType(tokenType)) {\n                text = text.replace(bracketsRegExp, '');\n            }\n            const metadata = tokens.getMetadata(tokenIndex);\n            textAndMetadata.push({ text, metadata });\n        });\n        const processedLineTokens = LineTokens.createFromTextAndMetadata(textAndMetadata, tokens.languageIdCodec);\n        return processedLineTokens;\n    }\n}\nexport function isLanguageDifferentFromLineStart(model, position) {\n    model.tokenization.forceTokenization(position.lineNumber);\n    const lineTokens = model.tokenization.getLineTokens(position.lineNumber);\n    const scopedLineTokens = createScopedLineTokens(lineTokens, position.column - 1);\n    const doesScopeStartAtOffsetZero = scopedLineTokens.firstCharOffset === 0;\n    const isScopedLanguageEqualToFirstLanguageOnLine = lineTokens.getLanguageId(0) === scopedLineTokens.languageId;\n    const languageIsDifferentFromLineStart = !doesScopeStartAtOffsetZero && !isScopedLanguageEqualToFirstLanguageOnLine;\n    return languageIsDifferentFromLineStart;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class BasicInplaceReplace {\n    constructor() {\n        this._defaultValueSet = [\n            ['true', 'false'],\n            ['True', 'False'],\n            ['Private', 'Public', 'Friend', 'ReadOnly', 'Partial', 'Protected', 'WriteOnly'],\n            ['public', 'protected', 'private'],\n        ];\n    }\n    navigateValueSet(range1, text1, range2, text2, up) {\n        if (range1 && text1) {\n            const result = this.doNavigateValueSet(text1, up);\n            if (result) {\n                return {\n                    range: range1,\n                    value: result\n                };\n            }\n        }\n        if (range2 && text2) {\n            const result = this.doNavigateValueSet(text2, up);\n            if (result) {\n                return {\n                    range: range2,\n                    value: result\n                };\n            }\n        }\n        return null;\n    }\n    doNavigateValueSet(text, up) {\n        const numberResult = this.numberReplace(text, up);\n        if (numberResult !== null) {\n            return numberResult;\n        }\n        return this.textReplace(text, up);\n    }\n    numberReplace(value, up) {\n        const precision = Math.pow(10, value.length - (value.lastIndexOf('.') + 1));\n        let n1 = Number(value);\n        const n2 = parseFloat(value);\n        if (!isNaN(n1) && !isNaN(n2) && n1 === n2) {\n            if (n1 === 0 && !up) {\n                return null; // don't do negative\n                //\t\t\t} else if(n1 === 9 && up) {\n                //\t\t\t\treturn null; // don't insert 10 into a number\n            }\n            else {\n                n1 = Math.floor(n1 * precision);\n                n1 += up ? precision : -precision;\n                return String(n1 / precision);\n            }\n        }\n        return null;\n    }\n    textReplace(value, up) {\n        return this.valueSetsReplace(this._defaultValueSet, value, up);\n    }\n    valueSetsReplace(valueSets, value, up) {\n        let result = null;\n        for (let i = 0, len = valueSets.length; result === null && i < len; i++) {\n            result = this.valueSetReplace(valueSets[i], value, up);\n        }\n        return result;\n    }\n    valueSetReplace(valueSet, value, up) {\n        let idx = valueSet.indexOf(value);\n        if (idx >= 0) {\n            idx += up ? +1 : -1;\n            if (idx < 0) {\n                idx = valueSet.length - 1;\n            }\n            else {\n                idx %= valueSet.length;\n            }\n            return valueSet[idx];\n        }\n        return null;\n    }\n}\nBasicInplaceReplace.INSTANCE = new BasicInplaceReplace();\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../../base/common/strings.js';\nimport * as stringBuilder from '../../core/stringBuilder.js';\nimport { Range } from '../../core/range.js';\n/**\n * Represents a grouping of colliding bracket pairs.\n *\n * Most of the times this contains a single bracket pair,\n * but sometimes this contains multiple bracket pairs in cases\n * where the same string appears as a closing bracket for multiple\n * bracket pairs, or the same string appears an opening bracket for\n * multiple bracket pairs.\n *\n * e.g. of a group containing a single pair:\n *   open: ['{'], close: ['}']\n *\n * e.g. of a group containing multiple pairs:\n *   open: ['if', 'for'], close: ['end', 'end']\n */\nexport class RichEditBracket {\n    constructor(languageId, index, open, close, forwardRegex, reversedRegex) {\n        this._richEditBracketBrand = undefined;\n        this.languageId = languageId;\n        this.index = index;\n        this.open = open;\n        this.close = close;\n        this.forwardRegex = forwardRegex;\n        this.reversedRegex = reversedRegex;\n        this._openSet = RichEditBracket._toSet(this.open);\n        this._closeSet = RichEditBracket._toSet(this.close);\n    }\n    /**\n     * Check if the provided `text` is an open bracket in this group.\n     */\n    isOpen(text) {\n        return this._openSet.has(text);\n    }\n    /**\n     * Check if the provided `text` is a close bracket in this group.\n     */\n    isClose(text) {\n        return this._closeSet.has(text);\n    }\n    static _toSet(arr) {\n        const result = new Set();\n        for (const element of arr) {\n            result.add(element);\n        }\n        return result;\n    }\n}\n/**\n * Groups together brackets that have equal open or close sequences.\n *\n * For example, if the following brackets are defined:\n *   ['IF','END']\n *   ['for','end']\n *   ['{','}']\n *\n * Then the grouped brackets would be:\n *   { open: ['if', 'for'], close: ['end', 'end'] }\n *   { open: ['{'], close: ['}'] }\n *\n */\nfunction groupFuzzyBrackets(brackets) {\n    const N = brackets.length;\n    brackets = brackets.map(b => [b[0].toLowerCase(), b[1].toLowerCase()]);\n    const group = [];\n    for (let i = 0; i < N; i++) {\n        group[i] = i;\n    }\n    const areOverlapping = (a, b) => {\n        const [aOpen, aClose] = a;\n        const [bOpen, bClose] = b;\n        return (aOpen === bOpen || aOpen === bClose || aClose === bOpen || aClose === bClose);\n    };\n    const mergeGroups = (g1, g2) => {\n        const newG = Math.min(g1, g2);\n        const oldG = Math.max(g1, g2);\n        for (let i = 0; i < N; i++) {\n            if (group[i] === oldG) {\n                group[i] = newG;\n            }\n        }\n    };\n    // group together brackets that have the same open or the same close sequence\n    for (let i = 0; i < N; i++) {\n        const a = brackets[i];\n        for (let j = i + 1; j < N; j++) {\n            const b = brackets[j];\n            if (areOverlapping(a, b)) {\n                mergeGroups(group[i], group[j]);\n            }\n        }\n    }\n    const result = [];\n    for (let g = 0; g < N; g++) {\n        const currentOpen = [];\n        const currentClose = [];\n        for (let i = 0; i < N; i++) {\n            if (group[i] === g) {\n                const [open, close] = brackets[i];\n                currentOpen.push(open);\n                currentClose.push(close);\n            }\n        }\n        if (currentOpen.length > 0) {\n            result.push({\n                open: currentOpen,\n                close: currentClose\n            });\n        }\n    }\n    return result;\n}\nexport class RichEditBrackets {\n    constructor(languageId, _brackets) {\n        this._richEditBracketsBrand = undefined;\n        const brackets = groupFuzzyBrackets(_brackets);\n        this.brackets = brackets.map((b, index) => {\n            return new RichEditBracket(languageId, index, b.open, b.close, getRegexForBracketPair(b.open, b.close, brackets, index), getReversedRegexForBracketPair(b.open, b.close, brackets, index));\n        });\n        this.forwardRegex = getRegexForBrackets(this.brackets);\n        this.reversedRegex = getReversedRegexForBrackets(this.brackets);\n        this.textIsBracket = {};\n        this.textIsOpenBracket = {};\n        this.maxBracketLength = 0;\n        for (const bracket of this.brackets) {\n            for (const open of bracket.open) {\n                this.textIsBracket[open] = bracket;\n                this.textIsOpenBracket[open] = true;\n                this.maxBracketLength = Math.max(this.maxBracketLength, open.length);\n            }\n            for (const close of bracket.close) {\n                this.textIsBracket[close] = bracket;\n                this.textIsOpenBracket[close] = false;\n                this.maxBracketLength = Math.max(this.maxBracketLength, close.length);\n            }\n        }\n    }\n}\nfunction collectSuperstrings(str, brackets, currentIndex, dest) {\n    for (let i = 0, len = brackets.length; i < len; i++) {\n        if (i === currentIndex) {\n            continue;\n        }\n        const bracket = brackets[i];\n        for (const open of bracket.open) {\n            if (open.indexOf(str) >= 0) {\n                dest.push(open);\n            }\n        }\n        for (const close of bracket.close) {\n            if (close.indexOf(str) >= 0) {\n                dest.push(close);\n            }\n        }\n    }\n}\nfunction lengthcmp(a, b) {\n    return a.length - b.length;\n}\nfunction unique(arr) {\n    if (arr.length <= 1) {\n        return arr;\n    }\n    const result = [];\n    const seen = new Set();\n    for (const element of arr) {\n        if (seen.has(element)) {\n            continue;\n        }\n        result.push(element);\n        seen.add(element);\n    }\n    return result;\n}\n/**\n * Create a regular expression that can be used to search forward in a piece of text\n * for a group of bracket pairs. But this regex must be built in a way in which\n * it is aware of the other bracket pairs defined for the language.\n *\n * For example, if a language contains the following bracket pairs:\n *   ['begin', 'end']\n *   ['if', 'end if']\n * The two bracket pairs do not collide because no open or close brackets are equal.\n * So the function getRegexForBracketPair is called twice, once with\n * the ['begin'], ['end'] group consisting of one bracket pair, and once with\n * the ['if'], ['end if'] group consiting of the other bracket pair.\n *\n * But there could be a situation where an occurrence of 'end if' is mistaken\n * for an occurrence of 'end'.\n *\n * Therefore, for the bracket pair ['begin', 'end'], the regex will also\n * target 'end if'. The regex will be something like:\n *   /(\\bend if\\b)|(\\bend\\b)|(\\bif\\b)/\n *\n * The regex also searches for \"superstrings\" (other brackets that might be mistaken with the current bracket).\n *\n */\nfunction getRegexForBracketPair(open, close, brackets, currentIndex) {\n    // search in all brackets for other brackets that are a superstring of these brackets\n    let pieces = [];\n    pieces = pieces.concat(open);\n    pieces = pieces.concat(close);\n    for (let i = 0, len = pieces.length; i < len; i++) {\n        collectSuperstrings(pieces[i], brackets, currentIndex, pieces);\n    }\n    pieces = unique(pieces);\n    pieces.sort(lengthcmp);\n    pieces.reverse();\n    return createBracketOrRegExp(pieces);\n}\n/**\n * Matching a regular expression in JS can only be done \"forwards\". So JS offers natively only\n * methods to find the first match of a regex in a string. But sometimes, it is useful to\n * find the last match of a regex in a string. For such a situation, a nice solution is to\n * simply reverse the string and then search for a reversed regex.\n *\n * This function also has the fine details of `getRegexForBracketPair`. For the same example\n * given above, the regex produced here would look like:\n *   /(\\bfi dne\\b)|(\\bdne\\b)|(\\bfi\\b)/\n */\nfunction getReversedRegexForBracketPair(open, close, brackets, currentIndex) {\n    // search in all brackets for other brackets that are a superstring of these brackets\n    let pieces = [];\n    pieces = pieces.concat(open);\n    pieces = pieces.concat(close);\n    for (let i = 0, len = pieces.length; i < len; i++) {\n        collectSuperstrings(pieces[i], brackets, currentIndex, pieces);\n    }\n    pieces = unique(pieces);\n    pieces.sort(lengthcmp);\n    pieces.reverse();\n    return createBracketOrRegExp(pieces.map(toReversedString));\n}\n/**\n * Creates a regular expression that targets all bracket pairs.\n *\n * e.g. for the bracket pairs:\n *  ['{','}']\n *  ['begin,'end']\n *  ['for','end']\n * the regex would look like:\n *  /(\\{)|(\\})|(\\bbegin\\b)|(\\bend\\b)|(\\bfor\\b)/\n */\nfunction getRegexForBrackets(brackets) {\n    let pieces = [];\n    for (const bracket of brackets) {\n        for (const open of bracket.open) {\n            pieces.push(open);\n        }\n        for (const close of bracket.close) {\n            pieces.push(close);\n        }\n    }\n    pieces = unique(pieces);\n    return createBracketOrRegExp(pieces);\n}\n/**\n * Matching a regular expression in JS can only be done \"forwards\". So JS offers natively only\n * methods to find the first match of a regex in a string. But sometimes, it is useful to\n * find the last match of a regex in a string. For such a situation, a nice solution is to\n * simply reverse the string and then search for a reversed regex.\n *\n * e.g. for the bracket pairs:\n *  ['{','}']\n *  ['begin,'end']\n *  ['for','end']\n * the regex would look like:\n *  /(\\{)|(\\})|(\\bnigeb\\b)|(\\bdne\\b)|(\\brof\\b)/\n */\nfunction getReversedRegexForBrackets(brackets) {\n    let pieces = [];\n    for (const bracket of brackets) {\n        for (const open of bracket.open) {\n            pieces.push(open);\n        }\n        for (const close of bracket.close) {\n            pieces.push(close);\n        }\n    }\n    pieces = unique(pieces);\n    return createBracketOrRegExp(pieces.map(toReversedString));\n}\nfunction prepareBracketForRegExp(str) {\n    // This bracket pair uses letters like e.g. \"begin\" - \"end\"\n    const insertWordBoundaries = (/^[\\w ]+$/.test(str));\n    str = strings.escapeRegExpCharacters(str);\n    return (insertWordBoundaries ? `\\\\b${str}\\\\b` : str);\n}\nexport function createBracketOrRegExp(pieces, options) {\n    const regexStr = `(${pieces.map(prepareBracketForRegExp).join(')|(')})`;\n    return strings.createRegExp(regexStr, true, options);\n}\nconst toReversedString = (function () {\n    function reverse(str) {\n        // create a Uint16Array and then use a TextDecoder to create a string\n        const arr = new Uint16Array(str.length);\n        let offset = 0;\n        for (let i = str.length - 1; i >= 0; i--) {\n            arr[offset++] = str.charCodeAt(i);\n        }\n        return stringBuilder.getPlatformTextDecoder().decode(arr);\n    }\n    let lastInput = null;\n    let lastOutput = null;\n    return function toReversedString(str) {\n        if (lastInput !== str) {\n            lastInput = str;\n            lastOutput = reverse(lastInput);\n        }\n        return lastOutput;\n    };\n})();\nexport class BracketsUtils {\n    static _findPrevBracketInText(reversedBracketRegex, lineNumber, reversedText, offset) {\n        const m = reversedText.match(reversedBracketRegex);\n        if (!m) {\n            return null;\n        }\n        const matchOffset = reversedText.length - (m.index || 0);\n        const matchLength = m[0].length;\n        const absoluteMatchOffset = offset + matchOffset;\n        return new Range(lineNumber, absoluteMatchOffset - matchLength + 1, lineNumber, absoluteMatchOffset + 1);\n    }\n    static findPrevBracketInRange(reversedBracketRegex, lineNumber, lineText, startOffset, endOffset) {\n        // Because JS does not support backwards regex search, we search forwards in a reversed string with a reversed regex ;)\n        const reversedLineText = toReversedString(lineText);\n        const reversedSubstr = reversedLineText.substring(lineText.length - endOffset, lineText.length - startOffset);\n        return this._findPrevBracketInText(reversedBracketRegex, lineNumber, reversedSubstr, startOffset);\n    }\n    static findNextBracketInText(bracketRegex, lineNumber, text, offset) {\n        const m = text.match(bracketRegex);\n        if (!m) {\n            return null;\n        }\n        const matchOffset = m.index || 0;\n        const matchLength = m[0].length;\n        if (matchLength === 0) {\n            return null;\n        }\n        const absoluteMatchOffset = offset + matchOffset;\n        return new Range(lineNumber, absoluteMatchOffset + 1, lineNumber, absoluteMatchOffset + 1 + matchLength);\n    }\n    static findNextBracketInRange(bracketRegex, lineNumber, lineText, startOffset, endOffset) {\n        const substr = lineText.substring(startOffset, endOffset);\n        return this.findNextBracketInText(bracketRegex, lineNumber, substr, startOffset);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Color } from '../../../../base/common/color.js';\nexport class ParsedTokenThemeRule {\n    constructor(token, index, fontStyle, foreground, background) {\n        this._parsedThemeRuleBrand = undefined;\n        this.token = token;\n        this.index = index;\n        this.fontStyle = fontStyle;\n        this.foreground = foreground;\n        this.background = background;\n    }\n}\n/**\n * Parse a raw theme into rules.\n */\nexport function parseTokenTheme(source) {\n    if (!source || !Array.isArray(source)) {\n        return [];\n    }\n    const result = [];\n    let resultLen = 0;\n    for (let i = 0, len = source.length; i < len; i++) {\n        const entry = source[i];\n        let fontStyle = -1 /* FontStyle.NotSet */;\n        if (typeof entry.fontStyle === 'string') {\n            fontStyle = 0 /* FontStyle.None */;\n            const segments = entry.fontStyle.split(' ');\n            for (let j = 0, lenJ = segments.length; j < lenJ; j++) {\n                const segment = segments[j];\n                switch (segment) {\n                    case 'italic':\n                        fontStyle = fontStyle | 1 /* FontStyle.Italic */;\n                        break;\n                    case 'bold':\n                        fontStyle = fontStyle | 2 /* FontStyle.Bold */;\n                        break;\n                    case 'underline':\n                        fontStyle = fontStyle | 4 /* FontStyle.Underline */;\n                        break;\n                    case 'strikethrough':\n                        fontStyle = fontStyle | 8 /* FontStyle.Strikethrough */;\n                        break;\n                }\n            }\n        }\n        let foreground = null;\n        if (typeof entry.foreground === 'string') {\n            foreground = entry.foreground;\n        }\n        let background = null;\n        if (typeof entry.background === 'string') {\n            background = entry.background;\n        }\n        result[resultLen++] = new ParsedTokenThemeRule(entry.token || '', i, fontStyle, foreground, background);\n    }\n    return result;\n}\n/**\n * Resolve rules (i.e. inheritance).\n */\nfunction resolveParsedTokenThemeRules(parsedThemeRules, customTokenColors) {\n    // Sort rules lexicographically, and then by index if necessary\n    parsedThemeRules.sort((a, b) => {\n        const r = strcmp(a.token, b.token);\n        if (r !== 0) {\n            return r;\n        }\n        return a.index - b.index;\n    });\n    // Determine defaults\n    let defaultFontStyle = 0 /* FontStyle.None */;\n    let defaultForeground = '000000';\n    let defaultBackground = 'ffffff';\n    while (parsedThemeRules.length >= 1 && parsedThemeRules[0].token === '') {\n        const incomingDefaults = parsedThemeRules.shift();\n        if (incomingDefaults.fontStyle !== -1 /* FontStyle.NotSet */) {\n            defaultFontStyle = incomingDefaults.fontStyle;\n        }\n        if (incomingDefaults.foreground !== null) {\n            defaultForeground = incomingDefaults.foreground;\n        }\n        if (incomingDefaults.background !== null) {\n            defaultBackground = incomingDefaults.background;\n        }\n    }\n    const colorMap = new ColorMap();\n    // start with token colors from custom token themes\n    for (const color of customTokenColors) {\n        colorMap.getId(color);\n    }\n    const foregroundColorId = colorMap.getId(defaultForeground);\n    const backgroundColorId = colorMap.getId(defaultBackground);\n    const defaults = new ThemeTrieElementRule(defaultFontStyle, foregroundColorId, backgroundColorId);\n    const root = new ThemeTrieElement(defaults);\n    for (let i = 0, len = parsedThemeRules.length; i < len; i++) {\n        const rule = parsedThemeRules[i];\n        root.insert(rule.token, rule.fontStyle, colorMap.getId(rule.foreground), colorMap.getId(rule.background));\n    }\n    return new TokenTheme(colorMap, root);\n}\nconst colorRegExp = /^#?([0-9A-Fa-f]{6})([0-9A-Fa-f]{2})?$/;\nexport class ColorMap {\n    constructor() {\n        this._lastColorId = 0;\n        this._id2color = [];\n        this._color2id = new Map();\n    }\n    getId(color) {\n        if (color === null) {\n            return 0;\n        }\n        const match = color.match(colorRegExp);\n        if (!match) {\n            throw new Error('Illegal value for token color: ' + color);\n        }\n        color = match[1].toUpperCase();\n        let value = this._color2id.get(color);\n        if (value) {\n            return value;\n        }\n        value = ++this._lastColorId;\n        this._color2id.set(color, value);\n        this._id2color[value] = Color.fromHex('#' + color);\n        return value;\n    }\n    getColorMap() {\n        return this._id2color.slice(0);\n    }\n}\nexport class TokenTheme {\n    static createFromRawTokenTheme(source, customTokenColors) {\n        return this.createFromParsedTokenTheme(parseTokenTheme(source), customTokenColors);\n    }\n    static createFromParsedTokenTheme(source, customTokenColors) {\n        return resolveParsedTokenThemeRules(source, customTokenColors);\n    }\n    constructor(colorMap, root) {\n        this._colorMap = colorMap;\n        this._root = root;\n        this._cache = new Map();\n    }\n    getColorMap() {\n        return this._colorMap.getColorMap();\n    }\n    _match(token) {\n        return this._root.match(token);\n    }\n    match(languageId, token) {\n        // The cache contains the metadata without the language bits set.\n        let result = this._cache.get(token);\n        if (typeof result === 'undefined') {\n            const rule = this._match(token);\n            const standardToken = toStandardTokenType(token);\n            result = (rule.metadata\n                | (standardToken << 8 /* MetadataConsts.TOKEN_TYPE_OFFSET */)) >>> 0;\n            this._cache.set(token, result);\n        }\n        return (result\n            | (languageId << 0 /* MetadataConsts.LANGUAGEID_OFFSET */)) >>> 0;\n    }\n}\nconst STANDARD_TOKEN_TYPE_REGEXP = /\\b(comment|string|regex|regexp)\\b/;\nexport function toStandardTokenType(tokenType) {\n    const m = tokenType.match(STANDARD_TOKEN_TYPE_REGEXP);\n    if (!m) {\n        return 0 /* StandardTokenType.Other */;\n    }\n    switch (m[1]) {\n        case 'comment':\n            return 1 /* StandardTokenType.Comment */;\n        case 'string':\n            return 2 /* StandardTokenType.String */;\n        case 'regex':\n            return 3 /* StandardTokenType.RegEx */;\n        case 'regexp':\n            return 3 /* StandardTokenType.RegEx */;\n    }\n    throw new Error('Unexpected match for standard token type!');\n}\nexport function strcmp(a, b) {\n    if (a < b) {\n        return -1;\n    }\n    if (a > b) {\n        return 1;\n    }\n    return 0;\n}\nexport class ThemeTrieElementRule {\n    constructor(fontStyle, foreground, background) {\n        this._themeTrieElementRuleBrand = undefined;\n        this._fontStyle = fontStyle;\n        this._foreground = foreground;\n        this._background = background;\n        this.metadata = ((this._fontStyle << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)\n            | (this._foreground << 15 /* MetadataConsts.FOREGROUND_OFFSET */)\n            | (this._background << 24 /* MetadataConsts.BACKGROUND_OFFSET */)) >>> 0;\n    }\n    clone() {\n        return new ThemeTrieElementRule(this._fontStyle, this._foreground, this._background);\n    }\n    acceptOverwrite(fontStyle, foreground, background) {\n        if (fontStyle !== -1 /* FontStyle.NotSet */) {\n            this._fontStyle = fontStyle;\n        }\n        if (foreground !== 0 /* ColorId.None */) {\n            this._foreground = foreground;\n        }\n        if (background !== 0 /* ColorId.None */) {\n            this._background = background;\n        }\n        this.metadata = ((this._fontStyle << 11 /* MetadataConsts.FONT_STYLE_OFFSET */)\n            | (this._foreground << 15 /* MetadataConsts.FOREGROUND_OFFSET */)\n            | (this._background << 24 /* MetadataConsts.BACKGROUND_OFFSET */)) >>> 0;\n    }\n}\nexport class ThemeTrieElement {\n    constructor(mainRule) {\n        this._themeTrieElementBrand = undefined;\n        this._mainRule = mainRule;\n        this._children = new Map();\n    }\n    match(token) {\n        if (token === '') {\n            return this._mainRule;\n        }\n        const dotIndex = token.indexOf('.');\n        let head;\n        let tail;\n        if (dotIndex === -1) {\n            head = token;\n            tail = '';\n        }\n        else {\n            head = token.substring(0, dotIndex);\n            tail = token.substring(dotIndex + 1);\n        }\n        const child = this._children.get(head);\n        if (typeof child !== 'undefined') {\n            return child.match(tail);\n        }\n        return this._mainRule;\n    }\n    insert(token, fontStyle, foreground, background) {\n        if (token === '') {\n            // Merge into the main rule\n            this._mainRule.acceptOverwrite(fontStyle, foreground, background);\n            return;\n        }\n        const dotIndex = token.indexOf('.');\n        let head;\n        let tail;\n        if (dotIndex === -1) {\n            head = token;\n            tail = '';\n        }\n        else {\n            head = token.substring(0, dotIndex);\n            tail = token.substring(dotIndex + 1);\n        }\n        let child = this._children.get(head);\n        if (typeof child === 'undefined') {\n            child = new ThemeTrieElement(this._mainRule.clone());\n            this._children.set(head, child);\n        }\n        child.insert(tail, fontStyle, foreground, background);\n    }\n}\nexport function generateTokensCSSForColorMap(colorMap) {\n    const rules = [];\n    for (let i = 1, len = colorMap.length; i < len; i++) {\n        const color = colorMap[i];\n        rules[i] = `.mtk${i} { color: ${color}; }`;\n    }\n    rules.push('.mtki { font-style: italic; }');\n    rules.push('.mtkb { font-weight: bold; }');\n    rules.push('.mtku { text-decoration: underline; text-underline-position: under; }');\n    rules.push('.mtks { text-decoration: line-through; }');\n    rules.push('.mtks.mtku { text-decoration: underline line-through; text-underline-position: under; }');\n    return rules.join('\\n');\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { LineTokens } from '../tokens/lineTokens.js';\nimport { TokenizationRegistry } from '../languages.js';\nimport { NullState, nullTokenizeEncoded } from './nullTokenize.js';\nconst fallback = {\n    getInitialState: () => NullState,\n    tokenizeEncoded: (buffer, hasEOL, state) => nullTokenizeEncoded(0 /* LanguageId.Null */, state)\n};\nexport async function tokenizeToString(languageService, text, languageId) {\n    if (!languageId) {\n        return _tokenizeToString(text, languageService.languageIdCodec, fallback);\n    }\n    const tokenizationSupport = await TokenizationRegistry.getOrCreate(languageId);\n    return _tokenizeToString(text, languageService.languageIdCodec, tokenizationSupport || fallback);\n}\nexport function tokenizeLineToHTML(text, viewLineTokens, colorMap, startOffset, endOffset, tabSize, useNbsp) {\n    let result = `<div>`;\n    let charIndex = startOffset;\n    let tabsCharDelta = 0;\n    let prevIsSpace = true;\n    for (let tokenIndex = 0, tokenCount = viewLineTokens.getCount(); tokenIndex < tokenCount; tokenIndex++) {\n        const tokenEndIndex = viewLineTokens.getEndOffset(tokenIndex);\n        if (tokenEndIndex <= startOffset) {\n            continue;\n        }\n        let partContent = '';\n        for (; charIndex < tokenEndIndex && charIndex < endOffset; charIndex++) {\n            const charCode = text.charCodeAt(charIndex);\n            switch (charCode) {\n                case 9 /* CharCode.Tab */: {\n                    let insertSpacesCount = tabSize - (charIndex + tabsCharDelta) % tabSize;\n                    tabsCharDelta += insertSpacesCount - 1;\n                    while (insertSpacesCount > 0) {\n                        if (useNbsp && prevIsSpace) {\n                            partContent += '&#160;';\n                            prevIsSpace = false;\n                        }\n                        else {\n                            partContent += ' ';\n                            prevIsSpace = true;\n                        }\n                        insertSpacesCount--;\n                    }\n                    break;\n                }\n                case 60 /* CharCode.LessThan */:\n                    partContent += '&lt;';\n                    prevIsSpace = false;\n                    break;\n                case 62 /* CharCode.GreaterThan */:\n                    partContent += '&gt;';\n                    prevIsSpace = false;\n                    break;\n                case 38 /* CharCode.Ampersand */:\n                    partContent += '&amp;';\n                    prevIsSpace = false;\n                    break;\n                case 0 /* CharCode.Null */:\n                    partContent += '&#00;';\n                    prevIsSpace = false;\n                    break;\n                case 65279 /* CharCode.UTF8_BOM */:\n                case 8232 /* CharCode.LINE_SEPARATOR */:\n                case 8233 /* CharCode.PARAGRAPH_SEPARATOR */:\n                case 133 /* CharCode.NEXT_LINE */:\n                    partContent += '\\ufffd';\n                    prevIsSpace = false;\n                    break;\n                case 13 /* CharCode.CarriageReturn */:\n                    // zero width space, because carriage return would introduce a line break\n                    partContent += '&#8203';\n                    prevIsSpace = false;\n                    break;\n                case 32 /* CharCode.Space */:\n                    if (useNbsp && prevIsSpace) {\n                        partContent += '&#160;';\n                        prevIsSpace = false;\n                    }\n                    else {\n                        partContent += ' ';\n                        prevIsSpace = true;\n                    }\n                    break;\n                default:\n                    partContent += String.fromCharCode(charCode);\n                    prevIsSpace = false;\n            }\n        }\n        result += `<span style=\"${viewLineTokens.getInlineStyle(tokenIndex, colorMap)}\">${partContent}</span>`;\n        if (tokenEndIndex > endOffset || charIndex >= endOffset) {\n            break;\n        }\n    }\n    result += `</div>`;\n    return result;\n}\nexport function _tokenizeToString(text, languageIdCodec, tokenizationSupport) {\n    let result = `<div class=\"monaco-tokenized-source\">`;\n    const lines = strings.splitLines(text);\n    let currentState = tokenizationSupport.getInitialState();\n    for (let i = 0, len = lines.length; i < len; i++) {\n        const line = lines[i];\n        if (i > 0) {\n            result += `<br/>`;\n        }\n        const tokenizationResult = tokenizationSupport.tokenizeEncoded(line, true, currentState);\n        LineTokens.convertToEndOffset(tokenizationResult.tokens, line.length);\n        const lineTokens = new LineTokens(tokenizationResult.tokens, line, languageIdCodec);\n        const viewLineTokens = lineTokens.inflate();\n        let startOffset = 0;\n        for (let j = 0, lenJ = viewLineTokens.getCount(); j < lenJ; j++) {\n            const type = viewLineTokens.getClassName(j);\n            const endIndex = viewLineTokens.getEndOffset(j);\n            result += `<span class=\"${type}\">${strings.escape(line.substring(startOffset, endIndex))}</span>`;\n            startOffset = endIndex;\n        }\n        currentState = tokenizationResult.endState;\n    }\n    result += `</div>`;\n    return result;\n}\n"],"names":["TokenMetadata","getLanguageId","metadata","getTokenType","containsBalancedBrackets","getFontStyle","getForeground","getBackground","getClassNameFromMetadata","className","this","fontStyle","getInlineStyleFromMetadata","colorMap","foreground","result","textDecoration","getPresentationFromMetadata","italic","Boolean","bold","underline","strikethrough","isExclusive","selector","Array","isArray","every","exclusive","MatchCandidate","constructor","uri","languageId","notebookUri","notebookType","equals","other","_a","_b","toString","LanguageFeatureRegistry","_notebookInfoResolver","_clock","_entries","_onDidChange","onDidChange","event","register","provider","entry","_score","_time","push","_lastCandidate","undefined","fire","length","idx","indexOf","splice","has","model","all","_updateScores","ordered","_orderedForEach","orderedGroups","lastBucket","lastBucketScore","callback","notebookInfo","call","candidate","type","sort","_compareByScoreAndTime","a","b","isBuiltinSelector","some","isBuiltin","score","candidateUri","candidateLanguage","candidateIsSynchronized","candidateNotebookUri","candidateNotebookType","ret","filter","value","language","pattern","scheme","hasAccessToAllModels","Math","max","normalizedPattern","base","fsPath","HoverVerbosityAction","CompletionItemKinds","InlineCompletionTriggerKind","DocumentPasteTriggerKind","SignatureHelpTriggerKind","DocumentHighlightKind","Token","offset","_tokenBrand","TokenizationResult","tokens","endState","_tokenizationResultBrand","EncodedTokenizationResult","_encodedTokenizationResultBrand","byKind","Map","set","toIcon","kind","codicon","get","console","info","data","fromString","strict","res","SelectedSuggestionInfo","range","text","completionKind","isSnippetText","equalsRange","isLocationLink","thing","originSelectionRange","targetSelectionRange","symbolKindNames","getAriaLabelForSymbol","symbolName","SymbolKinds","NewSymbolNameTag","NewSymbolNameTriggerKind","Command","InlayHintKind","icon","FoldingRangeKind","fromValue","Comment","Imports","Region","is","obj","id","title","LazyTokenizationSupport","createSupport","_tokenizationSupport","dispose","then","support","tokenizationSupport","TokenizationRegistry","InlineEditTriggerKind","getInheritIndentForLine","autoIndent","lineNumber","honorIntentialIndent","languageConfigurationService","indentRulesSupport","getLanguageConfiguration","tokenization","processedIndentRulesSupport","indentation","action","priorLineNumber","getLineContent","precedingUnIgnoredLine","getLanguageIdAtPosition","lastLineNumber","resultLineNumber","shouldIgnore","test","getPrecedingValidLine","shouldIncrease","shouldIndentNextLine","precedingUnIgnoredLineContent","Indent","line","shouldDecrease","previousLine","previousLineIndentMetadata","getIndentMetadata","stopLine","i","j","getGoodIndentForLine","virtualModel","indentConverter","richEditSupport","indent","inheritLine","shouldApplyEnterRules","inBetweenLine","enterResult","onEnter","removeText","substring","indentAction","shiftIndent","unshiftIndent","appendText","getIndentForEnter","startLineNumber","startColumn","forceTokenization","processedContextTokens","getProcessedTokenContextAroundRange","afterEnterProcessedTokens","afterRangeProcessedTokens","beforeEnterProcessedTokens","beforeRangeProcessedTokens","beforeEnterIndent","modifiedLineNumber","modifiedTokens","getLineTokens","column","createVirtualModelWithModifiedTokensAtLine","languageIsDifferentFromLineStart","getStartPosition","currentLine","currentLineIndent","afterEnterAction","beforeEnter","afterEnter","afterEnterIndent","getIndentActionForType","ch","beforeRangeText","afterRangeText","textAroundRange","textAroundRangeWithCharacter","r","getLineCount","_parseCaptureGroups","captureGroups","values","captureGroup","parsedNumber","Number","replace","_toIColor","g","red","blue","green","alpha","_findRange","match","index","startPosition","positionAt","endLineNumber","endColumn","_findHexColorInformation","hexValue","parsedHexColor","color","rgba","_findRGBColorInformation","matches","isAlpha","parsedRegex","_findHSLColorInformation","colorEquivalent","_findMatches","regex","matchAll","findMatches","computeDefaultDocumentColors","getValue","initialValidationMatches","initialMatch","initialCaptureGroups","colorScheme","colorParameters","colorInformation","regexParameters","computeColors","getEnterAction","previousLineText","previousLineProcessedTokens","beforeEnterText","afterEnterText","ILanguageService","IndentAction","StandardAutoClosingPairConditional","source","_neutralCharacter","_neutralCharacterSearched","open","close","_inString","_inComment","_inRegEx","notIn","len","isOK","standardToken","shouldAutoClose","context","getTokenCount","tokenIndex","findTokenIndexAtOffset","standardTokenType","getStandardTokenType","_findNeutralCharacterInRange","fromCharCode","toCharCode","charCode","character","String","includes","findNeutralCharacter","AutoClosingPairs","autoClosingPairs","autoClosingPairsOpenByStart","autoClosingPairsOpenByEnd","autoClosingPairsCloseByStart","autoClosingPairsCloseByEnd","autoClosingPairsCloseSingleChar","pair","appendEntry","charAt","target","key","CharacterPairSupport","config","_autoClosingPairs","map","el","brackets","__electricCharacterSupport","docComment","_autoCloseBeforeForQuotes","autoCloseBefore","DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_QUOTES","_autoCloseBeforeForBrackets","DEFAULT_AUTOCLOSE_BEFORE_LANGUAGE_DEFINED_BRACKETS","_surroundingPairs","surroundingPairs","getAutoClosingPairs","getAutoCloseBeforeSet","forQuotes","getSurroundingPairs","BracketElectricCharacterSupport","richEditBrackets","_richEditBrackets","getElectricCharacters","bracket","lastChar","onElectricCharacter","reversedBracketRegex","reversedRegex","bracketText","toLowerCase","textIsOpenBracket","textBeforeBracket","getActualLineContentBefore","matchOpenBracket","resetGlobalRegex","reg","global","lastIndex","IndentRulesSupport","indentationRules","_indentationRules","increaseIndentPattern","decreaseIndentPattern","indentNextLinePattern","unIndentedLinePattern","OnEnterSupport","opts","_brackets","forEach","openRegExp","_createOpenBracketRegExp","closeRegExp","_createCloseBracketRegExp","_regExpRules","onEnterRules","rule","beforeText","afterText","str","strings","_safeRegExp","def","RegExp","err","LanguageBracketsConfiguration","bracketPairs","filterValidBrackets","openingBracketInfos","closing","Set","OpeningBracketKind","closingBracketInfos","opening","openingColorized","ClosingBracketKind","add","colorizedBracketPairs","p","_openingBrackets","cachedValues","k","v","_closingBrackets","openingBrackets","closingBrackets","getOpeningBracketInfo","getClosingBracketInfo","getBracketInfo","getBracketRegExp","options","from","keys","BracketKindBase","openedBrackets","super","isOpeningBracket","openingColorizedBrackets","closes","closesColorized","getOpeningBrackets","__decorate","decorators","desc","d","c","arguments","Object","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","LanguageConfigurationServiceChangeEvent","affects","ILanguageConfigurationService","LanguageConfigurationService","configurationService","languageService","_registry","_register","LanguageConfigurationRegistry","onDidChangeEmitter","configurations","languageConfigKeys","customizedLanguageConfigKeys","onDidChangeConfiguration","e","globalConfigChanged","change","localConfigChanged","overrides","overrideLangName","clear","isRegisteredLanguageId","delete","configuration","priority","registry","languageConfig","ResolvedLanguageConfiguration","customizedConfig","overrideIdentifier","validateBracketPairs","getCustomizedLanguageConfig","combineLanguageConfigurations","underlyingConfig","computeConfig","getIndentationAtPosition","lineText","ComposedLanguageConfiguration","_resolved","_order","LanguageConfigurationContribution","getResolvedConfiguration","_resolve","cmp","configs","comments","wordPattern","folding","order","LanguageConfigurationChangeEvent","offSide","entries","disposable","_electricCharacter","_onEnterSupport","_handleComments","characterPair","wordDefinition","foldingRules","bracketsNew","getWordDefinition","electricCharacter","conf","commentRule","lineComment","lineCommentToken","blockComment","blockStart","blockEnd","blockCommentStartToken","blockCommentEndToken","Uint8Matrix","rows","cols","defaultValue","Uint8Array","_data","row","col","StateMachine","edges","maxCharCode","maxState","chCode","to","states","_states","_maxCharCode","nextState","currentState","_stateMachine","_classifier","LinkComputer","_createLink","classifier","linkBeginIndex","linkEndIndex","lastIncludedCharIndex","charCodeAt","charCodeBeforeLink","lastCharCodeInLink","url","computeLinks","stateMachine","getStateMachine","FORCE_TERMINATION_CHARACTERS","CANNOT_END_WITH_CHARACTERS","getClassifier","lineCount","linkBeginChCode","state","hasOpenParens","hasOpenSquareBracket","inSquareBrackets","hasOpenCurlyBracket","resetStateMachine","chClass","ModesRegistry","_onDidChangeLanguages","onDidChangeLanguages","_languages","registerLanguage","getLanguages","PLAINTEXT_LANGUAGE_ID","extensions","aliases","mimetypes","Configuration","registerDefaultConfigurations","NullState","clone","nullTokenize","nullTokenizeEncoded","Uint32Array","createScopedLineTokens","tokenCount","getCount","desiredLanguageId","lastTokenIndex","firstTokenIndex","ScopedLineTokens","getStartOffset","getEndOffset","actual","firstCharOffset","lastCharOffset","_scopedLineTokensBrand","_actual","_firstTokenIndex","_lastTokenIndex","_lastCharOffset","languageIdCodec","getLineLength","toIViewLineTokens","sliceAndInflate","ignoreBracketsInToken","ProcessedIndentRulesSupport","_indentRulesSupport","_indentationLineProcessor","IndentationLineProcessor","newIndentation","processedLine","getProcessedLine","IndentationContextProcessor","indentationLineProcessor","_getProcessedTokensBeforeRange","_getProcessedTokensAfterRange","_getProcessedPreviousLineTokens","lineTokens","scopedLineTokens","slicedTokens","isLanguageDifferentFromLineStart","columnIndexWithinScope","firstCharacterOffset","lastCharacterOffset","columnWithinLine","getProcessedTokens","position","isEmpty","getEndPosition","emptyTokens","previousLineNumber","scopedLineTokensAtEndColumnOfPreviousLine","endColumnOfLine","getLineMaxColumn","getScopedLineTokensAtEndColumnOfLine","previousSlicedLineTokens","currentIndentation","replaceIndentation","bracketsRegExp","textAndMetadata","tokenType","getTokenText","shouldRemoveBracketsFromTokenType","getMetadata","doesScopeStartAtOffsetZero","isScopedLanguageEqualToFirstLanguageOnLine","BasicInplaceReplace","_defaultValueSet","navigateValueSet","range1","text1","range2","text2","up","doNavigateValueSet","numberResult","numberReplace","textReplace","precision","pow","lastIndexOf","n1","n2","parseFloat","isNaN","floor","valueSetsReplace","valueSets","valueSetReplace","valueSet","INSTANCE","RichEditBracket","forwardRegex","_richEditBracketBrand","_openSet","_toSet","_closeSet","isOpen","isClose","arr","element","RichEditBrackets","_richEditBracketsBrand","N","group","areOverlapping","aOpen","aClose","bOpen","bClose","mergeGroups","g1","g2","newG","min","oldG","currentOpen","currentClose","groupFuzzyBrackets","currentIndex","pieces","concat","collectSuperstrings","unique","lengthcmp","reverse","createBracketOrRegExp","getRegexForBracketPair","toReversedString","getReversedRegexForBracketPair","getRegexForBrackets","getReversedRegexForBrackets","textIsBracket","maxBracketLength","dest","seen","prepareBracketForRegExp","insertWordBoundaries","regexStr","join","lastInput","lastOutput","Uint16Array","decode","BracketsUtils","_findPrevBracketInText","reversedText","m","matchOffset","matchLength","absoluteMatchOffset","findPrevBracketInRange","startOffset","endOffset","reversedSubstr","findNextBracketInText","bracketRegex","findNextBracketInRange","substr","ParsedTokenThemeRule","token","background","_parsedThemeRuleBrand","colorRegExp","ColorMap","_lastColorId","_id2color","_color2id","getId","Error","toUpperCase","getColorMap","slice","TokenTheme","createFromRawTokenTheme","customTokenColors","createFromParsedTokenTheme","resultLen","segments","split","lenJ","parseTokenTheme","parsedThemeRules","strcmp","defaultFontStyle","defaultForeground","defaultBackground","incomingDefaults","shift","foregroundColorId","backgroundColorId","defaults","ThemeTrieElementRule","root","ThemeTrieElement","insert","resolveParsedTokenThemeRules","_colorMap","_root","_cache","_match","STANDARD_TOKEN_TYPE_REGEXP","toStandardTokenType","_themeTrieElementRuleBrand","_fontStyle","_foreground","_background","acceptOverwrite","mainRule","_themeTrieElementBrand","_mainRule","_children","dotIndex","head","tail","child","generateTokensCSSForColorMap","rules","fallback","getInitialState","tokenizeEncoded","buffer","hasEOL","async","tokenizeToString","_tokenizeToString","tokenizeLineToHTML","viewLineTokens","tabSize","useNbsp","charIndex","tabsCharDelta","prevIsSpace","tokenEndIndex","partContent","insertSpacesCount","getInlineStyle","lines","tokenizationResult","inflate","getClassName","endIndex"],"sourceRoot":""}