@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/cjs/reference-definition.cjs

@@ -0,0 +1,234 @@
+/*
+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 reference_definition_exports = {};
+__export(reference_definition_exports, {
+  referenceDefinitionToFileChange: () => referenceDefinitionToFileChange
+});
+module.exports = __toCommonJS(reference_definition_exports);
+var import_debug = require('./debug.cjs');
+const ASCII_PUNCTUATION_REG_EXP = /[!-/:-@[-`{-~]/;
+const BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP = /[\s\p{Cc}]/u;
+const DEFINITION_PREFIX_REG_EXP = /^[ \t]*\[(?:\\[\s\S]|[^\\\]])+\]:[ \t]*(?:\r?\n(?:[ \t]*>)*[ \t]*)?/;
+const LINE_BREAK_REG_EXP = /[\r\n]/;
+const WHITESPACE_REG_EXP = /\s/;
+function referenceDefinitionToFileChange(params) {
+  const { content, definition, newDestination } = params;
+  const referenceDefinitionDebugger = (0, import_debug.getObsidianLibDebugger)("ReferenceDefinition:referenceDefinitionToFileChange");
+  const token = findDestinationToken(content, definition);
+  if (!token) {
+    referenceDefinitionDebugger("Skipping a definition whose content does not match its metadata", { definition });
+    return null;
+  }
+  const newRaw = encodeDestination(newDestination, token.isAngle);
+  if (newRaw === null) {
+    referenceDefinitionDebugger("Skipping a destination that holds a line break", { definition, newDestination });
+    return null;
+  }
+  const reference = {
+    link: definition.link,
+    original: token.raw,
+    position: {
+      end: getLoc(content, definition, token.end),
+      start: getLoc(content, definition, token.start)
+    }
+  };
+  return {
+    newContent: newRaw,
+    oldContent: token.raw,
+    reference
+  };
+}
+function canBeBare(destination) {
+  if (destination === "" || destination.startsWith("<") || BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP.test(destination)) {
+    return false;
+  }
+  let depth = 0;
+  for (const character of destination) {
+    if (character === "(") {
+      depth++;
+    } else if (character === ")") {
+      depth--;
+      if (depth < 0) {
+        return false;
+      }
+    }
+  }
+  return depth === 0;
+}
+function encodeDestination(destination, isAngle) {
+  if (LINE_BREAK_REG_EXP.test(destination)) {
+    return null;
+  }
+  const shouldUseAngle = isAngle || !canBeBare(destination);
+  let encoded = "";
+  for (let index = 0; index < destination.length; index++) {
+    const character = destination.charAt(index);
+    const nextCharacter = destination.charAt(index + 1);
+    const isEscapeNeeded = shouldUseAngle ? character === "<" || character === ">" || character === "\\" && (nextCharacter === "" || ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) : character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter);
+    encoded += isEscapeNeeded ? `\\${character}` : character;
+  }
+  return shouldUseAngle ? `<${encoded}>` : encoded;
+}
+function findDestinationToken(content, definition) {
+  const definitionStart = definition.position.start.offset;
+  const definitionEnd = definition.position.end.offset;
+  if (definitionStart < 0 || definitionEnd > content.length || definitionEnd < definitionStart) {
+    return null;
+  }
+  const definitionText = content.slice(definitionStart, definitionEnd);
+  const prefix = DEFINITION_PREFIX_REG_EXP.exec(definitionText);
+  if (!prefix) {
+    return null;
+  }
+  const tokenStart = prefix[0].length;
+  const isAngle = definitionText.charAt(tokenStart) === "<";
+  let tokenEnd = isAngle ? tokenStart + 1 : tokenStart;
+  for (; tokenEnd < definitionText.length; tokenEnd++) {
+    const character = definitionText.charAt(tokenEnd);
+    if (isAngle ? character === ">" || LINE_BREAK_REG_EXP.test(character) : WHITESPACE_REG_EXP.test(character)) {
+      break;
+    }
+    if (character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(definitionText.charAt(tokenEnd + 1))) {
+      tokenEnd++;
+    }
+  }
+  if (isAngle) {
+    if (definitionText.charAt(tokenEnd) !== ">") {
+      return null;
+    }
+    tokenEnd++;
+  }
+  const boundary = definitionText.charAt(tokenEnd);
+  if (boundary !== "" && !WHITESPACE_REG_EXP.test(boundary)) {
+    return null;
+  }
+  const raw = definitionText.slice(tokenStart, tokenEnd);
+  const value = isAngle ? raw.slice(1, -1) : raw;
+  if (tokenEnd === tokenStart || unescapeDestination(value) !== definition.link) {
+    return null;
+  }
+  return {
+    end: definitionStart + tokenEnd,
+    isAngle,
+    raw,
+    start: definitionStart + tokenStart
+  };
+}
+function getLoc(content, definition, offset) {
+  const definitionStart = definition.position.start.offset;
+  let line = definition.position.start.line;
+  for (let index = definitionStart; index < offset; index++) {
+    if (content.charAt(index) === "\n") {
+      line++;
+    }
+  }
+  return {
+    col: offset - (content.lastIndexOf("\n", offset - 1) + 1),
+    line,
+    offset
+  };
+}
+function unescapeDestination(value) {
+  let result = "";
+  for (let index = 0; index < value.length; index++) {
+    const character = value.charAt(index);
+    const nextCharacter = value.charAt(index + 1);
+    if (character === "\\" && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) {
+      result += nextCharacter;
+      index++;
+    } else {
+      result += character;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  referenceDefinitionToFileChange
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/reference-definition.ts"],"sourcesContent":["/**\n * @file\n *\n * Edits the destination of a reference-style link definition (`[id]: destination \"title\"`) that Obsidian reports\n * in `CachedMetadata.referenceLinks`.\n *\n * Read from Obsidian `1.15.1`: a definition's `position` spans the whole definition, its leading indentation\n * included and any blockquote or list marker excluded, and its `link` is the destination with the angle brackets\n * removed and every backslash escape resolved (`Target\\#Escaped.md` reports `Target#Escaped.md`). The uses of a\n * definition (`[text][id]`, `[id][]`, `[id]`) are not reported in `links` and name the definition by its id, so\n * rewriting only the destination keeps every one of them pointing at the new target.\n */\n\nimport type {\n  Loc,\n  ReferenceCache,\n  ReferenceLinkCache\n} from 'obsidian';\n\nimport type { FileChange } from './file-change.ts';\n\nimport { getObsidianLibDebugger } from './debug.ts';\n\n/**\n * Parameters for {@link referenceDefinitionToFileChange}.\n */\nexport interface ReferenceDefinitionToFileChangeParams {\n  /**\n   * The content the definition's position refers to.\n   */\n  readonly content: string;\n\n  /**\n   * The definition, as Obsidian reports it in `CachedMetadata.referenceLinks`.\n   */\n  readonly definition: ReferenceLinkCache;\n\n  /**\n   * The new destination, unescaped, in the same form as {@link ReferenceLinkCache.link}.\n   */\n  readonly newDestination: string;\n}\n\ninterface DestinationToken {\n  readonly end: number;\n  readonly isAngle: boolean;\n  readonly raw: string;\n  readonly start: number;\n}\n\nconst ASCII_PUNCTUATION_REG_EXP = /[!-/:-@[-`{-~]/;\nconst BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP = /[\\s\\p{Cc}]/u;\nconst DEFINITION_PREFIX_REG_EXP = /^[ \\t]*\\[(?:\\\\[\\s\\S]|[^\\\\\\]])+\\]:[ \\t]*(?:\\r?\\n(?:[ \\t]*>)*[ \\t]*)?/;\nconst LINE_BREAK_REG_EXP = /[\\r\\n]/;\nconst WHITESPACE_REG_EXP = /\\s/;\n\n/**\n * Builds the file change that replaces the destination of a reference-style link definition, leaving its id, its\n * title and the rest of the note unchanged.\n *\n * The destination keeps its form: one written in angle brackets stays in them, and a bare one stays bare unless\n * the new destination cannot be written bare (it is empty, holds whitespace or a control character, starts with\n * `<`, or has unbalanced parentheses), in which case it is written in angle brackets. Characters that would end\n * or change the destination are escaped with a backslash.\n *\n * @param params - The parameters for building the file change.\n * @returns The file change, or `null` when the content at the definition's position no longer holds a definition\n * whose destination reads as {@link ReferenceLinkCache.link}, or when the new destination holds a line break,\n * which no destination can.\n */\nexport function referenceDefinitionToFileChange(params: ReferenceDefinitionToFileChangeParams): FileChange | null {\n  const { content, definition, newDestination } = params;\n  const referenceDefinitionDebugger = getObsidianLibDebugger('ReferenceDefinition:referenceDefinitionToFileChange');\n\n  const token = findDestinationToken(content, definition);\n  if (!token) {\n    referenceDefinitionDebugger('Skipping a definition whose content does not match its metadata', { definition });\n    return null;\n  }\n\n  const newRaw = encodeDestination(newDestination, token.isAngle);\n  if (newRaw === null) {\n    referenceDefinitionDebugger('Skipping a destination that holds a line break', { definition, newDestination });\n    return null;\n  }\n\n  const reference: ReferenceCache = {\n    link: definition.link,\n    original: token.raw,\n    position: {\n      end: getLoc(content, definition, token.end),\n      start: getLoc(content, definition, token.start)\n    }\n  };\n\n  return {\n    newContent: newRaw,\n    oldContent: token.raw,\n    reference\n  };\n}\n\nfunction canBeBare(destination: string): boolean {\n  if (destination === '' || destination.startsWith('<') || BARE_DESTINATION_FORBIDDEN_CHARACTER_REG_EXP.test(destination)) {\n    return false;\n  }\n\n  let depth = 0;\n  for (const character of destination) {\n    if (character === '(') {\n      depth++;\n    } else if (character === ')') {\n      depth--;\n      if (depth < 0) {\n        return false;\n      }\n    }\n  }\n\n  return depth === 0;\n}\n\nfunction encodeDestination(destination: string, isAngle: boolean): null | string {\n  if (LINE_BREAK_REG_EXP.test(destination)) {\n    return null;\n  }\n\n  const shouldUseAngle = isAngle || !canBeBare(destination);\n  let encoded = '';\n  for (let index = 0; index < destination.length; index++) {\n    const character = destination.charAt(index);\n    const nextCharacter = destination.charAt(index + 1);\n    const isEscapeNeeded = shouldUseAngle\n      ? character === '<' || character === '>' || (character === '\\\\' && (nextCharacter === '' || ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)))\n      : character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter);\n    encoded += isEscapeNeeded ? `\\\\${character}` : character;\n  }\n\n  return shouldUseAngle ? `<${encoded}>` : encoded;\n}\n\nfunction findDestinationToken(content: string, definition: ReferenceLinkCache): DestinationToken | null {\n  const definitionStart = definition.position.start.offset;\n  const definitionEnd = definition.position.end.offset;\n  if (definitionStart < 0 || definitionEnd > content.length || definitionEnd < definitionStart) {\n    return null;\n  }\n\n  const definitionText = content.slice(definitionStart, definitionEnd);\n  const prefix = DEFINITION_PREFIX_REG_EXP.exec(definitionText);\n  if (!prefix) {\n    return null;\n  }\n\n  const tokenStart = prefix[0].length;\n  const isAngle = definitionText.charAt(tokenStart) === '<';\n  let tokenEnd = isAngle ? tokenStart + 1 : tokenStart;\n  for (; tokenEnd < definitionText.length; tokenEnd++) {\n    const character = definitionText.charAt(tokenEnd);\n    if (isAngle ? character === '>' || LINE_BREAK_REG_EXP.test(character) : WHITESPACE_REG_EXP.test(character)) {\n      break;\n    }\n    if (character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(definitionText.charAt(tokenEnd + 1))) {\n      tokenEnd++;\n    }\n  }\n\n  if (isAngle) {\n    if (definitionText.charAt(tokenEnd) !== '>') {\n      return null;\n    }\n    tokenEnd++;\n  }\n\n  const boundary = definitionText.charAt(tokenEnd);\n  if (boundary !== '' && !WHITESPACE_REG_EXP.test(boundary)) {\n    return null;\n  }\n\n  const raw = definitionText.slice(tokenStart, tokenEnd);\n  const value = isAngle ? raw.slice(1, -1) : raw;\n  if (tokenEnd === tokenStart || unescapeDestination(value) !== definition.link) {\n    return null;\n  }\n\n  return {\n    end: definitionStart + tokenEnd,\n    isAngle,\n    raw,\n    start: definitionStart + tokenStart\n  };\n}\n\nfunction getLoc(content: string, definition: ReferenceLinkCache, offset: number): Loc {\n  const definitionStart = definition.position.start.offset;\n  let line = definition.position.start.line;\n  for (let index = definitionStart; index < offset; index++) {\n    if (content.charAt(index) === '\\n') {\n      line++;\n    }\n  }\n\n  return {\n    col: offset - (content.lastIndexOf('\\n', offset - 1) + 1),\n    line,\n    offset\n  };\n}\n\nfunction unescapeDestination(value: string): string {\n  let result = '';\n  for (let index = 0; index < value.length; index++) {\n    const character = value.charAt(index);\n    const nextCharacter = value.charAt(index + 1);\n    if (character === '\\\\' && ASCII_PUNCTUATION_REG_EXP.test(nextCharacter)) {\n      result += nextCharacter;\n      index++;\n    } else {\n      result += character;\n    }\n  }\n\n  return result;\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/reference-definition.d.cts

@@ -0,0 +1,47 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Edits the destination of a reference-style link definition (`[id]: destination "title"`) that Obsidian reports
+ * in `CachedMetadata.referenceLinks`.
+ *
+ * Read from Obsidian `1.15.1`: a definition's `position` spans the whole definition, its leading indentation
+ * included and any blockquote or list marker excluded, and its `link` is the destination with the angle brackets
+ * removed and every backslash escape resolved (`Target\#Escaped.md` reports `Target#Escaped.md`). The uses of a
+ * definition (`[text][id]`, `[id][]`, `[id]`) are not reported in `links` and name the definition by its id, so
+ * rewriting only the destination keeps every one of them pointing at the new target.
+ */
+import type { ReferenceLinkCache } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { FileChange } from './file-change.cjs';
+/**
+ * Parameters for {@link referenceDefinitionToFileChange}.
+ */
+export interface ReferenceDefinitionToFileChangeParams {
+    /**
+     * The content the definition's position refers to.
+     */
+    readonly content: string;
+    /**
+     * The definition, as Obsidian reports it in `CachedMetadata.referenceLinks`.
+     */
+    readonly definition: ReferenceLinkCache;
+    /**
+     * The new destination, unescaped, in the same form as {@link ReferenceLinkCache.link}.
+     */
+    readonly newDestination: string;
+}
+/**
+ * Builds the file change that replaces the destination of a reference-style link definition, leaving its id, its
+ * title and the rest of the note unchanged.
+ *
+ * The destination keeps its form: one written in angle brackets stays in them, and a bare one stays bare unless
+ * the new destination cannot be written bare (it is empty, holds whitespace or a control character, starts with
+ * `<`, or has unbalanced parentheses), in which case it is written in angle brackets. Characters that would end
+ * or change the destination are escaped with a backslash.
+ *
+ * @param params - The parameters for building the file change.
+ * @returns The file change, or `null` when the content at the definition's position no longer holds a definition
+ * whose destination reads as {@link ReferenceLinkCache.link}, or when the new destination holds a line break,
+ * which no destination can.
+ */
+export declare function referenceDefinitionToFileChange(params: ReferenceDefinitionToFileChangeParams): FileChange | null;

package/dist/lib/cjs/release-asset.cjs

@@ -0,0 +1,279 @@
+/*
+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 release_asset_exports = {};
+__export(release_asset_exports, {
+  ReleaseAssetChecksumError: () => ReleaseAssetChecksumError,
+  computeSha256: () => computeSha256,
+  ensureReleaseAsset: () => ensureReleaseAsset,
+  formatByteSize: () => formatByteSize,
+  getGitHubReleaseAssetUrl: () => getGitHubReleaseAssetUrl
+});
+module.exports = __toCommonJS(release_asset_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_i18n = require('./i18n/i18n.cjs');
+var import_confirm = require('./modals/confirm.cjs');
+var import_request_url = require('./request-url.cjs');
+const BYTES_IN_KILOBYTE = 1024;
+const HEX_BYTE_LENGTH = 2;
+const HEX_RADIX = 16;
+const SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;
+const TEMPORARY_FILE_SUFFIX = ".download";
+class ReleaseAssetChecksumError extends Error {
+  /**
+   * The SHA-256 of the downloaded bytes.
+   */
+  actualSha256;
+  /**
+   * The expected SHA-256.
+   */
+  expectedSha256;
+  /**
+   * The URL the asset was downloaded from.
+   */
+  url;
+  /**
+   * Creates the error.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);
+    this.name = "ReleaseAssetChecksumError";
+    this.actualSha256 = params.actualSha256;
+    this.expectedSha256 = params.expectedSha256;
+    this.url = params.url;
+  }
+}
+const inFlightOperations = /* @__PURE__ */ new Map();
+async function computeSha256(data) {
+  const hash = await window.crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, "0")).join("");
+}
+async function ensureReleaseAsset(params) {
+  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {
+    throw new Error(`Invalid SHA-256: ${params.sha256}`);
+  }
+  if (!params.fileName || /[/\\]/.test(params.fileName) || params.fileName === "." || params.fileName === "..") {
+    throw new Error(`Invalid asset file name: ${params.fileName}`);
+  }
+  const path = (0, import_path.join)(params.cacheFolderPath, params.fileName);
+  const inFlightOperation = inFlightOperations.get(path);
+  if (inFlightOperation) {
+    return await inFlightOperation;
+  }
+  const operation = ensureReleaseAssetImpl(params, path);
+  inFlightOperations.set(path, operation);
+  try {
+    return await operation;
+  } finally {
+    inFlightOperations.delete(path);
+  }
+}
+function formatByteSize(sizeInBytes) {
+  if (sizeInBytes < BYTES_IN_KILOBYTE) {
+    return `${String(sizeInBytes)} B`;
+  }
+  let size = sizeInBytes / BYTES_IN_KILOBYTE;
+  let unit = "KB";
+  for (const largerUnit of ["MB", "GB"]) {
+    if (size < BYTES_IN_KILOBYTE) {
+      break;
+    }
+    size /= BYTES_IN_KILOBYTE;
+    unit = largerUnit;
+  }
+  return `${size.toFixed(1)} ${unit}`;
+}
+function getGitHubReleaseAssetUrl(params) {
+  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;
+}
+async function ensureReleaseAssetImpl(params, path) {
+  const { abortSignal, app } = params;
+  const adapter = app.vault.adapter;
+  const expectedSha256 = params.sha256.toLowerCase();
+  abortSignal?.throwIfAborted();
+  if (await adapter.exists(path)) {
+    const cachedBytes = await adapter.readBinary(path);
+    if (await computeSha256(cachedBytes) === expectedSha256) {
+      return {
+        path,
+        resourceUrl: adapter.getResourcePath(path),
+        wasCached: true
+      };
+    }
+    await adapter.remove(path);
+  }
+  const consentRequest = {
+    fileName: params.fileName,
+    sizeInBytes: params.sizeInBytes,
+    url: params.url
+  };
+  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);
+  if (!isDownloadAllowed) {
+    return null;
+  }
+  abortSignal?.throwIfAborted();
+  const response = await (0, import_request_url.requestUrlEx)({
+    abortSignal,
+    timeoutInMilliseconds: params.timeoutInMilliseconds,
+    url: params.url
+  });
+  const bytes = response.arrayBuffer;
+  const actualSha256 = await computeSha256(bytes);
+  if (actualSha256 !== expectedSha256) {
+    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });
+  }
+  abortSignal?.throwIfAborted();
+  if (!await adapter.exists(params.cacheFolderPath)) {
+    await adapter.mkdir(params.cacheFolderPath);
+  }
+  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;
+  try {
+    await adapter.writeBinary(temporaryPath, bytes);
+    if (await adapter.exists(path)) {
+      await adapter.remove(path);
+    }
+    await adapter.rename(temporaryPath, path);
+  } catch (error) {
+    if (await adapter.exists(temporaryPath)) {
+      await adapter.remove(temporaryPath);
+    }
+    throw error;
+  }
+  return {
+    path,
+    resourceUrl: adapter.getResourcePath(path),
+    wasCached: false
+  };
+}
+async function shouldDownloadWithModal(app, request) {
+  const host = new URL(request.url).host;
+  const message = request.sizeInBytes === void 0 ? (0, import_i18n.t)(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host }) : (0, import_i18n.t)(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });
+  return await (0, import_confirm.confirm)({
+    app,
+    message,
+    okButtonText: (0, import_i18n.t)(($) => $.obsidianLib.releaseAsset.download),
+    title: (0, import_i18n.t)(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReleaseAssetChecksumError,
+  computeSha256,
+  ensureReleaseAsset,
+  formatByteSize,
+  getGitHubReleaseAssetUrl
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/release-asset.ts"],"sourcesContent":["/**\n * @file\n *\n * Downloads an optional data asset of a plugin release on demand: it asks the user first, verifies an expected SHA-256\n * before anything is written or exposed, keeps the verified file in a local cache folder and hands back the adapter\n * resource URL.\n *\n * It uses only cross-platform APIs ({@link requestUrlEx}, the vault adapter and `crypto.subtle`), so it works on desktop\n * and mobile alike.\n *\n * Behavior that is part of the contract:\n *\n * - A cached file is hashed on every call. When its hash matches, it is reused without asking or downloading. When it\n *   does not, it is removed and treated as missing, so a corrupt or truncated cache recovers by itself.\n * - The user is asked only when a download is needed. Declining resolves with `null` and writes nothing.\n * - Downloaded bytes are verified before they are written. A mismatch throws {@link ReleaseAssetChecksumError} and\n *   writes nothing.\n * - The file is written to a temporary sibling and then renamed into place, so an interrupted write never leaves a\n *   partial file under the cached name.\n * - An abort (pass the plugin's abort signal, so a plugin unload counts) rejects with the signal's reason. Once the\n *   download has finished, the signal is checked again before writing, so nothing is written after an unload.\n * - Concurrent calls for the same cache path share one operation, so the user is asked once.\n */\n\nimport type { App } from 'obsidian';\n\nimport { join } from '@mnaoumov/typescript-lib/path';\n\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport { requestUrlEx } from './request-url.ts';\n\nconst BYTES_IN_KILOBYTE = 1024;\nconst HEX_BYTE_LENGTH = 2;\nconst HEX_RADIX = 16;\nconst SHA_256_HEX_REG_EXP = /^[0-9a-f]{64}$/i;\nconst TEMPORARY_FILE_SUFFIX = '.download';\n\n/**\n * Parameters for {@link ensureReleaseAsset}.\n */\nexport interface EnsureReleaseAssetParams {\n  /**\n   * Aborts the operation. Pass the plugin's abort signal, so an unload stops it.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The Obsidian application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The vault-relative folder that holds the cached file, typically `${plugin.manifest.dir}/assets`.\n   *\n   * A folder inside the config folder is not synced, so each device downloads the asset once.\n   */\n  readonly cacheFolderPath: string;\n\n  /**\n   * The name of the cached file. It must not contain a path separator.\n   */\n  readonly fileName: string;\n\n  /**\n   * The expected SHA-256 of the asset, as 64 hexadecimal digits.\n   */\n  readonly sha256: string;\n\n  /**\n   * Asks the user whether to download the asset. Defaults to a confirmation modal.\n   *\n   * Pass `() => Promise.resolve(true)` when the user has already agreed, for example through a setting.\n   */\n  readonly shouldDownload?: ((request: ReleaseAssetConsentRequest) => Promise<boolean>) | undefined;\n\n  /**\n   * The size of the asset in bytes, shown to the user when asking.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The download timeout in milliseconds.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL to download the asset from. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link getGitHubReleaseAssetUrl}.\n */\nexport interface GetGitHubReleaseAssetUrlParams {\n  /**\n   * The name of the release asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The repository, as `<owner>/<name>`.\n   */\n  readonly repository: string;\n\n  /**\n   * The release tag, typically the plugin version.\n   */\n  readonly tag: string;\n}\n\n/**\n * A verified release asset.\n */\nexport interface ReleaseAsset {\n  /**\n   * The vault-relative path of the cached file.\n   */\n  readonly path: string;\n\n  /**\n   * The resource URL of the cached file, from the adapter's `getResourcePath`.\n   */\n  readonly resourceUrl: string;\n\n  /**\n   * Whether the file was already cached, so nothing was downloaded.\n   */\n  readonly wasCached: boolean;\n}\n\n/**\n * Parameters for {@link ReleaseAssetChecksumError}.\n */\nexport interface ReleaseAssetChecksumErrorConstructorParams {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * What the user is asked to agree to.\n */\nexport interface ReleaseAssetConsentRequest {\n  /**\n   * The name of the asset.\n   */\n  readonly fileName: string;\n\n  /**\n   * The size of the asset in bytes, when known.\n   */\n  readonly sizeInBytes?: number | undefined;\n\n  /**\n   * The URL the asset is downloaded from.\n   */\n  readonly url: string;\n}\n\n/**\n * Thrown when downloaded bytes do not match the expected SHA-256. Nothing was written.\n */\nexport class ReleaseAssetChecksumError extends Error {\n  /**\n   * The SHA-256 of the downloaded bytes.\n   */\n  public readonly actualSha256: string;\n\n  /**\n   * The expected SHA-256.\n   */\n  public readonly expectedSha256: string;\n\n  /**\n   * The URL the asset was downloaded from.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates the error.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: ReleaseAssetChecksumErrorConstructorParams) {\n    super(`The asset downloaded from ${params.url} has SHA-256 ${params.actualSha256}, expected ${params.expectedSha256}.`);\n    this.name = 'ReleaseAssetChecksumError';\n    this.actualSha256 = params.actualSha256;\n    this.expectedSha256 = params.expectedSha256;\n    this.url = params.url;\n  }\n}\n\nconst inFlightOperations = new Map<string, Promise<null | ReleaseAsset>>();\n\n/**\n * Computes the SHA-256 of the given bytes.\n *\n * @param data - The bytes.\n * @returns The SHA-256 as 64 lowercase hexadecimal digits.\n */\nexport async function computeSha256(data: ArrayBuffer): Promise<string> {\n  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- This is the Obsidian renderer Web API, not a Node builtin.\n  const hash = await window.crypto.subtle.digest('SHA-256', data);\n  return [...new Uint8Array(hash)].map((byte) => byte.toString(HEX_RADIX).padStart(HEX_BYTE_LENGTH, '0')).join('');\n}\n\n/**\n * Returns the cached, verified asset, downloading it first, with the user's consent, when it is missing or corrupt.\n *\n * @param params - The parameters.\n * @returns The verified asset, or `null` when the user declined the download.\n */\nexport async function ensureReleaseAsset(params: EnsureReleaseAssetParams): Promise<null | ReleaseAsset> {\n  if (!SHA_256_HEX_REG_EXP.test(params.sha256)) {\n    throw new Error(`Invalid SHA-256: ${params.sha256}`);\n  }\n\n  if (!params.fileName || /[/\\\\]/.test(params.fileName) || params.fileName === '.' || params.fileName === '..') {\n    throw new Error(`Invalid asset file name: ${params.fileName}`);\n  }\n\n  const path = join(params.cacheFolderPath, params.fileName);\n  const inFlightOperation = inFlightOperations.get(path);\n  if (inFlightOperation) {\n    return await inFlightOperation;\n  }\n\n  const operation = ensureReleaseAssetImpl(params, path);\n  inFlightOperations.set(path, operation);\n  try {\n    return await operation;\n  } finally {\n    inFlightOperations.delete(path);\n  }\n}\n\n/**\n * Formats a byte size for a person to read.\n *\n * @param sizeInBytes - The size in bytes.\n * @returns The formatted size, such as `12.3 MB`.\n */\nexport function formatByteSize(sizeInBytes: number): string {\n  if (sizeInBytes < BYTES_IN_KILOBYTE) {\n    return `${String(sizeInBytes)} B`;\n  }\n  let size = sizeInBytes / BYTES_IN_KILOBYTE;\n  let unit = 'KB';\n  for (const largerUnit of ['MB', 'GB']) {\n    if (size < BYTES_IN_KILOBYTE) {\n      break;\n    }\n    size /= BYTES_IN_KILOBYTE;\n    unit = largerUnit;\n  }\n  return `${size.toFixed(1)} ${unit}`;\n}\n\n/**\n * Builds the download URL of a GitHub release asset.\n *\n * @param params - The parameters.\n * @returns The URL.\n */\nexport function getGitHubReleaseAssetUrl(params: GetGitHubReleaseAssetUrlParams): string {\n  return `https://github.com/${params.repository}/releases/download/${encodeURIComponent(params.tag)}/${encodeURIComponent(params.fileName)}`;\n}\n\nasync function ensureReleaseAssetImpl(params: EnsureReleaseAssetParams, path: string): Promise<null | ReleaseAsset> {\n  const { abortSignal, app } = params;\n  const adapter = app.vault.adapter;\n  const expectedSha256 = params.sha256.toLowerCase();\n  abortSignal?.throwIfAborted();\n\n  if (await adapter.exists(path)) {\n    const cachedBytes = await adapter.readBinary(path);\n    if (await computeSha256(cachedBytes) === expectedSha256) {\n      return {\n        path,\n        resourceUrl: adapter.getResourcePath(path),\n        wasCached: true\n      };\n    }\n    await adapter.remove(path);\n  }\n\n  const consentRequest: ReleaseAssetConsentRequest = {\n    fileName: params.fileName,\n    sizeInBytes: params.sizeInBytes,\n    url: params.url\n  };\n  const isDownloadAllowed = params.shouldDownload ? await params.shouldDownload(consentRequest) : await shouldDownloadWithModal(app, consentRequest);\n  if (!isDownloadAllowed) {\n    return null;\n  }\n  abortSignal?.throwIfAborted();\n\n  const response = await requestUrlEx({\n    abortSignal,\n    timeoutInMilliseconds: params.timeoutInMilliseconds,\n    url: params.url\n  });\n  const bytes = response.arrayBuffer;\n  const actualSha256 = await computeSha256(bytes);\n  if (actualSha256 !== expectedSha256) {\n    throw new ReleaseAssetChecksumError({ actualSha256, expectedSha256, url: params.url });\n  }\n  abortSignal?.throwIfAborted();\n\n  if (!await adapter.exists(params.cacheFolderPath)) {\n    await adapter.mkdir(params.cacheFolderPath);\n  }\n\n  const temporaryPath = `${path}${TEMPORARY_FILE_SUFFIX}`;\n  try {\n    await adapter.writeBinary(temporaryPath, bytes);\n    if (await adapter.exists(path)) {\n      await adapter.remove(path);\n    }\n    await adapter.rename(temporaryPath, path);\n  } catch (error) {\n    if (await adapter.exists(temporaryPath)) {\n      await adapter.remove(temporaryPath);\n    }\n    throw error;\n  }\n\n  return {\n    path,\n    resourceUrl: adapter.getResourcePath(path),\n    wasCached: false\n  };\n}\n\nasync function shouldDownloadWithModal(app: App, request: ReleaseAssetConsentRequest): Promise<boolean> {\n  const host = new URL(request.url).host;\n  const message = request.sizeInBytes === undefined\n    ? t(($) => $.obsidianLib.releaseAsset.consentMessageUnknownSize, { fileName: request.fileName, host })\n    : t(($) => $.obsidianLib.releaseAsset.consentMessage, { fileName: request.fileName, host, size: formatByteSize(request.sizeInBytes) });\n  return await confirm({\n    app,\n    message,\n    okButtonText: t(($) => $.obsidianLib.releaseAsset.download),\n    title: t(($) => $.obsidianLib.releaseAsset.consentTitle, { fileName: request.fileName })\n  });\n}\n"],"mappings":"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","names":[]}