{"version":3,"file":"static/js/871_c5e586b976cffdf9bed5.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/contrib/lineSelection/browser/lineSelection.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/contrib/linesOperations/browser/copyLinesCommand.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/contrib/linesOperations/browser/moveLinesCommand.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/contrib/linesOperations/browser/sortLinesCommand.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/contrib/linesOperations/browser/linesOperations.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/contrib/linkedEditing/browser/linkedEditing.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 { EditorAction, registerEditorAction } from '../../../browser/editorExtensions.js';\nimport { CursorMoveCommands } from '../../../common/cursor/cursorMoveCommands.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport * as nls from '../../../../nls.js';\nexport class ExpandLineSelectionAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'expandLineSelection',\n            label: nls.localize('expandLineSelection', \"Expand Line Selection\"),\n            alias: 'Expand Line Selection',\n            precondition: undefined,\n            kbOpts: {\n                weight: 0 /* KeybindingWeight.EditorCore */,\n                kbExpr: EditorContextKeys.textInputFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 42 /* KeyCode.KeyL */\n            },\n        });\n    }\n    run(_accessor, editor, args) {\n        args = args || {};\n        if (!editor.hasModel()) {\n            return;\n        }\n        const viewModel = editor._getViewModel();\n        viewModel.model.pushStackElement();\n        viewModel.setCursorStates(args.source, 3 /* CursorChangeReason.Explicit */, CursorMoveCommands.expandLineSelection(viewModel, viewModel.getCursorStates()));\n        viewModel.revealAllCursors(args.source, true);\n    }\n}\nregisterEditorAction(ExpandLineSelectionAction);\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 '../../../common/core/range.js';\nimport { Selection } from '../../../common/core/selection.js';\nexport class CopyLinesCommand {\n    constructor(selection, isCopyingDown, noop) {\n        this._selection = selection;\n        this._isCopyingDown = isCopyingDown;\n        this._noop = noop || false;\n        this._selectionDirection = 0 /* SelectionDirection.LTR */;\n        this._selectionId = null;\n        this._startLineNumberDelta = 0;\n        this._endLineNumberDelta = 0;\n    }\n    getEditOperations(model, builder) {\n        let s = this._selection;\n        this._startLineNumberDelta = 0;\n        this._endLineNumberDelta = 0;\n        if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {\n            this._endLineNumberDelta = 1;\n            s = s.setEndPosition(s.endLineNumber - 1, model.getLineMaxColumn(s.endLineNumber - 1));\n        }\n        const sourceLines = [];\n        for (let i = s.startLineNumber; i <= s.endLineNumber; i++) {\n            sourceLines.push(model.getLineContent(i));\n        }\n        const sourceText = sourceLines.join('\\n');\n        if (sourceText === '') {\n            // Duplicating empty line\n            if (this._isCopyingDown) {\n                this._startLineNumberDelta++;\n                this._endLineNumberDelta++;\n            }\n        }\n        if (this._noop) {\n            builder.addEditOperation(new Range(s.endLineNumber, model.getLineMaxColumn(s.endLineNumber), s.endLineNumber + 1, 1), s.endLineNumber === model.getLineCount() ? '' : '\\n');\n        }\n        else {\n            if (!this._isCopyingDown) {\n                builder.addEditOperation(new Range(s.endLineNumber, model.getLineMaxColumn(s.endLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), '\\n' + sourceText);\n            }\n            else {\n                builder.addEditOperation(new Range(s.startLineNumber, 1, s.startLineNumber, 1), sourceText + '\\n');\n            }\n        }\n        this._selectionId = builder.trackSelection(s);\n        this._selectionDirection = this._selection.getDirection();\n    }\n    computeCursorState(model, helper) {\n        let result = helper.getTrackedSelection(this._selectionId);\n        if (this._startLineNumberDelta !== 0 || this._endLineNumberDelta !== 0) {\n            let startLineNumber = result.startLineNumber;\n            let startColumn = result.startColumn;\n            let endLineNumber = result.endLineNumber;\n            let endColumn = result.endColumn;\n            if (this._startLineNumberDelta !== 0) {\n                startLineNumber = startLineNumber + this._startLineNumberDelta;\n                startColumn = 1;\n            }\n            if (this._endLineNumberDelta !== 0) {\n                endLineNumber = endLineNumber + this._endLineNumberDelta;\n                endColumn = 1;\n            }\n            result = Selection.createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, this._selectionDirection);\n        }\n        return result;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nimport * as strings from '../../../../base/common/strings.js';\nimport { ShiftCommand } from '../../../common/commands/shiftCommand.js';\nimport { Range } from '../../../common/core/range.js';\nimport { Selection } from '../../../common/core/selection.js';\nimport { IndentAction } from '../../../common/languages/languageConfiguration.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport * as indentUtils from '../../indentation/common/indentUtils.js';\nimport { getGoodIndentForLine, getIndentMetadata } from '../../../common/languages/autoIndent.js';\nimport { getEnterAction } from '../../../common/languages/enterAction.js';\nlet MoveLinesCommand = class MoveLinesCommand {\n    constructor(selection, isMovingDown, autoIndent, _languageConfigurationService) {\n        this._languageConfigurationService = _languageConfigurationService;\n        this._selection = selection;\n        this._isMovingDown = isMovingDown;\n        this._autoIndent = autoIndent;\n        this._selectionId = null;\n        this._moveEndLineSelectionShrink = false;\n    }\n    getEditOperations(model, builder) {\n        const getLanguageId = () => {\n            return model.getLanguageId();\n        };\n        const getLanguageIdAtPosition = (lineNumber, column) => {\n            return model.getLanguageIdAtPosition(lineNumber, column);\n        };\n        const modelLineCount = model.getLineCount();\n        if (this._isMovingDown && this._selection.endLineNumber === modelLineCount) {\n            this._selectionId = builder.trackSelection(this._selection);\n            return;\n        }\n        if (!this._isMovingDown && this._selection.startLineNumber === 1) {\n            this._selectionId = builder.trackSelection(this._selection);\n            return;\n        }\n        this._moveEndPositionDown = false;\n        let s = this._selection;\n        if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {\n            this._moveEndPositionDown = true;\n            s = s.setEndPosition(s.endLineNumber - 1, model.getLineMaxColumn(s.endLineNumber - 1));\n        }\n        const { tabSize, indentSize, insertSpaces } = model.getOptions();\n        const indentConverter = this.buildIndentConverter(tabSize, indentSize, insertSpaces);\n        if (s.startLineNumber === s.endLineNumber && model.getLineMaxColumn(s.startLineNumber) === 1) {\n            // Current line is empty\n            const lineNumber = s.startLineNumber;\n            const otherLineNumber = (this._isMovingDown ? lineNumber + 1 : lineNumber - 1);\n            if (model.getLineMaxColumn(otherLineNumber) === 1) {\n                // Other line number is empty too, so no editing is needed\n                // Add a no-op to force running by the model\n                builder.addEditOperation(new Range(1, 1, 1, 1), null);\n            }\n            else {\n                // Type content from other line number on line number\n                builder.addEditOperation(new Range(lineNumber, 1, lineNumber, 1), model.getLineContent(otherLineNumber));\n                // Remove content from other line number\n                builder.addEditOperation(new Range(otherLineNumber, 1, otherLineNumber, model.getLineMaxColumn(otherLineNumber)), null);\n            }\n            // Track selection at the other line number\n            s = new Selection(otherLineNumber, 1, otherLineNumber, 1);\n        }\n        else {\n            let movingLineNumber;\n            let movingLineText;\n            if (this._isMovingDown) {\n                movingLineNumber = s.endLineNumber + 1;\n                movingLineText = model.getLineContent(movingLineNumber);\n                // Delete line that needs to be moved\n                builder.addEditOperation(new Range(movingLineNumber - 1, model.getLineMaxColumn(movingLineNumber - 1), movingLineNumber, model.getLineMaxColumn(movingLineNumber)), null);\n                let insertingText = movingLineText;\n                if (this.shouldAutoIndent(model, s)) {\n                    const movingLineMatchResult = this.matchEnterRule(model, indentConverter, tabSize, movingLineNumber, s.startLineNumber - 1);\n                    // if s.startLineNumber - 1 matches onEnter rule, we still honor that.\n                    if (movingLineMatchResult !== null) {\n                        const oldIndentation = strings.getLeadingWhitespace(model.getLineContent(movingLineNumber));\n                        const newSpaceCnt = movingLineMatchResult + indentUtils.getSpaceCnt(oldIndentation, tabSize);\n                        const newIndentation = indentUtils.generateIndent(newSpaceCnt, tabSize, insertSpaces);\n                        insertingText = newIndentation + this.trimStart(movingLineText);\n                    }\n                    else {\n                        // no enter rule matches, let's check indentatin rules then.\n                        const virtualModel = {\n                            tokenization: {\n                                getLineTokens: (lineNumber) => {\n                                    if (lineNumber === s.startLineNumber) {\n                                        return model.tokenization.getLineTokens(movingLineNumber);\n                                    }\n                                    else {\n                                        return model.tokenization.getLineTokens(lineNumber);\n                                    }\n                                },\n                                getLanguageId,\n                                getLanguageIdAtPosition,\n                            },\n                            getLineContent: (lineNumber) => {\n                                if (lineNumber === s.startLineNumber) {\n                                    return model.getLineContent(movingLineNumber);\n                                }\n                                else {\n                                    return model.getLineContent(lineNumber);\n                                }\n                            },\n                        };\n                        const indentOfMovingLine = getGoodIndentForLine(this._autoIndent, virtualModel, model.getLanguageIdAtPosition(movingLineNumber, 1), s.startLineNumber, indentConverter, this._languageConfigurationService);\n                        if (indentOfMovingLine !== null) {\n                            const oldIndentation = strings.getLeadingWhitespace(model.getLineContent(movingLineNumber));\n                            const newSpaceCnt = indentUtils.getSpaceCnt(indentOfMovingLine, tabSize);\n                            const oldSpaceCnt = indentUtils.getSpaceCnt(oldIndentation, tabSize);\n                            if (newSpaceCnt !== oldSpaceCnt) {\n                                const newIndentation = indentUtils.generateIndent(newSpaceCnt, tabSize, insertSpaces);\n                                insertingText = newIndentation + this.trimStart(movingLineText);\n                            }\n                        }\n                    }\n                    // add edit operations for moving line first to make sure it's executed after we make indentation change\n                    // to s.startLineNumber\n                    builder.addEditOperation(new Range(s.startLineNumber, 1, s.startLineNumber, 1), insertingText + '\\n');\n                    const ret = this.matchEnterRuleMovingDown(model, indentConverter, tabSize, s.startLineNumber, movingLineNumber, insertingText);\n                    // check if the line being moved before matches onEnter rules, if so let's adjust the indentation by onEnter rules.\n                    if (ret !== null) {\n                        if (ret !== 0) {\n                            this.getIndentEditsOfMovingBlock(model, builder, s, tabSize, insertSpaces, ret);\n                        }\n                    }\n                    else {\n                        // it doesn't match onEnter rules, let's check indentation rules then.\n                        const virtualModel = {\n                            tokenization: {\n                                getLineTokens: (lineNumber) => {\n                                    if (lineNumber === s.startLineNumber) {\n                                        return model.tokenization.getLineTokens(movingLineNumber);\n                                    }\n                                    else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) {\n                                        return model.tokenization.getLineTokens(lineNumber - 1);\n                                    }\n                                    else {\n                                        return model.tokenization.getLineTokens(lineNumber);\n                                    }\n                                },\n                                getLanguageId,\n                                getLanguageIdAtPosition,\n                            },\n                            getLineContent: (lineNumber) => {\n                                if (lineNumber === s.startLineNumber) {\n                                    return insertingText;\n                                }\n                                else if (lineNumber >= s.startLineNumber + 1 && lineNumber <= s.endLineNumber + 1) {\n                                    return model.getLineContent(lineNumber - 1);\n                                }\n                                else {\n                                    return model.getLineContent(lineNumber);\n                                }\n                            },\n                        };\n                        const newIndentatOfMovingBlock = getGoodIndentForLine(this._autoIndent, virtualModel, model.getLanguageIdAtPosition(movingLineNumber, 1), s.startLineNumber + 1, indentConverter, this._languageConfigurationService);\n                        if (newIndentatOfMovingBlock !== null) {\n                            const oldIndentation = strings.getLeadingWhitespace(model.getLineContent(s.startLineNumber));\n                            const newSpaceCnt = indentUtils.getSpaceCnt(newIndentatOfMovingBlock, tabSize);\n                            const oldSpaceCnt = indentUtils.getSpaceCnt(oldIndentation, tabSize);\n                            if (newSpaceCnt !== oldSpaceCnt) {\n                                const spaceCntOffset = newSpaceCnt - oldSpaceCnt;\n                                this.getIndentEditsOfMovingBlock(model, builder, s, tabSize, insertSpaces, spaceCntOffset);\n                            }\n                        }\n                    }\n                }\n                else {\n                    // Insert line that needs to be moved before\n                    builder.addEditOperation(new Range(s.startLineNumber, 1, s.startLineNumber, 1), insertingText + '\\n');\n                }\n            }\n            else {\n                movingLineNumber = s.startLineNumber - 1;\n                movingLineText = model.getLineContent(movingLineNumber);\n                // Delete line that needs to be moved\n                builder.addEditOperation(new Range(movingLineNumber, 1, movingLineNumber + 1, 1), null);\n                // Insert line that needs to be moved after\n                builder.addEditOperation(new Range(s.endLineNumber, model.getLineMaxColumn(s.endLineNumber), s.endLineNumber, model.getLineMaxColumn(s.endLineNumber)), '\\n' + movingLineText);\n                if (this.shouldAutoIndent(model, s)) {\n                    const virtualModel = {\n                        tokenization: {\n                            getLineTokens: (lineNumber) => {\n                                if (lineNumber === movingLineNumber) {\n                                    return model.tokenization.getLineTokens(s.startLineNumber);\n                                }\n                                else {\n                                    return model.tokenization.getLineTokens(lineNumber);\n                                }\n                            },\n                            getLanguageId,\n                            getLanguageIdAtPosition,\n                        },\n                        getLineContent: (lineNumber) => {\n                            if (lineNumber === movingLineNumber) {\n                                return model.getLineContent(s.startLineNumber);\n                            }\n                            else {\n                                return model.getLineContent(lineNumber);\n                            }\n                        },\n                    };\n                    const ret = this.matchEnterRule(model, indentConverter, tabSize, s.startLineNumber, s.startLineNumber - 2);\n                    // check if s.startLineNumber - 2 matches onEnter rules, if so adjust the moving block by onEnter rules.\n                    if (ret !== null) {\n                        if (ret !== 0) {\n                            this.getIndentEditsOfMovingBlock(model, builder, s, tabSize, insertSpaces, ret);\n                        }\n                    }\n                    else {\n                        // it doesn't match any onEnter rule, let's check indentation rules then.\n                        const indentOfFirstLine = getGoodIndentForLine(this._autoIndent, virtualModel, model.getLanguageIdAtPosition(s.startLineNumber, 1), movingLineNumber, indentConverter, this._languageConfigurationService);\n                        if (indentOfFirstLine !== null) {\n                            // adjust the indentation of the moving block\n                            const oldIndent = strings.getLeadingWhitespace(model.getLineContent(s.startLineNumber));\n                            const newSpaceCnt = indentUtils.getSpaceCnt(indentOfFirstLine, tabSize);\n                            const oldSpaceCnt = indentUtils.getSpaceCnt(oldIndent, tabSize);\n                            if (newSpaceCnt !== oldSpaceCnt) {\n                                const spaceCntOffset = newSpaceCnt - oldSpaceCnt;\n                                this.getIndentEditsOfMovingBlock(model, builder, s, tabSize, insertSpaces, spaceCntOffset);\n                            }\n                        }\n                    }\n                }\n            }\n        }\n        this._selectionId = builder.trackSelection(s);\n    }\n    buildIndentConverter(tabSize, indentSize, insertSpaces) {\n        return {\n            shiftIndent: (indentation) => {\n                return ShiftCommand.shiftIndent(indentation, indentation.length + 1, tabSize, indentSize, insertSpaces);\n            },\n            unshiftIndent: (indentation) => {\n                return ShiftCommand.unshiftIndent(indentation, indentation.length + 1, tabSize, indentSize, insertSpaces);\n            }\n        };\n    }\n    parseEnterResult(model, indentConverter, tabSize, line, enter) {\n        if (enter) {\n            let enterPrefix = enter.indentation;\n            if (enter.indentAction === IndentAction.None) {\n                enterPrefix = enter.indentation + enter.appendText;\n            }\n            else if (enter.indentAction === IndentAction.Indent) {\n                enterPrefix = enter.indentation + enter.appendText;\n            }\n            else if (enter.indentAction === IndentAction.IndentOutdent) {\n                enterPrefix = enter.indentation;\n            }\n            else if (enter.indentAction === IndentAction.Outdent) {\n                enterPrefix = indentConverter.unshiftIndent(enter.indentation) + enter.appendText;\n            }\n            const movingLineText = model.getLineContent(line);\n            if (this.trimStart(movingLineText).indexOf(this.trimStart(enterPrefix)) >= 0) {\n                const oldIndentation = strings.getLeadingWhitespace(model.getLineContent(line));\n                let newIndentation = strings.getLeadingWhitespace(enterPrefix);\n                const indentMetadataOfMovelingLine = getIndentMetadata(model, line, this._languageConfigurationService);\n                if (indentMetadataOfMovelingLine !== null && indentMetadataOfMovelingLine & 2 /* IndentConsts.DECREASE_MASK */) {\n                    newIndentation = indentConverter.unshiftIndent(newIndentation);\n                }\n                const newSpaceCnt = indentUtils.getSpaceCnt(newIndentation, tabSize);\n                const oldSpaceCnt = indentUtils.getSpaceCnt(oldIndentation, tabSize);\n                return newSpaceCnt - oldSpaceCnt;\n            }\n        }\n        return null;\n    }\n    /**\n     *\n     * @param model\n     * @param indentConverter\n     * @param tabSize\n     * @param line the line moving down\n     * @param futureAboveLineNumber the line which will be at the `line` position\n     * @param futureAboveLineText\n     */\n    matchEnterRuleMovingDown(model, indentConverter, tabSize, line, futureAboveLineNumber, futureAboveLineText) {\n        if (strings.lastNonWhitespaceIndex(futureAboveLineText) >= 0) {\n            // break\n            const maxColumn = model.getLineMaxColumn(futureAboveLineNumber);\n            const enter = getEnterAction(this._autoIndent, model, new Range(futureAboveLineNumber, maxColumn, futureAboveLineNumber, maxColumn), this._languageConfigurationService);\n            return this.parseEnterResult(model, indentConverter, tabSize, line, enter);\n        }\n        else {\n            // go upwards, starting from `line - 1`\n            let validPrecedingLine = line - 1;\n            while (validPrecedingLine >= 1) {\n                const lineContent = model.getLineContent(validPrecedingLine);\n                const nonWhitespaceIdx = strings.lastNonWhitespaceIndex(lineContent);\n                if (nonWhitespaceIdx >= 0) {\n                    break;\n                }\n                validPrecedingLine--;\n            }\n            if (validPrecedingLine < 1 || line > model.getLineCount()) {\n                return null;\n            }\n            const maxColumn = model.getLineMaxColumn(validPrecedingLine);\n            const enter = getEnterAction(this._autoIndent, model, new Range(validPrecedingLine, maxColumn, validPrecedingLine, maxColumn), this._languageConfigurationService);\n            return this.parseEnterResult(model, indentConverter, tabSize, line, enter);\n        }\n    }\n    matchEnterRule(model, indentConverter, tabSize, line, oneLineAbove, previousLineText) {\n        let validPrecedingLine = oneLineAbove;\n        while (validPrecedingLine >= 1) {\n            // ship empty lines as empty lines just inherit indentation\n            let lineContent;\n            if (validPrecedingLine === oneLineAbove && previousLineText !== undefined) {\n                lineContent = previousLineText;\n            }\n            else {\n                lineContent = model.getLineContent(validPrecedingLine);\n            }\n            const nonWhitespaceIdx = strings.lastNonWhitespaceIndex(lineContent);\n            if (nonWhitespaceIdx >= 0) {\n                break;\n            }\n            validPrecedingLine--;\n        }\n        if (validPrecedingLine < 1 || line > model.getLineCount()) {\n            return null;\n        }\n        const maxColumn = model.getLineMaxColumn(validPrecedingLine);\n        const enter = getEnterAction(this._autoIndent, model, new Range(validPrecedingLine, maxColumn, validPrecedingLine, maxColumn), this._languageConfigurationService);\n        return this.parseEnterResult(model, indentConverter, tabSize, line, enter);\n    }\n    trimStart(str) {\n        return str.replace(/^\\s+/, '');\n    }\n    shouldAutoIndent(model, selection) {\n        if (this._autoIndent < 4 /* EditorAutoIndentStrategy.Full */) {\n            return false;\n        }\n        // if it's not easy to tokenize, we stop auto indent.\n        if (!model.tokenization.isCheapToTokenize(selection.startLineNumber)) {\n            return false;\n        }\n        const languageAtSelectionStart = model.getLanguageIdAtPosition(selection.startLineNumber, 1);\n        const languageAtSelectionEnd = model.getLanguageIdAtPosition(selection.endLineNumber, 1);\n        if (languageAtSelectionStart !== languageAtSelectionEnd) {\n            return false;\n        }\n        if (this._languageConfigurationService.getLanguageConfiguration(languageAtSelectionStart).indentRulesSupport === null) {\n            return false;\n        }\n        return true;\n    }\n    getIndentEditsOfMovingBlock(model, builder, s, tabSize, insertSpaces, offset) {\n        for (let i = s.startLineNumber; i <= s.endLineNumber; i++) {\n            const lineContent = model.getLineContent(i);\n            const originalIndent = strings.getLeadingWhitespace(lineContent);\n            const originalSpacesCnt = indentUtils.getSpaceCnt(originalIndent, tabSize);\n            const newSpacesCnt = originalSpacesCnt + offset;\n            const newIndent = indentUtils.generateIndent(newSpacesCnt, tabSize, insertSpaces);\n            if (newIndent !== originalIndent) {\n                builder.addEditOperation(new Range(i, 1, i, originalIndent.length + 1), newIndent);\n                if (i === s.endLineNumber && s.endColumn <= originalIndent.length + 1 && newIndent === '') {\n                    // as users select part of the original indent white spaces\n                    // when we adjust the indentation of endLine, we should adjust the cursor position as well.\n                    this._moveEndLineSelectionShrink = true;\n                }\n            }\n        }\n    }\n    computeCursorState(model, helper) {\n        let result = helper.getTrackedSelection(this._selectionId);\n        if (this._moveEndPositionDown) {\n            result = result.setEndPosition(result.endLineNumber + 1, 1);\n        }\n        if (this._moveEndLineSelectionShrink && result.startLineNumber < result.endLineNumber) {\n            result = result.setEndPosition(result.endLineNumber, 2);\n        }\n        return result;\n    }\n};\nMoveLinesCommand = __decorate([\n    __param(3, ILanguageConfigurationService)\n], MoveLinesCommand);\nexport { MoveLinesCommand };\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 { EditOperation } from '../../../common/core/editOperation.js';\nimport { Range } from '../../../common/core/range.js';\nexport class SortLinesCommand {\n    static getCollator() {\n        if (!SortLinesCommand._COLLATOR) {\n            SortLinesCommand._COLLATOR = new Intl.Collator();\n        }\n        return SortLinesCommand._COLLATOR;\n    }\n    constructor(selection, descending) {\n        this.selection = selection;\n        this.descending = descending;\n        this.selectionId = null;\n    }\n    getEditOperations(model, builder) {\n        const op = sortLines(model, this.selection, this.descending);\n        if (op) {\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    static canRun(model, selection, descending) {\n        if (model === null) {\n            return false;\n        }\n        const data = getSortData(model, selection, descending);\n        if (!data) {\n            return false;\n        }\n        for (let i = 0, len = data.before.length; i < len; i++) {\n            if (data.before[i] !== data.after[i]) {\n                return true;\n            }\n        }\n        return false;\n    }\n}\nSortLinesCommand._COLLATOR = null;\nfunction getSortData(model, selection, descending) {\n    const startLineNumber = selection.startLineNumber;\n    let endLineNumber = selection.endLineNumber;\n    if (selection.endColumn === 1) {\n        endLineNumber--;\n    }\n    // Nothing to sort if user didn't select anything.\n    if (startLineNumber >= endLineNumber) {\n        return null;\n    }\n    const linesToSort = [];\n    // Get the contents of the selection to be sorted.\n    for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n        linesToSort.push(model.getLineContent(lineNumber));\n    }\n    let sorted = linesToSort.slice(0);\n    sorted.sort(SortLinesCommand.getCollator().compare);\n    // If descending, reverse the order.\n    if (descending === true) {\n        sorted = sorted.reverse();\n    }\n    return {\n        startLineNumber: startLineNumber,\n        endLineNumber: endLineNumber,\n        before: linesToSort,\n        after: sorted\n    };\n}\n/**\n * Generate commands for sorting lines on a model.\n */\nfunction sortLines(model, selection, descending) {\n    const data = getSortData(model, selection, descending);\n    if (!data) {\n        return null;\n    }\n    return EditOperation.replace(new Range(data.startLineNumber, 1, data.endLineNumber, model.getLineMaxColumn(data.endLineNumber)), data.after.join('\\n'));\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { KeyChord } from '../../../../base/common/keyCodes.js';\nimport { CoreEditingCommands } from '../../../browser/coreCommands.js';\nimport { EditorAction, registerEditorAction } from '../../../browser/editorExtensions.js';\nimport { ReplaceCommand, ReplaceCommandThatPreservesSelection, ReplaceCommandThatSelectsText } from '../../../common/commands/replaceCommand.js';\nimport { TrimTrailingWhitespaceCommand } from '../../../common/commands/trimTrailingWhitespaceCommand.js';\nimport { TypeOperations } from '../../../common/cursor/cursorTypeOperations.js';\nimport { EditOperation } from '../../../common/core/editOperation.js';\nimport { Position } from '../../../common/core/position.js';\nimport { Range } from '../../../common/core/range.js';\nimport { Selection } from '../../../common/core/selection.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { CopyLinesCommand } from './copyLinesCommand.js';\nimport { MoveLinesCommand } from './moveLinesCommand.js';\nimport { SortLinesCommand } from './sortLinesCommand.js';\nimport * as nls from '../../../../nls.js';\nimport { MenuId } from '../../../../platform/actions/common/actions.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';\n// copy lines\nclass AbstractCopyLinesAction extends EditorAction {\n    constructor(down, opts) {\n        super(opts);\n        this.down = down;\n    }\n    run(_accessor, editor) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const selections = editor.getSelections().map((selection, index) => ({ selection, index, ignore: false }));\n        selections.sort((a, b) => Range.compareRangesUsingStarts(a.selection, b.selection));\n        // Remove selections that would result in copying the same line\n        let prev = selections[0];\n        for (let i = 1; i < selections.length; i++) {\n            const curr = selections[i];\n            if (prev.selection.endLineNumber === curr.selection.startLineNumber) {\n                // these two selections would copy the same line\n                if (prev.index < curr.index) {\n                    // prev wins\n                    curr.ignore = true;\n                }\n                else {\n                    // curr wins\n                    prev.ignore = true;\n                    prev = curr;\n                }\n            }\n        }\n        const commands = [];\n        for (const selection of selections) {\n            commands.push(new CopyLinesCommand(selection.selection, this.down, selection.ignore));\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, commands);\n        editor.pushUndoStop();\n    }\n}\nclass CopyLinesUpAction extends AbstractCopyLinesAction {\n    constructor() {\n        super(false, {\n            id: 'editor.action.copyLinesUpAction',\n            label: nls.localize('lines.copyUp', \"Copy Line Up\"),\n            alias: 'Copy Line Up',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 16 /* KeyCode.UpArrow */,\n                linux: { primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 16 /* KeyCode.UpArrow */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '2_line',\n                title: nls.localize({ key: 'miCopyLinesUp', comment: ['&& denotes a mnemonic'] }, \"&&Copy Line Up\"),\n                order: 1\n            }\n        });\n    }\n}\nclass CopyLinesDownAction extends AbstractCopyLinesAction {\n    constructor() {\n        super(true, {\n            id: 'editor.action.copyLinesDownAction',\n            label: nls.localize('lines.copyDown', \"Copy Line Down\"),\n            alias: 'Copy Line Down',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 18 /* KeyCode.DownArrow */,\n                linux: { primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 1024 /* KeyMod.Shift */ | 18 /* KeyCode.DownArrow */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '2_line',\n                title: nls.localize({ key: 'miCopyLinesDown', comment: ['&& denotes a mnemonic'] }, \"Co&&py Line Down\"),\n                order: 2\n            }\n        });\n    }\n}\nexport class DuplicateSelectionAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.duplicateSelection',\n            label: nls.localize('duplicateSelection', \"Duplicate Selection\"),\n            alias: 'Duplicate Selection',\n            precondition: EditorContextKeys.writable,\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '2_line',\n                title: nls.localize({ key: 'miDuplicateSelection', comment: ['&& denotes a mnemonic'] }, \"&&Duplicate Selection\"),\n                order: 5\n            }\n        });\n    }\n    run(accessor, editor, args) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const commands = [];\n        const selections = editor.getSelections();\n        const model = editor.getModel();\n        for (const selection of selections) {\n            if (selection.isEmpty()) {\n                commands.push(new CopyLinesCommand(selection, true));\n            }\n            else {\n                const insertSelection = new Selection(selection.endLineNumber, selection.endColumn, selection.endLineNumber, selection.endColumn);\n                commands.push(new ReplaceCommandThatSelectsText(insertSelection, model.getValueInRange(selection)));\n            }\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, commands);\n        editor.pushUndoStop();\n    }\n}\n// move lines\nclass AbstractMoveLinesAction extends EditorAction {\n    constructor(down, opts) {\n        super(opts);\n        this.down = down;\n    }\n    run(accessor, editor) {\n        const languageConfigurationService = accessor.get(ILanguageConfigurationService);\n        const commands = [];\n        const selections = editor.getSelections() || [];\n        const autoIndent = editor.getOption(12 /* EditorOption.autoIndent */);\n        for (const selection of selections) {\n            commands.push(new MoveLinesCommand(selection, this.down, autoIndent, languageConfigurationService));\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, commands);\n        editor.pushUndoStop();\n    }\n}\nclass MoveLinesUpAction extends AbstractMoveLinesAction {\n    constructor() {\n        super(false, {\n            id: 'editor.action.moveLinesUpAction',\n            label: nls.localize('lines.moveUp', \"Move Line Up\"),\n            alias: 'Move Line Up',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 512 /* KeyMod.Alt */ | 16 /* KeyCode.UpArrow */,\n                linux: { primary: 512 /* KeyMod.Alt */ | 16 /* KeyCode.UpArrow */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '2_line',\n                title: nls.localize({ key: 'miMoveLinesUp', comment: ['&& denotes a mnemonic'] }, \"Mo&&ve Line Up\"),\n                order: 3\n            }\n        });\n    }\n}\nclass MoveLinesDownAction extends AbstractMoveLinesAction {\n    constructor() {\n        super(true, {\n            id: 'editor.action.moveLinesDownAction',\n            label: nls.localize('lines.moveDown', \"Move Line Down\"),\n            alias: 'Move Line Down',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 512 /* KeyMod.Alt */ | 18 /* KeyCode.DownArrow */,\n                linux: { primary: 512 /* KeyMod.Alt */ | 18 /* KeyCode.DownArrow */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '2_line',\n                title: nls.localize({ key: 'miMoveLinesDown', comment: ['&& denotes a mnemonic'] }, \"Move &&Line Down\"),\n                order: 4\n            }\n        });\n    }\n}\nexport class AbstractSortLinesAction extends EditorAction {\n    constructor(descending, opts) {\n        super(opts);\n        this.descending = descending;\n    }\n    run(_accessor, editor) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const model = editor.getModel();\n        let selections = editor.getSelections();\n        if (selections.length === 1 && selections[0].isEmpty()) {\n            // Apply to whole document.\n            selections = [new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount()))];\n        }\n        for (const selection of selections) {\n            if (!SortLinesCommand.canRun(editor.getModel(), selection, this.descending)) {\n                return;\n            }\n        }\n        const commands = [];\n        for (let i = 0, len = selections.length; i < len; i++) {\n            commands[i] = new SortLinesCommand(selections[i], this.descending);\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, commands);\n        editor.pushUndoStop();\n    }\n}\nexport class SortLinesAscendingAction extends AbstractSortLinesAction {\n    constructor() {\n        super(false, {\n            id: 'editor.action.sortLinesAscending',\n            label: nls.localize('lines.sortAscending', \"Sort Lines Ascending\"),\n            alias: 'Sort Lines Ascending',\n            precondition: EditorContextKeys.writable\n        });\n    }\n}\nexport class SortLinesDescendingAction extends AbstractSortLinesAction {\n    constructor() {\n        super(true, {\n            id: 'editor.action.sortLinesDescending',\n            label: nls.localize('lines.sortDescending', \"Sort Lines Descending\"),\n            alias: 'Sort Lines Descending',\n            precondition: EditorContextKeys.writable\n        });\n    }\n}\nexport class DeleteDuplicateLinesAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.removeDuplicateLines',\n            label: nls.localize('lines.deleteDuplicates', \"Delete Duplicate Lines\"),\n            alias: 'Delete Duplicate Lines',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    run(_accessor, editor) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const model = editor.getModel();\n        if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {\n            return;\n        }\n        const edits = [];\n        const endCursorState = [];\n        let linesDeleted = 0;\n        let updateSelection = true;\n        let selections = editor.getSelections();\n        if (selections.length === 1 && selections[0].isEmpty()) {\n            // Apply to whole document.\n            selections = [new Selection(1, 1, model.getLineCount(), model.getLineMaxColumn(model.getLineCount()))];\n            updateSelection = false;\n        }\n        for (const selection of selections) {\n            const uniqueLines = new Set();\n            const lines = [];\n            for (let i = selection.startLineNumber; i <= selection.endLineNumber; i++) {\n                const line = model.getLineContent(i);\n                if (uniqueLines.has(line)) {\n                    continue;\n                }\n                lines.push(line);\n                uniqueLines.add(line);\n            }\n            const selectionToReplace = new Selection(selection.startLineNumber, 1, selection.endLineNumber, model.getLineMaxColumn(selection.endLineNumber));\n            const adjustedSelectionStart = selection.startLineNumber - linesDeleted;\n            const finalSelection = new Selection(adjustedSelectionStart, 1, adjustedSelectionStart + lines.length - 1, lines[lines.length - 1].length);\n            edits.push(EditOperation.replace(selectionToReplace, lines.join('\\n')));\n            endCursorState.push(finalSelection);\n            linesDeleted += (selection.endLineNumber - selection.startLineNumber + 1) - lines.length;\n        }\n        editor.pushUndoStop();\n        editor.executeEdits(this.id, edits, updateSelection ? endCursorState : undefined);\n        editor.pushUndoStop();\n    }\n}\nexport class TrimTrailingWhitespaceAction extends EditorAction {\n    constructor() {\n        super({\n            id: TrimTrailingWhitespaceAction.ID,\n            label: nls.localize('lines.trimTrailingWhitespace', \"Trim Trailing Whitespace\"),\n            alias: 'Trim Trailing Whitespace',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 54 /* KeyCode.KeyX */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor, args) {\n        let cursors = [];\n        if (args.reason === 'auto-save') {\n            // See https://github.com/editorconfig/editorconfig-vscode/issues/47\n            // It is very convenient for the editor config extension to invoke this action.\n            // So, if we get a reason:'auto-save' passed in, let's preserve cursor positions.\n            cursors = (editor.getSelections() || []).map(s => new Position(s.positionLineNumber, s.positionColumn));\n        }\n        const selection = editor.getSelection();\n        if (selection === null) {\n            return;\n        }\n        const config = _accessor.get(IConfigurationService);\n        const model = editor.getModel();\n        const trimInRegexAndStrings = config.getValue('files.trimTrailingWhitespaceInRegexAndStrings', { overrideIdentifier: model === null || model === void 0 ? void 0 : model.getLanguageId(), resource: model === null || model === void 0 ? void 0 : model.uri });\n        const command = new TrimTrailingWhitespaceCommand(selection, cursors, trimInRegexAndStrings);\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, [command]);\n        editor.pushUndoStop();\n    }\n}\nTrimTrailingWhitespaceAction.ID = 'editor.action.trimTrailingWhitespace';\nexport class DeleteLinesAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.deleteLines',\n            label: nls.localize('lines.delete', \"Delete Line\"),\n            alias: 'Delete Line',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.textInputFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 41 /* KeyCode.KeyK */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const ops = this._getLinesToRemove(editor);\n        const model = editor.getModel();\n        if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {\n            // Model is empty\n            return;\n        }\n        let linesDeleted = 0;\n        const edits = [];\n        const cursorState = [];\n        for (let i = 0, len = ops.length; i < len; i++) {\n            const op = ops[i];\n            let startLineNumber = op.startLineNumber;\n            let endLineNumber = op.endLineNumber;\n            let startColumn = 1;\n            let endColumn = model.getLineMaxColumn(endLineNumber);\n            if (endLineNumber < model.getLineCount()) {\n                endLineNumber += 1;\n                endColumn = 1;\n            }\n            else if (startLineNumber > 1) {\n                startLineNumber -= 1;\n                startColumn = model.getLineMaxColumn(startLineNumber);\n            }\n            edits.push(EditOperation.replace(new Selection(startLineNumber, startColumn, endLineNumber, endColumn), ''));\n            cursorState.push(new Selection(startLineNumber - linesDeleted, op.positionColumn, startLineNumber - linesDeleted, op.positionColumn));\n            linesDeleted += (op.endLineNumber - op.startLineNumber + 1);\n        }\n        editor.pushUndoStop();\n        editor.executeEdits(this.id, edits, cursorState);\n        editor.pushUndoStop();\n    }\n    _getLinesToRemove(editor) {\n        // Construct delete operations\n        const operations = editor.getSelections().map((s) => {\n            let endLineNumber = s.endLineNumber;\n            if (s.startLineNumber < s.endLineNumber && s.endColumn === 1) {\n                endLineNumber -= 1;\n            }\n            return {\n                startLineNumber: s.startLineNumber,\n                selectionStartColumn: s.selectionStartColumn,\n                endLineNumber: endLineNumber,\n                positionColumn: s.positionColumn\n            };\n        });\n        // Sort delete operations\n        operations.sort((a, b) => {\n            if (a.startLineNumber === b.startLineNumber) {\n                return a.endLineNumber - b.endLineNumber;\n            }\n            return a.startLineNumber - b.startLineNumber;\n        });\n        // Merge delete operations which are adjacent or overlapping\n        const mergedOperations = [];\n        let previousOperation = operations[0];\n        for (let i = 1; i < operations.length; i++) {\n            if (previousOperation.endLineNumber + 1 >= operations[i].startLineNumber) {\n                // Merge current operations into the previous one\n                previousOperation.endLineNumber = operations[i].endLineNumber;\n            }\n            else {\n                // Push previous operation\n                mergedOperations.push(previousOperation);\n                previousOperation = operations[i];\n            }\n        }\n        // Push the last operation\n        mergedOperations.push(previousOperation);\n        return mergedOperations;\n    }\n}\nexport class IndentLinesAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.indentLines',\n            label: nls.localize('lines.indent', \"Indent Line\"),\n            alias: 'Indent Line',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 94 /* KeyCode.BracketRight */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        const viewModel = editor._getViewModel();\n        if (!viewModel) {\n            return;\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, TypeOperations.indent(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));\n        editor.pushUndoStop();\n    }\n}\nclass OutdentLinesAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.outdentLines',\n            label: nls.localize('lines.outdent', \"Outdent Line\"),\n            alias: 'Outdent Line',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 92 /* KeyCode.BracketLeft */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        CoreEditingCommands.Outdent.runEditorCommand(_accessor, editor, null);\n    }\n}\nexport class InsertLineBeforeAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.insertLineBefore',\n            label: nls.localize('lines.insertBefore', \"Insert Line Above\"),\n            alias: 'Insert Line Above',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 3 /* KeyCode.Enter */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        const viewModel = editor._getViewModel();\n        if (!viewModel) {\n            return;\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, TypeOperations.lineInsertBefore(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));\n    }\n}\nexport class InsertLineAfterAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.insertLineAfter',\n            label: nls.localize('lines.insertAfter', \"Insert Line Below\"),\n            alias: 'Insert Line Below',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 3 /* KeyCode.Enter */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        const viewModel = editor._getViewModel();\n        if (!viewModel) {\n            return;\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, TypeOperations.lineInsertAfter(viewModel.cursorConfig, editor.getModel(), editor.getSelections()));\n    }\n}\nexport class AbstractDeleteAllToBoundaryAction extends EditorAction {\n    run(_accessor, editor) {\n        if (!editor.hasModel()) {\n            return;\n        }\n        const primaryCursor = editor.getSelection();\n        const rangesToDelete = this._getRangesToDelete(editor);\n        // merge overlapping selections\n        const effectiveRanges = [];\n        for (let i = 0, count = rangesToDelete.length - 1; i < count; i++) {\n            const range = rangesToDelete[i];\n            const nextRange = rangesToDelete[i + 1];\n            if (Range.intersectRanges(range, nextRange) === null) {\n                effectiveRanges.push(range);\n            }\n            else {\n                rangesToDelete[i + 1] = Range.plusRange(range, nextRange);\n            }\n        }\n        effectiveRanges.push(rangesToDelete[rangesToDelete.length - 1]);\n        const endCursorState = this._getEndCursorState(primaryCursor, effectiveRanges);\n        const edits = effectiveRanges.map(range => {\n            return EditOperation.replace(range, '');\n        });\n        editor.pushUndoStop();\n        editor.executeEdits(this.id, edits, endCursorState);\n        editor.pushUndoStop();\n    }\n}\nexport class DeleteAllLeftAction extends AbstractDeleteAllToBoundaryAction {\n    constructor() {\n        super({\n            id: 'deleteAllLeft',\n            label: nls.localize('lines.deleteAllLeft', \"Delete All Left\"),\n            alias: 'Delete All Left',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.textInputFocus,\n                primary: 0,\n                mac: { primary: 2048 /* KeyMod.CtrlCmd */ | 1 /* KeyCode.Backspace */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    _getEndCursorState(primaryCursor, rangesToDelete) {\n        let endPrimaryCursor = null;\n        const endCursorState = [];\n        let deletedLines = 0;\n        rangesToDelete.forEach(range => {\n            let endCursor;\n            if (range.endColumn === 1 && deletedLines > 0) {\n                const newStartLine = range.startLineNumber - deletedLines;\n                endCursor = new Selection(newStartLine, range.startColumn, newStartLine, range.startColumn);\n            }\n            else {\n                endCursor = new Selection(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n            }\n            deletedLines += range.endLineNumber - range.startLineNumber;\n            if (range.intersectRanges(primaryCursor)) {\n                endPrimaryCursor = endCursor;\n            }\n            else {\n                endCursorState.push(endCursor);\n            }\n        });\n        if (endPrimaryCursor) {\n            endCursorState.unshift(endPrimaryCursor);\n        }\n        return endCursorState;\n    }\n    _getRangesToDelete(editor) {\n        const selections = editor.getSelections();\n        if (selections === null) {\n            return [];\n        }\n        let rangesToDelete = selections;\n        const model = editor.getModel();\n        if (model === null) {\n            return [];\n        }\n        rangesToDelete.sort(Range.compareRangesUsingStarts);\n        rangesToDelete = rangesToDelete.map(selection => {\n            if (selection.isEmpty()) {\n                if (selection.startColumn === 1) {\n                    const deleteFromLine = Math.max(1, selection.startLineNumber - 1);\n                    const deleteFromColumn = selection.startLineNumber === 1 ? 1 : model.getLineLength(deleteFromLine) + 1;\n                    return new Range(deleteFromLine, deleteFromColumn, selection.startLineNumber, 1);\n                }\n                else {\n                    return new Range(selection.startLineNumber, 1, selection.startLineNumber, selection.startColumn);\n                }\n            }\n            else {\n                return new Range(selection.startLineNumber, 1, selection.endLineNumber, selection.endColumn);\n            }\n        });\n        return rangesToDelete;\n    }\n}\nexport class DeleteAllRightAction extends AbstractDeleteAllToBoundaryAction {\n    constructor() {\n        super({\n            id: 'deleteAllRight',\n            label: nls.localize('lines.deleteAllRight', \"Delete All Right\"),\n            alias: 'Delete All Right',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.textInputFocus,\n                primary: 0,\n                mac: { primary: 256 /* KeyMod.WinCtrl */ | 41 /* KeyCode.KeyK */, secondary: [2048 /* KeyMod.CtrlCmd */ | 20 /* KeyCode.Delete */] },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    _getEndCursorState(primaryCursor, rangesToDelete) {\n        let endPrimaryCursor = null;\n        const endCursorState = [];\n        for (let i = 0, len = rangesToDelete.length, offset = 0; i < len; i++) {\n            const range = rangesToDelete[i];\n            const endCursor = new Selection(range.startLineNumber - offset, range.startColumn, range.startLineNumber - offset, range.startColumn);\n            if (range.intersectRanges(primaryCursor)) {\n                endPrimaryCursor = endCursor;\n            }\n            else {\n                endCursorState.push(endCursor);\n            }\n        }\n        if (endPrimaryCursor) {\n            endCursorState.unshift(endPrimaryCursor);\n        }\n        return endCursorState;\n    }\n    _getRangesToDelete(editor) {\n        const model = editor.getModel();\n        if (model === null) {\n            return [];\n        }\n        const selections = editor.getSelections();\n        if (selections === null) {\n            return [];\n        }\n        const rangesToDelete = selections.map((sel) => {\n            if (sel.isEmpty()) {\n                const maxColumn = model.getLineMaxColumn(sel.startLineNumber);\n                if (sel.startColumn === maxColumn) {\n                    return new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber + 1, 1);\n                }\n                else {\n                    return new Range(sel.startLineNumber, sel.startColumn, sel.startLineNumber, maxColumn);\n                }\n            }\n            return sel;\n        });\n        rangesToDelete.sort(Range.compareRangesUsingStarts);\n        return rangesToDelete;\n    }\n}\nexport class JoinLinesAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.joinLines',\n            label: nls.localize('lines.joinLines', \"Join Lines\"),\n            alias: 'Join Lines',\n            precondition: EditorContextKeys.writable,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 0,\n                mac: { primary: 256 /* KeyMod.WinCtrl */ | 40 /* KeyCode.KeyJ */ },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    run(_accessor, editor) {\n        const selections = editor.getSelections();\n        if (selections === null) {\n            return;\n        }\n        let primaryCursor = editor.getSelection();\n        if (primaryCursor === null) {\n            return;\n        }\n        selections.sort(Range.compareRangesUsingStarts);\n        const reducedSelections = [];\n        const lastSelection = selections.reduce((previousValue, currentValue) => {\n            if (previousValue.isEmpty()) {\n                if (previousValue.endLineNumber === currentValue.startLineNumber) {\n                    if (primaryCursor.equalsSelection(previousValue)) {\n                        primaryCursor = currentValue;\n                    }\n                    return currentValue;\n                }\n                if (currentValue.startLineNumber > previousValue.endLineNumber + 1) {\n                    reducedSelections.push(previousValue);\n                    return currentValue;\n                }\n                else {\n                    return new Selection(previousValue.startLineNumber, previousValue.startColumn, currentValue.endLineNumber, currentValue.endColumn);\n                }\n            }\n            else {\n                if (currentValue.startLineNumber > previousValue.endLineNumber) {\n                    reducedSelections.push(previousValue);\n                    return currentValue;\n                }\n                else {\n                    return new Selection(previousValue.startLineNumber, previousValue.startColumn, currentValue.endLineNumber, currentValue.endColumn);\n                }\n            }\n        });\n        reducedSelections.push(lastSelection);\n        const model = editor.getModel();\n        if (model === null) {\n            return;\n        }\n        const edits = [];\n        const endCursorState = [];\n        let endPrimaryCursor = primaryCursor;\n        let lineOffset = 0;\n        for (let i = 0, len = reducedSelections.length; i < len; i++) {\n            const selection = reducedSelections[i];\n            const startLineNumber = selection.startLineNumber;\n            const startColumn = 1;\n            let columnDeltaOffset = 0;\n            let endLineNumber, endColumn;\n            const selectionEndPositionOffset = model.getLineLength(selection.endLineNumber) - selection.endColumn;\n            if (selection.isEmpty() || selection.startLineNumber === selection.endLineNumber) {\n                const position = selection.getStartPosition();\n                if (position.lineNumber < model.getLineCount()) {\n                    endLineNumber = startLineNumber + 1;\n                    endColumn = model.getLineMaxColumn(endLineNumber);\n                }\n                else {\n                    endLineNumber = position.lineNumber;\n                    endColumn = model.getLineMaxColumn(position.lineNumber);\n                }\n            }\n            else {\n                endLineNumber = selection.endLineNumber;\n                endColumn = model.getLineMaxColumn(endLineNumber);\n            }\n            let trimmedLinesContent = model.getLineContent(startLineNumber);\n            for (let i = startLineNumber + 1; i <= endLineNumber; i++) {\n                const lineText = model.getLineContent(i);\n                const firstNonWhitespaceIdx = model.getLineFirstNonWhitespaceColumn(i);\n                if (firstNonWhitespaceIdx >= 1) {\n                    let insertSpace = true;\n                    if (trimmedLinesContent === '') {\n                        insertSpace = false;\n                    }\n                    if (insertSpace && (trimmedLinesContent.charAt(trimmedLinesContent.length - 1) === ' ' ||\n                        trimmedLinesContent.charAt(trimmedLinesContent.length - 1) === '\\t')) {\n                        insertSpace = false;\n                        trimmedLinesContent = trimmedLinesContent.replace(/[\\s\\uFEFF\\xA0]+$/g, ' ');\n                    }\n                    const lineTextWithoutIndent = lineText.substr(firstNonWhitespaceIdx - 1);\n                    trimmedLinesContent += (insertSpace ? ' ' : '') + lineTextWithoutIndent;\n                    if (insertSpace) {\n                        columnDeltaOffset = lineTextWithoutIndent.length + 1;\n                    }\n                    else {\n                        columnDeltaOffset = lineTextWithoutIndent.length;\n                    }\n                }\n                else {\n                    columnDeltaOffset = 0;\n                }\n            }\n            const deleteSelection = new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n            if (!deleteSelection.isEmpty()) {\n                let resultSelection;\n                if (selection.isEmpty()) {\n                    edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));\n                    resultSelection = new Selection(deleteSelection.startLineNumber - lineOffset, trimmedLinesContent.length - columnDeltaOffset + 1, startLineNumber - lineOffset, trimmedLinesContent.length - columnDeltaOffset + 1);\n                }\n                else {\n                    if (selection.startLineNumber === selection.endLineNumber) {\n                        edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));\n                        resultSelection = new Selection(selection.startLineNumber - lineOffset, selection.startColumn, selection.endLineNumber - lineOffset, selection.endColumn);\n                    }\n                    else {\n                        edits.push(EditOperation.replace(deleteSelection, trimmedLinesContent));\n                        resultSelection = new Selection(selection.startLineNumber - lineOffset, selection.startColumn, selection.startLineNumber - lineOffset, trimmedLinesContent.length - selectionEndPositionOffset);\n                    }\n                }\n                if (Range.intersectRanges(deleteSelection, primaryCursor) !== null) {\n                    endPrimaryCursor = resultSelection;\n                }\n                else {\n                    endCursorState.push(resultSelection);\n                }\n            }\n            lineOffset += deleteSelection.endLineNumber - deleteSelection.startLineNumber;\n        }\n        endCursorState.unshift(endPrimaryCursor);\n        editor.pushUndoStop();\n        editor.executeEdits(this.id, edits, endCursorState);\n        editor.pushUndoStop();\n    }\n}\nexport class TransposeAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.transpose',\n            label: nls.localize('editor.transpose', \"Transpose Characters around the Cursor\"),\n            alias: 'Transpose Characters around the Cursor',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    run(_accessor, editor) {\n        const selections = editor.getSelections();\n        if (selections === null) {\n            return;\n        }\n        const model = editor.getModel();\n        if (model === null) {\n            return;\n        }\n        const commands = [];\n        for (let i = 0, len = selections.length; i < len; i++) {\n            const selection = selections[i];\n            if (!selection.isEmpty()) {\n                continue;\n            }\n            const cursor = selection.getStartPosition();\n            const maxColumn = model.getLineMaxColumn(cursor.lineNumber);\n            if (cursor.column >= maxColumn) {\n                if (cursor.lineNumber === model.getLineCount()) {\n                    continue;\n                }\n                // The cursor is at the end of current line and current line is not empty\n                // then we transpose the character before the cursor and the line break if there is any following line.\n                const deleteSelection = new Range(cursor.lineNumber, Math.max(1, cursor.column - 1), cursor.lineNumber + 1, 1);\n                const chars = model.getValueInRange(deleteSelection).split('').reverse().join('');\n                commands.push(new ReplaceCommand(new Selection(cursor.lineNumber, Math.max(1, cursor.column - 1), cursor.lineNumber + 1, 1), chars));\n            }\n            else {\n                const deleteSelection = new Range(cursor.lineNumber, Math.max(1, cursor.column - 1), cursor.lineNumber, cursor.column + 1);\n                const chars = model.getValueInRange(deleteSelection).split('').reverse().join('');\n                commands.push(new ReplaceCommandThatPreservesSelection(deleteSelection, chars, new Selection(cursor.lineNumber, cursor.column + 1, cursor.lineNumber, cursor.column + 1)));\n            }\n        }\n        editor.pushUndoStop();\n        editor.executeCommands(this.id, commands);\n        editor.pushUndoStop();\n    }\n}\nexport class AbstractCaseAction extends EditorAction {\n    run(_accessor, editor) {\n        const selections = editor.getSelections();\n        if (selections === null) {\n            return;\n        }\n        const model = editor.getModel();\n        if (model === null) {\n            return;\n        }\n        const wordSeparators = editor.getOption(131 /* EditorOption.wordSeparators */);\n        const textEdits = [];\n        for (const selection of selections) {\n            if (selection.isEmpty()) {\n                const cursor = selection.getStartPosition();\n                const word = editor.getConfiguredWordAtPosition(cursor);\n                if (!word) {\n                    continue;\n                }\n                const wordRange = new Range(cursor.lineNumber, word.startColumn, cursor.lineNumber, word.endColumn);\n                const text = model.getValueInRange(wordRange);\n                textEdits.push(EditOperation.replace(wordRange, this._modifyText(text, wordSeparators)));\n            }\n            else {\n                const text = model.getValueInRange(selection);\n                textEdits.push(EditOperation.replace(selection, this._modifyText(text, wordSeparators)));\n            }\n        }\n        editor.pushUndoStop();\n        editor.executeEdits(this.id, textEdits);\n        editor.pushUndoStop();\n    }\n}\nexport class UpperCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToUppercase',\n            label: nls.localize('editor.transformToUppercase', \"Transform to Uppercase\"),\n            alias: 'Transform to Uppercase',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        return text.toLocaleUpperCase();\n    }\n}\nexport class LowerCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToLowercase',\n            label: nls.localize('editor.transformToLowercase', \"Transform to Lowercase\"),\n            alias: 'Transform to Lowercase',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        return text.toLocaleLowerCase();\n    }\n}\nclass BackwardsCompatibleRegExp {\n    constructor(_pattern, _flags) {\n        this._pattern = _pattern;\n        this._flags = _flags;\n        this._actual = null;\n        this._evaluated = false;\n    }\n    get() {\n        if (!this._evaluated) {\n            this._evaluated = true;\n            try {\n                this._actual = new RegExp(this._pattern, this._flags);\n            }\n            catch (err) {\n                // this browser does not support this regular expression\n            }\n        }\n        return this._actual;\n    }\n    isSupported() {\n        return (this.get() !== null);\n    }\n}\nexport class TitleCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToTitlecase',\n            label: nls.localize('editor.transformToTitlecase', \"Transform to Title Case\"),\n            alias: 'Transform to Title Case',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        const titleBoundary = TitleCaseAction.titleBoundary.get();\n        if (!titleBoundary) {\n            // cannot support this\n            return text;\n        }\n        return text\n            .toLocaleLowerCase()\n            .replace(titleBoundary, (b) => b.toLocaleUpperCase());\n    }\n}\nTitleCaseAction.titleBoundary = new BackwardsCompatibleRegExp('(^|[^\\\\p{L}\\\\p{N}\\']|((^|\\\\P{L})\\'))\\\\p{L}', 'gmu');\nexport class SnakeCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToSnakecase',\n            label: nls.localize('editor.transformToSnakecase', \"Transform to Snake Case\"),\n            alias: 'Transform to Snake Case',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        const caseBoundary = SnakeCaseAction.caseBoundary.get();\n        const singleLetters = SnakeCaseAction.singleLetters.get();\n        if (!caseBoundary || !singleLetters) {\n            // cannot support this\n            return text;\n        }\n        return (text\n            .replace(caseBoundary, '$1_$2')\n            .replace(singleLetters, '$1_$2$3')\n            .toLocaleLowerCase());\n    }\n}\nSnakeCaseAction.caseBoundary = new BackwardsCompatibleRegExp('(\\\\p{Ll})(\\\\p{Lu})', 'gmu');\nSnakeCaseAction.singleLetters = new BackwardsCompatibleRegExp('(\\\\p{Lu}|\\\\p{N})(\\\\p{Lu})(\\\\p{Ll})', 'gmu');\nexport class CamelCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToCamelcase',\n            label: nls.localize('editor.transformToCamelcase', \"Transform to Camel Case\"),\n            alias: 'Transform to Camel Case',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        const wordBoundary = CamelCaseAction.wordBoundary.get();\n        if (!wordBoundary) {\n            // cannot support this\n            return text;\n        }\n        const words = text.split(wordBoundary);\n        const firstWord = words.shift();\n        return firstWord + words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1))\n            .join('');\n    }\n}\nCamelCaseAction.wordBoundary = new BackwardsCompatibleRegExp('[_\\\\s-]', 'gm');\nexport class PascalCaseAction extends AbstractCaseAction {\n    constructor() {\n        super({\n            id: 'editor.action.transformToPascalcase',\n            label: nls.localize('editor.transformToPascalcase', \"Transform to Pascal Case\"),\n            alias: 'Transform to Pascal Case',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, wordSeparators) {\n        const wordBoundary = PascalCaseAction.wordBoundary.get();\n        const wordBoundaryToMaintain = PascalCaseAction.wordBoundaryToMaintain.get();\n        if (!wordBoundary || !wordBoundaryToMaintain) {\n            // cannot support this\n            return text;\n        }\n        const wordsWithMaintainBoundaries = text.split(wordBoundaryToMaintain);\n        const words = wordsWithMaintainBoundaries.map((word) => word.split(wordBoundary)).flat();\n        return words.map((word) => word.substring(0, 1).toLocaleUpperCase() + word.substring(1))\n            .join('');\n    }\n}\nPascalCaseAction.wordBoundary = new BackwardsCompatibleRegExp('[_\\\\s-]', 'gm');\nPascalCaseAction.wordBoundaryToMaintain = new BackwardsCompatibleRegExp('(?<=\\\\.)', 'gm');\nexport class KebabCaseAction extends AbstractCaseAction {\n    static isSupported() {\n        const areAllRegexpsSupported = [\n            this.caseBoundary,\n            this.singleLetters,\n            this.underscoreBoundary,\n        ].every((regexp) => regexp.isSupported());\n        return areAllRegexpsSupported;\n    }\n    constructor() {\n        super({\n            id: 'editor.action.transformToKebabcase',\n            label: nls.localize('editor.transformToKebabcase', 'Transform to Kebab Case'),\n            alias: 'Transform to Kebab Case',\n            precondition: EditorContextKeys.writable\n        });\n    }\n    _modifyText(text, _) {\n        const caseBoundary = KebabCaseAction.caseBoundary.get();\n        const singleLetters = KebabCaseAction.singleLetters.get();\n        const underscoreBoundary = KebabCaseAction.underscoreBoundary.get();\n        if (!caseBoundary || !singleLetters || !underscoreBoundary) {\n            // one or more regexps aren't supported\n            return text;\n        }\n        return text\n            .replace(underscoreBoundary, '$1-$3')\n            .replace(caseBoundary, '$1-$2')\n            .replace(singleLetters, '$1-$2')\n            .toLocaleLowerCase();\n    }\n}\nKebabCaseAction.caseBoundary = new BackwardsCompatibleRegExp('(\\\\p{Ll})(\\\\p{Lu})', 'gmu');\nKebabCaseAction.singleLetters = new BackwardsCompatibleRegExp('(\\\\p{Lu}|\\\\p{N})(\\\\p{Lu}\\\\p{Ll})', 'gmu');\nKebabCaseAction.underscoreBoundary = new BackwardsCompatibleRegExp('(\\\\S)(_)(\\\\S)', 'gm');\nregisterEditorAction(CopyLinesUpAction);\nregisterEditorAction(CopyLinesDownAction);\nregisterEditorAction(DuplicateSelectionAction);\nregisterEditorAction(MoveLinesUpAction);\nregisterEditorAction(MoveLinesDownAction);\nregisterEditorAction(SortLinesAscendingAction);\nregisterEditorAction(SortLinesDescendingAction);\nregisterEditorAction(DeleteDuplicateLinesAction);\nregisterEditorAction(TrimTrailingWhitespaceAction);\nregisterEditorAction(DeleteLinesAction);\nregisterEditorAction(IndentLinesAction);\nregisterEditorAction(OutdentLinesAction);\nregisterEditorAction(InsertLineBeforeAction);\nregisterEditorAction(InsertLineAfterAction);\nregisterEditorAction(DeleteAllLeftAction);\nregisterEditorAction(DeleteAllRightAction);\nregisterEditorAction(JoinLinesAction);\nregisterEditorAction(TransposeAction);\nregisterEditorAction(UpperCaseAction);\nregisterEditorAction(LowerCaseAction);\nif (SnakeCaseAction.caseBoundary.isSupported() && SnakeCaseAction.singleLetters.isSupported()) {\n    registerEditorAction(SnakeCaseAction);\n}\nif (CamelCaseAction.wordBoundary.isSupported()) {\n    registerEditorAction(CamelCaseAction);\n}\nif (PascalCaseAction.wordBoundary.isSupported()) {\n    registerEditorAction(PascalCaseAction);\n}\nif (TitleCaseAction.titleBoundary.isSupported()) {\n    registerEditorAction(TitleCaseAction);\n}\nif (KebabCaseAction.isSupported()) {\n    registerEditorAction(KebabCaseAction);\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 LinkedEditingContribution_1;\nimport * as arrays from '../../../../base/common/arrays.js';\nimport { Delayer, first } from '../../../../base/common/async.js';\nimport { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';\nimport { Color } from '../../../../base/common/color.js';\nimport { isCancellationError, onUnexpectedError, onUnexpectedExternalError } from '../../../../base/common/errors.js';\nimport { Event } from '../../../../base/common/event.js';\nimport { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';\nimport * as strings from '../../../../base/common/strings.js';\nimport { URI } from '../../../../base/common/uri.js';\nimport { EditorAction, EditorCommand, registerEditorAction, registerEditorCommand, registerEditorContribution, registerModelAndPositionCommand } from '../../../browser/editorExtensions.js';\nimport { ICodeEditorService } from '../../../browser/services/codeEditorService.js';\nimport { Position } from '../../../common/core/position.js';\nimport { Range } from '../../../common/core/range.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { ModelDecorationOptions } from '../../../common/model/textModel.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport * as nls from '../../../../nls.js';\nimport { ContextKeyExpr, IContextKeyService, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';\nimport { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';\nimport { registerColor } from '../../../../platform/theme/common/colorRegistry.js';\nimport { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';\nimport { StopWatch } from '../../../../base/common/stopwatch.js';\nimport './linkedEditing.css';\nexport const CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE = new RawContextKey('LinkedEditingInputVisible', false);\nconst DECORATION_CLASS_NAME = 'linked-editing-decoration';\nlet LinkedEditingContribution = LinkedEditingContribution_1 = class LinkedEditingContribution extends Disposable {\n    static get(editor) {\n        return editor.getContribution(LinkedEditingContribution_1.ID);\n    }\n    constructor(editor, contextKeyService, languageFeaturesService, languageConfigurationService, languageFeatureDebounceService) {\n        super();\n        this.languageConfigurationService = languageConfigurationService;\n        this._syncRangesToken = 0;\n        this._localToDispose = this._register(new DisposableStore());\n        this._editor = editor;\n        this._providers = languageFeaturesService.linkedEditingRangeProvider;\n        this._enabled = false;\n        this._visibleContextKey = CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE.bindTo(contextKeyService);\n        this._debounceInformation = languageFeatureDebounceService.for(this._providers, 'Linked Editing', { max: 200 });\n        this._currentDecorations = this._editor.createDecorationsCollection();\n        this._languageWordPattern = null;\n        this._currentWordPattern = null;\n        this._ignoreChangeEvent = false;\n        this._localToDispose = this._register(new DisposableStore());\n        this._rangeUpdateTriggerPromise = null;\n        this._rangeSyncTriggerPromise = null;\n        this._currentRequestCts = null;\n        this._currentRequestPosition = null;\n        this._currentRequestModelVersion = null;\n        this._register(this._editor.onDidChangeModel(() => this.reinitialize(true)));\n        this._register(this._editor.onDidChangeConfiguration(e => {\n            if (e.hasChanged(70 /* EditorOption.linkedEditing */) || e.hasChanged(93 /* EditorOption.renameOnType */)) {\n                this.reinitialize(false);\n            }\n        }));\n        this._register(this._providers.onDidChange(() => this.reinitialize(false)));\n        this._register(this._editor.onDidChangeModelLanguage(() => this.reinitialize(true)));\n        this.reinitialize(true);\n    }\n    reinitialize(forceRefresh) {\n        const model = this._editor.getModel();\n        const isEnabled = model !== null && (this._editor.getOption(70 /* EditorOption.linkedEditing */) || this._editor.getOption(93 /* EditorOption.renameOnType */)) && this._providers.has(model);\n        if (isEnabled === this._enabled && !forceRefresh) {\n            return;\n        }\n        this._enabled = isEnabled;\n        this.clearRanges();\n        this._localToDispose.clear();\n        if (!isEnabled || model === null) {\n            return;\n        }\n        this._localToDispose.add(Event.runAndSubscribe(model.onDidChangeLanguageConfiguration, () => {\n            this._languageWordPattern = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();\n        }));\n        const rangeUpdateScheduler = new Delayer(this._debounceInformation.get(model));\n        const triggerRangeUpdate = () => {\n            var _a;\n            this._rangeUpdateTriggerPromise = rangeUpdateScheduler.trigger(() => this.updateRanges(), (_a = this._debounceDuration) !== null && _a !== void 0 ? _a : this._debounceInformation.get(model));\n        };\n        const rangeSyncScheduler = new Delayer(0);\n        const triggerRangeSync = (token) => {\n            this._rangeSyncTriggerPromise = rangeSyncScheduler.trigger(() => this._syncRanges(token));\n        };\n        this._localToDispose.add(this._editor.onDidChangeCursorPosition(() => {\n            triggerRangeUpdate();\n        }));\n        this._localToDispose.add(this._editor.onDidChangeModelContent((e) => {\n            if (!this._ignoreChangeEvent) {\n                if (this._currentDecorations.length > 0) {\n                    const referenceRange = this._currentDecorations.getRange(0);\n                    if (referenceRange && e.changes.every(c => referenceRange.intersectRanges(c.range))) {\n                        triggerRangeSync(this._syncRangesToken);\n                        return;\n                    }\n                }\n            }\n            triggerRangeUpdate();\n        }));\n        this._localToDispose.add({\n            dispose: () => {\n                rangeUpdateScheduler.dispose();\n                rangeSyncScheduler.dispose();\n            }\n        });\n        this.updateRanges();\n    }\n    _syncRanges(token) {\n        // delayed invocation, make sure we're still on\n        if (!this._editor.hasModel() || token !== this._syncRangesToken || this._currentDecorations.length === 0) {\n            // nothing to do\n            return;\n        }\n        const model = this._editor.getModel();\n        const referenceRange = this._currentDecorations.getRange(0);\n        if (!referenceRange || referenceRange.startLineNumber !== referenceRange.endLineNumber) {\n            return this.clearRanges();\n        }\n        const referenceValue = model.getValueInRange(referenceRange);\n        if (this._currentWordPattern) {\n            const match = referenceValue.match(this._currentWordPattern);\n            const matchLength = match ? match[0].length : 0;\n            if (matchLength !== referenceValue.length) {\n                return this.clearRanges();\n            }\n        }\n        const edits = [];\n        for (let i = 1, len = this._currentDecorations.length; i < len; i++) {\n            const mirrorRange = this._currentDecorations.getRange(i);\n            if (!mirrorRange) {\n                continue;\n            }\n            if (mirrorRange.startLineNumber !== mirrorRange.endLineNumber) {\n                edits.push({\n                    range: mirrorRange,\n                    text: referenceValue\n                });\n            }\n            else {\n                let oldValue = model.getValueInRange(mirrorRange);\n                let newValue = referenceValue;\n                let rangeStartColumn = mirrorRange.startColumn;\n                let rangeEndColumn = mirrorRange.endColumn;\n                const commonPrefixLength = strings.commonPrefixLength(oldValue, newValue);\n                rangeStartColumn += commonPrefixLength;\n                oldValue = oldValue.substr(commonPrefixLength);\n                newValue = newValue.substr(commonPrefixLength);\n                const commonSuffixLength = strings.commonSuffixLength(oldValue, newValue);\n                rangeEndColumn -= commonSuffixLength;\n                oldValue = oldValue.substr(0, oldValue.length - commonSuffixLength);\n                newValue = newValue.substr(0, newValue.length - commonSuffixLength);\n                if (rangeStartColumn !== rangeEndColumn || newValue.length !== 0) {\n                    edits.push({\n                        range: new Range(mirrorRange.startLineNumber, rangeStartColumn, mirrorRange.endLineNumber, rangeEndColumn),\n                        text: newValue\n                    });\n                }\n            }\n        }\n        if (edits.length === 0) {\n            return;\n        }\n        try {\n            this._editor.popUndoStop();\n            this._ignoreChangeEvent = true;\n            const prevEditOperationType = this._editor._getViewModel().getPrevEditOperationType();\n            this._editor.executeEdits('linkedEditing', edits);\n            this._editor._getViewModel().setPrevEditOperationType(prevEditOperationType);\n        }\n        finally {\n            this._ignoreChangeEvent = false;\n        }\n    }\n    dispose() {\n        this.clearRanges();\n        super.dispose();\n    }\n    clearRanges() {\n        this._visibleContextKey.set(false);\n        this._currentDecorations.clear();\n        if (this._currentRequestCts) {\n            this._currentRequestCts.cancel();\n            this._currentRequestCts = null;\n            this._currentRequestPosition = null;\n        }\n    }\n    async updateRanges(force = false) {\n        if (!this._editor.hasModel()) {\n            this.clearRanges();\n            return;\n        }\n        const position = this._editor.getPosition();\n        if (!this._enabled && !force || this._editor.getSelections().length > 1) {\n            // disabled or multicursor\n            this.clearRanges();\n            return;\n        }\n        const model = this._editor.getModel();\n        const modelVersionId = model.getVersionId();\n        if (this._currentRequestPosition && this._currentRequestModelVersion === modelVersionId) {\n            if (position.equals(this._currentRequestPosition)) {\n                return; // same position\n            }\n            if (this._currentDecorations.length > 0) {\n                const range = this._currentDecorations.getRange(0);\n                if (range && range.containsPosition(position)) {\n                    return; // just moving inside the existing primary range\n                }\n            }\n        }\n        // Clear existing decorations while we compute new ones\n        this.clearRanges();\n        this._currentRequestPosition = position;\n        this._currentRequestModelVersion = modelVersionId;\n        const currentRequestCts = this._currentRequestCts = new CancellationTokenSource();\n        try {\n            const sw = new StopWatch(false);\n            const response = await getLinkedEditingRanges(this._providers, model, position, currentRequestCts.token);\n            this._debounceInformation.update(model, sw.elapsed());\n            if (currentRequestCts !== this._currentRequestCts) {\n                return;\n            }\n            this._currentRequestCts = null;\n            if (modelVersionId !== model.getVersionId()) {\n                return;\n            }\n            let ranges = [];\n            if (response === null || response === void 0 ? void 0 : response.ranges) {\n                ranges = response.ranges;\n            }\n            this._currentWordPattern = (response === null || response === void 0 ? void 0 : response.wordPattern) || this._languageWordPattern;\n            let foundReferenceRange = false;\n            for (let i = 0, len = ranges.length; i < len; i++) {\n                if (Range.containsPosition(ranges[i], position)) {\n                    foundReferenceRange = true;\n                    if (i !== 0) {\n                        const referenceRange = ranges[i];\n                        ranges.splice(i, 1);\n                        ranges.unshift(referenceRange);\n                    }\n                    break;\n                }\n            }\n            if (!foundReferenceRange) {\n                // Cannot do linked editing if the ranges are not where the cursor is...\n                this.clearRanges();\n                return;\n            }\n            const decorations = ranges.map(range => ({ range: range, options: LinkedEditingContribution_1.DECORATION }));\n            this._visibleContextKey.set(true);\n            this._currentDecorations.set(decorations);\n            this._syncRangesToken++; // cancel any pending syncRanges call\n        }\n        catch (err) {\n            if (!isCancellationError(err)) {\n                onUnexpectedError(err);\n            }\n            if (this._currentRequestCts === currentRequestCts || !this._currentRequestCts) {\n                // stop if we are still the latest request\n                this.clearRanges();\n            }\n        }\n    }\n};\nLinkedEditingContribution.ID = 'editor.contrib.linkedEditing';\nLinkedEditingContribution.DECORATION = ModelDecorationOptions.register({\n    description: 'linked-editing',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    className: DECORATION_CLASS_NAME\n});\nLinkedEditingContribution = LinkedEditingContribution_1 = __decorate([\n    __param(1, IContextKeyService),\n    __param(2, ILanguageFeaturesService),\n    __param(3, ILanguageConfigurationService),\n    __param(4, ILanguageFeatureDebounceService)\n], LinkedEditingContribution);\nexport { LinkedEditingContribution };\nexport class LinkedEditingAction extends EditorAction {\n    constructor() {\n        super({\n            id: 'editor.action.linkedEditing',\n            label: nls.localize('linkedEditing.label', \"Start Linked Editing\"),\n            alias: 'Start Linked Editing',\n            precondition: ContextKeyExpr.and(EditorContextKeys.writable, EditorContextKeys.hasRenameProvider),\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 60 /* KeyCode.F2 */,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    runCommand(accessor, args) {\n        const editorService = accessor.get(ICodeEditorService);\n        const [uri, pos] = Array.isArray(args) && args || [undefined, undefined];\n        if (URI.isUri(uri) && Position.isIPosition(pos)) {\n            return editorService.openCodeEditor({ resource: uri }, editorService.getActiveCodeEditor()).then(editor => {\n                if (!editor) {\n                    return;\n                }\n                editor.setPosition(pos);\n                editor.invokeWithinContext(accessor => {\n                    this.reportTelemetry(accessor, editor);\n                    return this.run(accessor, editor);\n                });\n            }, onUnexpectedError);\n        }\n        return super.runCommand(accessor, args);\n    }\n    run(_accessor, editor) {\n        const controller = LinkedEditingContribution.get(editor);\n        if (controller) {\n            return Promise.resolve(controller.updateRanges(true));\n        }\n        return Promise.resolve();\n    }\n}\nconst LinkedEditingCommand = EditorCommand.bindToContribution(LinkedEditingContribution.get);\nregisterEditorCommand(new LinkedEditingCommand({\n    id: 'cancelLinkedEditingInput',\n    precondition: CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE,\n    handler: x => x.clearRanges(),\n    kbOpts: {\n        kbExpr: EditorContextKeys.editorTextFocus,\n        weight: 100 /* KeybindingWeight.EditorContrib */ + 99,\n        primary: 9 /* KeyCode.Escape */,\n        secondary: [1024 /* KeyMod.Shift */ | 9 /* KeyCode.Escape */]\n    }\n}));\nfunction getLinkedEditingRanges(providers, model, position, token) {\n    const orderedByScore = providers.ordered(model);\n    // in order of score ask the linked editing range provider\n    // until someone response with a good result\n    // (good = not null)\n    return first(orderedByScore.map(provider => async () => {\n        try {\n            return await provider.provideLinkedEditingRanges(model, position, token);\n        }\n        catch (e) {\n            onUnexpectedExternalError(e);\n            return undefined;\n        }\n    }), result => !!result && arrays.isNonEmptyArray(result === null || result === void 0 ? void 0 : result.ranges));\n}\nexport const editorLinkedEditingBackground = registerColor('editor.linkedEditingBackground', { dark: Color.fromHex('#f00').transparent(0.3), light: Color.fromHex('#f00').transparent(0.3), hcDark: Color.fromHex('#f00').transparent(0.3), hcLight: Color.white }, nls.localize('editorLinkedEditingBackground', 'Background color when the editor auto renames on type.'));\nregisterModelAndPositionCommand('_executeLinkedEditingProvider', (_accessor, model, position) => {\n    const { linkedEditingRangeProvider } = _accessor.get(ILanguageFeaturesService);\n    return getLinkedEditingRanges(linkedEditingRangeProvider, model, position, CancellationToken.None);\n});\nregisterEditorContribution(LinkedEditingContribution.ID, LinkedEditingContribution, 1 /* EditorContributionInstantiation.AfterFirstRender */);\nregisterEditorAction(LinkedEditingAction);\n"],"names":["ExpandLineSelectionAction","constructor","super","id","label","alias","precondition","undefined","kbOpts","weight","kbExpr","primary","run","_accessor","editor","args","hasModel","viewModel","_getViewModel","model","pushStackElement","setCursorStates","source","getCursorStates","revealAllCursors","CopyLinesCommand","selection","isCopyingDown","noop","this","_selection","_isCopyingDown","_noop","_selectionDirection","_selectionId","_startLineNumberDelta","_endLineNumberDelta","getEditOperations","builder","s","startLineNumber","endLineNumber","endColumn","setEndPosition","getLineMaxColumn","sourceLines","i","push","getLineContent","sourceText","join","addEditOperation","getLineCount","trackSelection","getDirection","computeCursorState","helper","result","getTrackedSelection","startColumn","__decorate","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","MoveLinesCommand","isMovingDown","autoIndent","_languageConfigurationService","_isMovingDown","_autoIndent","_moveEndLineSelectionShrink","getLanguageId","getLanguageIdAtPosition","lineNumber","column","modelLineCount","_moveEndPositionDown","tabSize","indentSize","insertSpaces","getOptions","indentConverter","buildIndentConverter","otherLineNumber","movingLineNumber","movingLineText","insertingText","shouldAutoIndent","movingLineMatchResult","matchEnterRule","oldIndentation","strings","newSpaceCnt","indentUtils","newIndentation","trimStart","virtualModel","tokenization","getLineTokens","indentOfMovingLine","ret","matchEnterRuleMovingDown","getIndentEditsOfMovingBlock","newIndentatOfMovingBlock","oldSpaceCnt","spaceCntOffset","indentOfFirstLine","oldIndent","shiftIndent","indentation","unshiftIndent","parseEnterResult","line","enter","enterPrefix","indentAction","Indent","appendText","indexOf","indentMetadataOfMovelingLine","futureAboveLineNumber","futureAboveLineText","maxColumn","validPrecedingLine","lineContent","oneLineAbove","previousLineText","str","replace","isCheapToTokenize","languageAtSelectionStart","getLanguageConfiguration","indentRulesSupport","offset","originalIndent","newSpacesCnt","newIndent","SortLinesCommand","getCollator","_COLLATOR","Intl","Collator","descending","selectionId","op","data","getSortData","after","sortLines","range","text","canRun","len","before","linesToSort","sorted","slice","sort","compare","reverse","AbstractCopyLinesAction","down","opts","selections","getSelections","map","index","ignore","a","b","prev","curr","commands","pushUndoStop","executeCommands","DuplicateSelectionAction","nls","menuOpts","menuId","group","title","comment","order","accessor","getModel","isEmpty","insertSelection","getValueInRange","AbstractMoveLinesAction","languageConfigurationService","get","getOption","AbstractSortLinesAction","DeleteDuplicateLinesAction","edits","endCursorState","linesDeleted","updateSelection","uniqueLines","Set","lines","has","add","selectionToReplace","adjustedSelectionStart","finalSelection","executeEdits","TrimTrailingWhitespaceAction","ID","cursors","reason","positionLineNumber","positionColumn","getSelection","config","trimInRegexAndStrings","getValue","overrideIdentifier","resource","uri","command","DeleteLinesAction","ops","_getLinesToRemove","cursorState","operations","selectionStartColumn","mergedOperations","previousOperation","IndentLinesAction","cursorConfig","OutdentLinesAction","InsertLineBeforeAction","InsertLineAfterAction","AbstractDeleteAllToBoundaryAction","primaryCursor","rangesToDelete","_getRangesToDelete","effectiveRanges","count","nextRange","_getEndCursorState","JoinLinesAction","mac","reducedSelections","lastSelection","reduce","previousValue","currentValue","equalsSelection","endPrimaryCursor","lineOffset","columnDeltaOffset","selectionEndPositionOffset","getLineLength","position","getStartPosition","trimmedLinesContent","lineText","firstNonWhitespaceIdx","getLineFirstNonWhitespaceColumn","insertSpace","charAt","lineTextWithoutIndent","substr","deleteSelection","resultSelection","unshift","TransposeAction","cursor","Math","max","chars","split","AbstractCaseAction","wordSeparators","textEdits","word","getConfiguredWordAtPosition","wordRange","_modifyText","BackwardsCompatibleRegExp","_pattern","_flags","_actual","_evaluated","RegExp","err","isSupported","TitleCaseAction","titleBoundary","toLocaleLowerCase","toLocaleUpperCase","SnakeCaseAction","caseBoundary","singleLetters","CamelCaseAction","wordBoundary","words","shift","substring","PascalCaseAction","wordBoundaryToMaintain","flat","KebabCaseAction","underscoreBoundary","every","regexp","_","linux","deletedLines","forEach","endCursor","newStartLine","intersectRanges","deleteFromLine","deleteFromColumn","secondary","sel","LinkedEditingContribution_1","CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE","LinkedEditingContribution","getContribution","contextKeyService","languageFeaturesService","languageFeatureDebounceService","_syncRangesToken","_localToDispose","_register","_editor","_providers","linkedEditingRangeProvider","_enabled","_visibleContextKey","bindTo","_debounceInformation","for","_currentDecorations","createDecorationsCollection","_languageWordPattern","_currentWordPattern","_ignoreChangeEvent","_rangeUpdateTriggerPromise","_rangeSyncTriggerPromise","_currentRequestCts","_currentRequestPosition","_currentRequestModelVersion","onDidChangeModel","reinitialize","onDidChangeConfiguration","e","hasChanged","onDidChange","onDidChangeModelLanguage","forceRefresh","isEnabled","clearRanges","clear","onDidChangeLanguageConfiguration","getWordDefinition","rangeUpdateScheduler","triggerRangeUpdate","_a","trigger","updateRanges","_debounceDuration","rangeSyncScheduler","triggerRangeSync","token","_syncRanges","onDidChangeCursorPosition","onDidChangeModelContent","referenceRange","getRange","changes","dispose","referenceValue","match","mirrorRange","oldValue","newValue","rangeStartColumn","rangeEndColumn","commonPrefixLength","commonSuffixLength","popUndoStop","prevEditOperationType","getPrevEditOperationType","setPrevEditOperationType","set","cancel","force","getPosition","modelVersionId","getVersionId","equals","containsPosition","currentRequestCts","sw","response","getLinkedEditingRanges","update","elapsed","ranges","wordPattern","foundReferenceRange","splice","decorations","options","DECORATION","description","stickiness","className","LinkedEditingAction","runCommand","editorService","pos","Array","isArray","openCodeEditor","getActiveCodeEditor","then","setPosition","invokeWithinContext","reportTelemetry","controller","Promise","resolve","LinkedEditingCommand","providers","orderedByScore","ordered","provider","async","provideLinkedEditingRanges","handler","x","dark","transparent","light","hcDark","hcLight"],"sourceRoot":""}