{"version":3,"file":"static/js/8771_6dd119c7a4394047a69c.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/textModelBracketPairs.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/textModelEvents.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/textModelGuides.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/tokenizationRegistry.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/tokens/contiguousMultilineTokens.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/tokens/contiguousMultilineTokensBuilder.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/tokens/contiguousTokensEditing.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/tokens/contiguousTokensStore.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/tokens/lineTokens.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/tokens/sparseMultilineTokens.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/tokens/sparseTokensStore.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 *--------------------------------------------------------------------------------------------*/\nexport class BracketInfo {\n    constructor(range, \n    /** 0-based level */\n    nestingLevel, nestingLevelOfEqualBracketType, isInvalid) {\n        this.range = range;\n        this.nestingLevel = nestingLevel;\n        this.nestingLevelOfEqualBracketType = nestingLevelOfEqualBracketType;\n        this.isInvalid = isInvalid;\n    }\n}\nexport class BracketPairInfo {\n    constructor(range, openingBracketRange, closingBracketRange, \n    /** 0-based */\n    nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode) {\n        this.range = range;\n        this.openingBracketRange = openingBracketRange;\n        this.closingBracketRange = closingBracketRange;\n        this.nestingLevel = nestingLevel;\n        this.nestingLevelOfEqualBracketType = nestingLevelOfEqualBracketType;\n        this.bracketPairNode = bracketPairNode;\n    }\n    get openingBracketInfo() {\n        return this.bracketPairNode.openingBracket.bracketInfo;\n    }\n}\nexport class BracketPairWithMinIndentationInfo extends BracketPairInfo {\n    constructor(range, openingBracketRange, closingBracketRange, \n    /**\n     * 0-based\n    */\n    nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode, \n    /**\n     * -1 if not requested, otherwise the size of the minimum indentation in the bracket pair in terms of visible columns.\n    */\n    minVisibleColumnIndentation) {\n        super(range, openingBracketRange, closingBracketRange, nestingLevel, nestingLevelOfEqualBracketType, bracketPairNode);\n        this.minVisibleColumnIndentation = minVisibleColumnIndentation;\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 *--------------------------------------------------------------------------------------------*/\n/**\n * An event describing that a model has been reset to a new value.\n * @internal\n */\nexport class ModelRawFlush {\n    constructor() {\n        this.changeType = 1 /* RawContentChangedType.Flush */;\n    }\n}\n/**\n * Represents text injected on a line\n * @internal\n */\nexport class LineInjectedText {\n    static applyInjectedText(lineText, injectedTexts) {\n        if (!injectedTexts || injectedTexts.length === 0) {\n            return lineText;\n        }\n        let result = '';\n        let lastOriginalOffset = 0;\n        for (const injectedText of injectedTexts) {\n            result += lineText.substring(lastOriginalOffset, injectedText.column - 1);\n            lastOriginalOffset = injectedText.column - 1;\n            result += injectedText.options.content;\n        }\n        result += lineText.substring(lastOriginalOffset);\n        return result;\n    }\n    static fromDecorations(decorations) {\n        const result = [];\n        for (const decoration of decorations) {\n            if (decoration.options.before && decoration.options.before.content.length > 0) {\n                result.push(new LineInjectedText(decoration.ownerId, decoration.range.startLineNumber, decoration.range.startColumn, decoration.options.before, 0));\n            }\n            if (decoration.options.after && decoration.options.after.content.length > 0) {\n                result.push(new LineInjectedText(decoration.ownerId, decoration.range.endLineNumber, decoration.range.endColumn, decoration.options.after, 1));\n            }\n        }\n        result.sort((a, b) => {\n            if (a.lineNumber === b.lineNumber) {\n                if (a.column === b.column) {\n                    return a.order - b.order;\n                }\n                return a.column - b.column;\n            }\n            return a.lineNumber - b.lineNumber;\n        });\n        return result;\n    }\n    constructor(ownerId, lineNumber, column, options, order) {\n        this.ownerId = ownerId;\n        this.lineNumber = lineNumber;\n        this.column = column;\n        this.options = options;\n        this.order = order;\n    }\n}\n/**\n * An event describing that a line has changed in a model.\n * @internal\n */\nexport class ModelRawLineChanged {\n    constructor(lineNumber, detail, injectedText) {\n        this.changeType = 2 /* RawContentChangedType.LineChanged */;\n        this.lineNumber = lineNumber;\n        this.detail = detail;\n        this.injectedText = injectedText;\n    }\n}\n/**\n * An event describing that line(s) have been deleted in a model.\n * @internal\n */\nexport class ModelRawLinesDeleted {\n    constructor(fromLineNumber, toLineNumber) {\n        this.changeType = 3 /* RawContentChangedType.LinesDeleted */;\n        this.fromLineNumber = fromLineNumber;\n        this.toLineNumber = toLineNumber;\n    }\n}\n/**\n * An event describing that line(s) have been inserted in a model.\n * @internal\n */\nexport class ModelRawLinesInserted {\n    constructor(fromLineNumber, toLineNumber, detail, injectedTexts) {\n        this.changeType = 4 /* RawContentChangedType.LinesInserted */;\n        this.injectedTexts = injectedTexts;\n        this.fromLineNumber = fromLineNumber;\n        this.toLineNumber = toLineNumber;\n        this.detail = detail;\n    }\n}\n/**\n * An event describing that a model has had its EOL changed.\n * @internal\n */\nexport class ModelRawEOLChanged {\n    constructor() {\n        this.changeType = 5 /* RawContentChangedType.EOLChanged */;\n    }\n}\n/**\n * An event describing a change in the text of a model.\n * @internal\n */\nexport class ModelRawContentChangedEvent {\n    constructor(changes, versionId, isUndoing, isRedoing) {\n        this.changes = changes;\n        this.versionId = versionId;\n        this.isUndoing = isUndoing;\n        this.isRedoing = isRedoing;\n        this.resultingSelection = null;\n    }\n    containsEvent(type) {\n        for (let i = 0, len = this.changes.length; i < len; i++) {\n            const change = this.changes[i];\n            if (change.changeType === type) {\n                return true;\n            }\n        }\n        return false;\n    }\n    static merge(a, b) {\n        const changes = [].concat(a.changes).concat(b.changes);\n        const versionId = b.versionId;\n        const isUndoing = (a.isUndoing || b.isUndoing);\n        const isRedoing = (a.isRedoing || b.isRedoing);\n        return new ModelRawContentChangedEvent(changes, versionId, isUndoing, isRedoing);\n    }\n}\n/**\n * An event describing a change in injected text.\n * @internal\n */\nexport class ModelInjectedTextChangedEvent {\n    constructor(changes) {\n        this.changes = changes;\n    }\n}\n/**\n * @internal\n */\nexport class InternalModelContentChangeEvent {\n    constructor(rawContentChangedEvent, contentChangedEvent) {\n        this.rawContentChangedEvent = rawContentChangedEvent;\n        this.contentChangedEvent = contentChangedEvent;\n    }\n    merge(other) {\n        const rawContentChangedEvent = ModelRawContentChangedEvent.merge(this.rawContentChangedEvent, other.rawContentChangedEvent);\n        const contentChangedEvent = InternalModelContentChangeEvent._mergeChangeEvents(this.contentChangedEvent, other.contentChangedEvent);\n        return new InternalModelContentChangeEvent(rawContentChangedEvent, contentChangedEvent);\n    }\n    static _mergeChangeEvents(a, b) {\n        const changes = [].concat(a.changes).concat(b.changes);\n        const eol = b.eol;\n        const versionId = b.versionId;\n        const isUndoing = (a.isUndoing || b.isUndoing);\n        const isRedoing = (a.isRedoing || b.isRedoing);\n        const isFlush = (a.isFlush || b.isFlush);\n        const isEolChange = a.isEolChange && b.isEolChange; // both must be true to not confuse listeners who skip such edits\n        return {\n            changes: changes,\n            eol: eol,\n            isEolChange: isEolChange,\n            versionId: versionId,\n            isUndoing: isUndoing,\n            isRedoing: isRedoing,\n            isFlush: isFlush,\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 *--------------------------------------------------------------------------------------------*/\nexport var HorizontalGuidesState;\n(function (HorizontalGuidesState) {\n    HorizontalGuidesState[HorizontalGuidesState[\"Disabled\"] = 0] = \"Disabled\";\n    HorizontalGuidesState[HorizontalGuidesState[\"EnabledForActive\"] = 1] = \"EnabledForActive\";\n    HorizontalGuidesState[HorizontalGuidesState[\"Enabled\"] = 2] = \"Enabled\";\n})(HorizontalGuidesState || (HorizontalGuidesState = {}));\nexport class IndentGuide {\n    constructor(visibleColumn, column, className, \n    /**\n     * If set, this indent guide is a horizontal guide (no vertical part).\n     * It starts at visibleColumn and continues until endColumn.\n    */\n    horizontalLine, \n    /**\n     * If set (!= -1), only show this guide for wrapped lines that don't contain this model column, but are after it.\n    */\n    forWrappedLinesAfterColumn, forWrappedLinesBeforeOrAtColumn) {\n        this.visibleColumn = visibleColumn;\n        this.column = column;\n        this.className = className;\n        this.horizontalLine = horizontalLine;\n        this.forWrappedLinesAfterColumn = forWrappedLinesAfterColumn;\n        this.forWrappedLinesBeforeOrAtColumn = forWrappedLinesBeforeOrAtColumn;\n        if ((visibleColumn !== -1) === (column !== -1)) {\n            throw new Error();\n        }\n    }\n}\nexport class IndentGuideHorizontalLine {\n    constructor(top, endColumn) {\n        this.top = top;\n        this.endColumn = endColumn;\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 { Disposable, toDisposable } from '../../base/common/lifecycle.js';\nexport class TokenizationRegistry {\n    constructor() {\n        this._tokenizationSupports = new Map();\n        this._factories = new Map();\n        this._onDidChange = new Emitter();\n        this.onDidChange = this._onDidChange.event;\n        this._colorMap = null;\n    }\n    handleChange(languageIds) {\n        this._onDidChange.fire({\n            changedLanguages: languageIds,\n            changedColorMap: false\n        });\n    }\n    register(languageId, support) {\n        this._tokenizationSupports.set(languageId, support);\n        this.handleChange([languageId]);\n        return toDisposable(() => {\n            if (this._tokenizationSupports.get(languageId) !== support) {\n                return;\n            }\n            this._tokenizationSupports.delete(languageId);\n            this.handleChange([languageId]);\n        });\n    }\n    get(languageId) {\n        return this._tokenizationSupports.get(languageId) || null;\n    }\n    registerFactory(languageId, factory) {\n        var _a;\n        (_a = this._factories.get(languageId)) === null || _a === void 0 ? void 0 : _a.dispose();\n        const myData = new TokenizationSupportFactoryData(this, languageId, factory);\n        this._factories.set(languageId, myData);\n        return toDisposable(() => {\n            const v = this._factories.get(languageId);\n            if (!v || v !== myData) {\n                return;\n            }\n            this._factories.delete(languageId);\n            v.dispose();\n        });\n    }\n    async getOrCreate(languageId) {\n        // check first if the support is already set\n        const tokenizationSupport = this.get(languageId);\n        if (tokenizationSupport) {\n            return tokenizationSupport;\n        }\n        const factory = this._factories.get(languageId);\n        if (!factory || factory.isResolved) {\n            // no factory or factory.resolve already finished\n            return null;\n        }\n        await factory.resolve();\n        return this.get(languageId);\n    }\n    isResolved(languageId) {\n        const tokenizationSupport = this.get(languageId);\n        if (tokenizationSupport) {\n            return true;\n        }\n        const factory = this._factories.get(languageId);\n        if (!factory || factory.isResolved) {\n            return true;\n        }\n        return false;\n    }\n    setColorMap(colorMap) {\n        this._colorMap = colorMap;\n        this._onDidChange.fire({\n            changedLanguages: Array.from(this._tokenizationSupports.keys()),\n            changedColorMap: true\n        });\n    }\n    getColorMap() {\n        return this._colorMap;\n    }\n    getDefaultBackground() {\n        if (this._colorMap && this._colorMap.length > 2 /* ColorId.DefaultBackground */) {\n            return this._colorMap[2 /* ColorId.DefaultBackground */];\n        }\n        return null;\n    }\n}\nclass TokenizationSupportFactoryData extends Disposable {\n    get isResolved() {\n        return this._isResolved;\n    }\n    constructor(_registry, _languageId, _factory) {\n        super();\n        this._registry = _registry;\n        this._languageId = _languageId;\n        this._factory = _factory;\n        this._isDisposed = false;\n        this._resolvePromise = null;\n        this._isResolved = false;\n    }\n    dispose() {\n        this._isDisposed = true;\n        super.dispose();\n    }\n    async resolve() {\n        if (!this._resolvePromise) {\n            this._resolvePromise = this._create();\n        }\n        return this._resolvePromise;\n    }\n    async _create() {\n        const value = await this._factory.tokenizationSupport;\n        this._isResolved = true;\n        if (value && !this._isDisposed) {\n            this._register(this._registry.register(this._languageId, value));\n        }\n    }\n}\n","/**\n * Represents contiguous tokens over a contiguous range of lines.\n */\nexport class ContiguousMultilineTokens {\n    /**\n     * (Inclusive) start line number for these tokens.\n     */\n    get startLineNumber() {\n        return this._startLineNumber;\n    }\n    /**\n     * (Inclusive) end line number for these tokens.\n     */\n    get endLineNumber() {\n        return this._startLineNumber + this._tokens.length - 1;\n    }\n    constructor(startLineNumber, tokens) {\n        this._startLineNumber = startLineNumber;\n        this._tokens = tokens;\n    }\n    /**\n     * @see {@link _tokens}\n     */\n    getLineTokens(lineNumber) {\n        return this._tokens[lineNumber - this._startLineNumber];\n    }\n    appendLineTokens(lineTokens) {\n        this._tokens.push(lineTokens);\n    }\n}\n","import { ContiguousMultilineTokens } from './contiguousMultilineTokens.js';\nexport class ContiguousMultilineTokensBuilder {\n    constructor() {\n        this._tokens = [];\n    }\n    add(lineNumber, lineTokens) {\n        if (this._tokens.length > 0) {\n            const last = this._tokens[this._tokens.length - 1];\n            if (last.endLineNumber + 1 === lineNumber) {\n                // append\n                last.appendLineTokens(lineTokens);\n                return;\n            }\n        }\n        this._tokens.push(new ContiguousMultilineTokens(lineNumber, [lineTokens]));\n    }\n    finalize() {\n        return this._tokens;\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 { LineTokens } from './lineTokens.js';\nexport const EMPTY_LINE_TOKENS = (new Uint32Array(0)).buffer;\nexport class ContiguousTokensEditing {\n    static deleteBeginning(lineTokens, toChIndex) {\n        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {\n            return lineTokens;\n        }\n        return ContiguousTokensEditing.delete(lineTokens, 0, toChIndex);\n    }\n    static deleteEnding(lineTokens, fromChIndex) {\n        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {\n            return lineTokens;\n        }\n        const tokens = toUint32Array(lineTokens);\n        const lineTextLength = tokens[tokens.length - 2];\n        return ContiguousTokensEditing.delete(lineTokens, fromChIndex, lineTextLength);\n    }\n    static delete(lineTokens, fromChIndex, toChIndex) {\n        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS || fromChIndex === toChIndex) {\n            return lineTokens;\n        }\n        const tokens = toUint32Array(lineTokens);\n        const tokensCount = (tokens.length >>> 1);\n        // special case: deleting everything\n        if (fromChIndex === 0 && tokens[tokens.length - 2] === toChIndex) {\n            return EMPTY_LINE_TOKENS;\n        }\n        const fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, fromChIndex);\n        const fromTokenStartOffset = (fromTokenIndex > 0 ? tokens[(fromTokenIndex - 1) << 1] : 0);\n        const fromTokenEndOffset = tokens[fromTokenIndex << 1];\n        if (toChIndex < fromTokenEndOffset) {\n            // the delete range is inside a single token\n            const delta = (toChIndex - fromChIndex);\n            for (let i = fromTokenIndex; i < tokensCount; i++) {\n                tokens[i << 1] -= delta;\n            }\n            return lineTokens;\n        }\n        let dest;\n        let lastEnd;\n        if (fromTokenStartOffset !== fromChIndex) {\n            tokens[fromTokenIndex << 1] = fromChIndex;\n            dest = ((fromTokenIndex + 1) << 1);\n            lastEnd = fromChIndex;\n        }\n        else {\n            dest = (fromTokenIndex << 1);\n            lastEnd = fromTokenStartOffset;\n        }\n        const delta = (toChIndex - fromChIndex);\n        for (let tokenIndex = fromTokenIndex + 1; tokenIndex < tokensCount; tokenIndex++) {\n            const tokenEndOffset = tokens[tokenIndex << 1] - delta;\n            if (tokenEndOffset > lastEnd) {\n                tokens[dest++] = tokenEndOffset;\n                tokens[dest++] = tokens[(tokenIndex << 1) + 1];\n                lastEnd = tokenEndOffset;\n            }\n        }\n        if (dest === tokens.length) {\n            // nothing to trim\n            return lineTokens;\n        }\n        const tmp = new Uint32Array(dest);\n        tmp.set(tokens.subarray(0, dest), 0);\n        return tmp.buffer;\n    }\n    static append(lineTokens, _otherTokens) {\n        if (_otherTokens === EMPTY_LINE_TOKENS) {\n            return lineTokens;\n        }\n        if (lineTokens === EMPTY_LINE_TOKENS) {\n            return _otherTokens;\n        }\n        if (lineTokens === null) {\n            return lineTokens;\n        }\n        if (_otherTokens === null) {\n            // cannot determine combined line length...\n            return null;\n        }\n        const myTokens = toUint32Array(lineTokens);\n        const otherTokens = toUint32Array(_otherTokens);\n        const otherTokensCount = (otherTokens.length >>> 1);\n        const result = new Uint32Array(myTokens.length + otherTokens.length);\n        result.set(myTokens, 0);\n        let dest = myTokens.length;\n        const delta = myTokens[myTokens.length - 2];\n        for (let i = 0; i < otherTokensCount; i++) {\n            result[dest++] = otherTokens[(i << 1)] + delta;\n            result[dest++] = otherTokens[(i << 1) + 1];\n        }\n        return result.buffer;\n    }\n    static insert(lineTokens, chIndex, textLength) {\n        if (lineTokens === null || lineTokens === EMPTY_LINE_TOKENS) {\n            // nothing to do\n            return lineTokens;\n        }\n        const tokens = toUint32Array(lineTokens);\n        const tokensCount = (tokens.length >>> 1);\n        let fromTokenIndex = LineTokens.findIndexInTokensArray(tokens, chIndex);\n        if (fromTokenIndex > 0) {\n            const fromTokenStartOffset = tokens[(fromTokenIndex - 1) << 1];\n            if (fromTokenStartOffset === chIndex) {\n                fromTokenIndex--;\n            }\n        }\n        for (let tokenIndex = fromTokenIndex; tokenIndex < tokensCount; tokenIndex++) {\n            tokens[tokenIndex << 1] += textLength;\n        }\n        return lineTokens;\n    }\n}\nexport function toUint32Array(arr) {\n    if (arr instanceof Uint32Array) {\n        return arr;\n    }\n    else {\n        return new Uint32Array(arr);\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 arrays from '../../../base/common/arrays.js';\nimport { Position } from '../core/position.js';\nimport { ContiguousTokensEditing, EMPTY_LINE_TOKENS, toUint32Array } from './contiguousTokensEditing.js';\nimport { LineTokens } from './lineTokens.js';\nimport { TokenMetadata } from '../encodedTokenAttributes.js';\n/**\n * Represents contiguous tokens in a text model.\n */\nexport class ContiguousTokensStore {\n    constructor(languageIdCodec) {\n        this._lineTokens = [];\n        this._len = 0;\n        this._languageIdCodec = languageIdCodec;\n    }\n    flush() {\n        this._lineTokens = [];\n        this._len = 0;\n    }\n    get hasTokens() {\n        return this._lineTokens.length > 0;\n    }\n    getTokens(topLevelLanguageId, lineIndex, lineText) {\n        let rawLineTokens = null;\n        if (lineIndex < this._len) {\n            rawLineTokens = this._lineTokens[lineIndex];\n        }\n        if (rawLineTokens !== null && rawLineTokens !== EMPTY_LINE_TOKENS) {\n            return new LineTokens(toUint32Array(rawLineTokens), lineText, this._languageIdCodec);\n        }\n        const lineTokens = new Uint32Array(2);\n        lineTokens[0] = lineText.length;\n        lineTokens[1] = getDefaultMetadata(this._languageIdCodec.encodeLanguageId(topLevelLanguageId));\n        return new LineTokens(lineTokens, lineText, this._languageIdCodec);\n    }\n    static _massageTokens(topLevelLanguageId, lineTextLength, _tokens) {\n        const tokens = _tokens ? toUint32Array(_tokens) : null;\n        if (lineTextLength === 0) {\n            let hasDifferentLanguageId = false;\n            if (tokens && tokens.length > 1) {\n                hasDifferentLanguageId = (TokenMetadata.getLanguageId(tokens[1]) !== topLevelLanguageId);\n            }\n            if (!hasDifferentLanguageId) {\n                return EMPTY_LINE_TOKENS;\n            }\n        }\n        if (!tokens || tokens.length === 0) {\n            const tokens = new Uint32Array(2);\n            tokens[0] = lineTextLength;\n            tokens[1] = getDefaultMetadata(topLevelLanguageId);\n            return tokens.buffer;\n        }\n        // Ensure the last token covers the end of the text\n        tokens[tokens.length - 2] = lineTextLength;\n        if (tokens.byteOffset === 0 && tokens.byteLength === tokens.buffer.byteLength) {\n            // Store directly the ArrayBuffer pointer to save an object\n            return tokens.buffer;\n        }\n        return tokens;\n    }\n    _ensureLine(lineIndex) {\n        while (lineIndex >= this._len) {\n            this._lineTokens[this._len] = null;\n            this._len++;\n        }\n    }\n    _deleteLines(start, deleteCount) {\n        if (deleteCount === 0) {\n            return;\n        }\n        if (start + deleteCount > this._len) {\n            deleteCount = this._len - start;\n        }\n        this._lineTokens.splice(start, deleteCount);\n        this._len -= deleteCount;\n    }\n    _insertLines(insertIndex, insertCount) {\n        if (insertCount === 0) {\n            return;\n        }\n        const lineTokens = [];\n        for (let i = 0; i < insertCount; i++) {\n            lineTokens[i] = null;\n        }\n        this._lineTokens = arrays.arrayInsert(this._lineTokens, insertIndex, lineTokens);\n        this._len += insertCount;\n    }\n    setTokens(topLevelLanguageId, lineIndex, lineTextLength, _tokens, checkEquality) {\n        const tokens = ContiguousTokensStore._massageTokens(this._languageIdCodec.encodeLanguageId(topLevelLanguageId), lineTextLength, _tokens);\n        this._ensureLine(lineIndex);\n        const oldTokens = this._lineTokens[lineIndex];\n        this._lineTokens[lineIndex] = tokens;\n        if (checkEquality) {\n            return !ContiguousTokensStore._equals(oldTokens, tokens);\n        }\n        return false;\n    }\n    static _equals(_a, _b) {\n        if (!_a || !_b) {\n            return !_a && !_b;\n        }\n        const a = toUint32Array(_a);\n        const b = toUint32Array(_b);\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (let i = 0, len = a.length; i < len; i++) {\n            if (a[i] !== b[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n    //#region Editing\n    acceptEdit(range, eolCount, firstLineLength) {\n        this._acceptDeleteRange(range);\n        this._acceptInsertText(new Position(range.startLineNumber, range.startColumn), eolCount, firstLineLength);\n    }\n    _acceptDeleteRange(range) {\n        const firstLineIndex = range.startLineNumber - 1;\n        if (firstLineIndex >= this._len) {\n            return;\n        }\n        if (range.startLineNumber === range.endLineNumber) {\n            if (range.startColumn === range.endColumn) {\n                // Nothing to delete\n                return;\n            }\n            this._lineTokens[firstLineIndex] = ContiguousTokensEditing.delete(this._lineTokens[firstLineIndex], range.startColumn - 1, range.endColumn - 1);\n            return;\n        }\n        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[firstLineIndex], range.startColumn - 1);\n        const lastLineIndex = range.endLineNumber - 1;\n        let lastLineTokens = null;\n        if (lastLineIndex < this._len) {\n            lastLineTokens = ContiguousTokensEditing.deleteBeginning(this._lineTokens[lastLineIndex], range.endColumn - 1);\n        }\n        // Take remaining text on last line and append it to remaining text on first line\n        this._lineTokens[firstLineIndex] = ContiguousTokensEditing.append(this._lineTokens[firstLineIndex], lastLineTokens);\n        // Delete middle lines\n        this._deleteLines(range.startLineNumber, range.endLineNumber - range.startLineNumber);\n    }\n    _acceptInsertText(position, eolCount, firstLineLength) {\n        if (eolCount === 0 && firstLineLength === 0) {\n            // Nothing to insert\n            return;\n        }\n        const lineIndex = position.lineNumber - 1;\n        if (lineIndex >= this._len) {\n            return;\n        }\n        if (eolCount === 0) {\n            // Inserting text on one line\n            this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);\n            return;\n        }\n        this._lineTokens[lineIndex] = ContiguousTokensEditing.deleteEnding(this._lineTokens[lineIndex], position.column - 1);\n        this._lineTokens[lineIndex] = ContiguousTokensEditing.insert(this._lineTokens[lineIndex], position.column - 1, firstLineLength);\n        this._insertLines(position.lineNumber, eolCount);\n    }\n    //#endregion\n    setMultilineTokens(tokens, textModel) {\n        if (tokens.length === 0) {\n            return { changes: [] };\n        }\n        const ranges = [];\n        for (let i = 0, len = tokens.length; i < len; i++) {\n            const element = tokens[i];\n            let minChangedLineNumber = 0;\n            let maxChangedLineNumber = 0;\n            let hasChange = false;\n            for (let lineNumber = element.startLineNumber; lineNumber <= element.endLineNumber; lineNumber++) {\n                if (hasChange) {\n                    this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), false);\n                    maxChangedLineNumber = lineNumber;\n                }\n                else {\n                    const lineHasChange = this.setTokens(textModel.getLanguageId(), lineNumber - 1, textModel.getLineLength(lineNumber), element.getLineTokens(lineNumber), true);\n                    if (lineHasChange) {\n                        hasChange = true;\n                        minChangedLineNumber = lineNumber;\n                        maxChangedLineNumber = lineNumber;\n                    }\n                }\n            }\n            if (hasChange) {\n                ranges.push({ fromLineNumber: minChangedLineNumber, toLineNumber: maxChangedLineNumber, });\n            }\n        }\n        return { changes: ranges };\n    }\n}\nfunction getDefaultMetadata(topLevelLanguageId) {\n    return ((topLevelLanguageId << 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 */)\n        // If there is no grammar, we just take a guess and try to match brackets.\n        | (1024 /* MetadataConsts.BALANCED_BRACKETS_MASK */)) >>> 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 { TokenMetadata } from '../encodedTokenAttributes.js';\nexport class LineTokens {\n    static createEmpty(lineContent, decoder) {\n        const defaultMetadata = LineTokens.defaultTokenMetadata;\n        const tokens = new Uint32Array(2);\n        tokens[0] = lineContent.length;\n        tokens[1] = defaultMetadata;\n        return new LineTokens(tokens, lineContent, decoder);\n    }\n    static createFromTextAndMetadata(data, decoder) {\n        let offset = 0;\n        let fullText = '';\n        const tokens = new Array();\n        for (const { text, metadata } of data) {\n            tokens.push(offset + text.length, metadata);\n            offset += text.length;\n            fullText += text;\n        }\n        return new LineTokens(new Uint32Array(tokens), fullText, decoder);\n    }\n    constructor(tokens, text, decoder) {\n        this._lineTokensBrand = undefined;\n        this._tokens = tokens;\n        this._tokensCount = (this._tokens.length >>> 1);\n        this._text = text;\n        this.languageIdCodec = decoder;\n    }\n    equals(other) {\n        if (other instanceof LineTokens) {\n            return this.slicedEquals(other, 0, this._tokensCount);\n        }\n        return false;\n    }\n    slicedEquals(other, sliceFromTokenIndex, sliceTokenCount) {\n        if (this._text !== other._text) {\n            return false;\n        }\n        if (this._tokensCount !== other._tokensCount) {\n            return false;\n        }\n        const from = (sliceFromTokenIndex << 1);\n        const to = from + (sliceTokenCount << 1);\n        for (let i = from; i < to; i++) {\n            if (this._tokens[i] !== other._tokens[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n    getLineContent() {\n        return this._text;\n    }\n    getCount() {\n        return this._tokensCount;\n    }\n    getStartOffset(tokenIndex) {\n        if (tokenIndex > 0) {\n            return this._tokens[(tokenIndex - 1) << 1];\n        }\n        return 0;\n    }\n    getMetadata(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return metadata;\n    }\n    getLanguageId(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        const languageId = TokenMetadata.getLanguageId(metadata);\n        return this.languageIdCodec.decodeLanguageId(languageId);\n    }\n    getStandardTokenType(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return TokenMetadata.getTokenType(metadata);\n    }\n    getForeground(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return TokenMetadata.getForeground(metadata);\n    }\n    getClassName(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return TokenMetadata.getClassNameFromMetadata(metadata);\n    }\n    getInlineStyle(tokenIndex, colorMap) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return TokenMetadata.getInlineStyleFromMetadata(metadata, colorMap);\n    }\n    getPresentation(tokenIndex) {\n        const metadata = this._tokens[(tokenIndex << 1) + 1];\n        return TokenMetadata.getPresentationFromMetadata(metadata);\n    }\n    getEndOffset(tokenIndex) {\n        return this._tokens[tokenIndex << 1];\n    }\n    /**\n     * Find the token containing offset `offset`.\n     * @param offset The search offset\n     * @return The index of the token containing the offset.\n     */\n    findTokenIndexAtOffset(offset) {\n        return LineTokens.findIndexInTokensArray(this._tokens, offset);\n    }\n    inflate() {\n        return this;\n    }\n    sliceAndInflate(startOffset, endOffset, deltaOffset) {\n        return new SliceLineTokens(this, startOffset, endOffset, deltaOffset);\n    }\n    static convertToEndOffset(tokens, lineTextLength) {\n        const tokenCount = (tokens.length >>> 1);\n        const lastTokenIndex = tokenCount - 1;\n        for (let tokenIndex = 0; tokenIndex < lastTokenIndex; tokenIndex++) {\n            tokens[tokenIndex << 1] = tokens[(tokenIndex + 1) << 1];\n        }\n        tokens[lastTokenIndex << 1] = lineTextLength;\n    }\n    static findIndexInTokensArray(tokens, desiredIndex) {\n        if (tokens.length <= 2) {\n            return 0;\n        }\n        let low = 0;\n        let high = (tokens.length >>> 1) - 1;\n        while (low < high) {\n            const mid = low + Math.floor((high - low) / 2);\n            const endOffset = tokens[(mid << 1)];\n            if (endOffset === desiredIndex) {\n                return mid + 1;\n            }\n            else if (endOffset < desiredIndex) {\n                low = mid + 1;\n            }\n            else if (endOffset > desiredIndex) {\n                high = mid;\n            }\n        }\n        return low;\n    }\n    /**\n     * @pure\n     * @param insertTokens Must be sorted by offset.\n    */\n    withInserted(insertTokens) {\n        if (insertTokens.length === 0) {\n            return this;\n        }\n        let nextOriginalTokenIdx = 0;\n        let nextInsertTokenIdx = 0;\n        let text = '';\n        const newTokens = new Array();\n        let originalEndOffset = 0;\n        while (true) {\n            const nextOriginalTokenEndOffset = nextOriginalTokenIdx < this._tokensCount ? this._tokens[nextOriginalTokenIdx << 1] : -1;\n            const nextInsertToken = nextInsertTokenIdx < insertTokens.length ? insertTokens[nextInsertTokenIdx] : null;\n            if (nextOriginalTokenEndOffset !== -1 && (nextInsertToken === null || nextOriginalTokenEndOffset <= nextInsertToken.offset)) {\n                // original token ends before next insert token\n                text += this._text.substring(originalEndOffset, nextOriginalTokenEndOffset);\n                const metadata = this._tokens[(nextOriginalTokenIdx << 1) + 1];\n                newTokens.push(text.length, metadata);\n                nextOriginalTokenIdx++;\n                originalEndOffset = nextOriginalTokenEndOffset;\n            }\n            else if (nextInsertToken) {\n                if (nextInsertToken.offset > originalEndOffset) {\n                    // insert token is in the middle of the next token.\n                    text += this._text.substring(originalEndOffset, nextInsertToken.offset);\n                    const metadata = this._tokens[(nextOriginalTokenIdx << 1) + 1];\n                    newTokens.push(text.length, metadata);\n                    originalEndOffset = nextInsertToken.offset;\n                }\n                text += nextInsertToken.text;\n                newTokens.push(text.length, nextInsertToken.tokenMetadata);\n                nextInsertTokenIdx++;\n            }\n            else {\n                break;\n            }\n        }\n        return new LineTokens(new Uint32Array(newTokens), text, this.languageIdCodec);\n    }\n    getTokenText(tokenIndex) {\n        const startOffset = this.getStartOffset(tokenIndex);\n        const endOffset = this.getEndOffset(tokenIndex);\n        const text = this._text.substring(startOffset, endOffset);\n        return text;\n    }\n    forEach(callback) {\n        const tokenCount = this.getCount();\n        for (let tokenIndex = 0; tokenIndex < tokenCount; tokenIndex++) {\n            callback(tokenIndex);\n        }\n    }\n}\nLineTokens.defaultTokenMetadata = ((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;\nclass SliceLineTokens {\n    constructor(source, startOffset, endOffset, deltaOffset) {\n        this._source = source;\n        this._startOffset = startOffset;\n        this._endOffset = endOffset;\n        this._deltaOffset = deltaOffset;\n        this._firstTokenIndex = source.findTokenIndexAtOffset(startOffset);\n        this.languageIdCodec = source.languageIdCodec;\n        this._tokensCount = 0;\n        for (let i = this._firstTokenIndex, len = source.getCount(); i < len; i++) {\n            const tokenStartOffset = source.getStartOffset(i);\n            if (tokenStartOffset >= endOffset) {\n                break;\n            }\n            this._tokensCount++;\n        }\n    }\n    getMetadata(tokenIndex) {\n        return this._source.getMetadata(this._firstTokenIndex + tokenIndex);\n    }\n    getLanguageId(tokenIndex) {\n        return this._source.getLanguageId(this._firstTokenIndex + tokenIndex);\n    }\n    getLineContent() {\n        return this._source.getLineContent().substring(this._startOffset, this._endOffset);\n    }\n    equals(other) {\n        if (other instanceof SliceLineTokens) {\n            return (this._startOffset === other._startOffset\n                && this._endOffset === other._endOffset\n                && this._deltaOffset === other._deltaOffset\n                && this._source.slicedEquals(other._source, this._firstTokenIndex, this._tokensCount));\n        }\n        return false;\n    }\n    getCount() {\n        return this._tokensCount;\n    }\n    getStandardTokenType(tokenIndex) {\n        return this._source.getStandardTokenType(this._firstTokenIndex + tokenIndex);\n    }\n    getForeground(tokenIndex) {\n        return this._source.getForeground(this._firstTokenIndex + tokenIndex);\n    }\n    getEndOffset(tokenIndex) {\n        const tokenEndOffset = this._source.getEndOffset(this._firstTokenIndex + tokenIndex);\n        return Math.min(this._endOffset, tokenEndOffset) - this._startOffset + this._deltaOffset;\n    }\n    getClassName(tokenIndex) {\n        return this._source.getClassName(this._firstTokenIndex + tokenIndex);\n    }\n    getInlineStyle(tokenIndex, colorMap) {\n        return this._source.getInlineStyle(this._firstTokenIndex + tokenIndex, colorMap);\n    }\n    getPresentation(tokenIndex) {\n        return this._source.getPresentation(this._firstTokenIndex + tokenIndex);\n    }\n    findTokenIndexAtOffset(offset) {\n        return this._source.findTokenIndexAtOffset(offset + this._startOffset - this._deltaOffset) - this._firstTokenIndex;\n    }\n    getTokenText(tokenIndex) {\n        const adjustedTokenIndex = this._firstTokenIndex + tokenIndex;\n        const tokenStartOffset = this._source.getStartOffset(adjustedTokenIndex);\n        const tokenEndOffset = this._source.getEndOffset(adjustedTokenIndex);\n        let text = this._source.getTokenText(adjustedTokenIndex);\n        if (tokenStartOffset < this._startOffset) {\n            text = text.substring(this._startOffset - tokenStartOffset);\n        }\n        if (tokenEndOffset > this._endOffset) {\n            text = text.substring(0, text.length - (tokenEndOffset - this._endOffset));\n        }\n        return text;\n    }\n    forEach(callback) {\n        for (let tokenIndex = 0; tokenIndex < this.getCount(); tokenIndex++) {\n            callback(tokenIndex);\n        }\n    }\n}\nexport function getStandardTokenTypeAtPosition(model, position) {\n    const lineNumber = position.lineNumber;\n    if (!model.tokenization.isCheapToTokenize(lineNumber)) {\n        return undefined;\n    }\n    model.tokenization.forceTokenization(lineNumber);\n    const lineTokens = model.tokenization.getLineTokens(lineNumber);\n    const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n    const tokenType = lineTokens.getStandardTokenType(tokenIndex);\n    return tokenType;\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 { Position } from '../core/position.js';\nimport { Range } from '../core/range.js';\nimport { countEOL } from '../core/eolCounter.js';\n/**\n * Represents sparse tokens over a contiguous range of lines.\n */\nexport class SparseMultilineTokens {\n    static create(startLineNumber, tokens) {\n        return new SparseMultilineTokens(startLineNumber, new SparseMultilineTokensStorage(tokens));\n    }\n    /**\n     * (Inclusive) start line number for these tokens.\n     */\n    get startLineNumber() {\n        return this._startLineNumber;\n    }\n    /**\n     * (Inclusive) end line number for these tokens.\n     */\n    get endLineNumber() {\n        return this._endLineNumber;\n    }\n    constructor(startLineNumber, tokens) {\n        this._startLineNumber = startLineNumber;\n        this._tokens = tokens;\n        this._endLineNumber = this._startLineNumber + this._tokens.getMaxDeltaLine();\n    }\n    toString() {\n        return this._tokens.toString(this._startLineNumber);\n    }\n    _updateEndLineNumber() {\n        this._endLineNumber = this._startLineNumber + this._tokens.getMaxDeltaLine();\n    }\n    isEmpty() {\n        return this._tokens.isEmpty();\n    }\n    getLineTokens(lineNumber) {\n        if (this._startLineNumber <= lineNumber && lineNumber <= this._endLineNumber) {\n            return this._tokens.getLineTokens(lineNumber - this._startLineNumber);\n        }\n        return null;\n    }\n    getRange() {\n        const deltaRange = this._tokens.getRange();\n        if (!deltaRange) {\n            return deltaRange;\n        }\n        return new Range(this._startLineNumber + deltaRange.startLineNumber, deltaRange.startColumn, this._startLineNumber + deltaRange.endLineNumber, deltaRange.endColumn);\n    }\n    removeTokens(range) {\n        const startLineIndex = range.startLineNumber - this._startLineNumber;\n        const endLineIndex = range.endLineNumber - this._startLineNumber;\n        this._startLineNumber += this._tokens.removeTokens(startLineIndex, range.startColumn - 1, endLineIndex, range.endColumn - 1);\n        this._updateEndLineNumber();\n    }\n    split(range) {\n        // split tokens to two:\n        // a) all the tokens before `range`\n        // b) all the tokens after `range`\n        const startLineIndex = range.startLineNumber - this._startLineNumber;\n        const endLineIndex = range.endLineNumber - this._startLineNumber;\n        const [a, b, bDeltaLine] = this._tokens.split(startLineIndex, range.startColumn - 1, endLineIndex, range.endColumn - 1);\n        return [new SparseMultilineTokens(this._startLineNumber, a), new SparseMultilineTokens(this._startLineNumber + bDeltaLine, b)];\n    }\n    applyEdit(range, text) {\n        const [eolCount, firstLineLength, lastLineLength] = countEOL(text);\n        this.acceptEdit(range, eolCount, firstLineLength, lastLineLength, text.length > 0 ? text.charCodeAt(0) : 0 /* CharCode.Null */);\n    }\n    acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode) {\n        this._acceptDeleteRange(range);\n        this._acceptInsertText(new Position(range.startLineNumber, range.startColumn), eolCount, firstLineLength, lastLineLength, firstCharCode);\n        this._updateEndLineNumber();\n    }\n    _acceptDeleteRange(range) {\n        if (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn) {\n            // Nothing to delete\n            return;\n        }\n        const firstLineIndex = range.startLineNumber - this._startLineNumber;\n        const lastLineIndex = range.endLineNumber - this._startLineNumber;\n        if (lastLineIndex < 0) {\n            // this deletion occurs entirely before this block, so we only need to adjust line numbers\n            const deletedLinesCount = lastLineIndex - firstLineIndex;\n            this._startLineNumber -= deletedLinesCount;\n            return;\n        }\n        const tokenMaxDeltaLine = this._tokens.getMaxDeltaLine();\n        if (firstLineIndex >= tokenMaxDeltaLine + 1) {\n            // this deletion occurs entirely after this block, so there is nothing to do\n            return;\n        }\n        if (firstLineIndex < 0 && lastLineIndex >= tokenMaxDeltaLine + 1) {\n            // this deletion completely encompasses this block\n            this._startLineNumber = 0;\n            this._tokens.clear();\n            return;\n        }\n        if (firstLineIndex < 0) {\n            const deletedBefore = -firstLineIndex;\n            this._startLineNumber -= deletedBefore;\n            this._tokens.acceptDeleteRange(range.startColumn - 1, 0, 0, lastLineIndex, range.endColumn - 1);\n        }\n        else {\n            this._tokens.acceptDeleteRange(0, firstLineIndex, range.startColumn - 1, lastLineIndex, range.endColumn - 1);\n        }\n    }\n    _acceptInsertText(position, eolCount, firstLineLength, lastLineLength, firstCharCode) {\n        if (eolCount === 0 && firstLineLength === 0) {\n            // Nothing to insert\n            return;\n        }\n        const lineIndex = position.lineNumber - this._startLineNumber;\n        if (lineIndex < 0) {\n            // this insertion occurs before this block, so we only need to adjust line numbers\n            this._startLineNumber += eolCount;\n            return;\n        }\n        const tokenMaxDeltaLine = this._tokens.getMaxDeltaLine();\n        if (lineIndex >= tokenMaxDeltaLine + 1) {\n            // this insertion occurs after this block, so there is nothing to do\n            return;\n        }\n        this._tokens.acceptInsertText(lineIndex, position.column - 1, eolCount, firstLineLength, lastLineLength, firstCharCode);\n    }\n}\nclass SparseMultilineTokensStorage {\n    constructor(tokens) {\n        this._tokens = tokens;\n        this._tokenCount = tokens.length / 4;\n    }\n    toString(startLineNumber) {\n        const pieces = [];\n        for (let i = 0; i < this._tokenCount; i++) {\n            pieces.push(`(${this._getDeltaLine(i) + startLineNumber},${this._getStartCharacter(i)}-${this._getEndCharacter(i)})`);\n        }\n        return `[${pieces.join(',')}]`;\n    }\n    getMaxDeltaLine() {\n        const tokenCount = this._getTokenCount();\n        if (tokenCount === 0) {\n            return -1;\n        }\n        return this._getDeltaLine(tokenCount - 1);\n    }\n    getRange() {\n        const tokenCount = this._getTokenCount();\n        if (tokenCount === 0) {\n            return null;\n        }\n        const startChar = this._getStartCharacter(0);\n        const maxDeltaLine = this._getDeltaLine(tokenCount - 1);\n        const endChar = this._getEndCharacter(tokenCount - 1);\n        return new Range(0, startChar + 1, maxDeltaLine, endChar + 1);\n    }\n    _getTokenCount() {\n        return this._tokenCount;\n    }\n    _getDeltaLine(tokenIndex) {\n        return this._tokens[4 * tokenIndex];\n    }\n    _getStartCharacter(tokenIndex) {\n        return this._tokens[4 * tokenIndex + 1];\n    }\n    _getEndCharacter(tokenIndex) {\n        return this._tokens[4 * tokenIndex + 2];\n    }\n    isEmpty() {\n        return (this._getTokenCount() === 0);\n    }\n    getLineTokens(deltaLine) {\n        let low = 0;\n        let high = this._getTokenCount() - 1;\n        while (low < high) {\n            const mid = low + Math.floor((high - low) / 2);\n            const midDeltaLine = this._getDeltaLine(mid);\n            if (midDeltaLine < deltaLine) {\n                low = mid + 1;\n            }\n            else if (midDeltaLine > deltaLine) {\n                high = mid - 1;\n            }\n            else {\n                let min = mid;\n                while (min > low && this._getDeltaLine(min - 1) === deltaLine) {\n                    min--;\n                }\n                let max = mid;\n                while (max < high && this._getDeltaLine(max + 1) === deltaLine) {\n                    max++;\n                }\n                return new SparseLineTokens(this._tokens.subarray(4 * min, 4 * max + 4));\n            }\n        }\n        if (this._getDeltaLine(low) === deltaLine) {\n            return new SparseLineTokens(this._tokens.subarray(4 * low, 4 * low + 4));\n        }\n        return null;\n    }\n    clear() {\n        this._tokenCount = 0;\n    }\n    removeTokens(startDeltaLine, startChar, endDeltaLine, endChar) {\n        const tokens = this._tokens;\n        const tokenCount = this._tokenCount;\n        let newTokenCount = 0;\n        let hasDeletedTokens = false;\n        let firstDeltaLine = 0;\n        for (let i = 0; i < tokenCount; i++) {\n            const srcOffset = 4 * i;\n            const tokenDeltaLine = tokens[srcOffset];\n            const tokenStartCharacter = tokens[srcOffset + 1];\n            const tokenEndCharacter = tokens[srcOffset + 2];\n            const tokenMetadata = tokens[srcOffset + 3];\n            if ((tokenDeltaLine > startDeltaLine || (tokenDeltaLine === startDeltaLine && tokenEndCharacter >= startChar))\n                && (tokenDeltaLine < endDeltaLine || (tokenDeltaLine === endDeltaLine && tokenStartCharacter <= endChar))) {\n                hasDeletedTokens = true;\n            }\n            else {\n                if (newTokenCount === 0) {\n                    firstDeltaLine = tokenDeltaLine;\n                }\n                if (hasDeletedTokens) {\n                    // must move the token to the left\n                    const destOffset = 4 * newTokenCount;\n                    tokens[destOffset] = tokenDeltaLine - firstDeltaLine;\n                    tokens[destOffset + 1] = tokenStartCharacter;\n                    tokens[destOffset + 2] = tokenEndCharacter;\n                    tokens[destOffset + 3] = tokenMetadata;\n                }\n                newTokenCount++;\n            }\n        }\n        this._tokenCount = newTokenCount;\n        return firstDeltaLine;\n    }\n    split(startDeltaLine, startChar, endDeltaLine, endChar) {\n        const tokens = this._tokens;\n        const tokenCount = this._tokenCount;\n        const aTokens = [];\n        const bTokens = [];\n        let destTokens = aTokens;\n        let destOffset = 0;\n        let destFirstDeltaLine = 0;\n        for (let i = 0; i < tokenCount; i++) {\n            const srcOffset = 4 * i;\n            const tokenDeltaLine = tokens[srcOffset];\n            const tokenStartCharacter = tokens[srcOffset + 1];\n            const tokenEndCharacter = tokens[srcOffset + 2];\n            const tokenMetadata = tokens[srcOffset + 3];\n            if ((tokenDeltaLine > startDeltaLine || (tokenDeltaLine === startDeltaLine && tokenEndCharacter >= startChar))) {\n                if ((tokenDeltaLine < endDeltaLine || (tokenDeltaLine === endDeltaLine && tokenStartCharacter <= endChar))) {\n                    // this token is touching the range\n                    continue;\n                }\n                else {\n                    // this token is after the range\n                    if (destTokens !== bTokens) {\n                        // this token is the first token after the range\n                        destTokens = bTokens;\n                        destOffset = 0;\n                        destFirstDeltaLine = tokenDeltaLine;\n                    }\n                }\n            }\n            destTokens[destOffset++] = tokenDeltaLine - destFirstDeltaLine;\n            destTokens[destOffset++] = tokenStartCharacter;\n            destTokens[destOffset++] = tokenEndCharacter;\n            destTokens[destOffset++] = tokenMetadata;\n        }\n        return [new SparseMultilineTokensStorage(new Uint32Array(aTokens)), new SparseMultilineTokensStorage(new Uint32Array(bTokens)), destFirstDeltaLine];\n    }\n    acceptDeleteRange(horizontalShiftForFirstLineTokens, startDeltaLine, startCharacter, endDeltaLine, endCharacter) {\n        // This is a bit complex, here are the cases I used to think about this:\n        //\n        // 1. The token starts before the deletion range\n        // 1a. The token is completely before the deletion range\n        //               -----------\n        //                          xxxxxxxxxxx\n        // 1b. The token starts before, the deletion range ends after the token\n        //               -----------\n        //                      xxxxxxxxxxx\n        // 1c. The token starts before, the deletion range ends precisely with the token\n        //               ---------------\n        //                      xxxxxxxx\n        // 1d. The token starts before, the deletion range is inside the token\n        //               ---------------\n        //                    xxxxx\n        //\n        // 2. The token starts at the same position with the deletion range\n        // 2a. The token starts at the same position, and ends inside the deletion range\n        //               -------\n        //               xxxxxxxxxxx\n        // 2b. The token starts at the same position, and ends at the same position as the deletion range\n        //               ----------\n        //               xxxxxxxxxx\n        // 2c. The token starts at the same position, and ends after the deletion range\n        //               -------------\n        //               xxxxxxx\n        //\n        // 3. The token starts inside the deletion range\n        // 3a. The token is inside the deletion range\n        //                -------\n        //             xxxxxxxxxxxxx\n        // 3b. The token starts inside the deletion range, and ends at the same position as the deletion range\n        //                ----------\n        //             xxxxxxxxxxxxx\n        // 3c. The token starts inside the deletion range, and ends after the deletion range\n        //                ------------\n        //             xxxxxxxxxxx\n        //\n        // 4. The token starts after the deletion range\n        //                  -----------\n        //          xxxxxxxx\n        //\n        const tokens = this._tokens;\n        const tokenCount = this._tokenCount;\n        const deletedLineCount = (endDeltaLine - startDeltaLine);\n        let newTokenCount = 0;\n        let hasDeletedTokens = false;\n        for (let i = 0; i < tokenCount; i++) {\n            const srcOffset = 4 * i;\n            let tokenDeltaLine = tokens[srcOffset];\n            let tokenStartCharacter = tokens[srcOffset + 1];\n            let tokenEndCharacter = tokens[srcOffset + 2];\n            const tokenMetadata = tokens[srcOffset + 3];\n            if (tokenDeltaLine < startDeltaLine || (tokenDeltaLine === startDeltaLine && tokenEndCharacter <= startCharacter)) {\n                // 1a. The token is completely before the deletion range\n                // => nothing to do\n                newTokenCount++;\n                continue;\n            }\n            else if (tokenDeltaLine === startDeltaLine && tokenStartCharacter < startCharacter) {\n                // 1b, 1c, 1d\n                // => the token survives, but it needs to shrink\n                if (tokenDeltaLine === endDeltaLine && tokenEndCharacter > endCharacter) {\n                    // 1d. The token starts before, the deletion range is inside the token\n                    // => the token shrinks by the deletion character count\n                    tokenEndCharacter -= (endCharacter - startCharacter);\n                }\n                else {\n                    // 1b. The token starts before, the deletion range ends after the token\n                    // 1c. The token starts before, the deletion range ends precisely with the token\n                    // => the token shrinks its ending to the deletion start\n                    tokenEndCharacter = startCharacter;\n                }\n            }\n            else if (tokenDeltaLine === startDeltaLine && tokenStartCharacter === startCharacter) {\n                // 2a, 2b, 2c\n                if (tokenDeltaLine === endDeltaLine && tokenEndCharacter > endCharacter) {\n                    // 2c. The token starts at the same position, and ends after the deletion range\n                    // => the token shrinks by the deletion character count\n                    tokenEndCharacter -= (endCharacter - startCharacter);\n                }\n                else {\n                    // 2a. The token starts at the same position, and ends inside the deletion range\n                    // 2b. The token starts at the same position, and ends at the same position as the deletion range\n                    // => the token is deleted\n                    hasDeletedTokens = true;\n                    continue;\n                }\n            }\n            else if (tokenDeltaLine < endDeltaLine || (tokenDeltaLine === endDeltaLine && tokenStartCharacter < endCharacter)) {\n                // 3a, 3b, 3c\n                if (tokenDeltaLine === endDeltaLine && tokenEndCharacter > endCharacter) {\n                    // 3c. The token starts inside the deletion range, and ends after the deletion range\n                    // => the token moves to continue right after the deletion\n                    tokenDeltaLine = startDeltaLine;\n                    tokenStartCharacter = startCharacter;\n                    tokenEndCharacter = tokenStartCharacter + (tokenEndCharacter - endCharacter);\n                }\n                else {\n                    // 3a. The token is inside the deletion range\n                    // 3b. The token starts inside the deletion range, and ends at the same position as the deletion range\n                    // => the token is deleted\n                    hasDeletedTokens = true;\n                    continue;\n                }\n            }\n            else if (tokenDeltaLine > endDeltaLine) {\n                // 4. (partial) The token starts after the deletion range, on a line below...\n                if (deletedLineCount === 0 && !hasDeletedTokens) {\n                    // early stop, there is no need to walk all the tokens and do nothing...\n                    newTokenCount = tokenCount;\n                    break;\n                }\n                tokenDeltaLine -= deletedLineCount;\n            }\n            else if (tokenDeltaLine === endDeltaLine && tokenStartCharacter >= endCharacter) {\n                // 4. (continued) The token starts after the deletion range, on the last line where a deletion occurs\n                if (horizontalShiftForFirstLineTokens && tokenDeltaLine === 0) {\n                    tokenStartCharacter += horizontalShiftForFirstLineTokens;\n                    tokenEndCharacter += horizontalShiftForFirstLineTokens;\n                }\n                tokenDeltaLine -= deletedLineCount;\n                tokenStartCharacter -= (endCharacter - startCharacter);\n                tokenEndCharacter -= (endCharacter - startCharacter);\n            }\n            else {\n                throw new Error(`Not possible!`);\n            }\n            const destOffset = 4 * newTokenCount;\n            tokens[destOffset] = tokenDeltaLine;\n            tokens[destOffset + 1] = tokenStartCharacter;\n            tokens[destOffset + 2] = tokenEndCharacter;\n            tokens[destOffset + 3] = tokenMetadata;\n            newTokenCount++;\n        }\n        this._tokenCount = newTokenCount;\n    }\n    acceptInsertText(deltaLine, character, eolCount, firstLineLength, lastLineLength, firstCharCode) {\n        // Here are the cases I used to think about this:\n        //\n        // 1. The token is completely before the insertion point\n        //            -----------   |\n        // 2. The token ends precisely at the insertion point\n        //            -----------|\n        // 3. The token contains the insertion point\n        //            -----|------\n        // 4. The token starts precisely at the insertion point\n        //            |-----------\n        // 5. The token is completely after the insertion point\n        //            |   -----------\n        //\n        const isInsertingPreciselyOneWordCharacter = (eolCount === 0\n            && firstLineLength === 1\n            && ((firstCharCode >= 48 /* CharCode.Digit0 */ && firstCharCode <= 57 /* CharCode.Digit9 */)\n                || (firstCharCode >= 65 /* CharCode.A */ && firstCharCode <= 90 /* CharCode.Z */)\n                || (firstCharCode >= 97 /* CharCode.a */ && firstCharCode <= 122 /* CharCode.z */)));\n        const tokens = this._tokens;\n        const tokenCount = this._tokenCount;\n        for (let i = 0; i < tokenCount; i++) {\n            const offset = 4 * i;\n            let tokenDeltaLine = tokens[offset];\n            let tokenStartCharacter = tokens[offset + 1];\n            let tokenEndCharacter = tokens[offset + 2];\n            if (tokenDeltaLine < deltaLine || (tokenDeltaLine === deltaLine && tokenEndCharacter < character)) {\n                // 1. The token is completely before the insertion point\n                // => nothing to do\n                continue;\n            }\n            else if (tokenDeltaLine === deltaLine && tokenEndCharacter === character) {\n                // 2. The token ends precisely at the insertion point\n                // => expand the end character only if inserting precisely one character that is a word character\n                if (isInsertingPreciselyOneWordCharacter) {\n                    tokenEndCharacter += 1;\n                }\n                else {\n                    continue;\n                }\n            }\n            else if (tokenDeltaLine === deltaLine && tokenStartCharacter < character && character < tokenEndCharacter) {\n                // 3. The token contains the insertion point\n                if (eolCount === 0) {\n                    // => just expand the end character\n                    tokenEndCharacter += firstLineLength;\n                }\n                else {\n                    // => cut off the token\n                    tokenEndCharacter = character;\n                }\n            }\n            else {\n                // 4. or 5.\n                if (tokenDeltaLine === deltaLine && tokenStartCharacter === character) {\n                    // 4. The token starts precisely at the insertion point\n                    // => grow the token (by keeping its start constant) only if inserting precisely one character that is a word character\n                    // => otherwise behave as in case 5.\n                    if (isInsertingPreciselyOneWordCharacter) {\n                        continue;\n                    }\n                }\n                // => the token must move and keep its size constant\n                if (tokenDeltaLine === deltaLine) {\n                    tokenDeltaLine += eolCount;\n                    // this token is on the line where the insertion is taking place\n                    if (eolCount === 0) {\n                        tokenStartCharacter += firstLineLength;\n                        tokenEndCharacter += firstLineLength;\n                    }\n                    else {\n                        const tokenLength = tokenEndCharacter - tokenStartCharacter;\n                        tokenStartCharacter = lastLineLength + (tokenStartCharacter - character);\n                        tokenEndCharacter = tokenStartCharacter + tokenLength;\n                    }\n                }\n                else {\n                    tokenDeltaLine += eolCount;\n                }\n            }\n            tokens[offset] = tokenDeltaLine;\n            tokens[offset + 1] = tokenStartCharacter;\n            tokens[offset + 2] = tokenEndCharacter;\n        }\n    }\n}\nexport class SparseLineTokens {\n    constructor(tokens) {\n        this._tokens = tokens;\n    }\n    getCount() {\n        return this._tokens.length / 4;\n    }\n    getStartCharacter(tokenIndex) {\n        return this._tokens[4 * tokenIndex + 1];\n    }\n    getEndCharacter(tokenIndex) {\n        return this._tokens[4 * tokenIndex + 2];\n    }\n    getMetadata(tokenIndex) {\n        return this._tokens[4 * tokenIndex + 3];\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 arrays from '../../../base/common/arrays.js';\nimport { LineTokens } from './lineTokens.js';\n/**\n * Represents sparse tokens in a text model.\n */\nexport class SparseTokensStore {\n    constructor(languageIdCodec) {\n        this._pieces = [];\n        this._isComplete = false;\n        this._languageIdCodec = languageIdCodec;\n    }\n    flush() {\n        this._pieces = [];\n        this._isComplete = false;\n    }\n    isEmpty() {\n        return (this._pieces.length === 0);\n    }\n    set(pieces, isComplete) {\n        this._pieces = pieces || [];\n        this._isComplete = isComplete;\n    }\n    setPartial(_range, pieces) {\n        // console.log(`setPartial ${_range} ${pieces.map(p => p.toString()).join(', ')}`);\n        let range = _range;\n        if (pieces.length > 0) {\n            const _firstRange = pieces[0].getRange();\n            const _lastRange = pieces[pieces.length - 1].getRange();\n            if (!_firstRange || !_lastRange) {\n                return _range;\n            }\n            range = _range.plusRange(_firstRange).plusRange(_lastRange);\n        }\n        let insertPosition = null;\n        for (let i = 0, len = this._pieces.length; i < len; i++) {\n            const piece = this._pieces[i];\n            if (piece.endLineNumber < range.startLineNumber) {\n                // this piece is before the range\n                continue;\n            }\n            if (piece.startLineNumber > range.endLineNumber) {\n                // this piece is after the range, so mark the spot before this piece\n                // as a good insertion position and stop looping\n                insertPosition = insertPosition || { index: i };\n                break;\n            }\n            // this piece might intersect with the range\n            piece.removeTokens(range);\n            if (piece.isEmpty()) {\n                // remove the piece if it became empty\n                this._pieces.splice(i, 1);\n                i--;\n                len--;\n                continue;\n            }\n            if (piece.endLineNumber < range.startLineNumber) {\n                // after removal, this piece is before the range\n                continue;\n            }\n            if (piece.startLineNumber > range.endLineNumber) {\n                // after removal, this piece is after the range\n                insertPosition = insertPosition || { index: i };\n                continue;\n            }\n            // after removal, this piece contains the range\n            const [a, b] = piece.split(range);\n            if (a.isEmpty()) {\n                // this piece is actually after the range\n                insertPosition = insertPosition || { index: i };\n                continue;\n            }\n            if (b.isEmpty()) {\n                // this piece is actually before the range\n                continue;\n            }\n            this._pieces.splice(i, 1, a, b);\n            i++;\n            len++;\n            insertPosition = insertPosition || { index: i };\n        }\n        insertPosition = insertPosition || { index: this._pieces.length };\n        if (pieces.length > 0) {\n            this._pieces = arrays.arrayInsert(this._pieces, insertPosition.index, pieces);\n        }\n        // console.log(`I HAVE ${this._pieces.length} pieces`);\n        // console.log(`${this._pieces.map(p => p.toString()).join('\\n')}`);\n        return range;\n    }\n    isComplete() {\n        return this._isComplete;\n    }\n    addSparseTokens(lineNumber, aTokens) {\n        if (aTokens.getLineContent().length === 0) {\n            // Don't do anything for empty lines\n            return aTokens;\n        }\n        const pieces = this._pieces;\n        if (pieces.length === 0) {\n            return aTokens;\n        }\n        const pieceIndex = SparseTokensStore._findFirstPieceWithLine(pieces, lineNumber);\n        const bTokens = pieces[pieceIndex].getLineTokens(lineNumber);\n        if (!bTokens) {\n            return aTokens;\n        }\n        const aLen = aTokens.getCount();\n        const bLen = bTokens.getCount();\n        let aIndex = 0;\n        const result = [];\n        let resultLen = 0;\n        let lastEndOffset = 0;\n        const emitToken = (endOffset, metadata) => {\n            if (endOffset === lastEndOffset) {\n                return;\n            }\n            lastEndOffset = endOffset;\n            result[resultLen++] = endOffset;\n            result[resultLen++] = metadata;\n        };\n        for (let bIndex = 0; bIndex < bLen; bIndex++) {\n            const bStartCharacter = bTokens.getStartCharacter(bIndex);\n            const bEndCharacter = bTokens.getEndCharacter(bIndex);\n            const bMetadata = bTokens.getMetadata(bIndex);\n            const bMask = (((bMetadata & 1 /* MetadataConsts.SEMANTIC_USE_ITALIC */) ? 2048 /* MetadataConsts.ITALIC_MASK */ : 0)\n                | ((bMetadata & 2 /* MetadataConsts.SEMANTIC_USE_BOLD */) ? 4096 /* MetadataConsts.BOLD_MASK */ : 0)\n                | ((bMetadata & 4 /* MetadataConsts.SEMANTIC_USE_UNDERLINE */) ? 8192 /* MetadataConsts.UNDERLINE_MASK */ : 0)\n                | ((bMetadata & 8 /* MetadataConsts.SEMANTIC_USE_STRIKETHROUGH */) ? 16384 /* MetadataConsts.STRIKETHROUGH_MASK */ : 0)\n                | ((bMetadata & 16 /* MetadataConsts.SEMANTIC_USE_FOREGROUND */) ? 16744448 /* MetadataConsts.FOREGROUND_MASK */ : 0)\n                | ((bMetadata & 32 /* MetadataConsts.SEMANTIC_USE_BACKGROUND */) ? 4278190080 /* MetadataConsts.BACKGROUND_MASK */ : 0)) >>> 0;\n            const aMask = (~bMask) >>> 0;\n            // push any token from `a` that is before `b`\n            while (aIndex < aLen && aTokens.getEndOffset(aIndex) <= bStartCharacter) {\n                emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));\n                aIndex++;\n            }\n            // push the token from `a` if it intersects the token from `b`\n            if (aIndex < aLen && aTokens.getStartOffset(aIndex) < bStartCharacter) {\n                emitToken(bStartCharacter, aTokens.getMetadata(aIndex));\n            }\n            // skip any tokens from `a` that are contained inside `b`\n            while (aIndex < aLen && aTokens.getEndOffset(aIndex) < bEndCharacter) {\n                emitToken(aTokens.getEndOffset(aIndex), (aTokens.getMetadata(aIndex) & aMask) | (bMetadata & bMask));\n                aIndex++;\n            }\n            if (aIndex < aLen) {\n                emitToken(bEndCharacter, (aTokens.getMetadata(aIndex) & aMask) | (bMetadata & bMask));\n                if (aTokens.getEndOffset(aIndex) === bEndCharacter) {\n                    // `a` ends exactly at the same spot as `b`!\n                    aIndex++;\n                }\n            }\n            else {\n                const aMergeIndex = Math.min(Math.max(0, aIndex - 1), aLen - 1);\n                // push the token from `b`\n                emitToken(bEndCharacter, (aTokens.getMetadata(aMergeIndex) & aMask) | (bMetadata & bMask));\n            }\n        }\n        // push the remaining tokens from `a`\n        while (aIndex < aLen) {\n            emitToken(aTokens.getEndOffset(aIndex), aTokens.getMetadata(aIndex));\n            aIndex++;\n        }\n        return new LineTokens(new Uint32Array(result), aTokens.getLineContent(), this._languageIdCodec);\n    }\n    static _findFirstPieceWithLine(pieces, lineNumber) {\n        let low = 0;\n        let high = pieces.length - 1;\n        while (low < high) {\n            let mid = low + Math.floor((high - low) / 2);\n            if (pieces[mid].endLineNumber < lineNumber) {\n                low = mid + 1;\n            }\n            else if (pieces[mid].startLineNumber > lineNumber) {\n                high = mid - 1;\n            }\n            else {\n                while (mid > low && pieces[mid - 1].startLineNumber <= lineNumber && lineNumber <= pieces[mid - 1].endLineNumber) {\n                    mid--;\n                }\n                return mid;\n            }\n        }\n        return low;\n    }\n    acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode) {\n        for (const piece of this._pieces) {\n            piece.acceptEdit(range, eolCount, firstLineLength, lastLineLength, firstCharCode);\n        }\n    }\n}\n"],"names":["BracketInfo","constructor","range","nestingLevel","nestingLevelOfEqualBracketType","isInvalid","this","BracketPairInfo","openingBracketRange","closingBracketRange","bracketPairNode","openingBracketInfo","openingBracket","bracketInfo","BracketPairWithMinIndentationInfo","minVisibleColumnIndentation","super","ModelRawFlush","changeType","LineInjectedText","applyInjectedText","lineText","injectedTexts","length","result","lastOriginalOffset","injectedText","substring","column","options","content","fromDecorations","decorations","decoration","before","push","ownerId","startLineNumber","startColumn","after","endLineNumber","endColumn","sort","a","b","lineNumber","order","ModelRawLineChanged","detail","ModelRawLinesDeleted","fromLineNumber","toLineNumber","ModelRawLinesInserted","ModelRawEOLChanged","ModelRawContentChangedEvent","changes","versionId","isUndoing","isRedoing","resultingSelection","containsEvent","type","i","len","merge","concat","ModelInjectedTextChangedEvent","InternalModelContentChangeEvent","rawContentChangedEvent","contentChangedEvent","other","_mergeChangeEvents","eol","isFlush","isEolChange","HorizontalGuidesState","IndentGuide","visibleColumn","className","horizontalLine","forWrappedLinesAfterColumn","forWrappedLinesBeforeOrAtColumn","Error","IndentGuideHorizontalLine","top","TokenizationRegistry","_tokenizationSupports","Map","_factories","_onDidChange","onDidChange","event","_colorMap","handleChange","languageIds","fire","changedLanguages","changedColorMap","register","languageId","support","set","get","delete","registerFactory","factory","_a","dispose","myData","TokenizationSupportFactoryData","v","getOrCreate","tokenizationSupport","isResolved","resolve","setColorMap","colorMap","Array","from","keys","getColorMap","getDefaultBackground","_isResolved","_registry","_languageId","_factory","_isDisposed","_resolvePromise","_create","value","_register","ContiguousMultilineTokens","_startLineNumber","_tokens","tokens","getLineTokens","appendLineTokens","lineTokens","ContiguousMultilineTokensBuilder","add","last","finalize","EMPTY_LINE_TOKENS","Uint32Array","buffer","ContiguousTokensEditing","deleteBeginning","toChIndex","deleteEnding","fromChIndex","toUint32Array","lineTextLength","tokensCount","fromTokenIndex","fromTokenStartOffset","delta","dest","lastEnd","tokenIndex","tokenEndOffset","tmp","subarray","append","_otherTokens","myTokens","otherTokens","otherTokensCount","insert","chIndex","textLength","arr","ContiguousTokensStore","languageIdCodec","_lineTokens","_len","_languageIdCodec","flush","hasTokens","getTokens","topLevelLanguageId","lineIndex","rawLineTokens","getDefaultMetadata","encodeLanguageId","_massageTokens","hasDifferentLanguageId","byteOffset","byteLength","_ensureLine","_deleteLines","start","deleteCount","splice","_insertLines","insertIndex","insertCount","arrays","setTokens","checkEquality","oldTokens","_equals","_b","acceptEdit","eolCount","firstLineLength","_acceptDeleteRange","_acceptInsertText","firstLineIndex","lastLineIndex","lastLineTokens","position","setMultilineTokens","textModel","ranges","element","minChangedLineNumber","maxChangedLineNumber","hasChange","getLanguageId","getLineLength","LineTokens","createEmpty","lineContent","decoder","defaultMetadata","defaultTokenMetadata","createFromTextAndMetadata","data","offset","fullText","text","metadata","_lineTokensBrand","undefined","_tokensCount","_text","equals","slicedEquals","sliceFromTokenIndex","sliceTokenCount","to","getLineContent","getCount","getStartOffset","getMetadata","decodeLanguageId","getStandardTokenType","getForeground","getClassName","getInlineStyle","getPresentation","getEndOffset","findTokenIndexAtOffset","findIndexInTokensArray","inflate","sliceAndInflate","startOffset","endOffset","deltaOffset","SliceLineTokens","convertToEndOffset","lastTokenIndex","desiredIndex","low","high","mid","Math","floor","withInserted","insertTokens","nextOriginalTokenIdx","nextInsertTokenIdx","newTokens","originalEndOffset","nextOriginalTokenEndOffset","nextInsertToken","tokenMetadata","getTokenText","forEach","callback","tokenCount","source","_source","_startOffset","_endOffset","_deltaOffset","_firstTokenIndex","min","adjustedTokenIndex","tokenStartOffset","getStandardTokenTypeAtPosition","model","tokenization","isCheapToTokenize","forceTokenization","SparseMultilineTokens","create","SparseMultilineTokensStorage","_endLineNumber","getMaxDeltaLine","toString","_updateEndLineNumber","isEmpty","getRange","deltaRange","removeTokens","startLineIndex","endLineIndex","split","bDeltaLine","applyEdit","lastLineLength","charCodeAt","firstCharCode","deletedLinesCount","tokenMaxDeltaLine","clear","deletedBefore","acceptDeleteRange","acceptInsertText","_tokenCount","pieces","_getDeltaLine","_getStartCharacter","_getEndCharacter","join","_getTokenCount","startChar","maxDeltaLine","endChar","deltaLine","midDeltaLine","max","SparseLineTokens","startDeltaLine","endDeltaLine","newTokenCount","hasDeletedTokens","firstDeltaLine","srcOffset","tokenDeltaLine","tokenStartCharacter","tokenEndCharacter","destOffset","aTokens","bTokens","destTokens","destFirstDeltaLine","horizontalShiftForFirstLineTokens","startCharacter","endCharacter","deletedLineCount","character","isInsertingPreciselyOneWordCharacter","tokenLength","getStartCharacter","getEndCharacter","SparseTokensStore","_pieces","_isComplete","isComplete","setPartial","_range","_firstRange","_lastRange","plusRange","insertPosition","piece","index","addSparseTokens","_findFirstPieceWithLine","aLen","bLen","aIndex","resultLen","lastEndOffset","emitToken","bIndex","bStartCharacter","bEndCharacter","bMetadata","bMask","aMask","aMergeIndex"],"sourceRoot":""}