@easyv/biz-components 0.0.52-beta.1 → 0.0.52-beta.2

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/folding/browser/folding.es.js

@@ -1,1258 +0,0 @@
-var _a;
-import { Delayer, RunOnceScheduler, createCancelablePromise } from "../../../../base/common/async.es.js";
-import { CancellationToken } from "../../../../base/common/cancellation.es.js";
-import { onUnexpectedError, illegalArgument } from "../../../../base/common/errors.es.js";
-import { KeyChord } from "../../../../base/common/keyCodes.es.js";
-import { Disposable, DisposableStore } from "../../../../base/common/lifecycle.es.js";
-import { escapeRegExpCharacters } from "../../../../base/common/strings.es.js";
-import { isUndefined, isObject, isNumber, isString } from "../../../../base/common/types.es.js";
-/* empty css               */
-import { StableEditorScrollState } from "../../../browser/stableEditorScroll.es.js";
-import { registerEditorContribution, registerEditorAction, registerInstantiatedEditorAction, EditorAction } from "../../../browser/editorExtensions.es.js";
-import { EditorContextKeys } from "../../../common/editorContextKeys.es.js";
-import { FoldingRangeKind } from "../../../common/languages.es.js";
-import { ILanguageConfigurationService } from "../../../common/languages/languageConfigurationRegistry.es.js";
-import { FoldingModel, setCollapseStateAtLevel, setCollapseStateLevelsUp, setCollapseStateLevelsDown, setCollapseStateUp, toggleCollapseState, setCollapseStateForType, setCollapseStateForMatchingLines, setCollapseStateForRest, getParentFoldLine, getPreviousFoldLine, getNextFoldLine } from "./foldingModel.es.js";
-import { HiddenRangeModel } from "./hiddenRangeModel.es.js";
-import { IndentRangeProvider } from "./indentRangeProvider.es.js";
-import { localize } from "../../../../nls.es.js";
-import { RawContextKey, IContextKeyService } from "../../../../platform/contextkey/common/contextkey.es.js";
-import { FoldingDecorationProvider } from "./foldingDecorations.es.js";
-import { FoldingRegions } from "./foldingRanges.es.js";
-import { SyntaxRangeProvider } from "./syntaxRangeProvider.es.js";
-import { INotificationService } from "../../../../platform/notification/common/notification.es.js";
-import { ILanguageFeatureDebounceService } from "../../../common/services/languageFeatureDebounce.es.js";
-import { StopWatch } from "../../../../base/common/stopwatch.es.js";
-import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.es.js";
-import { Emitter } from "../../../../base/common/event.es.js";
-import { CommandsRegistry } from "../../../../platform/commands/common/commands.es.js";
-import { URI } from "../../../../base/common/uri.es.js";
-import { IModelService } from "../../../common/services/model.es.js";
-import { IConfigurationService } from "../../../../platform/configuration/common/configuration.es.js";
-var __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 = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-var FoldingController_1;
-const CONTEXT_FOLDING_ENABLED = new RawContextKey("foldingEnabled", false);
-let FoldingController = (_a = class extends Disposable {
-  static get(editor) {
-    return editor.getContribution(FoldingController_1.ID);
-  }
-  static getFoldingRangeProviders(languageFeaturesService, model) {
-    var _a2;
-    const foldingRangeProviders = languageFeaturesService.foldingRangeProvider.ordered(model);
-    return ((_a2 = FoldingController_1._foldingRangeSelector) == null ? void 0 : _a2.call(FoldingController_1, foldingRangeProviders, model)) ?? 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(
-      111
-      /* 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(
-        111
-        /* EditorOption.showFoldingControls */
-      ) || e.hasChanged(
-        45
-        /* EditorOption.foldingHighlight */
-      )) {
-        const options2 = this.editor.getOptions();
-        this.foldingDecorationProvider.showFoldingControls = options2.get(
-          111
-          /* EditorOption.showFoldingControls */
-        );
-        this.foldingDecorationProvider.showFoldingHighlights = options2.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) {
-      const collapsedRegions = this.foldingModel.getMemento();
-      const provider = this.rangeProvider ? this.rangeProvider.id : void 0;
-      return { collapsedRegions, lineCount: model.getLineCount(), provider, foldedImports: this._currentModelHasFoldedImports };
-    }
-    return void 0;
-  }
-  /**
-   * 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()) {
-      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: () => {
-        var _a2, _b;
-        if (this.foldingRegionPromise) {
-          this.foldingRegionPromise.cancel();
-          this.foldingRegionPromise = null;
-        }
-        (_a2 = this.updateScheduler) == null ? void 0 : _a2.cancel();
-        this.updateScheduler = null;
-        this.foldingModel = null;
-        this.foldingModelPromise = null;
-        this.hiddenRangeModel = null;
-        this.cursorChangedScheduler = null;
-        (_b = this.rangeProvider) == null ? void 0 : _b.dispose();
-        this.rangeProvider = null;
-      }
-    });
-    this.triggerFoldingModelChanged();
-  }
-  onFoldingStrategyChanged() {
-    var _a2;
-    (_a2 = this.rangeProvider) == null ? void 0 : _a2.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) {
-    var _a2;
-    (_a2 = this.hiddenRangeModel) == null ? void 0 : _a2.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();
-            foldingModel.update(foldingRanges, toSelectedLines(selections));
-            scrollState == null ? void 0 : scrollState.restore(this.editor);
-            const newValue = this.updateDebounceInfo.update(foldingModel.textModel, sw.elapsed());
-            if (this.updateScheduler) {
-              this.updateScheduler.defaultDelay = newValue;
-            }
-          }
-          return foldingModel;
-        });
-      }).then(void 0, (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((foldingModel2) => {
-      if (foldingModel2) {
-        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(...foldingModel2.getAllRegionsAtLine(lineNumber, (r) => r.isCollapsed && lineNumber > r.startLineNumber));
-            }
-          }
-          if (toToggle.length) {
-            foldingModel2.toggleCollapseState(toToggle);
-            this.reveal(selections[0].getPosition());
-          }
-        }
-      }
-    }).then(void 0, 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
-      /* ScrollType.Smooth */
-    );
-  }
-}, FoldingController_1 = _a, _a.ID = "editor.contrib.folding", _a);
-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._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);
-    }
-    return this.getSelectedLines(editor);
-  }
-  run(_accessor, _editor) {
-  }
-}
-function toSelectedLines(selections) {
-  if (!selections || selections.length === 0) {
-    return {
-      startsInside: () => false
-    };
-  }
-  return {
-    startsInside(startLine, endLine) {
-      for (const s of selections) {
-        const line = s.startLineNumber;
-        if (line >= startLine && line <= endLine) {
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-}
-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: localize("unfoldAction.label", "Unfold"),
-      alias: "Unfold",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: 2048 | 1024 | 94,
-        mac: {
-          primary: 2048 | 512 | 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: localize("unFoldRecursivelyAction.label", "Unfold Recursively"),
-      alias: "Unfold Recursively",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 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: localize("foldAction.label", "Fold"),
-      alias: "Fold",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: 2048 | 1024 | 92,
-        mac: {
-          primary: 2048 | 512 | 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") {
-      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: localize("toggleFoldAction.label", "Toggle Fold"),
-      alias: "Toggle Fold",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 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: localize("foldRecursivelyAction.label", "Fold Recursively"),
-      alias: "Fold Recursively",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 92
-          /* KeyCode.BracketLeft */
-        ),
-        weight: 100
-        /* KeybindingWeight.EditorContrib */
-      }
-    });
-  }
-  invoke(_foldingController, foldingModel, editor) {
-    const selectedLines = this.getSelectedLines(editor);
-    setCollapseStateLevelsDown(foldingModel, true, Number.MAX_VALUE, selectedLines);
-  }
-}
-class ToggleFoldRecursivelyAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.toggleFoldRecursively",
-      label: localize("toggleFoldRecursivelyAction.label", "Toggle Fold Recursively"),
-      alias: "Toggle Fold Recursively",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 1024 | 42
-          /* KeyCode.KeyL */
-        ),
-        weight: 100
-        /* KeybindingWeight.EditorContrib */
-      }
-    });
-  }
-  invoke(_foldingController, foldingModel, editor) {
-    const selectedLines = this.getSelectedLines(editor);
-    toggleCollapseState(foldingModel, Number.MAX_VALUE, selectedLines);
-  }
-}
-class FoldAllBlockCommentsAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.foldAllBlockComments",
-      label: localize("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
-          /* 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: localize("foldAllMarkerRegions.label", "Fold All Regions"),
-      alias: "Fold All Regions",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 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: localize("unfoldAllMarkerRegions.label", "Unfold All Regions"),
-      alias: "Unfold All Regions",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 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: localize("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
-          /* 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: localize("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
-          /* 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: localize("foldAllAction.label", "Fold All"),
-      alias: "Fold All",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 21
-          /* KeyCode.Digit0 */
-        ),
-        weight: 100
-        /* KeybindingWeight.EditorContrib */
-      }
-    });
-  }
-  invoke(_foldingController, foldingModel, _editor) {
-    setCollapseStateLevelsDown(foldingModel, true);
-  }
-}
-class UnfoldAllAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.unfoldAll",
-      label: localize("unfoldAllAction.label", "Unfold All"),
-      alias: "Unfold All",
-      precondition: CONTEXT_FOLDING_ENABLED,
-      kbOpts: {
-        kbExpr: EditorContextKeys.editorTextFocus,
-        primary: KeyChord(
-          2048 | 41,
-          2048 | 40
-          /* KeyCode.KeyJ */
-        ),
-        weight: 100
-        /* KeybindingWeight.EditorContrib */
-      }
-    });
-  }
-  invoke(_foldingController, foldingModel, _editor) {
-    setCollapseStateLevelsDown(foldingModel, false);
-  }
-}
-const _FoldLevelAction = 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;
-let FoldLevelAction = _FoldLevelAction;
-class GotoParentFoldAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.gotoParentFold",
-      label: 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,
-          startColumn: 1,
-          endLineNumber: startLineNumber,
-          endColumn: 1
-        });
-      }
-    }
-  }
-}
-class GotoPreviousFoldAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.gotoPreviousFold",
-      label: 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,
-          startColumn: 1,
-          endLineNumber: startLineNumber,
-          endColumn: 1
-        });
-      }
-    }
-  }
-}
-class GotoNextFoldAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.gotoNextFold",
-      label: 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,
-          startColumn: 1,
-          endLineNumber: startLineNumber,
-          endColumn: 1
-        });
-      }
-    }
-  }
-}
-class FoldRangeFromSelectionAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.createFoldingRangeFromSelection",
-      label: 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 | 41,
-          2048 | 87
-          /* KeyCode.Comma */
-        ),
-        weight: 100
-        /* KeybindingWeight.EditorContrib */
-      }
-    });
-  }
-  invoke(_foldingController, foldingModel, editor) {
-    var _a2;
-    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,
-            type: void 0,
-            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, (_a2 = editor.getModel()) == null ? void 0 : _a2.getLineCount());
-        foldingModel.updatePost(FoldingRegions.fromFoldRanges(newRanges));
-      }
-    }
-  }
-}
-class RemoveFoldRangeFromSelectionAction extends FoldingAction {
-  constructor() {
-    super({
-      id: "editor.removeManualFoldingRanges",
-      label: localize("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
-          /* 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 */
-);
-registerEditorAction(UnfoldAction);
-registerEditorAction(UnFoldRecursivelyAction);
-registerEditorAction(FoldAction);
-registerEditorAction(FoldRecursivelyAction);
-registerEditorAction(ToggleFoldRecursivelyAction);
-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: localize("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
-      /* 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) : void 0 });
-      }
-    }
-    return result;
-  } finally {
-    rangeProvider.dispose();
-  }
-});
-export {
-  FoldingController,
-  RangesLimitReporter,
-  toSelectedLines
-};
-//# sourceMappingURL=folding.es.js.map