@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

package/dist/lib/esm/broken-link-candidates.mjs

@@ -0,0 +1,275 @@
+/*
+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 { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+var BrokenLinkEvidenceKind = /* @__PURE__ */ ((BrokenLinkEvidenceKind2) => {
+  BrokenLinkEvidenceKind2["Alias"] = "Alias";
+  BrokenLinkEvidenceKind2["CaseChange"] = "CaseChange";
+  BrokenLinkEvidenceKind2["GitRename"] = "GitRename";
+  BrokenLinkEvidenceKind2["RenamedFolder"] = "RenamedFolder";
+  BrokenLinkEvidenceKind2["SameName"] = "SameName";
+  BrokenLinkEvidenceKind2["Title"] = "Title";
+  return BrokenLinkEvidenceKind2;
+})(BrokenLinkEvidenceKind || {});
+const FOLDER_NOTE_MIN_SUFFIX_LENGTH = 2;
+const EVIDENCE_KIND_ORDER = [
+  "GitRename" /* GitRename */,
+  "CaseChange" /* CaseChange */,
+  "Alias" /* Alias */,
+  "Title" /* Title */,
+  "RenamedFolder" /* RenamedFolder */,
+  "SameName" /* SameName */
+];
+class BrokenLinkCandidateFinder {
+  aliasesByPath;
+  childFoldersByFolder = /* @__PURE__ */ new Map();
+  filePathSet;
+  filesByLowerCasePath = /* @__PURE__ */ new Map();
+  filesByName = /* @__PURE__ */ new Map();
+  folderNoteFileNames;
+  folderPaths = /* @__PURE__ */ new Set([""]);
+  gitRenames;
+  titlesByPath;
+  /**
+   * Indexes the vault snapshot.
+   *
+   * @param params - The snapshot.
+   */
+  constructor(params) {
+    this.aliasesByPath = params.aliasesByPath;
+    this.filePathSet = new Set(params.filePaths);
+    this.folderNoteFileNames = new Set(params.folderNoteFileNames);
+    this.gitRenames = params.gitRenames;
+    this.titlesByPath = params.titlesByPath;
+    for (const filePath of params.filePaths) {
+      addToMultiMap(this.filesByName, getName(filePath), filePath);
+      addToMultiMap(this.filesByLowerCasePath, filePath.toLowerCase(), filePath);
+      let folder = getParentPath(filePath);
+      while (!this.folderPaths.has(folder)) {
+        this.folderPaths.add(folder);
+        addToMultiMap(this.childFoldersByFolder, getParentPath(folder), folder);
+        folder = getParentPath(folder);
+      }
+    }
+  }
+  /**
+   * Finds the candidates for every missing path at once.
+   *
+   * All at once because one kind of evidence is collective: a renamed folder is recognized by every missing
+   * target that was under it turning up together under one sibling folder.
+   *
+   * @param missingPaths - The vault paths that links lead to and no file holds.
+   * @returns The candidates for each missing path, strongest first; an empty list when nothing is known.
+   */
+  findAll(missingPaths) {
+    const uniqueMissingPaths = new Set(missingPaths);
+    const missingSubtrees = this.getMissingSubtrees(uniqueMissingPaths);
+    const result = /* @__PURE__ */ new Map();
+    for (const missingPath of uniqueMissingPaths) {
+      let add2 = function(path, kind, description) {
+        addToMultiMap(evidenceByPath, path, { description, kind });
+      };
+      var add = add2;
+      const evidenceByPath = /* @__PURE__ */ new Map();
+      this.addGitRenameCandidate(missingPath, add2);
+      this.addCaseChangeCandidates(missingPath, add2);
+      this.addAliasAndTitleCandidates(missingPath, add2);
+      this.addRenamedFolderCandidates(missingPath, missingSubtrees, add2);
+      this.addSameNameCandidates(missingPath, add2);
+      result.set(missingPath, sortCandidates(evidenceByPath));
+    }
+    return result;
+  }
+  addAliasAndTitleCandidates(missingPath, add) {
+    const name = getName(missingPath);
+    const isFolderNote = this.folderNoteFileNames.has(name);
+    let oldName;
+    if (isFolderNote) {
+      oldName = getName(getParentPath(missingPath));
+      if (!oldName) {
+        return;
+      }
+    } else if (name.toLowerCase().endsWith(".md")) {
+      oldName = name.slice(0, -".md".length);
+    } else {
+      return;
+    }
+    const lowerCaseOldName = oldName.toLowerCase();
+    const isEligible = (path) => this.filePathSet.has(path) && (!isFolderNote || getName(path) === name);
+    for (const [path, aliases] of this.aliasesByPath) {
+      if (isEligible(path) && aliases.some((alias) => alias.toLowerCase() === lowerCaseOldName)) {
+        add(path, "Alias" /* Alias */, `Its aliases hold the old name "${oldName}".`);
+      }
+    }
+    for (const [path, title] of this.titlesByPath) {
+      if (isEligible(path) && title.toLowerCase() === lowerCaseOldName) {
+        add(path, "Title" /* Title */, `Its title is the old name "${oldName}".`);
+      }
+    }
+  }
+  addCaseChangeCandidates(missingPath, add) {
+    for (const path of this.filesByLowerCasePath.get(missingPath.toLowerCase()) ?? []) {
+      add(path, "CaseChange" /* CaseChange */, "Only the letter case of its path differs.");
+    }
+  }
+  addGitRenameCandidate(missingPath, add) {
+    const gitRename = this.gitRenames.get(missingPath);
+    if (gitRename && this.filePathSet.has(gitRename.newPath)) {
+      add(gitRename.newPath, "GitRename" /* GitRename */, `Git history records the rename, in commit ${gitRename.commit}.`);
+    }
+  }
+  addRenamedFolderCandidates(missingPath, missingSubtrees, add) {
+    const missingSubtree = missingSubtrees.get(missingPath);
+    if (!missingSubtree) {
+      return;
+    }
+    const parentPath = getParentPath(missingSubtree.root);
+    const remainder = getRelativePath(missingSubtree.root, missingPath);
+    for (const siblingFolder of this.childFoldersByFolder.get(parentPath) ?? []) {
+      const isSubtreeIntact = [...missingSubtree.remainders].every((path) => this.filePathSet.has(joinPath(siblingFolder, path)));
+      if (!isSubtreeIntact) {
+        continue;
+      }
+      const fileCount = missingSubtree.remainders.size;
+      add(
+        joinPath(siblingFolder, remainder),
+        "RenamedFolder" /* RenamedFolder */,
+        `The folder "${missingSubtree.root}" is gone, and its sibling "${siblingFolder}" holds ${fileCount === 1 ? "the missing file that was" : `all ${String(fileCount)} missing files that were`} under it.`
+      );
+    }
+  }
+  addSameNameCandidates(missingPath, add) {
+    const name = getName(missingPath);
+    const minSuffixLength = this.folderNoteFileNames.has(name) ? FOLDER_NOTE_MIN_SUFFIX_LENGTH : 1;
+    const missingSegments = missingPath.split("/");
+    let bestSuffixLength = minSuffixLength;
+    let bestPaths = [];
+    for (const path of this.filesByName.get(name) ?? []) {
+      const suffixLength = getCommonSuffixLength(missingSegments, path.split("/"));
+      if (suffixLength > bestSuffixLength) {
+        bestSuffixLength = suffixLength;
+        bestPaths = [path];
+      } else if (suffixLength === bestSuffixLength) {
+        bestPaths.push(path);
+      }
+    }
+    const suffix = missingSegments.slice(-bestSuffixLength).join("/");
+    for (const path of bestPaths) {
+      add(path, "SameName" /* SameName */, `It has the same name, "${suffix}", in another folder.`);
+    }
+  }
+  /**
+   * Groups the missing paths by the highest missing folder above each, the root of a subtree that may have been
+   * renamed as a whole.
+   *
+   * @param missingPaths - The missing paths.
+   * @returns Each missing path's subtree; a path whose own folder exists has none.
+   */
+  getMissingSubtrees(missingPaths) {
+    const subtreesByRoot = /* @__PURE__ */ new Map();
+    const result = /* @__PURE__ */ new Map();
+    for (const missingPath of missingPaths) {
+      let root = getParentPath(missingPath);
+      if (this.folderPaths.has(root)) {
+        continue;
+      }
+      while (!this.folderPaths.has(getParentPath(root))) {
+        root = getParentPath(root);
+      }
+      let missingSubtree = subtreesByRoot.get(root);
+      if (!missingSubtree) {
+        missingSubtree = { remainders: /* @__PURE__ */ new Set(), root };
+        subtreesByRoot.set(root, missingSubtree);
+      }
+      missingSubtree.remainders.add(getRelativePath(root, missingPath));
+      result.set(missingPath, missingSubtree);
+    }
+    return result;
+  }
+}
+function getParentPath(path) {
+  const index = path.lastIndexOf("/");
+  return index === -1 ? "" : path.slice(0, index);
+}
+function getPathMapping(oldPath, newPath) {
+  const oldSegments = oldPath.split("/");
+  const newSegments = newPath.split("/");
+  const suffixLength = getCommonSuffixLength(oldSegments, newSegments);
+  return {
+    newPrefix: newSegments.slice(0, newSegments.length - suffixLength).join("/"),
+    oldPrefix: oldSegments.slice(0, oldSegments.length - suffixLength).join("/")
+  };
+}
+function addToMultiMap(map, key, value) {
+  let values = map.get(key);
+  if (!values) {
+    values = [];
+    map.set(key, values);
+  }
+  values.push(value);
+}
+function getCommonSuffixLength(segments1, segments2) {
+  let length = 0;
+  while (length < segments1.length && length < segments2.length && segments1.at(-length - 1) === segments2.at(-length - 1)) {
+    length++;
+  }
+  return length;
+}
+function getEvidenceRank(evidence) {
+  return EVIDENCE_KIND_ORDER.indexOf(evidence.kind);
+}
+function getName(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function getRelativePath(folder, path) {
+  return path.slice(folder.length + 1);
+}
+function joinPath(folder, path) {
+  return `${folder}/${path}`;
+}
+function sortCandidates(evidenceByPath) {
+  const candidates = [...evidenceByPath].map(([path, evidence]) => ({
+    evidence: evidence.sort((evidence1, evidence2) => getEvidenceRank(evidence1) - getEvidenceRank(evidence2)),
+    path
+  }));
+  return candidates.sort((candidate1, candidate2) => {
+    const rankDifference = getEvidenceRank(ensureNonNullable(candidate1.evidence[0])) - getEvidenceRank(ensureNonNullable(candidate2.evidence[0]));
+    return rankDifference || candidate1.path.localeCompare(candidate2.path);
+  });
+}
+export {
+  BrokenLinkCandidateFinder,
+  BrokenLinkEvidenceKind,
+  getParentPath,
+  getPathMapping
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/broken-link-candidates.ts"],"sourcesContent":["/**\n * @file\n *\n * Where did a missing link target go? Pure, no `App`: every question about which file a broken link most likely\n * meant is answerable from a list of paths, the notes' aliases and titles, and the vault's git renames.\n *\n * A rename is not recoverable from the link alone: a link to `alpha/bravo/charlie/!.md` says nothing about\n * `charlie` having become `delta`. So every candidate carries the evidence that produced it, from outside the\n * link, and the finder never picks one of several: a caller offers a one-click fix only when exactly one\n * candidate exists.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\n/**\n * The kind of evidence that makes a file a candidate for a missing link target.\n *\n * Candidates list evidence strongest first, in EVIDENCE_KIND_ORDER below.\n */\nexport enum BrokenLinkEvidenceKind {\n  /**\n   * The candidate's `aliases` hold the missing target's old name.\n   */\n  Alias = 'Alias',\n\n  /**\n   * The candidate's path differs from the missing one only in letter case.\n   */\n  CaseChange = 'CaseChange',\n\n  /**\n   * The vault's git history records the missing path being renamed to the candidate.\n   */\n  GitRename = 'GitRename',\n\n  /**\n   * The missing target's folder is gone, and a sibling folder holds every missing target that was under it.\n   */\n  RenamedFolder = 'RenamedFolder',\n\n  /**\n   * A file with the same name, and the longest run of the same parent folders, sits elsewhere.\n   */\n  SameName = 'SameName',\n\n  /**\n   * The candidate's `title` is the missing target's old name.\n   */\n  Title = 'Title'\n}\n\n/**\n * A folder note's own name identifies nothing, so a same-name candidate must share its folder's name too.\n */\nconst FOLDER_NOTE_MIN_SUFFIX_LENGTH = 2;\n\nconst EVIDENCE_KIND_ORDER: readonly BrokenLinkEvidenceKind[] = [\n  BrokenLinkEvidenceKind.GitRename,\n  BrokenLinkEvidenceKind.CaseChange,\n  BrokenLinkEvidenceKind.Alias,\n  BrokenLinkEvidenceKind.Title,\n  BrokenLinkEvidenceKind.RenamedFolder,\n  BrokenLinkEvidenceKind.SameName\n];\n\n/**\n * One file that a missing link target may have become, and why.\n */\nexport interface BrokenLinkCandidate {\n  /**\n   * Every reason this file is a candidate, strongest first.\n   */\n  readonly evidence: readonly BrokenLinkEvidence[];\n\n  /**\n   * The candidate's vault path.\n   */\n  readonly path: string;\n}\n\n/**\n * The parameters for {@link BrokenLinkCandidateFinder}.\n */\nexport interface BrokenLinkCandidateFinderConstructorParams {\n  /**\n   * Each note's `aliases`, by note path.\n   */\n  readonly aliasesByPath: ReadonlyMap<string, readonly string[]>;\n\n  /**\n   * Every file in the vault.\n   */\n  readonly filePaths: readonly string[];\n\n  /**\n   * The file names a folder note is stored under, such as `index.md`. Such a name says nothing about which\n   * note it is, so a same-name candidate must share its folder's name too, and the old name an alias is\n   * matched against is the folder's.\n   */\n  readonly folderNoteFileNames: readonly string[];\n\n  /**\n   * The vault's git renames: each old vault path to the path it was renamed to, chains already followed.\n   */\n  readonly gitRenames: ReadonlyMap<string, GitRename>;\n\n  /**\n   * Each note's `title`, by note path.\n   */\n  readonly titlesByPath: ReadonlyMap<string, string>;\n}\n\n/**\n * One reason a file is a candidate for a missing link target.\n */\nexport interface BrokenLinkEvidence {\n  /**\n   * A sentence naming the evidence, for the user to judge it by.\n   */\n  readonly description: string;\n\n  /**\n   * The kind of evidence.\n   */\n  readonly kind: BrokenLinkEvidenceKind;\n}\n\n/**\n * A rename recorded in the vault's git history.\n */\nexport interface GitRename {\n  /**\n   * The abbreviated hash of the commit that made the last rename of the chain.\n   */\n  readonly commit: string;\n\n  /**\n   * The vault path the file was last renamed to.\n   */\n  readonly newPath: string;\n}\n\n/**\n * The part of a missing path that a candidate replaced: what a \"fix all like this\" applies to every other link.\n */\nexport interface PathMapping {\n  /**\n   * The part of the candidate path that replaced {@link oldPrefix}; `''` for the vault root.\n   */\n  readonly newPrefix: string;\n\n  /**\n   * The leading part of the missing path that no longer exists; `''` for the vault root.\n   */\n  readonly oldPrefix: string;\n}\n\ntype EvidenceAdder = (path: string, kind: BrokenLinkEvidenceKind, description: string) => void;\n\ninterface MissingSubtree {\n  /**\n   * Each missing path under the subtree's root, relative to it.\n   */\n  readonly remainders: Set<string>;\n\n  readonly root: string;\n}\n\n/**\n * Finds the candidates for missing link targets, from one snapshot of the vault.\n */\nexport class BrokenLinkCandidateFinder {\n  private readonly aliasesByPath: ReadonlyMap<string, readonly string[]>;\n  private readonly childFoldersByFolder = new Map<string, string[]>();\n  private readonly filePathSet: ReadonlySet<string>;\n  private readonly filesByLowerCasePath = new Map<string, string[]>();\n  private readonly filesByName = new Map<string, string[]>();\n  private readonly folderNoteFileNames: ReadonlySet<string>;\n  private readonly folderPaths = new Set<string>(['']);\n  private readonly gitRenames: ReadonlyMap<string, GitRename>;\n  private readonly titlesByPath: ReadonlyMap<string, string>;\n\n  /**\n   * Indexes the vault snapshot.\n   *\n   * @param params - The snapshot.\n   */\n  public constructor(params: BrokenLinkCandidateFinderConstructorParams) {\n    this.aliasesByPath = params.aliasesByPath;\n    this.filePathSet = new Set(params.filePaths);\n    this.folderNoteFileNames = new Set(params.folderNoteFileNames);\n    this.gitRenames = params.gitRenames;\n    this.titlesByPath = params.titlesByPath;\n\n    for (const filePath of params.filePaths) {\n      addToMultiMap(this.filesByName, getName(filePath), filePath);\n      addToMultiMap(this.filesByLowerCasePath, filePath.toLowerCase(), filePath);\n\n      let folder = getParentPath(filePath);\n      while (!this.folderPaths.has(folder)) {\n        this.folderPaths.add(folder);\n        addToMultiMap(this.childFoldersByFolder, getParentPath(folder), folder);\n        folder = getParentPath(folder);\n      }\n    }\n  }\n\n  /**\n   * Finds the candidates for every missing path at once.\n   *\n   * All at once because one kind of evidence is collective: a renamed folder is recognized by every missing\n   * target that was under it turning up together under one sibling folder.\n   *\n   * @param missingPaths - The vault paths that links lead to and no file holds.\n   * @returns The candidates for each missing path, strongest first; an empty list when nothing is known.\n   */\n  public findAll(missingPaths: Iterable<string>): Map<string, BrokenLinkCandidate[]> {\n    const uniqueMissingPaths = new Set(missingPaths);\n    const missingSubtrees = this.getMissingSubtrees(uniqueMissingPaths);\n    const result = new Map<string, BrokenLinkCandidate[]>();\n\n    for (const missingPath of uniqueMissingPaths) {\n      const evidenceByPath = new Map<string, BrokenLinkEvidence[]>();\n      function add(path: string, kind: BrokenLinkEvidenceKind, description: string): void {\n        addToMultiMap(evidenceByPath, path, { description, kind });\n      }\n\n      this.addGitRenameCandidate(missingPath, add);\n      this.addCaseChangeCandidates(missingPath, add);\n      this.addAliasAndTitleCandidates(missingPath, add);\n      this.addRenamedFolderCandidates(missingPath, missingSubtrees, add);\n      this.addSameNameCandidates(missingPath, add);\n\n      result.set(missingPath, sortCandidates(evidenceByPath));\n    }\n\n    return result;\n  }\n\n  private addAliasAndTitleCandidates(missingPath: string, add: EvidenceAdder): void {\n    const name = getName(missingPath);\n    const isFolderNote = this.folderNoteFileNames.has(name);\n    let oldName: string;\n\n    if (isFolderNote) {\n      oldName = getName(getParentPath(missingPath));\n      if (!oldName) {\n        return;\n      }\n    } else if (name.toLowerCase().endsWith('.md')) {\n      oldName = name.slice(0, -'.md'.length);\n    } else {\n      return;\n    }\n\n    const lowerCaseOldName = oldName.toLowerCase();\n    const isEligible = (path: string): boolean => this.filePathSet.has(path) && (!isFolderNote || getName(path) === name);\n\n    for (const [path, aliases] of this.aliasesByPath) {\n      if (isEligible(path) && aliases.some((alias) => alias.toLowerCase() === lowerCaseOldName)) {\n        add(path, BrokenLinkEvidenceKind.Alias, `Its aliases hold the old name \"${oldName}\".`);\n      }\n    }\n\n    for (const [path, title] of this.titlesByPath) {\n      if (isEligible(path) && title.toLowerCase() === lowerCaseOldName) {\n        add(path, BrokenLinkEvidenceKind.Title, `Its title is the old name \"${oldName}\".`);\n      }\n    }\n  }\n\n  private addCaseChangeCandidates(missingPath: string, add: EvidenceAdder): void {\n    for (const path of this.filesByLowerCasePath.get(missingPath.toLowerCase()) ?? []) {\n      add(path, BrokenLinkEvidenceKind.CaseChange, 'Only the letter case of its path differs.');\n    }\n  }\n\n  private addGitRenameCandidate(missingPath: string, add: EvidenceAdder): void {\n    const gitRename = this.gitRenames.get(missingPath);\n    if (gitRename && this.filePathSet.has(gitRename.newPath)) {\n      add(gitRename.newPath, BrokenLinkEvidenceKind.GitRename, `Git history records the rename, in commit ${gitRename.commit}.`);\n    }\n  }\n\n  private addRenamedFolderCandidates(missingPath: string, missingSubtrees: ReadonlyMap<string, MissingSubtree>, add: EvidenceAdder): void {\n    const missingSubtree = missingSubtrees.get(missingPath);\n    if (!missingSubtree) {\n      return;\n    }\n\n    const parentPath = getParentPath(missingSubtree.root);\n    const remainder = getRelativePath(missingSubtree.root, missingPath);\n\n    for (const siblingFolder of this.childFoldersByFolder.get(parentPath) ?? []) {\n      const isSubtreeIntact = [...missingSubtree.remainders].every((path) => this.filePathSet.has(joinPath(siblingFolder, path)));\n      if (!isSubtreeIntact) {\n        continue;\n      }\n\n      const fileCount = missingSubtree.remainders.size;\n      add(\n        joinPath(siblingFolder, remainder),\n        BrokenLinkEvidenceKind.RenamedFolder,\n        `The folder \"${missingSubtree.root}\" is gone, and its sibling \"${siblingFolder}\" holds ${fileCount === 1 ? 'the missing file that was' : `all ${String(fileCount)} missing files that were`} under it.`\n      );\n    }\n  }\n\n  private addSameNameCandidates(missingPath: string, add: EvidenceAdder): void {\n    const name = getName(missingPath);\n    const minSuffixLength = this.folderNoteFileNames.has(name) ? FOLDER_NOTE_MIN_SUFFIX_LENGTH : 1;\n    const missingSegments = missingPath.split('/');\n    let bestSuffixLength = minSuffixLength;\n    let bestPaths: string[] = [];\n\n    for (const path of this.filesByName.get(name) ?? []) {\n      const suffixLength = getCommonSuffixLength(missingSegments, path.split('/'));\n      if (suffixLength > bestSuffixLength) {\n        bestSuffixLength = suffixLength;\n        bestPaths = [path];\n      } else if (suffixLength === bestSuffixLength) {\n        bestPaths.push(path);\n      }\n    }\n\n    const suffix = missingSegments.slice(-bestSuffixLength).join('/');\n    for (const path of bestPaths) {\n      add(path, BrokenLinkEvidenceKind.SameName, `It has the same name, \"${suffix}\", in another folder.`);\n    }\n  }\n\n  /**\n   * Groups the missing paths by the highest missing folder above each, the root of a subtree that may have been\n   * renamed as a whole.\n   *\n   * @param missingPaths - The missing paths.\n   * @returns Each missing path's subtree; a path whose own folder exists has none.\n   */\n  private getMissingSubtrees(missingPaths: ReadonlySet<string>): Map<string, MissingSubtree> {\n    const subtreesByRoot = new Map<string, MissingSubtree>();\n    const result = new Map<string, MissingSubtree>();\n\n    for (const missingPath of missingPaths) {\n      let root = getParentPath(missingPath);\n      if (this.folderPaths.has(root)) {\n        continue;\n      }\n\n      while (!this.folderPaths.has(getParentPath(root))) {\n        root = getParentPath(root);\n      }\n\n      let missingSubtree = subtreesByRoot.get(root);\n      if (!missingSubtree) {\n        missingSubtree = { remainders: new Set(), root };\n        subtreesByRoot.set(root, missingSubtree);\n      }\n\n      missingSubtree.remainders.add(getRelativePath(root, missingPath));\n      result.set(missingPath, missingSubtree);\n    }\n\n    return result;\n  }\n}\n\n/**\n * The parent folder of a vault path.\n *\n * @param path - The path.\n * @returns The parent folder; `''` for the vault root.\n */\nexport function getParentPath(path: string): string {\n  const index = path.lastIndexOf('/');\n  return index === -1 ? '' : path.slice(0, index);\n}\n\n/**\n * The part of a missing path that a candidate path replaced, found by dropping the path segments they end with\n * in common.\n *\n * @param oldPath - The missing path.\n * @param newPath - The candidate path.\n * @returns The prefixes that differ.\n */\nexport function getPathMapping(oldPath: string, newPath: string): PathMapping {\n  const oldSegments = oldPath.split('/');\n  const newSegments = newPath.split('/');\n  const suffixLength = getCommonSuffixLength(oldSegments, newSegments);\n  return {\n    newPrefix: newSegments.slice(0, newSegments.length - suffixLength).join('/'),\n    oldPrefix: oldSegments.slice(0, oldSegments.length - suffixLength).join('/')\n  };\n}\n\nfunction addToMultiMap<Key, Value>(map: Map<Key, Value[]>, key: Key, value: Value): void {\n  let values = map.get(key);\n  if (!values) {\n    values = [];\n    map.set(key, values);\n  }\n  values.push(value);\n}\n\nfunction getCommonSuffixLength(segments1: readonly string[], segments2: readonly string[]): number {\n  let length = 0;\n  while (length < segments1.length && length < segments2.length && segments1.at(-length - 1) === segments2.at(-length - 1)) {\n    length++;\n  }\n  return length;\n}\n\nfunction getEvidenceRank(evidence: BrokenLinkEvidence): number {\n  return EVIDENCE_KIND_ORDER.indexOf(evidence.kind);\n}\n\nfunction getName(path: string): string {\n  return path.slice(path.lastIndexOf('/') + 1);\n}\n\n// The folder is never the vault root here: a missing subtree's root is a missing folder, and its siblings are\n// folders too.\nfunction getRelativePath(folder: string, path: string): string {\n  return path.slice(folder.length + 1);\n}\n\nfunction joinPath(folder: string, path: string): string {\n  return `${folder}/${path}`;\n}\n\nfunction sortCandidates(evidenceByPath: ReadonlyMap<string, BrokenLinkEvidence[]>): BrokenLinkCandidate[] {\n  const candidates = [...evidenceByPath].map(([path, evidence]) => ({\n    evidence: evidence.sort((evidence1, evidence2) => getEvidenceRank(evidence1) - getEvidenceRank(evidence2)),\n    path\n  }));\n\n  return candidates.sort((candidate1, candidate2) => {\n    const rankDifference = getEvidenceRank(ensureNonNullable(candidate1.evidence[0])) - getEvidenceRank(ensureNonNullable(candidate2.evidence[0]));\n    return rankDifference || candidate1.path.localeCompare(candidate2.path);\n  });\n}\n"],"mappings":"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","names":["BrokenLinkEvidenceKind","add"]}

package/dist/lib/esm/bug-report.d.mts

@@ -45,7 +45,7 @@ export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
  */
 export interface BugReportEnvironment {
     /**
-     * The other enabled plugins, sorted by id.
+     * The other loaded plugins, sorted by id.
      */
     readonly enabledPlugins: readonly BugReportPluginInfo[];
     /**

package/dist/lib/esm/bug-report.mjs

@@ -56,7 +56,9 @@ async function getBugReportEnvironment(params) {
   const { app, pluginId } = params;
   const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();
   return {
-    enabledPlugins: [...app.plugins.enabledPlugins].filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
+    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id
+    // whose folder was deleted, or whose load failed.
+    enabledPlugins: Object.keys(app.plugins.plugins).filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
     installerVersion,
     obsidianVersion: apiVersion,
     operatingSystem,
@@ -138,4 +140,4 @@ export {
   getBugReportIssueFormUrl,
   getGitHubIssueFormUrl
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other enabled plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    enabledPlugins: [...app.plugins.enabledPlugins]\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other loaded plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":"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","names":["BugReportIssueFormFieldId"]}

package/dist/lib/esm/code-block-render-handoff.d.mts

@@ -0,0 +1,131 @@
+/// <reference path="./library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Carries focus and plugin state from a code block to its next render.
+ *
+ * Obsidian renders a code block again whenever its source text changes: Reading view re-renders the section and Live
+ * Preview replaces the widget. So a block that edits its own source (a counter, a checkbox, a settings form) loses the
+ * element the user was interacting with, its focus and whatever the plugin kept on it. The element itself cannot be
+ * kept without patching Obsidian's renderers, so the write records a handoff instead, and the processor rendering the
+ * new source claims it: it gets back the state the write passed and can put the focus back on the same element.
+ *
+ * The handoff is matched by source path, language and the new block content, and it lives for
+ * {@link CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS}. The first render to claim it consumes it, so when the
+ * note is open in two panes only one of the new renders gets it.
+ */
+import type { MarkdownPostProcessorContext } from 'obsidian';
+/**
+ * How long a recorded handoff waits for the render that claims it.
+ */
+export declare const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 10000;
+/**
+ * Options for {@link claimCodeBlockRenderHandoff}.
+ */
+export interface ClaimCodeBlockRenderHandoffParams {
+    /**
+     * The {@link MarkdownPostProcessorContext} the processor received.
+     */
+    readonly context: MarkdownPostProcessorContext;
+    /**
+     * The element the processor renders into.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The source the processor received.
+     */
+    readonly source: string;
+}
+/**
+ * Where the focus was inside a rendered code block.
+ */
+export interface CodeBlockFocusSnapshot {
+    /**
+     * The child indices leading from the code block element to the focused element.
+     */
+    readonly childIndexPath: readonly number[];
+    /**
+     * The text selection of a focused input or text area.
+     */
+    readonly selection: null | TextSelection;
+}
+/**
+ * A handoff claimed by the render of a code block whose source a write just changed.
+ */
+export interface CodeBlockRenderHandoff {
+    /**
+     * Whether the write recorded a focused element to restore.
+     */
+    readonly hasFocus: boolean;
+    /**
+     * Puts the focus back on the element at the same position inside the new render, with the same text selection.
+     *
+     * Call it once the processor has rendered the block. It waits for the element to be attached to a document.
+     *
+     * @returns Whether an element was focused.
+     */
+    readonly restoreFocus: () => Promise<boolean>;
+    /**
+     * The state passed to the write, or `undefined` when none was.
+     */
+    readonly state: unknown;
+}
+/**
+ * Options for {@link recordCodeBlockRenderHandoff}.
+ */
+export interface RecordCodeBlockRenderHandoffParams {
+    /**
+     * The focus captured from the old render with {@link captureCodeBlockFocus}.
+     */
+    readonly focus: CodeBlockFocusSnapshot | null;
+    /**
+     * The code block written to the note, fences included.
+     */
+    readonly newCodeBlock: string;
+    /**
+     * The path of the note the code block is in.
+     */
+    readonly sourcePath: string;
+    /**
+     * The state to pass to the next render.
+     */
+    readonly state: unknown;
+}
+interface TextSelection {
+    readonly direction: 'backward' | 'forward' | 'none';
+    readonly end: number;
+    readonly start: number;
+}
+/**
+ * Captures where the focus is inside a rendered code block.
+ *
+ * @param el - The code block element.
+ * @returns The snapshot, or `null` when the focus is not inside the element.
+ */
+export declare function captureCodeBlockFocus(el: HTMLElement): CodeBlockFocusSnapshot | null;
+/**
+ * Claims the handoff a write recorded for the code block being rendered.
+ *
+ * Call it from a code block processor. It returns `null` when no write is waiting for this render.
+ *
+ * @param params - The parameters for the function.
+ * @returns The handoff, or `null`.
+ */
+export declare function claimCodeBlockRenderHandoff(params: ClaimCodeBlockRenderHandoffParams): CodeBlockRenderHandoff | null;
+/**
+ * Records a handoff for the next render of a code block a write is about to change.
+ *
+ * @param params - The parameters for the function.
+ * @returns Whether a handoff was recorded: `false` when the new text is not exactly one code block.
+ */
+export declare function recordCodeBlockRenderHandoff(params: RecordCodeBlockRenderHandoffParams): boolean;
+/**
+ * Puts the focus back on the element a {@link CodeBlockFocusSnapshot} describes.
+ *
+ * @param el - The new code block element.
+ * @param focus - The snapshot captured from the old render.
+ * @returns Whether an element was focused.
+ */
+export declare function restoreCodeBlockFocus(el: HTMLElement, focus: CodeBlockFocusSnapshot): Promise<boolean>;
+export {};