@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/gotoSymbol/browser/goToCommands.es.js

@@ -0,0 +1,709 @@
+var _a, _b, _c, _d, _e, _f, _g, _h;
+import { alert } from "../../../../base/browser/ui/aria/aria.es.js";
+import { raceCancellation, createCancelablePromise } from "../../../../base/common/async.es.js";
+import { KeyChord } from "../../../../base/common/keyCodes.es.js";
+import { assertType } from "../../../../base/common/types.es.js";
+import { URI } from "../../../../base/common/uri.es.js";
+import { EditorStateCancellationTokenSource } from "../../editorState/browser/editorState.es.js";
+import { isCodeEditor } from "../../../browser/editorBrowser.es.js";
+import { EditorAction2 } from "../../../browser/editorExtensions.es.js";
+import { ICodeEditorService } from "../../../browser/services/codeEditorService.es.js";
+import { EmbeddedCodeEditorWidget } from "../../../browser/widget/codeEditor/embeddedCodeEditorWidget.es.js";
+import { Position } from "../../../common/core/position.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { EditorContextKeys } from "../../../common/editorContextKeys.es.js";
+import { isLocationLink } from "../../../common/languages.es.js";
+import { ReferencesController } from "./peek/referencesController.es.js";
+import { ReferencesModel } from "./referencesModel.es.js";
+import { ISymbolNavigationService } from "./symbolNavigation.es.js";
+import { MessageController } from "../../message/browser/messageController.es.js";
+import { PeekContext } from "../../peekView/browser/peekView.es.js";
+import { localize, localize2 } from "../../../../nls.es.js";
+import { MenuRegistry, MenuId, registerAction2 } from "../../../../platform/actions/common/actions.es.js";
+import { CommandsRegistry, ICommandService } from "../../../../platform/commands/common/commands.es.js";
+import { ContextKeyExpr } from "../../../../platform/contextkey/common/contextkey.es.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.es.js";
+import { INotificationService } from "../../../../platform/notification/common/notification.es.js";
+import { IEditorProgressService } from "../../../../platform/progress/common/progress.es.js";
+import { getReferencesAtPosition, getDefinitionsAtPosition, getDeclarationsAtPosition, getTypeDefinitionsAtPosition, getImplementationsAtPosition } from "./goToSymbol.es.js";
+import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.es.js";
+import { Iterable } from "../../../../base/common/iterator.es.js";
+import { IsWebContext } from "../../../../platform/contextkey/common/contextkeys.es.js";
+MenuRegistry.appendMenuItem(MenuId.EditorContext, {
+  submenu: MenuId.EditorContextPeek,
+  title: localize("peek.submenu", "Peek"),
+  group: "navigation",
+  order: 100
+});
+class SymbolNavigationAnchor {
+  static is(thing) {
+    if (!thing || typeof thing !== "object") {
+      return false;
+    }
+    if (thing instanceof SymbolNavigationAnchor) {
+      return true;
+    }
+    if (Position.isIPosition(thing.position) && thing.model) {
+      return true;
+    }
+    return false;
+  }
+  constructor(model, position) {
+    this.model = model;
+    this.position = position;
+  }
+}
+const _SymbolNavigationAction = class _SymbolNavigationAction extends EditorAction2 {
+  static all() {
+    return _SymbolNavigationAction._allSymbolNavigationCommands.values();
+  }
+  static _patchConfig(opts) {
+    const result = { ...opts, f1: true };
+    if (result.menu) {
+      for (const item of Iterable.wrap(result.menu)) {
+        if (item.id === MenuId.EditorContext || item.id === MenuId.EditorContextPeek) {
+          item.when = ContextKeyExpr.and(opts.precondition, item.when);
+        }
+      }
+    }
+    return result;
+  }
+  constructor(configuration, opts) {
+    super(_SymbolNavigationAction._patchConfig(opts));
+    this.configuration = configuration;
+    _SymbolNavigationAction._allSymbolNavigationCommands.set(opts.id, this);
+  }
+  runEditorCommand(accessor, editor, arg, range) {
+    if (!editor.hasModel()) {
+      return Promise.resolve(void 0);
+    }
+    const notificationService = accessor.get(INotificationService);
+    const editorService = accessor.get(ICodeEditorService);
+    const progressService = accessor.get(IEditorProgressService);
+    const symbolNavService = accessor.get(ISymbolNavigationService);
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const instaService = accessor.get(IInstantiationService);
+    const model = editor.getModel();
+    const position = editor.getPosition();
+    const anchor = SymbolNavigationAnchor.is(arg) ? arg : new SymbolNavigationAnchor(model, position);
+    const cts = new EditorStateCancellationTokenSource(
+      editor,
+      1 | 4
+      /* CodeEditorStateFlag.Position */
+    );
+    const promise = raceCancellation(this._getLocationModel(languageFeaturesService, anchor.model, anchor.position, cts.token), cts.token).then(async (references) => {
+      var _a2;
+      if (!references || cts.token.isCancellationRequested) {
+        return;
+      }
+      alert(references.ariaMessage);
+      let altAction;
+      if (references.referenceAt(model.uri, position)) {
+        const altActionId = this._getAlternativeCommand(editor);
+        if (!_SymbolNavigationAction._activeAlternativeCommands.has(altActionId) && _SymbolNavigationAction._allSymbolNavigationCommands.has(altActionId)) {
+          altAction = _SymbolNavigationAction._allSymbolNavigationCommands.get(altActionId);
+        }
+      }
+      const referenceCount = references.references.length;
+      if (referenceCount === 0) {
+        if (!this.configuration.muteMessage) {
+          const info = model.getWordAtPosition(position);
+          (_a2 = MessageController.get(editor)) == null ? void 0 : _a2.showMessage(this._getNoResultFoundMessage(info), position);
+        }
+      } else if (referenceCount === 1 && altAction) {
+        _SymbolNavigationAction._activeAlternativeCommands.add(this.desc.id);
+        instaService.invokeFunction((accessor2) => altAction.runEditorCommand(accessor2, editor, arg, range).finally(() => {
+          _SymbolNavigationAction._activeAlternativeCommands.delete(this.desc.id);
+        }));
+      } else {
+        return this._onResult(editorService, symbolNavService, editor, references, range);
+      }
+    }, (err) => {
+      notificationService.error(err);
+    }).finally(() => {
+      cts.dispose();
+    });
+    progressService.showWhile(promise, 250);
+    return promise;
+  }
+  async _onResult(editorService, symbolNavService, editor, model, range) {
+    const gotoLocation = this._getGoToPreference(editor);
+    if (!(editor instanceof EmbeddedCodeEditorWidget) && (this.configuration.openInPeek || gotoLocation === "peek" && model.references.length > 1)) {
+      this._openInPeek(editor, model, range);
+    } else {
+      const next = model.firstReference();
+      const peek = model.references.length > 1 && gotoLocation === "gotoAndPeek";
+      const targetEditor = await this._openReference(editor, editorService, next, this.configuration.openToSide, !peek);
+      if (peek && targetEditor) {
+        this._openInPeek(targetEditor, model, range);
+      } else {
+        model.dispose();
+      }
+      if (gotoLocation === "goto") {
+        symbolNavService.put(next);
+      }
+    }
+  }
+  async _openReference(editor, editorService, reference, sideBySide, highlight) {
+    let range = void 0;
+    if (isLocationLink(reference)) {
+      range = reference.targetSelectionRange;
+    }
+    if (!range) {
+      range = reference.range;
+    }
+    if (!range) {
+      return void 0;
+    }
+    const targetEditor = await editorService.openCodeEditor({
+      resource: reference.uri,
+      options: {
+        selection: Range.collapseToStart(range),
+        selectionRevealType: 3,
+        selectionSource: "code.jump"
+        /* TextEditorSelectionSource.JUMP */
+      }
+    }, editor, sideBySide);
+    if (!targetEditor) {
+      return void 0;
+    }
+    if (highlight) {
+      const modelNow = targetEditor.getModel();
+      const decorations = targetEditor.createDecorationsCollection([{ range, options: { description: "symbol-navigate-action-highlight", className: "symbolHighlight" } }]);
+      setTimeout(() => {
+        if (targetEditor.getModel() === modelNow) {
+          decorations.clear();
+        }
+      }, 350);
+    }
+    return targetEditor;
+  }
+  _openInPeek(target, model, range) {
+    const controller = ReferencesController.get(target);
+    if (controller && target.hasModel()) {
+      controller.toggleWidget(range ?? target.getSelection(), createCancelablePromise((_) => Promise.resolve(model)), this.configuration.openInPeek);
+    } else {
+      model.dispose();
+    }
+  }
+};
+_SymbolNavigationAction._allSymbolNavigationCommands = /* @__PURE__ */ new Map();
+_SymbolNavigationAction._activeAlternativeCommands = /* @__PURE__ */ new Set();
+let SymbolNavigationAction = _SymbolNavigationAction;
+class DefinitionAction extends SymbolNavigationAction {
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getDefinitionsAtPosition(languageFeaturesService.definitionProvider, model, position, false, token), localize("def.title", "Definitions"));
+  }
+  _getNoResultFoundMessage(info) {
+    return info && info.word ? localize("noResultWord", "No definition found for '{0}'", info.word) : localize("generic.noResults", "No definition found");
+  }
+  _getAlternativeCommand(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).alternativeDefinitionCommand;
+  }
+  _getGoToPreference(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleDefinitions;
+  }
+}
+registerAction2((_a = class extends DefinitionAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: _a.id,
+      title: {
+        ...localize2("actions.goToDecl.label", "Go to Definition"),
+        mnemonicTitle: localize({ key: "miGotoDefinition", comment: ["&& denotes a mnemonic"] }, "Go to &&Definition")
+      },
+      precondition: EditorContextKeys.hasDefinitionProvider,
+      keybinding: [{
+        when: EditorContextKeys.editorTextFocus,
+        primary: 70,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }, {
+        when: ContextKeyExpr.and(EditorContextKeys.editorTextFocus, IsWebContext),
+        primary: 2048 | 70,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }],
+      menu: [{
+        id: MenuId.EditorContext,
+        group: "navigation",
+        order: 1.1
+      }, {
+        id: MenuId.MenubarGoMenu,
+        precondition: null,
+        group: "4_symbol_nav",
+        order: 2
+      }]
+    });
+    CommandsRegistry.registerCommandAlias("editor.action.goToDeclaration", _a.id);
+  }
+}, _a.id = "editor.action.revealDefinition", _a));
+registerAction2((_b = class extends DefinitionAction {
+  constructor() {
+    super({
+      openToSide: true,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: _b.id,
+      title: localize2("actions.goToDeclToSide.label", "Open Definition to the Side"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasDefinitionProvider, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      keybinding: [{
+        when: EditorContextKeys.editorTextFocus,
+        primary: KeyChord(
+          2048 | 41,
+          70
+          /* KeyCode.F12 */
+        ),
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }, {
+        when: ContextKeyExpr.and(EditorContextKeys.editorTextFocus, IsWebContext),
+        primary: KeyChord(
+          2048 | 41,
+          2048 | 70
+          /* KeyCode.F12 */
+        ),
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }]
+    });
+    CommandsRegistry.registerCommandAlias("editor.action.openDeclarationToTheSide", _b.id);
+  }
+}, _b.id = "editor.action.revealDefinitionAside", _b));
+registerAction2((_c = class extends DefinitionAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: true,
+      muteMessage: false
+    }, {
+      id: _c.id,
+      title: localize2("actions.previewDecl.label", "Peek Definition"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasDefinitionProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      keybinding: {
+        when: EditorContextKeys.editorTextFocus,
+        primary: 512 | 70,
+        linux: {
+          primary: 2048 | 1024 | 68
+          /* KeyCode.F10 */
+        },
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      },
+      menu: {
+        id: MenuId.EditorContextPeek,
+        group: "peek",
+        order: 2
+      }
+    });
+    CommandsRegistry.registerCommandAlias("editor.action.previewDeclaration", _c.id);
+  }
+}, _c.id = "editor.action.peekDefinition", _c));
+class DeclarationAction extends SymbolNavigationAction {
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getDeclarationsAtPosition(languageFeaturesService.declarationProvider, model, position, false, token), localize("decl.title", "Declarations"));
+  }
+  _getNoResultFoundMessage(info) {
+    return info && info.word ? localize("decl.noResultWord", "No declaration found for '{0}'", info.word) : localize("decl.generic.noResults", "No declaration found");
+  }
+  _getAlternativeCommand(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).alternativeDeclarationCommand;
+  }
+  _getGoToPreference(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleDeclarations;
+  }
+}
+registerAction2((_d = class extends DeclarationAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: _d.id,
+      title: {
+        ...localize2("actions.goToDeclaration.label", "Go to Declaration"),
+        mnemonicTitle: localize({ key: "miGotoDeclaration", comment: ["&& denotes a mnemonic"] }, "Go to &&Declaration")
+      },
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasDeclarationProvider, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      menu: [{
+        id: MenuId.EditorContext,
+        group: "navigation",
+        order: 1.3
+      }, {
+        id: MenuId.MenubarGoMenu,
+        precondition: null,
+        group: "4_symbol_nav",
+        order: 3
+      }]
+    });
+  }
+  _getNoResultFoundMessage(info) {
+    return info && info.word ? localize("decl.noResultWord", "No declaration found for '{0}'", info.word) : localize("decl.generic.noResults", "No declaration found");
+  }
+}, _d.id = "editor.action.revealDeclaration", _d));
+registerAction2(class PeekDeclarationAction extends DeclarationAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: true,
+      muteMessage: false
+    }, {
+      id: "editor.action.peekDeclaration",
+      title: localize2("actions.peekDecl.label", "Peek Declaration"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasDeclarationProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      menu: {
+        id: MenuId.EditorContextPeek,
+        group: "peek",
+        order: 3
+      }
+    });
+  }
+});
+class TypeDefinitionAction extends SymbolNavigationAction {
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getTypeDefinitionsAtPosition(languageFeaturesService.typeDefinitionProvider, model, position, false, token), localize("typedef.title", "Type Definitions"));
+  }
+  _getNoResultFoundMessage(info) {
+    return info && info.word ? localize("goToTypeDefinition.noResultWord", "No type definition found for '{0}'", info.word) : localize("goToTypeDefinition.generic.noResults", "No type definition found");
+  }
+  _getAlternativeCommand(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).alternativeTypeDefinitionCommand;
+  }
+  _getGoToPreference(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleTypeDefinitions;
+  }
+}
+registerAction2((_e = class extends TypeDefinitionAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: _e.ID,
+      title: {
+        ...localize2("actions.goToTypeDefinition.label", "Go to Type Definition"),
+        mnemonicTitle: localize({ key: "miGotoTypeDefinition", comment: ["&& denotes a mnemonic"] }, "Go to &&Type Definition")
+      },
+      precondition: EditorContextKeys.hasTypeDefinitionProvider,
+      keybinding: {
+        when: EditorContextKeys.editorTextFocus,
+        primary: 0,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      },
+      menu: [{
+        id: MenuId.EditorContext,
+        group: "navigation",
+        order: 1.4
+      }, {
+        id: MenuId.MenubarGoMenu,
+        precondition: null,
+        group: "4_symbol_nav",
+        order: 3
+      }]
+    });
+  }
+}, _e.ID = "editor.action.goToTypeDefinition", _e));
+registerAction2((_f = class extends TypeDefinitionAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: true,
+      muteMessage: false
+    }, {
+      id: _f.ID,
+      title: localize2("actions.peekTypeDefinition.label", "Peek Type Definition"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasTypeDefinitionProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      menu: {
+        id: MenuId.EditorContextPeek,
+        group: "peek",
+        order: 4
+      }
+    });
+  }
+}, _f.ID = "editor.action.peekTypeDefinition", _f));
+class ImplementationAction extends SymbolNavigationAction {
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getImplementationsAtPosition(languageFeaturesService.implementationProvider, model, position, false, token), localize("impl.title", "Implementations"));
+  }
+  _getNoResultFoundMessage(info) {
+    return info && info.word ? localize("goToImplementation.noResultWord", "No implementation found for '{0}'", info.word) : localize("goToImplementation.generic.noResults", "No implementation found");
+  }
+  _getAlternativeCommand(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).alternativeImplementationCommand;
+  }
+  _getGoToPreference(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleImplementations;
+  }
+}
+registerAction2((_g = class extends ImplementationAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: _g.ID,
+      title: {
+        ...localize2("actions.goToImplementation.label", "Go to Implementations"),
+        mnemonicTitle: localize({ key: "miGotoImplementation", comment: ["&& denotes a mnemonic"] }, "Go to &&Implementations")
+      },
+      precondition: EditorContextKeys.hasImplementationProvider,
+      keybinding: {
+        when: EditorContextKeys.editorTextFocus,
+        primary: 2048 | 70,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      },
+      menu: [{
+        id: MenuId.EditorContext,
+        group: "navigation",
+        order: 1.45
+      }, {
+        id: MenuId.MenubarGoMenu,
+        precondition: null,
+        group: "4_symbol_nav",
+        order: 4
+      }]
+    });
+  }
+}, _g.ID = "editor.action.goToImplementation", _g));
+registerAction2((_h = class extends ImplementationAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: true,
+      muteMessage: false
+    }, {
+      id: _h.ID,
+      title: localize2("actions.peekImplementation.label", "Peek Implementations"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasImplementationProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      keybinding: {
+        when: EditorContextKeys.editorTextFocus,
+        primary: 2048 | 1024 | 70,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      },
+      menu: {
+        id: MenuId.EditorContextPeek,
+        group: "peek",
+        order: 5
+      }
+    });
+  }
+}, _h.ID = "editor.action.peekImplementation", _h));
+class ReferencesAction extends SymbolNavigationAction {
+  _getNoResultFoundMessage(info) {
+    return info ? localize("references.no", "No references found for '{0}'", info.word) : localize("references.noGeneric", "No references found");
+  }
+  _getAlternativeCommand(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).alternativeReferenceCommand;
+  }
+  _getGoToPreference(editor) {
+    return editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleReferences;
+  }
+}
+registerAction2(class GoToReferencesAction extends ReferencesAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: false,
+      muteMessage: false
+    }, {
+      id: "editor.action.goToReferences",
+      title: {
+        ...localize2("goToReferences.label", "Go to References"),
+        mnemonicTitle: localize({ key: "miGotoReference", comment: ["&& denotes a mnemonic"] }, "Go to &&References")
+      },
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasReferenceProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      keybinding: {
+        when: EditorContextKeys.editorTextFocus,
+        primary: 1024 | 70,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      },
+      menu: [{
+        id: MenuId.EditorContext,
+        group: "navigation",
+        order: 1.45
+      }, {
+        id: MenuId.MenubarGoMenu,
+        precondition: null,
+        group: "4_symbol_nav",
+        order: 5
+      }]
+    });
+  }
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, true, false, token), localize("ref.title", "References"));
+  }
+});
+registerAction2(class PeekReferencesAction extends ReferencesAction {
+  constructor() {
+    super({
+      openToSide: false,
+      openInPeek: true,
+      muteMessage: false
+    }, {
+      id: "editor.action.referenceSearch.trigger",
+      title: localize2("references.action.label", "Peek References"),
+      precondition: ContextKeyExpr.and(EditorContextKeys.hasReferenceProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated()),
+      menu: {
+        id: MenuId.EditorContextPeek,
+        group: "peek",
+        order: 6
+      }
+    });
+  }
+  async _getLocationModel(languageFeaturesService, model, position, token) {
+    return new ReferencesModel(await getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, false, false, token), localize("ref.title", "References"));
+  }
+});
+class GenericGoToLocationAction extends SymbolNavigationAction {
+  constructor(config, _references, _gotoMultipleBehaviour) {
+    super(config, {
+      id: "editor.action.goToLocation",
+      title: localize2("label.generic", "Go to Any Symbol"),
+      precondition: ContextKeyExpr.and(PeekContext.notInPeekEditor, EditorContextKeys.isInEmbeddedEditor.toNegated())
+    });
+    this._references = _references;
+    this._gotoMultipleBehaviour = _gotoMultipleBehaviour;
+  }
+  async _getLocationModel(languageFeaturesService, _model, _position, _token) {
+    return new ReferencesModel(this._references, localize("generic.title", "Locations"));
+  }
+  _getNoResultFoundMessage(info) {
+    return info && localize("generic.noResult", "No results for '{0}'", info.word) || "";
+  }
+  _getGoToPreference(editor) {
+    return this._gotoMultipleBehaviour ?? editor.getOption(
+      58
+      /* EditorOption.gotoLocation */
+    ).multipleReferences;
+  }
+  _getAlternativeCommand() {
+    return "";
+  }
+}
+CommandsRegistry.registerCommand({
+  id: "editor.action.goToLocations",
+  metadata: {
+    description: "Go to locations from a position in a file",
+    args: [
+      { name: "uri", description: "The text document in which to start", constraint: URI },
+      { name: "position", description: "The position at which to start", constraint: Position.isIPosition },
+      { name: "locations", description: "An array of locations.", constraint: Array },
+      { name: "multiple", description: "Define what to do when having multiple results, either `peek`, `gotoAndPeek`, or `goto`" },
+      { name: "noResultsMessage", description: "Human readable message that shows when locations is empty." }
+    ]
+  },
+  handler: async (accessor, resource, position, references, multiple, noResultsMessage, openInPeek) => {
+    assertType(URI.isUri(resource));
+    assertType(Position.isIPosition(position));
+    assertType(Array.isArray(references));
+    assertType(typeof multiple === "undefined" || typeof multiple === "string");
+    assertType(typeof openInPeek === "undefined" || typeof openInPeek === "boolean");
+    const editorService = accessor.get(ICodeEditorService);
+    const editor = await editorService.openCodeEditor({ resource }, editorService.getFocusedCodeEditor());
+    if (isCodeEditor(editor)) {
+      editor.setPosition(position);
+      editor.revealPositionInCenterIfOutsideViewport(
+        position,
+        0
+        /* ScrollType.Smooth */
+      );
+      return editor.invokeWithinContext((accessor2) => {
+        const command = new class extends GenericGoToLocationAction {
+          _getNoResultFoundMessage(info) {
+            return noResultsMessage || super._getNoResultFoundMessage(info);
+          }
+        }({
+          muteMessage: !Boolean(noResultsMessage),
+          openInPeek: Boolean(openInPeek),
+          openToSide: false
+        }, references, multiple);
+        accessor2.get(IInstantiationService).invokeFunction(command.run.bind(command), editor);
+      });
+    }
+  }
+});
+CommandsRegistry.registerCommand({
+  id: "editor.action.peekLocations",
+  metadata: {
+    description: "Peek locations from a position in a file",
+    args: [
+      { name: "uri", description: "The text document in which to start", constraint: URI },
+      { name: "position", description: "The position at which to start", constraint: Position.isIPosition },
+      { name: "locations", description: "An array of locations.", constraint: Array },
+      { name: "multiple", description: "Define what to do when having multiple results, either `peek`, `gotoAndPeek`, or `goto`" }
+    ]
+  },
+  handler: async (accessor, resource, position, references, multiple) => {
+    accessor.get(ICommandService).executeCommand("editor.action.goToLocations", resource, position, references, multiple, void 0, true);
+  }
+});
+CommandsRegistry.registerCommand({
+  id: "editor.action.findReferences",
+  handler: (accessor, resource, position) => {
+    assertType(URI.isUri(resource));
+    assertType(Position.isIPosition(position));
+    const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+    const codeEditorService = accessor.get(ICodeEditorService);
+    return codeEditorService.openCodeEditor({ resource }, codeEditorService.getFocusedCodeEditor()).then((control) => {
+      if (!isCodeEditor(control) || !control.hasModel()) {
+        return void 0;
+      }
+      const controller = ReferencesController.get(control);
+      if (!controller) {
+        return void 0;
+      }
+      const references = createCancelablePromise((token) => getReferencesAtPosition(languageFeaturesService.referenceProvider, control.getModel(), Position.lift(position), false, false, token).then((references2) => new ReferencesModel(references2, localize("ref.title", "References"))));
+      const range = new Range(position.lineNumber, position.column, position.lineNumber, position.column);
+      return Promise.resolve(controller.toggleWidget(range, references, false));
+    });
+  }
+});
+CommandsRegistry.registerCommandAlias("editor.action.showReferences", "editor.action.peekLocations");
+export {
+  DefinitionAction,
+  SymbolNavigationAction,
+  SymbolNavigationAnchor
+};
+//# sourceMappingURL=goToCommands.es.js.map