{"version":3,"file":"static/js/4553_0d621bf9f7b8beceeaa8.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/folding/browser/hiddenRangeModel.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/folding/browser/folding.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/folding/browser/foldingDecorations.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/folding/browser/foldingModel.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/folding/browser/foldingRanges.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/folding/browser/indentRangeProvider.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/folding/browser/syntaxRangeProvider.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 { findFirstIdxMonotonousOrArrLen } from '../../../../base/common/arraysFind.js';\nimport { Emitter } from '../../../../base/common/event.js';\nimport { Range } from '../../../common/core/range.js';\nimport { countEOL } from '../../../common/core/eolCounter.js';\nexport class HiddenRangeModel {\n    get onDidChange() { return this._updateEventEmitter.event; }\n    get hiddenRanges() { return this._hiddenRanges; }\n    constructor(model) {\n        this._updateEventEmitter = new Emitter();\n        this._hasLineChanges = false;\n        this._foldingModel = model;\n        this._foldingModelListener = model.onDidChange(_ => this.updateHiddenRanges());\n        this._hiddenRanges = [];\n        if (model.regions.length) {\n            this.updateHiddenRanges();\n        }\n    }\n    notifyChangeModelContent(e) {\n        if (this._hiddenRanges.length && !this._hasLineChanges) {\n            this._hasLineChanges = e.changes.some(change => {\n                return change.range.endLineNumber !== change.range.startLineNumber || countEOL(change.text)[0] !== 0;\n            });\n        }\n    }\n    updateHiddenRanges() {\n        let updateHiddenAreas = false;\n        const newHiddenAreas = [];\n        let i = 0; // index into hidden\n        let k = 0;\n        let lastCollapsedStart = Number.MAX_VALUE;\n        let lastCollapsedEnd = -1;\n        const ranges = this._foldingModel.regions;\n        for (; i < ranges.length; i++) {\n            if (!ranges.isCollapsed(i)) {\n                continue;\n            }\n            const startLineNumber = ranges.getStartLineNumber(i) + 1; // the first line is not hidden\n            const endLineNumber = ranges.getEndLineNumber(i);\n            if (lastCollapsedStart <= startLineNumber && endLineNumber <= lastCollapsedEnd) {\n                // ignore ranges contained in collapsed regions\n                continue;\n            }\n            if (!updateHiddenAreas && k < this._hiddenRanges.length && this._hiddenRanges[k].startLineNumber === startLineNumber && this._hiddenRanges[k].endLineNumber === endLineNumber) {\n                // reuse the old ranges\n                newHiddenAreas.push(this._hiddenRanges[k]);\n                k++;\n            }\n            else {\n                updateHiddenAreas = true;\n                newHiddenAreas.push(new Range(startLineNumber, 1, endLineNumber, 1));\n            }\n            lastCollapsedStart = startLineNumber;\n            lastCollapsedEnd = endLineNumber;\n        }\n        if (this._hasLineChanges || updateHiddenAreas || k < this._hiddenRanges.length) {\n            this.applyHiddenRanges(newHiddenAreas);\n        }\n    }\n    applyHiddenRanges(newHiddenAreas) {\n        this._hiddenRanges = newHiddenAreas;\n        this._hasLineChanges = false;\n        this._updateEventEmitter.fire(newHiddenAreas);\n    }\n    hasRanges() {\n        return this._hiddenRanges.length > 0;\n    }\n    isHidden(line) {\n        return findRange(this._hiddenRanges, line) !== null;\n    }\n    adjustSelections(selections) {\n        let hasChanges = false;\n        const editorModel = this._foldingModel.textModel;\n        let lastRange = null;\n        const adjustLine = (line) => {\n            if (!lastRange || !isInside(line, lastRange)) {\n                lastRange = findRange(this._hiddenRanges, line);\n            }\n            if (lastRange) {\n                return lastRange.startLineNumber - 1;\n            }\n            return null;\n        };\n        for (let i = 0, len = selections.length; i < len; i++) {\n            let selection = selections[i];\n            const adjustedStartLine = adjustLine(selection.startLineNumber);\n            if (adjustedStartLine) {\n                selection = selection.setStartPosition(adjustedStartLine, editorModel.getLineMaxColumn(adjustedStartLine));\n                hasChanges = true;\n            }\n            const adjustedEndLine = adjustLine(selection.endLineNumber);\n            if (adjustedEndLine) {\n                selection = selection.setEndPosition(adjustedEndLine, editorModel.getLineMaxColumn(adjustedEndLine));\n                hasChanges = true;\n            }\n            selections[i] = selection;\n        }\n        return hasChanges;\n    }\n    dispose() {\n        if (this.hiddenRanges.length > 0) {\n            this._hiddenRanges = [];\n            this._updateEventEmitter.fire(this._hiddenRanges);\n        }\n        if (this._foldingModelListener) {\n            this._foldingModelListener.dispose();\n            this._foldingModelListener = null;\n        }\n    }\n}\nfunction isInside(line, range) {\n    return line >= range.startLineNumber && line <= range.endLineNumber;\n}\nfunction findRange(ranges, line) {\n    const i = findFirstIdxMonotonousOrArrLen(ranges, r => line < r.startLineNumber) - 1;\n    if (i >= 0 && ranges[i].endLineNumber >= line) {\n        return ranges[i];\n    }\n    return null;\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 FoldingController_1;\nimport { createCancelablePromise, Delayer, RunOnceScheduler } from '../../../../base/common/async.js';\nimport { CancellationToken } from '../../../../base/common/cancellation.js';\nimport { illegalArgument, onUnexpectedError } from '../../../../base/common/errors.js';\nimport { KeyChord } from '../../../../base/common/keyCodes.js';\nimport { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';\nimport { escapeRegExpCharacters } from '../../../../base/common/strings.js';\nimport * as types from '../../../../base/common/types.js';\nimport './folding.css';\nimport { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';\nimport { EditorAction, registerEditorAction, registerEditorContribution, registerInstantiatedEditorAction } from '../../../browser/editorExtensions.js';\nimport { EditorContextKeys } from '../../../common/editorContextKeys.js';\nimport { FoldingRangeKind } from '../../../common/languages.js';\nimport { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';\nimport { FoldingModel, getNextFoldLine, getParentFoldLine as getParentFoldLine, getPreviousFoldLine, setCollapseStateAtLevel, setCollapseStateForMatchingLines, setCollapseStateForRest, setCollapseStateForType, setCollapseStateLevelsDown, setCollapseStateLevelsUp, setCollapseStateUp, toggleCollapseState } from './foldingModel.js';\nimport { HiddenRangeModel } from './hiddenRangeModel.js';\nimport { IndentRangeProvider } from './indentRangeProvider.js';\nimport * as nls from '../../../../nls.js';\nimport { IContextKeyService, RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';\nimport { FoldingDecorationProvider } from './foldingDecorations.js';\nimport { FoldingRegions } from './foldingRanges.js';\nimport { SyntaxRangeProvider } from './syntaxRangeProvider.js';\nimport { INotificationService } from '../../../../platform/notification/common/notification.js';\nimport { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';\nimport { StopWatch } from '../../../../base/common/stopwatch.js';\nimport { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';\nimport { Emitter } from '../../../../base/common/event.js';\nimport { CommandsRegistry } from '../../../../platform/commands/common/commands.js';\nimport { URI } from '../../../../base/common/uri.js';\nimport { IModelService } from '../../../common/services/model.js';\nimport { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';\nconst CONTEXT_FOLDING_ENABLED = new RawContextKey('foldingEnabled', false);\nlet FoldingController = FoldingController_1 = class FoldingController extends Disposable {\n    static get(editor) {\n        return editor.getContribution(FoldingController_1.ID);\n    }\n    static getFoldingRangeProviders(languageFeaturesService, model) {\n        var _a, _b;\n        const foldingRangeProviders = languageFeaturesService.foldingRangeProvider.ordered(model);\n        return (_b = ((_a = FoldingController_1._foldingRangeSelector) === null || _a === void 0 ? void 0 : _a.call(FoldingController_1, foldingRangeProviders, model))) !== null && _b !== void 0 ? _b : foldingRangeProviders;\n    }\n    constructor(editor, contextKeyService, languageConfigurationService, notificationService, languageFeatureDebounceService, languageFeaturesService) {\n        super();\n        this.contextKeyService = contextKeyService;\n        this.languageConfigurationService = languageConfigurationService;\n        this.languageFeaturesService = languageFeaturesService;\n        this.localToDispose = this._register(new DisposableStore());\n        this.editor = editor;\n        this._foldingLimitReporter = new RangesLimitReporter(editor);\n        const options = this.editor.getOptions();\n        this._isEnabled = options.get(43 /* EditorOption.folding */);\n        this._useFoldingProviders = options.get(44 /* EditorOption.foldingStrategy */) !== 'indentation';\n        this._unfoldOnClickAfterEndOfLine = options.get(48 /* EditorOption.unfoldOnClickAfterEndOfLine */);\n        this._restoringViewState = false;\n        this._currentModelHasFoldedImports = false;\n        this._foldingImportsByDefault = options.get(46 /* EditorOption.foldingImportsByDefault */);\n        this.updateDebounceInfo = languageFeatureDebounceService.for(languageFeaturesService.foldingRangeProvider, 'Folding', { min: 200 });\n        this.foldingModel = null;\n        this.hiddenRangeModel = null;\n        this.rangeProvider = null;\n        this.foldingRegionPromise = null;\n        this.foldingModelPromise = null;\n        this.updateScheduler = null;\n        this.cursorChangedScheduler = null;\n        this.mouseDownInfo = null;\n        this.foldingDecorationProvider = new FoldingDecorationProvider(editor);\n        this.foldingDecorationProvider.showFoldingControls = options.get(110 /* EditorOption.showFoldingControls */);\n        this.foldingDecorationProvider.showFoldingHighlights = options.get(45 /* EditorOption.foldingHighlight */);\n        this.foldingEnabled = CONTEXT_FOLDING_ENABLED.bindTo(this.contextKeyService);\n        this.foldingEnabled.set(this._isEnabled);\n        this._register(this.editor.onDidChangeModel(() => this.onModelChanged()));\n        this._register(this.editor.onDidChangeConfiguration((e) => {\n            if (e.hasChanged(43 /* EditorOption.folding */)) {\n                this._isEnabled = this.editor.getOptions().get(43 /* EditorOption.folding */);\n                this.foldingEnabled.set(this._isEnabled);\n                this.onModelChanged();\n            }\n            if (e.hasChanged(47 /* EditorOption.foldingMaximumRegions */)) {\n                this.onModelChanged();\n            }\n            if (e.hasChanged(110 /* EditorOption.showFoldingControls */) || e.hasChanged(45 /* EditorOption.foldingHighlight */)) {\n                const options = this.editor.getOptions();\n                this.foldingDecorationProvider.showFoldingControls = options.get(110 /* EditorOption.showFoldingControls */);\n                this.foldingDecorationProvider.showFoldingHighlights = options.get(45 /* EditorOption.foldingHighlight */);\n                this.triggerFoldingModelChanged();\n            }\n            if (e.hasChanged(44 /* EditorOption.foldingStrategy */)) {\n                this._useFoldingProviders = this.editor.getOptions().get(44 /* EditorOption.foldingStrategy */) !== 'indentation';\n                this.onFoldingStrategyChanged();\n            }\n            if (e.hasChanged(48 /* EditorOption.unfoldOnClickAfterEndOfLine */)) {\n                this._unfoldOnClickAfterEndOfLine = this.editor.getOptions().get(48 /* EditorOption.unfoldOnClickAfterEndOfLine */);\n            }\n            if (e.hasChanged(46 /* EditorOption.foldingImportsByDefault */)) {\n                this._foldingImportsByDefault = this.editor.getOptions().get(46 /* EditorOption.foldingImportsByDefault */);\n            }\n        }));\n        this.onModelChanged();\n    }\n    /**\n     * Store view state.\n     */\n    saveViewState() {\n        const model = this.editor.getModel();\n        if (!model || !this._isEnabled || model.isTooLargeForTokenization()) {\n            return {};\n        }\n        if (this.foldingModel) { // disposed ?\n            const collapsedRegions = this.foldingModel.getMemento();\n            const provider = this.rangeProvider ? this.rangeProvider.id : undefined;\n            return { collapsedRegions, lineCount: model.getLineCount(), provider, foldedImports: this._currentModelHasFoldedImports };\n        }\n        return undefined;\n    }\n    /**\n     * Restore view state.\n     */\n    restoreViewState(state) {\n        const model = this.editor.getModel();\n        if (!model || !this._isEnabled || model.isTooLargeForTokenization() || !this.hiddenRangeModel) {\n            return;\n        }\n        if (!state) {\n            return;\n        }\n        this._currentModelHasFoldedImports = !!state.foldedImports;\n        if (state.collapsedRegions && state.collapsedRegions.length > 0 && this.foldingModel) {\n            this._restoringViewState = true;\n            try {\n                this.foldingModel.applyMemento(state.collapsedRegions);\n            }\n            finally {\n                this._restoringViewState = false;\n            }\n        }\n    }\n    onModelChanged() {\n        this.localToDispose.clear();\n        const model = this.editor.getModel();\n        if (!this._isEnabled || !model || model.isTooLargeForTokenization()) {\n            // huge files get no view model, so they cannot support hidden areas\n            return;\n        }\n        this._currentModelHasFoldedImports = false;\n        this.foldingModel = new FoldingModel(model, this.foldingDecorationProvider);\n        this.localToDispose.add(this.foldingModel);\n        this.hiddenRangeModel = new HiddenRangeModel(this.foldingModel);\n        this.localToDispose.add(this.hiddenRangeModel);\n        this.localToDispose.add(this.hiddenRangeModel.onDidChange(hr => this.onHiddenRangesChanges(hr)));\n        this.updateScheduler = new Delayer(this.updateDebounceInfo.get(model));\n        this.cursorChangedScheduler = new RunOnceScheduler(() => this.revealCursor(), 200);\n        this.localToDispose.add(this.cursorChangedScheduler);\n        this.localToDispose.add(this.languageFeaturesService.foldingRangeProvider.onDidChange(() => this.onFoldingStrategyChanged()));\n        this.localToDispose.add(this.editor.onDidChangeModelLanguageConfiguration(() => this.onFoldingStrategyChanged())); // covers model language changes as well\n        this.localToDispose.add(this.editor.onDidChangeModelContent(e => this.onDidChangeModelContent(e)));\n        this.localToDispose.add(this.editor.onDidChangeCursorPosition(() => this.onCursorPositionChanged()));\n        this.localToDispose.add(this.editor.onMouseDown(e => this.onEditorMouseDown(e)));\n        this.localToDispose.add(this.editor.onMouseUp(e => this.onEditorMouseUp(e)));\n        this.localToDispose.add({\n            dispose: () => {\n                var _a, _b;\n                if (this.foldingRegionPromise) {\n                    this.foldingRegionPromise.cancel();\n                    this.foldingRegionPromise = null;\n                }\n                (_a = this.updateScheduler) === null || _a === void 0 ? void 0 : _a.cancel();\n                this.updateScheduler = null;\n                this.foldingModel = null;\n                this.foldingModelPromise = null;\n                this.hiddenRangeModel = null;\n                this.cursorChangedScheduler = null;\n                (_b = this.rangeProvider) === null || _b === void 0 ? void 0 : _b.dispose();\n                this.rangeProvider = null;\n            }\n        });\n        this.triggerFoldingModelChanged();\n    }\n    onFoldingStrategyChanged() {\n        var _a;\n        (_a = this.rangeProvider) === null || _a === void 0 ? void 0 : _a.dispose();\n        this.rangeProvider = null;\n        this.triggerFoldingModelChanged();\n    }\n    getRangeProvider(editorModel) {\n        if (this.rangeProvider) {\n            return this.rangeProvider;\n        }\n        const indentRangeProvider = new IndentRangeProvider(editorModel, this.languageConfigurationService, this._foldingLimitReporter);\n        this.rangeProvider = indentRangeProvider; // fallback\n        if (this._useFoldingProviders && this.foldingModel) {\n            const selectedProviders = FoldingController_1.getFoldingRangeProviders(this.languageFeaturesService, editorModel);\n            if (selectedProviders.length > 0) {\n                this.rangeProvider = new SyntaxRangeProvider(editorModel, selectedProviders, () => this.triggerFoldingModelChanged(), this._foldingLimitReporter, indentRangeProvider);\n            }\n        }\n        return this.rangeProvider;\n    }\n    getFoldingModel() {\n        return this.foldingModelPromise;\n    }\n    onDidChangeModelContent(e) {\n        var _a;\n        (_a = this.hiddenRangeModel) === null || _a === void 0 ? void 0 : _a.notifyChangeModelContent(e);\n        this.triggerFoldingModelChanged();\n    }\n    triggerFoldingModelChanged() {\n        if (this.updateScheduler) {\n            if (this.foldingRegionPromise) {\n                this.foldingRegionPromise.cancel();\n                this.foldingRegionPromise = null;\n            }\n            this.foldingModelPromise = this.updateScheduler.trigger(() => {\n                const foldingModel = this.foldingModel;\n                if (!foldingModel) { // null if editor has been disposed, or folding turned off\n                    return null;\n                }\n                const sw = new StopWatch();\n                const provider = this.getRangeProvider(foldingModel.textModel);\n                const foldingRegionPromise = this.foldingRegionPromise = createCancelablePromise(token => provider.compute(token));\n                return foldingRegionPromise.then(foldingRanges => {\n                    if (foldingRanges && foldingRegionPromise === this.foldingRegionPromise) { // new request or cancelled in the meantime?\n                        let scrollState;\n                        if (this._foldingImportsByDefault && !this._currentModelHasFoldedImports) {\n                            const hasChanges = foldingRanges.setCollapsedAllOfType(FoldingRangeKind.Imports.value, true);\n                            if (hasChanges) {\n                                scrollState = StableEditorScrollState.capture(this.editor);\n                                this._currentModelHasFoldedImports = hasChanges;\n                            }\n                        }\n                        // some cursors might have moved into hidden regions, make sure they are in expanded regions\n                        const selections = this.editor.getSelections();\n                        const selectionLineNumbers = selections ? selections.map(s => s.startLineNumber) : [];\n                        foldingModel.update(foldingRanges, selectionLineNumbers);\n                        scrollState === null || scrollState === void 0 ? void 0 : scrollState.restore(this.editor);\n                        // update debounce info\n                        const newValue = this.updateDebounceInfo.update(foldingModel.textModel, sw.elapsed());\n                        if (this.updateScheduler) {\n                            this.updateScheduler.defaultDelay = newValue;\n                        }\n                    }\n                    return foldingModel;\n                });\n            }).then(undefined, (err) => {\n                onUnexpectedError(err);\n                return null;\n            });\n        }\n    }\n    onHiddenRangesChanges(hiddenRanges) {\n        if (this.hiddenRangeModel && hiddenRanges.length && !this._restoringViewState) {\n            const selections = this.editor.getSelections();\n            if (selections) {\n                if (this.hiddenRangeModel.adjustSelections(selections)) {\n                    this.editor.setSelections(selections);\n                }\n            }\n        }\n        this.editor.setHiddenAreas(hiddenRanges, this);\n    }\n    onCursorPositionChanged() {\n        if (this.hiddenRangeModel && this.hiddenRangeModel.hasRanges()) {\n            this.cursorChangedScheduler.schedule();\n        }\n    }\n    revealCursor() {\n        const foldingModel = this.getFoldingModel();\n        if (!foldingModel) {\n            return;\n        }\n        foldingModel.then(foldingModel => {\n            if (foldingModel) {\n                const selections = this.editor.getSelections();\n                if (selections && selections.length > 0) {\n                    const toToggle = [];\n                    for (const selection of selections) {\n                        const lineNumber = selection.selectionStartLineNumber;\n                        if (this.hiddenRangeModel && this.hiddenRangeModel.isHidden(lineNumber)) {\n                            toToggle.push(...foldingModel.getAllRegionsAtLine(lineNumber, r => r.isCollapsed && lineNumber > r.startLineNumber));\n                        }\n                    }\n                    if (toToggle.length) {\n                        foldingModel.toggleCollapseState(toToggle);\n                        this.reveal(selections[0].getPosition());\n                    }\n                }\n            }\n        }).then(undefined, onUnexpectedError);\n    }\n    onEditorMouseDown(e) {\n        this.mouseDownInfo = null;\n        if (!this.hiddenRangeModel || !e.target || !e.target.range) {\n            return;\n        }\n        if (!e.event.leftButton && !e.event.middleButton) {\n            return;\n        }\n        const range = e.target.range;\n        let iconClicked = false;\n        switch (e.target.type) {\n            case 4 /* MouseTargetType.GUTTER_LINE_DECORATIONS */: {\n                const data = e.target.detail;\n                const offsetLeftInGutter = e.target.element.offsetLeft;\n                const gutterOffsetX = data.offsetX - offsetLeftInGutter;\n                // const gutterOffsetX = data.offsetX - data.glyphMarginWidth - data.lineNumbersWidth - data.glyphMarginLeft;\n                // TODO@joao TODO@alex TODO@martin this is such that we don't collide with dirty diff\n                if (gutterOffsetX < 4) { // the whitespace between the border and the real folding icon border is 4px\n                    return;\n                }\n                iconClicked = true;\n                break;\n            }\n            case 7 /* MouseTargetType.CONTENT_EMPTY */: {\n                if (this._unfoldOnClickAfterEndOfLine && this.hiddenRangeModel.hasRanges()) {\n                    const data = e.target.detail;\n                    if (!data.isAfterLines) {\n                        break;\n                    }\n                }\n                return;\n            }\n            case 6 /* MouseTargetType.CONTENT_TEXT */: {\n                if (this.hiddenRangeModel.hasRanges()) {\n                    const model = this.editor.getModel();\n                    if (model && range.startColumn === model.getLineMaxColumn(range.startLineNumber)) {\n                        break;\n                    }\n                }\n                return;\n            }\n            default:\n                return;\n        }\n        this.mouseDownInfo = { lineNumber: range.startLineNumber, iconClicked };\n    }\n    onEditorMouseUp(e) {\n        const foldingModel = this.foldingModel;\n        if (!foldingModel || !this.mouseDownInfo || !e.target) {\n            return;\n        }\n        const lineNumber = this.mouseDownInfo.lineNumber;\n        const iconClicked = this.mouseDownInfo.iconClicked;\n        const range = e.target.range;\n        if (!range || range.startLineNumber !== lineNumber) {\n            return;\n        }\n        if (iconClicked) {\n            if (e.target.type !== 4 /* MouseTargetType.GUTTER_LINE_DECORATIONS */) {\n                return;\n            }\n        }\n        else {\n            const model = this.editor.getModel();\n            if (!model || range.startColumn !== model.getLineMaxColumn(lineNumber)) {\n                return;\n            }\n        }\n        const region = foldingModel.getRegionAtLine(lineNumber);\n        if (region && region.startLineNumber === lineNumber) {\n            const isCollapsed = region.isCollapsed;\n            if (iconClicked || isCollapsed) {\n                const surrounding = e.event.altKey;\n                let toToggle = [];\n                if (surrounding) {\n                    const filter = (otherRegion) => !otherRegion.containedBy(region) && !region.containedBy(otherRegion);\n                    const toMaybeToggle = foldingModel.getRegionsInside(null, filter);\n                    for (const r of toMaybeToggle) {\n                        if (r.isCollapsed) {\n                            toToggle.push(r);\n                        }\n                    }\n                    // if any surrounding regions are folded, unfold those. Otherwise, fold all surrounding\n                    if (toToggle.length === 0) {\n                        toToggle = toMaybeToggle;\n                    }\n                }\n                else {\n                    const recursive = e.event.middleButton || e.event.shiftKey;\n                    if (recursive) {\n                        for (const r of foldingModel.getRegionsInside(region)) {\n                            if (r.isCollapsed === isCollapsed) {\n                                toToggle.push(r);\n                            }\n                        }\n                    }\n                    // when recursive, first only collapse all children. If all are already folded or there are no children, also fold parent.\n                    if (isCollapsed || !recursive || toToggle.length === 0) {\n                        toToggle.push(region);\n                    }\n                }\n                foldingModel.toggleCollapseState(toToggle);\n                this.reveal({ lineNumber, column: 1 });\n            }\n        }\n    }\n    reveal(position) {\n        this.editor.revealPositionInCenterIfOutsideViewport(position, 0 /* ScrollType.Smooth */);\n    }\n};\nFoldingController.ID = 'editor.contrib.folding';\nFoldingController = FoldingController_1 = __decorate([\n    __param(1, IContextKeyService),\n    __param(2, ILanguageConfigurationService),\n    __param(3, INotificationService),\n    __param(4, ILanguageFeatureDebounceService),\n    __param(5, ILanguageFeaturesService)\n], FoldingController);\nexport { FoldingController };\nexport class RangesLimitReporter {\n    constructor(editor) {\n        this.editor = editor;\n        this._onDidChange = new Emitter();\n        this._computed = 0;\n        this._limited = false;\n    }\n    get limit() {\n        return this.editor.getOptions().get(47 /* EditorOption.foldingMaximumRegions */);\n    }\n    update(computed, limited) {\n        if (computed !== this._computed || limited !== this._limited) {\n            this._computed = computed;\n            this._limited = limited;\n            this._onDidChange.fire();\n        }\n    }\n}\nclass FoldingAction extends EditorAction {\n    runEditorCommand(accessor, editor, args) {\n        const languageConfigurationService = accessor.get(ILanguageConfigurationService);\n        const foldingController = FoldingController.get(editor);\n        if (!foldingController) {\n            return;\n        }\n        const foldingModelPromise = foldingController.getFoldingModel();\n        if (foldingModelPromise) {\n            this.reportTelemetry(accessor, editor);\n            return foldingModelPromise.then(foldingModel => {\n                if (foldingModel) {\n                    this.invoke(foldingController, foldingModel, editor, args, languageConfigurationService);\n                    const selection = editor.getSelection();\n                    if (selection) {\n                        foldingController.reveal(selection.getStartPosition());\n                    }\n                }\n            });\n        }\n    }\n    getSelectedLines(editor) {\n        const selections = editor.getSelections();\n        return selections ? selections.map(s => s.startLineNumber) : [];\n    }\n    getLineNumbers(args, editor) {\n        if (args && args.selectionLines) {\n            return args.selectionLines.map(l => l + 1); // to 0-bases line numbers\n        }\n        return this.getSelectedLines(editor);\n    }\n    run(_accessor, _editor) {\n    }\n}\nfunction foldingArgumentsConstraint(args) {\n    if (!types.isUndefined(args)) {\n        if (!types.isObject(args)) {\n            return false;\n        }\n        const foldingArgs = args;\n        if (!types.isUndefined(foldingArgs.levels) && !types.isNumber(foldingArgs.levels)) {\n            return false;\n        }\n        if (!types.isUndefined(foldingArgs.direction) && !types.isString(foldingArgs.direction)) {\n            return false;\n        }\n        if (!types.isUndefined(foldingArgs.selectionLines) && (!Array.isArray(foldingArgs.selectionLines) || !foldingArgs.selectionLines.every(types.isNumber))) {\n            return false;\n        }\n    }\n    return true;\n}\nclass UnfoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.unfold',\n            label: nls.localize('unfoldAction.label', \"Unfold\"),\n            alias: 'Unfold',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 94 /* KeyCode.BracketRight */,\n                mac: {\n                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 94 /* KeyCode.BracketRight */\n                },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            metadata: {\n                description: 'Unfold the content in the editor',\n                args: [\n                    {\n                        name: 'Unfold editor argument',\n                        description: `Property-value pairs that can be passed through this argument:\n\t\t\t\t\t\t* 'levels': Number of levels to unfold. If not set, defaults to 1.\n\t\t\t\t\t\t* 'direction': If 'up', unfold given number of levels up otherwise unfolds down.\n\t\t\t\t\t\t* 'selectionLines': Array of the start lines (0-based) of the editor selections to apply the unfold action to. If not set, the active selection(s) will be used.\n\t\t\t\t\t\t`,\n                        constraint: foldingArgumentsConstraint,\n                        schema: {\n                            'type': 'object',\n                            'properties': {\n                                'levels': {\n                                    'type': 'number',\n                                    'default': 1\n                                },\n                                'direction': {\n                                    'type': 'string',\n                                    'enum': ['up', 'down'],\n                                    'default': 'down'\n                                },\n                                'selectionLines': {\n                                    'type': 'array',\n                                    'items': {\n                                        'type': 'number'\n                                    }\n                                }\n                            }\n                        }\n                    }\n                ]\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, args) {\n        const levels = args && args.levels || 1;\n        const lineNumbers = this.getLineNumbers(args, editor);\n        if (args && args.direction === 'up') {\n            setCollapseStateLevelsUp(foldingModel, false, levels, lineNumbers);\n        }\n        else {\n            setCollapseStateLevelsDown(foldingModel, false, levels, lineNumbers);\n        }\n    }\n}\nclass UnFoldRecursivelyAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.unfoldRecursively',\n            label: nls.localize('unFoldRecursivelyAction.label', \"Unfold Recursively\"),\n            alias: 'Unfold Recursively',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 94 /* KeyCode.BracketRight */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, _args) {\n        setCollapseStateLevelsDown(foldingModel, false, Number.MAX_VALUE, this.getSelectedLines(editor));\n    }\n}\nclass FoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.fold',\n            label: nls.localize('foldAction.label', \"Fold\"),\n            alias: 'Fold',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 92 /* KeyCode.BracketLeft */,\n                mac: {\n                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 92 /* KeyCode.BracketLeft */\n                },\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            },\n            metadata: {\n                description: 'Fold the content in the editor',\n                args: [\n                    {\n                        name: 'Fold editor argument',\n                        description: `Property-value pairs that can be passed through this argument:\n\t\t\t\t\t\t\t* 'levels': Number of levels to fold.\n\t\t\t\t\t\t\t* 'direction': If 'up', folds given number of levels up otherwise folds down.\n\t\t\t\t\t\t\t* 'selectionLines': Array of the start lines (0-based) of the editor selections to apply the fold action to. If not set, the active selection(s) will be used.\n\t\t\t\t\t\t\tIf no levels or direction is set, folds the region at the locations or if already collapsed, the first uncollapsed parent instead.\n\t\t\t\t\t\t`,\n                        constraint: foldingArgumentsConstraint,\n                        schema: {\n                            'type': 'object',\n                            'properties': {\n                                'levels': {\n                                    'type': 'number',\n                                },\n                                'direction': {\n                                    'type': 'string',\n                                    'enum': ['up', 'down'],\n                                },\n                                'selectionLines': {\n                                    'type': 'array',\n                                    'items': {\n                                        'type': 'number'\n                                    }\n                                }\n                            }\n                        }\n                    }\n                ]\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, args) {\n        const lineNumbers = this.getLineNumbers(args, editor);\n        const levels = args && args.levels;\n        const direction = args && args.direction;\n        if (typeof levels !== 'number' && typeof direction !== 'string') {\n            // fold the region at the location or if already collapsed, the first uncollapsed parent instead.\n            setCollapseStateUp(foldingModel, true, lineNumbers);\n        }\n        else {\n            if (direction === 'up') {\n                setCollapseStateLevelsUp(foldingModel, true, levels || 1, lineNumbers);\n            }\n            else {\n                setCollapseStateLevelsDown(foldingModel, true, levels || 1, lineNumbers);\n            }\n        }\n    }\n}\nclass ToggleFoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.toggleFold',\n            label: nls.localize('toggleFoldAction.label', \"Toggle Fold\"),\n            alias: 'Toggle Fold',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 42 /* KeyCode.KeyL */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        toggleCollapseState(foldingModel, 1, selectedLines);\n    }\n}\nclass FoldRecursivelyAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.foldRecursively',\n            label: nls.localize('foldRecursivelyAction.label', \"Fold Recursively\"),\n            alias: 'Fold Recursively',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 92 /* KeyCode.BracketLeft */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        setCollapseStateLevelsDown(foldingModel, true, Number.MAX_VALUE, selectedLines);\n    }\n}\nclass FoldAllBlockCommentsAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.foldAllBlockComments',\n            label: nls.localize('foldAllBlockComments.label', \"Fold All Block Comments\"),\n            alias: 'Fold All Block Comments',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 90 /* KeyCode.Slash */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {\n        if (foldingModel.regions.hasTypes()) {\n            setCollapseStateForType(foldingModel, FoldingRangeKind.Comment.value, true);\n        }\n        else {\n            const editorModel = editor.getModel();\n            if (!editorModel) {\n                return;\n            }\n            const comments = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).comments;\n            if (comments && comments.blockCommentStartToken) {\n                const regExp = new RegExp('^\\\\s*' + escapeRegExpCharacters(comments.blockCommentStartToken));\n                setCollapseStateForMatchingLines(foldingModel, regExp, true);\n            }\n        }\n    }\n}\nclass FoldAllRegionsAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.foldAllMarkerRegions',\n            label: nls.localize('foldAllMarkerRegions.label', \"Fold All Regions\"),\n            alias: 'Fold All Regions',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 29 /* KeyCode.Digit8 */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {\n        if (foldingModel.regions.hasTypes()) {\n            setCollapseStateForType(foldingModel, FoldingRangeKind.Region.value, true);\n        }\n        else {\n            const editorModel = editor.getModel();\n            if (!editorModel) {\n                return;\n            }\n            const foldingRules = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).foldingRules;\n            if (foldingRules && foldingRules.markers && foldingRules.markers.start) {\n                const regExp = new RegExp(foldingRules.markers.start);\n                setCollapseStateForMatchingLines(foldingModel, regExp, true);\n            }\n        }\n    }\n}\nclass UnfoldAllRegionsAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.unfoldAllMarkerRegions',\n            label: nls.localize('unfoldAllMarkerRegions.label', \"Unfold All Regions\"),\n            alias: 'Unfold All Regions',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 30 /* KeyCode.Digit9 */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {\n        if (foldingModel.regions.hasTypes()) {\n            setCollapseStateForType(foldingModel, FoldingRangeKind.Region.value, false);\n        }\n        else {\n            const editorModel = editor.getModel();\n            if (!editorModel) {\n                return;\n            }\n            const foldingRules = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).foldingRules;\n            if (foldingRules && foldingRules.markers && foldingRules.markers.start) {\n                const regExp = new RegExp(foldingRules.markers.start);\n                setCollapseStateForMatchingLines(foldingModel, regExp, false);\n            }\n        }\n    }\n}\nclass FoldAllExceptAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.foldAllExcept',\n            label: nls.localize('foldAllExcept.label', \"Fold All Except Selected\"),\n            alias: 'Fold All Except Selected',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 88 /* KeyCode.Minus */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        setCollapseStateForRest(foldingModel, true, selectedLines);\n    }\n}\nclass UnfoldAllExceptAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.unfoldAllExcept',\n            label: nls.localize('unfoldAllExcept.label', \"Unfold All Except Selected\"),\n            alias: 'Unfold All Except Selected',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 86 /* KeyCode.Equal */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        setCollapseStateForRest(foldingModel, false, selectedLines);\n    }\n}\nclass FoldAllAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.foldAll',\n            label: nls.localize('foldAllAction.label', \"Fold All\"),\n            alias: 'Fold All',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 21 /* KeyCode.Digit0 */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, _editor) {\n        setCollapseStateLevelsDown(foldingModel, true);\n    }\n}\nclass UnfoldAllAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.unfoldAll',\n            label: nls.localize('unfoldAllAction.label', \"Unfold All\"),\n            alias: 'Unfold All',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 40 /* KeyCode.KeyJ */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, _editor) {\n        setCollapseStateLevelsDown(foldingModel, false);\n    }\n}\nclass FoldLevelAction extends FoldingAction {\n    getFoldingLevel() {\n        return parseInt(this.id.substr(FoldLevelAction.ID_PREFIX.length));\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        setCollapseStateAtLevel(foldingModel, this.getFoldingLevel(), true, this.getSelectedLines(editor));\n    }\n}\nFoldLevelAction.ID_PREFIX = 'editor.foldLevel';\nFoldLevelAction.ID = (level) => FoldLevelAction.ID_PREFIX + level;\n/** Action to go to the parent fold of current line */\nclass GotoParentFoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.gotoParentFold',\n            label: nls.localize('gotoParentFold.label', \"Go to Parent Fold\"),\n            alias: 'Go to Parent Fold',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        if (selectedLines.length > 0) {\n            const startLineNumber = getParentFoldLine(selectedLines[0], foldingModel);\n            if (startLineNumber !== null) {\n                editor.setSelection({\n                    startLineNumber: startLineNumber,\n                    startColumn: 1,\n                    endLineNumber: startLineNumber,\n                    endColumn: 1\n                });\n            }\n        }\n    }\n}\n/** Action to go to the previous fold of current line */\nclass GotoPreviousFoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.gotoPreviousFold',\n            label: nls.localize('gotoPreviousFold.label', \"Go to Previous Folding Range\"),\n            alias: 'Go to Previous Folding Range',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        if (selectedLines.length > 0) {\n            const startLineNumber = getPreviousFoldLine(selectedLines[0], foldingModel);\n            if (startLineNumber !== null) {\n                editor.setSelection({\n                    startLineNumber: startLineNumber,\n                    startColumn: 1,\n                    endLineNumber: startLineNumber,\n                    endColumn: 1\n                });\n            }\n        }\n    }\n}\n/** Action to go to the next fold of current line */\nclass GotoNextFoldAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.gotoNextFold',\n            label: nls.localize('gotoNextFold.label', \"Go to Next Folding Range\"),\n            alias: 'Go to Next Folding Range',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        const selectedLines = this.getSelectedLines(editor);\n        if (selectedLines.length > 0) {\n            const startLineNumber = getNextFoldLine(selectedLines[0], foldingModel);\n            if (startLineNumber !== null) {\n                editor.setSelection({\n                    startLineNumber: startLineNumber,\n                    startColumn: 1,\n                    endLineNumber: startLineNumber,\n                    endColumn: 1\n                });\n            }\n        }\n    }\n}\nclass FoldRangeFromSelectionAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.createFoldingRangeFromSelection',\n            label: nls.localize('createManualFoldRange.label', \"Create Folding Range from Selection\"),\n            alias: 'Create Folding Range from Selection',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 87 /* KeyCode.Comma */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(_foldingController, foldingModel, editor) {\n        var _a;\n        const collapseRanges = [];\n        const selections = editor.getSelections();\n        if (selections) {\n            for (const selection of selections) {\n                let endLineNumber = selection.endLineNumber;\n                if (selection.endColumn === 1) {\n                    --endLineNumber;\n                }\n                if (endLineNumber > selection.startLineNumber) {\n                    collapseRanges.push({\n                        startLineNumber: selection.startLineNumber,\n                        endLineNumber: endLineNumber,\n                        type: undefined,\n                        isCollapsed: true,\n                        source: 1 /* FoldSource.userDefined */\n                    });\n                    editor.setSelection({\n                        startLineNumber: selection.startLineNumber,\n                        startColumn: 1,\n                        endLineNumber: selection.startLineNumber,\n                        endColumn: 1\n                    });\n                }\n            }\n            if (collapseRanges.length > 0) {\n                collapseRanges.sort((a, b) => {\n                    return a.startLineNumber - b.startLineNumber;\n                });\n                const newRanges = FoldingRegions.sanitizeAndMerge(foldingModel.regions, collapseRanges, (_a = editor.getModel()) === null || _a === void 0 ? void 0 : _a.getLineCount());\n                foldingModel.updatePost(FoldingRegions.fromFoldRanges(newRanges));\n            }\n        }\n    }\n}\nclass RemoveFoldRangeFromSelectionAction extends FoldingAction {\n    constructor() {\n        super({\n            id: 'editor.removeManualFoldingRanges',\n            label: nls.localize('removeManualFoldingRanges.label', \"Remove Manual Folding Ranges\"),\n            alias: 'Remove Manual Folding Ranges',\n            precondition: CONTEXT_FOLDING_ENABLED,\n            kbOpts: {\n                kbExpr: EditorContextKeys.editorTextFocus,\n                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */),\n                weight: 100 /* KeybindingWeight.EditorContrib */\n            }\n        });\n    }\n    invoke(foldingController, foldingModel, editor) {\n        const selections = editor.getSelections();\n        if (selections) {\n            const ranges = [];\n            for (const selection of selections) {\n                const { startLineNumber, endLineNumber } = selection;\n                ranges.push(endLineNumber >= startLineNumber ? { startLineNumber, endLineNumber } : { endLineNumber, startLineNumber });\n            }\n            foldingModel.removeManualRanges(ranges);\n            foldingController.triggerFoldingModelChanged();\n        }\n    }\n}\nregisterEditorContribution(FoldingController.ID, FoldingController, 0 /* EditorContributionInstantiation.Eager */); // eager because it uses `saveViewState`/`restoreViewState`\nregisterEditorAction(UnfoldAction);\nregisterEditorAction(UnFoldRecursivelyAction);\nregisterEditorAction(FoldAction);\nregisterEditorAction(FoldRecursivelyAction);\nregisterEditorAction(FoldAllAction);\nregisterEditorAction(UnfoldAllAction);\nregisterEditorAction(FoldAllBlockCommentsAction);\nregisterEditorAction(FoldAllRegionsAction);\nregisterEditorAction(UnfoldAllRegionsAction);\nregisterEditorAction(FoldAllExceptAction);\nregisterEditorAction(UnfoldAllExceptAction);\nregisterEditorAction(ToggleFoldAction);\nregisterEditorAction(GotoParentFoldAction);\nregisterEditorAction(GotoPreviousFoldAction);\nregisterEditorAction(GotoNextFoldAction);\nregisterEditorAction(FoldRangeFromSelectionAction);\nregisterEditorAction(RemoveFoldRangeFromSelectionAction);\nfor (let i = 1; i <= 7; i++) {\n    registerInstantiatedEditorAction(new FoldLevelAction({\n        id: FoldLevelAction.ID(i),\n        label: nls.localize('foldLevelAction.label', \"Fold Level {0}\", i),\n        alias: `Fold Level ${i}`,\n        precondition: CONTEXT_FOLDING_ENABLED,\n        kbOpts: {\n            kbExpr: EditorContextKeys.editorTextFocus,\n            primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | (21 /* KeyCode.Digit0 */ + i)),\n            weight: 100 /* KeybindingWeight.EditorContrib */\n        }\n    }));\n}\nCommandsRegistry.registerCommand('_executeFoldingRangeProvider', async function (accessor, ...args) {\n    const [resource] = args;\n    if (!(resource instanceof URI)) {\n        throw illegalArgument();\n    }\n    const languageFeaturesService = accessor.get(ILanguageFeaturesService);\n    const model = accessor.get(IModelService).getModel(resource);\n    if (!model) {\n        throw illegalArgument();\n    }\n    const configurationService = accessor.get(IConfigurationService);\n    if (!configurationService.getValue('editor.folding', { resource })) {\n        return [];\n    }\n    const languageConfigurationService = accessor.get(ILanguageConfigurationService);\n    const strategy = configurationService.getValue('editor.foldingStrategy', { resource });\n    const foldingLimitReporter = {\n        get limit() {\n            return configurationService.getValue('editor.foldingMaximumRegions', { resource });\n        },\n        update: (computed, limited) => { }\n    };\n    const indentRangeProvider = new IndentRangeProvider(model, languageConfigurationService, foldingLimitReporter);\n    let rangeProvider = indentRangeProvider;\n    if (strategy !== 'indentation') {\n        const providers = FoldingController.getFoldingRangeProviders(languageFeaturesService, model);\n        if (providers.length) {\n            rangeProvider = new SyntaxRangeProvider(model, providers, () => { }, foldingLimitReporter, indentRangeProvider);\n        }\n    }\n    const ranges = await rangeProvider.compute(CancellationToken.None);\n    const result = [];\n    try {\n        if (ranges) {\n            for (let i = 0; i < ranges.length; i++) {\n                const type = ranges.getType(i);\n                result.push({ start: ranges.getStartLineNumber(i), end: ranges.getEndLineNumber(i), kind: type ? FoldingRangeKind.fromValue(type) : undefined });\n            }\n        }\n        return result;\n    }\n    finally {\n        rangeProvider.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 *--------------------------------------------------------------------------------------------*/\nimport { Codicon } from '../../../../base/common/codicons.js';\nimport { ModelDecorationOptions } from '../../../common/model/textModel.js';\nimport { localize } from '../../../../nls.js';\nimport { editorSelectionBackground, iconForeground, registerColor, transparent } from '../../../../platform/theme/common/colorRegistry.js';\nimport { registerIcon } from '../../../../platform/theme/common/iconRegistry.js';\nimport { themeColorFromId } from '../../../../platform/theme/common/themeService.js';\nimport { ThemeIcon } from '../../../../base/common/themables.js';\nconst foldBackground = registerColor('editor.foldBackground', { light: transparent(editorSelectionBackground, 0.3), dark: transparent(editorSelectionBackground, 0.3), hcDark: null, hcLight: null }, localize('foldBackgroundBackground', \"Background color behind folded ranges. The color must not be opaque so as not to hide underlying decorations.\"), true);\nregisterColor('editorGutter.foldingControlForeground', { dark: iconForeground, light: iconForeground, hcDark: iconForeground, hcLight: iconForeground }, localize('editorGutter.foldingControlForeground', 'Color of the folding control in the editor gutter.'));\nexport const foldingExpandedIcon = registerIcon('folding-expanded', Codicon.chevronDown, localize('foldingExpandedIcon', 'Icon for expanded ranges in the editor glyph margin.'));\nexport const foldingCollapsedIcon = registerIcon('folding-collapsed', Codicon.chevronRight, localize('foldingCollapsedIcon', 'Icon for collapsed ranges in the editor glyph margin.'));\nexport const foldingManualCollapsedIcon = registerIcon('folding-manual-collapsed', foldingCollapsedIcon, localize('foldingManualCollapedIcon', 'Icon for manually collapsed ranges in the editor glyph margin.'));\nexport const foldingManualExpandedIcon = registerIcon('folding-manual-expanded', foldingExpandedIcon, localize('foldingManualExpandedIcon', 'Icon for manually expanded ranges in the editor glyph margin.'));\nconst foldedBackgroundMinimap = { color: themeColorFromId(foldBackground), position: 1 /* MinimapPosition.Inline */ };\nconst collapsed = localize('linesCollapsed', \"Click to expand the range.\");\nconst expanded = localize('linesExpanded', \"Click to collapse the range.\");\nexport class FoldingDecorationProvider {\n    constructor(editor) {\n        this.editor = editor;\n        this.showFoldingControls = 'mouseover';\n        this.showFoldingHighlights = true;\n    }\n    getDecorationOption(isCollapsed, isHidden, isManual) {\n        if (isHidden) { // is inside another collapsed region\n            return FoldingDecorationProvider.HIDDEN_RANGE_DECORATION;\n        }\n        if (this.showFoldingControls === 'never') {\n            if (isCollapsed) {\n                return this.showFoldingHighlights ? FoldingDecorationProvider.NO_CONTROLS_COLLAPSED_HIGHLIGHTED_RANGE_DECORATION : FoldingDecorationProvider.NO_CONTROLS_COLLAPSED_RANGE_DECORATION;\n            }\n            return FoldingDecorationProvider.NO_CONTROLS_EXPANDED_RANGE_DECORATION;\n        }\n        if (isCollapsed) {\n            return isManual ?\n                (this.showFoldingHighlights ? FoldingDecorationProvider.MANUALLY_COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION : FoldingDecorationProvider.MANUALLY_COLLAPSED_VISUAL_DECORATION)\n                : (this.showFoldingHighlights ? FoldingDecorationProvider.COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION : FoldingDecorationProvider.COLLAPSED_VISUAL_DECORATION);\n        }\n        else if (this.showFoldingControls === 'mouseover') {\n            return isManual ? FoldingDecorationProvider.MANUALLY_EXPANDED_AUTO_HIDE_VISUAL_DECORATION : FoldingDecorationProvider.EXPANDED_AUTO_HIDE_VISUAL_DECORATION;\n        }\n        else {\n            return isManual ? FoldingDecorationProvider.MANUALLY_EXPANDED_VISUAL_DECORATION : FoldingDecorationProvider.EXPANDED_VISUAL_DECORATION;\n        }\n    }\n    changeDecorations(callback) {\n        return this.editor.changeDecorations(callback);\n    }\n    removeDecorations(decorationIds) {\n        this.editor.removeDecorations(decorationIds);\n    }\n}\nFoldingDecorationProvider.COLLAPSED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-collapsed-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingCollapsedIcon),\n});\nFoldingDecorationProvider.COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-collapsed-highlighted-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    className: 'folded-background',\n    minimap: foldedBackgroundMinimap,\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingCollapsedIcon)\n});\nFoldingDecorationProvider.MANUALLY_COLLAPSED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-manually-collapsed-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingManualCollapsedIcon)\n});\nFoldingDecorationProvider.MANUALLY_COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-manually-collapsed-highlighted-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    className: 'folded-background',\n    minimap: foldedBackgroundMinimap,\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingManualCollapsedIcon)\n});\nFoldingDecorationProvider.NO_CONTROLS_COLLAPSED_RANGE_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-no-controls-range-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n});\nFoldingDecorationProvider.NO_CONTROLS_COLLAPSED_HIGHLIGHTED_RANGE_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-no-controls-range-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    afterContentClassName: 'inline-folded',\n    className: 'folded-background',\n    minimap: foldedBackgroundMinimap,\n    isWholeLine: true,\n    linesDecorationsTooltip: collapsed,\n});\nFoldingDecorationProvider.EXPANDED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-expanded-visual-decoration',\n    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,\n    isWholeLine: true,\n    firstLineDecorationClassName: 'alwaysShowFoldIcons ' + ThemeIcon.asClassName(foldingExpandedIcon),\n    linesDecorationsTooltip: expanded,\n});\nFoldingDecorationProvider.EXPANDED_AUTO_HIDE_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-expanded-auto-hide-visual-decoration',\n    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */,\n    isWholeLine: true,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingExpandedIcon),\n    linesDecorationsTooltip: expanded,\n});\nFoldingDecorationProvider.MANUALLY_EXPANDED_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-manually-expanded-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    isWholeLine: true,\n    firstLineDecorationClassName: 'alwaysShowFoldIcons ' + ThemeIcon.asClassName(foldingManualExpandedIcon),\n    linesDecorationsTooltip: expanded,\n});\nFoldingDecorationProvider.MANUALLY_EXPANDED_AUTO_HIDE_VISUAL_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-manually-expanded-auto-hide-visual-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    isWholeLine: true,\n    firstLineDecorationClassName: ThemeIcon.asClassName(foldingManualExpandedIcon),\n    linesDecorationsTooltip: expanded,\n});\nFoldingDecorationProvider.NO_CONTROLS_EXPANDED_RANGE_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-no-controls-range-decoration',\n    stickiness: 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */,\n    isWholeLine: true\n});\nFoldingDecorationProvider.HIDDEN_RANGE_DECORATION = ModelDecorationOptions.register({\n    description: 'folding-hidden-range-decoration',\n    stickiness: 1 /* TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges */\n});\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Emitter } from '../../../../base/common/event.js';\nimport { FoldingRegions } from './foldingRanges.js';\nimport { hash } from '../../../../base/common/hash.js';\nexport class FoldingModel {\n    get regions() { return this._regions; }\n    get textModel() { return this._textModel; }\n    constructor(textModel, decorationProvider) {\n        this._updateEventEmitter = new Emitter();\n        this.onDidChange = this._updateEventEmitter.event;\n        this._textModel = textModel;\n        this._decorationProvider = decorationProvider;\n        this._regions = new FoldingRegions(new Uint32Array(0), new Uint32Array(0));\n        this._editorDecorationIds = [];\n    }\n    toggleCollapseState(toggledRegions) {\n        if (!toggledRegions.length) {\n            return;\n        }\n        toggledRegions = toggledRegions.sort((r1, r2) => r1.regionIndex - r2.regionIndex);\n        const processed = {};\n        this._decorationProvider.changeDecorations(accessor => {\n            let k = 0; // index from [0 ... this.regions.length]\n            let dirtyRegionEndLine = -1; // end of the range where decorations need to be updated\n            let lastHiddenLine = -1; // the end of the last hidden lines\n            const updateDecorationsUntil = (index) => {\n                while (k < index) {\n                    const endLineNumber = this._regions.getEndLineNumber(k);\n                    const isCollapsed = this._regions.isCollapsed(k);\n                    if (endLineNumber <= dirtyRegionEndLine) {\n                        const isManual = this.regions.getSource(k) !== 0 /* FoldSource.provider */;\n                        accessor.changeDecorationOptions(this._editorDecorationIds[k], this._decorationProvider.getDecorationOption(isCollapsed, endLineNumber <= lastHiddenLine, isManual));\n                    }\n                    if (isCollapsed && endLineNumber > lastHiddenLine) {\n                        lastHiddenLine = endLineNumber;\n                    }\n                    k++;\n                }\n            };\n            for (const region of toggledRegions) {\n                const index = region.regionIndex;\n                const editorDecorationId = this._editorDecorationIds[index];\n                if (editorDecorationId && !processed[editorDecorationId]) {\n                    processed[editorDecorationId] = true;\n                    updateDecorationsUntil(index); // update all decorations up to current index using the old dirtyRegionEndLine\n                    const newCollapseState = !this._regions.isCollapsed(index);\n                    this._regions.setCollapsed(index, newCollapseState);\n                    dirtyRegionEndLine = Math.max(dirtyRegionEndLine, this._regions.getEndLineNumber(index));\n                }\n            }\n            updateDecorationsUntil(this._regions.length);\n        });\n        this._updateEventEmitter.fire({ model: this, collapseStateChanged: toggledRegions });\n    }\n    removeManualRanges(ranges) {\n        const newFoldingRanges = new Array();\n        const intersects = (foldRange) => {\n            for (const range of ranges) {\n                if (!(range.startLineNumber > foldRange.endLineNumber || foldRange.startLineNumber > range.endLineNumber)) {\n                    return true;\n                }\n            }\n            return false;\n        };\n        for (let i = 0; i < this._regions.length; i++) {\n            const foldRange = this._regions.toFoldRange(i);\n            if (foldRange.source === 0 /* FoldSource.provider */ || !intersects(foldRange)) {\n                newFoldingRanges.push(foldRange);\n            }\n        }\n        this.updatePost(FoldingRegions.fromFoldRanges(newFoldingRanges));\n    }\n    update(newRegions, blockedLineNumers = []) {\n        const foldedOrManualRanges = this._currentFoldedOrManualRanges(blockedLineNumers);\n        const newRanges = FoldingRegions.sanitizeAndMerge(newRegions, foldedOrManualRanges, this._textModel.getLineCount());\n        this.updatePost(FoldingRegions.fromFoldRanges(newRanges));\n    }\n    updatePost(newRegions) {\n        const newEditorDecorations = [];\n        let lastHiddenLine = -1;\n        for (let index = 0, limit = newRegions.length; index < limit; index++) {\n            const startLineNumber = newRegions.getStartLineNumber(index);\n            const endLineNumber = newRegions.getEndLineNumber(index);\n            const isCollapsed = newRegions.isCollapsed(index);\n            const isManual = newRegions.getSource(index) !== 0 /* FoldSource.provider */;\n            const decorationRange = {\n                startLineNumber: startLineNumber,\n                startColumn: this._textModel.getLineMaxColumn(startLineNumber),\n                endLineNumber: endLineNumber,\n                endColumn: this._textModel.getLineMaxColumn(endLineNumber) + 1\n            };\n            newEditorDecorations.push({ range: decorationRange, options: this._decorationProvider.getDecorationOption(isCollapsed, endLineNumber <= lastHiddenLine, isManual) });\n            if (isCollapsed && endLineNumber > lastHiddenLine) {\n                lastHiddenLine = endLineNumber;\n            }\n        }\n        this._decorationProvider.changeDecorations(accessor => this._editorDecorationIds = accessor.deltaDecorations(this._editorDecorationIds, newEditorDecorations));\n        this._regions = newRegions;\n        this._updateEventEmitter.fire({ model: this });\n    }\n    _currentFoldedOrManualRanges(blockedLineNumers = []) {\n        const isBlocked = (startLineNumber, endLineNumber) => {\n            for (const blockedLineNumber of blockedLineNumers) {\n                if (startLineNumber < blockedLineNumber && blockedLineNumber <= endLineNumber) { // first line is visible\n                    return true;\n                }\n            }\n            return false;\n        };\n        const foldedRanges = [];\n        for (let i = 0, limit = this._regions.length; i < limit; i++) {\n            let isCollapsed = this.regions.isCollapsed(i);\n            const source = this.regions.getSource(i);\n            if (isCollapsed || source !== 0 /* FoldSource.provider */) {\n                const foldRange = this._regions.toFoldRange(i);\n                const decRange = this._textModel.getDecorationRange(this._editorDecorationIds[i]);\n                if (decRange) {\n                    if (isCollapsed && isBlocked(decRange.startLineNumber, decRange.endLineNumber)) {\n                        isCollapsed = false; // uncollapse is the range is blocked\n                    }\n                    foldedRanges.push({\n                        startLineNumber: decRange.startLineNumber,\n                        endLineNumber: decRange.endLineNumber,\n                        type: foldRange.type,\n                        isCollapsed,\n                        source\n                    });\n                }\n            }\n        }\n        return foldedRanges;\n    }\n    /**\n     * Collapse state memento, for persistence only\n     */\n    getMemento() {\n        const foldedOrManualRanges = this._currentFoldedOrManualRanges();\n        const result = [];\n        const maxLineNumber = this._textModel.getLineCount();\n        for (let i = 0, limit = foldedOrManualRanges.length; i < limit; i++) {\n            const range = foldedOrManualRanges[i];\n            if (range.startLineNumber >= range.endLineNumber || range.startLineNumber < 1 || range.endLineNumber > maxLineNumber) {\n                continue;\n            }\n            const checksum = this._getLinesChecksum(range.startLineNumber + 1, range.endLineNumber);\n            result.push({\n                startLineNumber: range.startLineNumber,\n                endLineNumber: range.endLineNumber,\n                isCollapsed: range.isCollapsed,\n                source: range.source,\n                checksum: checksum\n            });\n        }\n        return (result.length > 0) ? result : undefined;\n    }\n    /**\n     * Apply persisted state, for persistence only\n     */\n    applyMemento(state) {\n        var _a, _b;\n        if (!Array.isArray(state)) {\n            return;\n        }\n        const rangesToRestore = [];\n        const maxLineNumber = this._textModel.getLineCount();\n        for (const range of state) {\n            if (range.startLineNumber >= range.endLineNumber || range.startLineNumber < 1 || range.endLineNumber > maxLineNumber) {\n                continue;\n            }\n            const checksum = this._getLinesChecksum(range.startLineNumber + 1, range.endLineNumber);\n            if (!range.checksum || checksum === range.checksum) {\n                rangesToRestore.push({\n                    startLineNumber: range.startLineNumber,\n                    endLineNumber: range.endLineNumber,\n                    type: undefined,\n                    isCollapsed: (_a = range.isCollapsed) !== null && _a !== void 0 ? _a : true,\n                    source: (_b = range.source) !== null && _b !== void 0 ? _b : 0 /* FoldSource.provider */\n                });\n            }\n        }\n        const newRanges = FoldingRegions.sanitizeAndMerge(this._regions, rangesToRestore, maxLineNumber);\n        this.updatePost(FoldingRegions.fromFoldRanges(newRanges));\n    }\n    _getLinesChecksum(lineNumber1, lineNumber2) {\n        const h = hash(this._textModel.getLineContent(lineNumber1)\n            + this._textModel.getLineContent(lineNumber2));\n        return h % 1000000; // 6 digits is plenty\n    }\n    dispose() {\n        this._decorationProvider.removeDecorations(this._editorDecorationIds);\n    }\n    getAllRegionsAtLine(lineNumber, filter) {\n        const result = [];\n        if (this._regions) {\n            let index = this._regions.findRange(lineNumber);\n            let level = 1;\n            while (index >= 0) {\n                const current = this._regions.toRegion(index);\n                if (!filter || filter(current, level)) {\n                    result.push(current);\n                }\n                level++;\n                index = current.parentIndex;\n            }\n        }\n        return result;\n    }\n    getRegionAtLine(lineNumber) {\n        if (this._regions) {\n            const index = this._regions.findRange(lineNumber);\n            if (index >= 0) {\n                return this._regions.toRegion(index);\n            }\n        }\n        return null;\n    }\n    getRegionsInside(region, filter) {\n        const result = [];\n        const index = region ? region.regionIndex + 1 : 0;\n        const endLineNumber = region ? region.endLineNumber : Number.MAX_VALUE;\n        if (filter && filter.length === 2) {\n            const levelStack = [];\n            for (let i = index, len = this._regions.length; i < len; i++) {\n                const current = this._regions.toRegion(i);\n                if (this._regions.getStartLineNumber(i) < endLineNumber) {\n                    while (levelStack.length > 0 && !current.containedBy(levelStack[levelStack.length - 1])) {\n                        levelStack.pop();\n                    }\n                    levelStack.push(current);\n                    if (filter(current, levelStack.length)) {\n                        result.push(current);\n                    }\n                }\n                else {\n                    break;\n                }\n            }\n        }\n        else {\n            for (let i = index, len = this._regions.length; i < len; i++) {\n                const current = this._regions.toRegion(i);\n                if (this._regions.getStartLineNumber(i) < endLineNumber) {\n                    if (!filter || filter(current)) {\n                        result.push(current);\n                    }\n                }\n                else {\n                    break;\n                }\n            }\n        }\n        return result;\n    }\n}\n/**\n * Collapse or expand the regions at the given locations\n * @param levels The number of levels. Use 1 to only impact the regions at the location, use Number.MAX_VALUE for all levels.\n * @param lineNumbers the location of the regions to collapse or expand, or if not set, all regions in the model.\n */\nexport function toggleCollapseState(foldingModel, levels, lineNumbers) {\n    const toToggle = [];\n    for (const lineNumber of lineNumbers) {\n        const region = foldingModel.getRegionAtLine(lineNumber);\n        if (region) {\n            const doCollapse = !region.isCollapsed;\n            toToggle.push(region);\n            if (levels > 1) {\n                const regionsInside = foldingModel.getRegionsInside(region, (r, level) => r.isCollapsed !== doCollapse && level < levels);\n                toToggle.push(...regionsInside);\n            }\n        }\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Collapse or expand the regions at the given locations including all children.\n * @param doCollapse Whether to collapse or expand\n * @param levels The number of levels. Use 1 to only impact the regions at the location, use Number.MAX_VALUE for all levels.\n * @param lineNumbers the location of the regions to collapse or expand, or if not set, all regions in the model.\n */\nexport function setCollapseStateLevelsDown(foldingModel, doCollapse, levels = Number.MAX_VALUE, lineNumbers) {\n    const toToggle = [];\n    if (lineNumbers && lineNumbers.length > 0) {\n        for (const lineNumber of lineNumbers) {\n            const region = foldingModel.getRegionAtLine(lineNumber);\n            if (region) {\n                if (region.isCollapsed !== doCollapse) {\n                    toToggle.push(region);\n                }\n                if (levels > 1) {\n                    const regionsInside = foldingModel.getRegionsInside(region, (r, level) => r.isCollapsed !== doCollapse && level < levels);\n                    toToggle.push(...regionsInside);\n                }\n            }\n        }\n    }\n    else {\n        const regionsInside = foldingModel.getRegionsInside(null, (r, level) => r.isCollapsed !== doCollapse && level < levels);\n        toToggle.push(...regionsInside);\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Collapse or expand the regions at the given locations including all parents.\n * @param doCollapse Whether to collapse or expand\n * @param levels The number of levels. Use 1 to only impact the regions at the location, use Number.MAX_VALUE for all levels.\n * @param lineNumbers the location of the regions to collapse or expand.\n */\nexport function setCollapseStateLevelsUp(foldingModel, doCollapse, levels, lineNumbers) {\n    const toToggle = [];\n    for (const lineNumber of lineNumbers) {\n        const regions = foldingModel.getAllRegionsAtLine(lineNumber, (region, level) => region.isCollapsed !== doCollapse && level <= levels);\n        toToggle.push(...regions);\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Collapse or expand a region at the given locations. If the inner most region is already collapsed/expanded, uses the first parent instead.\n * @param doCollapse Whether to collapse or expand\n * @param lineNumbers the location of the regions to collapse or expand.\n */\nexport function setCollapseStateUp(foldingModel, doCollapse, lineNumbers) {\n    const toToggle = [];\n    for (const lineNumber of lineNumbers) {\n        const regions = foldingModel.getAllRegionsAtLine(lineNumber, (region) => region.isCollapsed !== doCollapse);\n        if (regions.length > 0) {\n            toToggle.push(regions[0]);\n        }\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Folds or unfolds all regions that have a given level, except if they contain one of the blocked lines.\n * @param foldLevel level. Level == 1 is the top level\n * @param doCollapse Whether to collapse or expand\n*/\nexport function setCollapseStateAtLevel(foldingModel, foldLevel, doCollapse, blockedLineNumbers) {\n    const filter = (region, level) => level === foldLevel && region.isCollapsed !== doCollapse && !blockedLineNumbers.some(line => region.containsLine(line));\n    const toToggle = foldingModel.getRegionsInside(null, filter);\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Folds or unfolds all regions, except if they contain or are contained by a region of one of the blocked lines.\n * @param doCollapse Whether to collapse or expand\n * @param blockedLineNumbers the location of regions to not collapse or expand\n */\nexport function setCollapseStateForRest(foldingModel, doCollapse, blockedLineNumbers) {\n    const filteredRegions = [];\n    for (const lineNumber of blockedLineNumbers) {\n        const regions = foldingModel.getAllRegionsAtLine(lineNumber, undefined);\n        if (regions.length > 0) {\n            filteredRegions.push(regions[0]);\n        }\n    }\n    const filter = (region) => filteredRegions.every((filteredRegion) => !filteredRegion.containedBy(region) && !region.containedBy(filteredRegion)) && region.isCollapsed !== doCollapse;\n    const toToggle = foldingModel.getRegionsInside(null, filter);\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Folds all regions for which the lines start with a given regex\n * @param foldingModel the folding model\n */\nexport function setCollapseStateForMatchingLines(foldingModel, regExp, doCollapse) {\n    const editorModel = foldingModel.textModel;\n    const regions = foldingModel.regions;\n    const toToggle = [];\n    for (let i = regions.length - 1; i >= 0; i--) {\n        if (doCollapse !== regions.isCollapsed(i)) {\n            const startLineNumber = regions.getStartLineNumber(i);\n            if (regExp.test(editorModel.getLineContent(startLineNumber))) {\n                toToggle.push(regions.toRegion(i));\n            }\n        }\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Folds all regions of the given type\n * @param foldingModel the folding model\n */\nexport function setCollapseStateForType(foldingModel, type, doCollapse) {\n    const regions = foldingModel.regions;\n    const toToggle = [];\n    for (let i = regions.length - 1; i >= 0; i--) {\n        if (doCollapse !== regions.isCollapsed(i) && type === regions.getType(i)) {\n            toToggle.push(regions.toRegion(i));\n        }\n    }\n    foldingModel.toggleCollapseState(toToggle);\n}\n/**\n * Get line to go to for parent fold of current line\n * @param lineNumber the current line number\n * @param foldingModel the folding model\n *\n * @return Parent fold start line\n */\nexport function getParentFoldLine(lineNumber, foldingModel) {\n    let startLineNumber = null;\n    const foldingRegion = foldingModel.getRegionAtLine(lineNumber);\n    if (foldingRegion !== null) {\n        startLineNumber = foldingRegion.startLineNumber;\n        // If current line is not the start of the current fold, go to top line of current fold. If not, go to parent fold\n        if (lineNumber === startLineNumber) {\n            const parentFoldingIdx = foldingRegion.parentIndex;\n            if (parentFoldingIdx !== -1) {\n                startLineNumber = foldingModel.regions.getStartLineNumber(parentFoldingIdx);\n            }\n            else {\n                startLineNumber = null;\n            }\n        }\n    }\n    return startLineNumber;\n}\n/**\n * Get line to go to for previous fold at the same level of current line\n * @param lineNumber the current line number\n * @param foldingModel the folding model\n *\n * @return Previous fold start line\n */\nexport function getPreviousFoldLine(lineNumber, foldingModel) {\n    let foldingRegion = foldingModel.getRegionAtLine(lineNumber);\n    // If on the folding range start line, go to previous sibling.\n    if (foldingRegion !== null && foldingRegion.startLineNumber === lineNumber) {\n        // If current line is not the start of the current fold, go to top line of current fold. If not, go to previous fold.\n        if (lineNumber !== foldingRegion.startLineNumber) {\n            return foldingRegion.startLineNumber;\n        }\n        else {\n            // Find min line number to stay within parent.\n            const expectedParentIndex = foldingRegion.parentIndex;\n            let minLineNumber = 0;\n            if (expectedParentIndex !== -1) {\n                minLineNumber = foldingModel.regions.getStartLineNumber(foldingRegion.parentIndex);\n            }\n            // Find fold at same level.\n            while (foldingRegion !== null) {\n                if (foldingRegion.regionIndex > 0) {\n                    foldingRegion = foldingModel.regions.toRegion(foldingRegion.regionIndex - 1);\n                    // Keep at same level.\n                    if (foldingRegion.startLineNumber <= minLineNumber) {\n                        return null;\n                    }\n                    else if (foldingRegion.parentIndex === expectedParentIndex) {\n                        return foldingRegion.startLineNumber;\n                    }\n                }\n                else {\n                    return null;\n                }\n            }\n        }\n    }\n    else {\n        // Go to last fold that's before the current line.\n        if (foldingModel.regions.length > 0) {\n            foldingRegion = foldingModel.regions.toRegion(foldingModel.regions.length - 1);\n            while (foldingRegion !== null) {\n                // Found fold before current line.\n                if (foldingRegion.startLineNumber < lineNumber) {\n                    return foldingRegion.startLineNumber;\n                }\n                if (foldingRegion.regionIndex > 0) {\n                    foldingRegion = foldingModel.regions.toRegion(foldingRegion.regionIndex - 1);\n                }\n                else {\n                    foldingRegion = null;\n                }\n            }\n        }\n    }\n    return null;\n}\n/**\n * Get line to go to next fold at the same level of current line\n * @param lineNumber the current line number\n * @param foldingModel the folding model\n *\n * @return Next fold start line\n */\nexport function getNextFoldLine(lineNumber, foldingModel) {\n    let foldingRegion = foldingModel.getRegionAtLine(lineNumber);\n    // If on the folding range start line, go to next sibling.\n    if (foldingRegion !== null && foldingRegion.startLineNumber === lineNumber) {\n        // Find max line number to stay within parent.\n        const expectedParentIndex = foldingRegion.parentIndex;\n        let maxLineNumber = 0;\n        if (expectedParentIndex !== -1) {\n            maxLineNumber = foldingModel.regions.getEndLineNumber(foldingRegion.parentIndex);\n        }\n        else if (foldingModel.regions.length === 0) {\n            return null;\n        }\n        else {\n            maxLineNumber = foldingModel.regions.getEndLineNumber(foldingModel.regions.length - 1);\n        }\n        // Find fold at same level.\n        while (foldingRegion !== null) {\n            if (foldingRegion.regionIndex < foldingModel.regions.length) {\n                foldingRegion = foldingModel.regions.toRegion(foldingRegion.regionIndex + 1);\n                // Keep at same level.\n                if (foldingRegion.startLineNumber >= maxLineNumber) {\n                    return null;\n                }\n                else if (foldingRegion.parentIndex === expectedParentIndex) {\n                    return foldingRegion.startLineNumber;\n                }\n            }\n            else {\n                return null;\n            }\n        }\n    }\n    else {\n        // Go to first fold that's after the current line.\n        if (foldingModel.regions.length > 0) {\n            foldingRegion = foldingModel.regions.toRegion(0);\n            while (foldingRegion !== null) {\n                // Found fold after current line.\n                if (foldingRegion.startLineNumber > lineNumber) {\n                    return foldingRegion.startLineNumber;\n                }\n                if (foldingRegion.regionIndex < foldingModel.regions.length) {\n                    foldingRegion = foldingModel.regions.toRegion(foldingRegion.regionIndex + 1);\n                }\n                else {\n                    foldingRegion = null;\n                }\n            }\n        }\n    }\n    return null;\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 const foldSourceAbbr = {\n    [0 /* FoldSource.provider */]: ' ',\n    [1 /* FoldSource.userDefined */]: 'u',\n    [2 /* FoldSource.recovered */]: 'r',\n};\nexport const MAX_FOLDING_REGIONS = 0xFFFF;\nexport const MAX_LINE_NUMBER = 0xFFFFFF;\nconst MASK_INDENT = 0xFF000000;\nclass BitField {\n    constructor(size) {\n        const numWords = Math.ceil(size / 32);\n        this._states = new Uint32Array(numWords);\n    }\n    get(index) {\n        const arrayIndex = (index / 32) | 0;\n        const bit = index % 32;\n        return (this._states[arrayIndex] & (1 << bit)) !== 0;\n    }\n    set(index, newState) {\n        const arrayIndex = (index / 32) | 0;\n        const bit = index % 32;\n        const value = this._states[arrayIndex];\n        if (newState) {\n            this._states[arrayIndex] = value | (1 << bit);\n        }\n        else {\n            this._states[arrayIndex] = value & ~(1 << bit);\n        }\n    }\n}\nexport class FoldingRegions {\n    constructor(startIndexes, endIndexes, types) {\n        if (startIndexes.length !== endIndexes.length || startIndexes.length > MAX_FOLDING_REGIONS) {\n            throw new Error('invalid startIndexes or endIndexes size');\n        }\n        this._startIndexes = startIndexes;\n        this._endIndexes = endIndexes;\n        this._collapseStates = new BitField(startIndexes.length);\n        this._userDefinedStates = new BitField(startIndexes.length);\n        this._recoveredStates = new BitField(startIndexes.length);\n        this._types = types;\n        this._parentsComputed = false;\n    }\n    ensureParentIndices() {\n        if (!this._parentsComputed) {\n            this._parentsComputed = true;\n            const parentIndexes = [];\n            const isInsideLast = (startLineNumber, endLineNumber) => {\n                const index = parentIndexes[parentIndexes.length - 1];\n                return this.getStartLineNumber(index) <= startLineNumber && this.getEndLineNumber(index) >= endLineNumber;\n            };\n            for (let i = 0, len = this._startIndexes.length; i < len; i++) {\n                const startLineNumber = this._startIndexes[i];\n                const endLineNumber = this._endIndexes[i];\n                if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {\n                    throw new Error('startLineNumber or endLineNumber must not exceed ' + MAX_LINE_NUMBER);\n                }\n                while (parentIndexes.length > 0 && !isInsideLast(startLineNumber, endLineNumber)) {\n                    parentIndexes.pop();\n                }\n                const parentIndex = parentIndexes.length > 0 ? parentIndexes[parentIndexes.length - 1] : -1;\n                parentIndexes.push(i);\n                this._startIndexes[i] = startLineNumber + ((parentIndex & 0xFF) << 24);\n                this._endIndexes[i] = endLineNumber + ((parentIndex & 0xFF00) << 16);\n            }\n        }\n    }\n    get length() {\n        return this._startIndexes.length;\n    }\n    getStartLineNumber(index) {\n        return this._startIndexes[index] & MAX_LINE_NUMBER;\n    }\n    getEndLineNumber(index) {\n        return this._endIndexes[index] & MAX_LINE_NUMBER;\n    }\n    getType(index) {\n        return this._types ? this._types[index] : undefined;\n    }\n    hasTypes() {\n        return !!this._types;\n    }\n    isCollapsed(index) {\n        return this._collapseStates.get(index);\n    }\n    setCollapsed(index, newState) {\n        this._collapseStates.set(index, newState);\n    }\n    isUserDefined(index) {\n        return this._userDefinedStates.get(index);\n    }\n    setUserDefined(index, newState) {\n        return this._userDefinedStates.set(index, newState);\n    }\n    isRecovered(index) {\n        return this._recoveredStates.get(index);\n    }\n    setRecovered(index, newState) {\n        return this._recoveredStates.set(index, newState);\n    }\n    getSource(index) {\n        if (this.isUserDefined(index)) {\n            return 1 /* FoldSource.userDefined */;\n        }\n        else if (this.isRecovered(index)) {\n            return 2 /* FoldSource.recovered */;\n        }\n        return 0 /* FoldSource.provider */;\n    }\n    setSource(index, source) {\n        if (source === 1 /* FoldSource.userDefined */) {\n            this.setUserDefined(index, true);\n            this.setRecovered(index, false);\n        }\n        else if (source === 2 /* FoldSource.recovered */) {\n            this.setUserDefined(index, false);\n            this.setRecovered(index, true);\n        }\n        else {\n            this.setUserDefined(index, false);\n            this.setRecovered(index, false);\n        }\n    }\n    setCollapsedAllOfType(type, newState) {\n        let hasChanged = false;\n        if (this._types) {\n            for (let i = 0; i < this._types.length; i++) {\n                if (this._types[i] === type) {\n                    this.setCollapsed(i, newState);\n                    hasChanged = true;\n                }\n            }\n        }\n        return hasChanged;\n    }\n    toRegion(index) {\n        return new FoldingRegion(this, index);\n    }\n    getParentIndex(index) {\n        this.ensureParentIndices();\n        const parent = ((this._startIndexes[index] & MASK_INDENT) >>> 24) + ((this._endIndexes[index] & MASK_INDENT) >>> 16);\n        if (parent === MAX_FOLDING_REGIONS) {\n            return -1;\n        }\n        return parent;\n    }\n    contains(index, line) {\n        return this.getStartLineNumber(index) <= line && this.getEndLineNumber(index) >= line;\n    }\n    findIndex(line) {\n        let low = 0, high = this._startIndexes.length;\n        if (high === 0) {\n            return -1; // no children\n        }\n        while (low < high) {\n            const mid = Math.floor((low + high) / 2);\n            if (line < this.getStartLineNumber(mid)) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        return low - 1;\n    }\n    findRange(line) {\n        let index = this.findIndex(line);\n        if (index >= 0) {\n            const endLineNumber = this.getEndLineNumber(index);\n            if (endLineNumber >= line) {\n                return index;\n            }\n            index = this.getParentIndex(index);\n            while (index !== -1) {\n                if (this.contains(index, line)) {\n                    return index;\n                }\n                index = this.getParentIndex(index);\n            }\n        }\n        return -1;\n    }\n    toString() {\n        const res = [];\n        for (let i = 0; i < this.length; i++) {\n            res[i] = `[${foldSourceAbbr[this.getSource(i)]}${this.isCollapsed(i) ? '+' : '-'}] ${this.getStartLineNumber(i)}/${this.getEndLineNumber(i)}`;\n        }\n        return res.join(', ');\n    }\n    toFoldRange(index) {\n        return {\n            startLineNumber: this._startIndexes[index] & MAX_LINE_NUMBER,\n            endLineNumber: this._endIndexes[index] & MAX_LINE_NUMBER,\n            type: this._types ? this._types[index] : undefined,\n            isCollapsed: this.isCollapsed(index),\n            source: this.getSource(index)\n        };\n    }\n    static fromFoldRanges(ranges) {\n        const rangesLength = ranges.length;\n        const startIndexes = new Uint32Array(rangesLength);\n        const endIndexes = new Uint32Array(rangesLength);\n        let types = [];\n        let gotTypes = false;\n        for (let i = 0; i < rangesLength; i++) {\n            const range = ranges[i];\n            startIndexes[i] = range.startLineNumber;\n            endIndexes[i] = range.endLineNumber;\n            types.push(range.type);\n            if (range.type) {\n                gotTypes = true;\n            }\n        }\n        if (!gotTypes) {\n            types = undefined;\n        }\n        const regions = new FoldingRegions(startIndexes, endIndexes, types);\n        for (let i = 0; i < rangesLength; i++) {\n            if (ranges[i].isCollapsed) {\n                regions.setCollapsed(i, true);\n            }\n            regions.setSource(i, ranges[i].source);\n        }\n        return regions;\n    }\n    /**\n     * Two inputs, each a FoldingRegions or a FoldRange[], are merged.\n     * Each input must be pre-sorted on startLineNumber.\n     * The first list is assumed to always include all regions currently defined by range providers.\n     * The second list only contains the previously collapsed and all manual ranges.\n     * If the line position matches, the range of the new range is taken, and the range is no longer manual\n     * When an entry in one list overlaps an entry in the other, the second list's entry \"wins\" and\n     * overlapping entries in the first list are discarded.\n     * Invalid entries are discarded. An entry is invalid if:\n     * \t\tthe start and end line numbers aren't a valid range of line numbers,\n     * \t\tit is out of sequence or has the same start line as a preceding entry,\n     * \t\tit overlaps a preceding entry and is not fully contained by that entry.\n     */\n    static sanitizeAndMerge(rangesA, rangesB, maxLineNumber) {\n        maxLineNumber = maxLineNumber !== null && maxLineNumber !== void 0 ? maxLineNumber : Number.MAX_VALUE;\n        const getIndexedFunction = (r, limit) => {\n            return Array.isArray(r)\n                ? ((i) => { return (i < limit) ? r[i] : undefined; })\n                : ((i) => { return (i < limit) ? r.toFoldRange(i) : undefined; });\n        };\n        const getA = getIndexedFunction(rangesA, rangesA.length);\n        const getB = getIndexedFunction(rangesB, rangesB.length);\n        let indexA = 0;\n        let indexB = 0;\n        let nextA = getA(0);\n        let nextB = getB(0);\n        const stackedRanges = [];\n        let topStackedRange;\n        let prevLineNumber = 0;\n        const resultRanges = [];\n        while (nextA || nextB) {\n            let useRange = undefined;\n            if (nextB && (!nextA || nextA.startLineNumber >= nextB.startLineNumber)) {\n                if (nextA && nextA.startLineNumber === nextB.startLineNumber) {\n                    if (nextB.source === 1 /* FoldSource.userDefined */) {\n                        // a user defined range (possibly unfolded)\n                        useRange = nextB;\n                    }\n                    else {\n                        // a previously folded range or a (possibly unfolded) recovered range\n                        useRange = nextA;\n                        useRange.isCollapsed = nextB.isCollapsed && nextA.endLineNumber === nextB.endLineNumber;\n                        useRange.source = 0 /* FoldSource.provider */;\n                    }\n                    nextA = getA(++indexA); // not necessary, just for speed\n                }\n                else {\n                    useRange = nextB;\n                    if (nextB.isCollapsed && nextB.source === 0 /* FoldSource.provider */) {\n                        // a previously collapsed range\n                        useRange.source = 2 /* FoldSource.recovered */;\n                    }\n                }\n                nextB = getB(++indexB);\n            }\n            else {\n                // nextA is next. The user folded B set takes precedence and we sometimes need to look\n                // ahead in it to check for an upcoming conflict.\n                let scanIndex = indexB;\n                let prescanB = nextB;\n                while (true) {\n                    if (!prescanB || prescanB.startLineNumber > nextA.endLineNumber) {\n                        useRange = nextA;\n                        break; // no conflict, use this nextA\n                    }\n                    if (prescanB.source === 1 /* FoldSource.userDefined */ && prescanB.endLineNumber > nextA.endLineNumber) {\n                        // we found a user folded range, it wins\n                        break; // without setting nextResult, so this nextA gets skipped\n                    }\n                    prescanB = getB(++scanIndex);\n                }\n                nextA = getA(++indexA);\n            }\n            if (useRange) {\n                while (topStackedRange\n                    && topStackedRange.endLineNumber < useRange.startLineNumber) {\n                    topStackedRange = stackedRanges.pop();\n                }\n                if (useRange.endLineNumber > useRange.startLineNumber\n                    && useRange.startLineNumber > prevLineNumber\n                    && useRange.endLineNumber <= maxLineNumber\n                    && (!topStackedRange\n                        || topStackedRange.endLineNumber >= useRange.endLineNumber)) {\n                    resultRanges.push(useRange);\n                    prevLineNumber = useRange.startLineNumber;\n                    if (topStackedRange) {\n                        stackedRanges.push(topStackedRange);\n                    }\n                    topStackedRange = useRange;\n                }\n            }\n        }\n        return resultRanges;\n    }\n}\nexport class FoldingRegion {\n    constructor(ranges, index) {\n        this.ranges = ranges;\n        this.index = index;\n    }\n    get startLineNumber() {\n        return this.ranges.getStartLineNumber(this.index);\n    }\n    get endLineNumber() {\n        return this.ranges.getEndLineNumber(this.index);\n    }\n    get regionIndex() {\n        return this.index;\n    }\n    get parentIndex() {\n        return this.ranges.getParentIndex(this.index);\n    }\n    get isCollapsed() {\n        return this.ranges.isCollapsed(this.index);\n    }\n    containedBy(range) {\n        return range.startLineNumber <= this.startLineNumber && range.endLineNumber >= this.endLineNumber;\n    }\n    containsLine(lineNumber) {\n        return this.startLineNumber <= lineNumber && lineNumber <= this.endLineNumber;\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { computeIndentLevel } from '../../../common/model/utils.js';\nimport { FoldingRegions, MAX_LINE_NUMBER } from './foldingRanges.js';\nconst MAX_FOLDING_REGIONS_FOR_INDENT_DEFAULT = 5000;\nconst ID_INDENT_PROVIDER = 'indent';\nexport class IndentRangeProvider {\n    constructor(editorModel, languageConfigurationService, foldingRangesLimit) {\n        this.editorModel = editorModel;\n        this.languageConfigurationService = languageConfigurationService;\n        this.foldingRangesLimit = foldingRangesLimit;\n        this.id = ID_INDENT_PROVIDER;\n    }\n    dispose() { }\n    compute(cancelationToken) {\n        const foldingRules = this.languageConfigurationService.getLanguageConfiguration(this.editorModel.getLanguageId()).foldingRules;\n        const offSide = foldingRules && !!foldingRules.offSide;\n        const markers = foldingRules && foldingRules.markers;\n        return Promise.resolve(computeRanges(this.editorModel, offSide, markers, this.foldingRangesLimit));\n    }\n}\n// public only for testing\nexport class RangesCollector {\n    constructor(foldingRangesLimit) {\n        this._startIndexes = [];\n        this._endIndexes = [];\n        this._indentOccurrences = [];\n        this._length = 0;\n        this._foldingRangesLimit = foldingRangesLimit;\n    }\n    insertFirst(startLineNumber, endLineNumber, indent) {\n        if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {\n            return;\n        }\n        const index = this._length;\n        this._startIndexes[index] = startLineNumber;\n        this._endIndexes[index] = endLineNumber;\n        this._length++;\n        if (indent < 1000) {\n            this._indentOccurrences[indent] = (this._indentOccurrences[indent] || 0) + 1;\n        }\n    }\n    toIndentRanges(model) {\n        const limit = this._foldingRangesLimit.limit;\n        if (this._length <= limit) {\n            this._foldingRangesLimit.update(this._length, false);\n            // reverse and create arrays of the exact length\n            const startIndexes = new Uint32Array(this._length);\n            const endIndexes = new Uint32Array(this._length);\n            for (let i = this._length - 1, k = 0; i >= 0; i--, k++) {\n                startIndexes[k] = this._startIndexes[i];\n                endIndexes[k] = this._endIndexes[i];\n            }\n            return new FoldingRegions(startIndexes, endIndexes);\n        }\n        else {\n            this._foldingRangesLimit.update(this._length, limit);\n            let entries = 0;\n            let maxIndent = this._indentOccurrences.length;\n            for (let i = 0; i < this._indentOccurrences.length; i++) {\n                const n = this._indentOccurrences[i];\n                if (n) {\n                    if (n + entries > limit) {\n                        maxIndent = i;\n                        break;\n                    }\n                    entries += n;\n                }\n            }\n            const tabSize = model.getOptions().tabSize;\n            // reverse and create arrays of the exact length\n            const startIndexes = new Uint32Array(limit);\n            const endIndexes = new Uint32Array(limit);\n            for (let i = this._length - 1, k = 0; i >= 0; i--) {\n                const startIndex = this._startIndexes[i];\n                const lineContent = model.getLineContent(startIndex);\n                const indent = computeIndentLevel(lineContent, tabSize);\n                if (indent < maxIndent || (indent === maxIndent && entries++ < limit)) {\n                    startIndexes[k] = startIndex;\n                    endIndexes[k] = this._endIndexes[i];\n                    k++;\n                }\n            }\n            return new FoldingRegions(startIndexes, endIndexes);\n        }\n    }\n}\nconst foldingRangesLimitDefault = {\n    limit: MAX_FOLDING_REGIONS_FOR_INDENT_DEFAULT,\n    update: () => { }\n};\nexport function computeRanges(model, offSide, markers, foldingRangesLimit = foldingRangesLimitDefault) {\n    const tabSize = model.getOptions().tabSize;\n    const result = new RangesCollector(foldingRangesLimit);\n    let pattern = undefined;\n    if (markers) {\n        pattern = new RegExp(`(${markers.start.source})|(?:${markers.end.source})`);\n    }\n    const previousRegions = [];\n    const line = model.getLineCount() + 1;\n    previousRegions.push({ indent: -1, endAbove: line, line }); // sentinel, to make sure there's at least one entry\n    for (let line = model.getLineCount(); line > 0; line--) {\n        const lineContent = model.getLineContent(line);\n        const indent = computeIndentLevel(lineContent, tabSize);\n        let previous = previousRegions[previousRegions.length - 1];\n        if (indent === -1) {\n            if (offSide) {\n                // for offSide languages, empty lines are associated to the previous block\n                // note: the next block is already written to the results, so this only\n                // impacts the end position of the block before\n                previous.endAbove = line;\n            }\n            continue; // only whitespace\n        }\n        let m;\n        if (pattern && (m = lineContent.match(pattern))) {\n            // folding pattern match\n            if (m[1]) { // start pattern match\n                // discard all regions until the folding pattern\n                let i = previousRegions.length - 1;\n                while (i > 0 && previousRegions[i].indent !== -2) {\n                    i--;\n                }\n                if (i > 0) {\n                    previousRegions.length = i + 1;\n                    previous = previousRegions[i];\n                    // new folding range from pattern, includes the end line\n                    result.insertFirst(line, previous.line, indent);\n                    previous.line = line;\n                    previous.indent = indent;\n                    previous.endAbove = line;\n                    continue;\n                }\n                else {\n                    // no end marker found, treat line as a regular line\n                }\n            }\n            else { // end pattern match\n                previousRegions.push({ indent: -2, endAbove: line, line });\n                continue;\n            }\n        }\n        if (previous.indent > indent) {\n            // discard all regions with larger indent\n            do {\n                previousRegions.pop();\n                previous = previousRegions[previousRegions.length - 1];\n            } while (previous.indent > indent);\n            // new folding range\n            const endLineNumber = previous.endAbove - 1;\n            if (endLineNumber - line >= 1) { // needs at east size 1\n                result.insertFirst(line, endLineNumber, indent);\n            }\n        }\n        if (previous.indent === indent) {\n            previous.endAbove = line;\n        }\n        else { // previous.indent < indent\n            // new region with a bigger indent\n            previousRegions.push({ indent, endAbove: line, line });\n        }\n    }\n    return result.toIndentRanges(model);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { onUnexpectedExternalError } from '../../../../base/common/errors.js';\nimport { DisposableStore } from '../../../../base/common/lifecycle.js';\nimport { FoldingRegions, MAX_LINE_NUMBER } from './foldingRanges.js';\nconst foldingContext = {};\nconst ID_SYNTAX_PROVIDER = 'syntax';\nexport class SyntaxRangeProvider {\n    constructor(editorModel, providers, handleFoldingRangesChange, foldingRangesLimit, fallbackRangeProvider // used when all providers return null\n    ) {\n        this.editorModel = editorModel;\n        this.providers = providers;\n        this.handleFoldingRangesChange = handleFoldingRangesChange;\n        this.foldingRangesLimit = foldingRangesLimit;\n        this.fallbackRangeProvider = fallbackRangeProvider;\n        this.id = ID_SYNTAX_PROVIDER;\n        this.disposables = new DisposableStore();\n        if (fallbackRangeProvider) {\n            this.disposables.add(fallbackRangeProvider);\n        }\n        for (const provider of providers) {\n            if (typeof provider.onDidChange === 'function') {\n                this.disposables.add(provider.onDidChange(handleFoldingRangesChange));\n            }\n        }\n    }\n    compute(cancellationToken) {\n        return collectSyntaxRanges(this.providers, this.editorModel, cancellationToken).then(ranges => {\n            var _a, _b;\n            if (ranges) {\n                const res = sanitizeRanges(ranges, this.foldingRangesLimit);\n                return res;\n            }\n            return (_b = (_a = this.fallbackRangeProvider) === null || _a === void 0 ? void 0 : _a.compute(cancellationToken)) !== null && _b !== void 0 ? _b : null;\n        });\n    }\n    dispose() {\n        this.disposables.dispose();\n    }\n}\nfunction collectSyntaxRanges(providers, model, cancellationToken) {\n    let rangeData = null;\n    const promises = providers.map((provider, i) => {\n        return Promise.resolve(provider.provideFoldingRanges(model, foldingContext, cancellationToken)).then(ranges => {\n            if (cancellationToken.isCancellationRequested) {\n                return;\n            }\n            if (Array.isArray(ranges)) {\n                if (!Array.isArray(rangeData)) {\n                    rangeData = [];\n                }\n                const nLines = model.getLineCount();\n                for (const r of ranges) {\n                    if (r.start > 0 && r.end > r.start && r.end <= nLines) {\n                        rangeData.push({ start: r.start, end: r.end, rank: i, kind: r.kind });\n                    }\n                }\n            }\n        }, onUnexpectedExternalError);\n    });\n    return Promise.all(promises).then(_ => {\n        return rangeData;\n    });\n}\nclass RangesCollector {\n    constructor(foldingRangesLimit) {\n        this._startIndexes = [];\n        this._endIndexes = [];\n        this._nestingLevels = [];\n        this._nestingLevelCounts = [];\n        this._types = [];\n        this._length = 0;\n        this._foldingRangesLimit = foldingRangesLimit;\n    }\n    add(startLineNumber, endLineNumber, type, nestingLevel) {\n        if (startLineNumber > MAX_LINE_NUMBER || endLineNumber > MAX_LINE_NUMBER) {\n            return;\n        }\n        const index = this._length;\n        this._startIndexes[index] = startLineNumber;\n        this._endIndexes[index] = endLineNumber;\n        this._nestingLevels[index] = nestingLevel;\n        this._types[index] = type;\n        this._length++;\n        if (nestingLevel < 30) {\n            this._nestingLevelCounts[nestingLevel] = (this._nestingLevelCounts[nestingLevel] || 0) + 1;\n        }\n    }\n    toIndentRanges() {\n        const limit = this._foldingRangesLimit.limit;\n        if (this._length <= limit) {\n            this._foldingRangesLimit.update(this._length, false);\n            const startIndexes = new Uint32Array(this._length);\n            const endIndexes = new Uint32Array(this._length);\n            for (let i = 0; i < this._length; i++) {\n                startIndexes[i] = this._startIndexes[i];\n                endIndexes[i] = this._endIndexes[i];\n            }\n            return new FoldingRegions(startIndexes, endIndexes, this._types);\n        }\n        else {\n            this._foldingRangesLimit.update(this._length, limit);\n            let entries = 0;\n            let maxLevel = this._nestingLevelCounts.length;\n            for (let i = 0; i < this._nestingLevelCounts.length; i++) {\n                const n = this._nestingLevelCounts[i];\n                if (n) {\n                    if (n + entries > limit) {\n                        maxLevel = i;\n                        break;\n                    }\n                    entries += n;\n                }\n            }\n            const startIndexes = new Uint32Array(limit);\n            const endIndexes = new Uint32Array(limit);\n            const types = [];\n            for (let i = 0, k = 0; i < this._length; i++) {\n                const level = this._nestingLevels[i];\n                if (level < maxLevel || (level === maxLevel && entries++ < limit)) {\n                    startIndexes[k] = this._startIndexes[i];\n                    endIndexes[k] = this._endIndexes[i];\n                    types[k] = this._types[i];\n                    k++;\n                }\n            }\n            return new FoldingRegions(startIndexes, endIndexes, types);\n        }\n    }\n}\nexport function sanitizeRanges(rangeData, foldingRangesLimit) {\n    const sorted = rangeData.sort((d1, d2) => {\n        let diff = d1.start - d2.start;\n        if (diff === 0) {\n            diff = d1.rank - d2.rank;\n        }\n        return diff;\n    });\n    const collector = new RangesCollector(foldingRangesLimit);\n    let top = undefined;\n    const previous = [];\n    for (const entry of sorted) {\n        if (!top) {\n            top = entry;\n            collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);\n        }\n        else {\n            if (entry.start > top.start) {\n                if (entry.end <= top.end) {\n                    previous.push(top);\n                    top = entry;\n                    collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);\n                }\n                else {\n                    if (entry.start > top.end) {\n                        do {\n                            top = previous.pop();\n                        } while (top && entry.start > top.end);\n                        if (top) {\n                            previous.push(top);\n                        }\n                        top = entry;\n                    }\n                    collector.add(entry.start, entry.end, entry.kind && entry.kind.value, previous.length);\n                }\n            }\n        }\n    }\n    return collector.toIndentRanges();\n}\n"],"names":["HiddenRangeModel","onDidChange","this","_updateEventEmitter","event","hiddenRanges","_hiddenRanges","constructor","model","_hasLineChanges","_foldingModel","_foldingModelListener","_","updateHiddenRanges","regions","length","notifyChangeModelContent","e","changes","some","change","range","endLineNumber","startLineNumber","text","updateHiddenAreas","newHiddenAreas","i","k","lastCollapsedStart","Number","MAX_VALUE","lastCollapsedEnd","ranges","isCollapsed","getStartLineNumber","getEndLineNumber","push","applyHiddenRanges","fire","hasRanges","isHidden","line","findRange","adjustSelections","selections","hasChanges","editorModel","textModel","lastRange","adjustLine","isInside","len","selection","adjustedStartLine","setStartPosition","getLineMaxColumn","adjustedEndLine","setEndPosition","dispose","r","FoldingController_1","__decorate","decorators","target","key","desc","d","c","arguments","Object","getOwnPropertyDescriptor","Reflect","decorate","defineProperty","__param","paramIndex","decorator","CONTEXT_FOLDING_ENABLED","FoldingController","get","editor","getContribution","ID","getFoldingRangeProviders","languageFeaturesService","_a","_b","foldingRangeProviders","foldingRangeProvider","ordered","_foldingRangeSelector","call","contextKeyService","languageConfigurationService","notificationService","languageFeatureDebounceService","super","localToDispose","_register","_foldingLimitReporter","RangesLimitReporter","options","getOptions","_isEnabled","_useFoldingProviders","_unfoldOnClickAfterEndOfLine","_restoringViewState","_currentModelHasFoldedImports","_foldingImportsByDefault","updateDebounceInfo","for","min","foldingModel","hiddenRangeModel","rangeProvider","foldingRegionPromise","foldingModelPromise","updateScheduler","cursorChangedScheduler","mouseDownInfo","foldingDecorationProvider","showFoldingControls","showFoldingHighlights","foldingEnabled","bindTo","set","onDidChangeModel","onModelChanged","onDidChangeConfiguration","hasChanged","triggerFoldingModelChanged","onFoldingStrategyChanged","saveViewState","getModel","isTooLargeForTokenization","collapsedRegions","getMemento","provider","id","undefined","lineCount","getLineCount","foldedImports","restoreViewState","state","applyMemento","clear","add","hr","onHiddenRangesChanges","revealCursor","onDidChangeModelLanguageConfiguration","onDidChangeModelContent","onDidChangeCursorPosition","onCursorPositionChanged","onMouseDown","onEditorMouseDown","onMouseUp","onEditorMouseUp","cancel","getRangeProvider","indentRangeProvider","selectedProviders","getFoldingModel","trigger","sw","token","compute","then","foldingRanges","scrollState","setCollapsedAllOfType","getSelections","selectionLineNumbers","map","s","update","restore","newValue","elapsed","defaultDelay","err","setSelections","setHiddenAreas","schedule","toToggle","lineNumber","selectionStartLineNumber","getAllRegionsAtLine","toggleCollapseState","reveal","getPosition","leftButton","middleButton","iconClicked","type","data","detail","offsetLeftInGutter","element","offsetLeft","offsetX","isAfterLines","startColumn","region","getRegionAtLine","altKey","filter","otherRegion","containedBy","toMaybeToggle","getRegionsInside","recursive","shiftKey","column","position","revealPositionInCenterIfOutsideViewport","_onDidChange","_computed","_limited","limit","computed","limited","FoldingAction","runEditorCommand","accessor","args","foldingController","reportTelemetry","invoke","getSelection","getStartPosition","getSelectedLines","getLineNumbers","selectionLines","l","run","_accessor","_editor","foldingArgumentsConstraint","types","foldingArgs","levels","direction","Array","isArray","every","FoldLevelAction","getFoldingLevel","parseInt","substr","ID_PREFIX","_foldingController","level","label","nls","alias","precondition","kbOpts","kbExpr","primary","mac","weight","metadata","description","name","constraint","schema","lineNumbers","_args","selectedLines","hasTypes","comments","getLanguageConfiguration","getLanguageId","blockCommentStartToken","regExp","RegExp","foldingRules","markers","start","setSelection","endColumn","collapseRanges","source","sort","a","b","newRanges","updatePost","removeManualRanges","async","resource","configurationService","getValue","strategy","foldingLimitReporter","providers","result","getType","end","kind","foldBackground","light","dark","hcDark","hcLight","foldingExpandedIcon","foldingCollapsedIcon","foldingManualCollapsedIcon","foldingManualExpandedIcon","foldedBackgroundMinimap","color","collapsed","expanded","FoldingDecorationProvider","getDecorationOption","isManual","HIDDEN_RANGE_DECORATION","NO_CONTROLS_COLLAPSED_HIGHLIGHTED_RANGE_DECORATION","NO_CONTROLS_COLLAPSED_RANGE_DECORATION","NO_CONTROLS_EXPANDED_RANGE_DECORATION","MANUALLY_COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION","MANUALLY_COLLAPSED_VISUAL_DECORATION","COLLAPSED_HIGHLIGHTED_VISUAL_DECORATION","COLLAPSED_VISUAL_DECORATION","MANUALLY_EXPANDED_AUTO_HIDE_VISUAL_DECORATION","EXPANDED_AUTO_HIDE_VISUAL_DECORATION","MANUALLY_EXPANDED_VISUAL_DECORATION","EXPANDED_VISUAL_DECORATION","changeDecorations","callback","removeDecorations","decorationIds","stickiness","afterContentClassName","isWholeLine","linesDecorationsTooltip","firstLineDecorationClassName","className","minimap","FoldingModel","_regions","_textModel","decorationProvider","_decorationProvider","Uint32Array","_editorDecorationIds","toggledRegions","r1","r2","regionIndex","processed","dirtyRegionEndLine","lastHiddenLine","updateDecorationsUntil","index","getSource","changeDecorationOptions","editorDecorationId","newCollapseState","setCollapsed","Math","max","collapseStateChanged","newFoldingRanges","intersects","foldRange","toFoldRange","newRegions","blockedLineNumers","foldedOrManualRanges","_currentFoldedOrManualRanges","newEditorDecorations","decorationRange","deltaDecorations","isBlocked","blockedLineNumber","foldedRanges","decRange","getDecorationRange","maxLineNumber","checksum","_getLinesChecksum","rangesToRestore","lineNumber1","lineNumber2","getLineContent","current","toRegion","parentIndex","levelStack","pop","doCollapse","regionsInside","setCollapseStateLevelsDown","setCollapseStateLevelsUp","setCollapseStateUp","setCollapseStateAtLevel","foldLevel","blockedLineNumbers","containsLine","setCollapseStateForRest","filteredRegions","filteredRegion","setCollapseStateForMatchingLines","test","setCollapseStateForType","getParentFoldLine","foldingRegion","parentFoldingIdx","getPreviousFoldLine","expectedParentIndex","minLineNumber","getNextFoldLine","foldSourceAbbr","MAX_LINE_NUMBER","MASK_INDENT","BitField","size","numWords","ceil","_states","arrayIndex","bit","newState","value","FoldingRegions","startIndexes","endIndexes","Error","_startIndexes","_endIndexes","_collapseStates","_userDefinedStates","_recoveredStates","_types","_parentsComputed","ensureParentIndices","parentIndexes","isInsideLast","isUserDefined","setUserDefined","isRecovered","setRecovered","setSource","FoldingRegion","getParentIndex","parent","contains","findIndex","low","high","mid","floor","toString","res","join","fromFoldRanges","rangesLength","gotTypes","sanitizeAndMerge","rangesA","rangesB","getIndexedFunction","getA","getB","indexA","indexB","nextA","nextB","stackedRanges","topStackedRange","prevLineNumber","resultRanges","useRange","scanIndex","prescanB","IndentRangeProvider","foldingRangesLimit","cancelationToken","offSide","Promise","resolve","foldingRangesLimitDefault","tabSize","RangesCollector","pattern","previousRegions","indent","endAbove","lineContent","m","previous","match","insertFirst","toIndentRanges","computeRanges","_indentOccurrences","_length","_foldingRangesLimit","entries","maxIndent","n","startIndex","foldingContext","SyntaxRangeProvider","handleFoldingRangesChange","fallbackRangeProvider","disposables","cancellationToken","rangeData","promises","provideFoldingRanges","isCancellationRequested","nLines","rank","all","collectSyntaxRanges","sorted","d1","d2","diff","collector","top","entry","sanitizeRanges","_nestingLevels","_nestingLevelCounts","nestingLevel","maxLevel"],"sourceRoot":""}