{"version":3,"file":"static/js/348_f4519c6badf5cef911c9.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/model/tokenizationTextModelPart.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/model/utils.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 *--------------------------------------------------------------------------------------------*/\nimport { equals } from '../../../base/common/arrays.js';\nimport { RunOnceScheduler } from '../../../base/common/async.js';\nimport { BugIndicatingError, onUnexpectedError } from '../../../base/common/errors.js';\nimport { Emitter } from '../../../base/common/event.js';\nimport { Disposable, DisposableMap, MutableDisposable } from '../../../base/common/lifecycle.js';\nimport { countEOL } from '../core/eolCounter.js';\nimport { LineRange } from '../core/lineRange.js';\nimport { Position } from '../core/position.js';\nimport { getWordAtText } from '../core/wordHelper.js';\nimport { TokenizationRegistry } from '../languages.js';\nimport { TextModelPart } from './textModelPart.js';\nimport { DefaultBackgroundTokenizer, TokenizerWithStateStoreAndTextModel, TrackingTokenizationStateStore } from './textModelTokens.js';\nimport { ContiguousMultilineTokensBuilder } from '../tokens/contiguousMultilineTokensBuilder.js';\nimport { ContiguousTokensStore } from '../tokens/contiguousTokensStore.js';\nimport { SparseTokensStore } from '../tokens/sparseTokensStore.js';\nexport class TokenizationTextModelPart extends TextModelPart {\n    constructor(_languageService, _languageConfigurationService, _textModel, _bracketPairsTextModelPart, _languageId, _attachedViews) {\n        super();\n        this._languageService = _languageService;\n        this._languageConfigurationService = _languageConfigurationService;\n        this._textModel = _textModel;\n        this._bracketPairsTextModelPart = _bracketPairsTextModelPart;\n        this._languageId = _languageId;\n        this._attachedViews = _attachedViews;\n        this._semanticTokens = new SparseTokensStore(this._languageService.languageIdCodec);\n        this._onDidChangeLanguage = this._register(new Emitter());\n        this.onDidChangeLanguage = this._onDidChangeLanguage.event;\n        this._onDidChangeLanguageConfiguration = this._register(new Emitter());\n        this.onDidChangeLanguageConfiguration = this._onDidChangeLanguageConfiguration.event;\n        this._onDidChangeTokens = this._register(new Emitter());\n        this.onDidChangeTokens = this._onDidChangeTokens.event;\n        this.grammarTokens = this._register(new GrammarTokens(this._languageService.languageIdCodec, this._textModel, () => this._languageId, this._attachedViews));\n        this._register(this._languageConfigurationService.onDidChange(e => {\n            if (e.affects(this._languageId)) {\n                this._onDidChangeLanguageConfiguration.fire({});\n            }\n        }));\n        this._register(this.grammarTokens.onDidChangeTokens(e => {\n            this._emitModelTokensChangedEvent(e);\n        }));\n        this._register(this.grammarTokens.onDidChangeBackgroundTokenizationState(e => {\n            this._bracketPairsTextModelPart.handleDidChangeBackgroundTokenizationState();\n        }));\n    }\n    handleDidChangeContent(e) {\n        if (e.isFlush) {\n            this._semanticTokens.flush();\n        }\n        else if (!e.isEolChange) { // We don't have to do anything on an EOL change\n            for (const c of e.changes) {\n                const [eolCount, firstLineLength, lastLineLength] = countEOL(c.text);\n                this._semanticTokens.acceptEdit(c.range, eolCount, firstLineLength, lastLineLength, c.text.length > 0 ? c.text.charCodeAt(0) : 0 /* CharCode.Null */);\n            }\n        }\n        this.grammarTokens.handleDidChangeContent(e);\n    }\n    handleDidChangeAttached() {\n        this.grammarTokens.handleDidChangeAttached();\n    }\n    /**\n     * Includes grammar and semantic tokens.\n     */\n    getLineTokens(lineNumber) {\n        this.validateLineNumber(lineNumber);\n        const syntacticTokens = this.grammarTokens.getLineTokens(lineNumber);\n        return this._semanticTokens.addSparseTokens(lineNumber, syntacticTokens);\n    }\n    _emitModelTokensChangedEvent(e) {\n        if (!this._textModel._isDisposing()) {\n            this._bracketPairsTextModelPart.handleDidChangeTokens(e);\n            this._onDidChangeTokens.fire(e);\n        }\n    }\n    // #region Grammar Tokens\n    validateLineNumber(lineNumber) {\n        if (lineNumber < 1 || lineNumber > this._textModel.getLineCount()) {\n            throw new BugIndicatingError('Illegal value for lineNumber');\n        }\n    }\n    get hasTokens() {\n        return this.grammarTokens.hasTokens;\n    }\n    resetTokenization() {\n        this.grammarTokens.resetTokenization();\n    }\n    get backgroundTokenizationState() {\n        return this.grammarTokens.backgroundTokenizationState;\n    }\n    forceTokenization(lineNumber) {\n        this.validateLineNumber(lineNumber);\n        this.grammarTokens.forceTokenization(lineNumber);\n    }\n    hasAccurateTokensForLine(lineNumber) {\n        this.validateLineNumber(lineNumber);\n        return this.grammarTokens.hasAccurateTokensForLine(lineNumber);\n    }\n    isCheapToTokenize(lineNumber) {\n        this.validateLineNumber(lineNumber);\n        return this.grammarTokens.isCheapToTokenize(lineNumber);\n    }\n    tokenizeIfCheap(lineNumber) {\n        this.validateLineNumber(lineNumber);\n        this.grammarTokens.tokenizeIfCheap(lineNumber);\n    }\n    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {\n        return this.grammarTokens.getTokenTypeIfInsertingCharacter(lineNumber, column, character);\n    }\n    tokenizeLineWithEdit(position, length, newText) {\n        return this.grammarTokens.tokenizeLineWithEdit(position, length, newText);\n    }\n    // #endregion\n    // #region Semantic Tokens\n    setSemanticTokens(tokens, isComplete) {\n        this._semanticTokens.set(tokens, isComplete);\n        this._emitModelTokensChangedEvent({\n            semanticTokensApplied: tokens !== null,\n            ranges: [{ fromLineNumber: 1, toLineNumber: this._textModel.getLineCount() }],\n        });\n    }\n    hasCompleteSemanticTokens() {\n        return this._semanticTokens.isComplete();\n    }\n    hasSomeSemanticTokens() {\n        return !this._semanticTokens.isEmpty();\n    }\n    setPartialSemanticTokens(range, tokens) {\n        if (this.hasCompleteSemanticTokens()) {\n            return;\n        }\n        const changedRange = this._textModel.validateRange(this._semanticTokens.setPartial(range, tokens));\n        this._emitModelTokensChangedEvent({\n            semanticTokensApplied: true,\n            ranges: [\n                {\n                    fromLineNumber: changedRange.startLineNumber,\n                    toLineNumber: changedRange.endLineNumber,\n                },\n            ],\n        });\n    }\n    // #endregion\n    // #region Utility Methods\n    getWordAtPosition(_position) {\n        this.assertNotDisposed();\n        const position = this._textModel.validatePosition(_position);\n        const lineContent = this._textModel.getLineContent(position.lineNumber);\n        const lineTokens = this.getLineTokens(position.lineNumber);\n        const tokenIndex = lineTokens.findTokenIndexAtOffset(position.column - 1);\n        // (1). First try checking right biased word\n        const [rbStartOffset, rbEndOffset] = TokenizationTextModelPart._findLanguageBoundaries(lineTokens, tokenIndex);\n        const rightBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex)).getWordDefinition(), lineContent.substring(rbStartOffset, rbEndOffset), rbStartOffset);\n        // Make sure the result touches the original passed in position\n        if (rightBiasedWord &&\n            rightBiasedWord.startColumn <= _position.column &&\n            _position.column <= rightBiasedWord.endColumn) {\n            return rightBiasedWord;\n        }\n        // (2). Else, if we were at a language boundary, check the left biased word\n        if (tokenIndex > 0 && rbStartOffset === position.column - 1) {\n            // edge case, where `position` sits between two tokens belonging to two different languages\n            const [lbStartOffset, lbEndOffset] = TokenizationTextModelPart._findLanguageBoundaries(lineTokens, tokenIndex - 1);\n            const leftBiasedWord = getWordAtText(position.column, this.getLanguageConfiguration(lineTokens.getLanguageId(tokenIndex - 1)).getWordDefinition(), lineContent.substring(lbStartOffset, lbEndOffset), lbStartOffset);\n            // Make sure the result touches the original passed in position\n            if (leftBiasedWord &&\n                leftBiasedWord.startColumn <= _position.column &&\n                _position.column <= leftBiasedWord.endColumn) {\n                return leftBiasedWord;\n            }\n        }\n        return null;\n    }\n    getLanguageConfiguration(languageId) {\n        return this._languageConfigurationService.getLanguageConfiguration(languageId);\n    }\n    static _findLanguageBoundaries(lineTokens, tokenIndex) {\n        const languageId = lineTokens.getLanguageId(tokenIndex);\n        // go left until a different language is hit\n        let startOffset = 0;\n        for (let i = tokenIndex; i >= 0 && lineTokens.getLanguageId(i) === languageId; i--) {\n            startOffset = lineTokens.getStartOffset(i);\n        }\n        // go right until a different language is hit\n        let endOffset = lineTokens.getLineContent().length;\n        for (let i = tokenIndex, tokenCount = lineTokens.getCount(); i < tokenCount && lineTokens.getLanguageId(i) === languageId; i++) {\n            endOffset = lineTokens.getEndOffset(i);\n        }\n        return [startOffset, endOffset];\n    }\n    getWordUntilPosition(position) {\n        const wordAtPosition = this.getWordAtPosition(position);\n        if (!wordAtPosition) {\n            return { word: '', startColumn: position.column, endColumn: position.column, };\n        }\n        return {\n            word: wordAtPosition.word.substr(0, position.column - wordAtPosition.startColumn),\n            startColumn: wordAtPosition.startColumn,\n            endColumn: position.column,\n        };\n    }\n    // #endregion\n    // #region Language Id handling\n    getLanguageId() {\n        return this._languageId;\n    }\n    getLanguageIdAtPosition(lineNumber, column) {\n        const position = this._textModel.validatePosition(new Position(lineNumber, column));\n        const lineTokens = this.getLineTokens(position.lineNumber);\n        return lineTokens.getLanguageId(lineTokens.findTokenIndexAtOffset(position.column - 1));\n    }\n    setLanguageId(languageId, source = 'api') {\n        if (this._languageId === languageId) {\n            // There's nothing to do\n            return;\n        }\n        const e = {\n            oldLanguage: this._languageId,\n            newLanguage: languageId,\n            source\n        };\n        this._languageId = languageId;\n        this._bracketPairsTextModelPart.handleDidChangeLanguage(e);\n        this.grammarTokens.resetTokenization();\n        this._onDidChangeLanguage.fire(e);\n        this._onDidChangeLanguageConfiguration.fire({});\n    }\n}\nclass GrammarTokens extends Disposable {\n    get backgroundTokenizationState() {\n        return this._backgroundTokenizationState;\n    }\n    constructor(_languageIdCodec, _textModel, getLanguageId, attachedViews) {\n        super();\n        this._languageIdCodec = _languageIdCodec;\n        this._textModel = _textModel;\n        this.getLanguageId = getLanguageId;\n        this._tokenizer = null;\n        this._defaultBackgroundTokenizer = null;\n        this._backgroundTokenizer = this._register(new MutableDisposable());\n        this._tokens = new ContiguousTokensStore(this._languageIdCodec);\n        this._debugBackgroundTokenizer = this._register(new MutableDisposable());\n        this._backgroundTokenizationState = 1 /* BackgroundTokenizationState.InProgress */;\n        this._onDidChangeBackgroundTokenizationState = this._register(new Emitter());\n        /** @internal, should not be exposed by the text model! */\n        this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;\n        this._onDidChangeTokens = this._register(new Emitter());\n        /** @internal, should not be exposed by the text model! */\n        this.onDidChangeTokens = this._onDidChangeTokens.event;\n        this._attachedViewStates = this._register(new DisposableMap());\n        this._register(TokenizationRegistry.onDidChange((e) => {\n            const languageId = this.getLanguageId();\n            if (e.changedLanguages.indexOf(languageId) === -1) {\n                return;\n            }\n            this.resetTokenization();\n        }));\n        this.resetTokenization();\n        this._register(attachedViews.onDidChangeVisibleRanges(({ view, state }) => {\n            if (state) {\n                let existing = this._attachedViewStates.get(view);\n                if (!existing) {\n                    existing = new AttachedViewHandler(() => this.refreshRanges(existing.lineRanges));\n                    this._attachedViewStates.set(view, existing);\n                }\n                existing.handleStateChange(state);\n            }\n            else {\n                this._attachedViewStates.deleteAndDispose(view);\n            }\n        }));\n    }\n    resetTokenization(fireTokenChangeEvent = true) {\n        var _a;\n        this._tokens.flush();\n        (_a = this._debugBackgroundTokens) === null || _a === void 0 ? void 0 : _a.flush();\n        if (this._debugBackgroundStates) {\n            this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());\n        }\n        if (fireTokenChangeEvent) {\n            this._onDidChangeTokens.fire({\n                semanticTokensApplied: false,\n                ranges: [\n                    {\n                        fromLineNumber: 1,\n                        toLineNumber: this._textModel.getLineCount(),\n                    },\n                ],\n            });\n        }\n        const initializeTokenization = () => {\n            if (this._textModel.isTooLargeForTokenization()) {\n                return [null, null];\n            }\n            const tokenizationSupport = TokenizationRegistry.get(this.getLanguageId());\n            if (!tokenizationSupport) {\n                return [null, null];\n            }\n            let initialState;\n            try {\n                initialState = tokenizationSupport.getInitialState();\n            }\n            catch (e) {\n                onUnexpectedError(e);\n                return [null, null];\n            }\n            return [tokenizationSupport, initialState];\n        };\n        const [tokenizationSupport, initialState] = initializeTokenization();\n        if (tokenizationSupport && initialState) {\n            this._tokenizer = new TokenizerWithStateStoreAndTextModel(this._textModel.getLineCount(), tokenizationSupport, this._textModel, this._languageIdCodec);\n        }\n        else {\n            this._tokenizer = null;\n        }\n        this._backgroundTokenizer.clear();\n        this._defaultBackgroundTokenizer = null;\n        if (this._tokenizer) {\n            const b = {\n                setTokens: (tokens) => {\n                    this.setTokens(tokens);\n                },\n                backgroundTokenizationFinished: () => {\n                    if (this._backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {\n                        // We already did a full tokenization and don't go back to progressing.\n                        return;\n                    }\n                    const newState = 2 /* BackgroundTokenizationState.Completed */;\n                    this._backgroundTokenizationState = newState;\n                    this._onDidChangeBackgroundTokenizationState.fire();\n                },\n                setEndState: (lineNumber, state) => {\n                    var _a;\n                    if (!this._tokenizer) {\n                        return;\n                    }\n                    const firstInvalidEndStateLineNumber = this._tokenizer.store.getFirstInvalidEndStateLineNumber();\n                    // Don't accept states for definitely valid states, the renderer is ahead of the worker!\n                    if (firstInvalidEndStateLineNumber !== null && lineNumber >= firstInvalidEndStateLineNumber) {\n                        (_a = this._tokenizer) === null || _a === void 0 ? void 0 : _a.store.setEndState(lineNumber, state);\n                    }\n                },\n            };\n            if (tokenizationSupport && tokenizationSupport.createBackgroundTokenizer && !tokenizationSupport.backgroundTokenizerShouldOnlyVerifyTokens) {\n                this._backgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, b);\n            }\n            if (!this._backgroundTokenizer.value && !this._textModel.isTooLargeForTokenization()) {\n                this._backgroundTokenizer.value = this._defaultBackgroundTokenizer =\n                    new DefaultBackgroundTokenizer(this._tokenizer, b);\n                this._defaultBackgroundTokenizer.handleChanges();\n            }\n            if ((tokenizationSupport === null || tokenizationSupport === void 0 ? void 0 : tokenizationSupport.backgroundTokenizerShouldOnlyVerifyTokens) && tokenizationSupport.createBackgroundTokenizer) {\n                this._debugBackgroundTokens = new ContiguousTokensStore(this._languageIdCodec);\n                this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());\n                this._debugBackgroundTokenizer.clear();\n                this._debugBackgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, {\n                    setTokens: (tokens) => {\n                        var _a;\n                        (_a = this._debugBackgroundTokens) === null || _a === void 0 ? void 0 : _a.setMultilineTokens(tokens, this._textModel);\n                    },\n                    backgroundTokenizationFinished() {\n                        // NO OP\n                    },\n                    setEndState: (lineNumber, state) => {\n                        var _a;\n                        (_a = this._debugBackgroundStates) === null || _a === void 0 ? void 0 : _a.setEndState(lineNumber, state);\n                    },\n                });\n            }\n            else {\n                this._debugBackgroundTokens = undefined;\n                this._debugBackgroundStates = undefined;\n                this._debugBackgroundTokenizer.value = undefined;\n            }\n        }\n        this.refreshAllVisibleLineTokens();\n    }\n    handleDidChangeAttached() {\n        var _a;\n        (_a = this._defaultBackgroundTokenizer) === null || _a === void 0 ? void 0 : _a.handleChanges();\n    }\n    handleDidChangeContent(e) {\n        var _a, _b, _c;\n        if (e.isFlush) {\n            // Don't fire the event, as the view might not have got the text change event yet\n            this.resetTokenization(false);\n        }\n        else if (!e.isEolChange) { // We don't have to do anything on an EOL change\n            for (const c of e.changes) {\n                const [eolCount, firstLineLength] = countEOL(c.text);\n                this._tokens.acceptEdit(c.range, eolCount, firstLineLength);\n                (_a = this._debugBackgroundTokens) === null || _a === void 0 ? void 0 : _a.acceptEdit(c.range, eolCount, firstLineLength);\n            }\n            (_b = this._debugBackgroundStates) === null || _b === void 0 ? void 0 : _b.acceptChanges(e.changes);\n            if (this._tokenizer) {\n                this._tokenizer.store.acceptChanges(e.changes);\n            }\n            (_c = this._defaultBackgroundTokenizer) === null || _c === void 0 ? void 0 : _c.handleChanges();\n        }\n    }\n    setTokens(tokens) {\n        const { changes } = this._tokens.setMultilineTokens(tokens, this._textModel);\n        if (changes.length > 0) {\n            this._onDidChangeTokens.fire({ semanticTokensApplied: false, ranges: changes, });\n        }\n        return { changes: changes };\n    }\n    refreshAllVisibleLineTokens() {\n        const ranges = LineRange.joinMany([...this._attachedViewStates].map(([_, s]) => s.lineRanges));\n        this.refreshRanges(ranges);\n    }\n    refreshRanges(ranges) {\n        for (const range of ranges) {\n            this.refreshRange(range.startLineNumber, range.endLineNumberExclusive - 1);\n        }\n    }\n    refreshRange(startLineNumber, endLineNumber) {\n        var _a, _b;\n        if (!this._tokenizer) {\n            return;\n        }\n        startLineNumber = Math.max(1, Math.min(this._textModel.getLineCount(), startLineNumber));\n        endLineNumber = Math.min(this._textModel.getLineCount(), endLineNumber);\n        const builder = new ContiguousMultilineTokensBuilder();\n        const { heuristicTokens } = this._tokenizer.tokenizeHeuristically(builder, startLineNumber, endLineNumber);\n        const changedTokens = this.setTokens(builder.finalize());\n        if (heuristicTokens) {\n            // We overrode tokens with heuristically computed ones.\n            // Because old states might get reused (thus stopping invalidation),\n            // we have to explicitly request the tokens for the changed ranges again.\n            for (const c of changedTokens.changes) {\n                (_a = this._backgroundTokenizer.value) === null || _a === void 0 ? void 0 : _a.requestTokens(c.fromLineNumber, c.toLineNumber + 1);\n            }\n        }\n        (_b = this._defaultBackgroundTokenizer) === null || _b === void 0 ? void 0 : _b.checkFinished();\n    }\n    forceTokenization(lineNumber) {\n        var _a, _b;\n        const builder = new ContiguousMultilineTokensBuilder();\n        (_a = this._tokenizer) === null || _a === void 0 ? void 0 : _a.updateTokensUntilLine(builder, lineNumber);\n        this.setTokens(builder.finalize());\n        (_b = this._defaultBackgroundTokenizer) === null || _b === void 0 ? void 0 : _b.checkFinished();\n    }\n    hasAccurateTokensForLine(lineNumber) {\n        if (!this._tokenizer) {\n            return true;\n        }\n        return this._tokenizer.hasAccurateTokensForLine(lineNumber);\n    }\n    isCheapToTokenize(lineNumber) {\n        if (!this._tokenizer) {\n            return true;\n        }\n        return this._tokenizer.isCheapToTokenize(lineNumber);\n    }\n    tokenizeIfCheap(lineNumber) {\n        if (this.isCheapToTokenize(lineNumber)) {\n            this.forceTokenization(lineNumber);\n        }\n    }\n    getLineTokens(lineNumber) {\n        var _a;\n        const lineText = this._textModel.getLineContent(lineNumber);\n        const result = this._tokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);\n        if (this._debugBackgroundTokens && this._debugBackgroundStates && this._tokenizer) {\n            if (this._debugBackgroundStates.getFirstInvalidEndStateLineNumberOrMax() > lineNumber && this._tokenizer.store.getFirstInvalidEndStateLineNumberOrMax() > lineNumber) {\n                const backgroundResult = this._debugBackgroundTokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);\n                if (!result.equals(backgroundResult) && ((_a = this._debugBackgroundTokenizer.value) === null || _a === void 0 ? void 0 : _a.reportMismatchingTokens)) {\n                    this._debugBackgroundTokenizer.value.reportMismatchingTokens(lineNumber);\n                }\n            }\n        }\n        return result;\n    }\n    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {\n        if (!this._tokenizer) {\n            return 0 /* StandardTokenType.Other */;\n        }\n        const position = this._textModel.validatePosition(new Position(lineNumber, column));\n        this.forceTokenization(position.lineNumber);\n        return this._tokenizer.getTokenTypeIfInsertingCharacter(position, character);\n    }\n    tokenizeLineWithEdit(position, length, newText) {\n        if (!this._tokenizer) {\n            return null;\n        }\n        const validatedPosition = this._textModel.validatePosition(position);\n        this.forceTokenization(validatedPosition.lineNumber);\n        return this._tokenizer.tokenizeLineWithEdit(validatedPosition, length, newText);\n    }\n    get hasTokens() {\n        return this._tokens.hasTokens;\n    }\n}\nclass AttachedViewHandler extends Disposable {\n    get lineRanges() { return this._lineRanges; }\n    constructor(_refreshTokens) {\n        super();\n        this._refreshTokens = _refreshTokens;\n        this.runner = this._register(new RunOnceScheduler(() => this.update(), 50));\n        this._computedLineRanges = [];\n        this._lineRanges = [];\n    }\n    update() {\n        if (equals(this._computedLineRanges, this._lineRanges, (a, b) => a.equals(b))) {\n            return;\n        }\n        this._computedLineRanges = this._lineRanges;\n        this._refreshTokens();\n    }\n    handleStateChange(state) {\n        this._lineRanges = state.visibleLineRanges;\n        if (state.stabilized) {\n            this.runner.cancel();\n            this.update();\n        }\n        else {\n            this.runner.schedule();\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 *--------------------------------------------------------------------------------------------*/\n/**\n * Returns:\n *  - -1 => the line consists of whitespace\n *  - otherwise => the indent level is returned value\n */\nexport function computeIndentLevel(line, tabSize) {\n    let indent = 0;\n    let i = 0;\n    const len = line.length;\n    while (i < len) {\n        const chCode = line.charCodeAt(i);\n        if (chCode === 32 /* CharCode.Space */) {\n            indent++;\n        }\n        else if (chCode === 9 /* CharCode.Tab */) {\n            indent = indent - indent % tabSize + tabSize;\n        }\n        else {\n            break;\n        }\n        i++;\n    }\n    if (i === len) {\n        return -1; // line only consists of whitespace\n    }\n    return indent;\n}\n"],"names":["TokenizationTextModelPart","constructor","_languageService","_languageConfigurationService","_textModel","_bracketPairsTextModelPart","_languageId","_attachedViews","super","this","_semanticTokens","languageIdCodec","_onDidChangeLanguage","_register","onDidChangeLanguage","event","_onDidChangeLanguageConfiguration","onDidChangeLanguageConfiguration","_onDidChangeTokens","onDidChangeTokens","grammarTokens","GrammarTokens","onDidChange","e","affects","fire","_emitModelTokensChangedEvent","onDidChangeBackgroundTokenizationState","handleDidChangeBackgroundTokenizationState","handleDidChangeContent","isFlush","flush","isEolChange","c","changes","eolCount","firstLineLength","lastLineLength","text","acceptEdit","range","length","charCodeAt","handleDidChangeAttached","getLineTokens","lineNumber","validateLineNumber","syntacticTokens","addSparseTokens","_isDisposing","handleDidChangeTokens","getLineCount","hasTokens","resetTokenization","backgroundTokenizationState","forceTokenization","hasAccurateTokensForLine","isCheapToTokenize","tokenizeIfCheap","getTokenTypeIfInsertingCharacter","column","character","tokenizeLineWithEdit","position","newText","setSemanticTokens","tokens","isComplete","set","semanticTokensApplied","ranges","fromLineNumber","toLineNumber","hasCompleteSemanticTokens","hasSomeSemanticTokens","isEmpty","setPartialSemanticTokens","changedRange","validateRange","setPartial","startLineNumber","endLineNumber","getWordAtPosition","_position","assertNotDisposed","validatePosition","lineContent","getLineContent","lineTokens","tokenIndex","findTokenIndexAtOffset","rbStartOffset","rbEndOffset","_findLanguageBoundaries","rightBiasedWord","getLanguageConfiguration","getLanguageId","getWordDefinition","substring","startColumn","endColumn","lbStartOffset","lbEndOffset","leftBiasedWord","languageId","startOffset","i","getStartOffset","endOffset","tokenCount","getCount","getEndOffset","getWordUntilPosition","wordAtPosition","word","substr","getLanguageIdAtPosition","setLanguageId","source","oldLanguage","newLanguage","handleDidChangeLanguage","_backgroundTokenizationState","_languageIdCodec","attachedViews","_tokenizer","_defaultBackgroundTokenizer","_backgroundTokenizer","_tokens","_debugBackgroundTokenizer","_onDidChangeBackgroundTokenizationState","_attachedViewStates","changedLanguages","indexOf","onDidChangeVisibleRanges","view","state","existing","get","AttachedViewHandler","refreshRanges","lineRanges","handleStateChange","deleteAndDispose","fireTokenChangeEvent","_a","_debugBackgroundTokens","_debugBackgroundStates","tokenizationSupport","initialState","isTooLargeForTokenization","getInitialState","initializeTokenization","clear","b","setTokens","backgroundTokenizationFinished","setEndState","firstInvalidEndStateLineNumber","store","getFirstInvalidEndStateLineNumber","createBackgroundTokenizer","backgroundTokenizerShouldOnlyVerifyTokens","value","handleChanges","setMultilineTokens","undefined","refreshAllVisibleLineTokens","_b","_c","acceptChanges","map","_","s","refreshRange","endLineNumberExclusive","Math","max","min","builder","heuristicTokens","tokenizeHeuristically","changedTokens","finalize","requestTokens","checkFinished","updateTokensUntilLine","lineText","result","getTokens","getFirstInvalidEndStateLineNumberOrMax","backgroundResult","equals","reportMismatchingTokens","validatedPosition","_lineRanges","_refreshTokens","runner","update","_computedLineRanges","a","visibleLineRanges","stabilized","cancel","schedule","computeIndentLevel","line","tabSize","indent","len","chCode"],"sourceRoot":""}