@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/cjs/git-hub-discussion.d.cts

@@ -0,0 +1,28 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Links to GitHub's new-discussion page.
+ */
+/**
+ * Parameters for {@link getGitHubDiscussionUrl}.
+ */
+export interface GetGitHubDiscussionUrlParams {
+    /**
+     * The category slug, such as `q-a` or `ideas`. The repository must have this category.
+     *
+     * @default `'q-a'`
+     */
+    readonly category?: string;
+    /**
+     * The repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+}
+/**
+ * Gets a new-discussion URL with a category selected. Callers must enable Discussions in the repository.
+ *
+ * @param params - The parameters.
+ * @returns The link.
+ */
+export declare function getGitHubDiscussionUrl(params: GetGitHubDiscussionUrlParams): string;

package/dist/lib/cjs/git-rename-history.cjs

@@ -0,0 +1,148 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_rename_history_exports = {};
+__export(git_rename_history_exports, {
+  loadGitRenames: () => loadGitRenames,
+  parseGitRenameLog: () => parseGitRenameLog
+});
+module.exports = __toCommonJS(git_rename_history_exports);
+const RENAME_STATUS_REGEXP = /^R\d*$/;
+async function loadGitRenames(params) {
+  try {
+    const showPrefixOutput = await params.runGit(["rev-parse", "--show-prefix"]);
+    const vaultPrefix = showPrefixOutput.trim();
+    const log = await params.runGit(["-c", "core.quotePath=false", "log", "-z", "--diff-filter=R", "-M", "--name-status", "--format=%h"]);
+    return parseGitRenameLog(log, vaultPrefix);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function parseGitRenameLog(log, vaultPrefix) {
+  const tokens = log.split("\0").map((token) => token.replace(/^\n+/, ""));
+  const renames = [];
+  let commit = "";
+  let index = 0;
+  function readToken() {
+    return tokens[index++] ?? "";
+  }
+  while (index < tokens.length) {
+    const token = readToken();
+    if (RENAME_STATUS_REGEXP.test(token)) {
+      const oldPath = readToken();
+      const newPath = readToken();
+      if (oldPath.startsWith(vaultPrefix) && newPath.startsWith(vaultPrefix)) {
+        renames.push({ commit, newPath: newPath.slice(vaultPrefix.length), oldPath: oldPath.slice(vaultPrefix.length) });
+      }
+    } else if (token) {
+      commit = token;
+    }
+  }
+  const nextByPath = /* @__PURE__ */ new Map();
+  for (const rename of renames.reverse()) {
+    nextByPath.set(rename.oldPath, { commit: rename.commit, newPath: rename.newPath });
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [oldPath, firstRename] of nextByPath) {
+    let rename = firstRename;
+    const visitedPaths = /* @__PURE__ */ new Set([oldPath]);
+    let next = nextByPath.get(rename.newPath);
+    while (next && !visitedPaths.has(rename.newPath)) {
+      visitedPaths.add(rename.newPath);
+      rename = next;
+      next = nextByPath.get(rename.newPath);
+    }
+    result.set(oldPath, rename);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadGitRenames,
+  parseGitRenameLog
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/git-rename-history.d.cts

@@ -0,0 +1,43 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * The renames a vault's git history records, the strongest evidence of where a missing link target went.
+ *
+ * Cross-platform: it only parses. Running `git` belongs to `desktop-git-runner.ts`, whose Node imports are
+ * deferred until a command runs. Call that runner only behind `Platform.isDesktopApp`.
+ */
+import type { GitRename } from './broken-link-candidates.cjs';
+/**
+ * Runs `git` with the given arguments in the vault's folder.
+ *
+ * @param arguments_ - The arguments.
+ * @returns The command's standard output.
+ */
+export type GitRunner = (arguments_: readonly string[]) => Promise<string>;
+/**
+ * The parameters for {@link loadGitRenames}.
+ */
+export interface LoadGitRenamesParams {
+    /**
+     * Runs `git` in the vault's folder.
+     */
+    readonly runGit: GitRunner;
+}
+/**
+ * Reads every rename in the git history of the repository the vault lives in.
+ *
+ * @param params - The parameters.
+ * @returns Each old vault path to the path it ended up at; empty when the vault is not in a git repository or
+ * `git` cannot run, because missing evidence is not an error.
+ */
+export declare function loadGitRenames(params: LoadGitRenamesParams): Promise<Map<string, GitRename>>;
+/**
+ * Parses the output of `git log -z --diff-filter=R -M --name-status --format=%h`.
+ *
+ * @param log - The output, newest commit first.
+ * @param vaultPrefix - The vault's folder within the repository, as `git rev-parse --show-prefix` prints it:
+ * `''` or a path ending in `/`. Renames outside it are dropped, and it is stripped from the rest.
+ * @returns Each old vault path to the path it ended up at, following a chain of renames to its end.
+ */
+export declare function parseGitRenameLog(log: string, vaultPrefix: string): Map<string, GitRename>;

package/dist/lib/cjs/hotkey.cjs

@@ -0,0 +1,185 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const $module = originalRequire?.(id);
+      if ($module) {
+        return extractDefault($module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hotkey_exports = {};
+__export(hotkey_exports, {
+  formatHotkey: () => formatHotkey,
+  getHotkeyFromKeyboardEvent: () => getHotkeyFromKeyboardEvent,
+  isSameHotkey: () => isSameHotkey
+});
+module.exports = __toCommonJS(hotkey_exports);
+var import_obsidian = require('obsidian');
+const MODIFIER_KEYS = /* @__PURE__ */ new Set(["Alt", "AltGraph", "Control", "Meta", "OS", "Shift"]);
+const CODE_KEY_REG_EXP = /^(?:Key(?<letter>[A-Z])|Digit(?<digit>\d))$/;
+const MAC_MODIFIER_NAMES = [
+  ["Mod", "\u2318"],
+  ["Ctrl", "\u2303"],
+  ["Meta", "\u2318"],
+  ["Alt", "\u2325"],
+  ["Shift", "\u21E7"]
+];
+const OTHER_MODIFIER_NAMES = [
+  ["Mod", "Ctrl"],
+  ["Ctrl", "Ctrl"],
+  ["Meta", "Win"],
+  ["Alt", "Alt"],
+  ["Shift", "Shift"]
+];
+const KEY_DISPLAY_NAMES = {
+  " ": "Space",
+  "ArrowDown": "\u2193",
+  "ArrowLeft": "\u2190",
+  "ArrowRight": "\u2192",
+  "ArrowUp": "\u2191"
+};
+function formatHotkey(params) {
+  const isMacOS = params.isMacOS ?? import_obsidian.Platform.isMacOS;
+  const modifierNames = isMacOS ? MAC_MODIFIER_NAMES : OTHER_MODIFIER_NAMES;
+  const parts = modifierNames.filter(([modifier]) => params.hotkey.modifiers.includes(modifier)).map(([, name]) => name);
+  parts.push(KEY_DISPLAY_NAMES[params.hotkey.key] ?? params.hotkey.key);
+  return parts.join(isMacOS ? "" : " + ");
+}
+function getHotkeyFromKeyboardEvent(params) {
+  const keyboardEvent = params.event;
+  if (MODIFIER_KEYS.has(keyboardEvent.key)) {
+    return null;
+  }
+  const isMacOS = params.isMacOS ?? import_obsidian.Platform.isMacOS;
+  const modifiers = [];
+  if (isMacOS ? keyboardEvent.metaKey : keyboardEvent.ctrlKey) {
+    modifiers.push("Mod");
+  }
+  if (isMacOS ? keyboardEvent.ctrlKey : keyboardEvent.metaKey) {
+    modifiers.push(isMacOS ? "Ctrl" : "Meta");
+  }
+  if (keyboardEvent.altKey) {
+    modifiers.push("Alt");
+  }
+  if (keyboardEvent.shiftKey) {
+    modifiers.push("Shift");
+  }
+  const codeGroups = CODE_KEY_REG_EXP.exec(keyboardEvent.code)?.groups;
+  const key = codeGroups?.["letter"] ?? codeGroups?.["digit"] ?? (keyboardEvent.key.length === 1 ? keyboardEvent.key.toUpperCase() : keyboardEvent.key);
+  return { key, modifiers };
+}
+function isSameHotkey(hotkey1, hotkey2) {
+  return hotkey1.key.toUpperCase() === hotkey2.key.toUpperCase() && hotkey1.modifiers.length === hotkey2.modifiers.length && hotkey1.modifiers.every((modifier) => hotkey2.modifiers.includes(modifier));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatHotkey,
+  getHotkeyFromKeyboardEvent,
+  isSameHotkey
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/hotkey.d.cts

@@ -0,0 +1,59 @@
+/// <reference path="./library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Reads a {@link Hotkey} from a key press and formats one for display.
+ */
+import type { Hotkey } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * Parameters of {@link formatHotkey}.
+ */
+export interface FormatHotkeyParams {
+    /**
+     * The hotkey to format.
+     */
+    readonly hotkey: Hotkey;
+    /**
+     * Whether to format it the macOS way, with modifier symbols and no separator. Defaults to `Platform.isMacOS`.
+     */
+    readonly isMacOS?: boolean;
+}
+/**
+ * Parameters of {@link getHotkeyFromKeyboardEvent}.
+ */
+export interface GetHotkeyFromKeyboardEventParams {
+    /**
+     * The key press.
+     */
+    readonly event: KeyboardEvent;
+    /**
+     * Whether the platform is macOS, where `Mod` is the Command key rather than Ctrl. Defaults to `Platform.isMacOS`.
+     */
+    readonly isMacOS?: boolean;
+}
+/**
+ * Formats a hotkey the way Obsidian's hotkey settings show it: `Ctrl + Shift + P`, or `⌘⇧P` on macOS.
+ *
+ * @param params - The parameters.
+ * @returns The display string.
+ */
+export declare function formatHotkey(params: FormatHotkeyParams): string;
+/**
+ * Reads the hotkey a key press makes, in the shape Obsidian stores in `hotkeys.json`.
+ *
+ * The Ctrl key reads as `Mod` everywhere but macOS, and the Command key as `Mod` on macOS. Letters and digits come from
+ * the physical key, so Shift or a keyboard layout does not change them.
+ *
+ * @param params - The parameters.
+ * @returns The hotkey, or `null` when only a modifier key was pressed.
+ */
+export declare function getHotkeyFromKeyboardEvent(params: GetHotkeyFromKeyboardEventParams): Hotkey | null;
+/**
+ * Checks whether two hotkeys are the same key combination, whatever order their modifiers are listed in.
+ *
+ * @param hotkey1 - The first hotkey.
+ * @param hotkey2 - The second hotkey.
+ * @returns Whether they are equal.
+ */
+export declare function isSameHotkey(hotkey1: Hotkey, hotkey2: Hotkey): boolean;

package/dist/lib/cjs/i18n/locales/en.cjs

@@ -121,6 +121,18 @@ const en = {
       jumpToPage: "Jump to page:",
       pageHeader: "Page {{pageNumber, number}} of {{totalPages, number}}, Total items: {{totalItems, number}}"
     },
+    hotkey: {
+      clear: "Clear hotkey",
+      notSet: "Not set",
+      pressHotkey: "Press a hotkey..."
+    },
+    list: {
+      add: "Add",
+      empty: "No items",
+      moveDown: "Move down",
+      moveUp: "Move up",
+      remove: "Remove"
+    },
     menu: {
       copy: "Copy"
     },
@@ -201,4 +213,4 @@ const en = {
 0 && (module.exports = {
   en
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/i18n/locales/en.ts"],"sourcesContent":["/**\n * @file\n *\n * This file defines the English translations for the `i18n` module.\n */\n\n/**\n * The English translations.\n */\nexport const en = {\n  obsidianLib: {\n    asyncWithNotice: {\n      milliseconds: 'milliseconds...',\n      operation: 'Operation',\n      runningFor: 'Running for',\n      terminateOperation: 'You can terminate the operation by clicking the button below, but be aware it might leave the vault in an inconsistent state.',\n      timedOut: 'The operation timed out after {{duration, number}} milliseconds.'\n    },\n    bulkOperation: {\n      noOperations: 'No bulk operation of this plugin was found in the vault repository.',\n      notActive: 'Bulk operation commits are off, or the vault is not in a git repository.',\n      recoveredInterrupted: 'A bulk operation was interrupted. Its changes were committed as {{operationId}} interrupted.',\n      resumedAfterRecovery: 'The lock of {{recoveredOperationId}} went stale while it ran, so its changes so far were committed as {{recoveredOperationId}} interrupted, and the rest as {{operationId}}. Undoing the whole operation takes reverting both.',\n      revertConflict: 'Reverting {{operationId}} stopped on a conflict. The vault repository is left mid-revert: resolve the conflicts, then run git revert --continue, or git revert --abort to give up.',\n      reverted: 'Reverted {{operationId}}.',\n      revertFailed: 'Failed to revert {{operationId}}: {{error}}',\n      selectOperation: 'Select a bulk operation to undo'\n    },\n    buttons: {\n      cancel: 'Cancel',\n      ok: 'OK'\n    },\n    callout: {\n      loadContent: 'Load content for callout'\n    },\n    dataview: {\n      itemsPerPage: 'Items per page:',\n      jumpToPage: 'Jump to page:',\n      pageHeader: 'Page {{pageNumber, number}} of {{totalPages, number}}, Total items: {{totalItems, number}}'\n    },\n    menu: {\n      copy: 'Copy'\n    },\n    metadataCache: {\n      getBacklinksForFilePath: 'Get backlinks for {{filePath}}'\n    },\n    notices: {\n      attachmentIsStillUsed: 'Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.',\n      attachmentRescued: 'Attachment {{attachmentPath}} is still used by other notes. It was moved to {{newAttachmentPath}}.',\n      closeAriaLabel: 'Close',\n      failedToOpenUrl: 'Failed to open {{url}}',\n      unhandledError: 'An unhandled error occurred. Please check the console for more information.'\n    },\n    pathSettings: {\n      invalidGlob: 'Invalid glob pattern: {{glob}} ({{reason}})',\n      invalidRegularExpression: 'Invalid regular expression: {{regExp}} ({{reason}})',\n      trailingEscape: 'it ends with an unescaped \\\\',\n      unclosedCharacterClass: 'a [ character class is never closed with ]'\n    },\n    pluginConflict: {\n      blockedNotice: '{{pluginName}} does nothing while {{conflictingPluginName}} is enabled. Update or disable it to continue.',\n      conflictAppearedNotice: '{{conflictingPluginName}} is now enabled, so {{pluginName}} has stopped working. Update or disable it to resume.',\n      disable: 'Disable {{conflictingPluginName}}',\n      settingsHeading: 'Conflicting plugin',\n      warningNotice: '{{pluginName}} and {{conflictingPluginName}} overlap, and both are running.'\n    },\n    pluginDependency: {\n      alreadyUpToDate: '{{dependencyPluginName}} is already at its latest release. {{pluginName}} needs a version that has not been released yet.',\n      blockedNotice: '{{pluginName}} does nothing until {{dependencyPluginName}} is installed and enabled.',\n      dependencyLostNotice: '{{dependencyPluginName}} is no longer available, so {{pluginName}} has stopped working. Bring it back to resume.',\n      noReadableApiNotice: '{{dependencyPluginName}} is enabled but publishes no API {{pluginName}} can read, so {{pluginName}} does nothing. Update {{dependencyPluginName}} to resume.',\n      openDependencySettings: 'Open {{dependencyPluginName}} settings',\n      settingsHeading: 'Required plugin missing',\n      update: 'Update {{dependencyPluginName}}',\n      updated: '{{dependencyPluginName}} is updated.',\n      updateFailed: 'Failed to update {{dependencyPluginName}}. Check the console for more information.',\n      versionMismatchNotice: '{{pluginName}} needs a newer version of {{dependencyPluginName}}. Update it to resume.'\n    },\n    pluginSuggestion: {\n      enable: 'Enable',\n      install: 'Install and enable',\n      installed: '{{pluginName}} is installed and enabled.',\n      installFailed: 'Failed to install {{pluginName}}. Check the console for more information.',\n      notNow: 'Not now'\n    },\n    queue: {\n      flushQueue: 'Flush queue'\n    },\n    releaseNotes: {\n      title: '{{pluginName}} release notes'\n    },\n    renameDeleteHandler: {\n      handleDelete: 'Handle delete: {{filePath}}',\n      handleOrphanedRenames: 'Handle orphaned renames',\n      handleRename: 'Handle rename: {{oldPath}} -> {{newPath}}',\n      updatedLinks: 'Updated {{linksCount, number}} links in {{filesCount, number}} files.'\n    },\n    resourceLock: {\n      lockedByTooltip: 'Locked by',\n      lockedNoteTooltip: 'This note is locked while an operation is in progress.',\n      unlockConfirmMessage: 'This will cancel the operation(s) currently holding a lock on this note and may leave the vault in an inconsistent state. The note is locked by:',\n      unlockConfirmTitle: 'Unlock note?',\n      unlockMenuItem: 'Unlock'\n    },\n    validation: {\n      controlCharacter: '{{name}} contains a control character.',\n      emptyName: 'The name is empty.',\n      trailingCharacters: '{{name}} ends with a dot or a space, which Windows removes.',\n      unsafeCharacters: '{{name}} contains characters that are not allowed: {{characters}}',\n      windowsReservedName: '{{name}} is a device name Windows reserves, so the file cannot exist on Windows.'\n    },\n    vault: {\n      processFile: 'Process file {{filePath}}'\n    }\n  }\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,KAAK;AAAA,EAChB,aAAa;AAAA,IACX,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,WAAW;AAAA,MACX,YAAY;AAAA,MACZ,oBAAoB;AAAA,MACpB,UAAU;AAAA,IACZ;AAAA,IACA,eAAe;AAAA,MACb,cAAc;AAAA,MACd,WAAW;AAAA,MACX,sBAAsB;AAAA,MACtB,sBAAsB;AAAA,MACtB,gBAAgB;AAAA,MAChB,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA,SAAS;AAAA,MACP,QAAQ;AAAA,MACR,IAAI;AAAA,IACN;AAAA,IACA,SAAS;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA,IACA,MAAM;AAAA,MACJ,MAAM;AAAA,IACR;AAAA,IACA,eAAe;AAAA,MACb,yBAAyB;AAAA,IAC3B;AAAA,IACA,SAAS;AAAA,MACP,uBAAuB;AAAA,MACvB,mBAAmB;AAAA,MACnB,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,IAClB;AAAA,IACA,cAAc;AAAA,MACZ,aAAa;AAAA,MACb,0BAA0B;AAAA,MAC1B,gBAAgB;AAAA,MAChB,wBAAwB;AAAA,IAC1B;AAAA,IACA,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,wBAAwB;AAAA,MACxB,SAAS;AAAA,MACT,iBAAiB;AAAA,MACjB,eAAe;AAAA,IACjB;AAAA,IACA,kBAAkB;AAAA,MAChB,iBAAiB;AAAA,MACjB,eAAe;AAAA,MACf,sBAAsB;AAAA,MACtB,qBAAqB;AAAA,MACrB,wBAAwB;AAAA,MACxB,iBAAiB;AAAA,MACjB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,cAAc;AAAA,MACd,uBAAuB;AAAA,IACzB;AAAA,IACA,kBAAkB;AAAA,MAChB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,WAAW;AAAA,MACX,eAAe;AAAA,MACf,QAAQ;AAAA,IACV;AAAA,IACA,OAAO;AAAA,MACL,YAAY;AAAA,IACd;AAAA,IACA,cAAc;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IACA,qBAAqB;AAAA,MACnB,cAAc;AAAA,MACd,uBAAuB;AAAA,MACvB,cAAc;AAAA,MACd,cAAc;AAAA,IAChB;AAAA,IACA,cAAc;AAAA,MACZ,iBAAiB;AAAA,MACjB,mBAAmB;AAAA,MACnB,sBAAsB;AAAA,MACtB,oBAAoB;AAAA,MACpB,gBAAgB;AAAA,IAClB;AAAA,IACA,YAAY;AAAA,MACV,kBAAkB;AAAA,MAClB,WAAW;AAAA,MACX,oBAAoB;AAAA,MACpB,kBAAkB;AAAA,MAClB,qBAAqB;AAAA,IACvB;AAAA,IACA,OAAO;AAAA,MACL,aAAa;AAAA,IACf;AAAA,EACF;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/i18n/locales/en.ts"],"sourcesContent":["/**\n * @file\n *\n * This file defines the English translations for the `i18n` module.\n */\n\n/**\n * The English translations.\n */\nexport const en = {\n  obsidianLib: {\n    asyncWithNotice: {\n      milliseconds: 'milliseconds...',\n      operation: 'Operation',\n      runningFor: 'Running for',\n      terminateOperation: 'You can terminate the operation by clicking the button below, but be aware it might leave the vault in an inconsistent state.',\n      timedOut: 'The operation timed out after {{duration, number}} milliseconds.'\n    },\n    bulkOperation: {\n      noOperations: 'No bulk operation of this plugin was found in the vault repository.',\n      notActive: 'Bulk operation commits are off, or the vault is not in a git repository.',\n      recoveredInterrupted: 'A bulk operation was interrupted. Its changes were committed as {{operationId}} interrupted.',\n      resumedAfterRecovery: 'The lock of {{recoveredOperationId}} went stale while it ran, so its changes so far were committed as {{recoveredOperationId}} interrupted, and the rest as {{operationId}}. Undoing the whole operation takes reverting both.',\n      revertConflict: 'Reverting {{operationId}} stopped on a conflict. The vault repository is left mid-revert: resolve the conflicts, then run git revert --continue, or git revert --abort to give up.',\n      reverted: 'Reverted {{operationId}}.',\n      revertFailed: 'Failed to revert {{operationId}}: {{error}}',\n      selectOperation: 'Select a bulk operation to undo'\n    },\n    buttons: {\n      cancel: 'Cancel',\n      ok: 'OK'\n    },\n    callout: {\n      loadContent: 'Load content for callout'\n    },\n    dataview: {\n      itemsPerPage: 'Items per page:',\n      jumpToPage: 'Jump to page:',\n      pageHeader: 'Page {{pageNumber, number}} of {{totalPages, number}}, Total items: {{totalItems, number}}'\n    },\n    hotkey: {\n      clear: 'Clear hotkey',\n      notSet: 'Not set',\n      pressHotkey: 'Press a hotkey...'\n    },\n    list: {\n      add: 'Add',\n      empty: 'No items',\n      moveDown: 'Move down',\n      moveUp: 'Move up',\n      remove: 'Remove'\n    },\n    menu: {\n      copy: 'Copy'\n    },\n    metadataCache: {\n      getBacklinksForFilePath: 'Get backlinks for {{filePath}}'\n    },\n    notices: {\n      attachmentIsStillUsed: 'Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.',\n      attachmentRescued: 'Attachment {{attachmentPath}} is still used by other notes. It was moved to {{newAttachmentPath}}.',\n      closeAriaLabel: 'Close',\n      failedToOpenUrl: 'Failed to open {{url}}',\n      unhandledError: 'An unhandled error occurred. Please check the console for more information.'\n    },\n    pathSettings: {\n      invalidGlob: 'Invalid glob pattern: {{glob}} ({{reason}})',\n      invalidRegularExpression: 'Invalid regular expression: {{regExp}} ({{reason}})',\n      trailingEscape: 'it ends with an unescaped \\\\',\n      unclosedCharacterClass: 'a [ character class is never closed with ]'\n    },\n    pluginConflict: {\n      blockedNotice: '{{pluginName}} does nothing while {{conflictingPluginName}} is enabled. Update or disable it to continue.',\n      conflictAppearedNotice: '{{conflictingPluginName}} is now enabled, so {{pluginName}} has stopped working. Update or disable it to resume.',\n      disable: 'Disable {{conflictingPluginName}}',\n      settingsHeading: 'Conflicting plugin',\n      warningNotice: '{{pluginName}} and {{conflictingPluginName}} overlap, and both are running.'\n    },\n    pluginDependency: {\n      alreadyUpToDate: '{{dependencyPluginName}} is already at its latest release. {{pluginName}} needs a version that has not been released yet.',\n      blockedNotice: '{{pluginName}} does nothing until {{dependencyPluginName}} is installed and enabled.',\n      dependencyLostNotice: '{{dependencyPluginName}} is no longer available, so {{pluginName}} has stopped working. Bring it back to resume.',\n      noReadableApiNotice: '{{dependencyPluginName}} is enabled but publishes no API {{pluginName}} can read, so {{pluginName}} does nothing. Update {{dependencyPluginName}} to resume.',\n      openDependencySettings: 'Open {{dependencyPluginName}} settings',\n      settingsHeading: 'Required plugin missing',\n      update: 'Update {{dependencyPluginName}}',\n      updated: '{{dependencyPluginName}} is updated.',\n      updateFailed: 'Failed to update {{dependencyPluginName}}. Check the console for more information.',\n      versionMismatchNotice: '{{pluginName}} needs a newer version of {{dependencyPluginName}}. Update it to resume.'\n    },\n    pluginSuggestion: {\n      enable: 'Enable',\n      install: 'Install and enable',\n      installed: '{{pluginName}} is installed and enabled.',\n      installFailed: 'Failed to install {{pluginName}}. Check the console for more information.',\n      notNow: 'Not now'\n    },\n    queue: {\n      flushQueue: 'Flush queue'\n    },\n    releaseNotes: {\n      title: '{{pluginName}} release notes'\n    },\n    renameDeleteHandler: {\n      handleDelete: 'Handle delete: {{filePath}}',\n      handleOrphanedRenames: 'Handle orphaned renames',\n      handleRename: 'Handle rename: {{oldPath}} -> {{newPath}}',\n      updatedLinks: 'Updated {{linksCount, number}} links in {{filesCount, number}} files.'\n    },\n    resourceLock: {\n      lockedByTooltip: 'Locked by',\n      lockedNoteTooltip: 'This note is locked while an operation is in progress.',\n      unlockConfirmMessage: 'This will cancel the operation(s) currently holding a lock on this note and may leave the vault in an inconsistent state. The note is locked by:',\n      unlockConfirmTitle: 'Unlock note?',\n      unlockMenuItem: 'Unlock'\n    },\n    validation: {\n      controlCharacter: '{{name}} contains a control character.',\n      emptyName: 'The name is empty.',\n      trailingCharacters: '{{name}} ends with a dot or a space, which Windows removes.',\n      unsafeCharacters: '{{name}} contains characters that are not allowed: {{characters}}',\n      windowsReservedName: '{{name}} is a device name Windows reserves, so the file cannot exist on Windows.'\n    },\n    vault: {\n      processFile: 'Process file {{filePath}}'\n    }\n  }\n} as const;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,MAAM,KAAK;AAAA,EAChB,aAAa;AAAA,IACX,iBAAiB;AAAA,MACf,cAAc;AAAA,MACd,WAAW;AAAA,MACX,YAAY;AAAA,MACZ,oBAAoB;AAAA,MACpB,UAAU;AAAA,IACZ;AAAA,IACA,eAAe;AAAA,MACb,cAAc;AAAA,MACd,WAAW;AAAA,MACX,sBAAsB;AAAA,MACtB,sBAAsB;AAAA,MACtB,gBAAgB;AAAA,MAChB,UAAU;AAAA,MACV,cAAc;AAAA,MACd,iBAAiB;AAAA,IACnB;AAAA,IACA,SAAS;AAAA,MACP,QAAQ;AAAA,MACR,IAAI;AAAA,IACN;AAAA,IACA,SAAS;AAAA,MACP,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA,IACA,QAAQ;AAAA,MACN,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,aAAa;AAAA,IACf;AAAA,IACA,MAAM;AAAA,MACJ,KAAK;AAAA,MACL,OAAO;AAAA,MACP,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,QAAQ;AAAA,IACV;AAAA,IACA,MAAM;AAAA,MACJ,MAAM;AAAA,IACR;AAAA,IACA,eAAe;AAAA,MACb,yBAAyB;AAAA,IAC3B;AAAA,IACA,SAAS;AAAA,MACP,uBAAuB;AAAA,MACvB,mBAAmB;AAAA,MACnB,gBAAgB;AAAA,MAChB,iBAAiB;AAAA,MACjB,gBAAgB;AAAA,IAClB;AAAA,IACA,cAAc;AAAA,MACZ,aAAa;AAAA,MACb,0BAA0B;AAAA,MAC1B,gBAAgB;AAAA,MAChB,wBAAwB;AAAA,IAC1B;AAAA,IACA,gBAAgB;AAAA,MACd,eAAe;AAAA,MACf,wBAAwB;AAAA,MACxB,SAAS;AAAA,MACT,iBAAiB;AAAA,MACjB,eAAe;AAAA,IACjB;AAAA,IACA,kBAAkB;AAAA,MAChB,iBAAiB;AAAA,MACjB,eAAe;AAAA,MACf,sBAAsB;AAAA,MACtB,qBAAqB;AAAA,MACrB,wBAAwB;AAAA,MACxB,iBAAiB;AAAA,MACjB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,cAAc;AAAA,MACd,uBAAuB;AAAA,IACzB;AAAA,IACA,kBAAkB;AAAA,MAChB,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,WAAW;AAAA,MACX,eAAe;AAAA,MACf,QAAQ;AAAA,IACV;AAAA,IACA,OAAO;AAAA,MACL,YAAY;AAAA,IACd;AAAA,IACA,cAAc;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IACA,qBAAqB;AAAA,MACnB,cAAc;AAAA,MACd,uBAAuB;AAAA,MACvB,cAAc;AAAA,MACd,cAAc;AAAA,IAChB;AAAA,IACA,cAAc;AAAA,MACZ,iBAAiB;AAAA,MACjB,mBAAmB;AAAA,MACnB,sBAAsB;AAAA,MACtB,oBAAoB;AAAA,MACpB,gBAAgB;AAAA,IAClB;AAAA,IACA,YAAY;AAAA,MACV,kBAAkB;AAAA,MAClB,WAAW;AAAA,MACX,oBAAoB;AAAA,MACpB,kBAAkB;AAAA,MAClB,qBAAqB;AAAA,IACvB;AAAA,IACA,OAAO;AAAA,MACL,aAAa;AAAA,IACf;AAAA,EACF;AACF;","names":[]}

package/dist/lib/cjs/i18n/locales/en.d.cts

@@ -38,6 +38,18 @@ export declare const en: {
             readonly jumpToPage: "Jump to page:";
             readonly pageHeader: "Page {{pageNumber, number}} of {{totalPages, number}}, Total items: {{totalItems, number}}";
         };
+        readonly hotkey: {
+            readonly clear: "Clear hotkey";
+            readonly notSet: "Not set";
+            readonly pressHotkey: "Press a hotkey...";
+        };
+        readonly list: {
+            readonly add: "Add";
+            readonly empty: "No items";
+            readonly moveDown: "Move down";
+            readonly moveUp: "Move up";
+            readonly remove: "Remove";
+        };
         readonly menu: {
             readonly copy: "Copy";
         };

package/dist/lib/cjs/i18n/locales/translations-map.d.cts

@@ -41,6 +41,18 @@ declare const translationsMapImpl: {
                 readonly jumpToPage: "Jump to page:";
                 readonly pageHeader: "Page {{pageNumber, number}} of {{totalPages, number}}, Total items: {{totalItems, number}}";
             };
+            readonly hotkey: {
+                readonly clear: "Clear hotkey";
+                readonly notSet: "Not set";
+                readonly pressHotkey: "Press a hotkey...";
+            };
+            readonly list: {
+                readonly add: "Add";
+                readonly empty: "No items";
+                readonly moveDown: "Move down";
+                readonly moveUp: "Move up";
+                readonly remove: "Remove";
+            };
             readonly menu: {
                 readonly copy: "Copy";
             };