@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

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

@@ -0,0 +1,306 @@
+/*
+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 rendered_markdown_exports = {};
+__export(rendered_markdown_exports, {
+  isOwnedByRenderedMarkdown: () => isOwnedByRenderedMarkdown,
+  registerFoldHandlers: () => registerFoldHandlers,
+  registerFootnoteLinkHandler: () => registerFootnoteLinkHandler
+});
+module.exports = __toCommonJS(rendered_markdown_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_obsidian = require('obsidian');
+var import_css_class = require('./css-class.cjs');
+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(import_css_class.CssClass.LibraryName, import_css_class.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
+  });
+  (0, import_obsidian.setIcon)(indicatorEl, FOLD_ICON);
+}
+function flash(targetEl, rootEl) {
+  for (const flashingEl of rootEl.findAll(".is-flashing")) {
+    flashingEl.removeClass("is-flashing");
+  }
+  targetEl.addClass("is-flashing");
+  (0, import_async.invokeAsyncSafely)(async () => {
+    await (0, import_async.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((0, import_type_guards.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 = (0, import_type_guards.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((0, import_type_guards.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;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/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;