import { isStandalone } from "../../../../base/browser/browser.mjs";
import { alert } from "../../../../base/browser/ui/aria/aria.mjs";
import { createCancelablePromise, raceCancellation } from "../../../../base/common/async.mjs";
import { KeyChord } from "../../../../base/common/keyCodes.mjs";
import { isWeb } from "../../../../base/common/platform.mjs";
import { assertType } from "../../../../base/common/types.mjs";
import { URI } from "../../../../base/common/uri.mjs";
import { EditorStateCancellationTokenSource } from "../../editorState/browser/editorState.mjs";
import { isCodeEditor } from "../../../browser/editorBrowser.mjs";
import { registerInstantiatedEditorAction, EditorAction } from "../../../browser/editorExtensions.mjs";
import { ICodeEditorService } from "../../../browser/services/codeEditorService.mjs";
import { EmbeddedCodeEditorWidget } from "../../../browser/widget/embeddedCodeEditorWidget.mjs";
import { Position } from "../../../common/core/position.mjs";
import { Range } from "../../../common/core/range.mjs";
import { EditorContextKeys } from "../../../common/editorContextKeys.mjs";
import { isLocationLink } from "../../../common/languages.mjs";
import { ReferencesController } from "./peek/referencesController.mjs";
import { ReferencesModel } from "./referencesModel.mjs";
import { ISymbolNavigationService } from "./symbolNavigation.mjs";
import { MessageController } from "../../message/browser/messageController.mjs";
import { PeekContext } from "../../peekView/browser/peekView.mjs";
import { localize } from "../../../../nls.mjs";
import { MenuRegistry, MenuId } from "../../../../platform/actions/common/actions.mjs";
import { CommandsRegistry, ICommandService } from "../../../../platform/commands/common/commands.mjs";
import { ContextKeyExpr } from "../../../../platform/contextkey/common/contextkey.mjs";
import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.mjs";
import { INotificationService } from "../../../../platform/notification/common/notification.mjs";
import { IEditorProgressService } from "../../../../platform/progress/common/progress.mjs";
import { getReferencesAtPosition, getDefinitionsAtPosition, getDeclarationsAtPosition, getTypeDefinitionsAtPosition, getImplementationsAtPosition } from "./goToSymbol.mjs";
import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.mjs";
var __awaiter = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function(resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function(resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
var _a, _b, _c, _d, _e, _f, _g, _h;
MenuRegistry.appendMenuItem(MenuId.EditorContext, {
  submenu: MenuId.EditorContextPeek,
  title: localize("peek.submenu", "Peek"),
  group: "navigation",
  order: 100
});
const _goToActionIds = /* @__PURE__ */ new Set();
function registerGoToAction(ctor) {
  const result = new ctor();
  registerInstantiatedEditorAction(result);
  _goToActionIds.add(result.id);
  return result;
}
class SymbolNavigationAnchor {
  constructor(model, position) {
    this.model = model;
    this.position = position;
  }
  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;
  }
}
class SymbolNavigationAction extends EditorAction {
  constructor(configuration, opts) {
    super(opts);
    this.configuration = configuration;
  }
  run(accessor, editor, arg) {
    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 model = editor.getModel();
    const position = editor.getPosition();
    const anchor = SymbolNavigationAnchor.is(arg) ? arg : new SymbolNavigationAnchor(model, position);
    const cts = new EditorStateCancellationTokenSource(
      editor,
      1 | 4
      /* Position */
    );
    const promise = raceCancellation(this._getLocationModel(languageFeaturesService, anchor.model, anchor.position, cts.token), cts.token).then((references) => __awaiter(this, void 0, void 0, function* () {
      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 (altActionId !== this.id && _goToActionIds.has(altActionId)) {
          altAction = editor.getAction(altActionId);
        }
      }
      const referenceCount = references.references.length;
      if (referenceCount === 0) {
        if (!this.configuration.muteMessage) {
          const info = model.getWordAtPosition(position);
          (_a2 = MessageController.get(editor)) === null || _a2 === void 0 ? void 0 : _a2.showMessage(this._getNoResultFoundMessage(info), position);
        }
      } else if (referenceCount === 1 && altAction) {
        altAction.run();
      } else {
        return this._onResult(editorService, symbolNavService, editor, references);
      }
    }), (err) => {
      notificationService.error(err);
    }).finally(() => {
      cts.dispose();
    });
    progressService.showWhile(promise, 250);
    return promise;
  }
  _onResult(editorService, symbolNavService, editor, model) {
    return __awaiter(this, void 0, void 0, function* () {
      const gotoLocation = this._getGoToPreference(editor);
      if (!(editor instanceof EmbeddedCodeEditorWidget) && (this.configuration.openInPeek || gotoLocation === "peek" && model.references.length > 1)) {
        this._openInPeek(editor, model);
      } else {
        const next = model.firstReference();
        const peek = model.references.length > 1 && gotoLocation === "gotoAndPeek";
        const targetEditor = yield this._openReference(editor, editorService, next, this.configuration.openToSide, !peek);
        if (peek && targetEditor) {
          this._openInPeek(targetEditor, model);
        } else {
          model.dispose();
        }
        if (gotoLocation === "goto") {
          symbolNavService.put(next);
        }
      }
    });
  }
  _openReference(editor, editorService, reference, sideBySide, highlight) {
    return __awaiter(this, void 0, void 0, function* () {
      let range = void 0;
      if (isLocationLink(reference)) {
        range = reference.targetSelectionRange;
      }
      if (!range) {
        range = reference.range;
      }
      if (!range) {
        return void 0;
      }
      const targetEditor = yield editorService.openCodeEditor({
        resource: reference.uri,
        options: {
          selection: Range.collapseToStart(range),
          selectionRevealType: 3,
          selectionSource: "code.jump"
          /* JUMP */
        }
      }, editor, sideBySide);
      if (!targetEditor) {
        return void 0;
      }
      if (highlight) {
        const modelNow = targetEditor.getModel();
        const ids = targetEditor.deltaDecorations([], [{ range, options: { description: "symbol-navigate-action-highlight", className: "symbolHighlight" } }]);
        setTimeout(() => {
          if (targetEditor.getModel() === modelNow) {
            targetEditor.deltaDecorations(ids, []);
          }
        }, 350);
      }
      return targetEditor;
    });
  }
  _openInPeek(target, model) {
    const controller = ReferencesController.get(target);
    if (controller && target.hasModel()) {
      controller.toggleWidget(target.getSelection(), createCancelablePromise((_) => Promise.resolve(model)), this.configuration.openInPeek);
    } else {
      model.dispose();
    }
  }
}
class DefinitionAction extends SymbolNavigationAction {
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getDefinitionsAtPosition(languageFeaturesService.definitionProvider, model, position, 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(
      51
      /* gotoLocation */
    ).alternativeDefinitionCommand;
  }
  _getGoToPreference(editor) {
    return editor.getOption(
      51
      /* gotoLocation */
    ).multipleDefinitions;
  }
}
const goToDefinitionKb = isWeb && !isStandalone ? 2048 | 70 : 70;
registerGoToAction((_a = class GoToDefinitionAction extends DefinitionAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: false,
      muteMessage: false
    }, {
      id: GoToDefinitionAction.id,
      label: localize("actions.goToDecl.label", "Go to Definition"),
      alias: "Go to Definition",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasDefinitionProvider, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: goToDefinitionKb,
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        group: "navigation",
        order: 1.1
      }
    });
    CommandsRegistry.registerCommandAlias("editor.action.goToDeclaration", GoToDefinitionAction.id);
  }
}, _a.id = "editor.action.revealDefinition", _a));
registerGoToAction((_b = class OpenDefinitionToSideAction extends DefinitionAction {
  constructor() {
    super({
      openToSide: true,
      openInPeek: false,
      muteMessage: false
    }, {
      id: OpenDefinitionToSideAction.id,
      label: localize("actions.goToDeclToSide.label", "Open Definition to the Side"),
      alias: "Open Definition to the Side",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasDefinitionProvider, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: KeyChord(2048 | 41, goToDefinitionKb),
        weight: 100
        /* EditorContrib */
      }
    });
    CommandsRegistry.registerCommandAlias("editor.action.openDeclarationToTheSide", OpenDefinitionToSideAction.id);
  }
}, _b.id = "editor.action.revealDefinitionAside", _b));
registerGoToAction((_c = class PeekDefinitionAction extends DefinitionAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: true,
      muteMessage: false
    }, {
      id: PeekDefinitionAction.id,
      label: localize("actions.previewDecl.label", "Peek Definition"),
      alias: "Peek Definition",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasDefinitionProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: 512 | 70,
        linux: {
          primary: 2048 | 1024 | 68
          /* F10 */
        },
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        menuId: MenuId.EditorContextPeek,
        group: "peek",
        order: 2
      }
    });
    CommandsRegistry.registerCommandAlias("editor.action.previewDeclaration", PeekDefinitionAction.id);
  }
}, _c.id = "editor.action.peekDefinition", _c));
class DeclarationAction extends SymbolNavigationAction {
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getDeclarationsAtPosition(languageFeaturesService.declarationProvider, model, position, 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(
      51
      /* gotoLocation */
    ).alternativeDeclarationCommand;
  }
  _getGoToPreference(editor) {
    return editor.getOption(
      51
      /* gotoLocation */
    ).multipleDeclarations;
  }
}
registerGoToAction((_d = class GoToDeclarationAction extends DeclarationAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: false,
      muteMessage: false
    }, {
      id: GoToDeclarationAction.id,
      label: localize("actions.goToDeclaration.label", "Go to Declaration"),
      alias: "Go to Declaration",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasDeclarationProvider, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      contextMenuOpts: {
        group: "navigation",
        order: 1.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));
registerGoToAction(class PeekDeclarationAction extends DeclarationAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: true,
      muteMessage: false
    }, {
      id: "editor.action.peekDeclaration",
      label: localize("actions.peekDecl.label", "Peek Declaration"),
      alias: "Peek Declaration",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasDeclarationProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      contextMenuOpts: {
        menuId: MenuId.EditorContextPeek,
        group: "peek",
        order: 3
      }
    });
  }
});
class TypeDefinitionAction extends SymbolNavigationAction {
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getTypeDefinitionsAtPosition(languageFeaturesService.typeDefinitionProvider, model, position, 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(
      51
      /* gotoLocation */
    ).alternativeTypeDefinitionCommand;
  }
  _getGoToPreference(editor) {
    return editor.getOption(
      51
      /* gotoLocation */
    ).multipleTypeDefinitions;
  }
}
registerGoToAction((_e = class GoToTypeDefinitionAction extends TypeDefinitionAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: false,
      muteMessage: false
    }, {
      id: GoToTypeDefinitionAction.ID,
      label: localize("actions.goToTypeDefinition.label", "Go to Type Definition"),
      alias: "Go to Type Definition",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasTypeDefinitionProvider, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: 0,
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        group: "navigation",
        order: 1.4
      }
    });
  }
}, _e.ID = "editor.action.goToTypeDefinition", _e));
registerGoToAction((_f = class PeekTypeDefinitionAction extends TypeDefinitionAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: true,
      muteMessage: false
    }, {
      id: PeekTypeDefinitionAction.ID,
      label: localize("actions.peekTypeDefinition.label", "Peek Type Definition"),
      alias: "Peek Type Definition",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasTypeDefinitionProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      contextMenuOpts: {
        menuId: MenuId.EditorContextPeek,
        group: "peek",
        order: 4
      }
    });
  }
}, _f.ID = "editor.action.peekTypeDefinition", _f));
class ImplementationAction extends SymbolNavigationAction {
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getImplementationsAtPosition(languageFeaturesService.implementationProvider, model, position, 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(
      51
      /* gotoLocation */
    ).alternativeImplementationCommand;
  }
  _getGoToPreference(editor) {
    return editor.getOption(
      51
      /* gotoLocation */
    ).multipleImplementations;
  }
}
registerGoToAction((_g = class GoToImplementationAction extends ImplementationAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: false,
      muteMessage: false
    }, {
      id: GoToImplementationAction.ID,
      label: localize("actions.goToImplementation.label", "Go to Implementations"),
      alias: "Go to Implementations",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasImplementationProvider, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: 2048 | 70,
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        group: "navigation",
        order: 1.45
      }
    });
  }
}, _g.ID = "editor.action.goToImplementation", _g));
registerGoToAction((_h = class PeekImplementationAction extends ImplementationAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: true,
      muteMessage: false
    }, {
      id: PeekImplementationAction.ID,
      label: localize("actions.peekImplementation.label", "Peek Implementations"),
      alias: "Peek Implementations",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasImplementationProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: 2048 | 1024 | 70,
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        menuId: 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(
      51
      /* gotoLocation */
    ).alternativeReferenceCommand;
  }
  _getGoToPreference(editor) {
    return editor.getOption(
      51
      /* gotoLocation */
    ).multipleReferences;
  }
}
registerGoToAction(class GoToReferencesAction extends ReferencesAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: false,
      muteMessage: false
    }, {
      id: "editor.action.goToReferences",
      label: localize("goToReferences.label", "Go to References"),
      alias: "Go to References",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasReferenceProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      kbOpts: {
        kbExpr: EditorContextKeys.editorTextFocus,
        primary: 1024 | 70,
        weight: 100
        /* EditorContrib */
      },
      contextMenuOpts: {
        group: "navigation",
        order: 1.45
      }
    });
  }
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, true, token), localize("ref.title", "References"));
    });
  }
});
registerGoToAction(class PeekReferencesAction extends ReferencesAction {
  constructor() {
    super({
      openToSide: false,
      openInPeek: true,
      muteMessage: false
    }, {
      id: "editor.action.referenceSearch.trigger",
      label: localize("references.action.label", "Peek References"),
      alias: "Peek References",
      precondition: ContextKeyExpr.and(EditorContextKeys.hasReferenceProvider, PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated()),
      contextMenuOpts: {
        menuId: MenuId.EditorContextPeek,
        group: "peek",
        order: 6
      }
    });
  }
  _getLocationModel(languageFeaturesService, model, position, token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(yield getReferencesAtPosition(languageFeaturesService.referenceProvider, model, position, false, token), localize("ref.title", "References"));
    });
  }
});
class GenericGoToLocationAction extends SymbolNavigationAction {
  constructor(config, _references, _gotoMultipleBehaviour) {
    super(config, {
      id: "editor.action.goToLocation",
      label: localize("label.generic", "Go to Any Symbol"),
      alias: "Go to Any Symbol",
      precondition: ContextKeyExpr.and(PeekContext.notInPeekEditor, EditorContextKeys.isInWalkThroughSnippet.toNegated())
    });
    this._references = _references;
    this._gotoMultipleBehaviour = _gotoMultipleBehaviour;
  }
  _getLocationModel(languageFeaturesService, _model, _position, _token) {
    return __awaiter(this, void 0, void 0, function* () {
      return new ReferencesModel(this._references, localize("generic.title", "Locations"));
    });
  }
  _getNoResultFoundMessage(info) {
    return info && localize("generic.noResult", "No results for '{0}'", info.word) || "";
  }
  _getGoToPreference(editor) {
    var _a2;
    return (_a2 = this._gotoMultipleBehaviour) !== null && _a2 !== void 0 ? _a2 : editor.getOption(
      51
      /* gotoLocation */
    ).multipleReferences;
  }
  _getAlternativeCommand() {
    return "";
  }
}
CommandsRegistry.registerCommand({
  id: "editor.action.goToLocations",
  description: {
    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: (accessor, resource, position, references, multiple, noResultsMessage, openInPeek) => __awaiter(void 0, void 0, void 0, function* () {
    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 = yield editorService.openCodeEditor({ resource }, editorService.getFocusedCodeEditor());
    if (isCodeEditor(editor)) {
      editor.setPosition(position);
      editor.revealPositionInCenterIfOutsideViewport(
        position,
        0
        /* 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",
  description: {
    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: (accessor, resource, position, references, multiple) => __awaiter(void 0, void 0, void 0, function* () {
    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, 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");
MenuRegistry.appendMenuItems([
  {
    id: MenuId.MenubarGoMenu,
    item: {
      command: {
        id: "editor.action.revealDefinition",
        title: localize({ key: "miGotoDefinition", comment: ["&& denotes a mnemonic"] }, "Go to &&Definition")
      },
      group: "4_symbol_nav",
      order: 2
    }
  },
  {
    id: MenuId.MenubarGoMenu,
    item: {
      command: {
        id: "editor.action.revealDeclaration",
        title: localize({ key: "miGotoDeclaration", comment: ["&& denotes a mnemonic"] }, "Go to &&Declaration")
      },
      group: "4_symbol_nav",
      order: 3
    }
  },
  {
    id: MenuId.MenubarGoMenu,
    item: {
      command: {
        id: "editor.action.goToTypeDefinition",
        title: localize({ key: "miGotoTypeDefinition", comment: ["&& denotes a mnemonic"] }, "Go to &&Type Definition")
      },
      group: "4_symbol_nav",
      order: 3
    }
  },
  {
    id: MenuId.MenubarGoMenu,
    item: {
      command: {
        id: "editor.action.goToImplementation",
        title: localize({ key: "miGotoImplementation", comment: ["&& denotes a mnemonic"] }, "Go to &&Implementations")
      },
      group: "4_symbol_nav",
      order: 4
    }
  },
  {
    id: MenuId.MenubarGoMenu,
    item: {
      command: {
        id: "editor.action.goToReferences",
        title: localize({ key: "miGotoReference", comment: ["&& denotes a mnemonic"] }, "Go to &&References")
      },
      group: "4_symbol_nav",
      order: 5
    }
  }
]);
export {
  DefinitionAction,
  SymbolNavigationAction,
  SymbolNavigationAnchor
};
