{"version":3,"file":"static/js/8110_d12de4d46b09d56b4c5c.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/smartSelect/browser/bracketSelections.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/smartSelect/browser/wordSelections.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/smartSelect/browser/smartSelect.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/snippet/browser/snippetController2.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/snippet/browser/snippetParser.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/snippet/browser/snippetVariables.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/snippet/browser/snippetSession.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 { LinkedList } from '../../../../base/common/linkedList.js';\nimport { Position } from '../../../common/core/position.js';\nimport { Range } from '../../../common/core/range.js';\nexport class BracketSelectionRangeProvider {\n    async provideSelectionRanges(model, positions) {\n        const result = [];\n        for (const position of positions) {\n            const bucket = [];\n            result.push(bucket);\n            const ranges = new Map();\n            await new Promise(resolve => BracketSelectionRangeProvider._bracketsRightYield(resolve, 0, model, position, ranges));\n            await new Promise(resolve => BracketSelectionRangeProvider._bracketsLeftYield(resolve, 0, model, position, ranges, bucket));\n        }\n        return result;\n    }\n    static _bracketsRightYield(resolve, round, model, pos, ranges) {\n        const counts = new Map();\n        const t1 = Date.now();\n        while (true) {\n            if (round >= BracketSelectionRangeProvider._maxRounds) {\n                resolve();\n                break;\n            }\n            if (!pos) {\n                resolve();\n                break;\n            }\n            const bracket = model.bracketPairs.findNextBracket(pos);\n            if (!bracket) {\n                resolve();\n                break;\n            }\n            const d = Date.now() - t1;\n            if (d > BracketSelectionRangeProvider._maxDuration) {\n                setTimeout(() => BracketSelectionRangeProvider._bracketsRightYield(resolve, round + 1, model, pos, ranges));\n                break;\n            }\n            if (bracket.bracketInfo.isOpeningBracket) {\n                const key = bracket.bracketInfo.bracketText;\n                // wait for closing\n                const val = counts.has(key) ? counts.get(key) : 0;\n                counts.set(key, val + 1);\n            }\n            else {\n                const key = bracket.bracketInfo.getOpeningBrackets()[0].bracketText;\n                // process closing\n                let val = counts.has(key) ? counts.get(key) : 0;\n                val -= 1;\n                counts.set(key, Math.max(0, val));\n                if (val < 0) {\n                    let list = ranges.get(key);\n                    if (!list) {\n                        list = new LinkedList();\n                        ranges.set(key, list);\n                    }\n                    list.push(bracket.range);\n                }\n            }\n            pos = bracket.range.getEndPosition();\n        }\n    }\n    static _bracketsLeftYield(resolve, round, model, pos, ranges, bucket) {\n        const counts = new Map();\n        const t1 = Date.now();\n        while (true) {\n            if (round >= BracketSelectionRangeProvider._maxRounds && ranges.size === 0) {\n                resolve();\n                break;\n            }\n            if (!pos) {\n                resolve();\n                break;\n            }\n            const bracket = model.bracketPairs.findPrevBracket(pos);\n            if (!bracket) {\n                resolve();\n                break;\n            }\n            const d = Date.now() - t1;\n            if (d > BracketSelectionRangeProvider._maxDuration) {\n                setTimeout(() => BracketSelectionRangeProvider._bracketsLeftYield(resolve, round + 1, model, pos, ranges, bucket));\n                break;\n            }\n            if (!bracket.bracketInfo.isOpeningBracket) {\n                const key = bracket.bracketInfo.getOpeningBrackets()[0].bracketText;\n                // wait for opening\n                const val = counts.has(key) ? counts.get(key) : 0;\n                counts.set(key, val + 1);\n            }\n            else {\n                const key = bracket.bracketInfo.bracketText;\n                // opening\n                let val = counts.has(key) ? counts.get(key) : 0;\n                val -= 1;\n                counts.set(key, Math.max(0, val));\n                if (val < 0) {\n                    const list = ranges.get(key);\n                    if (list) {\n                        const closing = list.shift();\n                        if (list.size === 0) {\n                            ranges.delete(key);\n                        }\n                        const innerBracket = Range.fromPositions(bracket.range.getEndPosition(), closing.getStartPosition());\n                        const outerBracket = Range.fromPositions(bracket.range.getStartPosition(), closing.getEndPosition());\n                        bucket.push({ range: innerBracket });\n                        bucket.push({ range: outerBracket });\n                        BracketSelectionRangeProvider._addBracketLeading(model, outerBracket, bucket);\n                    }\n                }\n            }\n            pos = bracket.range.getStartPosition();\n        }\n    }\n    static _addBracketLeading(model, bracket, bucket) {\n        if (bracket.startLineNumber === bracket.endLineNumber) {\n            return;\n        }\n        // xxxxxxxx {\n        //\n        // }\n        const startLine = bracket.startLineNumber;\n        const column = model.getLineFirstNonWhitespaceColumn(startLine);\n        if (column !== 0 && column !== bracket.startColumn) {\n            bucket.push({ range: Range.fromPositions(new Position(startLine, column), bracket.getEndPosition()) });\n            bucket.push({ range: Range.fromPositions(new Position(startLine, 1), bracket.getEndPosition()) });\n        }\n        // xxxxxxxx\n        // {\n        //\n        // }\n        const aboveLine = startLine - 1;\n        if (aboveLine > 0) {\n            const column = model.getLineFirstNonWhitespaceColumn(aboveLine);\n            if (column === bracket.startColumn && column !== model.getLineLastNonWhitespaceColumn(aboveLine)) {\n                bucket.push({ range: Range.fromPositions(new Position(aboveLine, column), bracket.getEndPosition()) });\n                bucket.push({ range: Range.fromPositions(new Position(aboveLine, 1), bracket.getEndPosition()) });\n            }\n        }\n    }\n}\nBracketSelectionRangeProvider._maxDuration = 30;\nBracketSelectionRangeProvider._maxRounds = 2;\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 { isLowerAsciiLetter, isUpperAsciiLetter } from '../../../../base/common/strings.js';\nimport { Range } from '../../../common/core/range.js';\nexport class WordSelectionRangeProvider {\n    constructor(selectSubwords = true) {\n        this.selectSubwords = selectSubwords;\n    }\n    provideSelectionRanges(model, positions) {\n        const result = [];\n        for (const position of positions) {\n            const bucket = [];\n            result.push(bucket);\n            if (this.selectSubwords) {\n                this._addInWordRanges(bucket, model, position);\n            }\n            this._addWordRanges(bucket, model, position);\n            this._addWhitespaceLine(bucket, model, position);\n            bucket.push({ range: model.getFullModelRange() });\n        }\n        return result;\n    }\n    _addInWordRanges(bucket, model, pos) {\n        const obj = model.getWordAtPosition(pos);\n        if (!obj) {\n            return;\n        }\n        const { word, startColumn } = obj;\n        const offset = pos.column - startColumn;\n        let start = offset;\n        let end = offset;\n        let lastCh = 0;\n        // LEFT anchor (start)\n        for (; start >= 0; start--) {\n            const ch = word.charCodeAt(start);\n            if ((start !== offset) && (ch === 95 /* CharCode.Underline */ || ch === 45 /* CharCode.Dash */)) {\n                // foo-bar OR foo_bar\n                break;\n            }\n            else if (isLowerAsciiLetter(ch) && isUpperAsciiLetter(lastCh)) {\n                // fooBar\n                break;\n            }\n            lastCh = ch;\n        }\n        start += 1;\n        // RIGHT anchor (end)\n        for (; end < word.length; end++) {\n            const ch = word.charCodeAt(end);\n            if (isUpperAsciiLetter(ch) && isLowerAsciiLetter(lastCh)) {\n                // fooBar\n                break;\n            }\n            else if (ch === 95 /* CharCode.Underline */ || ch === 45 /* CharCode.Dash */) {\n                // foo-bar OR foo_bar\n                break;\n            }\n            lastCh = ch;\n        }\n        if (start < end) {\n            bucket.push({ range: new Range(pos.lineNumber, startColumn + start, pos.lineNumber, startColumn + end) });\n        }\n    }\n    _addWordRanges(bucket, model, pos) {\n        const word = model.getWordAtPosition(pos);\n        if (word) {\n            bucket.push({ range: new Range(pos.lineNumber, word.startColumn, pos.lineNumber, word.endColumn) });\n        }\n    }\n    _addWhitespaceLine(bucket, model, pos) {\n        if (model.getLineLength(pos.lineNumber) > 0\n            && model.getLineFirstNonWhitespaceColumn(pos.lineNumber) === 0\n            && model.getLineLastNonWhitespaceColumn(pos.lineNumber) === 0) {\n            bucket.push({ range: new Range(pos.lineNumber, 1, pos.lineNumber, model.getLineMaxColumn(pos.lineNumber)) });\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\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 SmartSelectController_1;\nimport * as arrays from '../../../../base/common/arrays.js';\nimport { CancellationToken } from '../../../../base/common/cancellation.js';\nimport { onUnexpectedExternalError } from '../../../../base/common/errors.js';\nimport { EditorAction, registerEditorAction, registerEditorContribution } from '../../../browser/editorExtensions.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 { BracketSelectionRangeProvider } from './bracketSelections.js';\nimport { WordSelectionRangeProvider } from './wordSelections.js';\nimport * as nls from '../../../../nls.js';\nimport { MenuId } from '../../../../platform/actions/common/actions.js';\nimport { CommandsRegistry } from '../../../../platform/commands/common/commands.js';\nimport { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';\nimport { ITextModelService } from '../../../common/services/resolverService.js';\nimport { assertType } from '../../../../base/common/types.js';\nimport { URI } from '../../../../base/common/uri.js';\nclass SelectionRanges {\n    constructor(index, ranges) {\n        this.index = index;\n        this.ranges = ranges;\n    }\n    mov(fwd) {\n        const index = this.index + (fwd ? 1 : -1);\n        if (index < 0 || index >= this.ranges.length) {\n            return this;\n        }\n        const res = new SelectionRanges(index, this.ranges);\n        if (res.ranges[index].equalsRange(this.ranges[this.index])) {\n            // next range equals this range, retry with next-next\n            return res.mov(fwd);\n        }\n        return res;\n    }\n}\nlet SmartSelectController = SmartSelectController_1 = class SmartSelectController {\n    static get(editor) {\n        return editor.getContribution(SmartSelectController_1.ID);\n    }\n    constructor(_editor, _languageFeaturesService) {\n        this._editor = _editor;\n        this._languageFeaturesService = _languageFeaturesService;\n        this._ignoreSelection = false;\n    }\n    dispose() {\n        var _a;\n        (_a = this._selectionListener) === null || _a === void 0 ? void 0 : _a.dispose();\n    }\n    async run(forward) {\n        if (!this._editor.hasModel()) {\n            return;\n        }\n        const selections = this._editor.getSelections();\n        const model = this._editor.getModel();\n        if (!this._state) {\n            await provideSelectionRanges(this._languageFeaturesService.selectionRangeProvider, model, selections.map(s => s.getPosition()), this._editor.getOption(113 /* EditorOption.smartSelect */), CancellationToken.None).then(ranges => {\n                var _a;\n                if (!arrays.isNonEmptyArray(ranges) || ranges.length !== selections.length) {\n                    // invalid result\n                    return;\n                }\n                if (!this._editor.hasModel() || !arrays.equals(this._editor.getSelections(), selections, (a, b) => a.equalsSelection(b))) {\n                    // invalid editor state\n                    return;\n                }\n                for (let i = 0; i < ranges.length; i++) {\n                    ranges[i] = ranges[i].filter(range => {\n                        // filter ranges inside the selection\n                        return range.containsPosition(selections[i].getStartPosition()) && range.containsPosition(selections[i].getEndPosition());\n                    });\n                    // prepend current selection\n                    ranges[i].unshift(selections[i]);\n                }\n                this._state = ranges.map(ranges => new SelectionRanges(0, ranges));\n                // listen to caret move and forget about state\n                (_a = this._selectionListener) === null || _a === void 0 ? void 0 : _a.dispose();\n                this._selectionListener = this._editor.onDidChangeCursorPosition(() => {\n                    var _a;\n                    if (!this._ignoreSelection) {\n                        (_a = this._selectionListener) === null || _a === void 0 ? void 0 : _a.dispose();\n                        this._state = undefined;\n                    }\n                });\n            });\n        }\n        if (!this._state) {\n            // no state\n            return;\n        }\n        this._state = this._state.map(state => state.mov(forward));\n        const newSelections = this._state.map(state => Selection.fromPositions(state.ranges[state.index].getStartPosition(), state.ranges[state.index].getEndPosition()));\n        this._ignoreSelection = true;\n        try {\n            this._editor.setSelections(newSelections);\n        }\n        finally {\n            this._ignoreSelection = false;\n        }\n    }\n};\nSmartSelectController.ID = 'editor.contrib.smartSelectController';\nSmartSelectController = SmartSelectController_1 = __decorate([\n    __param(1, ILanguageFeaturesService)\n], SmartSelectController);\nexport { SmartSelectController };\nclass AbstractSmartSelect extends EditorAction {\n    constructor(forward, opts) {\n        super(opts);\n        this._forward = forward;\n    }\n    async run(_accessor, editor) {\n        const controller = SmartSelectController.get(editor);\n        if (controller) {\n            await controller.run(this._forward);\n        }\n    }\n}\nclass GrowSelectionAction extends AbstractSmartSelect {\n    constructor() {\n        super(true, {\n            id: 'editor.action.smartSelect.expand',\n            label: nls.localize('smartSelect.expand', \"Expand Selection\"),\n            alias: 'Expand Selection',\n            precondition: undefined,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 17 /* KeyCode.RightArrow */,\n                mac: {\n                    primary: 2048 /* KeyMod.CtrlCmd */ | 256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 17 /* KeyCode.RightArrow */,\n                    secondary: [256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 17 /* KeyCode.RightArrow */],\n                },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '1_basic',\n                title: nls.localize({ key: 'miSmartSelectGrow', comment: ['&& denotes a mnemonic'] }, \"&&Expand Selection\"),\n                order: 2\n            }\n        });\n    }\n}\n// renamed command id\nCommandsRegistry.registerCommandAlias('editor.action.smartSelect.grow', 'editor.action.smartSelect.expand');\nclass ShrinkSelectionAction extends AbstractSmartSelect {\n    constructor() {\n        super(false, {\n            id: 'editor.action.smartSelect.shrink',\n            label: nls.localize('smartSelect.shrink', \"Shrink Selection\"),\n            alias: 'Shrink Selection',\n            precondition: undefined,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 1024 /* KeyMod.Shift */ | 512 /* KeyMod.Alt */ | 15 /* KeyCode.LeftArrow */,\n                mac: {\n                    primary: 2048 /* KeyMod.CtrlCmd */ | 256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 15 /* KeyCode.LeftArrow */,\n                    secondary: [256 /* KeyMod.WinCtrl */ | 1024 /* KeyMod.Shift */ | 15 /* KeyCode.LeftArrow */],\n                },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            menuOpts: {\n                menuId: MenuId.MenubarSelectionMenu,\n                group: '1_basic',\n                title: nls.localize({ key: 'miSmartSelectShrink', comment: ['&& denotes a mnemonic'] }, \"&&Shrink Selection\"),\n                order: 3\n            }\n        });\n    }\n}\nregisterEditorContribution(SmartSelectController.ID, SmartSelectController, 4 /* EditorContributionInstantiation.Lazy */);\nregisterEditorAction(GrowSelectionAction);\nregisterEditorAction(ShrinkSelectionAction);\nexport async function provideSelectionRanges(registry, model, positions, options, token) {\n    const providers = registry.all(model)\n        .concat(new WordSelectionRangeProvider(options.selectSubwords)); // ALWAYS have word based selection range\n    if (providers.length === 1) {\n        // add word selection and bracket selection when no provider exists\n        providers.unshift(new BracketSelectionRangeProvider());\n    }\n    const work = [];\n    const allRawRanges = [];\n    for (const provider of providers) {\n        work.push(Promise.resolve(provider.provideSelectionRanges(model, positions, token)).then(allProviderRanges => {\n            if (arrays.isNonEmptyArray(allProviderRanges) && allProviderRanges.length === positions.length) {\n                for (let i = 0; i < positions.length; i++) {\n                    if (!allRawRanges[i]) {\n                        allRawRanges[i] = [];\n                    }\n                    for (const oneProviderRanges of allProviderRanges[i]) {\n                        if (Range.isIRange(oneProviderRanges.range) && Range.containsPosition(oneProviderRanges.range, positions[i])) {\n                            allRawRanges[i].push(Range.lift(oneProviderRanges.range));\n                        }\n                    }\n                }\n            }\n        }, onUnexpectedExternalError));\n    }\n    await Promise.all(work);\n    return allRawRanges.map(oneRawRanges => {\n        if (oneRawRanges.length === 0) {\n            return [];\n        }\n        // sort all by start/end position\n        oneRawRanges.sort((a, b) => {\n            if (Position.isBefore(a.getStartPosition(), b.getStartPosition())) {\n                return 1;\n            }\n            else if (Position.isBefore(b.getStartPosition(), a.getStartPosition())) {\n                return -1;\n            }\n            else if (Position.isBefore(a.getEndPosition(), b.getEndPosition())) {\n                return -1;\n            }\n            else if (Position.isBefore(b.getEndPosition(), a.getEndPosition())) {\n                return 1;\n            }\n            else {\n                return 0;\n            }\n        });\n        // remove ranges that don't contain the former range or that are equal to the\n        // former range\n        const oneRanges = [];\n        let last;\n        for (const range of oneRawRanges) {\n            if (!last || (Range.containsRange(range, last) && !Range.equalsRange(range, last))) {\n                oneRanges.push(range);\n                last = range;\n            }\n        }\n        if (!options.selectLeadingAndTrailingWhitespace) {\n            return oneRanges;\n        }\n        // add ranges that expand trivia at line starts and ends whenever a range\n        // wraps onto the a new line\n        const oneRangesWithTrivia = [oneRanges[0]];\n        for (let i = 1; i < oneRanges.length; i++) {\n            const prev = oneRanges[i - 1];\n            const cur = oneRanges[i];\n            if (cur.startLineNumber !== prev.startLineNumber || cur.endLineNumber !== prev.endLineNumber) {\n                // add line/block range without leading/failing whitespace\n                const rangeNoWhitespace = new Range(prev.startLineNumber, model.getLineFirstNonWhitespaceColumn(prev.startLineNumber), prev.endLineNumber, model.getLineLastNonWhitespaceColumn(prev.endLineNumber));\n                if (rangeNoWhitespace.containsRange(prev) && !rangeNoWhitespace.equalsRange(prev) && cur.containsRange(rangeNoWhitespace) && !cur.equalsRange(rangeNoWhitespace)) {\n                    oneRangesWithTrivia.push(rangeNoWhitespace);\n                }\n                // add line/block range\n                const rangeFull = new Range(prev.startLineNumber, 1, prev.endLineNumber, model.getLineMaxColumn(prev.endLineNumber));\n                if (rangeFull.containsRange(prev) && !rangeFull.equalsRange(rangeNoWhitespace) && cur.containsRange(rangeFull) && !cur.equalsRange(rangeFull)) {\n                    oneRangesWithTrivia.push(rangeFull);\n                }\n            }\n            oneRangesWithTrivia.push(cur);\n        }\n        return oneRangesWithTrivia;\n    });\n}\nCommandsRegistry.registerCommand('_executeSelectionRangeProvider', async function (accessor, ...args) {\n    const [resource, positions] = args;\n    assertType(URI.isUri(resource));\n    const registry = accessor.get(ILanguageFeaturesService).selectionRangeProvider;\n    const reference = await accessor.get(ITextModelService).createModelReference(resource);\n    try {\n        return provideSelectionRanges(registry, reference.object.textEditorModel, positions, { selectLeadingAndTrailingWhitespace: true, selectSubwords: true }, CancellationToken.None);\n    }\n    finally {\n        reference.dispose();\n    }\n});\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nvar SnippetController2_1;\nimport { DisposableStore } from '../../../../base/common/lifecycle.js';\nimport { assertType } from '../../../../base/common/types.js';\nimport { EditorCommand, registerEditorCommand, registerEditorContribution } from '../../../browser/editorExtensions.js';\nimport { Position } from '../../../common/core/position.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';\nimport { showSimpleSuggestions } from '../../suggest/browser/suggest.js';\nimport { localize } from '../../../../nls.js';\nimport { ContextKeyExpr, IContextKeyService, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';\nimport { ILogService } from '../../../../platform/log/common/log.js';\nimport { SnippetSession } from './snippetSession.js';\nconst _defaultOptions = {\n    overwriteBefore: 0,\n    overwriteAfter: 0,\n    undoStopBefore: true,\n    undoStopAfter: true,\n    adjustWhitespace: true,\n    clipboardText: undefined,\n    overtypingCapturer: undefined\n};\nlet SnippetController2 = SnippetController2_1 = class SnippetController2 {\n    static get(editor) {\n        return editor.getContribution(SnippetController2_1.ID);\n    }\n    constructor(_editor, _logService, _languageFeaturesService, contextKeyService, _languageConfigurationService) {\n        this._editor = _editor;\n        this._logService = _logService;\n        this._languageFeaturesService = _languageFeaturesService;\n        this._languageConfigurationService = _languageConfigurationService;\n        this._snippetListener = new DisposableStore();\n        this._modelVersionId = -1;\n        this._inSnippet = SnippetController2_1.InSnippetMode.bindTo(contextKeyService);\n        this._hasNextTabstop = SnippetController2_1.HasNextTabstop.bindTo(contextKeyService);\n        this._hasPrevTabstop = SnippetController2_1.HasPrevTabstop.bindTo(contextKeyService);\n    }\n    dispose() {\n        var _a;\n        this._inSnippet.reset();\n        this._hasPrevTabstop.reset();\n        this._hasNextTabstop.reset();\n        (_a = this._session) === null || _a === void 0 ? void 0 : _a.dispose();\n        this._snippetListener.dispose();\n    }\n    insert(template, opts) {\n        // this is here to find out more about the yet-not-understood\n        // error that sometimes happens when we fail to inserted a nested\n        // snippet\n        try {\n            this._doInsert(template, typeof opts === 'undefined' ? _defaultOptions : { ..._defaultOptions, ...opts });\n        }\n        catch (e) {\n            this.cancel();\n            this._logService.error(e);\n            this._logService.error('snippet_error');\n            this._logService.error('insert_template=', template);\n            this._logService.error('existing_template=', this._session ? this._session._logInfo() : '<no_session>');\n        }\n    }\n    _doInsert(template, opts) {\n        var _a;\n        if (!this._editor.hasModel()) {\n            return;\n        }\n        // don't listen while inserting the snippet\n        // as that is the inflight state causing cancelation\n        this._snippetListener.clear();\n        if (opts.undoStopBefore) {\n            this._editor.getModel().pushStackElement();\n        }\n        // don't merge\n        if (this._session && typeof template !== 'string') {\n            this.cancel();\n        }\n        if (!this._session) {\n            this._modelVersionId = this._editor.getModel().getAlternativeVersionId();\n            this._session = new SnippetSession(this._editor, template, opts, this._languageConfigurationService);\n            this._session.insert();\n        }\n        else {\n            assertType(typeof template === 'string');\n            this._session.merge(template, opts);\n        }\n        if (opts.undoStopAfter) {\n            this._editor.getModel().pushStackElement();\n        }\n        // regster completion item provider when there is any choice element\n        if ((_a = this._session) === null || _a === void 0 ? void 0 : _a.hasChoice) {\n            const provider = {\n                _debugDisplayName: 'snippetChoiceCompletions',\n                provideCompletionItems: (model, position) => {\n                    if (!this._session || model !== this._editor.getModel() || !Position.equals(this._editor.getPosition(), position)) {\n                        return undefined;\n                    }\n                    const { activeChoice } = this._session;\n                    if (!activeChoice || activeChoice.choice.options.length === 0) {\n                        return undefined;\n                    }\n                    const word = model.getValueInRange(activeChoice.range);\n                    const isAnyOfOptions = Boolean(activeChoice.choice.options.find(o => o.value === word));\n                    const suggestions = [];\n                    for (let i = 0; i < activeChoice.choice.options.length; i++) {\n                        const option = activeChoice.choice.options[i];\n                        suggestions.push({\n                            kind: 13 /* CompletionItemKind.Value */,\n                            label: option.value,\n                            insertText: option.value,\n                            sortText: 'a'.repeat(i + 1),\n                            range: activeChoice.range,\n                            filterText: isAnyOfOptions ? `${word}_${option.value}` : undefined,\n                            command: { id: 'jumpToNextSnippetPlaceholder', title: localize('next', 'Go to next placeholder...') }\n                        });\n                    }\n                    return { suggestions };\n                }\n            };\n            const model = this._editor.getModel();\n            let registration;\n            let isRegistered = false;\n            const disable = () => {\n                registration === null || registration === void 0 ? void 0 : registration.dispose();\n                isRegistered = false;\n            };\n            const enable = () => {\n                if (!isRegistered) {\n                    registration = this._languageFeaturesService.completionProvider.register({\n                        language: model.getLanguageId(),\n                        pattern: model.uri.fsPath,\n                        scheme: model.uri.scheme,\n                        exclusive: true\n                    }, provider);\n                    this._snippetListener.add(registration);\n                    isRegistered = true;\n                }\n            };\n            this._choiceCompletions = { provider, enable, disable };\n        }\n        this._updateState();\n        this._snippetListener.add(this._editor.onDidChangeModelContent(e => e.isFlush && this.cancel()));\n        this._snippetListener.add(this._editor.onDidChangeModel(() => this.cancel()));\n        this._snippetListener.add(this._editor.onDidChangeCursorSelection(() => this._updateState()));\n    }\n    _updateState() {\n        if (!this._session || !this._editor.hasModel()) {\n            // canceled in the meanwhile\n            return;\n        }\n        if (this._modelVersionId === this._editor.getModel().getAlternativeVersionId()) {\n            // undo until the 'before' state happened\n            // and makes use cancel snippet mode\n            return this.cancel();\n        }\n        if (!this._session.hasPlaceholder) {\n            // don't listen for selection changes and don't\n            // update context keys when the snippet is plain text\n            return this.cancel();\n        }\n        if (this._session.isAtLastPlaceholder || !this._session.isSelectionWithinPlaceholders()) {\n            this._editor.getModel().pushStackElement();\n            return this.cancel();\n        }\n        this._inSnippet.set(true);\n        this._hasPrevTabstop.set(!this._session.isAtFirstPlaceholder);\n        this._hasNextTabstop.set(!this._session.isAtLastPlaceholder);\n        this._handleChoice();\n    }\n    _handleChoice() {\n        var _a;\n        if (!this._session || !this._editor.hasModel()) {\n            this._currentChoice = undefined;\n            return;\n        }\n        const { activeChoice } = this._session;\n        if (!activeChoice || !this._choiceCompletions) {\n            (_a = this._choiceCompletions) === null || _a === void 0 ? void 0 : _a.disable();\n            this._currentChoice = undefined;\n            return;\n        }\n        if (this._currentChoice !== activeChoice.choice) {\n            this._currentChoice = activeChoice.choice;\n            this._choiceCompletions.enable();\n            // trigger suggest with the special choice completion provider\n            queueMicrotask(() => {\n                showSimpleSuggestions(this._editor, this._choiceCompletions.provider);\n            });\n        }\n    }\n    finish() {\n        while (this._inSnippet.get()) {\n            this.next();\n        }\n    }\n    cancel(resetSelection = false) {\n        var _a;\n        this._inSnippet.reset();\n        this._hasPrevTabstop.reset();\n        this._hasNextTabstop.reset();\n        this._snippetListener.clear();\n        this._currentChoice = undefined;\n        (_a = this._session) === null || _a === void 0 ? void 0 : _a.dispose();\n        this._session = undefined;\n        this._modelVersionId = -1;\n        if (resetSelection) {\n            // reset selection to the primary cursor when being asked\n            // for. this happens when explicitly cancelling snippet mode,\n            // e.g. when pressing ESC\n            this._editor.setSelections([this._editor.getSelection()]);\n        }\n    }\n    prev() {\n        var _a;\n        (_a = this._session) === null || _a === void 0 ? void 0 : _a.prev();\n        this._updateState();\n    }\n    next() {\n        var _a;\n        (_a = this._session) === null || _a === void 0 ? void 0 : _a.next();\n        this._updateState();\n    }\n    isInSnippet() {\n        return Boolean(this._inSnippet.get());\n    }\n};\nSnippetController2.ID = 'snippetController2';\nSnippetController2.InSnippetMode = new RawContextKey('inSnippetMode', false, localize('inSnippetMode', \"Whether the editor in current in snippet mode\"));\nSnippetController2.HasNextTabstop = new RawContextKey('hasNextTabstop', false, localize('hasNextTabstop', \"Whether there is a next tab stop when in snippet mode\"));\nSnippetController2.HasPrevTabstop = new RawContextKey('hasPrevTabstop', false, localize('hasPrevTabstop', \"Whether there is a previous tab stop when in snippet mode\"));\nSnippetController2 = SnippetController2_1 = __decorate([\n    __param(1, ILogService),\n    __param(2, ILanguageFeaturesService),\n    __param(3, IContextKeyService),\n    __param(4, ILanguageConfigurationService)\n], SnippetController2);\nexport { SnippetController2 };\nregisterEditorContribution(SnippetController2.ID, SnippetController2, 4 /* EditorContributionInstantiation.Lazy */);\nconst CommandCtor = EditorCommand.bindToContribution(SnippetController2.get);\nregisterEditorCommand(new CommandCtor({\n    id: 'jumpToNextSnippetPlaceholder',\n    precondition: ContextKeyExpr.and(SnippetController2.InSnippetMode, SnippetController2.HasNextTabstop),\n    handler: ctrl => ctrl.next(),\n    kbOpts: {\n        weight: 100 /* KeybindingWeight.EditorContrib */ + 30,\n        kbExpr: EditorContextKeys.textInputFocus,\n        primary: 2 /* KeyCode.Tab */\n    }\n}));\nregisterEditorCommand(new CommandCtor({\n    id: 'jumpToPrevSnippetPlaceholder',\n    precondition: ContextKeyExpr.and(SnippetController2.InSnippetMode, SnippetController2.HasPrevTabstop),\n    handler: ctrl => ctrl.prev(),\n    kbOpts: {\n        weight: 100 /* KeybindingWeight.EditorContrib */ + 30,\n        kbExpr: EditorContextKeys.textInputFocus,\n        primary: 1024 /* KeyMod.Shift */ | 2 /* KeyCode.Tab */\n    }\n}));\nregisterEditorCommand(new CommandCtor({\n    id: 'leaveSnippet',\n    precondition: SnippetController2.InSnippetMode,\n    handler: ctrl => ctrl.cancel(true),\n    kbOpts: {\n        weight: 100 /* KeybindingWeight.EditorContrib */ + 30,\n        kbExpr: EditorContextKeys.textInputFocus,\n        primary: 9 /* KeyCode.Escape */,\n        secondary: [1024 /* KeyMod.Shift */ | 9 /* KeyCode.Escape */]\n    }\n}));\nregisterEditorCommand(new CommandCtor({\n    id: 'acceptSnippet',\n    precondition: SnippetController2.InSnippetMode,\n    handler: ctrl => ctrl.finish(),\n    // kbOpts: {\n    // \tweight: KeybindingWeight.EditorContrib + 30,\n    // \tkbExpr: EditorContextKeys.textFocus,\n    // \tprimary: KeyCode.Enter,\n    // }\n}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport class Scanner {\n    constructor() {\n        this.value = '';\n        this.pos = 0;\n    }\n    static isDigitCharacter(ch) {\n        return ch >= 48 /* CharCode.Digit0 */ && ch <= 57 /* CharCode.Digit9 */;\n    }\n    static isVariableCharacter(ch) {\n        return ch === 95 /* CharCode.Underline */\n            || (ch >= 97 /* CharCode.a */ && ch <= 122 /* CharCode.z */)\n            || (ch >= 65 /* CharCode.A */ && ch <= 90 /* CharCode.Z */);\n    }\n    text(value) {\n        this.value = value;\n        this.pos = 0;\n    }\n    tokenText(token) {\n        return this.value.substr(token.pos, token.len);\n    }\n    next() {\n        if (this.pos >= this.value.length) {\n            return { type: 14 /* TokenType.EOF */, pos: this.pos, len: 0 };\n        }\n        const pos = this.pos;\n        let len = 0;\n        let ch = this.value.charCodeAt(pos);\n        let type;\n        // static types\n        type = Scanner._table[ch];\n        if (typeof type === 'number') {\n            this.pos += 1;\n            return { type, pos, len: 1 };\n        }\n        // number\n        if (Scanner.isDigitCharacter(ch)) {\n            type = 8 /* TokenType.Int */;\n            do {\n                len += 1;\n                ch = this.value.charCodeAt(pos + len);\n            } while (Scanner.isDigitCharacter(ch));\n            this.pos += len;\n            return { type, pos, len };\n        }\n        // variable name\n        if (Scanner.isVariableCharacter(ch)) {\n            type = 9 /* TokenType.VariableName */;\n            do {\n                ch = this.value.charCodeAt(pos + (++len));\n            } while (Scanner.isVariableCharacter(ch) || Scanner.isDigitCharacter(ch));\n            this.pos += len;\n            return { type, pos, len };\n        }\n        // format\n        type = 10 /* TokenType.Format */;\n        do {\n            len += 1;\n            ch = this.value.charCodeAt(pos + len);\n        } while (!isNaN(ch)\n            && typeof Scanner._table[ch] === 'undefined' // not static token\n            && !Scanner.isDigitCharacter(ch) // not number\n            && !Scanner.isVariableCharacter(ch) // not variable\n        );\n        this.pos += len;\n        return { type, pos, len };\n    }\n}\nScanner._table = {\n    [36 /* CharCode.DollarSign */]: 0 /* TokenType.Dollar */,\n    [58 /* CharCode.Colon */]: 1 /* TokenType.Colon */,\n    [44 /* CharCode.Comma */]: 2 /* TokenType.Comma */,\n    [123 /* CharCode.OpenCurlyBrace */]: 3 /* TokenType.CurlyOpen */,\n    [125 /* CharCode.CloseCurlyBrace */]: 4 /* TokenType.CurlyClose */,\n    [92 /* CharCode.Backslash */]: 5 /* TokenType.Backslash */,\n    [47 /* CharCode.Slash */]: 6 /* TokenType.Forwardslash */,\n    [124 /* CharCode.Pipe */]: 7 /* TokenType.Pipe */,\n    [43 /* CharCode.Plus */]: 11 /* TokenType.Plus */,\n    [45 /* CharCode.Dash */]: 12 /* TokenType.Dash */,\n    [63 /* CharCode.QuestionMark */]: 13 /* TokenType.QuestionMark */,\n};\nexport class Marker {\n    constructor() {\n        this._children = [];\n    }\n    appendChild(child) {\n        if (child instanceof Text && this._children[this._children.length - 1] instanceof Text) {\n            // this and previous child are text -> merge them\n            this._children[this._children.length - 1].value += child.value;\n        }\n        else {\n            // normal adoption of child\n            child.parent = this;\n            this._children.push(child);\n        }\n        return this;\n    }\n    replace(child, others) {\n        const { parent } = child;\n        const idx = parent.children.indexOf(child);\n        const newChildren = parent.children.slice(0);\n        newChildren.splice(idx, 1, ...others);\n        parent._children = newChildren;\n        (function _fixParent(children, parent) {\n            for (const child of children) {\n                child.parent = parent;\n                _fixParent(child.children, child);\n            }\n        })(others, parent);\n    }\n    get children() {\n        return this._children;\n    }\n    get rightMostDescendant() {\n        if (this._children.length > 0) {\n            return this._children[this._children.length - 1].rightMostDescendant;\n        }\n        return this;\n    }\n    get snippet() {\n        let candidate = this;\n        while (true) {\n            if (!candidate) {\n                return undefined;\n            }\n            if (candidate instanceof TextmateSnippet) {\n                return candidate;\n            }\n            candidate = candidate.parent;\n        }\n    }\n    toString() {\n        return this.children.reduce((prev, cur) => prev + cur.toString(), '');\n    }\n    len() {\n        return 0;\n    }\n}\nexport class Text extends Marker {\n    constructor(value) {\n        super();\n        this.value = value;\n    }\n    toString() {\n        return this.value;\n    }\n    len() {\n        return this.value.length;\n    }\n    clone() {\n        return new Text(this.value);\n    }\n}\nexport class TransformableMarker extends Marker {\n}\nexport class Placeholder extends TransformableMarker {\n    static compareByIndex(a, b) {\n        if (a.index === b.index) {\n            return 0;\n        }\n        else if (a.isFinalTabstop) {\n            return 1;\n        }\n        else if (b.isFinalTabstop) {\n            return -1;\n        }\n        else if (a.index < b.index) {\n            return -1;\n        }\n        else if (a.index > b.index) {\n            return 1;\n        }\n        else {\n            return 0;\n        }\n    }\n    constructor(index) {\n        super();\n        this.index = index;\n    }\n    get isFinalTabstop() {\n        return this.index === 0;\n    }\n    get choice() {\n        return this._children.length === 1 && this._children[0] instanceof Choice\n            ? this._children[0]\n            : undefined;\n    }\n    clone() {\n        const ret = new Placeholder(this.index);\n        if (this.transform) {\n            ret.transform = this.transform.clone();\n        }\n        ret._children = this.children.map(child => child.clone());\n        return ret;\n    }\n}\nexport class Choice extends Marker {\n    constructor() {\n        super(...arguments);\n        this.options = [];\n    }\n    appendChild(marker) {\n        if (marker instanceof Text) {\n            marker.parent = this;\n            this.options.push(marker);\n        }\n        return this;\n    }\n    toString() {\n        return this.options[0].value;\n    }\n    len() {\n        return this.options[0].len();\n    }\n    clone() {\n        const ret = new Choice();\n        this.options.forEach(ret.appendChild, ret);\n        return ret;\n    }\n}\nexport class Transform extends Marker {\n    constructor() {\n        super(...arguments);\n        this.regexp = new RegExp('');\n    }\n    resolve(value) {\n        const _this = this;\n        let didMatch = false;\n        let ret = value.replace(this.regexp, function () {\n            didMatch = true;\n            return _this._replace(Array.prototype.slice.call(arguments, 0, -2));\n        });\n        // when the regex didn't match and when the transform has\n        // else branches, then run those\n        if (!didMatch && this._children.some(child => child instanceof FormatString && Boolean(child.elseValue))) {\n            ret = this._replace([]);\n        }\n        return ret;\n    }\n    _replace(groups) {\n        let ret = '';\n        for (const marker of this._children) {\n            if (marker instanceof FormatString) {\n                let value = groups[marker.index] || '';\n                value = marker.resolve(value);\n                ret += value;\n            }\n            else {\n                ret += marker.toString();\n            }\n        }\n        return ret;\n    }\n    toString() {\n        return '';\n    }\n    clone() {\n        const ret = new Transform();\n        ret.regexp = new RegExp(this.regexp.source, '' + (this.regexp.ignoreCase ? 'i' : '') + (this.regexp.global ? 'g' : ''));\n        ret._children = this.children.map(child => child.clone());\n        return ret;\n    }\n}\nexport class FormatString extends Marker {\n    constructor(index, shorthandName, ifValue, elseValue) {\n        super();\n        this.index = index;\n        this.shorthandName = shorthandName;\n        this.ifValue = ifValue;\n        this.elseValue = elseValue;\n    }\n    resolve(value) {\n        if (this.shorthandName === 'upcase') {\n            return !value ? '' : value.toLocaleUpperCase();\n        }\n        else if (this.shorthandName === 'downcase') {\n            return !value ? '' : value.toLocaleLowerCase();\n        }\n        else if (this.shorthandName === 'capitalize') {\n            return !value ? '' : (value[0].toLocaleUpperCase() + value.substr(1));\n        }\n        else if (this.shorthandName === 'pascalcase') {\n            return !value ? '' : this._toPascalCase(value);\n        }\n        else if (this.shorthandName === 'camelcase') {\n            return !value ? '' : this._toCamelCase(value);\n        }\n        else if (Boolean(value) && typeof this.ifValue === 'string') {\n            return this.ifValue;\n        }\n        else if (!Boolean(value) && typeof this.elseValue === 'string') {\n            return this.elseValue;\n        }\n        else {\n            return value || '';\n        }\n    }\n    _toPascalCase(value) {\n        const match = value.match(/[a-z0-9]+/gi);\n        if (!match) {\n            return value;\n        }\n        return match.map(word => {\n            return word.charAt(0).toUpperCase() + word.substr(1);\n        })\n            .join('');\n    }\n    _toCamelCase(value) {\n        const match = value.match(/[a-z0-9]+/gi);\n        if (!match) {\n            return value;\n        }\n        return match.map((word, index) => {\n            if (index === 0) {\n                return word.charAt(0).toLowerCase() + word.substr(1);\n            }\n            return word.charAt(0).toUpperCase() + word.substr(1);\n        })\n            .join('');\n    }\n    clone() {\n        const ret = new FormatString(this.index, this.shorthandName, this.ifValue, this.elseValue);\n        return ret;\n    }\n}\nexport class Variable extends TransformableMarker {\n    constructor(name) {\n        super();\n        this.name = name;\n    }\n    resolve(resolver) {\n        let value = resolver.resolve(this);\n        if (this.transform) {\n            value = this.transform.resolve(value || '');\n        }\n        if (value !== undefined) {\n            this._children = [new Text(value)];\n            return true;\n        }\n        return false;\n    }\n    clone() {\n        const ret = new Variable(this.name);\n        if (this.transform) {\n            ret.transform = this.transform.clone();\n        }\n        ret._children = this.children.map(child => child.clone());\n        return ret;\n    }\n}\nfunction walk(marker, visitor) {\n    const stack = [...marker];\n    while (stack.length > 0) {\n        const marker = stack.shift();\n        const recurse = visitor(marker);\n        if (!recurse) {\n            break;\n        }\n        stack.unshift(...marker.children);\n    }\n}\nexport class TextmateSnippet extends Marker {\n    get placeholderInfo() {\n        if (!this._placeholders) {\n            // fill in placeholders\n            const all = [];\n            let last;\n            this.walk(function (candidate) {\n                if (candidate instanceof Placeholder) {\n                    all.push(candidate);\n                    last = !last || last.index < candidate.index ? candidate : last;\n                }\n                return true;\n            });\n            this._placeholders = { all, last };\n        }\n        return this._placeholders;\n    }\n    get placeholders() {\n        const { all } = this.placeholderInfo;\n        return all;\n    }\n    offset(marker) {\n        let pos = 0;\n        let found = false;\n        this.walk(candidate => {\n            if (candidate === marker) {\n                found = true;\n                return false;\n            }\n            pos += candidate.len();\n            return true;\n        });\n        if (!found) {\n            return -1;\n        }\n        return pos;\n    }\n    fullLen(marker) {\n        let ret = 0;\n        walk([marker], marker => {\n            ret += marker.len();\n            return true;\n        });\n        return ret;\n    }\n    enclosingPlaceholders(placeholder) {\n        const ret = [];\n        let { parent } = placeholder;\n        while (parent) {\n            if (parent instanceof Placeholder) {\n                ret.push(parent);\n            }\n            parent = parent.parent;\n        }\n        return ret;\n    }\n    resolveVariables(resolver) {\n        this.walk(candidate => {\n            if (candidate instanceof Variable) {\n                if (candidate.resolve(resolver)) {\n                    this._placeholders = undefined;\n                }\n            }\n            return true;\n        });\n        return this;\n    }\n    appendChild(child) {\n        this._placeholders = undefined;\n        return super.appendChild(child);\n    }\n    replace(child, others) {\n        this._placeholders = undefined;\n        return super.replace(child, others);\n    }\n    clone() {\n        const ret = new TextmateSnippet();\n        this._children = this.children.map(child => child.clone());\n        return ret;\n    }\n    walk(visitor) {\n        walk(this.children, visitor);\n    }\n}\nexport class SnippetParser {\n    constructor() {\n        this._scanner = new Scanner();\n        this._token = { type: 14 /* TokenType.EOF */, pos: 0, len: 0 };\n    }\n    static escape(value) {\n        return value.replace(/\\$|}|\\\\/g, '\\\\$&');\n    }\n    static guessNeedsClipboard(template) {\n        return /\\${?CLIPBOARD/.test(template);\n    }\n    parse(value, insertFinalTabstop, enforceFinalTabstop) {\n        const snippet = new TextmateSnippet();\n        this.parseFragment(value, snippet);\n        this.ensureFinalTabstop(snippet, enforceFinalTabstop !== null && enforceFinalTabstop !== void 0 ? enforceFinalTabstop : false, insertFinalTabstop !== null && insertFinalTabstop !== void 0 ? insertFinalTabstop : false);\n        return snippet;\n    }\n    parseFragment(value, snippet) {\n        const offset = snippet.children.length;\n        this._scanner.text(value);\n        this._token = this._scanner.next();\n        while (this._parse(snippet)) {\n            // nothing\n        }\n        // fill in values for placeholders. the first placeholder of an index\n        // that has a value defines the value for all placeholders with that index\n        const placeholderDefaultValues = new Map();\n        const incompletePlaceholders = [];\n        snippet.walk(marker => {\n            if (marker instanceof Placeholder) {\n                if (marker.isFinalTabstop) {\n                    placeholderDefaultValues.set(0, undefined);\n                }\n                else if (!placeholderDefaultValues.has(marker.index) && marker.children.length > 0) {\n                    placeholderDefaultValues.set(marker.index, marker.children);\n                }\n                else {\n                    incompletePlaceholders.push(marker);\n                }\n            }\n            return true;\n        });\n        const fillInIncompletePlaceholder = (placeholder, stack) => {\n            const defaultValues = placeholderDefaultValues.get(placeholder.index);\n            if (!defaultValues) {\n                return;\n            }\n            const clone = new Placeholder(placeholder.index);\n            clone.transform = placeholder.transform;\n            for (const child of defaultValues) {\n                const newChild = child.clone();\n                clone.appendChild(newChild);\n                // \"recurse\" on children that are again placeholders\n                if (newChild instanceof Placeholder && placeholderDefaultValues.has(newChild.index) && !stack.has(newChild.index)) {\n                    stack.add(newChild.index);\n                    fillInIncompletePlaceholder(newChild, stack);\n                    stack.delete(newChild.index);\n                }\n            }\n            snippet.replace(placeholder, [clone]);\n        };\n        const stack = new Set();\n        for (const placeholder of incompletePlaceholders) {\n            fillInIncompletePlaceholder(placeholder, stack);\n        }\n        return snippet.children.slice(offset);\n    }\n    ensureFinalTabstop(snippet, enforceFinalTabstop, insertFinalTabstop) {\n        if (enforceFinalTabstop || insertFinalTabstop && snippet.placeholders.length > 0) {\n            const finalTabstop = snippet.placeholders.find(p => p.index === 0);\n            if (!finalTabstop) {\n                // the snippet uses placeholders but has no\n                // final tabstop defined -> insert at the end\n                snippet.appendChild(new Placeholder(0));\n            }\n        }\n    }\n    _accept(type, value) {\n        if (type === undefined || this._token.type === type) {\n            const ret = !value ? true : this._scanner.tokenText(this._token);\n            this._token = this._scanner.next();\n            return ret;\n        }\n        return false;\n    }\n    _backTo(token) {\n        this._scanner.pos = token.pos + token.len;\n        this._token = token;\n        return false;\n    }\n    _until(type) {\n        const start = this._token;\n        while (this._token.type !== type) {\n            if (this._token.type === 14 /* TokenType.EOF */) {\n                return false;\n            }\n            else if (this._token.type === 5 /* TokenType.Backslash */) {\n                const nextToken = this._scanner.next();\n                if (nextToken.type !== 0 /* TokenType.Dollar */\n                    && nextToken.type !== 4 /* TokenType.CurlyClose */\n                    && nextToken.type !== 5 /* TokenType.Backslash */) {\n                    return false;\n                }\n            }\n            this._token = this._scanner.next();\n        }\n        const value = this._scanner.value.substring(start.pos, this._token.pos).replace(/\\\\(\\$|}|\\\\)/g, '$1');\n        this._token = this._scanner.next();\n        return value;\n    }\n    _parse(marker) {\n        return this._parseEscaped(marker)\n            || this._parseTabstopOrVariableName(marker)\n            || this._parseComplexPlaceholder(marker)\n            || this._parseComplexVariable(marker)\n            || this._parseAnything(marker);\n    }\n    // \\$, \\\\, \\} -> just text\n    _parseEscaped(marker) {\n        let value;\n        if (value = this._accept(5 /* TokenType.Backslash */, true)) {\n            // saw a backslash, append escaped token or that backslash\n            value = this._accept(0 /* TokenType.Dollar */, true)\n                || this._accept(4 /* TokenType.CurlyClose */, true)\n                || this._accept(5 /* TokenType.Backslash */, true)\n                || value;\n            marker.appendChild(new Text(value));\n            return true;\n        }\n        return false;\n    }\n    // $foo -> variable, $1 -> tabstop\n    _parseTabstopOrVariableName(parent) {\n        let value;\n        const token = this._token;\n        const match = this._accept(0 /* TokenType.Dollar */)\n            && (value = this._accept(9 /* TokenType.VariableName */, true) || this._accept(8 /* TokenType.Int */, true));\n        if (!match) {\n            return this._backTo(token);\n        }\n        parent.appendChild(/^\\d+$/.test(value)\n            ? new Placeholder(Number(value))\n            : new Variable(value));\n        return true;\n    }\n    // ${1:<children>}, ${1} -> placeholder\n    _parseComplexPlaceholder(parent) {\n        let index;\n        const token = this._token;\n        const match = this._accept(0 /* TokenType.Dollar */)\n            && this._accept(3 /* TokenType.CurlyOpen */)\n            && (index = this._accept(8 /* TokenType.Int */, true));\n        if (!match) {\n            return this._backTo(token);\n        }\n        const placeholder = new Placeholder(Number(index));\n        if (this._accept(1 /* TokenType.Colon */)) {\n            // ${1:<children>}\n            while (true) {\n                // ...} -> done\n                if (this._accept(4 /* TokenType.CurlyClose */)) {\n                    parent.appendChild(placeholder);\n                    return true;\n                }\n                if (this._parse(placeholder)) {\n                    continue;\n                }\n                // fallback\n                parent.appendChild(new Text('${' + index + ':'));\n                placeholder.children.forEach(parent.appendChild, parent);\n                return true;\n            }\n        }\n        else if (placeholder.index > 0 && this._accept(7 /* TokenType.Pipe */)) {\n            // ${1|one,two,three|}\n            const choice = new Choice();\n            while (true) {\n                if (this._parseChoiceElement(choice)) {\n                    if (this._accept(2 /* TokenType.Comma */)) {\n                        // opt, -> more\n                        continue;\n                    }\n                    if (this._accept(7 /* TokenType.Pipe */)) {\n                        placeholder.appendChild(choice);\n                        if (this._accept(4 /* TokenType.CurlyClose */)) {\n                            // ..|} -> done\n                            parent.appendChild(placeholder);\n                            return true;\n                        }\n                    }\n                }\n                this._backTo(token);\n                return false;\n            }\n        }\n        else if (this._accept(6 /* TokenType.Forwardslash */)) {\n            // ${1/<regex>/<format>/<options>}\n            if (this._parseTransform(placeholder)) {\n                parent.appendChild(placeholder);\n                return true;\n            }\n            this._backTo(token);\n            return false;\n        }\n        else if (this._accept(4 /* TokenType.CurlyClose */)) {\n            // ${1}\n            parent.appendChild(placeholder);\n            return true;\n        }\n        else {\n            // ${1 <- missing curly or colon\n            return this._backTo(token);\n        }\n    }\n    _parseChoiceElement(parent) {\n        const token = this._token;\n        const values = [];\n        while (true) {\n            if (this._token.type === 2 /* TokenType.Comma */ || this._token.type === 7 /* TokenType.Pipe */) {\n                break;\n            }\n            let value;\n            if (value = this._accept(5 /* TokenType.Backslash */, true)) {\n                // \\, \\|, or \\\\\n                value = this._accept(2 /* TokenType.Comma */, true)\n                    || this._accept(7 /* TokenType.Pipe */, true)\n                    || this._accept(5 /* TokenType.Backslash */, true)\n                    || value;\n            }\n            else {\n                value = this._accept(undefined, true);\n            }\n            if (!value) {\n                // EOF\n                this._backTo(token);\n                return false;\n            }\n            values.push(value);\n        }\n        if (values.length === 0) {\n            this._backTo(token);\n            return false;\n        }\n        parent.appendChild(new Text(values.join('')));\n        return true;\n    }\n    // ${foo:<children>}, ${foo} -> variable\n    _parseComplexVariable(parent) {\n        let name;\n        const token = this._token;\n        const match = this._accept(0 /* TokenType.Dollar */)\n            && this._accept(3 /* TokenType.CurlyOpen */)\n            && (name = this._accept(9 /* TokenType.VariableName */, true));\n        if (!match) {\n            return this._backTo(token);\n        }\n        const variable = new Variable(name);\n        if (this._accept(1 /* TokenType.Colon */)) {\n            // ${foo:<children>}\n            while (true) {\n                // ...} -> done\n                if (this._accept(4 /* TokenType.CurlyClose */)) {\n                    parent.appendChild(variable);\n                    return true;\n                }\n                if (this._parse(variable)) {\n                    continue;\n                }\n                // fallback\n                parent.appendChild(new Text('${' + name + ':'));\n                variable.children.forEach(parent.appendChild, parent);\n                return true;\n            }\n        }\n        else if (this._accept(6 /* TokenType.Forwardslash */)) {\n            // ${foo/<regex>/<format>/<options>}\n            if (this._parseTransform(variable)) {\n                parent.appendChild(variable);\n                return true;\n            }\n            this._backTo(token);\n            return false;\n        }\n        else if (this._accept(4 /* TokenType.CurlyClose */)) {\n            // ${foo}\n            parent.appendChild(variable);\n            return true;\n        }\n        else {\n            // ${foo <- missing curly or colon\n            return this._backTo(token);\n        }\n    }\n    _parseTransform(parent) {\n        // ...<regex>/<format>/<options>}\n        const transform = new Transform();\n        let regexValue = '';\n        let regexOptions = '';\n        // (1) /regex\n        while (true) {\n            if (this._accept(6 /* TokenType.Forwardslash */)) {\n                break;\n            }\n            let escaped;\n            if (escaped = this._accept(5 /* TokenType.Backslash */, true)) {\n                escaped = this._accept(6 /* TokenType.Forwardslash */, true) || escaped;\n                regexValue += escaped;\n                continue;\n            }\n            if (this._token.type !== 14 /* TokenType.EOF */) {\n                regexValue += this._accept(undefined, true);\n                continue;\n            }\n            return false;\n        }\n        // (2) /format\n        while (true) {\n            if (this._accept(6 /* TokenType.Forwardslash */)) {\n                break;\n            }\n            let escaped;\n            if (escaped = this._accept(5 /* TokenType.Backslash */, true)) {\n                escaped = this._accept(5 /* TokenType.Backslash */, true) || this._accept(6 /* TokenType.Forwardslash */, true) || escaped;\n                transform.appendChild(new Text(escaped));\n                continue;\n            }\n            if (this._parseFormatString(transform) || this._parseAnything(transform)) {\n                continue;\n            }\n            return false;\n        }\n        // (3) /option\n        while (true) {\n            if (this._accept(4 /* TokenType.CurlyClose */)) {\n                break;\n            }\n            if (this._token.type !== 14 /* TokenType.EOF */) {\n                regexOptions += this._accept(undefined, true);\n                continue;\n            }\n            return false;\n        }\n        try {\n            transform.regexp = new RegExp(regexValue, regexOptions);\n        }\n        catch (e) {\n            // invalid regexp\n            return false;\n        }\n        parent.transform = transform;\n        return true;\n    }\n    _parseFormatString(parent) {\n        const token = this._token;\n        if (!this._accept(0 /* TokenType.Dollar */)) {\n            return false;\n        }\n        let complex = false;\n        if (this._accept(3 /* TokenType.CurlyOpen */)) {\n            complex = true;\n        }\n        const index = this._accept(8 /* TokenType.Int */, true);\n        if (!index) {\n            this._backTo(token);\n            return false;\n        }\n        else if (!complex) {\n            // $1\n            parent.appendChild(new FormatString(Number(index)));\n            return true;\n        }\n        else if (this._accept(4 /* TokenType.CurlyClose */)) {\n            // ${1}\n            parent.appendChild(new FormatString(Number(index)));\n            return true;\n        }\n        else if (!this._accept(1 /* TokenType.Colon */)) {\n            this._backTo(token);\n            return false;\n        }\n        if (this._accept(6 /* TokenType.Forwardslash */)) {\n            // ${1:/upcase}\n            const shorthand = this._accept(9 /* TokenType.VariableName */, true);\n            if (!shorthand || !this._accept(4 /* TokenType.CurlyClose */)) {\n                this._backTo(token);\n                return false;\n            }\n            else {\n                parent.appendChild(new FormatString(Number(index), shorthand));\n                return true;\n            }\n        }\n        else if (this._accept(11 /* TokenType.Plus */)) {\n            // ${1:+<if>}\n            const ifValue = this._until(4 /* TokenType.CurlyClose */);\n            if (ifValue) {\n                parent.appendChild(new FormatString(Number(index), undefined, ifValue, undefined));\n                return true;\n            }\n        }\n        else if (this._accept(12 /* TokenType.Dash */)) {\n            // ${2:-<else>}\n            const elseValue = this._until(4 /* TokenType.CurlyClose */);\n            if (elseValue) {\n                parent.appendChild(new FormatString(Number(index), undefined, undefined, elseValue));\n                return true;\n            }\n        }\n        else if (this._accept(13 /* TokenType.QuestionMark */)) {\n            // ${2:?<if>:<else>}\n            const ifValue = this._until(1 /* TokenType.Colon */);\n            if (ifValue) {\n                const elseValue = this._until(4 /* TokenType.CurlyClose */);\n                if (elseValue) {\n                    parent.appendChild(new FormatString(Number(index), undefined, ifValue, elseValue));\n                    return true;\n                }\n            }\n        }\n        else {\n            // ${1:<else>}\n            const elseValue = this._until(4 /* TokenType.CurlyClose */);\n            if (elseValue) {\n                parent.appendChild(new FormatString(Number(index), undefined, undefined, elseValue));\n                return true;\n            }\n        }\n        this._backTo(token);\n        return false;\n    }\n    _parseAnything(marker) {\n        if (this._token.type !== 14 /* TokenType.EOF */) {\n            marker.appendChild(new Text(this._scanner.tokenText(this._token)));\n            this._accept(undefined);\n            return true;\n        }\n        return false;\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 { normalizeDriveLetter } from '../../../../base/common/labels.js';\nimport * as path from '../../../../base/common/path.js';\nimport { dirname } from '../../../../base/common/resources.js';\nimport { commonPrefixLength, getLeadingWhitespace, isFalsyOrWhitespace, splitLines } from '../../../../base/common/strings.js';\nimport { generateUuid } from '../../../../base/common/uuid.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport { Text } from './snippetParser.js';\nimport * as nls from '../../../../nls.js';\nimport { WORKSPACE_EXTENSION, isSingleFolderWorkspaceIdentifier, toWorkspaceIdentifier, isEmptyWorkspaceIdentifier } from '../../../../platform/workspace/common/workspace.js';\nexport const KnownSnippetVariableNames = Object.freeze({\n    'CURRENT_YEAR': true,\n    'CURRENT_YEAR_SHORT': true,\n    'CURRENT_MONTH': true,\n    'CURRENT_DATE': true,\n    'CURRENT_HOUR': true,\n    'CURRENT_MINUTE': true,\n    'CURRENT_SECOND': true,\n    'CURRENT_DAY_NAME': true,\n    'CURRENT_DAY_NAME_SHORT': true,\n    'CURRENT_MONTH_NAME': true,\n    'CURRENT_MONTH_NAME_SHORT': true,\n    'CURRENT_SECONDS_UNIX': true,\n    'CURRENT_TIMEZONE_OFFSET': true,\n    'SELECTION': true,\n    'CLIPBOARD': true,\n    'TM_SELECTED_TEXT': true,\n    'TM_CURRENT_LINE': true,\n    'TM_CURRENT_WORD': true,\n    'TM_LINE_INDEX': true,\n    'TM_LINE_NUMBER': true,\n    'TM_FILENAME': true,\n    'TM_FILENAME_BASE': true,\n    'TM_DIRECTORY': true,\n    'TM_FILEPATH': true,\n    'CURSOR_INDEX': true, // 0-offset\n    'CURSOR_NUMBER': true, // 1-offset\n    'RELATIVE_FILEPATH': true,\n    'BLOCK_COMMENT_START': true,\n    'BLOCK_COMMENT_END': true,\n    'LINE_COMMENT': true,\n    'WORKSPACE_NAME': true,\n    'WORKSPACE_FOLDER': true,\n    'RANDOM': true,\n    'RANDOM_HEX': true,\n    'UUID': true\n});\nexport class CompositeSnippetVariableResolver {\n    constructor(_delegates) {\n        this._delegates = _delegates;\n        //\n    }\n    resolve(variable) {\n        for (const delegate of this._delegates) {\n            const value = delegate.resolve(variable);\n            if (value !== undefined) {\n                return value;\n            }\n        }\n        return undefined;\n    }\n}\nexport class SelectionBasedVariableResolver {\n    constructor(_model, _selection, _selectionIdx, _overtypingCapturer) {\n        this._model = _model;\n        this._selection = _selection;\n        this._selectionIdx = _selectionIdx;\n        this._overtypingCapturer = _overtypingCapturer;\n        //\n    }\n    resolve(variable) {\n        const { name } = variable;\n        if (name === 'SELECTION' || name === 'TM_SELECTED_TEXT') {\n            let value = this._model.getValueInRange(this._selection) || undefined;\n            let isMultiline = this._selection.startLineNumber !== this._selection.endLineNumber;\n            // If there was no selected text, try to get last overtyped text\n            if (!value && this._overtypingCapturer) {\n                const info = this._overtypingCapturer.getLastOvertypedInfo(this._selectionIdx);\n                if (info) {\n                    value = info.value;\n                    isMultiline = info.multiline;\n                }\n            }\n            if (value && isMultiline && variable.snippet) {\n                // Selection is a multiline string which we indentation we now\n                // need to adjust. We compare the indentation of this variable\n                // with the indentation at the editor position and add potential\n                // extra indentation to the value\n                const line = this._model.getLineContent(this._selection.startLineNumber);\n                const lineLeadingWhitespace = getLeadingWhitespace(line, 0, this._selection.startColumn - 1);\n                let varLeadingWhitespace = lineLeadingWhitespace;\n                variable.snippet.walk(marker => {\n                    if (marker === variable) {\n                        return false;\n                    }\n                    if (marker instanceof Text) {\n                        varLeadingWhitespace = getLeadingWhitespace(splitLines(marker.value).pop());\n                    }\n                    return true;\n                });\n                const whitespaceCommonLength = commonPrefixLength(varLeadingWhitespace, lineLeadingWhitespace);\n                value = value.replace(/(\\r\\n|\\r|\\n)(.*)/g, (m, newline, rest) => `${newline}${varLeadingWhitespace.substr(whitespaceCommonLength)}${rest}`);\n            }\n            return value;\n        }\n        else if (name === 'TM_CURRENT_LINE') {\n            return this._model.getLineContent(this._selection.positionLineNumber);\n        }\n        else if (name === 'TM_CURRENT_WORD') {\n            const info = this._model.getWordAtPosition({\n                lineNumber: this._selection.positionLineNumber,\n                column: this._selection.positionColumn\n            });\n            return info && info.word || undefined;\n        }\n        else if (name === 'TM_LINE_INDEX') {\n            return String(this._selection.positionLineNumber - 1);\n        }\n        else if (name === 'TM_LINE_NUMBER') {\n            return String(this._selection.positionLineNumber);\n        }\n        else if (name === 'CURSOR_INDEX') {\n            return String(this._selectionIdx);\n        }\n        else if (name === 'CURSOR_NUMBER') {\n            return String(this._selectionIdx + 1);\n        }\n        return undefined;\n    }\n}\nexport class ModelBasedVariableResolver {\n    constructor(_labelService, _model) {\n        this._labelService = _labelService;\n        this._model = _model;\n        //\n    }\n    resolve(variable) {\n        const { name } = variable;\n        if (name === 'TM_FILENAME') {\n            return path.basename(this._model.uri.fsPath);\n        }\n        else if (name === 'TM_FILENAME_BASE') {\n            const name = path.basename(this._model.uri.fsPath);\n            const idx = name.lastIndexOf('.');\n            if (idx <= 0) {\n                return name;\n            }\n            else {\n                return name.slice(0, idx);\n            }\n        }\n        else if (name === 'TM_DIRECTORY') {\n            if (path.dirname(this._model.uri.fsPath) === '.') {\n                return '';\n            }\n            return this._labelService.getUriLabel(dirname(this._model.uri));\n        }\n        else if (name === 'TM_FILEPATH') {\n            return this._labelService.getUriLabel(this._model.uri);\n        }\n        else if (name === 'RELATIVE_FILEPATH') {\n            return this._labelService.getUriLabel(this._model.uri, { relative: true, noPrefix: true });\n        }\n        return undefined;\n    }\n}\nexport class ClipboardBasedVariableResolver {\n    constructor(_readClipboardText, _selectionIdx, _selectionCount, _spread) {\n        this._readClipboardText = _readClipboardText;\n        this._selectionIdx = _selectionIdx;\n        this._selectionCount = _selectionCount;\n        this._spread = _spread;\n        //\n    }\n    resolve(variable) {\n        if (variable.name !== 'CLIPBOARD') {\n            return undefined;\n        }\n        const clipboardText = this._readClipboardText();\n        if (!clipboardText) {\n            return undefined;\n        }\n        // `spread` is assigning each cursor a line of the clipboard\n        // text whenever there the line count equals the cursor count\n        // and when enabled\n        if (this._spread) {\n            const lines = clipboardText.split(/\\r\\n|\\n|\\r/).filter(s => !isFalsyOrWhitespace(s));\n            if (lines.length === this._selectionCount) {\n                return lines[this._selectionIdx];\n            }\n        }\n        return clipboardText;\n    }\n}\nlet CommentBasedVariableResolver = class CommentBasedVariableResolver {\n    constructor(_model, _selection, _languageConfigurationService) {\n        this._model = _model;\n        this._selection = _selection;\n        this._languageConfigurationService = _languageConfigurationService;\n        //\n    }\n    resolve(variable) {\n        const { name } = variable;\n        const langId = this._model.getLanguageIdAtPosition(this._selection.selectionStartLineNumber, this._selection.selectionStartColumn);\n        const config = this._languageConfigurationService.getLanguageConfiguration(langId).comments;\n        if (!config) {\n            return undefined;\n        }\n        if (name === 'LINE_COMMENT') {\n            return config.lineCommentToken || undefined;\n        }\n        else if (name === 'BLOCK_COMMENT_START') {\n            return config.blockCommentStartToken || undefined;\n        }\n        else if (name === 'BLOCK_COMMENT_END') {\n            return config.blockCommentEndToken || undefined;\n        }\n        return undefined;\n    }\n};\nCommentBasedVariableResolver = __decorate([\n    __param(2, ILanguageConfigurationService)\n], CommentBasedVariableResolver);\nexport { CommentBasedVariableResolver };\nexport class TimeBasedVariableResolver {\n    constructor() {\n        this._date = new Date();\n    }\n    resolve(variable) {\n        const { name } = variable;\n        if (name === 'CURRENT_YEAR') {\n            return String(this._date.getFullYear());\n        }\n        else if (name === 'CURRENT_YEAR_SHORT') {\n            return String(this._date.getFullYear()).slice(-2);\n        }\n        else if (name === 'CURRENT_MONTH') {\n            return String(this._date.getMonth().valueOf() + 1).padStart(2, '0');\n        }\n        else if (name === 'CURRENT_DATE') {\n            return String(this._date.getDate().valueOf()).padStart(2, '0');\n        }\n        else if (name === 'CURRENT_HOUR') {\n            return String(this._date.getHours().valueOf()).padStart(2, '0');\n        }\n        else if (name === 'CURRENT_MINUTE') {\n            return String(this._date.getMinutes().valueOf()).padStart(2, '0');\n        }\n        else if (name === 'CURRENT_SECOND') {\n            return String(this._date.getSeconds().valueOf()).padStart(2, '0');\n        }\n        else if (name === 'CURRENT_DAY_NAME') {\n            return TimeBasedVariableResolver.dayNames[this._date.getDay()];\n        }\n        else if (name === 'CURRENT_DAY_NAME_SHORT') {\n            return TimeBasedVariableResolver.dayNamesShort[this._date.getDay()];\n        }\n        else if (name === 'CURRENT_MONTH_NAME') {\n            return TimeBasedVariableResolver.monthNames[this._date.getMonth()];\n        }\n        else if (name === 'CURRENT_MONTH_NAME_SHORT') {\n            return TimeBasedVariableResolver.monthNamesShort[this._date.getMonth()];\n        }\n        else if (name === 'CURRENT_SECONDS_UNIX') {\n            return String(Math.floor(this._date.getTime() / 1000));\n        }\n        else if (name === 'CURRENT_TIMEZONE_OFFSET') {\n            const rawTimeOffset = this._date.getTimezoneOffset();\n            const sign = rawTimeOffset > 0 ? '-' : '+';\n            const hours = Math.trunc(Math.abs(rawTimeOffset / 60));\n            const hoursString = (hours < 10 ? '0' + hours : hours);\n            const minutes = Math.abs(rawTimeOffset) - hours * 60;\n            const minutesString = (minutes < 10 ? '0' + minutes : minutes);\n            return sign + hoursString + ':' + minutesString;\n        }\n        return undefined;\n    }\n}\nTimeBasedVariableResolver.dayNames = [nls.localize('Sunday', \"Sunday\"), nls.localize('Monday', \"Monday\"), nls.localize('Tuesday', \"Tuesday\"), nls.localize('Wednesday', \"Wednesday\"), nls.localize('Thursday', \"Thursday\"), nls.localize('Friday', \"Friday\"), nls.localize('Saturday', \"Saturday\")];\nTimeBasedVariableResolver.dayNamesShort = [nls.localize('SundayShort', \"Sun\"), nls.localize('MondayShort', \"Mon\"), nls.localize('TuesdayShort', \"Tue\"), nls.localize('WednesdayShort', \"Wed\"), nls.localize('ThursdayShort', \"Thu\"), nls.localize('FridayShort', \"Fri\"), nls.localize('SaturdayShort', \"Sat\")];\nTimeBasedVariableResolver.monthNames = [nls.localize('January', \"January\"), nls.localize('February', \"February\"), nls.localize('March', \"March\"), nls.localize('April', \"April\"), nls.localize('May', \"May\"), nls.localize('June', \"June\"), nls.localize('July', \"July\"), nls.localize('August', \"August\"), nls.localize('September', \"September\"), nls.localize('October', \"October\"), nls.localize('November', \"November\"), nls.localize('December', \"December\")];\nTimeBasedVariableResolver.monthNamesShort = [nls.localize('JanuaryShort', \"Jan\"), nls.localize('FebruaryShort', \"Feb\"), nls.localize('MarchShort', \"Mar\"), nls.localize('AprilShort', \"Apr\"), nls.localize('MayShort', \"May\"), nls.localize('JuneShort', \"Jun\"), nls.localize('JulyShort', \"Jul\"), nls.localize('AugustShort', \"Aug\"), nls.localize('SeptemberShort', \"Sep\"), nls.localize('OctoberShort', \"Oct\"), nls.localize('NovemberShort', \"Nov\"), nls.localize('DecemberShort', \"Dec\")];\nexport class WorkspaceBasedVariableResolver {\n    constructor(_workspaceService) {\n        this._workspaceService = _workspaceService;\n        //\n    }\n    resolve(variable) {\n        if (!this._workspaceService) {\n            return undefined;\n        }\n        const workspaceIdentifier = toWorkspaceIdentifier(this._workspaceService.getWorkspace());\n        if (isEmptyWorkspaceIdentifier(workspaceIdentifier)) {\n            return undefined;\n        }\n        if (variable.name === 'WORKSPACE_NAME') {\n            return this._resolveWorkspaceName(workspaceIdentifier);\n        }\n        else if (variable.name === 'WORKSPACE_FOLDER') {\n            return this._resoveWorkspacePath(workspaceIdentifier);\n        }\n        return undefined;\n    }\n    _resolveWorkspaceName(workspaceIdentifier) {\n        if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {\n            return path.basename(workspaceIdentifier.uri.path);\n        }\n        let filename = path.basename(workspaceIdentifier.configPath.path);\n        if (filename.endsWith(WORKSPACE_EXTENSION)) {\n            filename = filename.substr(0, filename.length - WORKSPACE_EXTENSION.length - 1);\n        }\n        return filename;\n    }\n    _resoveWorkspacePath(workspaceIdentifier) {\n        if (isSingleFolderWorkspaceIdentifier(workspaceIdentifier)) {\n            return normalizeDriveLetter(workspaceIdentifier.uri.fsPath);\n        }\n        const filename = path.basename(workspaceIdentifier.configPath.path);\n        let folderpath = workspaceIdentifier.configPath.fsPath;\n        if (folderpath.endsWith(filename)) {\n            folderpath = folderpath.substr(0, folderpath.length - filename.length - 1);\n        }\n        return (folderpath ? normalizeDriveLetter(folderpath) : '/');\n    }\n}\nexport class RandomBasedVariableResolver {\n    resolve(variable) {\n        const { name } = variable;\n        if (name === 'RANDOM') {\n            return Math.random().toString().slice(-6);\n        }\n        else if (name === 'RANDOM_HEX') {\n            return Math.random().toString(16).slice(-6);\n        }\n        else if (name === 'UUID') {\n            return generateUuid();\n        }\n        return undefined;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nvar __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\nvar SnippetSession_1;\nimport { groupBy } from '../../../../base/common/arrays.js';\nimport { dispose } from '../../../../base/common/lifecycle.js';\nimport { getLeadingWhitespace } from '../../../../base/common/strings.js';\nimport './snippetSession.css';\nimport { EditOperation } from '../../../common/core/editOperation.js';\nimport { Range } from '../../../common/core/range.js';\nimport { Selection } from '../../../common/core/selection.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport { ModelDecorationOptions } from '../../../common/model/textModel.js';\nimport { ILabelService } from '../../../../platform/label/common/label.js';\nimport { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';\nimport { Choice, Placeholder, SnippetParser, Text, TextmateSnippet } from './snippetParser.js';\nimport { ClipboardBasedVariableResolver, CommentBasedVariableResolver, CompositeSnippetVariableResolver, ModelBasedVariableResolver, RandomBasedVariableResolver, SelectionBasedVariableResolver, TimeBasedVariableResolver, WorkspaceBasedVariableResolver } from './snippetVariables.js';\nexport class OneSnippet {\n    constructor(_editor, _snippet, _snippetLineLeadingWhitespace) {\n        this._editor = _editor;\n        this._snippet = _snippet;\n        this._snippetLineLeadingWhitespace = _snippetLineLeadingWhitespace;\n        this._offset = -1;\n        this._nestingLevel = 1;\n        this._placeholderGroups = groupBy(_snippet.placeholders, Placeholder.compareByIndex);\n        this._placeholderGroupsIdx = -1;\n    }\n    initialize(textChange) {\n        this._offset = textChange.newPosition;\n    }\n    dispose() {\n        if (this._placeholderDecorations) {\n            this._editor.removeDecorations([...this._placeholderDecorations.values()]);\n        }\n        this._placeholderGroups.length = 0;\n    }\n    _initDecorations() {\n        if (this._offset === -1) {\n            throw new Error(`Snippet not initialized!`);\n        }\n        if (this._placeholderDecorations) {\n            // already initialized\n            return;\n        }\n        this._placeholderDecorations = new Map();\n        const model = this._editor.getModel();\n        this._editor.changeDecorations(accessor => {\n            // create a decoration for each placeholder\n            for (const placeholder of this._snippet.placeholders) {\n                const placeholderOffset = this._snippet.offset(placeholder);\n                const placeholderLen = this._snippet.fullLen(placeholder);\n                const range = Range.fromPositions(model.getPositionAt(this._offset + placeholderOffset), model.getPositionAt(this._offset + placeholderOffset + placeholderLen));\n                const options = placeholder.isFinalTabstop ? OneSnippet._decor.inactiveFinal : OneSnippet._decor.inactive;\n                const handle = accessor.addDecoration(range, options);\n                this._placeholderDecorations.set(placeholder, handle);\n            }\n        });\n    }\n    move(fwd) {\n        if (!this._editor.hasModel()) {\n            return [];\n        }\n        this._initDecorations();\n        // Transform placeholder text if necessary\n        if (this._placeholderGroupsIdx >= 0) {\n            const operations = [];\n            for (const placeholder of this._placeholderGroups[this._placeholderGroupsIdx]) {\n                // Check if the placeholder has a transformation\n                if (placeholder.transform) {\n                    const id = this._placeholderDecorations.get(placeholder);\n                    const range = this._editor.getModel().getDecorationRange(id);\n                    const currentValue = this._editor.getModel().getValueInRange(range);\n                    const transformedValueLines = placeholder.transform.resolve(currentValue).split(/\\r\\n|\\r|\\n/);\n                    // fix indentation for transformed lines\n                    for (let i = 1; i < transformedValueLines.length; i++) {\n                        transformedValueLines[i] = this._editor.getModel().normalizeIndentation(this._snippetLineLeadingWhitespace + transformedValueLines[i]);\n                    }\n                    operations.push(EditOperation.replace(range, transformedValueLines.join(this._editor.getModel().getEOL())));\n                }\n            }\n            if (operations.length > 0) {\n                this._editor.executeEdits('snippet.placeholderTransform', operations);\n            }\n        }\n        let couldSkipThisPlaceholder = false;\n        if (fwd === true && this._placeholderGroupsIdx < this._placeholderGroups.length - 1) {\n            this._placeholderGroupsIdx += 1;\n            couldSkipThisPlaceholder = true;\n        }\n        else if (fwd === false && this._placeholderGroupsIdx > 0) {\n            this._placeholderGroupsIdx -= 1;\n            couldSkipThisPlaceholder = true;\n        }\n        else {\n            // the selection of the current placeholder might\n            // not acurate any more -> simply restore it\n        }\n        const newSelections = this._editor.getModel().changeDecorations(accessor => {\n            const activePlaceholders = new Set();\n            // change stickiness to always grow when typing at its edges\n            // because these decorations represent the currently active\n            // tabstop.\n            // Special case #1: reaching the final tabstop\n            // Special case #2: placeholders enclosing active placeholders\n            const selections = [];\n            for (const placeholder of this._placeholderGroups[this._placeholderGroupsIdx]) {\n                const id = this._placeholderDecorations.get(placeholder);\n                const range = this._editor.getModel().getDecorationRange(id);\n                selections.push(new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn));\n                // consider to skip this placeholder index when the decoration\n                // range is empty but when the placeholder wasn't. that's a strong\n                // hint that the placeholder has been deleted. (all placeholder must match this)\n                couldSkipThisPlaceholder = couldSkipThisPlaceholder && this._hasPlaceholderBeenCollapsed(placeholder);\n                accessor.changeDecorationOptions(id, placeholder.isFinalTabstop ? OneSnippet._decor.activeFinal : OneSnippet._decor.active);\n                activePlaceholders.add(placeholder);\n                for (const enclosingPlaceholder of this._snippet.enclosingPlaceholders(placeholder)) {\n                    const id = this._placeholderDecorations.get(enclosingPlaceholder);\n                    accessor.changeDecorationOptions(id, enclosingPlaceholder.isFinalTabstop ? OneSnippet._decor.activeFinal : OneSnippet._decor.active);\n                    activePlaceholders.add(enclosingPlaceholder);\n                }\n            }\n            // change stickness to never grow when typing at its edges\n            // so that in-active tabstops never grow\n            for (const [placeholder, id] of this._placeholderDecorations) {\n                if (!activePlaceholders.has(placeholder)) {\n                    accessor.changeDecorationOptions(id, placeholder.isFinalTabstop ? OneSnippet._decor.inactiveFinal : OneSnippet._decor.inactive);\n                }\n            }\n            return selections;\n        });\n        return !couldSkipThisPlaceholder ? newSelections !== null && newSelections !== void 0 ? newSelections : [] : this.move(fwd);\n    }\n    _hasPlaceholderBeenCollapsed(placeholder) {\n        // A placeholder is empty when it wasn't empty when authored but\n        // when its tracking decoration is empty. This also applies to all\n        // potential parent placeholders\n        let marker = placeholder;\n        while (marker) {\n            if (marker instanceof Placeholder) {\n                const id = this._placeholderDecorations.get(marker);\n                const range = this._editor.getModel().getDecorationRange(id);\n                if (range.isEmpty() && marker.toString().length > 0) {\n                    return true;\n                }\n            }\n            marker = marker.parent;\n        }\n        return false;\n    }\n    get isAtFirstPlaceholder() {\n        return this._placeholderGroupsIdx <= 0 || this._placeholderGroups.length === 0;\n    }\n    get isAtLastPlaceholder() {\n        return this._placeholderGroupsIdx === this._placeholderGroups.length - 1;\n    }\n    get hasPlaceholder() {\n        return this._snippet.placeholders.length > 0;\n    }\n    /**\n     * A snippet is trivial when it has no placeholder or only a final placeholder at\n     * its very end\n     */\n    get isTrivialSnippet() {\n        if (this._snippet.placeholders.length === 0) {\n            return true;\n        }\n        if (this._snippet.placeholders.length === 1) {\n            const [placeholder] = this._snippet.placeholders;\n            if (placeholder.isFinalTabstop) {\n                if (this._snippet.rightMostDescendant === placeholder) {\n                    return true;\n                }\n            }\n        }\n        return false;\n    }\n    computePossibleSelections() {\n        const result = new Map();\n        for (const placeholdersWithEqualIndex of this._placeholderGroups) {\n            let ranges;\n            for (const placeholder of placeholdersWithEqualIndex) {\n                if (placeholder.isFinalTabstop) {\n                    // ignore those\n                    break;\n                }\n                if (!ranges) {\n                    ranges = [];\n                    result.set(placeholder.index, ranges);\n                }\n                const id = this._placeholderDecorations.get(placeholder);\n                const range = this._editor.getModel().getDecorationRange(id);\n                if (!range) {\n                    // one of the placeholder lost its decoration and\n                    // therefore we bail out and pretend the placeholder\n                    // (with its mirrors) doesn't exist anymore.\n                    result.delete(placeholder.index);\n                    break;\n                }\n                ranges.push(range);\n            }\n        }\n        return result;\n    }\n    get activeChoice() {\n        if (!this._placeholderDecorations) {\n            return undefined;\n        }\n        const placeholder = this._placeholderGroups[this._placeholderGroupsIdx][0];\n        if (!(placeholder === null || placeholder === void 0 ? void 0 : placeholder.choice)) {\n            return undefined;\n        }\n        const id = this._placeholderDecorations.get(placeholder);\n        if (!id) {\n            return undefined;\n        }\n        const range = this._editor.getModel().getDecorationRange(id);\n        if (!range) {\n            return undefined;\n        }\n        return { range, choice: placeholder.choice };\n    }\n    get hasChoice() {\n        let result = false;\n        this._snippet.walk(marker => {\n            result = marker instanceof Choice;\n            return !result;\n        });\n        return result;\n    }\n    merge(others) {\n        const model = this._editor.getModel();\n        this._nestingLevel *= 10;\n        this._editor.changeDecorations(accessor => {\n            // For each active placeholder take one snippet and merge it\n            // in that the placeholder (can be many for `$1foo$1foo`). Because\n            // everything is sorted by editor selection we can simply remove\n            // elements from the beginning of the array\n            for (const placeholder of this._placeholderGroups[this._placeholderGroupsIdx]) {\n                const nested = others.shift();\n                console.assert(nested._offset !== -1);\n                console.assert(!nested._placeholderDecorations);\n                // Massage placeholder-indicies of the nested snippet to be\n                // sorted right after the insertion point. This ensures we move\n                // through the placeholders in the correct order\n                const indexLastPlaceholder = nested._snippet.placeholderInfo.last.index;\n                for (const nestedPlaceholder of nested._snippet.placeholderInfo.all) {\n                    if (nestedPlaceholder.isFinalTabstop) {\n                        nestedPlaceholder.index = placeholder.index + ((indexLastPlaceholder + 1) / this._nestingLevel);\n                    }\n                    else {\n                        nestedPlaceholder.index = placeholder.index + (nestedPlaceholder.index / this._nestingLevel);\n                    }\n                }\n                this._snippet.replace(placeholder, nested._snippet.children);\n                // Remove the placeholder at which position are inserting\n                // the snippet and also remove its decoration.\n                const id = this._placeholderDecorations.get(placeholder);\n                accessor.removeDecoration(id);\n                this._placeholderDecorations.delete(placeholder);\n                // For each *new* placeholder we create decoration to monitor\n                // how and if it grows/shrinks.\n                for (const placeholder of nested._snippet.placeholders) {\n                    const placeholderOffset = nested._snippet.offset(placeholder);\n                    const placeholderLen = nested._snippet.fullLen(placeholder);\n                    const range = Range.fromPositions(model.getPositionAt(nested._offset + placeholderOffset), model.getPositionAt(nested._offset + placeholderOffset + placeholderLen));\n                    const handle = accessor.addDecoration(range, OneSnippet._decor.inactive);\n                    this._placeholderDecorations.set(placeholder, handle);\n                }\n            }\n            // Last, re-create the placeholder groups by sorting placeholders by their index.\n            this._placeholderGroups = groupBy(this._snippet.placeholders, Placeholder.compareByIndex);\n        });\n    }\n}\nOneSnippet._decor = {\n    active: ModelDecorationOptions.register({ description: 'snippet-placeholder-1', stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */, className: 'snippet-placeholder' }),\n    inactive: ModelDecorationOptions.register({ description: 'snippet-placeholder-2', stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */, className: 'snippet-placeholder' }),\n    activeFinal: ModelDecorationOptions.register({ description: 'snippet-placeholder-3', stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */, className: 'finish-snippet-placeholder' }),\n    inactiveFinal: ModelDecorationOptions.register({ description: 'snippet-placeholder-4', stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */, className: 'finish-snippet-placeholder' }),\n};\nconst _defaultOptions = {\n    overwriteBefore: 0,\n    overwriteAfter: 0,\n    adjustWhitespace: true,\n    clipboardText: undefined,\n    overtypingCapturer: undefined\n};\nlet SnippetSession = SnippetSession_1 = class SnippetSession {\n    static adjustWhitespace(model, position, adjustIndentation, snippet, filter) {\n        const line = model.getLineContent(position.lineNumber);\n        const lineLeadingWhitespace = getLeadingWhitespace(line, 0, position.column - 1);\n        // the snippet as inserted\n        let snippetTextString;\n        snippet.walk(marker => {\n            // all text elements that are not inside choice\n            if (!(marker instanceof Text) || marker.parent instanceof Choice) {\n                return true;\n            }\n            // check with filter (iff provided)\n            if (filter && !filter.has(marker)) {\n                return true;\n            }\n            const lines = marker.value.split(/\\r\\n|\\r|\\n/);\n            if (adjustIndentation) {\n                // adjust indentation of snippet test\n                // -the snippet-start doesn't get extra-indented (lineLeadingWhitespace), only normalized\n                // -all N+1 lines get extra-indented and normalized\n                // -the text start get extra-indented and normalized when following a linebreak\n                const offset = snippet.offset(marker);\n                if (offset === 0) {\n                    // snippet start\n                    lines[0] = model.normalizeIndentation(lines[0]);\n                }\n                else {\n                    // check if text start is after a linebreak\n                    snippetTextString = snippetTextString !== null && snippetTextString !== void 0 ? snippetTextString : snippet.toString();\n                    const prevChar = snippetTextString.charCodeAt(offset - 1);\n                    if (prevChar === 10 /* CharCode.LineFeed */ || prevChar === 13 /* CharCode.CarriageReturn */) {\n                        lines[0] = model.normalizeIndentation(lineLeadingWhitespace + lines[0]);\n                    }\n                }\n                for (let i = 1; i < lines.length; i++) {\n                    lines[i] = model.normalizeIndentation(lineLeadingWhitespace + lines[i]);\n                }\n            }\n            const newValue = lines.join(model.getEOL());\n            if (newValue !== marker.value) {\n                marker.parent.replace(marker, [new Text(newValue)]);\n                snippetTextString = undefined;\n            }\n            return true;\n        });\n        return lineLeadingWhitespace;\n    }\n    static adjustSelection(model, selection, overwriteBefore, overwriteAfter) {\n        if (overwriteBefore !== 0 || overwriteAfter !== 0) {\n            // overwrite[Before|After] is compute using the position, not the whole\n            // selection. therefore we adjust the selection around that position\n            const { positionLineNumber, positionColumn } = selection;\n            const positionColumnBefore = positionColumn - overwriteBefore;\n            const positionColumnAfter = positionColumn + overwriteAfter;\n            const range = model.validateRange({\n                startLineNumber: positionLineNumber,\n                startColumn: positionColumnBefore,\n                endLineNumber: positionLineNumber,\n                endColumn: positionColumnAfter\n            });\n            selection = Selection.createWithDirection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn, selection.getDirection());\n        }\n        return selection;\n    }\n    static createEditsAndSnippetsFromSelections(editor, template, overwriteBefore, overwriteAfter, enforceFinalTabstop, adjustWhitespace, clipboardText, overtypingCapturer, languageConfigurationService) {\n        const edits = [];\n        const snippets = [];\n        if (!editor.hasModel()) {\n            return { edits, snippets };\n        }\n        const model = editor.getModel();\n        const workspaceService = editor.invokeWithinContext(accessor => accessor.get(IWorkspaceContextService));\n        const modelBasedVariableResolver = editor.invokeWithinContext(accessor => new ModelBasedVariableResolver(accessor.get(ILabelService), model));\n        const readClipboardText = () => clipboardText;\n        // know what text the overwrite[Before|After] extensions\n        // of the primary curser have selected because only when\n        // secondary selections extend to the same text we can grow them\n        const firstBeforeText = model.getValueInRange(SnippetSession_1.adjustSelection(model, editor.getSelection(), overwriteBefore, 0));\n        const firstAfterText = model.getValueInRange(SnippetSession_1.adjustSelection(model, editor.getSelection(), 0, overwriteAfter));\n        // remember the first non-whitespace column to decide if\n        // `keepWhitespace` should be overruled for secondary selections\n        const firstLineFirstNonWhitespace = model.getLineFirstNonWhitespaceColumn(editor.getSelection().positionLineNumber);\n        // sort selections by their start position but remeber\n        // the original index. that allows you to create correct\n        // offset-based selection logic without changing the\n        // primary selection\n        const indexedSelections = editor.getSelections()\n            .map((selection, idx) => ({ selection, idx }))\n            .sort((a, b) => Range.compareRangesUsingStarts(a.selection, b.selection));\n        for (const { selection, idx } of indexedSelections) {\n            // extend selection with the `overwriteBefore` and `overwriteAfter` and then\n            // compare if this matches the extensions of the primary selection\n            let extensionBefore = SnippetSession_1.adjustSelection(model, selection, overwriteBefore, 0);\n            let extensionAfter = SnippetSession_1.adjustSelection(model, selection, 0, overwriteAfter);\n            if (firstBeforeText !== model.getValueInRange(extensionBefore)) {\n                extensionBefore = selection;\n            }\n            if (firstAfterText !== model.getValueInRange(extensionAfter)) {\n                extensionAfter = selection;\n            }\n            // merge the before and after selection into one\n            const snippetSelection = selection\n                .setStartPosition(extensionBefore.startLineNumber, extensionBefore.startColumn)\n                .setEndPosition(extensionAfter.endLineNumber, extensionAfter.endColumn);\n            const snippet = new SnippetParser().parse(template, true, enforceFinalTabstop);\n            // adjust the template string to match the indentation and\n            // whitespace rules of this insert location (can be different for each cursor)\n            // happens when being asked for (default) or when this is a secondary\n            // cursor and the leading whitespace is different\n            const start = snippetSelection.getStartPosition();\n            const snippetLineLeadingWhitespace = SnippetSession_1.adjustWhitespace(model, start, adjustWhitespace || (idx > 0 && firstLineFirstNonWhitespace !== model.getLineFirstNonWhitespaceColumn(selection.positionLineNumber)), snippet);\n            snippet.resolveVariables(new CompositeSnippetVariableResolver([\n                modelBasedVariableResolver,\n                new ClipboardBasedVariableResolver(readClipboardText, idx, indexedSelections.length, editor.getOption(79 /* EditorOption.multiCursorPaste */) === 'spread'),\n                new SelectionBasedVariableResolver(model, selection, idx, overtypingCapturer),\n                new CommentBasedVariableResolver(model, selection, languageConfigurationService),\n                new TimeBasedVariableResolver,\n                new WorkspaceBasedVariableResolver(workspaceService),\n                new RandomBasedVariableResolver,\n            ]));\n            // store snippets with the index of their originating selection.\n            // that ensures the primiary cursor stays primary despite not being\n            // the one with lowest start position\n            edits[idx] = EditOperation.replace(snippetSelection, snippet.toString());\n            edits[idx].identifier = { major: idx, minor: 0 }; // mark the edit so only our undo edits will be used to generate end cursors\n            edits[idx]._isTracked = true;\n            snippets[idx] = new OneSnippet(editor, snippet, snippetLineLeadingWhitespace);\n        }\n        return { edits, snippets };\n    }\n    static createEditsAndSnippetsFromEdits(editor, snippetEdits, enforceFinalTabstop, adjustWhitespace, clipboardText, overtypingCapturer, languageConfigurationService) {\n        if (!editor.hasModel() || snippetEdits.length === 0) {\n            return { edits: [], snippets: [] };\n        }\n        const edits = [];\n        const model = editor.getModel();\n        const parser = new SnippetParser();\n        const snippet = new TextmateSnippet();\n        // snippet variables resolver\n        const resolver = new CompositeSnippetVariableResolver([\n            editor.invokeWithinContext(accessor => new ModelBasedVariableResolver(accessor.get(ILabelService), model)),\n            new ClipboardBasedVariableResolver(() => clipboardText, 0, editor.getSelections().length, editor.getOption(79 /* EditorOption.multiCursorPaste */) === 'spread'),\n            new SelectionBasedVariableResolver(model, editor.getSelection(), 0, overtypingCapturer),\n            new CommentBasedVariableResolver(model, editor.getSelection(), languageConfigurationService),\n            new TimeBasedVariableResolver,\n            new WorkspaceBasedVariableResolver(editor.invokeWithinContext(accessor => accessor.get(IWorkspaceContextService))),\n            new RandomBasedVariableResolver,\n        ]);\n        //\n        snippetEdits = snippetEdits.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));\n        let offset = 0;\n        for (let i = 0; i < snippetEdits.length; i++) {\n            const { range, template } = snippetEdits[i];\n            // gaps between snippet edits are appended as text nodes. this\n            // ensures placeholder-offsets are later correct\n            if (i > 0) {\n                const lastRange = snippetEdits[i - 1].range;\n                const textRange = Range.fromPositions(lastRange.getEndPosition(), range.getStartPosition());\n                const textNode = new Text(model.getValueInRange(textRange));\n                snippet.appendChild(textNode);\n                offset += textNode.value.length;\n            }\n            const newNodes = parser.parseFragment(template, snippet);\n            SnippetSession_1.adjustWhitespace(model, range.getStartPosition(), true, snippet, new Set(newNodes));\n            snippet.resolveVariables(resolver);\n            const snippetText = snippet.toString();\n            const snippetFragmentText = snippetText.slice(offset);\n            offset = snippetText.length;\n            // make edit\n            const edit = EditOperation.replace(range, snippetFragmentText);\n            edit.identifier = { major: i, minor: 0 }; // mark the edit so only our undo edits will be used to generate end cursors\n            edit._isTracked = true;\n            edits.push(edit);\n        }\n        //\n        parser.ensureFinalTabstop(snippet, enforceFinalTabstop, true);\n        return {\n            edits,\n            snippets: [new OneSnippet(editor, snippet, '')]\n        };\n    }\n    constructor(_editor, _template, _options = _defaultOptions, _languageConfigurationService) {\n        this._editor = _editor;\n        this._template = _template;\n        this._options = _options;\n        this._languageConfigurationService = _languageConfigurationService;\n        this._templateMerges = [];\n        this._snippets = [];\n    }\n    dispose() {\n        dispose(this._snippets);\n    }\n    _logInfo() {\n        return `template=\"${this._template}\", merged_templates=\"${this._templateMerges.join(' -> ')}\"`;\n    }\n    insert() {\n        if (!this._editor.hasModel()) {\n            return;\n        }\n        // make insert edit and start with first selections\n        const { edits, snippets } = typeof this._template === 'string'\n            ? SnippetSession_1.createEditsAndSnippetsFromSelections(this._editor, this._template, this._options.overwriteBefore, this._options.overwriteAfter, false, this._options.adjustWhitespace, this._options.clipboardText, this._options.overtypingCapturer, this._languageConfigurationService)\n            : SnippetSession_1.createEditsAndSnippetsFromEdits(this._editor, this._template, false, this._options.adjustWhitespace, this._options.clipboardText, this._options.overtypingCapturer, this._languageConfigurationService);\n        this._snippets = snippets;\n        this._editor.executeEdits('snippet', edits, _undoEdits => {\n            // Sometimes, the text buffer will remove automatic whitespace when doing any edits,\n            // so we need to look only at the undo edits relevant for us.\n            // Our edits have an identifier set so that's how we can distinguish them\n            const undoEdits = _undoEdits.filter(edit => !!edit.identifier);\n            for (let idx = 0; idx < snippets.length; idx++) {\n                snippets[idx].initialize(undoEdits[idx].textChange);\n            }\n            if (this._snippets[0].hasPlaceholder) {\n                return this._move(true);\n            }\n            else {\n                return undoEdits\n                    .map(edit => Selection.fromPositions(edit.range.getEndPosition()));\n            }\n        });\n        this._editor.revealRange(this._editor.getSelections()[0]);\n    }\n    merge(template, options = _defaultOptions) {\n        if (!this._editor.hasModel()) {\n            return;\n        }\n        this._templateMerges.push([this._snippets[0]._nestingLevel, this._snippets[0]._placeholderGroupsIdx, template]);\n        const { edits, snippets } = SnippetSession_1.createEditsAndSnippetsFromSelections(this._editor, template, options.overwriteBefore, options.overwriteAfter, true, options.adjustWhitespace, options.clipboardText, options.overtypingCapturer, this._languageConfigurationService);\n        this._editor.executeEdits('snippet', edits, _undoEdits => {\n            // Sometimes, the text buffer will remove automatic whitespace when doing any edits,\n            // so we need to look only at the undo edits relevant for us.\n            // Our edits have an identifier set so that's how we can distinguish them\n            const undoEdits = _undoEdits.filter(edit => !!edit.identifier);\n            for (let idx = 0; idx < snippets.length; idx++) {\n                snippets[idx].initialize(undoEdits[idx].textChange);\n            }\n            // Trivial snippets have no placeholder or are just the final placeholder. That means they\n            // are just text insertions and we don't need to merge the nested snippet into the existing\n            // snippet\n            const isTrivialSnippet = snippets[0].isTrivialSnippet;\n            if (!isTrivialSnippet) {\n                for (const snippet of this._snippets) {\n                    snippet.merge(snippets);\n                }\n                console.assert(snippets.length === 0);\n            }\n            if (this._snippets[0].hasPlaceholder && !isTrivialSnippet) {\n                return this._move(undefined);\n            }\n            else {\n                return undoEdits.map(edit => Selection.fromPositions(edit.range.getEndPosition()));\n            }\n        });\n    }\n    next() {\n        const newSelections = this._move(true);\n        this._editor.setSelections(newSelections);\n        this._editor.revealPositionInCenterIfOutsideViewport(newSelections[0].getPosition());\n    }\n    prev() {\n        const newSelections = this._move(false);\n        this._editor.setSelections(newSelections);\n        this._editor.revealPositionInCenterIfOutsideViewport(newSelections[0].getPosition());\n    }\n    _move(fwd) {\n        const selections = [];\n        for (const snippet of this._snippets) {\n            const oneSelection = snippet.move(fwd);\n            selections.push(...oneSelection);\n        }\n        return selections;\n    }\n    get isAtFirstPlaceholder() {\n        return this._snippets[0].isAtFirstPlaceholder;\n    }\n    get isAtLastPlaceholder() {\n        return this._snippets[0].isAtLastPlaceholder;\n    }\n    get hasPlaceholder() {\n        return this._snippets[0].hasPlaceholder;\n    }\n    get hasChoice() {\n        return this._snippets[0].hasChoice;\n    }\n    get activeChoice() {\n        return this._snippets[0].activeChoice;\n    }\n    isSelectionWithinPlaceholders() {\n        if (!this.hasPlaceholder) {\n            return false;\n        }\n        const selections = this._editor.getSelections();\n        if (selections.length < this._snippets.length) {\n            // this means we started snippet mode with N\n            // selections and have M (N > M) selections.\n            // So one snippet is without selection -> cancel\n            return false;\n        }\n        const allPossibleSelections = new Map();\n        for (const snippet of this._snippets) {\n            const possibleSelections = snippet.computePossibleSelections();\n            // for the first snippet find the placeholder (and its ranges)\n            // that contain at least one selection. for all remaining snippets\n            // the same placeholder (and their ranges) must be used.\n            if (allPossibleSelections.size === 0) {\n                for (const [index, ranges] of possibleSelections) {\n                    ranges.sort(Range.compareRangesUsingStarts);\n                    for (const selection of selections) {\n                        if (ranges[0].containsRange(selection)) {\n                            allPossibleSelections.set(index, []);\n                            break;\n                        }\n                    }\n                }\n            }\n            if (allPossibleSelections.size === 0) {\n                // return false if we couldn't associate a selection to\n                // this (the first) snippet\n                return false;\n            }\n            // add selections from 'this' snippet so that we know all\n            // selections for this placeholder\n            allPossibleSelections.forEach((array, index) => {\n                array.push(...possibleSelections.get(index));\n            });\n        }\n        // sort selections (and later placeholder-ranges). then walk both\n        // arrays and make sure the placeholder-ranges contain the corresponding\n        // selection\n        selections.sort(Range.compareRangesUsingStarts);\n        for (const [index, ranges] of allPossibleSelections) {\n            if (ranges.length !== selections.length) {\n                allPossibleSelections.delete(index);\n                continue;\n            }\n            ranges.sort(Range.compareRangesUsingStarts);\n            for (let i = 0; i < ranges.length; i++) {\n                if (!ranges[i].containsRange(selections[i])) {\n                    allPossibleSelections.delete(index);\n                    continue;\n                }\n            }\n        }\n        // from all possible selections we have deleted those\n        // that don't match with the current selection. if we don't\n        // have any left, we don't have a selection anymore\n        return allPossibleSelections.size > 0;\n    }\n};\nSnippetSession = SnippetSession_1 = __decorate([\n    __param(3, ILanguageConfigurationService)\n], SnippetSession);\nexport { SnippetSession };\n"],"names":["BracketSelectionRangeProvider","provideSelectionRanges","model","positions","result","position","bucket","push","ranges","Map","Promise","resolve","_bracketsRightYield","_bracketsLeftYield","round","pos","counts","t1","Date","now","_maxRounds","bracket","bracketPairs","findNextBracket","_maxDuration","setTimeout","bracketInfo","isOpeningBracket","key","bracketText","val","has","get","set","getOpeningBrackets","Math","max","list","range","getEndPosition","size","findPrevBracket","closing","shift","delete","innerBracket","getStartPosition","outerBracket","_addBracketLeading","startLineNumber","endLineNumber","startLine","column","getLineFirstNonWhitespaceColumn","startColumn","aboveLine","getLineLastNonWhitespaceColumn","WordSelectionRangeProvider","constructor","selectSubwords","this","_addInWordRanges","_addWordRanges","_addWhitespaceLine","getFullModelRange","obj","getWordAtPosition","word","offset","start","end","lastCh","ch","charCodeAt","length","lineNumber","endColumn","getLineLength","getLineMaxColumn","SmartSelectController_1","__decorate","decorators","target","desc","d","c","arguments","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","__param","paramIndex","decorator","SelectionRanges","index","mov","fwd","res","equalsRange","SmartSelectController","editor","getContribution","ID","_editor","_languageFeaturesService","_ignoreSelection","dispose","_a","_selectionListener","run","forward","hasModel","selections","getSelections","getModel","_state","selectionRangeProvider","map","s","getPosition","getOption","then","arrays","a","b","equalsSelection","filter","containsPosition","unshift","onDidChangeCursorPosition","undefined","state","newSelections","setSelections","AbstractSmartSelect","opts","super","_forward","_accessor","controller","async","registry","options","token","providers","all","concat","work","allRawRanges","provider","allProviderRanges","oneProviderRanges","oneRawRanges","sort","oneRanges","last","selectLeadingAndTrailingWhitespace","oneRangesWithTrivia","prev","cur","rangeNoWhitespace","containsRange","rangeFull","id","label","nls","alias","precondition","kbOpts","kbExpr","primary","mac","secondary","weight","menuOpts","menuId","group","title","comment","order","accessor","args","resource","reference","createModelReference","object","textEditorModel","SnippetController2_1","_defaultOptions","overwriteBefore","overwriteAfter","undoStopBefore","undoStopAfter","adjustWhitespace","clipboardText","overtypingCapturer","SnippetController2","_logService","contextKeyService","_languageConfigurationService","_snippetListener","_modelVersionId","_inSnippet","InSnippetMode","bindTo","_hasNextTabstop","HasNextTabstop","_hasPrevTabstop","HasPrevTabstop","reset","_session","insert","template","_doInsert","e","cancel","error","_logInfo","clear","pushStackElement","merge","getAlternativeVersionId","hasChoice","_debugDisplayName","provideCompletionItems","activeChoice","choice","getValueInRange","isAnyOfOptions","Boolean","find","o","value","suggestions","option","kind","insertText","sortText","repeat","filterText","command","registration","isRegistered","disable","enable","completionProvider","register","language","getLanguageId","pattern","uri","fsPath","scheme","exclusive","add","_choiceCompletions","_updateState","onDidChangeModelContent","isFlush","onDidChangeModel","onDidChangeCursorSelection","hasPlaceholder","isAtLastPlaceholder","isSelectionWithinPlaceholders","isAtFirstPlaceholder","_handleChoice","_currentChoice","queueMicrotask","finish","next","resetSelection","getSelection","isInSnippet","CommandCtor","handler","ctrl","Scanner","isDigitCharacter","isVariableCharacter","text","tokenText","substr","len","type","_table","isNaN","Marker","_children","appendChild","child","Text","parent","replace","others","idx","children","indexOf","newChildren","slice","splice","_fixParent","rightMostDescendant","snippet","candidate","TextmateSnippet","toString","reduce","clone","TransformableMarker","Placeholder","compareByIndex","isFinalTabstop","Choice","ret","transform","marker","forEach","Transform","regexp","RegExp","_this","didMatch","_replace","Array","prototype","call","some","FormatString","elseValue","groups","source","ignoreCase","global","shorthandName","ifValue","toLocaleUpperCase","toLocaleLowerCase","_toPascalCase","_toCamelCase","match","charAt","toUpperCase","join","toLowerCase","Variable","name","resolver","walk","visitor","stack","placeholderInfo","_placeholders","placeholders","found","fullLen","enclosingPlaceholders","placeholder","resolveVariables","SnippetParser","_scanner","_token","escape","guessNeedsClipboard","test","parse","insertFinalTabstop","enforceFinalTabstop","parseFragment","ensureFinalTabstop","_parse","placeholderDefaultValues","incompletePlaceholders","fillInIncompletePlaceholder","defaultValues","newChild","Set","p","_accept","_backTo","_until","nextToken","substring","_parseEscaped","_parseTabstopOrVariableName","_parseComplexPlaceholder","_parseComplexVariable","_parseAnything","Number","_parseTransform","_parseChoiceElement","values","variable","regexValue","regexOptions","escaped","_parseFormatString","complex","shorthand","freeze","CompositeSnippetVariableResolver","_delegates","delegate","SelectionBasedVariableResolver","_model","_selection","_selectionIdx","_overtypingCapturer","isMultiline","info","getLastOvertypedInfo","multiline","line","getLineContent","lineLeadingWhitespace","varLeadingWhitespace","pop","whitespaceCommonLength","m","newline","rest","positionLineNumber","positionColumn","String","ModelBasedVariableResolver","_labelService","path","lastIndexOf","getUriLabel","relative","noPrefix","ClipboardBasedVariableResolver","_readClipboardText","_selectionCount","_spread","lines","split","CommentBasedVariableResolver","langId","getLanguageIdAtPosition","selectionStartLineNumber","selectionStartColumn","config","getLanguageConfiguration","comments","lineCommentToken","blockCommentStartToken","blockCommentEndToken","TimeBasedVariableResolver","_date","getFullYear","getMonth","valueOf","padStart","getDate","getHours","getMinutes","getSeconds","dayNames","getDay","dayNamesShort","monthNames","monthNamesShort","floor","getTime","rawTimeOffset","getTimezoneOffset","sign","hours","trunc","abs","hoursString","minutes","WorkspaceBasedVariableResolver","_workspaceService","workspaceIdentifier","getWorkspace","_resolveWorkspaceName","_resoveWorkspacePath","filename","configPath","endsWith","folderpath","RandomBasedVariableResolver","random","SnippetSession_1","OneSnippet","_snippet","_snippetLineLeadingWhitespace","_offset","_nestingLevel","_placeholderGroups","_placeholderGroupsIdx","initialize","textChange","newPosition","_placeholderDecorations","removeDecorations","_initDecorations","Error","changeDecorations","placeholderOffset","placeholderLen","getPositionAt","_decor","inactiveFinal","inactive","handle","addDecoration","move","operations","getDecorationRange","currentValue","transformedValueLines","normalizeIndentation","getEOL","executeEdits","couldSkipThisPlaceholder","activePlaceholders","_hasPlaceholderBeenCollapsed","changeDecorationOptions","activeFinal","active","enclosingPlaceholder","isEmpty","isTrivialSnippet","computePossibleSelections","placeholdersWithEqualIndex","nested","console","assert","indexLastPlaceholder","nestedPlaceholder","removeDecoration","description","stickiness","className","SnippetSession","adjustIndentation","snippetTextString","prevChar","newValue","adjustSelection","selection","positionColumnBefore","positionColumnAfter","validateRange","getDirection","createEditsAndSnippetsFromSelections","languageConfigurationService","edits","snippets","workspaceService","invokeWithinContext","modelBasedVariableResolver","readClipboardText","firstBeforeText","firstAfterText","firstLineFirstNonWhitespace","indexedSelections","extensionBefore","extensionAfter","snippetSelection","setStartPosition","setEndPosition","snippetLineLeadingWhitespace","identifier","major","minor","_isTracked","createEditsAndSnippetsFromEdits","snippetEdits","parser","lastRange","textRange","textNode","newNodes","snippetText","snippetFragmentText","edit","_template","_options","_templateMerges","_snippets","_undoEdits","undoEdits","_move","revealRange","revealPositionInCenterIfOutsideViewport","oneSelection","allPossibleSelections","possibleSelections","array"],"sourceRoot":""}