claude-flow-novice 2.0.3 → 2.0.5

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/folding/browser/folding.js

@@ -1,1093 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    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;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-var FoldingController_1;
-import { createCancelablePromise, Delayer, RunOnceScheduler } from '../../../../base/common/async.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
-import { illegalArgument, onUnexpectedError } 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 * as types from '../../../../base/common/types.js';
-import './folding.css';
-import { StableEditorScrollState } from '../../../browser/stableEditorScroll.js';
-import { EditorAction, registerEditorAction, registerEditorContribution, registerInstantiatedEditorAction } 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, getNextFoldLine, getParentFoldLine as getParentFoldLine, getPreviousFoldLine, setCollapseStateAtLevel, setCollapseStateForMatchingLines, setCollapseStateForRest, setCollapseStateForType, setCollapseStateLevelsDown, setCollapseStateLevelsUp, setCollapseStateUp, toggleCollapseState } from './foldingModel.js';
-import { HiddenRangeModel } from './hiddenRangeModel.js';
-import { IndentRangeProvider } from './indentRangeProvider.js';
-import * as nls from '../../../../nls.js';
-import { IContextKeyService, RawContextKey } 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';
-const CONTEXT_FOLDING_ENABLED = new RawContextKey('foldingEnabled', false);
-let FoldingController = FoldingController_1 = class FoldingController extends Disposable {
-    static get(editor) {
-        return editor.getContribution(FoldingController_1.ID);
-    }
-    static getFoldingRangeProviders(languageFeaturesService, model) {
-        var _a, _b;
-        const foldingRangeProviders = languageFeaturesService.foldingRangeProvider.ordered(model);
-        return (_b = ((_a = FoldingController_1._foldingRangeSelector) === null || _a === void 0 ? void 0 : _a.call(FoldingController_1, foldingRangeProviders, model))) !== null && _b !== void 0 ? _b : foldingRangeProviders;
-    }
-    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 /* EditorOption.folding */);
-        this._useFoldingProviders = options.get(44 /* EditorOption.foldingStrategy */) !== 'indentation';
-        this._unfoldOnClickAfterEndOfLine = options.get(48 /* EditorOption.unfoldOnClickAfterEndOfLine */);
-        this._restoringViewState = false;
-        this._currentModelHasFoldedImports = false;
-        this._foldingImportsByDefault = options.get(46 /* EditorOption.foldingImportsByDefault */);
-        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 /* EditorOption.showFoldingControls */);
-        this.foldingDecorationProvider.showFoldingHighlights = options.get(45 /* EditorOption.foldingHighlight */);
-        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 /* EditorOption.folding */)) {
-                this._isEnabled = this.editor.getOptions().get(43 /* EditorOption.folding */);
-                this.foldingEnabled.set(this._isEnabled);
-                this.onModelChanged();
-            }
-            if (e.hasChanged(47 /* EditorOption.foldingMaximumRegions */)) {
-                this.onModelChanged();
-            }
-            if (e.hasChanged(109 /* EditorOption.showFoldingControls */) || e.hasChanged(45 /* EditorOption.foldingHighlight */)) {
-                const options = this.editor.getOptions();
-                this.foldingDecorationProvider.showFoldingControls = options.get(109 /* EditorOption.showFoldingControls */);
-                this.foldingDecorationProvider.showFoldingHighlights = options.get(45 /* EditorOption.foldingHighlight */);
-                this.triggerFoldingModelChanged();
-            }
-            if (e.hasChanged(44 /* EditorOption.foldingStrategy */)) {
-                this._useFoldingProviders = this.editor.getOptions().get(44 /* EditorOption.foldingStrategy */) !== 'indentation';
-                this.onFoldingStrategyChanged();
-            }
-            if (e.hasChanged(48 /* EditorOption.unfoldOnClickAfterEndOfLine */)) {
-                this._unfoldOnClickAfterEndOfLine = this.editor.getOptions().get(48 /* EditorOption.unfoldOnClickAfterEndOfLine */);
-            }
-            if (e.hasChanged(46 /* EditorOption.foldingImportsByDefault */)) {
-                this._foldingImportsByDefault = this.editor.getOptions().get(46 /* EditorOption.foldingImportsByDefault */);
-            }
-        }));
-        this.onModelChanged();
-    }
-    /**
-     * Store view state.
-     */
-    saveViewState() {
-        const model = this.editor.getModel();
-        if (!model || !this._isEnabled || model.isTooLargeForTokenization()) {
-            return {};
-        }
-        if (this.foldingModel) { // disposed ?
-            const collapsedRegions = this.foldingModel.getMemento();
-            const provider = this.rangeProvider ? this.rangeProvider.id : undefined;
-            return { collapsedRegions, lineCount: model.getLineCount(), provider, foldedImports: this._currentModelHasFoldedImports };
-        }
-        return undefined;
-    }
-    /**
-     * Restore view state.
-     */
-    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()) {
-            // huge files get no view model, so they cannot support hidden areas
-            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())); // covers model language changes as well
-        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: () => {
-                var _a, _b;
-                if (this.foldingRegionPromise) {
-                    this.foldingRegionPromise.cancel();
-                    this.foldingRegionPromise = null;
-                }
-                (_a = this.updateScheduler) === null || _a === void 0 ? void 0 : _a.cancel();
-                this.updateScheduler = null;
-                this.foldingModel = null;
-                this.foldingModelPromise = null;
-                this.hiddenRangeModel = null;
-                this.cursorChangedScheduler = null;
-                (_b = this.rangeProvider) === null || _b === void 0 ? void 0 : _b.dispose();
-                this.rangeProvider = null;
-            }
-        });
-        this.triggerFoldingModelChanged();
-    }
-    onFoldingStrategyChanged() {
-        var _a;
-        (_a = this.rangeProvider) === null || _a === void 0 ? void 0 : _a.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; // fallback
-        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) {
-        var _a;
-        (_a = this.hiddenRangeModel) === null || _a === void 0 ? void 0 : _a.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) { // null if editor has been disposed, or folding turned off
-                    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) { // new request or cancelled in the meantime?
-                        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;
-                            }
-                        }
-                        // some cursors might have moved into hidden regions, make sure they are in expanded regions
-                        const selections = this.editor.getSelections();
-                        const selectionLineNumbers = selections ? selections.map(s => s.startLineNumber) : [];
-                        foldingModel.update(foldingRanges, selectionLineNumbers);
-                        scrollState === null || scrollState === void 0 ? void 0 : scrollState.restore(this.editor);
-                        // update debounce info
-                        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 /* MouseTargetType.GUTTER_LINE_DECORATIONS */: {
-                const data = e.target.detail;
-                const offsetLeftInGutter = e.target.element.offsetLeft;
-                const gutterOffsetX = data.offsetX - offsetLeftInGutter;
-                // const gutterOffsetX = data.offsetX - data.glyphMarginWidth - data.lineNumbersWidth - data.glyphMarginLeft;
-                // TODO@joao TODO@alex TODO@martin this is such that we don't collide with dirty diff
-                if (gutterOffsetX < 4) { // the whitespace between the border and the real folding icon border is 4px
-                    return;
-                }
-                iconClicked = true;
-                break;
-            }
-            case 7 /* MouseTargetType.CONTENT_EMPTY */: {
-                if (this._unfoldOnClickAfterEndOfLine && this.hiddenRangeModel.hasRanges()) {
-                    const data = e.target.detail;
-                    if (!data.isAfterLines) {
-                        break;
-                    }
-                }
-                return;
-            }
-            case 6 /* MouseTargetType.CONTENT_TEXT */: {
-                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 /* MouseTargetType.GUTTER_LINE_DECORATIONS */) {
-                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 any surrounding regions are folded, unfold those. Otherwise, fold all surrounding
-                    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);
-                            }
-                        }
-                    }
-                    // when recursive, first only collapse all children. If all are already folded or there are no children, also fold parent.
-                    if (isCollapsed || !recursive || toToggle.length === 0) {
-                        toToggle.push(region);
-                    }
-                }
-                foldingModel.toggleCollapseState(toToggle);
-                this.reveal({ lineNumber, column: 1 });
-            }
-        }
-    }
-    reveal(position) {
-        this.editor.revealPositionInCenterIfOutsideViewport(position, 0 /* ScrollType.Smooth */);
-    }
-};
-FoldingController.ID = 'editor.contrib.folding';
-FoldingController = FoldingController_1 = __decorate([
-    __param(1, IContextKeyService),
-    __param(2, ILanguageConfigurationService),
-    __param(3, INotificationService),
-    __param(4, ILanguageFeatureDebounceService),
-    __param(5, ILanguageFeaturesService)
-], FoldingController);
-export { FoldingController };
-export class RangesLimitReporter {
-    constructor(editor) {
-        this.editor = editor;
-        this._onDidChange = new Emitter();
-        this._computed = 0;
-        this._limited = false;
-    }
-    get limit() {
-        return this.editor.getOptions().get(47 /* EditorOption.foldingMaximumRegions */);
-    }
-    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); // to 0-bases line numbers
-        }
-        return this.getSelectedLines(editor);
-    }
-    run(_accessor, _editor) {
-    }
-}
-function foldingArgumentsConstraint(args) {
-    if (!types.isUndefined(args)) {
-        if (!types.isObject(args)) {
-            return false;
-        }
-        const foldingArgs = args;
-        if (!types.isUndefined(foldingArgs.levels) && !types.isNumber(foldingArgs.levels)) {
-            return false;
-        }
-        if (!types.isUndefined(foldingArgs.direction) && !types.isString(foldingArgs.direction)) {
-            return false;
-        }
-        if (!types.isUndefined(foldingArgs.selectionLines) && (!Array.isArray(foldingArgs.selectionLines) || !foldingArgs.selectionLines.every(types.isNumber))) {
-            return false;
-        }
-    }
-    return true;
-}
-class UnfoldAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.unfold',
-            label: nls.localize('unfoldAction.label', "Unfold"),
-            alias: 'Unfold',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 94 /* KeyCode.BracketRight */,
-                mac: {
-                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 94 /* KeyCode.BracketRight */
-                },
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            },
-            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: nls.localize('unFoldRecursivelyAction.label', "Unfold Recursively"),
-            alias: 'Unfold Recursively',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 94 /* KeyCode.BracketRight */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, editor, _args) {
-        setCollapseStateLevelsDown(foldingModel, false, Number.MAX_VALUE, this.getSelectedLines(editor));
-    }
-}
-class FoldAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.fold',
-            label: nls.localize('foldAction.label', "Fold"),
-            alias: 'Fold',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: 2048 /* KeyMod.CtrlCmd */ | 1024 /* KeyMod.Shift */ | 92 /* KeyCode.BracketLeft */,
-                mac: {
-                    primary: 2048 /* KeyMod.CtrlCmd */ | 512 /* KeyMod.Alt */ | 92 /* KeyCode.BracketLeft */
-                },
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            },
-            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') {
-            // fold the region at the location or if already collapsed, the first uncollapsed parent instead.
-            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: nls.localize('toggleFoldAction.label', "Toggle Fold"),
-            alias: 'Toggle Fold',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 42 /* KeyCode.KeyL */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, editor) {
-        const selectedLines = this.getSelectedLines(editor);
-        toggleCollapseState(foldingModel, 1, selectedLines);
-    }
-}
-class FoldRecursivelyAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.foldRecursively',
-            label: nls.localize('foldRecursivelyAction.label', "Fold Recursively"),
-            alias: 'Fold Recursively',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 92 /* KeyCode.BracketLeft */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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: nls.localize('foldAllBlockComments.label', "Fold All Block Comments"),
-            alias: 'Fold All Block Comments',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 90 /* KeyCode.Slash */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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: nls.localize('foldAllMarkerRegions.label', "Fold All Regions"),
-            alias: 'Fold All Regions',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 29 /* KeyCode.Digit8 */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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: nls.localize('unfoldAllMarkerRegions.label', "Unfold All Regions"),
-            alias: 'Unfold All Regions',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 30 /* KeyCode.Digit9 */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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: nls.localize('foldAllExcept.label', "Fold All Except Selected"),
-            alias: 'Fold All Except Selected',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 88 /* KeyCode.Minus */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, editor) {
-        const selectedLines = this.getSelectedLines(editor);
-        setCollapseStateForRest(foldingModel, true, selectedLines);
-    }
-}
-class UnfoldAllExceptAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.unfoldAllExcept',
-            label: nls.localize('unfoldAllExcept.label', "Unfold All Except Selected"),
-            alias: 'Unfold All Except Selected',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 86 /* KeyCode.Equal */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, editor) {
-        const selectedLines = this.getSelectedLines(editor);
-        setCollapseStateForRest(foldingModel, false, selectedLines);
-    }
-}
-class FoldAllAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.foldAll',
-            label: nls.localize('foldAllAction.label', "Fold All"),
-            alias: 'Fold All',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 21 /* KeyCode.Digit0 */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, _editor) {
-        setCollapseStateLevelsDown(foldingModel, true);
-    }
-}
-class UnfoldAllAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.unfoldAll',
-            label: nls.localize('unfoldAllAction.label', "Unfold All"),
-            alias: 'Unfold All',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 40 /* KeyCode.KeyJ */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, _editor) {
-        setCollapseStateLevelsDown(foldingModel, false);
-    }
-}
-class FoldLevelAction extends FoldingAction {
-    getFoldingLevel() {
-        return parseInt(this.id.substr(FoldLevelAction.ID_PREFIX.length));
-    }
-    invoke(_foldingController, foldingModel, editor) {
-        setCollapseStateAtLevel(foldingModel, this.getFoldingLevel(), true, this.getSelectedLines(editor));
-    }
-}
-FoldLevelAction.ID_PREFIX = 'editor.foldLevel';
-FoldLevelAction.ID = (level) => FoldLevelAction.ID_PREFIX + level;
-/** Action to go to the parent fold of current line */
-class GotoParentFoldAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.gotoParentFold',
-            label: nls.localize('gotoParentFold.label', "Go to Parent Fold"),
-            alias: 'Go to Parent Fold',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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
-                });
-            }
-        }
-    }
-}
-/** Action to go to the previous fold of current line */
-class GotoPreviousFoldAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.gotoPreviousFold',
-            label: nls.localize('gotoPreviousFold.label', "Go to Previous Folding Range"),
-            alias: 'Go to Previous Folding Range',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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
-                });
-            }
-        }
-    }
-}
-/** Action to go to the next fold of current line */
-class GotoNextFoldAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.gotoNextFold',
-            label: nls.localize('gotoNextFold.label', "Go to Next Folding Range"),
-            alias: 'Go to Next Folding Range',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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: nls.localize('createManualFoldRange.label', "Create Folding Range from Selection"),
-            alias: 'Create Folding Range from Selection',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 87 /* KeyCode.Comma */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    invoke(_foldingController, foldingModel, editor) {
-        var _a;
-        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 /* FoldSource.userDefined */
-                    });
-                    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, (_a = editor.getModel()) === null || _a === void 0 ? void 0 : _a.getLineCount());
-                foldingModel.updatePost(FoldingRegions.fromFoldRanges(newRanges));
-            }
-        }
-    }
-}
-class RemoveFoldRangeFromSelectionAction extends FoldingAction {
-    constructor() {
-        super({
-            id: 'editor.removeManualFoldingRanges',
-            label: nls.localize('removeManualFoldingRanges.label', "Remove Manual Folding Ranges"),
-            alias: 'Remove Manual Folding Ranges',
-            precondition: CONTEXT_FOLDING_ENABLED,
-            kbOpts: {
-                kbExpr: EditorContextKeys.editorTextFocus,
-                primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */),
-                weight: 100 /* KeybindingWeight.EditorContrib */
-            }
-        });
-    }
-    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 /* EditorContributionInstantiation.Eager */); // eager because it uses `saveViewState`/`restoreViewState`
-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: nls.localize('foldLevelAction.label', "Fold Level {0}", i),
-        alias: `Fold Level ${i}`,
-        precondition: CONTEXT_FOLDING_ENABLED,
-        kbOpts: {
-            kbExpr: EditorContextKeys.editorTextFocus,
-            primary: KeyChord(2048 /* KeyMod.CtrlCmd */ | 41 /* KeyCode.KeyK */, 2048 /* KeyMod.CtrlCmd */ | (21 /* KeyCode.Digit0 */ + i)),
-            weight: 100 /* KeybindingWeight.EditorContrib */
-        }
-    }));
-}
-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();
-    }
-});