@mnaoumov/obsidian-lib 10.5.0 → 10.6.0

package/dist/lib/cjs/rendered-markdown.d.cts

@@ -0,0 +1,77 @@
+/// <reference path="./library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * The parts of a Reading view's behavior that Obsidian keeps inside its preview renderer, ported for
+ * markdown rendered anywhere else with `MarkdownRenderer.render`.
+ *
+ * `MarkdownPreviewRenderer.registerDomEvents` covers internal and external links, tags, drags, context
+ * menus and the footnote HOVER. Three things it does not cover, read from Obsidian `1.15.0`: the footnote
+ * CLICK (`onFootnoteLinkClick`), and the heading and list FOLDING, whose indicators the renderer only adds
+ * in its own `onRender` and whose clicks only it handles. Without these, a footnote click in standalone
+ * rendered markdown falls through to the browser's hash navigation, and nothing can be folded.
+ */
+/**
+ * Parameters for {@link registerFoldHandlers}.
+ */
+export interface RegisterFoldHandlersParams {
+    /**
+     * The element markdown was rendered into, the one `MarkdownRenderer.render` was handed. Its direct
+     * children are the rendered blocks a folded heading hides.
+     */
+    readonly el: HTMLElement;
+    /**
+     * Whether headings can be folded.
+     *
+     * @default `true`
+     */
+    readonly shouldFoldHeadings?: boolean;
+    /**
+     * Whether list items with a nested list can be folded.
+     *
+     * @default `true`
+     */
+    readonly shouldFoldLists?: boolean;
+}
+/**
+ * Parameters for {@link registerFootnoteLinkHandler}.
+ */
+export interface RegisterFootnoteLinkHandlerParams {
+    /**
+     * The element markdown was rendered into.
+     */
+    readonly el: HTMLElement;
+}
+/**
+ * Whether an element belongs to the markdown rendered into `rootEl`, rather than to a Reading view or a
+ * Bases view nested inside it (an embed), which handles its own events. A port of Obsidian's static
+ * `MarkdownPreviewRenderer.belongsToMe`, which `obsidian-typings` does not declare.
+ *
+ * @param element - The element an event landed on.
+ * @param rootEl - The element markdown was rendered into.
+ * @returns Whether the element is `rootEl` itself or sits inside it with no nested view in between.
+ */
+export declare function isOwnedByRenderedMarkdown(element: Element, rootEl: HTMLElement): boolean;
+/**
+ * Makes the headings and the nested lists of rendered markdown foldable, the way they are in a Reading
+ * view: it adds Obsidian's own collapse indicators and handles their clicks.
+ *
+ * A folded heading hides every block after it up to the next heading of the same or a higher level;
+ * unfolding it shows them again, except those a folded heading among them still hides. A folded list
+ * item hides its nested lists. Call it again after the element is re-rendered: blocks that already have
+ * an indicator are left alone, and the click handler is registered only once per element.
+ *
+ * @param params - The parameters.
+ */
+export declare function registerFoldHandlers(params: RegisterFoldHandlersParams): void;
+/**
+ * Makes a footnote link in rendered markdown act as it does in a Reading view: a click scrolls to the
+ * footnote, or back to its reference, and flashes it, instead of navigating to the link's `#` hash.
+ *
+ * Registered by `registerLinkHandlers`, which is the usual way in; call it directly only for an element
+ * whose other links are handled some other way.
+ *
+ * @param params - The parameters.
+ */
+export declare function registerFootnoteLinkHandler(params: RegisterFootnoteLinkHandlerParams): void;

package/dist/lib/cjs/request-url.cjs

