{"version":3,"file":"static/js/5282_49254bb61fbf27bd4906.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/commands/replaceCommand.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/commands/shiftCommand.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/commands/surroundSelectionCommand.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/commands/trimTrailingWhitespaceCommand.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 { Selection } from '../core/selection.js';\nexport class ReplaceCommand {\n    constructor(range, text, insertsAutoWhitespace = false) {\n        this._range = range;\n        this._text = text;\n        this.insertsAutoWhitespace = insertsAutoWhitespace;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._range, this._text);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const srcRange = inverseEditOperations[0].range;\n        return Selection.fromPositions(srcRange.getEndPosition());\n    }\n}\nexport class ReplaceCommandThatSelectsText {\n    constructor(range, text) {\n        this._range = range;\n        this._text = text;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._range, this._text);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const srcRange = inverseEditOperations[0].range;\n        return Selection.fromRange(srcRange, 0 /* SelectionDirection.LTR */);\n    }\n}\nexport class ReplaceCommandWithoutChangingPosition {\n    constructor(range, text, insertsAutoWhitespace = false) {\n        this._range = range;\n        this._text = text;\n        this.insertsAutoWhitespace = insertsAutoWhitespace;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._range, this._text);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const srcRange = inverseEditOperations[0].range;\n        return Selection.fromPositions(srcRange.getStartPosition());\n    }\n}\nexport class ReplaceCommandWithOffsetCursorState {\n    constructor(range, text, lineNumberDeltaOffset, columnDeltaOffset, insertsAutoWhitespace = false) {\n        this._range = range;\n        this._text = text;\n        this._columnDeltaOffset = columnDeltaOffset;\n        this._lineNumberDeltaOffset = lineNumberDeltaOffset;\n        this.insertsAutoWhitespace = insertsAutoWhitespace;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._range, this._text);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const srcRange = inverseEditOperations[0].range;\n        return Selection.fromPositions(srcRange.getEndPosition().delta(this._lineNumberDeltaOffset, this._columnDeltaOffset));\n    }\n}\nexport class ReplaceCommandThatPreservesSelection {\n    constructor(editRange, text, initialSelection, forceMoveMarkers = false) {\n        this._range = editRange;\n        this._text = text;\n        this._initialSelection = initialSelection;\n        this._forceMoveMarkers = forceMoveMarkers;\n        this._selectionId = null;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(this._range, this._text, this._forceMoveMarkers);\n        this._selectionId = builder.trackSelection(this._initialSelection);\n    }\n    computeCursorState(model, helper) {\n        return helper.getTrackedSelection(this._selectionId);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nvar ShiftCommand_1;\nimport * as strings from '../../../base/common/strings.js';\nimport { CursorColumns } from '../core/cursorColumns.js';\nimport { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nimport { getEnterAction } from '../languages/enterAction.js';\nimport { ILanguageConfigurationService } from '../languages/languageConfigurationRegistry.js';\nconst repeatCache = Object.create(null);\nfunction cachedStringRepeat(str, count) {\n    if (count <= 0) {\n        return '';\n    }\n    if (!repeatCache[str]) {\n        repeatCache[str] = ['', str];\n    }\n    const cache = repeatCache[str];\n    for (let i = cache.length; i <= count; i++) {\n        cache[i] = cache[i - 1] + str;\n    }\n    return cache[count];\n}\nlet ShiftCommand = ShiftCommand_1 = class ShiftCommand {\n    static unshiftIndent(line, column, tabSize, indentSize, insertSpaces) {\n        // Determine the visible column where the content starts\n        const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(line, column, tabSize);\n        if (insertSpaces) {\n            const indent = cachedStringRepeat(' ', indentSize);\n            const desiredTabStop = CursorColumns.prevIndentTabStop(contentStartVisibleColumn, indentSize);\n            const indentCount = desiredTabStop / indentSize; // will be an integer\n            return cachedStringRepeat(indent, indentCount);\n        }\n        else {\n            const indent = '\\t';\n            const desiredTabStop = CursorColumns.prevRenderTabStop(contentStartVisibleColumn, tabSize);\n            const indentCount = desiredTabStop / tabSize; // will be an integer\n            return cachedStringRepeat(indent, indentCount);\n        }\n    }\n    static shiftIndent(line, column, tabSize, indentSize, insertSpaces) {\n        // Determine the visible column where the content starts\n        const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(line, column, tabSize);\n        if (insertSpaces) {\n            const indent = cachedStringRepeat(' ', indentSize);\n            const desiredTabStop = CursorColumns.nextIndentTabStop(contentStartVisibleColumn, indentSize);\n            const indentCount = desiredTabStop / indentSize; // will be an integer\n            return cachedStringRepeat(indent, indentCount);\n        }\n        else {\n            const indent = '\\t';\n            const desiredTabStop = CursorColumns.nextRenderTabStop(contentStartVisibleColumn, tabSize);\n            const indentCount = desiredTabStop / tabSize; // will be an integer\n            return cachedStringRepeat(indent, indentCount);\n        }\n    }\n    constructor(range, opts, _languageConfigurationService) {\n        this._languageConfigurationService = _languageConfigurationService;\n        this._opts = opts;\n        this._selection = range;\n        this._selectionId = null;\n        this._useLastEditRangeForCursorEndPosition = false;\n        this._selectionStartColumnStaysPut = false;\n    }\n    _addEditOperation(builder, range, text) {\n        if (this._useLastEditRangeForCursorEndPosition) {\n            builder.addTrackedEditOperation(range, text);\n        }\n        else {\n            builder.addEditOperation(range, text);\n        }\n    }\n    getEditOperations(model, builder) {\n        const startLine = this._selection.startLineNumber;\n        let endLine = this._selection.endLineNumber;\n        if (this._selection.endColumn === 1 && startLine !== endLine) {\n            endLine = endLine - 1;\n        }\n        const { tabSize, indentSize, insertSpaces } = this._opts;\n        const shouldIndentEmptyLines = (startLine === endLine);\n        if (this._opts.useTabStops) {\n            // if indenting or outdenting on a whitespace only line\n            if (this._selection.isEmpty()) {\n                if (/^\\s*$/.test(model.getLineContent(startLine))) {\n                    this._useLastEditRangeForCursorEndPosition = true;\n                }\n            }\n            // keep track of previous line's \"miss-alignment\"\n            let previousLineExtraSpaces = 0, extraSpaces = 0;\n            for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++, previousLineExtraSpaces = extraSpaces) {\n                extraSpaces = 0;\n                const lineText = model.getLineContent(lineNumber);\n                let indentationEndIndex = strings.firstNonWhitespaceIndex(lineText);\n                if (this._opts.isUnshift && (lineText.length === 0 || indentationEndIndex === 0)) {\n                    // empty line or line with no leading whitespace => nothing to do\n                    continue;\n                }\n                if (!shouldIndentEmptyLines && !this._opts.isUnshift && lineText.length === 0) {\n                    // do not indent empty lines => nothing to do\n                    continue;\n                }\n                if (indentationEndIndex === -1) {\n                    // the entire line is whitespace\n                    indentationEndIndex = lineText.length;\n                }\n                if (lineNumber > 1) {\n                    const contentStartVisibleColumn = CursorColumns.visibleColumnFromColumn(lineText, indentationEndIndex + 1, tabSize);\n                    if (contentStartVisibleColumn % indentSize !== 0) {\n                        // The current line is \"miss-aligned\", so let's see if this is expected...\n                        // This can only happen when it has trailing commas in the indent\n                        if (model.tokenization.isCheapToTokenize(lineNumber - 1)) {\n                            const enterAction = getEnterAction(this._opts.autoIndent, model, new Range(lineNumber - 1, model.getLineMaxColumn(lineNumber - 1), lineNumber - 1, model.getLineMaxColumn(lineNumber - 1)), this._languageConfigurationService);\n                            if (enterAction) {\n                                extraSpaces = previousLineExtraSpaces;\n                                if (enterAction.appendText) {\n                                    for (let j = 0, lenJ = enterAction.appendText.length; j < lenJ && extraSpaces < indentSize; j++) {\n                                        if (enterAction.appendText.charCodeAt(j) === 32 /* CharCode.Space */) {\n                                            extraSpaces++;\n                                        }\n                                        else {\n                                            break;\n                                        }\n                                    }\n                                }\n                                if (enterAction.removeText) {\n                                    extraSpaces = Math.max(0, extraSpaces - enterAction.removeText);\n                                }\n                                // Act as if `prefixSpaces` is not part of the indentation\n                                for (let j = 0; j < extraSpaces; j++) {\n                                    if (indentationEndIndex === 0 || lineText.charCodeAt(indentationEndIndex - 1) !== 32 /* CharCode.Space */) {\n                                        break;\n                                    }\n                                    indentationEndIndex--;\n                                }\n                            }\n                        }\n                    }\n                }\n                if (this._opts.isUnshift && indentationEndIndex === 0) {\n                    // line with no leading whitespace => nothing to do\n                    continue;\n                }\n                let desiredIndent;\n                if (this._opts.isUnshift) {\n                    desiredIndent = ShiftCommand_1.unshiftIndent(lineText, indentationEndIndex + 1, tabSize, indentSize, insertSpaces);\n                }\n                else {\n                    desiredIndent = ShiftCommand_1.shiftIndent(lineText, indentationEndIndex + 1, tabSize, indentSize, insertSpaces);\n                }\n                this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, indentationEndIndex + 1), desiredIndent);\n                if (lineNumber === startLine && !this._selection.isEmpty()) {\n                    // Force the startColumn to stay put because we're inserting after it\n                    this._selectionStartColumnStaysPut = (this._selection.startColumn <= indentationEndIndex + 1);\n                }\n            }\n        }\n        else {\n            // if indenting or outdenting on a whitespace only line\n            if (!this._opts.isUnshift && this._selection.isEmpty() && model.getLineLength(startLine) === 0) {\n                this._useLastEditRangeForCursorEndPosition = true;\n            }\n            const oneIndent = (insertSpaces ? cachedStringRepeat(' ', indentSize) : '\\t');\n            for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++) {\n                const lineText = model.getLineContent(lineNumber);\n                let indentationEndIndex = strings.firstNonWhitespaceIndex(lineText);\n                if (this._opts.isUnshift && (lineText.length === 0 || indentationEndIndex === 0)) {\n                    // empty line or line with no leading whitespace => nothing to do\n                    continue;\n                }\n                if (!shouldIndentEmptyLines && !this._opts.isUnshift && lineText.length === 0) {\n                    // do not indent empty lines => nothing to do\n                    continue;\n                }\n                if (indentationEndIndex === -1) {\n                    // the entire line is whitespace\n                    indentationEndIndex = lineText.length;\n                }\n                if (this._opts.isUnshift && indentationEndIndex === 0) {\n                    // line with no leading whitespace => nothing to do\n                    continue;\n                }\n                if (this._opts.isUnshift) {\n                    indentationEndIndex = Math.min(indentationEndIndex, indentSize);\n                    for (let i = 0; i < indentationEndIndex; i++) {\n                        const chr = lineText.charCodeAt(i);\n                        if (chr === 9 /* CharCode.Tab */) {\n                            indentationEndIndex = i + 1;\n                            break;\n                        }\n                    }\n                    this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, indentationEndIndex + 1), '');\n                }\n                else {\n                    this._addEditOperation(builder, new Range(lineNumber, 1, lineNumber, 1), oneIndent);\n                    if (lineNumber === startLine && !this._selection.isEmpty()) {\n                        // Force the startColumn to stay put because we're inserting after it\n                        this._selectionStartColumnStaysPut = (this._selection.startColumn === 1);\n                    }\n                }\n            }\n        }\n        this._selectionId = builder.trackSelection(this._selection);\n    }\n    computeCursorState(model, helper) {\n        if (this._useLastEditRangeForCursorEndPosition) {\n            const lastOp = helper.getInverseEditOperations()[0];\n            return new Selection(lastOp.range.endLineNumber, lastOp.range.endColumn, lastOp.range.endLineNumber, lastOp.range.endColumn);\n        }\n        const result = helper.getTrackedSelection(this._selectionId);\n        if (this._selectionStartColumnStaysPut) {\n            // The selection start should not move\n            const initialStartColumn = this._selection.startColumn;\n            const resultStartColumn = result.startColumn;\n            if (resultStartColumn <= initialStartColumn) {\n                return result;\n            }\n            if (result.getDirection() === 0 /* SelectionDirection.LTR */) {\n                return new Selection(result.startLineNumber, initialStartColumn, result.endLineNumber, result.endColumn);\n            }\n            return new Selection(result.endLineNumber, result.endColumn, result.startLineNumber, initialStartColumn);\n        }\n        return result;\n    }\n};\nShiftCommand = ShiftCommand_1 = __decorate([\n    __param(2, ILanguageConfigurationService)\n], ShiftCommand);\nexport { ShiftCommand };\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 { Range } from '../core/range.js';\nimport { Selection } from '../core/selection.js';\nexport class SurroundSelectionCommand {\n    constructor(range, charBeforeSelection, charAfterSelection) {\n        this._range = range;\n        this._charBeforeSelection = charBeforeSelection;\n        this._charAfterSelection = charAfterSelection;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(new Range(this._range.startLineNumber, this._range.startColumn, this._range.startLineNumber, this._range.startColumn), this._charBeforeSelection);\n        builder.addTrackedEditOperation(new Range(this._range.endLineNumber, this._range.endColumn, this._range.endLineNumber, this._range.endColumn), this._charAfterSelection);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const firstOperationRange = inverseEditOperations[0].range;\n        const secondOperationRange = inverseEditOperations[1].range;\n        return new Selection(firstOperationRange.endLineNumber, firstOperationRange.endColumn, secondOperationRange.endLineNumber, secondOperationRange.endColumn - this._charAfterSelection.length);\n    }\n}\n/**\n * A surround selection command that runs after composition finished.\n */\nexport class CompositionSurroundSelectionCommand {\n    constructor(_position, _text, _charAfter) {\n        this._position = _position;\n        this._text = _text;\n        this._charAfter = _charAfter;\n    }\n    getEditOperations(model, builder) {\n        builder.addTrackedEditOperation(new Range(this._position.lineNumber, this._position.column, this._position.lineNumber, this._position.column), this._text + this._charAfter);\n    }\n    computeCursorState(model, helper) {\n        const inverseEditOperations = helper.getInverseEditOperations();\n        const opRange = inverseEditOperations[0].range;\n        return new Selection(opRange.endLineNumber, opRange.startColumn, opRange.endLineNumber, opRange.endColumn - this._charAfter.length);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { EditOperation } from '../core/editOperation.js';\nimport { Range } from '../core/range.js';\nexport class TrimTrailingWhitespaceCommand {\n    constructor(selection, cursors, trimInRegexesAndStrings) {\n        this._selection = selection;\n        this._cursors = cursors;\n        this._selectionId = null;\n        this._trimInRegexesAndStrings = trimInRegexesAndStrings;\n    }\n    getEditOperations(model, builder) {\n        const ops = trimTrailingWhitespace(model, this._cursors, this._trimInRegexesAndStrings);\n        for (let i = 0, len = ops.length; i < len; i++) {\n            const op = ops[i];\n            builder.addEditOperation(op.range, op.text);\n        }\n        this._selectionId = builder.trackSelection(this._selection);\n    }\n    computeCursorState(model, helper) {\n        return helper.getTrackedSelection(this._selectionId);\n    }\n}\n/**\n * Generate commands for trimming trailing whitespace on a model and ignore lines on which cursors are sitting.\n */\nexport function trimTrailingWhitespace(model, cursors, trimInRegexesAndStrings) {\n    // Sort cursors ascending\n    cursors.sort((a, b) => {\n        if (a.lineNumber === b.lineNumber) {\n            return a.column - b.column;\n        }\n        return a.lineNumber - b.lineNumber;\n    });\n    // Reduce multiple cursors on the same line and only keep the last one on the line\n    for (let i = cursors.length - 2; i >= 0; i--) {\n        if (cursors[i].lineNumber === cursors[i + 1].lineNumber) {\n            // Remove cursor at `i`\n            cursors.splice(i, 1);\n        }\n    }\n    const r = [];\n    let rLen = 0;\n    let cursorIndex = 0;\n    const cursorLen = cursors.length;\n    for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {\n        const lineContent = model.getLineContent(lineNumber);\n        const maxLineColumn = lineContent.length + 1;\n        let minEditColumn = 0;\n        if (cursorIndex < cursorLen && cursors[cursorIndex].lineNumber === lineNumber) {\n            minEditColumn = cursors[cursorIndex].column;\n            cursorIndex++;\n            if (minEditColumn === maxLineColumn) {\n                // The cursor is at the end of the line => no edits for sure on this line\n                continue;\n            }\n        }\n        if (lineContent.length === 0) {\n            continue;\n        }\n        const lastNonWhitespaceIndex = strings.lastNonWhitespaceIndex(lineContent);\n        let fromColumn = 0;\n        if (lastNonWhitespaceIndex === -1) {\n            // Entire line is whitespace\n            fromColumn = 1;\n        }\n        else if (lastNonWhitespaceIndex !== lineContent.length - 1) {\n            // There is trailing whitespace\n            fromColumn = lastNonWhitespaceIndex + 2;\n        }\n        else {\n            // There is no trailing whitespace\n            continue;\n        }\n        if (!trimInRegexesAndStrings) {\n            if (!model.tokenization.hasAccurateTokensForLine(lineNumber)) {\n                // We don't want to force line tokenization, as that can be expensive, but we also don't want to trim\n                // trailing whitespace in lines that are not tokenized yet, as that can be wrong and trim whitespace from\n                // lines that the user requested we don't. So we bail out if the tokens are not accurate for this line.\n                continue;\n            }\n            const lineTokens = model.tokenization.getLineTokens(lineNumber);\n            const fromColumnType = lineTokens.getStandardTokenType(lineTokens.findTokenIndexAtOffset(fromColumn));\n            if (fromColumnType === 2 /* StandardTokenType.String */ || fromColumnType === 3 /* StandardTokenType.RegEx */) {\n                continue;\n            }\n        }\n        fromColumn = Math.max(minEditColumn, fromColumn);\n        r[rLen++] = EditOperation.delete(new Range(lineNumber, fromColumn, lineNumber, maxLineColumn));\n    }\n    return r;\n}\n"],"names":["ReplaceCommand","constructor","range","text","insertsAutoWhitespace","this","_range","_text","getEditOperations","model","builder","addTrackedEditOperation","computeCursorState","helper","srcRange","getInverseEditOperations","getEndPosition","ReplaceCommandThatSelectsText","ReplaceCommandWithoutChangingPosition","getStartPosition","ReplaceCommandWithOffsetCursorState","lineNumberDeltaOffset","columnDeltaOffset","_columnDeltaOffset","_lineNumberDeltaOffset","delta","ReplaceCommandThatPreservesSelection","editRange","initialSelection","forceMoveMarkers","_initialSelection","_forceMoveMarkers","_selectionId","trackSelection","getTrackedSelection","ShiftCommand_1","__decorate","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","__param","paramIndex","decorator","repeatCache","create","cachedStringRepeat","str","count","cache","ShiftCommand","unshiftIndent","line","column","tabSize","indentSize","insertSpaces","contentStartVisibleColumn","indent","shiftIndent","opts","_languageConfigurationService","_opts","_selection","_useLastEditRangeForCursorEndPosition","_selectionStartColumnStaysPut","_addEditOperation","addEditOperation","startLine","startLineNumber","endLine","endLineNumber","endColumn","shouldIndentEmptyLines","useTabStops","isEmpty","test","getLineContent","previousLineExtraSpaces","extraSpaces","lineNumber","lineText","desiredIndent","indentationEndIndex","isUnshift","tokenization","isCheapToTokenize","enterAction","autoIndent","getLineMaxColumn","appendText","j","lenJ","charCodeAt","removeText","Math","max","startColumn","getLineLength","oneIndent","min","lastOp","result","initialStartColumn","getDirection","SurroundSelectionCommand","charBeforeSelection","charAfterSelection","_charBeforeSelection","_charAfterSelection","inverseEditOperations","firstOperationRange","secondOperationRange","CompositionSurroundSelectionCommand","_position","_charAfter","opRange","TrimTrailingWhitespaceCommand","selection","cursors","trimInRegexesAndStrings","_cursors","_trimInRegexesAndStrings","ops","sort","a","b","splice","rLen","cursorIndex","cursorLen","lineCount","getLineCount","lineContent","maxLineColumn","minEditColumn","lastNonWhitespaceIndex","fromColumn","hasAccurateTokensForLine","lineTokens","getLineTokens","fromColumnType","getStandardTokenType","findTokenIndexAtOffset","trimTrailingWhitespace","len","op"],"sourceRoot":""}