@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

package/vscode/src/vs/editor/contrib/folding/browser/folding.js

@@ -0,0 +1,1149 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Delayer, RunOnceScheduler, createCancelablePromise } from '../../../../base/common/async.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { onUnexpectedError, illegalArgument } from '../../../../base/common/errors.js';
+import { KeyChord } from '../../../../base/common/keyCodes.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { escapeRegExpCharacters } from '../../../../base/common/strings.js';
+import { isUndefined, isObject, isNumber, isString } from '../../../../base/common/types.js';
+import './folding.css.js';
+import { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';
+import { registerEditorContribution, registerEditorAction, registerInstantiatedEditorAction, EditorAction } from '../../../browser/editorExtensions.js';
+import { EditorContextKeys } from '../../../common/editorContextKeys.js';
+import { FoldingRangeKind } from '../../../common/languages.js';
+import { ILanguageConfigurationService } from '../../../common/languages/languageConfigurationRegistry.js';
+import { FoldingModel, setCollapseStateAtLevel, setCollapseStateLevelsUp, setCollapseStateLevelsDown, setCollapseStateUp, toggleCollapseState, setCollapseStateForType, setCollapseStateForMatchingLines, setCollapseStateForRest, getParentFoldLine, getPreviousFoldLine, getNextFoldLine } from './foldingModel.js';
+import { HiddenRangeModel } from './hiddenRangeModel.js';
+import { IndentRangeProvider } from './indentRangeProvider.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { FoldingDecorationProvider } from './foldingDecorations.js';
+import { FoldingRegions } from './foldingRanges.js';
+import { SyntaxRangeProvider } from './syntaxRangeProvider.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { ILanguageFeatureDebounceService } from '../../../common/services/languageFeatureDebounce.js';
+import { StopWatch } from '../../../../base/common/stopwatch.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IModelService } from '../../../common/services/model.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+var FoldingController_1;
+const CONTEXT_FOLDING_ENABLED = ( new RawContextKey('foldingEnabled', false));
+let FoldingController = class FoldingController extends Disposable {
+    static { FoldingController_1 = this; }
+    static { this.ID = 'editor.contrib.folding'; }
+    static get(editor) {
+        return editor.getContribution(FoldingController_1.ID);
+    }
+    static getFoldingRangeProviders(languageFeaturesService, model) {
+        const foldingRangeProviders = languageFeaturesService.foldingRangeProvider.ordered(model);
+        return (FoldingController_1._foldingRangeSelector?.(foldingRangeProviders, model)) ?? foldingRangeProviders;
+    }
+    static setFoldingRangeProviderSelector(foldingRangeSelector) {
+        FoldingController_1._foldingRangeSelector = foldingRangeSelector;
+        return { dispose: () => { FoldingController_1._foldingRangeSelector = undefined; } };
+    }
+    constructor(editor, contextKeyService, languageConfigurationService, notificationService, languageFeatureDebounceService, languageFeaturesService) {
+        super();
+        this.contextKeyService = contextKeyService;
+        this.languageConfigurationService = languageConfigurationService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.localToDispose = this._register(( new DisposableStore()));
+        this.editor = editor;
+        this._foldingLimitReporter = ( new RangesLimitReporter(editor));
+        const options = this.editor.getOptions();
+        this._isEnabled = options.get(43 );
+        this._useFoldingProviders = options.get(44 ) !== 'indentation';
+        this._unfoldOnClickAfterEndOfLine = options.get(48 );
+        this._restoringViewState = false;
+        this._currentModelHasFoldedImports = false;
+        this._foldingImportsByDefault = options.get(46 );
+        this.updateDebounceInfo = languageFeatureDebounceService.for(languageFeaturesService.foldingRangeProvider, 'Folding', { min: 200 });
+        this.foldingModel = null;
+        this.hiddenRangeModel = null;
+        this.rangeProvider = null;
+        this.foldingRegionPromise = null;
+        this.foldingModelPromise = null;
+        this.updateScheduler = null;
+        this.cursorChangedScheduler = null;
+        this.mouseDownInfo = null;
+        this.foldingDecorationProvider = ( new FoldingDecorationProvider(editor));
+        this.foldingDecorationProvider.showFoldingControls = options.get(109 );
+        this.foldingDecorationProvider.showFoldingHighlights = options.get(45 );
+        this.foldingEnabled = CONTEXT_FOLDING_ENABLED.bindTo(this.contextKeyService);
+        this.foldingEnabled.set(this._isEnabled);
+        this._register(this.editor.onDidChangeModel(() => this.onModelChanged()));
+        this._register(this.editor.onDidChangeConfiguration((e) => {
+            if (e.hasChanged(43 )) {
+                this._isEnabled = this.editor.getOptions().get(43 );
+                this.foldingEnabled.set(this._isEnabled);
+                this.onModelChanged();
+            }
+            if (e.hasChanged(47 )) {
+                this.onModelChanged();
+            }
+            if (e.hasChanged(109 ) || e.hasChanged(45 )) {
+                const options = this.editor.getOptions();
+                this.foldingDecorationProvider.showFoldingControls = options.get(109 );
+                this.foldingDecorationProvider.showFoldingHighlights = options.get(45 );
+                this.triggerFoldingModelChanged();
+            }
+            if (e.hasChanged(44 )) {
+                this._useFoldingProviders = this.editor.getOptions().get(44 ) !== 'indentation';
+                this.onFoldingStrategyChanged();
+            }
+            if (e.hasChanged(48 )) {
+                this._unfoldOnClickAfterEndOfLine = this.editor.getOptions().get(48 );
+            }
+            if (e.hasChanged(46 )) {
+                this._foldingImportsByDefault = this.editor.getOptions().get(46 );
+            }
+        }));
+        this.onModelChanged();
+    }
+    get limitReporter() {
+        return this._foldingLimitReporter;
+    }
+    saveViewState() {
+        const model = this.editor.getModel();
+        if (!model || !this._isEnabled || model.isTooLargeForTokenization()) {
+            return {};
+        }
+        if (this.foldingModel) {
+            const collapsedRegions = this.foldingModel.getMemento();
+            const provider = this.rangeProvider ? this.rangeProvider.id : undefined;
+            return { collapsedRegions, lineCount: model.getLineCount(), provider, foldedImports: this._currentModelHasFoldedImports };
+        }
+        return undefined;
+    }
+    restoreViewState(state) {
+        const model = this.editor.getModel();
+        if (!model || !this._isEnabled || model.isTooLargeForTokenization() || !this.hiddenRangeModel) {
+            return;
+        }
+        if (!state) {
+            return;
+        }
+        this._currentModelHasFoldedImports = !!state.foldedImports;
+        if (state.collapsedRegions && state.collapsedRegions.length > 0 && this.foldingModel) {
+            this._restoringViewState = true;
+            try {
+                this.foldingModel.applyMemento(state.collapsedRegions);
+            }
+            finally {
+                this._restoringViewState = false;
+            }
+        }
+    }
+    onModelChanged() {
+        this.localToDispose.clear();
+        const model = this.editor.getModel();
+        if (!this._isEnabled || !model || model.isTooLargeForTokenization()) {
+            return;
+        }
+        this._currentModelHasFoldedImports = false;
+        this.foldingModel = ( new FoldingModel(model, this.foldingDecorationProvider));
+        this.localToDispose.add(this.foldingModel);
+        this.hiddenRangeModel = ( new HiddenRangeModel(this.foldingModel));
+        this.localToDispose.add(this.hiddenRangeModel);
+        this.localToDispose.add(this.hiddenRangeModel.onDidChange(hr => this.onHiddenRangesChanges(hr)));
+        this.updateScheduler = ( new Delayer(this.updateDebounceInfo.get(model)));
+        this.cursorChangedScheduler = ( new RunOnceScheduler(() => this.revealCursor(), 200));
+        this.localToDispose.add(this.cursorChangedScheduler);
+        this.localToDispose.add(this.languageFeaturesService.foldingRangeProvider.onDidChange(() => this.onFoldingStrategyChanged()));
+        this.localToDispose.add(this.editor.onDidChangeModelLanguageConfiguration(() => this.onFoldingStrategyChanged()));
+        this.localToDispose.add(this.editor.onDidChangeModelContent(e => this.onDidChangeModelContent(e)));
+        this.localToDispose.add(this.editor.onDidChangeCursorPosition(() => this.onCursorPositionChanged()));
+        this.localToDispose.add(this.editor.onMouseDown(e => this.onEditorMouseDown(e)));
+        this.localToDispose.add(this.editor.onMouseUp(e => this.onEditorMouseUp(e)));
+        this.localToDispose.add({
+            dispose: () => {
+                if (this.foldingRegionPromise) {
+                    this.foldingRegionPromise.cancel();
+                    this.foldingRegionPromise = null;
+                }
+                this.updateScheduler?.cancel();
+                this.updateScheduler = null;
+                this.foldingModel = null;
+                this.foldingModelPromise = null;
+                this.hiddenRangeModel = null;
+                this.cursorChangedScheduler = null;
+                this.rangeProvider?.dispose();
+                this.rangeProvider = null;
+            }
+        });
+        this.triggerFoldingModelChanged();
+    }
+    onFoldingStrategyChanged() {
+        this.rangeProvider?.dispose();
+        this.rangeProvider = null;
+        this.triggerFoldingModelChanged();
+    }
+    getRangeProvider(editorModel) {
+        if (this.rangeProvider) {
+            return this.rangeProvider;
+        }
+        const indentRangeProvider = ( new IndentRangeProvider(editorModel, this.languageConfigurationService, this._foldingLimitReporter));
+        this.rangeProvider = indentRangeProvider;
+        if (this._useFoldingProviders && this.foldingModel) {
+            const selectedProviders = FoldingController_1.getFoldingRangeProviders(this.languageFeaturesService, editorModel);
+            if (selectedProviders.length > 0) {
+                this.rangeProvider = ( new SyntaxRangeProvider(
+                    editorModel,
+                    selectedProviders,
+                    () => this.triggerFoldingModelChanged(),
+                    this._foldingLimitReporter,
+                    indentRangeProvider
+                ));
+            }
+        }
+        return this.rangeProvider;
+    }
+    getFoldingModel() {
+        return this.foldingModelPromise;
+    }
+    onDidChangeModelContent(e) {
+        this.hiddenRangeModel?.notifyChangeModelContent(e);
+        this.triggerFoldingModelChanged();
+    }
+    triggerFoldingModelChanged() {
+        if (this.updateScheduler) {
+            if (this.foldingRegionPromise) {
+                this.foldingRegionPromise.cancel();
+                this.foldingRegionPromise = null;
+            }
+            this.foldingModelPromise = this.updateScheduler.trigger(() => {
+                const foldingModel = this.foldingModel;
+                if (!foldingModel) {
+                    return null;
+                }
+                const sw = ( new StopWatch());
+                const provider = this.getRangeProvider(foldingModel.textModel);
+                const foldingRegionPromise = this.foldingRegionPromise = createCancelablePromise(token => provider.compute(token));
+                return foldingRegionPromise.then(foldingRanges => {
+                    if (foldingRanges && foldingRegionPromise === this.foldingRegionPromise) {
+                        let scrollState;
+                        if (this._foldingImportsByDefault && !this._currentModelHasFoldedImports) {
+                            const hasChanges = foldingRanges.setCollapsedAllOfType(FoldingRangeKind.Imports.value, true);
+                            if (hasChanges) {
+                                scrollState = StableEditorScrollState.capture(this.editor);
+                                this._currentModelHasFoldedImports = hasChanges;
+                            }
+                        }
+                        const selections = this.editor.getSelections();
+                        const selectionLineNumbers = selections ? ( selections.map(s => s.startLineNumber)) : [];
+                        foldingModel.update(foldingRanges, selectionLineNumbers);
+                        scrollState?.restore(this.editor);
+                        const newValue = this.updateDebounceInfo.update(foldingModel.textModel, sw.elapsed());
+                        if (this.updateScheduler) {
+                            this.updateScheduler.defaultDelay = newValue;
+                        }
+                    }
+                    return foldingModel;
+                });
+            }).then(undefined, (err) => {
+                onUnexpectedError(err);
+                return null;
+            });
+        }
+    }
+    onHiddenRangesChanges(hiddenRanges) {
+        if (this.hiddenRangeModel && hiddenRanges.length && !this._restoringViewState) {
+            const selections = this.editor.getSelections();
+            if (selections) {
+                if (this.hiddenRangeModel.adjustSelections(selections)) {
+                    this.editor.setSelections(selections);
+                }
+            }
+        }
+        this.editor.setHiddenAreas(hiddenRanges, this);
+    }
+    onCursorPositionChanged() {
+        if (this.hiddenRangeModel && this.hiddenRangeModel.hasRanges()) {
+            this.cursorChangedScheduler.schedule();
+        }
+    }
+    revealCursor() {
+        const foldingModel = this.getFoldingModel();
+        if (!foldingModel) {
+            return;
+        }
+        foldingModel.then(foldingModel => {
+            if (foldingModel) {
+                const selections = this.editor.getSelections();
+                if (selections && selections.length > 0) {
+                    const toToggle = [];
+                    for (const selection of selections) {
+                        const lineNumber = selection.selectionStartLineNumber;
+                        if (this.hiddenRangeModel && this.hiddenRangeModel.isHidden(lineNumber)) {
+                            toToggle.push(...foldingModel.getAllRegionsAtLine(lineNumber, r => r.isCollapsed && lineNumber > r.startLineNumber));
+                        }
+                    }
+                    if (toToggle.length) {
+                        foldingModel.toggleCollapseState(toToggle);
+                        this.reveal(selections[0].getPosition());
+                    }
+                }
+            }
+        }).then(undefined, onUnexpectedError);
+    }
+    onEditorMouseDown(e) {
+        this.mouseDownInfo = null;
+        if (!this.hiddenRangeModel || !e.target || !e.target.range) {
+            return;
+        }
+        if (!e.event.leftButton && !e.event.middleButton) {
+            return;
+        }
+        const range = e.target.range;
+        let iconClicked = false;
+        switch (e.target.type) {
+            case 4 : {
+                const data = e.target.detail;
+                const offsetLeftInGutter = e.target.element.offsetLeft;
+                const gutterOffsetX = data.offsetX - offsetLeftInGutter;
+                if (gutterOffsetX < 4) {
+                    return;
+                }
+                iconClicked = true;
+                break;
+            }
+            case 7 : {
+                if (this._unfoldOnClickAfterEndOfLine && this.hiddenRangeModel.hasRanges()) {
+                    const data = e.target.detail;
+                    if (!data.isAfterLines) {
+                        break;
+                    }
+                }
+                return;
+            }
+            case 6 : {
+                if (this.hiddenRangeModel.hasRanges()) {
+                    const model = this.editor.getModel();
+                    if (model && range.startColumn === model.getLineMaxColumn(range.startLineNumber)) {
+                        break;
+                    }
+                }
+                return;
+            }
+            default:
+                return;
+        }
+        this.mouseDownInfo = { lineNumber: range.startLineNumber, iconClicked };
+    }
+    onEditorMouseUp(e) {
+        const foldingModel = this.foldingModel;
+        if (!foldingModel || !this.mouseDownInfo || !e.target) {
+            return;
+        }
+        const lineNumber = this.mouseDownInfo.lineNumber;
+        const iconClicked = this.mouseDownInfo.iconClicked;
+        const range = e.target.range;
+        if (!range || range.startLineNumber !== lineNumber) {
+            return;
+        }
+        if (iconClicked) {
+            if (e.target.type !== 4 ) {
+                return;
+            }
+        }
+        else {
+            const model = this.editor.getModel();
+            if (!model || range.startColumn !== model.getLineMaxColumn(lineNumber)) {
+                return;
+            }
+        }
+        const region = foldingModel.getRegionAtLine(lineNumber);
+        if (region && region.startLineNumber === lineNumber) {
+            const isCollapsed = region.isCollapsed;
+            if (iconClicked || isCollapsed) {
+                const surrounding = e.event.altKey;
+                let toToggle = [];
+                if (surrounding) {
+                    const filter = (otherRegion) => !otherRegion.containedBy(region) && !region.containedBy(otherRegion);
+                    const toMaybeToggle = foldingModel.getRegionsInside(null, filter);
+                    for (const r of toMaybeToggle) {
+                        if (r.isCollapsed) {
+                            toToggle.push(r);
+                        }
+                    }
+                    if (toToggle.length === 0) {
+                        toToggle = toMaybeToggle;
+                    }
+                }
+                else {
+                    const recursive = e.event.middleButton || e.event.shiftKey;
+                    if (recursive) {
+                        for (const r of foldingModel.getRegionsInside(region)) {
+                            if (r.isCollapsed === isCollapsed) {
+                                toToggle.push(r);
+                            }
+                        }
+                    }
+                    if (isCollapsed || !recursive || toToggle.length === 0) {
+                        toToggle.push(region);
+                    }
+                }
+                foldingModel.toggleCollapseState(toToggle);
+                this.reveal({ lineNumber, column: 1 });
+            }
+        }
+    }
+    reveal(position) {
+        this.editor.revealPositionInCenterIfOutsideViewport(position, 0 );
+    }
+};
+FoldingController = FoldingController_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, ILanguageConfigurationService)),
+    ( __param(3, INotificationService)),
+    ( __param(4, ILanguageFeatureDebounceService)),
+    ( __param(5, ILanguageFeaturesService))
+], FoldingController));
+class RangesLimitReporter {
+    constructor(editor) {
+        this.editor = editor;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this._computed = 0;
+        this._limited = false;
+    }
+    get limit() {
+        return this.editor.getOptions().get(47 );
+    }
+    get computed() {
+        return this._computed;
+    }
+    get limited() {
+        return this._limited;
+    }
+    update(computed, limited) {
+        if (computed !== this._computed || limited !== this._limited) {
+            this._computed = computed;
+            this._limited = limited;
+            this._onDidChange.fire();
+        }
+    }
+}
+class FoldingAction extends EditorAction {
+    runEditorCommand(accessor, editor, args) {
+        const languageConfigurationService = accessor.get(ILanguageConfigurationService);
+        const foldingController = FoldingController.get(editor);
+        if (!foldingController) {
+            return;
+        }
+        const foldingModelPromise = foldingController.getFoldingModel();
+        if (foldingModelPromise) {
+            this.reportTelemetry(accessor, editor);
+            return foldingModelPromise.then(foldingModel => {
+                if (foldingModel) {
+                    this.invoke(foldingController, foldingModel, editor, args, languageConfigurationService);
+                    const selection = editor.getSelection();
+                    if (selection) {
+                        foldingController.reveal(selection.getStartPosition());
+                    }
+                }
+            });
+        }
+    }
+    getSelectedLines(editor) {
+        const selections = editor.getSelections();
+        return selections ? ( selections.map(s => s.startLineNumber)) : [];
+    }
+    getLineNumbers(args, editor) {
+        if (args && args.selectionLines) {
+            return ( args.selectionLines.map(l => l + 1));
+        }
+        return this.getSelectedLines(editor);
+    }
+    run(_accessor, _editor) {
+    }
+}
+function foldingArgumentsConstraint(args) {
+    if (!isUndefined(args)) {
+        if (!isObject(args)) {
+            return false;
+        }
+        const foldingArgs = args;
+        if (!isUndefined(foldingArgs.levels) && !isNumber(foldingArgs.levels)) {
+            return false;
+        }
+        if (!isUndefined(foldingArgs.direction) && !isString(foldingArgs.direction)) {
+            return false;
+        }
+        if (!isUndefined(foldingArgs.selectionLines) && (!Array.isArray(foldingArgs.selectionLines) || !foldingArgs.selectionLines.every(isNumber))) {
+            return false;
+        }
+    }
+    return true;
+}
+class UnfoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.unfold',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'unfoldAction.label',
+                "Unfold"
+            )),
+            alias: 'Unfold',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 1024  | 94 ,
+                mac: {
+                    primary: 2048  | 512  | 94
+                },
+                weight: 100
+            },
+            metadata: {
+                description: 'Unfold the content in the editor',
+                args: [
+                    {
+                        name: 'Unfold editor argument',
+                        description: `Property-value pairs that can be passed through this argument:
+						* 'levels': Number of levels to unfold. If not set, defaults to 1.
+						* 'direction': If 'up', unfold given number of levels up otherwise unfolds down.
+						* '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.
+						`,
+                        constraint: foldingArgumentsConstraint,
+                        schema: {
+                            'type': 'object',
+                            'properties': {
+                                'levels': {
+                                    'type': 'number',
+                                    'default': 1
+                                },
+                                'direction': {
+                                    'type': 'string',
+                                    'enum': ['up', 'down'],
+                                    'default': 'down'
+                                },
+                                'selectionLines': {
+                                    'type': 'array',
+                                    'items': {
+                                        'type': 'number'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, args) {
+        const levels = args && args.levels || 1;
+        const lineNumbers = this.getLineNumbers(args, editor);
+        if (args && args.direction === 'up') {
+            setCollapseStateLevelsUp(foldingModel, false, levels, lineNumbers);
+        }
+        else {
+            setCollapseStateLevelsDown(foldingModel, false, levels, lineNumbers);
+        }
+    }
+}
+class UnFoldRecursivelyAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.unfoldRecursively',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'unFoldRecursivelyAction.label',
+                "Unfold Recursively"
+            )),
+            alias: 'Unfold Recursively',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 94 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, _args) {
+        setCollapseStateLevelsDown(foldingModel, false, Number.MAX_VALUE, this.getSelectedLines(editor));
+    }
+}
+class FoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.fold',
+            label: ( localizeWithPath('vs/editor/contrib/folding/browser/folding', 'foldAction.label', "Fold")),
+            alias: 'Fold',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: 2048  | 1024  | 92 ,
+                mac: {
+                    primary: 2048  | 512  | 92
+                },
+                weight: 100
+            },
+            metadata: {
+                description: 'Fold the content in the editor',
+                args: [
+                    {
+                        name: 'Fold editor argument',
+                        description: `Property-value pairs that can be passed through this argument:
+							* 'levels': Number of levels to fold.
+							* 'direction': If 'up', folds given number of levels up otherwise folds down.
+							* '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.
+							If no levels or direction is set, folds the region at the locations or if already collapsed, the first uncollapsed parent instead.
+						`,
+                        constraint: foldingArgumentsConstraint,
+                        schema: {
+                            'type': 'object',
+                            'properties': {
+                                'levels': {
+                                    'type': 'number',
+                                },
+                                'direction': {
+                                    'type': 'string',
+                                    'enum': ['up', 'down'],
+                                },
+                                'selectionLines': {
+                                    'type': 'array',
+                                    'items': {
+                                        'type': 'number'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                ]
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, args) {
+        const lineNumbers = this.getLineNumbers(args, editor);
+        const levels = args && args.levels;
+        const direction = args && args.direction;
+        if (typeof levels !== 'number' && typeof direction !== 'string') {
+            setCollapseStateUp(foldingModel, true, lineNumbers);
+        }
+        else {
+            if (direction === 'up') {
+                setCollapseStateLevelsUp(foldingModel, true, levels || 1, lineNumbers);
+            }
+            else {
+                setCollapseStateLevelsDown(foldingModel, true, levels || 1, lineNumbers);
+            }
+        }
+    }
+}
+class ToggleFoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.toggleFold',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'toggleFoldAction.label',
+                "Toggle Fold"
+            )),
+            alias: 'Toggle Fold',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 42 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        toggleCollapseState(foldingModel, 1, selectedLines);
+    }
+}
+class FoldRecursivelyAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.foldRecursively',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'foldRecursivelyAction.label',
+                "Fold Recursively"
+            )),
+            alias: 'Fold Recursively',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 92 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        setCollapseStateLevelsDown(foldingModel, true, Number.MAX_VALUE, selectedLines);
+    }
+}
+class FoldAllBlockCommentsAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.foldAllBlockComments',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'foldAllBlockComments.label',
+                "Fold All Block Comments"
+            )),
+            alias: 'Fold All Block Comments',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 90 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {
+        if (foldingModel.regions.hasTypes()) {
+            setCollapseStateForType(foldingModel, FoldingRangeKind.Comment.value, true);
+        }
+        else {
+            const editorModel = editor.getModel();
+            if (!editorModel) {
+                return;
+            }
+            const comments = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).comments;
+            if (comments && comments.blockCommentStartToken) {
+                const regExp = ( new RegExp('^\\s*' + escapeRegExpCharacters(comments.blockCommentStartToken)));
+                setCollapseStateForMatchingLines(foldingModel, regExp, true);
+            }
+        }
+    }
+}
+class FoldAllRegionsAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.foldAllMarkerRegions',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'foldAllMarkerRegions.label',
+                "Fold All Regions"
+            )),
+            alias: 'Fold All Regions',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 29 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {
+        if (foldingModel.regions.hasTypes()) {
+            setCollapseStateForType(foldingModel, FoldingRangeKind.Region.value, true);
+        }
+        else {
+            const editorModel = editor.getModel();
+            if (!editorModel) {
+                return;
+            }
+            const foldingRules = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).foldingRules;
+            if (foldingRules && foldingRules.markers && foldingRules.markers.start) {
+                const regExp = ( new RegExp(foldingRules.markers.start));
+                setCollapseStateForMatchingLines(foldingModel, regExp, true);
+            }
+        }
+    }
+}
+class UnfoldAllRegionsAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.unfoldAllMarkerRegions',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'unfoldAllMarkerRegions.label',
+                "Unfold All Regions"
+            )),
+            alias: 'Unfold All Regions',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 30 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor, args, languageConfigurationService) {
+        if (foldingModel.regions.hasTypes()) {
+            setCollapseStateForType(foldingModel, FoldingRangeKind.Region.value, false);
+        }
+        else {
+            const editorModel = editor.getModel();
+            if (!editorModel) {
+                return;
+            }
+            const foldingRules = languageConfigurationService.getLanguageConfiguration(editorModel.getLanguageId()).foldingRules;
+            if (foldingRules && foldingRules.markers && foldingRules.markers.start) {
+                const regExp = ( new RegExp(foldingRules.markers.start));
+                setCollapseStateForMatchingLines(foldingModel, regExp, false);
+            }
+        }
+    }
+}
+class FoldAllExceptAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.foldAllExcept',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'foldAllExcept.label',
+                "Fold All Except Selected"
+            )),
+            alias: 'Fold All Except Selected',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 88 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        setCollapseStateForRest(foldingModel, true, selectedLines);
+    }
+}
+class UnfoldAllExceptAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.unfoldAllExcept',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'unfoldAllExcept.label',
+                "Unfold All Except Selected"
+            )),
+            alias: 'Unfold All Except Selected',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 86 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        setCollapseStateForRest(foldingModel, false, selectedLines);
+    }
+}
+class FoldAllAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.foldAll',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'foldAllAction.label',
+                "Fold All"
+            )),
+            alias: 'Fold All',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 21 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, _editor) {
+        setCollapseStateLevelsDown(foldingModel, true);
+    }
+}
+class UnfoldAllAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.unfoldAll',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'unfoldAllAction.label',
+                "Unfold All"
+            )),
+            alias: 'Unfold All',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 40 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, _editor) {
+        setCollapseStateLevelsDown(foldingModel, false);
+    }
+}
+class FoldLevelAction extends FoldingAction {
+    static { this.ID_PREFIX = 'editor.foldLevel'; }
+    static { this.ID = (level) => FoldLevelAction.ID_PREFIX + level; }
+    getFoldingLevel() {
+        return parseInt(this.id.substr(FoldLevelAction.ID_PREFIX.length));
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        setCollapseStateAtLevel(foldingModel, this.getFoldingLevel(), true, this.getSelectedLines(editor));
+    }
+}
+class GotoParentFoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.gotoParentFold',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'gotoParentFold.label',
+                "Go to Parent Fold"
+            )),
+            alias: 'Go to Parent Fold',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        if (selectedLines.length > 0) {
+            const startLineNumber = getParentFoldLine(selectedLines[0], foldingModel);
+            if (startLineNumber !== null) {
+                editor.setSelection({
+                    startLineNumber: startLineNumber,
+                    startColumn: 1,
+                    endLineNumber: startLineNumber,
+                    endColumn: 1
+                });
+            }
+        }
+    }
+}
+class GotoPreviousFoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.gotoPreviousFold',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'gotoPreviousFold.label',
+                "Go to Previous Folding Range"
+            )),
+            alias: 'Go to Previous Folding Range',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        if (selectedLines.length > 0) {
+            const startLineNumber = getPreviousFoldLine(selectedLines[0], foldingModel);
+            if (startLineNumber !== null) {
+                editor.setSelection({
+                    startLineNumber: startLineNumber,
+                    startColumn: 1,
+                    endLineNumber: startLineNumber,
+                    endColumn: 1
+                });
+            }
+        }
+    }
+}
+class GotoNextFoldAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.gotoNextFold',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'gotoNextFold.label',
+                "Go to Next Folding Range"
+            )),
+            alias: 'Go to Next Folding Range',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const selectedLines = this.getSelectedLines(editor);
+        if (selectedLines.length > 0) {
+            const startLineNumber = getNextFoldLine(selectedLines[0], foldingModel);
+            if (startLineNumber !== null) {
+                editor.setSelection({
+                    startLineNumber: startLineNumber,
+                    startColumn: 1,
+                    endLineNumber: startLineNumber,
+                    endColumn: 1
+                });
+            }
+        }
+    }
+}
+class FoldRangeFromSelectionAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.createFoldingRangeFromSelection',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'createManualFoldRange.label',
+                "Create Folding Range from Selection"
+            )),
+            alias: 'Create Folding Range from Selection',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 87 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(_foldingController, foldingModel, editor) {
+        const collapseRanges = [];
+        const selections = editor.getSelections();
+        if (selections) {
+            for (const selection of selections) {
+                let endLineNumber = selection.endLineNumber;
+                if (selection.endColumn === 1) {
+                    --endLineNumber;
+                }
+                if (endLineNumber > selection.startLineNumber) {
+                    collapseRanges.push({
+                        startLineNumber: selection.startLineNumber,
+                        endLineNumber: endLineNumber,
+                        type: undefined,
+                        isCollapsed: true,
+                        source: 1
+                    });
+                    editor.setSelection({
+                        startLineNumber: selection.startLineNumber,
+                        startColumn: 1,
+                        endLineNumber: selection.startLineNumber,
+                        endColumn: 1
+                    });
+                }
+            }
+            if (collapseRanges.length > 0) {
+                collapseRanges.sort((a, b) => {
+                    return a.startLineNumber - b.startLineNumber;
+                });
+                const newRanges = FoldingRegions.sanitizeAndMerge(foldingModel.regions, collapseRanges, editor.getModel()?.getLineCount());
+                foldingModel.updatePost(FoldingRegions.fromFoldRanges(newRanges));
+            }
+        }
+    }
+}
+class RemoveFoldRangeFromSelectionAction extends FoldingAction {
+    constructor() {
+        super({
+            id: 'editor.removeManualFoldingRanges',
+            label: ( localizeWithPath(
+                'vs/editor/contrib/folding/browser/folding',
+                'removeManualFoldingRanges.label',
+                "Remove Manual Folding Ranges"
+            )),
+            alias: 'Remove Manual Folding Ranges',
+            precondition: CONTEXT_FOLDING_ENABLED,
+            kbOpts: {
+                kbExpr: EditorContextKeys.editorTextFocus,
+                primary: KeyChord(2048  | 41 , 2048  | 89 ),
+                weight: 100
+            }
+        });
+    }
+    invoke(foldingController, foldingModel, editor) {
+        const selections = editor.getSelections();
+        if (selections) {
+            const ranges = [];
+            for (const selection of selections) {
+                const { startLineNumber, endLineNumber } = selection;
+                ranges.push(endLineNumber >= startLineNumber ? { startLineNumber, endLineNumber } : { endLineNumber, startLineNumber });
+            }
+            foldingModel.removeManualRanges(ranges);
+            foldingController.triggerFoldingModelChanged();
+        }
+    }
+}
+registerEditorContribution(FoldingController.ID, FoldingController, 0 );
+registerEditorAction(UnfoldAction);
+registerEditorAction(UnFoldRecursivelyAction);
+registerEditorAction(FoldAction);
+registerEditorAction(FoldRecursivelyAction);
+registerEditorAction(FoldAllAction);
+registerEditorAction(UnfoldAllAction);
+registerEditorAction(FoldAllBlockCommentsAction);
+registerEditorAction(FoldAllRegionsAction);
+registerEditorAction(UnfoldAllRegionsAction);
+registerEditorAction(FoldAllExceptAction);
+registerEditorAction(UnfoldAllExceptAction);
+registerEditorAction(ToggleFoldAction);
+registerEditorAction(GotoParentFoldAction);
+registerEditorAction(GotoPreviousFoldAction);
+registerEditorAction(GotoNextFoldAction);
+registerEditorAction(FoldRangeFromSelectionAction);
+registerEditorAction(RemoveFoldRangeFromSelectionAction);
+for (let i = 1; i <= 7; i++) {
+    registerInstantiatedEditorAction(( new FoldLevelAction({
+        id: FoldLevelAction.ID(i),
+        label: ( localizeWithPath(
+            'vs/editor/contrib/folding/browser/folding',
+            'foldLevelAction.label',
+            "Fold Level {0}",
+            i
+        )),
+        alias: `Fold Level ${i}`,
+        precondition: CONTEXT_FOLDING_ENABLED,
+        kbOpts: {
+            kbExpr: EditorContextKeys.editorTextFocus,
+            primary: KeyChord(2048  | 41 , 2048  | (21  + i)),
+            weight: 100
+        }
+    })));
+}
+CommandsRegistry.registerCommand('_executeFoldingRangeProvider', async function (accessor, ...args) {
+    const [resource] = args;
+    if (!(resource instanceof URI)) {
+        throw illegalArgument();
+    }
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(resource);
+    if (!model) {
+        throw illegalArgument();
+    }
+    const configurationService = accessor.get(IConfigurationService);
+    if (!configurationService.getValue('editor.folding', { resource })) {
+        return [];
+    }
+    const languageConfigurationService = accessor.get(ILanguageConfigurationService);
+    const strategy = configurationService.getValue('editor.foldingStrategy', { resource });
+    const foldingLimitReporter = {
+        get limit() {
+            return configurationService.getValue('editor.foldingMaximumRegions', { resource });
+        },
+        update: (computed, limited) => { }
+    };
+    const indentRangeProvider = ( new IndentRangeProvider(model, languageConfigurationService, foldingLimitReporter));
+    let rangeProvider = indentRangeProvider;
+    if (strategy !== 'indentation') {
+        const providers = FoldingController.getFoldingRangeProviders(languageFeaturesService, model);
+        if (providers.length) {
+            rangeProvider = ( new SyntaxRangeProvider(model, providers, () => { }, foldingLimitReporter, indentRangeProvider));
+        }
+    }
+    const ranges = await rangeProvider.compute(CancellationToken.None);
+    const result = [];
+    try {
+        if (ranges) {
+            for (let i = 0; i < ranges.length; i++) {
+                const type = ranges.getType(i);
+                result.push({ start: ranges.getStartLineNumber(i), end: ranges.getEndLineNumber(i), kind: type ? FoldingRangeKind.fromValue(type) : undefined });
+            }
+        }
+        return result;
+    }
+    finally {
+        rangeProvider.dispose();
+    }
+});
+export { FoldingController, RangesLimitReporter };