@@ -0,0 +1,523 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+ensureDisposeSymbols();
+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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+var request_url_exports = {};
+__export(request_url_exports, {
+  RequestUrlError: () => RequestUrlError,
+  createRequestUrlFetch: () => createRequestUrlFetch,
+  encodeRequestUrlRequest: () => encodeRequestUrlRequest,
+  requestUrlEx: () => requestUrlEx,
+  requestUrlStream: () => requestUrlStream
+});
+module.exports = __toCommonJS(request_url_exports);
+var import_abort_controller = require('@mnaoumov/typescript-lib/abort-controller');
+var import_function = require('@mnaoumov/typescript-lib/function');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_obsidian = require('obsidian');
+const HTTP_ERROR_STATUS_MIN = 400;
+const ERROR_MESSAGE_BODY_LENGTH = 200;
+const HTTP_SWITCHING_PROTOCOLS_STATUS = 101;
+const HTTP_EARLY_HINTS_STATUS = 103;
+const HTTP_NO_CONTENT_STATUS = 204;
+const HTTP_RESET_CONTENT_STATUS = 205;
+const HTTP_NOT_MODIFIED_STATUS = 304;
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+  HTTP_EARLY_HINTS_STATUS,
+  HTTP_NO_CONTENT_STATUS,
+  HTTP_NOT_MODIFIED_STATUS,
+  HTTP_RESET_CONTENT_STATUS,
+  HTTP_SWITCHING_PROTOCOLS_STATUS
+]);
+const SUPPORTED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+const CONTENT_TYPE_HEADER = "content-type";
+const HEX_RADIX = 16;
+const BOUNDARY_RANDOM_PART_COUNT = 2;
+const RANDOM_PART_START = 2;
+class RequestUrlError extends Error {
+  /**
+   * The response headers.
+   */
+  headers;
+  /**
+   * The HTTP method.
+   */
+  method;
+  /**
+   * The status code.
+   */
+  status;
+  /**
+   * The response body as text.
+   */
+  text;
+  /**
+   * The URL.
+   */
+  url;
+  /**
+   * Creates a {@link RequestUrlError}.
+   *
+   * @param params - The failed request and its response.
+   */
+  constructor(params) {
+    const bodyExcerpt = params.text.length > ERROR_MESSAGE_BODY_LENGTH ? `${params.text.slice(0, ERROR_MESSAGE_BODY_LENGTH)}\u2026` : params.text;
+    super(`${params.method} ${params.url} failed with status ${String(params.status)}${bodyExcerpt ? `: ${bodyExcerpt}` : ""}`);
+    this.name = "RequestUrlError";
+    this.headers = params.headers;
+    this.method = params.method;
+    this.status = params.status;
+    this.text = params.text;
+    this.url = params.url;
+  }
+  /**
+   * Parses the response body as JSON.
+   *
+   * @returns The parsed body.
+   */
+  json() {
+    return JSON.parse(this.text);
+  }
+}
+function createRequestUrlFetch(options = {}) {
+  return async (input, init = {}) => {
+    let request = null;
+    let url;
+    if (typeof input === "string") {
+      url = input;
+    } else if ("method" in input) {
+      request = input;
+      url = input.url;
+    } else {
+      url = input.href;
+    }
+    const method = (init.method ?? request?.method ?? "GET").toUpperCase();
+    const headers = toHeaderRecord(request?.headers, init.headers);
+    let body = init.body ?? void 0;
+    if (body === void 0 && request && method !== "GET" && method !== "HEAD") {
+      body = await request.arrayBuffer();
+    }
+    const params = {
+      abortSignal: init.signal ?? request?.signal ?? void 0,
+      body,
+      headers,
+      method,
+      shouldThrowOnHttpError: false,
+      timeoutInMilliseconds: options.timeoutInMilliseconds,
+      url
+    };
+    if (options.shouldStream) {
+      const streamResponse = await requestUrlStream(params);
+      return createResponse(streamResponse.status, streamResponse.headers, streamResponse.body, streamResponse.url);
+    }
+    const response = await requestUrlEx(params);
+    return createResponse(response.status, response.headers, response.arrayBuffer, url);
+  };
+}
+async function encodeRequestUrlRequest(params) {
+  const url = assertHttpUrl(params.url);
+  const abortSignal = (0, import_abort_controller.abortSignalAny)(
+    params.abortSignal,
+    params.timeoutInMilliseconds === void 0 ? void 0 : (0, import_abort_controller.abortSignalTimeout)(params.timeoutInMilliseconds)
+  );
+  abortSignal.throwIfAborted();
+  const encodedBody = await encodeBody(params.body);
+  abortSignal.throwIfAborted();
+  const headers = { ...params.headers };
+  const hasContentTypeHeader = Object.keys(headers).some((name) => name.toLowerCase() === CONTENT_TYPE_HEADER);
+  const contentType = params.contentType ?? (hasContentTypeHeader ? void 0 : encodedBody.contentType);
+  if (contentType !== void 0) {
+    for (const name of Object.keys(headers)) {
+      if (name.toLowerCase() === CONTENT_TYPE_HEADER) {
+        delete headers[name];
+      }
+    }
+    headers["Content-Type"] = contentType;
+  }
+  return (0, import_object_utils.normalizeOptionalProperties)({
+    abortSignal,
+    body: encodedBody.body,
+    headers,
+    method: (params.method ?? "GET").toUpperCase(),
+    url
+  });
+}
+async function requestUrlEx(params) {
+  const request = await encodeRequestUrlRequest(params);
+  const obsidianRequest = (0, import_object_utils.normalizeOptionalProperties)({
+    body: request.body,
+    headers: { ...request.headers },
+    method: request.method,
+    throw: false,
+    url: request.url
+  });
+  const response = await raceWithAbort(Promise.resolve((0, import_obsidian.requestUrl)(obsidianRequest)), request.abortSignal);
+  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {
+    throw new RequestUrlError({
+      headers: response.headers,
+      method: request.method,
+      status: response.status,
+      text: response.text,
+      url: request.url
+    });
+  }
+  return response;
+}
+async function requestUrlStream(params) {
+  const request = await encodeRequestUrlRequest(params);
+  let response;
+  if (import_obsidian.Platform.isDesktopApp) {
+    const { openDesktopRequestUrlStream } = await import("./desktop-request-url-stream.cjs");
+    response = await openDesktopRequestUrlStream(request);
+  } else {
+    const bufferedResponse = await requestUrlEx({
+      abortSignal: request.abortSignal,
+      body: request.body,
+      headers: request.headers,
+      method: request.method,
+      shouldThrowOnHttpError: false,
+      url: request.url
+    });
+    response = {
+      body: createSingleChunkStream(bufferedResponse.arrayBuffer),
+      headers: bufferedResponse.headers,
+      status: bufferedResponse.status,
+      url: request.url
+    };
+  }
+  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {
+    const text = new TextDecoder().decode(await readStream(response.body));
+    throw new RequestUrlError({
+      headers: response.headers,
+      method: request.method,
+      status: response.status,
+      text,
+      url: response.url
+    });
+  }
+  return response;
+}
+function assertHttpUrl(url) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+  } catch {
+    throw new TypeError(`Invalid URL: ${url}`);
+  }
+  if (!SUPPORTED_PROTOCOLS.has(parsedUrl.protocol)) {
+    throw new TypeError(`Unsupported protocol ${parsedUrl.protocol} in ${url}: only http: and https: URLs can be requested`);
+  }
+  return url;
+}
+function concatBytes(chunks) {
+  const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const bytes = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes.buffer;
+}
+function createResponse(status, headers, body, url) {
+  const response = new Response(NULL_BODY_STATUSES.has(status) ? null : body, {
+    headers: new Headers({ ...headers }),
+    status
+  });
+  Object.defineProperty(response, "url", { value: url });
+  return response;
+}
+function createSingleChunkStream(arrayBuffer) {
+  return new ReadableStream({
+    start(controller) {
+      if (arrayBuffer.byteLength > 0) {
+        controller.enqueue(new Uint8Array(arrayBuffer));
+      }
+      controller.close();
+    }
+  });
+}
+async function encodeBody(body) {
+  if (body === void 0 || typeof body === "string") {
+    return (0, import_object_utils.normalizeOptionalProperties)({ body });
+  }
+  switch (Object.prototype.toString.call(body)) {
+    case "[object ArrayBuffer]": {
+      return { body };
+    }
+    case "[object Blob]":
+    case "[object File]": {
+      const blob = body;
+      return (0, import_object_utils.normalizeOptionalProperties)({ body: await blob.arrayBuffer(), contentType: blob.type || void 0 });
+    }
+    case "[object FormData]": {
+      return await encodeFormData(body);
+    }
+    case "[object ReadableStream]": {
+      return { body: await readStream(body) };
+    }
+    case "[object URLSearchParams]": {
+      return { body: body.toString(), contentType: "application/x-www-form-urlencoded;charset=UTF-8" };
+    }
+    default: {
+      if (ArrayBuffer.isView(body)) {
+        return { body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength).slice().buffer };
+      }
+      throw new TypeError(`Unsupported request body: ${Object.prototype.toString.call(body)}`);
+    }
+  }
+}
+async function encodeFormData(formData) {
+  const boundary = `----ObsidianLibFormBoundary${generateRandomHex()}`;
+  const textEncoder = new TextEncoder();
+  const chunks = [];
+  const entries = [];
+  formData.forEach((value, name) => {
+    entries.push([name, value]);
+  });
+  for (const [name, value] of entries) {
+    let header = `--${boundary}\r
+Content-Disposition: form-data; name="${escapeMultipartName(name)}"`;
+    if (typeof value === "string") {
+      chunks.push(textEncoder.encode(`${header}\r
+\r
+${value}\r
+`));
+      continue;
+    }
+    header += `; filename="${escapeMultipartName(value.name)}"\r
+Content-Type: ${value.type || "application/octet-stream"}\r
+\r
+`;
+    chunks.push(textEncoder.encode(header), new Uint8Array(await value.arrayBuffer()), textEncoder.encode("\r\n"));
+  }
+  chunks.push(textEncoder.encode(`--${boundary}--\r
+`));
+  return { body: concatBytes(chunks), contentType: `multipart/form-data; boundary=${boundary}` };
+}
+function escapeMultipartName(name) {
+  return name.replaceAll('"', "%22").replaceAll("\r", "%0D").replaceAll("\n", "%0A");
+}
+function generateRandomHex() {
+  return Array.from({ length: BOUNDARY_RANDOM_PART_COUNT }, () => Math.random().toString(HEX_RADIX).slice(RANDOM_PART_START)).join("");
+}
+async function raceWithAbort(promise, abortSignal) {
+  var _stack = [];
+  try {
+    let rejectOnAbort = import_function.noop;
+    const abortPromise = new Promise((_resolve, reject) => {
+      rejectOnAbort = reject;
+    });
+    const _abortListener = __using(_stack, (0, import_abort_controller.onAbort)(abortSignal, () => {
+      rejectOnAbort(abortSignal.reason);
+    }));
+    return await Promise.race([promise, abortPromise]);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+async function readStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (; ; ) {
+    const result = await reader.read();
+    if (result.done) {
+      break;
+    }
+    chunks.push(result.value);
+  }
+  return concatBytes(chunks);
+}
+function toHeaderRecord(requestHeaders, initHeaders) {
+  const headers = new Headers(requestHeaders);
+  new Headers(initHeaders).forEach((value, name) => {
+    headers.set(name, value);
+  });
+  const record = {};
+  headers.forEach((value, name) => {
+    record[name] = value;
+  });
+  return record;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RequestUrlError,
+  createRequestUrlFetch,
+  encodeRequestUrlRequest,
+  requestUrlEx,
+  requestUrlStream
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/request-url.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n *\n * A wrapper over Obsidian's {@link requestUrl} that fills the gaps plugins keep hand-rolling: an abort signal and a\n * timeout, request bodies beyond `string | ArrayBuffer` (`FormData`, `URLSearchParams`, `Blob`, typed arrays and\n * streams), an error that carries the status and the body, an up-front protocol check, a streamed response body, and\n * a `fetch`-compatible adapter that third-party SDKs can take.\n *\n * `requestUrl` itself cannot be cancelled: an abort or a timeout settles the returned promise at once, while the\n * underlying request runs to completion and its result is dropped. The streamed variant really cancels on desktop,\n * where it goes through `node:http` / `node:https`; that module is imported dynamically, so this one stays\n * cross-platform-loadable. On mobile the streamed variant falls back to `requestUrl` and delivers the whole body as a\n * single chunk.\n */\n\nimport type {\n  RequestUrlParam,\n  RequestUrlResponse\n} from 'obsidian';\n\nimport {\n  abortSignalAny,\n  abortSignalTimeout,\n  onAbort\n} from '@mnaoumov/typescript-lib/abort-controller';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  Platform,\n  requestUrl\n} from 'obsidian';\n\n/**\n * Options for {@link createRequestUrlFetch}.\n */\nexport interface CreateRequestUrlFetchOptions {\n  /**\n   * Whether to stream the response body through {@link requestUrlStream} rather than buffer it. Streaming is real on\n   * desktop only; on mobile the body still arrives as one chunk. Defaults to `false`.\n   */\n  readonly shouldStream?: boolean;\n\n  /**\n   * The timeout in milliseconds applied to every request, on top of the request's own `signal`.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * The request in the form the transports take: validated, with the body encoded.\n */\nexport interface EncodedRequestUrlRequest {\n  /**\n   * Aborts the request.\n   */\n  readonly abortSignal: AbortSignal;\n\n  /**\n   * The encoded body.\n   */\n  readonly body?: ArrayBuffer | string;\n\n  /**\n   * The request headers, including the content type.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method, uppercase.\n   */\n  readonly method: string;\n\n  /**\n   * The URL.\n   */\n  readonly url: string;\n}\n\n/**\n * Parameters for {@link encodeRequestUrlRequest}.\n */\nexport type EncodeRequestUrlRequestParams = RequestUrlExParams;\n\n/**\n * Parameters for the {@link RequestUrlError} constructor.\n */\nexport interface RequestUrlErrorConstructorParams {\n  /**\n   * The response headers.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method.\n   */\n  readonly method: string;\n\n  /**\n   * The status code.\n   */\n  readonly status: number;\n\n  /**\n   * The response body as text.\n   */\n  readonly text: string;\n\n  /**\n   * The URL.\n   */\n  readonly url: string;\n}\n\n/**\n * A request body {@link requestUrlEx} accepts: everything `fetch` accepts.\n */\nexport type RequestUrlExBody = ArrayBuffer | ArrayBufferView | Blob | FormData | ReadableStream<Uint8Array> | string | URLSearchParams;\n\n/**\n * Parameters for {@link requestUrlEx}.\n */\nexport interface RequestUrlExParams {\n  /**\n   * Aborts the request. The promise rejects with the signal's reason.\n   */\n  readonly abortSignal?: AbortSignal | undefined;\n\n  /**\n   * The request body.\n   */\n  readonly body?: RequestUrlExBody | undefined;\n\n  /**\n   * The content type. When omitted, it is derived from the body: a `FormData` body gets `multipart/form-data` with its\n   * boundary, a `URLSearchParams` body `application/x-www-form-urlencoded` and a `Blob` body its own type — unless\n   * {@link RequestUrlExParams.headers} already carries a `Content-Type`.\n   */\n  readonly contentType?: string | undefined;\n\n  /**\n   * The request headers.\n   */\n  readonly headers?: Readonly<Record<string, string>> | undefined;\n\n  /**\n   * The HTTP method. Defaults to `GET`.\n   */\n  readonly method?: string | undefined;\n\n  /**\n   * Whether to throw a {@link RequestUrlError} when the status code is 400 or higher. Defaults to `true`.\n   */\n  readonly shouldThrowOnHttpError?: boolean | undefined;\n\n  /**\n   * The timeout in milliseconds. The promise rejects with a `TimeoutError` {@link DOMException} once it elapses.\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n\n  /**\n   * The URL. Only `http:` and `https:` URLs are accepted.\n   */\n  readonly url: string;\n}\n\n/**\n * A `fetch`-compatible function built on {@link requestUrl}.\n */\nexport type RequestUrlFetch = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;\n\n/**\n * Parameters for {@link requestUrlStream}.\n */\nexport type RequestUrlStreamParams = RequestUrlExParams;\n\n/**\n * The response of {@link requestUrlStream}.\n */\nexport interface RequestUrlStreamResponse {\n  /**\n   * The response body.\n   */\n  readonly body: ReadableStream<Uint8Array>;\n\n  /**\n   * The response headers, with lowercase names.\n   */\n  readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The status code.\n   */\n  readonly status: number;\n\n  /**\n   * The final URL, after any redirects.\n   */\n  readonly url: string;\n}\n\ninterface EncodedBody {\n  readonly body?: ArrayBuffer | string;\n  readonly contentType?: string;\n}\n\nconst HTTP_ERROR_STATUS_MIN = 400;\nconst ERROR_MESSAGE_BODY_LENGTH = 200;\nconst HTTP_SWITCHING_PROTOCOLS_STATUS = 101;\nconst HTTP_EARLY_HINTS_STATUS = 103;\nconst HTTP_NO_CONTENT_STATUS = 204;\nconst HTTP_RESET_CONTENT_STATUS = 205;\nconst HTTP_NOT_MODIFIED_STATUS = 304;\n// The statuses a Response refuses a body for.\nconst NULL_BODY_STATUSES = new Set([\n  HTTP_EARLY_HINTS_STATUS,\n  HTTP_NO_CONTENT_STATUS,\n  HTTP_NOT_MODIFIED_STATUS,\n  HTTP_RESET_CONTENT_STATUS,\n  HTTP_SWITCHING_PROTOCOLS_STATUS\n]);\nconst SUPPORTED_PROTOCOLS = new Set(['http:', 'https:']);\nconst CONTENT_TYPE_HEADER = 'content-type';\nconst HEX_RADIX = 16;\nconst BOUNDARY_RANDOM_PART_COUNT = 2;\nconst RANDOM_PART_START = 2;\n\n/**\n * The error {@link requestUrlEx} and {@link requestUrlStream} throw for a status code of 400 or higher.\n */\nexport class RequestUrlError extends Error {\n  /**\n   * The response headers.\n   */\n  public readonly headers: Readonly<Record<string, string>>;\n\n  /**\n   * The HTTP method.\n   */\n  public readonly method: string;\n\n  /**\n   * The status code.\n   */\n  public readonly status: number;\n\n  /**\n   * The response body as text.\n   */\n  public readonly text: string;\n\n  /**\n   * The URL.\n   */\n  public readonly url: string;\n\n  /**\n   * Creates a {@link RequestUrlError}.\n   *\n   * @param params - The failed request and its response.\n   */\n  public constructor(params: RequestUrlErrorConstructorParams) {\n    const bodyExcerpt = params.text.length > ERROR_MESSAGE_BODY_LENGTH ? `${params.text.slice(0, ERROR_MESSAGE_BODY_LENGTH)}…` : params.text;\n    super(`${params.method} ${params.url} failed with status ${String(params.status)}${bodyExcerpt ? `: ${bodyExcerpt}` : ''}`);\n    this.name = 'RequestUrlError';\n    this.headers = params.headers;\n    this.method = params.method;\n    this.status = params.status;\n    this.text = params.text;\n    this.url = params.url;\n  }\n\n  /**\n   * Parses the response body as JSON.\n   *\n   * @returns The parsed body.\n   */\n  public json(): unknown {\n    return JSON.parse(this.text);\n  }\n}\n\n/**\n * Creates a `fetch`-compatible function built on {@link requestUrl}, for SDKs that take a custom `fetch` (OpenAI,\n * LangChain, OAuth clients) and would otherwise hit CORS.\n *\n * Unlike `fetch`, it never rejects on an HTTP error status: it resolves with a {@link Response} carrying that status,\n * exactly as `fetch` does. It rejects with a `TypeError` for a URL that is not `http:` or `https:`.\n *\n * @param options - The options.\n * @returns The `fetch`-compatible function.\n */\nexport function createRequestUrlFetch(options: CreateRequestUrlFetchOptions = {}): RequestUrlFetch {\n  return async (input, init = {}) => {\n    let request: null | Request = null;\n    let url: string;\n    if (typeof input === 'string') {\n      url = input;\n    } else if ('method' in input) {\n      // A `URL` has no `method`; `instanceof` would fail across windows.\n      request = input;\n      url = input.url;\n    } else {\n      url = input.href;\n    }\n    const method = (init.method ?? request?.method ?? 'GET').toUpperCase();\n    const headers = toHeaderRecord(request?.headers, init.headers);\n    let body: RequestUrlExBody | undefined = init.body ?? undefined;\n    if (body === undefined && request && method !== 'GET' && method !== 'HEAD') {\n      body = await request.arrayBuffer();\n    }\n    const params: RequestUrlExParams = {\n      abortSignal: init.signal ?? request?.signal ?? undefined,\n      body,\n      headers,\n      method,\n      shouldThrowOnHttpError: false,\n      timeoutInMilliseconds: options.timeoutInMilliseconds,\n      url\n    };\n\n    if (options.shouldStream) {\n      const streamResponse = await requestUrlStream(params);\n      return createResponse(streamResponse.status, streamResponse.headers, streamResponse.body, streamResponse.url);\n    }\n\n    const response = await requestUrlEx(params);\n    return createResponse(response.status, response.headers, response.arrayBuffer, url);\n  };\n}\n\n/**\n * Encodes a request for a transport: validates the URL, combines the abort signal with the timeout, encodes the body\n * and settles the content type.\n *\n * @param params - The request.\n * @returns The encoded request.\n */\nexport async function encodeRequestUrlRequest(params: EncodeRequestUrlRequestParams): Promise<EncodedRequestUrlRequest> {\n  const url = assertHttpUrl(params.url);\n  const abortSignal = abortSignalAny(\n    params.abortSignal,\n    params.timeoutInMilliseconds === undefined ? undefined : abortSignalTimeout(params.timeoutInMilliseconds)\n  );\n  abortSignal.throwIfAborted();\n\n  const encodedBody = await encodeBody(params.body);\n  abortSignal.throwIfAborted();\n\n  const headers: Record<string, string> = { ...params.headers };\n  const hasContentTypeHeader = Object.keys(headers).some((name) => name.toLowerCase() === CONTENT_TYPE_HEADER);\n  const contentType = params.contentType ?? (hasContentTypeHeader ? undefined : encodedBody.contentType);\n  if (contentType !== undefined) {\n    for (const name of Object.keys(headers)) {\n      if (name.toLowerCase() === CONTENT_TYPE_HEADER) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- A header record is keyed by name.\n        delete headers[name];\n      }\n    }\n    headers['Content-Type'] = contentType;\n  }\n\n  return normalizeOptionalProperties<EncodedRequestUrlRequest>({\n    abortSignal,\n    body: encodedBody.body,\n    headers,\n    method: (params.method ?? 'GET').toUpperCase(),\n    url\n  });\n}\n\n/**\n * Requests a URL through {@link requestUrl}, with an abort signal, a timeout, richer bodies, a protocol check and a\n * {@link RequestUrlError} for an HTTP error status.\n *\n * @param params - The request.\n * @returns The response.\n */\nexport async function requestUrlEx(params: RequestUrlExParams): Promise<RequestUrlResponse> {\n  const request = await encodeRequestUrlRequest(params);\n  const obsidianRequest: RequestUrlParam = normalizeOptionalProperties<RequestUrlParam>({\n    body: request.body,\n    headers: { ...request.headers },\n    method: request.method,\n    throw: false,\n    url: request.url\n  });\n  const response = await raceWithAbort(Promise.resolve(requestUrl(obsidianRequest)), request.abortSignal);\n  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {\n    throw new RequestUrlError({\n      headers: response.headers,\n      method: request.method,\n      status: response.status,\n      text: response.text,\n      url: request.url\n    });\n  }\n  return response;\n}\n\n/**\n * Requests a URL and returns its body as a stream.\n *\n * On desktop the request goes through `node:http` / `node:https`, so the body streams as it arrives, an abort really\n * cancels the request, and redirects are followed. On mobile it falls back to {@link requestUrl}, and the whole body\n * arrives as a single chunk.\n *\n * @param params - The request.\n * @returns The response, with a streamed body.\n */\nexport async function requestUrlStream(params: RequestUrlStreamParams): Promise<RequestUrlStreamResponse> {\n  const request = await encodeRequestUrlRequest(params);\n  let response: RequestUrlStreamResponse;\n  if (Platform.isDesktopApp) {\n    const { openDesktopRequestUrlStream } = await import('./desktop-request-url-stream.ts');\n    response = await openDesktopRequestUrlStream(request);\n  } else {\n    const bufferedResponse = await requestUrlEx({\n      abortSignal: request.abortSignal,\n      body: request.body,\n      headers: request.headers,\n      method: request.method,\n      shouldThrowOnHttpError: false,\n      url: request.url\n    });\n    response = {\n      body: createSingleChunkStream(bufferedResponse.arrayBuffer),\n      headers: bufferedResponse.headers,\n      status: bufferedResponse.status,\n      url: request.url\n    };\n  }\n\n  if ((params.shouldThrowOnHttpError ?? true) && response.status >= HTTP_ERROR_STATUS_MIN) {\n    const text = new TextDecoder().decode(await readStream(response.body));\n    throw new RequestUrlError({\n      headers: response.headers,\n      method: request.method,\n      status: response.status,\n      text,\n      url: response.url\n    });\n  }\n  return response;\n}\n\nfunction assertHttpUrl(url: string): string {\n  let parsedUrl: URL;\n  try {\n    parsedUrl = new URL(url);\n  } catch {\n    throw new TypeError(`Invalid URL: ${url}`);\n  }\n  if (!SUPPORTED_PROTOCOLS.has(parsedUrl.protocol)) {\n    throw new TypeError(`Unsupported protocol ${parsedUrl.protocol} in ${url}: only http: and https: URLs can be requested`);\n  }\n  return url;\n}\n\nfunction concatBytes(chunks: readonly Uint8Array[]): ArrayBuffer {\n  const length = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);\n  const bytes = new Uint8Array(length);\n  let offset = 0;\n  for (const chunk of chunks) {\n    bytes.set(chunk, offset);\n    offset += chunk.byteLength;\n  }\n  return bytes.buffer;\n}\n\nfunction createResponse(status: number, headers: Readonly<Record<string, string>>, body: ArrayBuffer | ReadableStream<Uint8Array>, url: string): Response {\n  const response = new Response(NULL_BODY_STATUSES.has(status) ? null : body, {\n    headers: new Headers({ ...headers }),\n    status\n  });\n  Object.defineProperty(response, 'url', { value: url });\n  return response;\n}\n\nfunction createSingleChunkStream(arrayBuffer: ArrayBuffer): ReadableStream<Uint8Array> {\n  return new ReadableStream<Uint8Array>({\n    start(controller): void {\n      if (arrayBuffer.byteLength > 0) {\n        controller.enqueue(new Uint8Array(arrayBuffer));\n      }\n      controller.close();\n    }\n  });\n}\n\nasync function encodeBody(body: RequestUrlExBody | undefined): Promise<EncodedBody> {\n  if (body === undefined || typeof body === 'string') {\n    return normalizeOptionalProperties<EncodedBody>({ body });\n  }\n\n  // `instanceof` fails across windows, so the body kinds are told apart by their built-in tags.\n  switch (Object.prototype.toString.call(body)) {\n    case '[object ArrayBuffer]': {\n      return { body: body as ArrayBuffer };\n    }\n    case '[object Blob]':\n    case '[object File]': {\n      const blob = body as Blob;\n      return normalizeOptionalProperties<EncodedBody>({ body: await blob.arrayBuffer(), contentType: blob.type || undefined });\n    }\n    case '[object FormData]': {\n      return await encodeFormData(body as FormData);\n    }\n    case '[object ReadableStream]': {\n      return { body: await readStream(body as ReadableStream<Uint8Array>) };\n    }\n    case '[object URLSearchParams]': {\n      return { body: (body as URLSearchParams).toString(), contentType: 'application/x-www-form-urlencoded;charset=UTF-8' };\n    }\n    default: {\n      if (ArrayBuffer.isView(body)) {\n        return { body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength).slice().buffer };\n      }\n      throw new TypeError(`Unsupported request body: ${Object.prototype.toString.call(body)}`);\n    }\n  }\n}\n\nasync function encodeFormData(formData: FormData): Promise<EncodedBody> {\n  const boundary = `----ObsidianLibFormBoundary${generateRandomHex()}`;\n  const textEncoder = new TextEncoder();\n  const chunks: Uint8Array[] = [];\n  const entries: [string, FormDataEntryValue][] = [];\n  formData.forEach((value, name) => {\n    entries.push([name, value]);\n  });\n\n  for (const [name, value] of entries) {\n    let header = `--${boundary}\\r\\nContent-Disposition: form-data; name=\"${escapeMultipartName(name)}\"`;\n    if (typeof value === 'string') {\n      chunks.push(textEncoder.encode(`${header}\\r\\n\\r\\n${value}\\r\\n`));\n      continue;\n    }\n    header += `; filename=\"${escapeMultipartName(value.name)}\"\\r\\nContent-Type: ${value.type || 'application/octet-stream'}\\r\\n\\r\\n`;\n    chunks.push(textEncoder.encode(header), new Uint8Array(await value.arrayBuffer()), textEncoder.encode('\\r\\n'));\n  }\n\n  chunks.push(textEncoder.encode(`--${boundary}--\\r\\n`));\n  return { body: concatBytes(chunks), contentType: `multipart/form-data; boundary=${boundary}` };\n}\n\nfunction escapeMultipartName(name: string): string {\n  // The escaping the HTML standard prescribes for multipart/form-data names and file names.\n  return name.replaceAll('\"', '%22').replaceAll('\\r', '%0D').replaceAll('\\n', '%0A');\n}\n\nfunction generateRandomHex(): string {\n  return Array.from({ length: BOUNDARY_RANDOM_PART_COUNT }, () => Math.random().toString(HEX_RADIX).slice(RANDOM_PART_START)).join('');\n}\n\nasync function raceWithAbort<T>(promise: Promise<T>, abortSignal: AbortSignal): Promise<T> {\n  let rejectOnAbort: (reason: Error) => void = noop;\n  const abortPromise = new Promise<never>((_resolve, reject) => {\n    rejectOnAbort = reject;\n  });\n  using _abortListener = onAbort(abortSignal, () => {\n    // The reason is whatever the caller aborted with, an `AbortError` or `TimeoutError` by default.\n    rejectOnAbort(abortSignal.reason as Error);\n  });\n  return await Promise.race([promise, abortPromise]);\n}\n\nasync function readStream(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer> {\n  const reader = stream.getReader();\n  const chunks: Uint8Array[] = [];\n  for (;;) {\n    const result = await reader.read();\n    if (result.done) {\n      break;\n    }\n    chunks.push(result.value);\n  }\n  return concatBytes(chunks);\n}\n\nfunction toHeaderRecord(requestHeaders: Headers | undefined, initHeaders: HeadersInit | undefined): Record<string, string> {\n  const headers = new Headers(requestHeaders);\n  new Headers(initHeaders).forEach((value, name) => {\n    headers.set(name, value);\n  });\n  const record: Record<string, string> = {};\n  headers.forEach((value, name) => {\n    record[name] = value;\n  });\n  return record;\n}\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n"],"mappings":"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","names":[]}