@mnaoumov/obsidian-lib 10.5.1 → 10.6.0

package/dist/lib/esm/rendered-markdown.mjs

@@ -0,0 +1,219 @@
+/*
+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();
+})();
+
+import {
+  invokeAsyncSafely,
+  sleep
+} from "@mnaoumov/typescript-lib/async";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { setIcon } from "obsidian";
+import { CssClass } from "./css-class.mjs";
+const FLASH_DURATION_IN_MILLISECONDS = 3e3;
+const FOLD_ICON = "right-triangle";
+const HEADING_TAG_NAMES = /* @__PURE__ */ new Set(["H1", "H2", "H3", "H4", "H5", "H6"]);
+function isOwnedByRenderedMarkdown(element, rootEl) {
+  let current = element;
+  while (current) {
+    if (current === rootEl) {
+      return true;
+    }
+    if (current.hasClass("markdown-preview-view") || current.hasClass("bases-view")) {
+      return false;
+    }
+    current = current.parentElement;
+  }
+  return false;
+}
+function registerFoldHandlers(params) {
+  const {
+    el,
+    shouldFoldHeadings = true,
+    shouldFoldLists = true
+  } = params;
+  el.addClass(CssClass.LibraryName, CssClass.FoldableMarkdown);
+  if (shouldFoldHeadings) {
+    for (const block of getBlocks(el)) {
+      const headingEl = getBlockHeading(block);
+      if (headingEl && !headingEl.querySelector(":scope > .heading-collapse-indicator")) {
+        addIndicator(headingEl, "heading-collapse-indicator");
+      }
+    }
+  }
+  if (shouldFoldLists) {
+    for (const listItemEl of el.findAll("li")) {
+      if (isOwnedByRenderedMarkdown(listItemEl, el) && listItemEl.querySelector(":scope > ul, :scope > ol") && !listItemEl.querySelector(":scope > .list-collapse-indicator")) {
+        addIndicator(listItemEl, "list-collapse-indicator");
+      }
+    }
+  }
+  if (registeredFoldEls.has(el)) {
+    return;
+  }
+  registeredFoldEls.add(el);
+  el.on("click", ".heading-collapse-indicator", (clickEvent, indicatorEl) => {
+    handleIndicatorClick(clickEvent, indicatorEl, el, (headingEl) => {
+      if (!isHeading(headingEl)) {
+        return;
+      }
+      toggleCollapsed(headingEl, !headingEl.hasClass("is-collapsed"));
+      updateFoldedBlocks(el);
+      el.win.getSelection()?.removeAllRanges();
+    });
+  });
+  el.on("click", "li > .list-collapse-indicator", (clickEvent, indicatorEl) => {
+    handleIndicatorClick(clickEvent, indicatorEl, el, (listItemEl) => {
+      toggleCollapsed(listItemEl, !listItemEl.hasClass("is-collapsed"));
+    });
+  });
+}
+function registerFootnoteLinkHandler(params) {
+  const { el } = params;
+  el.on("click", "a.footnote-link", (clickEvent, linkEl) => {
+    if (clickEvent.button !== 0 || !isOwnedByRenderedMarkdown(linkEl, el)) {
+      return;
+    }
+    clickEvent.preventDefault();
+    const href = linkEl.getAttr("href");
+    if (!href?.startsWith("#")) {
+      return;
+    }
+    const footnoteId = href.slice(1);
+    const targetEl = el.findAll("[data-footnote-id]").find((candidateEl) => candidateEl.getAttr("data-footnote-id") === footnoteId);
+    if (!targetEl) {
+      return;
+    }
+    unfoldAncestors(targetEl, el);
+    targetEl.scrollIntoView({ block: "center" });
+    flash(targetEl, el);
+  });
+}
+const registeredFoldEls = /* @__PURE__ */ new WeakSet();
+function addIndicator(parentEl, cls) {
+  const indicatorEl = parentEl.createSpan({
+    cls: [cls, "collapse-indicator", "collapse-icon"],
+    prepend: true
+  });
+  setIcon(indicatorEl, FOLD_ICON);
+}
+function flash(targetEl, rootEl) {
+  for (const flashingEl of rootEl.findAll(".is-flashing")) {
+    flashingEl.removeClass("is-flashing");
+  }
+  targetEl.addClass("is-flashing");
+  invokeAsyncSafely(async () => {
+    await sleep({ milliseconds: FLASH_DURATION_IN_MILLISECONDS });
+    targetEl.removeClass("is-flashing");
+  });
+}
+function getBlockHeading(block) {
+  if (isHeading(block)) {
+    return block;
+  }
+  const firstChild = block.firstElementChild;
+  return firstChild && isHeading(firstChild) ? firstChild : null;
+}
+function getBlockHeadingLevel(block) {
+  const headingEl = getBlockHeading(block);
+  return headingEl ? getHeadingLevel(headingEl) : null;
+}
+function getBlocks(rootEl) {
+  return rootEl.findAll(":scope > *");
+}
+function getHeadingLevel(headingEl) {
+  return Number(headingEl.tagName.slice(1));
+}
+function handleIndicatorClick(clickEvent, indicatorEl, rootEl, toggle) {
+  if (clickEvent.button !== 0 || clickEvent.defaultPrevented || !isOwnedByRenderedMarkdown(indicatorEl, rootEl)) {
+    return;
+  }
+  clickEvent.preventDefault();
+  toggle(ensureNonNullable(indicatorEl.parentElement));
+}
+function isHeading(element) {
+  return HEADING_TAG_NAMES.has(element.tagName);
+}
+function toggleCollapsed(parentEl, isCollapsed) {
+  parentEl.toggleClass("is-collapsed", isCollapsed);
+  parentEl.querySelector(":scope > .collapse-icon")?.toggleClass("is-collapsed", isCollapsed);
+}
+function unfoldAncestors(targetEl, rootEl) {
+  let targetBlock = targetEl;
+  for (; ; ) {
+    if (targetBlock.tagName === "LI" && targetBlock.hasClass("is-collapsed")) {
+      toggleCollapsed(targetBlock, false);
+    }
+    const parentEl = ensureNonNullable(targetBlock.parentElement);
+    if (parentEl === rootEl) {
+      break;
+    }
+    targetBlock = parentEl;
+  }
+  const blocks = getBlocks(rootEl);
+  let level = getBlockHeadingLevel(targetBlock) ?? Infinity;
+  let hasUnfolded = false;
+  for (let index = blocks.indexOf(targetBlock) - 1; index >= 0; index--) {
+    const headingEl = getBlockHeading(ensureNonNullable(blocks[index]));
+    if (!headingEl || getHeadingLevel(headingEl) >= level) {
+      continue;
+    }
+    level = getHeadingLevel(headingEl);
+    if (!headingEl.hasClass("is-collapsed")) {
+      continue;
+    }
+    toggleCollapsed(headingEl, false);
+    hasUnfolded = true;
+  }
+  if (hasUnfolded) {
+    updateFoldedBlocks(rootEl);
+  }
+}
+function updateFoldedBlocks(rootEl) {
+  let foldedLevel = null;
+  for (const block of getBlocks(rootEl)) {
+    const headingEl = getBlockHeading(block);
+    const headingLevel = headingEl ? getHeadingLevel(headingEl) : null;
+    if (foldedLevel !== null && headingLevel !== null && headingLevel <= foldedLevel) {
+      foldedLevel = null;
+    }
+    const isShown = foldedLevel === null;
+    block.toggle(isShown);
+    if (isShown && headingEl?.hasClass("is-collapsed")) {
+      foldedLevel = headingLevel;
+    }
+  }
+}
+export {
+  isOwnedByRenderedMarkdown,
+  registerFoldHandlers,
+  registerFootnoteLinkHandler
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/rendered-markdown.ts"],"sourcesContent":["/**\n * @file\n *\n * The parts of a Reading view's behavior that Obsidian keeps inside its preview renderer, ported for\n * markdown rendered anywhere else with `MarkdownRenderer.render`.\n *\n * `MarkdownPreviewRenderer.registerDomEvents` covers internal and external links, tags, drags, context\n * menus and the footnote HOVER. Three things it does not cover, read from Obsidian `1.15.0`: the footnote\n * CLICK (`onFootnoteLinkClick`), and the heading and list FOLDING, whose indicators the renderer only adds\n * in its own `onRender` and whose clicks only it handles. Without these, a footnote click in standalone\n * rendered markdown falls through to the browser's hash navigation, and nothing can be folded.\n */\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '@mnaoumov/typescript-lib/async';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { setIcon } from 'obsidian';\n\nimport { CssClass } from './css-class.ts';\n\n/**\n * How long a footnote's target stays highlighted after a click took it there, as in Obsidian's own\n * `highlightEl`.\n */\nconst FLASH_DURATION_IN_MILLISECONDS = 3000;\n\nconst FOLD_ICON = 'right-triangle';\n\nconst HEADING_TAG_NAMES = new Set(['H1', 'H2', 'H3', 'H4', 'H5', 'H6']);\n\n/**\n * Parameters for {@link registerFoldHandlers}.\n */\nexport interface RegisterFoldHandlersParams {\n  /**\n   * The element markdown was rendered into, the one `MarkdownRenderer.render` was handed. Its direct\n   * children are the rendered blocks a folded heading hides.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * Whether headings can be folded.\n   *\n   * @default `true`\n   */\n  readonly shouldFoldHeadings?: boolean;\n\n  /**\n   * Whether list items with a nested list can be folded.\n   *\n   * @default `true`\n   */\n  readonly shouldFoldLists?: boolean;\n}\n\n/**\n * Parameters for {@link registerFootnoteLinkHandler}.\n */\nexport interface RegisterFootnoteLinkHandlerParams {\n  /**\n   * The element markdown was rendered into.\n   */\n  readonly el: HTMLElement;\n}\n\n/**\n * Whether an element belongs to the markdown rendered into `rootEl`, rather than to a Reading view or a\n * Bases view nested inside it (an embed), which handles its own events. A port of Obsidian's static\n * `MarkdownPreviewRenderer.belongsToMe`, which `obsidian-typings` does not declare.\n *\n * @param element - The element an event landed on.\n * @param rootEl - The element markdown was rendered into.\n * @returns Whether the element is `rootEl` itself or sits inside it with no nested view in between.\n */\nexport function isOwnedByRenderedMarkdown(element: Element, rootEl: HTMLElement): boolean {\n  let current: Element | null = element;\n  while (current) {\n    if (current === rootEl) {\n      return true;\n    }\n    if (current.hasClass('markdown-preview-view') || current.hasClass('bases-view')) {\n      return false;\n    }\n    current = current.parentElement;\n  }\n  return false;\n}\n\n/**\n * Makes the headings and the nested lists of rendered markdown foldable, the way they are in a Reading\n * view: it adds Obsidian's own collapse indicators and handles their clicks.\n *\n * A folded heading hides every block after it up to the next heading of the same or a higher level;\n * unfolding it shows them again, except those a folded heading among them still hides. A folded list\n * item hides its nested lists. Call it again after the element is re-rendered: blocks that already have\n * an indicator are left alone, and the click handler is registered only once per element.\n *\n * @param params - The parameters.\n */\nexport function registerFoldHandlers(params: RegisterFoldHandlersParams): void {\n  const {\n    el,\n    shouldFoldHeadings = true,\n    shouldFoldLists = true\n  } = params;\n\n  el.addClass(CssClass.LibraryName, CssClass.FoldableMarkdown);\n\n  if (shouldFoldHeadings) {\n    for (const block of getBlocks(el)) {\n      const headingEl = getBlockHeading(block);\n      if (headingEl && !headingEl.querySelector(':scope > .heading-collapse-indicator')) {\n        addIndicator(headingEl, 'heading-collapse-indicator');\n      }\n    }\n  }\n\n  if (shouldFoldLists) {\n    for (const listItemEl of el.findAll('li')) {\n      if (\n        isOwnedByRenderedMarkdown(listItemEl, el)\n        && listItemEl.querySelector(':scope > ul, :scope > ol')\n        && !listItemEl.querySelector(':scope > .list-collapse-indicator')\n      ) {\n        addIndicator(listItemEl, 'list-collapse-indicator');\n      }\n    }\n  }\n\n  if (registeredFoldEls.has(el)) {\n    return;\n  }\n  registeredFoldEls.add(el);\n\n  el.on('click', '.heading-collapse-indicator', (clickEvent, indicatorEl) => {\n    handleIndicatorClick(clickEvent, indicatorEl, el, (headingEl) => {\n      if (!isHeading(headingEl)) {\n        return;\n      }\n      toggleCollapsed(headingEl, !headingEl.hasClass('is-collapsed'));\n      updateFoldedBlocks(el);\n      el.win.getSelection()?.removeAllRanges();\n    });\n  });\n\n  el.on('click', 'li > .list-collapse-indicator', (clickEvent, indicatorEl) => {\n    handleIndicatorClick(clickEvent, indicatorEl, el, (listItemEl) => {\n      toggleCollapsed(listItemEl, !listItemEl.hasClass('is-collapsed'));\n    });\n  });\n}\n\n/**\n * Makes a footnote link in rendered markdown act as it does in a Reading view: a click scrolls to the\n * footnote, or back to its reference, and flashes it, instead of navigating to the link's `#` hash.\n *\n * Registered by `registerLinkHandlers`, which is the usual way in; call it directly only for an element\n * whose other links are handled some other way.\n *\n * @param params - The parameters.\n */\nexport function registerFootnoteLinkHandler(params: RegisterFootnoteLinkHandlerParams): void {\n  const { el } = params;\n  el.on('click', 'a.footnote-link', (clickEvent, linkEl) => {\n    if (clickEvent.button !== 0 || !isOwnedByRenderedMarkdown(linkEl, el)) {\n      return;\n    }\n    clickEvent.preventDefault();\n\n    const href = linkEl.getAttr('href');\n    if (!href?.startsWith('#')) {\n      return;\n    }\n    const footnoteId = href.slice(1);\n    const targetEl = el.findAll('[data-footnote-id]').find((candidateEl) => candidateEl.getAttr('data-footnote-id') === footnoteId);\n    if (!targetEl) {\n      return;\n    }\n\n    unfoldAncestors(targetEl, el);\n    targetEl.scrollIntoView({ block: 'center' });\n    flash(targetEl, el);\n  });\n}\n\nconst registeredFoldEls = new WeakSet<HTMLElement>();\n\nfunction addIndicator(parentEl: HTMLElement, cls: string): void {\n  const indicatorEl = parentEl.createSpan({\n    cls: [cls, 'collapse-indicator', 'collapse-icon'],\n    prepend: true\n  });\n  setIcon(indicatorEl, FOLD_ICON);\n}\n\nfunction flash(targetEl: HTMLElement, rootEl: HTMLElement): void {\n  for (const flashingEl of rootEl.findAll('.is-flashing')) {\n    flashingEl.removeClass('is-flashing');\n  }\n  targetEl.addClass('is-flashing');\n  invokeAsyncSafely(async () => {\n    await sleep({ milliseconds: FLASH_DURATION_IN_MILLISECONDS });\n    targetEl.removeClass('is-flashing');\n  });\n}\n\nfunction getBlockHeading(block: Element): HTMLElement | null {\n  if (isHeading(block)) {\n    return block;\n  }\n  const firstChild = block.firstElementChild;\n  return firstChild && isHeading(firstChild) ? firstChild : null;\n}\n\nfunction getBlockHeadingLevel(block: Element): null | number {\n  const headingEl = getBlockHeading(block);\n  return headingEl ? getHeadingLevel(headingEl) : null;\n}\n\nfunction getBlocks(rootEl: HTMLElement): HTMLElement[] {\n  return rootEl.findAll(':scope > *');\n}\n\nfunction getHeadingLevel(headingEl: HTMLElement): number {\n  return Number(headingEl.tagName.slice(1));\n}\n\nfunction handleIndicatorClick(\n  clickEvent: MouseEvent,\n  indicatorEl: HTMLElement,\n  rootEl: HTMLElement,\n  toggle: (parentEl: Element) => void\n): void {\n  if (clickEvent.button !== 0 || clickEvent.defaultPrevented || !isOwnedByRenderedMarkdown(indicatorEl, rootEl)) {\n    return;\n  }\n  clickEvent.preventDefault();\n  // The delegated click matched the indicator inside `rootEl`, so it has a parent.\n  toggle(ensureNonNullable(indicatorEl.parentElement));\n}\n\nfunction isHeading(element: Element): element is HTMLElement {\n  return HEADING_TAG_NAMES.has(element.tagName);\n}\n\nfunction toggleCollapsed(parentEl: Element, isCollapsed: boolean): void {\n  parentEl.toggleClass('is-collapsed', isCollapsed);\n  parentEl.querySelector<HTMLElement>(':scope > .collapse-icon')?.toggleClass('is-collapsed', isCollapsed);\n}\n\n/**\n * Unfolds whatever hides `targetEl`: every folded list item around it, and every folded heading it sits\n * under, so a footnote click never scrolls to an element nobody can see.\n *\n * @param targetEl - The element to reveal.\n * @param rootEl - The element markdown was rendered into.\n */\nfunction unfoldAncestors(targetEl: HTMLElement, rootEl: HTMLElement): void {\n  let targetBlock: Element = targetEl;\n  for (;;) {\n    if (targetBlock.tagName === 'LI' && targetBlock.hasClass('is-collapsed')) {\n      toggleCollapsed(targetBlock, false);\n    }\n    // `targetEl` was found inside `rootEl`, so the walk reaches it before running out of parents.\n    const parentEl = ensureNonNullable(targetBlock.parentElement);\n    if (parentEl === rootEl) {\n      break;\n    }\n    targetBlock = parentEl;\n  }\n\n  // The headings a block sits under are the nearest earlier heading of each strictly lower level.\n  const blocks: Element[] = getBlocks(rootEl);\n  let level = getBlockHeadingLevel(targetBlock) ?? Infinity;\n  let hasUnfolded = false;\n  for (let index = blocks.indexOf(targetBlock) - 1; index >= 0; index--) {\n    const headingEl = getBlockHeading(ensureNonNullable(blocks[index]));\n    if (!headingEl || getHeadingLevel(headingEl) >= level) {\n      continue;\n    }\n    level = getHeadingLevel(headingEl);\n    if (!headingEl.hasClass('is-collapsed')) {\n      continue;\n    }\n\n    toggleCollapsed(headingEl, false);\n    hasUnfolded = true;\n  }\n\n  if (hasUnfolded) {\n    updateFoldedBlocks(rootEl);\n  }\n}\n\n/**\n * Shows or hides every block of `rootEl` after the folded headings, so a block is hidden exactly when a\n * folded heading above it has no heading of the same or a higher level in between.\n *\n * @param rootEl - The element markdown was rendered into.\n */\nfunction updateFoldedBlocks(rootEl: HTMLElement): void {\n  let foldedLevel: null | number = null;\n  for (const block of getBlocks(rootEl)) {\n    const headingEl = getBlockHeading(block);\n    const headingLevel = headingEl ? getHeadingLevel(headingEl) : null;\n    if (foldedLevel !== null && headingLevel !== null && headingLevel <= foldedLevel) {\n      foldedLevel = null;\n    }\n    const isShown = foldedLevel === null;\n    block.toggle(isShown);\n    if (isShown && headingEl?.hasClass('is-collapsed')) {\n      foldedLevel = headingLevel;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/request-url.d.mts

@@ -0,0 +1,233 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+/**
+ * @file
+ *
+ * A wrapper over Obsidian's {@link requestUrl} that fills the gaps plugins keep hand-rolling: an abort signal and a
+ * timeout, request bodies beyond `string | ArrayBuffer` (`FormData`, `URLSearchParams`, `Blob`, typed arrays and
+ * streams), an error that carries the status and the body, an up-front protocol check, a streamed response body, and
+ * a `fetch`-compatible adapter that third-party SDKs can take.
+ *
+ * `requestUrl` itself cannot be cancelled: an abort or a timeout settles the returned promise at once, while the
+ * underlying request runs to completion and its result is dropped. The streamed variant really cancels on desktop,
+ * where it goes through `node:http` / `node:https`; that module is imported dynamically, so this one stays
+ * cross-platform-loadable. On mobile the streamed variant falls back to `requestUrl` and delivers the whole body as a
+ * single chunk.
+ */
+import type { RequestUrlResponse } from 'obsidian';
+/**
+ * Options for {@link createRequestUrlFetch}.
+ */
+export interface CreateRequestUrlFetchOptions {
+    /**
+     * Whether to stream the response body through {@link requestUrlStream} rather than buffer it. Streaming is real on
+     * desktop only; on mobile the body still arrives as one chunk. Defaults to `false`.
+     */
+    readonly shouldStream?: boolean;
+    /**
+     * The timeout in milliseconds applied to every request, on top of the request's own `signal`.
+     */
+    readonly timeoutInMilliseconds?: number;
+}
+/**
+ * The request in the form the transports take: validated, with the body encoded.
+ */
+export interface EncodedRequestUrlRequest {
+    /**
+     * Aborts the request.
+     */
+    readonly abortSignal: AbortSignal;
+    /**
+     * The encoded body.
+     */
+    readonly body?: ArrayBuffer | string;
+    /**
+     * The request headers, including the content type.
+     */
+    readonly headers: Readonly<Record<string, string>>;
+    /**
+     * The HTTP method, uppercase.
+     */
+    readonly method: string;
+    /**
+     * The URL.
+     */
+    readonly url: string;
+}
+/**
+ * Parameters for {@link encodeRequestUrlRequest}.
+ */
+export type EncodeRequestUrlRequestParams = RequestUrlExParams;
+/**
+ * Parameters for the {@link RequestUrlError} constructor.
+ */
+export interface RequestUrlErrorConstructorParams {
+    /**
+     * The response headers.
+     */
+    readonly headers: Readonly<Record<string, string>>;
+    /**
+     * The HTTP method.
+     */
+    readonly method: string;
+    /**
+     * The status code.
+     */
+    readonly status: number;
+    /**
+     * The response body as text.
+     */
+    readonly text: string;
+    /**
+     * The URL.
+     */
+    readonly url: string;
+}
+/**
+ * A request body {@link requestUrlEx} accepts: everything `fetch` accepts.
+ */
+export type RequestUrlExBody = ArrayBuffer | ArrayBufferView | Blob | FormData | ReadableStream<Uint8Array> | string | URLSearchParams;
+/**
+ * Parameters for {@link requestUrlEx}.
+ */
+export interface RequestUrlExParams {
+    /**
+     * Aborts the request. The promise rejects with the signal's reason.
+     */
+    readonly abortSignal?: AbortSignal | undefined;
+    /**
+     * The request body.
+     */
+    readonly body?: RequestUrlExBody | undefined;
+    /**
+     * The content type. When omitted, it is derived from the body: a `FormData` body gets `multipart/form-data` with its
+     * boundary, a `URLSearchParams` body `application/x-www-form-urlencoded` and a `Blob` body its own type — unless
+     * {@link RequestUrlExParams.headers} already carries a `Content-Type`.
+     */
+    readonly contentType?: string | undefined;
+    /**
+     * The request headers.
+     */
+    readonly headers?: Readonly<Record<string, string>> | undefined;
+    /**
+     * The HTTP method. Defaults to `GET`.
+     */
+    readonly method?: string | undefined;
+    /**
+     * Whether to throw a {@link RequestUrlError} when the status code is 400 or higher. Defaults to `true`.
+     */
+    readonly shouldThrowOnHttpError?: boolean | undefined;
+    /**
+     * The timeout in milliseconds. The promise rejects with a `TimeoutError` {@link DOMException} once it elapses.
+     */
+    readonly timeoutInMilliseconds?: number | undefined;
+    /**
+     * The URL. Only `http:` and `https:` URLs are accepted.
+     */
+    readonly url: string;
+}
+/**
+ * A `fetch`-compatible function built on {@link requestUrl}.
+ */
+export type RequestUrlFetch = (input: Request | string | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Parameters for {@link requestUrlStream}.
+ */
+export type RequestUrlStreamParams = RequestUrlExParams;
+/**
+ * The response of {@link requestUrlStream}.
+ */
+export interface RequestUrlStreamResponse {
+    /**
+     * The response body.
+     */
+    readonly body: ReadableStream<Uint8Array>;
+    /**
+     * The response headers, with lowercase names.
+     */
+    readonly headers: Readonly<Record<string, string>>;
+    /**
+     * The status code.
+     */
+    readonly status: number;
+    /**
+     * The final URL, after any redirects.
+     */
+    readonly url: string;
+}
+/**
+ * The error {@link requestUrlEx} and {@link requestUrlStream} throw for a status code of 400 or higher.
+ */
+export declare class RequestUrlError extends Error {
+    /**
+     * The response headers.
+     */
+    readonly headers: Readonly<Record<string, string>>;
+    /**
+     * The HTTP method.
+     */
+    readonly method: string;
+    /**
+     * The status code.
+     */
+    readonly status: number;
+    /**
+     * The response body as text.
+     */
+    readonly text: string;
+    /**
+     * The URL.
+     */
+    readonly url: string;
+    /**
+     * Creates a {@link RequestUrlError}.
+     *
+     * @param params - The failed request and its response.
+     */
+    constructor(params: RequestUrlErrorConstructorParams);
+    /**
+     * Parses the response body as JSON.
+     *
+     * @returns The parsed body.
+     */
+    json(): unknown;
+}
+/**
+ * Creates a `fetch`-compatible function built on {@link requestUrl}, for SDKs that take a custom `fetch` (OpenAI,
+ * LangChain, OAuth clients) and would otherwise hit CORS.
+ *
+ * Unlike `fetch`, it never rejects on an HTTP error status: it resolves with a {@link Response} carrying that status,
+ * exactly as `fetch` does. It rejects with a `TypeError` for a URL that is not `http:` or `https:`.
+ *
+ * @param options - The options.
+ * @returns The `fetch`-compatible function.
+ */
+export declare function createRequestUrlFetch(options?: CreateRequestUrlFetchOptions): RequestUrlFetch;
+/**
+ * Encodes a request for a transport: validates the URL, combines the abort signal with the timeout, encodes the body
+ * and settles the content type.
+ *
+ * @param params - The request.
+ * @returns The encoded request.
+ */
+export declare function encodeRequestUrlRequest(params: EncodeRequestUrlRequestParams): Promise<EncodedRequestUrlRequest>;
+/**
+ * Requests a URL through {@link requestUrl}, with an abort signal, a timeout, richer bodies, a protocol check and a
+ * {@link RequestUrlError} for an HTTP error status.
+ *
+ * @param params - The request.
+ * @returns The response.
+ */
+export declare function requestUrlEx(params: RequestUrlExParams): Promise<RequestUrlResponse>;
+/**
+ * Requests a URL and returns its body as a stream.
+ *
+ * On desktop the request goes through `node:http` / `node:https`, so the body streams as it arrives, an abort really
+ * cancels the request, and redirects are followed. On mobile it falls back to {@link requestUrl}, and the whole body
+ * arrives as a single chunk.
+ *
+ * @param params - The request.
+ * @returns The response, with a streamed body.
+ */
+export declare function requestUrlStream(params: RequestUrlStreamParams): Promise<RequestUrlStreamResponse>;