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

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

@@ -0,0 +1,1258 @@
+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