@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/esm/components/rename-delete-handler-component.mjs

@@ -0,0 +1,1230 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import { filterInPlace } from "@mnaoumov/typescript-lib/array";
+import { printError } from "@mnaoumov/typescript-lib/error";
+import {
+  normalizeOptionalProperties,
+  toJson
+} from "@mnaoumov/typescript-lib/object-utils";
+import {
+  basename,
+  dirname,
+  extname,
+  join,
+  relative
+} from "@mnaoumov/typescript-lib/path";
+import {
+  getDataAdapterEx,
+  InternalPluginName
+} from "@obsidian-typings/obsidian-public-latest/implementations";
+import { t } from "i18next";
+import {
+  FileManager,
+  Vault
+} from "obsidian";
+import {
+  AttachmentPathContext,
+  getAttachmentFilePath,
+  getAttachmentFolderPath,
+  hasOwnAttachmentFolder
+} from "../attachment-path.mjs";
+import { getCanvasReferences } from "../canvas.mjs";
+import { getObsidianLibDebugger } from "../debug.mjs";
+import { waitForPendingLinkUpdates } from "../file-manager.mjs";
+import {
+  CANVAS_FILE_EXTENSION,
+  getFile,
+  getFileOrNull,
+  getFolderOrNull,
+  isCanvasFile,
+  isFile,
+  isFolder,
+  isMarkdownFile,
+  isNote
+} from "../file-system.mjs";
+import {
+  buildBacklinksSnapshot,
+  editBacklinksSnapshot,
+  extractLinkFile,
+  updateLink,
+  updateLinksInFile
+} from "../link.mjs";
+import {
+  getBacklinksForFileOrPath,
+  getBacklinksForFileSafe,
+  getLinks,
+  hasBacklinkCachePlugin,
+  registerFileCacheForNonExistingFile,
+  registerFiles
+} from "../metadata-cache.mjs";
+import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
+import { addToQueue } from "../queue.mjs";
+import { isResourceLockedForPathByAncestor } from "../resource-lock.mjs";
+import { deleteIfNotUsed } from "../vault-delete.mjs";
+import {
+  cleanupEmptyFolders,
+  EmptyFolderBehavior,
+  getSafeRenamePath,
+  isChildOrSelf,
+  renameSafe,
+  trashSafe
+} from "../vault.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+import {
+  hasPatchToken,
+  MonkeyAroundComponent
+} from "./monkey-around-component.mjs";
+import { EmptyFolderBehavior as EmptyFolderBehavior2 } from "../vault.mjs";
+const PATCH_TOKEN = /* @__PURE__ */ Symbol.for("renameDeleteHandler");
+class DeleteHandler {
+  abortSignal;
+  app;
+  deletedMetadataCacheMap;
+  file;
+  pluginNoticeComponent;
+  settingsManager;
+  constructor(params) {
+    this.app = params.app;
+    this.file = params.file;
+    this.abortSignal = params.abortSignal;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.settingsManager = params.settingsManager;
+    this.deletedMetadataCacheMap = params.deletedMetadataCacheMap;
+  }
+  async handle() {
+    this.abortSignal.throwIfAborted();
+    getObsidianLibDebugger("RenameDeleteHandler:handleDelete")(`Handle Delete ${this.file.path}`);
+    if (!isNote(this.file)) {
+      return;
+    }
+    if (await this.app.vault.adapter.exists(this.file.path)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleDelete")(
+        `Skipping delete handler of ${this.file.path} as the file still exists on disk (index-only removal, not a real deletion).`
+      );
+      return;
+    }
+    const settings = this.settingsManager.getSettings();
+    if (settings.isPathIgnored?.(this.file.path)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleDelete")(`Skipping delete handler of ${this.file.path} as the path is ignored.`);
+      return;
+    }
+    const parentFolderPaths = /* @__PURE__ */ new Set([dirname(this.file.path)]);
+    if (settings.shouldHandleDeletions) {
+      const cache = this.deletedMetadataCacheMap.get(this.file.path);
+      this.deletedMetadataCacheMap.delete(this.file.path);
+      if (cache) {
+        const links = getLinks({ cache });
+        for (const link of links) {
+          const attachmentFile = extractLinkFile({ app: this.app, link, sourcePathOrFile: this.file.path });
+          if (!attachmentFile || this.settingsManager.isNoteEx(attachmentFile.path)) {
+            continue;
+          }
+          parentFolderPaths.add(attachmentFile.parent?.path ?? "");
+          await deleteIfNotUsed({
+            app: this.app,
+            deletedNotePath: this.file.path,
+            pathOrFile: attachmentFile,
+            rescueStillUsedFile: this.rescueStillUsedFile.bind(this),
+            shouldDeleteEmptyFolders: settings.emptyFolderBehavior !== EmptyFolderBehavior.Keep
+          });
+          this.abortSignal.throwIfAborted();
+        }
+      }
+    }
+    parentFolderPaths.delete("");
+    await cleanupEmptyFolders({
+      app: this.app,
+      emptyFolderBehavior: settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,
+      folderPaths: [...parentFolderPaths]
+    });
+    this.abortSignal.throwIfAborted();
+    if (!settings.shouldHandleDeletions) {
+      return;
+    }
+    const attachmentFolderPath = await getAttachmentFolderPath({
+      app: this.app,
+      context: AttachmentPathContext.DeleteNote,
+      notePathOrFile: this.file.path
+    });
+    const attachmentFolder = getFolderOrNull({ app: this.app, pathOrFolder: attachmentFolderPath });
+    if (!attachmentFolder || !await hasOwnAttachmentFolder({
+      app: this.app,
+      context: AttachmentPathContext.DeleteNote,
+      path: this.file.path
+    })) {
+      return;
+    }
+    this.abortSignal.throwIfAborted();
+    await deleteIfNotUsed({
+      app: this.app,
+      deletedNotePath: this.file.path,
+      pathOrFile: attachmentFolder,
+      rescueStillUsedFile: this.rescueStillUsedFile.bind(this),
+      shouldDeleteEmptyFolders: settings.emptyFolderBehavior !== EmptyFolderBehavior.Keep
+    });
+    this.abortSignal.throwIfAborted();
+  }
+  rescueStillUsedFile(rescueParams) {
+    return didRescueStillUsedAttachment({
+      app: this.app,
+      pluginNoticeComponent: this.pluginNoticeComponent,
+      rescueParams,
+      settingsManager: this.settingsManager
+    });
+  }
+}
+class DeleteProtectionPatchComponent extends MonkeyAroundComponent {
+  app;
+  pluginNoticeComponent;
+  /**
+   * Roots of the folder deletions currently being replayed. The replay deletes through the UNPATCHED
+   * original, so it cannot re-enter this component directly — but `FileManager.trashFile` itself calls down
+   * into `Vault.trash` / `Vault.delete`, which are patched too, and re-scanning a subtree already being
+   * walked is pure waste. Scoped by path rather than by a flag so that an unrelated folder deletion
+   * interleaving on an `await` is still protected.
+   */
+  replayedFolderPaths = /* @__PURE__ */ new Set();
+  settingsManager;
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.settingsManager = params.settingsManager;
+  }
+  onload() {
+    this.registerMethodPatch({
+      $object: FileManager.prototype,
+      methodName: "trashFile",
+      patchHandler: ({ fallback, originalArguments: [file], originalMethodBound }) => this.handleDeletion(file, fallback, async (abstractFile) => {
+        await originalMethodBound(abstractFile);
+      })
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "delete",
+      patchHandler: ({ fallback, originalArguments: [file, force], originalMethodBound }) => this.handleDeletion(file, fallback, async (abstractFile) => {
+        await originalMethodBound(abstractFile, force);
+      })
+    });
+    this.registerMethodPatch({
+      $object: Vault.prototype,
+      methodName: "trash",
+      patchHandler: ({ fallback, originalArguments: [file, system], originalMethodBound }) => this.handleDeletion(file, fallback, async (abstractFile) => {
+        await originalMethodBound(abstractFile, system);
+      })
+    });
+  }
+  /**
+   * Collects the paths of every note inside the folder. They are the link sources that disappear along with
+   * the folder, so their backlinks must not keep an attachment alive.
+   *
+   * @param folder - The folder being deleted.
+   * @param settings - The aggregated rename/delete handler settings.
+   * @returns The paths of the notes inside the folder.
+   */
+  collectDeletedNotePaths(folder, settings) {
+    const deletedNotePaths = /* @__PURE__ */ new Set();
+    Vault.recurseChildren(folder, (child) => {
+      if (isFile(child) && (settings.isNote?.(child.path) ?? false)) {
+        deletedNotePaths.add(child.path);
+      }
+    });
+    return deletedNotePaths;
+  }
+  /**
+   * Finds the attachments inside the folder that a note outside it still references, and would therefore be
+   * destroyed by deleting the folder.
+   *
+   * @param folder - The folder being deleted.
+   * @param deletedNotePaths - The paths of the notes that disappear along with the folder.
+   * @param settings - The aggregated rename/delete handler settings.
+   * @returns The paths of the attachments that must survive the deletion.
+   */
+  async findStillUsedAttachmentPaths(folder, deletedNotePaths, settings) {
+    const candidateFiles = [];
+    Vault.recurseChildren(folder, (child) => {
+      if (isFile(child) && !(settings.isNote?.(child.path) ?? false)) {
+        candidateFiles.push(child);
+      }
+    });
+    const stillUsedAttachmentPaths = [];
+    for (const candidateFile of candidateFiles) {
+      const backlinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: candidateFile });
+      for (const deletedNotePath of deletedNotePaths) {
+        backlinks.clear(deletedNotePath);
+      }
+      if (backlinks.count() !== 0) {
+        stillUsedAttachmentPaths.push(candidateFile.path);
+      }
+    }
+    return stillUsedAttachmentPaths;
+  }
+  /**
+   * Decides whether a deletion needs protecting and, if so, replaces it with a protected replay.
+   *
+   * @param file - The abstract file being deleted.
+   * @param fallback - Invokes the intercepted method unchanged.
+   * @param deleteAbstractFile - Deletes a single abstract file through the intercepted method's unpatched original.
+   * @returns A {@link Promise} that resolves when the deletion is done.
+   */
+  handleDeletion(file, fallback, deleteAbstractFile) {
+    return this.shouldConsiderFolder(file) ? this.replayFolderDeletion(file, fallback, deleteAbstractFile) : fallback();
+  }
+  /**
+   * Deletes the folder while keeping whatever inside it is still referenced from outside.
+   *
+   * @param folder - The folder being deleted.
+   * @param fallback - Invokes the intercepted method unchanged.
+   * @param deleteAbstractFile - Deletes a single abstract file through the intercepted method's unpatched original.
+   * @returns A {@link Promise} that resolves when the deletion is done.
+   */
+  async replayFolderDeletion(folder, fallback, deleteAbstractFile) {
+    const settings = this.settingsManager.getSettings();
+    const deletedNotePaths = this.collectDeletedNotePaths(folder, settings);
+    const stillUsedAttachmentPaths = await this.findStillUsedAttachmentPaths(folder, deletedNotePaths, settings);
+    if (stillUsedAttachmentPaths.length === 0) {
+      getObsidianLibDebugger("RenameDeleteHandler:deleteProtection")(`Nothing to protect in ${folder.path}; deleting it as usual.`);
+      await fallback();
+      return;
+    }
+    getObsidianLibDebugger("RenameDeleteHandler:deleteProtection")(
+      `Protecting ${stillUsedAttachmentPaths.length.toString()} still-referenced attachment(s) from the deletion of ${folder.path}: ${toJson(stillUsedAttachmentPaths)}`
+    );
+    this.replayedFolderPaths.add(folder.path);
+    try {
+      await deleteIfNotUsed({
+        app: this.app,
+        deleteAbstractFile,
+        deletedNotePaths: [...deletedNotePaths],
+        pathOrFile: folder,
+        pluginNoticeComponent: this.pluginNoticeComponent,
+        rescueStillUsedFile: this.rescueStillUsedFile.bind(this),
+        /*
+         * The user named THIS folder, so it goes even under `EmptyFolderBehavior.Keep` — that setting
+         * governs folders emptied incidentally, not the one explicitly deleted. `deleteIfNotUsed` still
+         * refuses to remove any folder whose child had to be kept, which is the protection wanted here.
+         */
+        shouldDeleteEmptyFolders: true,
+        /*
+         * A note that others link to is deleted as normal; Obsidian leaves the dangling link. Protecting
+         * notes too would make deleting a folder of linked-to notes impossible.
+         */
+        shouldProtectIfStillUsed: (candidateFile) => !(settings.isNote?.(candidateFile.path) ?? false)
+      });
+    } finally {
+      this.replayedFolderPaths.delete(folder.path);
+    }
+  }
+  rescueStillUsedFile(rescueParams) {
+    return didRescueStillUsedAttachment({
+      app: this.app,
+      pluginNoticeComponent: this.pluginNoticeComponent,
+      rescueParams,
+      settingsManager: this.settingsManager
+    });
+  }
+  /**
+   * Checks whether a deletion is a folder deletion this handler is responsible for protecting.
+   *
+   * Every check here is synchronous and cheap, so a file deletion — the overwhelming majority — costs one
+   * {@link isFolder} call and reaches the original untouched.
+   *
+   * @param file - The abstract file being deleted.
+   * @returns `true` when the deletion should be scanned before it runs.
+   */
+  shouldConsiderFolder(file) {
+    if (!isFolder(file)) {
+      return false;
+    }
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleDeletions || (settings.isPathIgnored?.(file.path) ?? false)) {
+      return false;
+    }
+    for (const replayedFolderPath of this.replayedFolderPaths) {
+      if (isChildOrSelf({ app: this.app, childPathOrFile: file.path, parentPathOrFile: replayedFolderPath })) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+class FileManagerRunAsyncLinkUpdatePatchComponent extends MonkeyAroundComponent {
+  app;
+  fileManager;
+  settingsManager;
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.fileManager = params.fileManager;
+    this.settingsManager = params.settingsManager;
+  }
+  onload() {
+    this.registerMethodPatch({
+      $object: this.fileManager,
+      methodName: "runAsyncLinkUpdate",
+      patchHandler: ({
+        fallback,
+        originalArguments: [linkUpdatesHandler],
+        originalMethod,
+        originalMethodBound
+      }) => {
+        if (hasPatchToken(originalMethod, PATCH_TOKEN)) {
+          return fallback();
+        }
+        const newHandler = (linkUpdates) => this.wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler);
+        return originalMethodBound(newHandler);
+      },
+      /*
+       * Suppressing Obsidian's own link updates is NOT idempotent, so two live copies of this component
+       * would fight over the same method. `PATCH_TOKEN` is a `Symbol.for` and the token registry is
+       * `getObsidianDevUtilsState`-backed, so the arbitration spans independently bundled copies of this
+       * library: the first patcher stays live, a copy that patches afterwards sees the token on its own
+       * `originalMethod` and defers via the guard above, and it takes over on its next call once the
+       * leader unloads and the token is dropped.
+       *
+       * This arbitrates the PATCH only. The component's `vault.on('rename' | 'delete')` and
+       * `metadataCache.on('deleted')` listeners have no equivalent guard — the plugin-registry election
+       * that used to provide one went with the multi-plugin machinery — so two live copies would both
+       * handle an event. With one owner that cannot arise; a consumer that must guarantee it refuses to
+       * load beside a conflicting version.
+       *
+       * That refusal used to be described here as "a plugin's job rather than a library's", which is no
+       * longer true — `PluginBase.getPluginDependencies` is where a consumer declares it, and the
+       * `apiVersionRange` it names is exactly the conflicting-version guard. The library owns the
+       * mechanism; the plugin still owns the decision to use it.
+       */
+      patchToken: PATCH_TOKEN
+    });
+  }
+  async wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler) {
+    let isRenameCalled = false;
+    let isForeignLockedRenameCalled = false;
+    const eventRef = this.app.vault.on("rename", (file, oldPath) => {
+      isRenameCalled = true;
+      if (isResourceLockedForPathByAncestor(this.app, file.path) || isResourceLockedForPathByAncestor(this.app, oldPath)) {
+        isForeignLockedRenameCalled = true;
+      }
+    });
+    try {
+      await linkUpdatesHandler(linkUpdates);
+    } finally {
+      this.app.vault.offref(eventRef);
+    }
+    const settings = this.settingsManager.getSettings();
+    if (!isRenameCalled || !settings.shouldHandleRenames || isForeignLockedRenameCalled) {
+      return;
+    }
+    filterInPlace(
+      linkUpdates,
+      (linkUpdate) => {
+        if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {
+          getObsidianLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
+            `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`
+          );
+          return true;
+        }
+        if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {
+          getObsidianLibDebugger("RenameDeleteHandler:runAsyncLinkUpdate")(
+            `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`
+          );
+          return true;
+        }
+        return this.app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas) !== null && !hasBacklinkCachePlugin(this.app) && (linkUpdate.sourceFile.extension === CANVAS_FILE_EXTENSION || linkUpdate.resolvedFile.extension === CANVAS_FILE_EXTENSION);
+      }
+    );
+  }
+}
+class HandledRenames {
+  map = /* @__PURE__ */ new Map();
+  add(oldPath, newPath) {
+    this.map.set(this.keyToString(oldPath, newPath), { newPath, oldPath });
+  }
+  delete(oldPath, newPath) {
+    this.map.delete(this.keyToString(oldPath, newPath));
+  }
+  has(oldPath, newPath) {
+    return this.map.has(this.keyToString(oldPath, newPath));
+  }
+  keys() {
+    return this.map.values();
+  }
+  keyToString(oldPath, newPath) {
+    return `${oldPath} -> ${newPath}`;
+  }
+}
+class MetadataDeletedHandler {
+  deletedMetadataCacheMap;
+  file;
+  previousCache;
+  settingsManager;
+  constructor(params) {
+    this.deletedMetadataCacheMap = params.deletedMetadataCacheMap;
+    this.file = params.file;
+    this.previousCache = params.previousCache;
+    this.settingsManager = params.settingsManager;
+  }
+  handle() {
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleDeletions) {
+      return;
+    }
+    if (settings.isPathIgnored?.(this.file.path)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleMetadataDeleted")(`Skipping metadata delete handler of ${this.file.path} as the path is ignored.`);
+      return;
+    }
+    if (isMarkdownFile(this.file) && this.previousCache) {
+      this.deletedMetadataCacheMap.set(this.file.path, this.previousCache);
+    }
+  }
+}
+class RenameHandler {
+  abortSignal;
+  app;
+  handledRenames;
+  interruptedCombinedBacklinksMap;
+  interruptedRenamesMap;
+  linkUpdateProgressReporter;
+  newPath;
+  oldCache;
+  oldPath;
+  oldPathBacklinksMap;
+  pluginNoticeComponent;
+  resourceLockComponent;
+  settingsManager;
+  constructor(params) {
+    this.abortSignal = params.abortSignal;
+    this.app = params.app;
+    this.resourceLockComponent = params.resourceLockComponent;
+    this.handledRenames = params.handledRenames;
+    this.interruptedCombinedBacklinksMap = params.interruptedCombinedBacklinksMap ?? /* @__PURE__ */ new Map();
+    this.interruptedRenamesMap = params.interruptedRenamesMap;
+    this.linkUpdateProgressReporter = params.linkUpdateProgressReporter;
+    this.newPath = params.newPath;
+    this.oldCache = params.oldCache;
+    this.oldPath = params.oldPath;
+    this.oldPathBacklinksMap = params.oldPathBacklinksMap;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.settingsManager = params.settingsManager;
+  }
+  async handle() {
+    if (this.oldPath === this.newPath) {
+      return;
+    }
+    this.abortSignal.throwIfAborted();
+    await waitForPendingLinkUpdates(this.app);
+    this.abortSignal.throwIfAborted();
+    await this.continueInterruptedRenames();
+    this.abortSignal.throwIfAborted();
+    if (this.settingsManager.getSettings().shouldHandleRenames) {
+      await this.refreshLinks();
+      this.abortSignal.throwIfAborted();
+    }
+    if (await this.handleCaseCollision()) {
+      return;
+    }
+    this.abortSignal.throwIfAborted();
+    const pluginNoticeComponent = this.pluginNoticeComponent;
+    const renamedFilePaths = getObsidianDevUtilsState("renamedFilePaths", /* @__PURE__ */ new Set()).value;
+    const renamedLinks = getObsidianDevUtilsState("renamedLinkPaths", /* @__PURE__ */ new Set()).value;
+    try {
+      const renameMap = new RenameMap({
+        abortSignal: this.abortSignal,
+        app: this.app,
+        newPath: this.newPath,
+        oldCache: this.oldCache,
+        oldPath: this.oldPath,
+        settingsManager: this.settingsManager
+      });
+      await renameMap.fill();
+      this.abortSignal.throwIfAborted();
+      const settings = this.settingsManager.getSettings();
+      const combinedBacklinksMap = /* @__PURE__ */ new Map();
+      if (settings.shouldHandleRenames) {
+        renameMap.initOriginalLinksMap(combinedBacklinksMap);
+        renameMap.initBacklinksMap({
+          combinedBacklinksMap,
+          path: this.oldPath,
+          singleBacklinksMap: this.oldPathBacklinksMap
+        });
+        for (const attachmentOldPath of renameMap.keys()) {
+          if (attachmentOldPath === this.oldPath) {
+            continue;
+          }
+          const attachmentOldPathBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: attachmentOldPath });
+          const attachmentOldPathBacklinksMap = attachmentOldPathBacklinks.data;
+          this.abortSignal.throwIfAborted();
+          renameMap.initBacklinksMap({
+            combinedBacklinksMap,
+            path: attachmentOldPath,
+            singleBacklinksMap: attachmentOldPathBacklinksMap
+          });
+        }
+      }
+      const parentFolderPaths = /* @__PURE__ */ new Set();
+      for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {
+        if (oldAttachmentPath !== this.oldPath) {
+          const fixedNewAttachmentPath = await this.renameHandled(oldAttachmentPath, newAttachmentPath);
+          this.abortSignal.throwIfAborted();
+          renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);
+        }
+        if (!this.settingsManager.isNoteEx(oldAttachmentPath)) {
+          parentFolderPaths.add(dirname(oldAttachmentPath));
+        }
+      }
+      await cleanupEmptyFolders({
+        app: this.app,
+        emptyFolderBehavior: settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,
+        folderPaths: [...parentFolderPaths]
+      });
+      this.abortSignal.throwIfAborted();
+      if (!settings.shouldHandleRenames) {
+        return;
+      }
+      for (const [interruptedBacklinkPath, interruptedLinkKeyToPathMap] of this.interruptedCombinedBacklinksMap) {
+        const linkKeyToPathMap = combinedBacklinksMap.get(interruptedBacklinkPath);
+        if (!linkKeyToPathMap) {
+          combinedBacklinksMap.set(interruptedBacklinkPath, interruptedLinkKeyToPathMap);
+          continue;
+        }
+        for (const [linkKey, oldTargetPath] of interruptedLinkKeyToPathMap) {
+          if (!linkKeyToPathMap.has(linkKey)) {
+            linkKeyToPathMap.set(linkKey, oldTargetPath);
+          }
+        }
+      }
+      const linkIndexes = /* @__PURE__ */ new Map();
+      await editBacklinksSnapshot(normalizeOptionalProperties({
+        abortSignal: this.abortSignal,
+        app: this.app,
+        linkConverter: ({ link, payload: oldAttachmentPath, sourcePath: newBacklinkPath }) => {
+          const linkIndex = (linkIndexes.get(newBacklinkPath) ?? 0) + 1;
+          linkIndexes.set(newBacklinkPath, linkIndex);
+          if (!oldAttachmentPath) {
+            getObsidianLibDebugger("RenameDeleteHandler:updateBacklinks")(
+              `No snapshot entry for link ${toJson(link)} in ${newBacklinkPath}; leaving it unchanged.`
+            );
+            return;
+          }
+          const newAttachmentPath = renameMap.get(oldAttachmentPath) ?? oldAttachmentPath;
+          renamedFilePaths.add(newBacklinkPath);
+          renamedLinks.add(`${newBacklinkPath}//${String(linkIndex)}`);
+          return updateLink(normalizeOptionalProperties({
+            app: this.app,
+            link,
+            newSourcePathOrFile: newBacklinkPath,
+            newTargetPathOrFile: newAttachmentPath,
+            oldTargetPathOrFile: oldAttachmentPath,
+            shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
+          }));
+        },
+        linkUpdateProgressReporter: this.linkUpdateProgressReporter ?? void 0,
+        pluginNoticeComponent,
+        resourceLockComponent: this.resourceLockComponent,
+        shouldFailOnMissingFile: false,
+        // The converter logs every link it declines, so it has to be shown the ones the snapshot does not name.
+        shouldVisitUnmatchedLinks: true,
+        snapshot: combinedBacklinksMap
+      }));
+      this.abortSignal.throwIfAborted();
+      if (isNote(this.newPath)) {
+        await updateLinksInFile(normalizeOptionalProperties({
+          app: this.app,
+          newSourcePathOrFile: this.newPath,
+          oldSourcePathOrFile: this.oldPath,
+          pluginNoticeComponent,
+          resourceLockComponent: this.resourceLockComponent,
+          shouldFailOnMissingFile: false,
+          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases
+        }));
+        this.abortSignal.throwIfAborted();
+      }
+      if (!getFileOrNull({ app: this.app, pathOrFile: this.newPath })) {
+        let interruptedRenames = this.interruptedRenamesMap.get(this.newPath);
+        if (!interruptedRenames) {
+          interruptedRenames = [];
+          this.interruptedRenamesMap.set(this.newPath, interruptedRenames);
+        }
+        interruptedRenames.push({
+          combinedBacklinksMap,
+          oldPath: this.oldPath
+        });
+      }
+    } finally {
+      const orphanKeys = [...this.handledRenames.keys()];
+      addToQueue({
+        abortSignal: this.abortSignal,
+        operationFunction: () => {
+          for (const orphanKey of orphanKeys) {
+            this.handledRenames.delete(orphanKey.oldPath, orphanKey.newPath);
+          }
+          if (renamedLinks.size === 0) {
+            return;
+          }
+          pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.renameDeleteHandler.updatedLinks, { filesCount: renamedFilePaths.size, linksCount: renamedLinks.size }));
+          renamedFilePaths.clear();
+          renamedLinks.clear();
+        },
+        operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleOrphanedRenames)
+      });
+    }
+  }
+  async continueInterruptedRenames() {
+    const interruptedRenames = this.interruptedRenamesMap.get(this.oldPath);
+    if (!interruptedRenames) {
+      return;
+    }
+    this.interruptedRenamesMap.delete(this.oldPath);
+    for (const interruptedRename of interruptedRenames) {
+      await new RenameHandler({
+        abortSignal: this.abortSignal,
+        app: this.app,
+        handledRenames: this.handledRenames,
+        interruptedCombinedBacklinksMap: interruptedRename.combinedBacklinksMap,
+        interruptedRenamesMap: this.interruptedRenamesMap,
+        linkUpdateProgressReporter: this.linkUpdateProgressReporter,
+        newPath: this.newPath,
+        oldCache: this.oldCache,
+        oldPath: interruptedRename.oldPath,
+        oldPathBacklinksMap: this.oldPathBacklinksMap,
+        pluginNoticeComponent: this.pluginNoticeComponent,
+        resourceLockComponent: this.resourceLockComponent,
+        settingsManager: this.settingsManager
+      }).handle();
+    }
+  }
+  async handleCaseCollision() {
+    if (!getDataAdapterEx(this.app).insensitive || this.oldPath.toLowerCase() !== this.newPath.toLowerCase()) {
+      return false;
+    }
+    const temporaryPath = join(dirname(this.newPath), `__temp__${basename(this.newPath)}`);
+    await this.renameHandled(this.newPath, temporaryPath);
+    await new RenameHandler({
+      abortSignal: this.abortSignal,
+      app: this.app,
+      handledRenames: this.handledRenames,
+      interruptedRenamesMap: this.interruptedRenamesMap,
+      linkUpdateProgressReporter: this.linkUpdateProgressReporter,
+      newPath: temporaryPath,
+      oldCache: this.oldCache,
+      oldPath: this.oldPath,
+      oldPathBacklinksMap: this.oldPathBacklinksMap,
+      pluginNoticeComponent: this.pluginNoticeComponent,
+      resourceLockComponent: this.resourceLockComponent,
+      settingsManager: this.settingsManager
+    }).handle();
+    await this.app.fileManager.renameFile(getFile({ app: this.app, pathOrFile: temporaryPath }), this.newPath);
+    return true;
+  }
+  async refreshLinks() {
+    const fakeOldFile = getFile({ app: this.app, pathOrFile: this.oldPath, shouldIncludeNonExisting: true });
+    let oldPathBacklinksMapRefreshed;
+    {
+      var _stack = [];
+      try {
+        const _registration = __using(_stack, registerFiles(this.app, [fakeOldFile]));
+        const fakeOldFileBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: fakeOldFile });
+        oldPathBacklinksMapRefreshed = fakeOldFileBacklinks.data;
+      } catch (_) {
+        var _error = _, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    }
+    for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed) {
+      let oldLinks = this.oldPathBacklinksMap.get(backlinkPath);
+      if (!oldLinks) {
+        oldLinks = [];
+        this.oldPathBacklinksMap.set(backlinkPath, oldLinks);
+      }
+      for (const link of refreshedLinks) {
+        if (oldLinks.includes(link)) {
+          continue;
+        }
+        oldLinks.push(link);
+      }
+    }
+  }
+  async renameHandled(oldPath, newPath) {
+    newPath = getSafeRenamePath({ app: this.app, newPath, oldPathOrAbstractFile: oldPath });
+    if (oldPath === newPath) {
+      return newPath;
+    }
+    this.handledRenames.add(oldPath, newPath);
+    newPath = await renameSafe({ app: this.app, newPath, oldPathOrAbstractFile: oldPath });
+    return newPath;
+  }
+}
+class RenameMap {
+  abortSignal;
+  app;
+  map = /* @__PURE__ */ new Map();
+  newPath;
+  oldCache;
+  oldPath;
+  oldPathLinks;
+  settingsManager;
+  constructor(params) {
+    this.abortSignal = params.abortSignal;
+    this.app = params.app;
+    this.settingsManager = params.settingsManager;
+    this.oldCache = params.oldCache;
+    this.oldPath = params.oldPath;
+    this.newPath = params.newPath;
+    this.oldPathLinks = this.oldCache ? getLinks({ cache: this.oldCache }) : [];
+  }
+  entries() {
+    return this.map.entries();
+  }
+  async fill() {
+    this.abortSignal.throwIfAborted();
+    this.map.set(this.oldPath, this.newPath);
+    if (!isNote(this.oldPath)) {
+      return;
+    }
+    if (isCanvasFile(this.oldPath)) {
+      const canvasReferences = await getCanvasReferences(this.app, this.newPath);
+      this.oldPathLinks.push(...canvasReferences);
+    }
+    const settings = this.settingsManager.getSettings();
+    const oldFile = getFile({ app: this.app, pathOrFile: this.oldPath, shouldIncludeNonExisting: true });
+    const oldAttachmentFolderPath = await this.getOldAttachmentFolderPath(oldFile);
+    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder ? await getAttachmentFolderPath({
+      app: this.app,
+      context: AttachmentPathContext.RenameNote,
+      notePathOrFile: this.newPath
+    }) : oldAttachmentFolderPath;
+    const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === "/";
+    const oldAttachmentFolder = getFolderOrNull({ app: this.app, pathOrFolder: oldAttachmentFolderPath });
+    if (!oldAttachmentFolder || oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles) {
+      return;
+    }
+    const oldAttachmentFiles = [];
+    if (await hasOwnAttachmentFolder({
+      app: this.app,
+      context: AttachmentPathContext.RenameNote,
+      path: this.oldPath
+    })) {
+      Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {
+        this.abortSignal.throwIfAborted();
+        if (isFile(oldAttachmentFile)) {
+          oldAttachmentFiles.push(oldAttachmentFile);
+        }
+      });
+    } else {
+      for (const oldPathLink of this.oldPathLinks) {
+        this.abortSignal.throwIfAborted();
+        const oldAttachmentFile = extractLinkFile({ app: this.app, link: oldPathLink, sourcePathOrFile: this.oldPath });
+        if (!oldAttachmentFile || !isOldAttachmentFolderAtRoot && !oldAttachmentFile.path.startsWith(oldAttachmentFolderPath)) {
+          continue;
+        }
+        const oldAttachmentBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: oldAttachmentFile });
+        this.abortSignal.throwIfAborted();
+        const keys = new Set(oldAttachmentBacklinks.keys());
+        keys.delete(this.oldPath);
+        keys.delete(this.newPath);
+        if (keys.size === 0) {
+          oldAttachmentFiles.push(oldAttachmentFile);
+        }
+      }
+    }
+    for (const oldAttachmentFile of oldAttachmentFiles) {
+      this.abortSignal.throwIfAborted();
+      if (this.settingsManager.isNoteEx(oldAttachmentFile.path)) {
+        continue;
+      }
+      let newAttachmentFilePath;
+      if (settings.shouldRenameAttachmentFiles) {
+        newAttachmentFilePath = await getAttachmentFilePath({
+          app: this.app,
+          context: AttachmentPathContext.RenameNote,
+          notePathOrFile: this.newPath,
+          oldAttachmentPathOrFile: oldAttachmentFile,
+          oldNotePathOrFile: this.oldPath,
+          shouldSkipDuplicateCheck: true
+        });
+        this.abortSignal.throwIfAborted();
+      } else {
+        const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);
+        const newFolder = join(newAttachmentFolderPath, dirname(relativePath));
+        newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);
+      }
+      if (oldAttachmentFile.path === newAttachmentFilePath) {
+        continue;
+      }
+      if (settings.shouldDeleteConflictingAttachments) {
+        const newAttachmentFile = getFileOrNull({ app: this.app, pathOrFile: newAttachmentFilePath });
+        if (newAttachmentFile) {
+          getObsidianLibDebugger("RenameDeleteHandler:fillRenameMap")(`Removing conflicting attachment ${newAttachmentFile.path}.`);
+          await trashSafe(this.app, newAttachmentFile);
+          this.abortSignal.throwIfAborted();
+        }
+      } else {
+        const directory = dirname(newAttachmentFilePath);
+        const extension = extname(newAttachmentFilePath);
+        const baseName = basename(newAttachmentFilePath, extension);
+        newAttachmentFilePath = this.app.vault.getAvailablePath(join(directory, baseName), extension.slice(1));
+      }
+      this.map.set(oldAttachmentFile.path, newAttachmentFilePath);
+    }
+  }
+  get(oldPath) {
+    return this.map.get(oldPath);
+  }
+  initBacklinksMap(params) {
+    const {
+      combinedBacklinksMap,
+      path,
+      singleBacklinksMap
+    } = params;
+    buildBacklinksSnapshot({
+      backlinks: singleBacklinksMap,
+      linkIdentityKeyProvider: getLinkIdentityKey,
+      pathRemapper: (backlinkPath) => this.map.get(backlinkPath) ?? backlinkPath,
+      payloadProvider: () => path,
+      target: combinedBacklinksMap
+    });
+  }
+  initOriginalLinksMap(combinedBacklinksMap) {
+    for (const oldPathLink of this.oldPathLinks) {
+      const oldAttachmentFile = extractLinkFile({ app: this.app, link: oldPathLink, sourcePathOrFile: this.oldPath });
+      if (!oldAttachmentFile) {
+        continue;
+      }
+      const backlinksMap = /* @__PURE__ */ new Map([[this.newPath, [oldPathLink]]]);
+      this.initBacklinksMap({
+        combinedBacklinksMap,
+        path: oldAttachmentFile.path,
+        singleBacklinksMap: backlinksMap
+      });
+    }
+  }
+  keys() {
+    return this.map.keys();
+  }
+  set(oldPath, newPath) {
+    this.map.set(oldPath, newPath);
+  }
+  async getOldAttachmentFolderPath(oldFile) {
+    var _stack = [];
+    try {
+      const _registration = __using(_stack, registerFiles(this.app, [oldFile]));
+      const _cacheRegistration = __using(_stack, this.oldCache && oldFile.deleted ? registerFileCacheForNonExistingFile({ app: this.app, cache: this.oldCache, pathOrFile: oldFile }) : void 0);
+      return await getAttachmentFolderPath({
+        app: this.app,
+        context: AttachmentPathContext.RenameNote,
+        notePathOrFile: this.oldPath
+      });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+}
+class SettingsManager {
+  settingsBuilder;
+  constructor(settingsBuilder) {
+    this.settingsBuilder = settingsBuilder;
+  }
+  getSettings() {
+    const builtSettings = this.settingsBuilder();
+    return {
+      ...builtSettings,
+      emptyFolderBehavior: builtSettings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,
+      isNote: (path) => builtSettings.isNote?.(path) ?? isNote(path),
+      isPathIgnored: (path) => builtSettings.isPathIgnored?.(path) ?? false
+    };
+  }
+  isNoteEx(path) {
+    const settings = this.getSettings();
+    return settings.isNote?.(path) ?? false;
+  }
+}
+class RenameDeleteHandlerComponent extends ComponentEx {
+  /**
+   * The abort signal component whose signal cancels in-flight rename operations.
+   */
+  abortSignalComponent;
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * An optional reporter invoked once per backlink file whose links are updated during a rename/move,
+   * with the running count of processed files and the total. When `null`, no progress is reported.
+   */
+  linkUpdateProgressReporter;
+  /**
+   * The notice component used to report updated links to the user.
+   */
+  pluginNoticeComponent;
+  /**
+   * The resource lock component used to guard link updates, or `null` if none is used.
+   */
+  resourceLockComponent;
+  /**
+   * Builds this plugin's rename/delete handler settings.
+   */
+  settingsBuilder;
+  /**
+   * The manager that aggregates rename/delete handler settings across registered plugins.
+   */
+  settingsManager;
+  deletedMetadataCacheMap = /* @__PURE__ */ new Map();
+  handledRenames = new HandledRenames();
+  interruptedRenamesMap = /* @__PURE__ */ new Map();
+  /**
+   * Creates an instance of RenameDeleteHandlerComponent.
+   *
+   * @param params - The parameters for the RenameDeleteHandlerComponent.
+   */
+  constructor(params) {
+    super();
+    this.abortSignalComponent = params.abortSignalComponent;
+    this.app = params.app;
+    this.linkUpdateProgressReporter = params.linkUpdateProgressReporter ?? null;
+    this.resourceLockComponent = params.resourceLockComponent;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.settingsBuilder = params.settingsBuilder;
+    this.settingsManager = new SettingsManager(this.settingsBuilder);
+  }
+  /**
+   * Loads the component
+   */
+  onload() {
+    this.registerEvent(this.app.vault.on("delete", this.handleDelete.bind(this)));
+    this.registerEvent(this.app.vault.on("rename", this.handleRename.bind(this)));
+    this.registerEvent(this.app.metadataCache.on("deleted", this.handleMetadataDeleted.bind(this)));
+    this.addChild(
+      new FileManagerRunAsyncLinkUpdatePatchComponent({
+        app: this.app,
+        fileManager: this.app.fileManager,
+        settingsManager: this.settingsManager
+      })
+    );
+    this.addChild(
+      new DeleteProtectionPatchComponent({
+        app: this.app,
+        pluginNoticeComponent: this.pluginNoticeComponent,
+        settingsManager: this.settingsManager
+      })
+    );
+  }
+  handleDelete(file) {
+    addToQueue({
+      operationFunction: (abortSignal) => new DeleteHandler({
+        abortSignal,
+        app: this.app,
+        deletedMetadataCacheMap: this.deletedMetadataCacheMap,
+        file,
+        pluginNoticeComponent: this.pluginNoticeComponent,
+        settingsManager: this.settingsManager
+      }).handle(),
+      operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleDelete, { filePath: file.path })
+    });
+  }
+  handleMetadataDeleted(file, previousCache) {
+    new MetadataDeletedHandler({
+      deletedMetadataCacheMap: this.deletedMetadataCacheMap,
+      file,
+      previousCache,
+      settingsManager: this.settingsManager
+    }).handle();
+  }
+  handleRename(file, oldPath) {
+    if (!isFile(file)) {
+      return;
+    }
+    const newPath = file.path;
+    getObsidianLibDebugger("RenameDeleteHandler:handleRename")(`Handle Rename ${oldPath} -> ${newPath}`);
+    if (this.handledRenames.has(oldPath, newPath)) {
+      this.handledRenames.delete(oldPath, newPath);
+      return;
+    }
+    if (isResourceLockedForPathByAncestor(this.app, oldPath) || isResourceLockedForPathByAncestor(this.app, newPath)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleRename")(
+        `Skipping rename handler of ${oldPath} -> ${newPath} as it occurs inside a foreign locked transaction.`
+      );
+      return;
+    }
+    const settings = this.settingsManager.getSettings();
+    if (!settings.shouldHandleRenames && !settings.shouldRenameAttachmentFolder && !settings.shouldRenameAttachmentFiles) {
+      return;
+    }
+    if (this.isNoOpRename(settings, oldPath, newPath)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleRename")(
+        `Skipping rename handler of ${oldPath} -> ${newPath} as it is not a note and there is nothing to do with link updates disabled.`
+      );
+      return;
+    }
+    if (settings.isPathIgnored?.(oldPath)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);
+      return;
+    }
+    if (settings.isPathIgnored?.(newPath)) {
+      getObsidianLibDebugger("RenameDeleteHandler:handleRename")(`Skipping rename handler of new path ${newPath} as the path is ignored.`);
+      return;
+    }
+    const oldCache = this.app.metadataCache.getCache(oldPath) ?? this.app.metadataCache.getCache(newPath);
+    const oldPathBacklinksMap = getBacklinksForFileOrPath(this.app, oldPath).data;
+    addToQueue({
+      abortSignal: this.abortSignalComponent.abortSignal,
+      operationFunction: (abortSignal) => new RenameHandler({
+        abortSignal,
+        app: this.app,
+        handledRenames: this.handledRenames,
+        interruptedRenamesMap: this.interruptedRenamesMap,
+        linkUpdateProgressReporter: this.linkUpdateProgressReporter,
+        newPath,
+        oldCache,
+        oldPath,
+        oldPathBacklinksMap,
+        pluginNoticeComponent: this.pluginNoticeComponent,
+        resourceLockComponent: this.resourceLockComponent,
+        settingsManager: this.settingsManager
+      }).handle(),
+      operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleRename, { newPath, oldPath })
+    });
+  }
+  /**
+   * With link rewriting off, the handler's only remaining jobs are moving a NOTE's attachments and pruning
+   * the folder a moved file vacated. A non-note rename needs neither when empty folders are kept, so there
+   * is nothing to queue.
+   *
+   * @param settings - The aggregated rename/delete handler settings.
+   * @param oldPath - The path the file was renamed from.
+   * @param newPath - The path the file was renamed to.
+   * @returns `true` when the handler would do no work for this rename.
+   */
+  isNoOpRename(settings, oldPath, newPath) {
+    return !settings.shouldHandleRenames && !(settings.isNote?.(oldPath) ?? false) && !(settings.isNote?.(newPath) ?? false) && (settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep) === EmptyFolderBehavior.Keep;
+  }
+}
+async function didRescueStillUsedAttachment(params) {
+  const settings = params.settingsManager.getSettings();
+  if (!settings.getRescuePath) {
+    return false;
+  }
+  const attachmentPath = params.rescueParams.file.path;
+  const rescuePath = await settings.getRescuePath({
+    attachmentPath,
+    survivingNotePaths: params.rescueParams.survivingNotePaths
+  });
+  if (rescuePath === null) {
+    getObsidianLibDebugger("RenameDeleteHandler:didRescueStillUsedAttachment")(`No rescue path for ${attachmentPath}; keeping it where it is.`);
+    return false;
+  }
+  try {
+    const newAttachmentPath = await renameSafe({
+      app: params.app,
+      newPath: rescuePath,
+      oldPathOrAbstractFile: params.rescueParams.file
+    });
+    if (newAttachmentPath === attachmentPath) {
+      getObsidianLibDebugger("RenameDeleteHandler:didRescueStillUsedAttachment")(`${attachmentPath} already sits at its rescue path; nothing to move.`);
+      return false;
+    }
+    await waitForPendingLinkUpdates(params.app);
+    getObsidianLibDebugger("RenameDeleteHandler:didRescueStillUsedAttachment")(`Rescued ${attachmentPath} to ${newAttachmentPath}.`);
+    params.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.notices.attachmentRescued, { attachmentPath, newAttachmentPath }));
+    return true;
+  } catch (error) {
+    printError(new Error(`Failed to rescue ${attachmentPath} to ${rescuePath}`, { cause: error }));
+    return false;
+  }
+}
+function getLinkIdentityKey(link) {
+  return toJson({
+    link: link.link,
+    original: link.original
+  });
+}
+export {
+  EmptyFolderBehavior2 as EmptyFolderBehavior,
+  RenameDeleteHandlerComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/components/rename-delete-handler-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for handling rename and delete events in Obsidian.\n */\n\nimport type {\n  LinkUpdate,\n  LinkUpdatesHandler\n} from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  CachedMetadata,\n  Reference,\n  TAbstractFile,\n  TFile,\n  TFolder\n} from 'obsidian';\n\nimport { filterInPlace } from '@mnaoumov/typescript-lib/array';\nimport { printError } from '@mnaoumov/typescript-lib/error';\nimport {\n  normalizeOptionalProperties,\n  toJson\n} from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  basename,\n  dirname,\n  extname,\n  join,\n  relative\n} from '@mnaoumov/typescript-lib/path';\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\nimport {\n  getDataAdapterEx,\n  InternalPluginName\n} from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { t } from 'i18next';\nimport {\n  FileManager,\n  Vault\n} from 'obsidian';\n\nimport type { LinkUpdateProgressReporter } from '../link-update-progress.ts';\nimport type {\n  EditBacklinksSnapshotParams,\n  UpdateLinkParams,\n  UpdateLinksInFileParams\n} from '../link.ts';\nimport type { ResourceLockComponent } from '../resource-lock.ts';\nimport type { RescueStillUsedFileParams } from '../vault-delete.ts';\nimport type { AbortSignalComponent } from './abort-signal-component.ts';\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport {\n  AttachmentPathContext,\n  getAttachmentFilePath,\n  getAttachmentFolderPath,\n  hasOwnAttachmentFolder\n} from '../attachment-path.ts';\nimport { getCanvasReferences } from '../canvas.ts';\nimport { getObsidianLibDebugger } from '../debug.ts';\nimport { waitForPendingLinkUpdates } from '../file-manager.ts';\nimport {\n  CANVAS_FILE_EXTENSION,\n  getFile,\n  getFileOrNull,\n  getFolderOrNull,\n  isCanvasFile,\n  isFile,\n  isFolder,\n  isMarkdownFile,\n  isNote\n} from '../file-system.ts';\nimport {\n  buildBacklinksSnapshot,\n  editBacklinksSnapshot,\n  extractLinkFile,\n  updateLink,\n  updateLinksInFile\n} from '../link.ts';\nimport {\n  getBacklinksForFileOrPath,\n  getBacklinksForFileSafe,\n  getLinks,\n  hasBacklinkCachePlugin,\n  registerFileCacheForNonExistingFile,\n  registerFiles\n} from '../metadata-cache.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport { addToQueue } from '../queue.ts';\nimport { isResourceLockedForPathByAncestor } from '../resource-lock.ts';\nimport { deleteIfNotUsed } from '../vault-delete.ts';\nimport {\n  cleanupEmptyFolders,\n  EmptyFolderBehavior,\n  getSafeRenamePath,\n  isChildOrSelf,\n  renameSafe,\n  trashSafe\n} from '../vault.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport {\n  hasPatchToken,\n  MonkeyAroundComponent\n} from './monkey-around-component.ts';\n\n/**\n * Parameters for {@link RenameDeleteHandlerSettings.getRescuePath}.\n */\nexport interface GetRescuePathParams {\n  /**\n   * The path of the attachment that is about to be stranded.\n   */\n  readonly attachmentPath: string;\n\n  /**\n   * The paths of the notes that still reference the attachment once the deletion is done. Never empty.\n   */\n  readonly survivingNotePaths: readonly string[];\n}\n\n/**\n * Settings for the rename/delete handler.\n */\nexport interface RenameDeleteHandlerSettings {\n  /**\n   * A behavior of the rename/delete handler when deleting empty folders.\n   */\n  emptyFolderBehavior: EmptyFolderBehavior;\n\n  /**\n   * Where to move an attachment that a deletion would otherwise strand \u2014 one that survives because another\n   * note still references it, but is left sitting in a folder whose owning note is gone.\n   *\n   * Deciding the destination is the plugin's attachment-path policy, which is why the handler asks rather\n   * than guesses. Returning `null` \u2014 or not implementing this at all \u2014 keeps the attachment where it is,\n   * which is the behavior every consumer had before this member existed.\n   */\n  getRescuePath?: (params: GetRescuePathParams) => Promise<null | string>;\n\n  /**\n   * Whether the path is a note.\n   */\n  isNote: (path: string) => boolean;\n\n  /**\n   * Whether to ignore the path.\n   */\n  isPathIgnored: (path: string) => boolean;\n\n  /**\n   * Whether to delete conflicting attachments.\n   */\n  shouldDeleteConflictingAttachments: boolean;\n\n  /**\n   * Whether to handle deletions.\n   */\n  shouldHandleDeletions: boolean;\n\n  /**\n   * Whether to handle renames.\n   */\n  shouldHandleRenames: boolean;\n\n  /**\n   * Whether to rename attachment files when a note is renamed.\n   */\n  shouldRenameAttachmentFiles: boolean;\n\n  /**\n   * Whether to rename attachment folder when a note is renamed.\n   */\n  shouldRenameAttachmentFolder: boolean;\n\n  /**\n   * Whether to update file name aliases when a note is renamed.\n   */\n  shouldUpdateFileNameAliases: boolean;\n}\n\ninterface HandledRenameKey {\n  newPath: string;\n  oldPath: string;\n}\n\ninterface InterruptedRename {\n  combinedBacklinksMap: Map<string, Map<string, string>>;\n  oldPath: string;\n}\n\ninterface RenameHandlerConstructorParams {\n  readonly abortSignal: AbortSignal;\n  readonly app: App;\n  readonly handledRenames: HandledRenames;\n  readonly interruptedCombinedBacklinksMap?: Map<string, Map<string, string>>;\n  readonly interruptedRenamesMap: Map<string, InterruptedRename[]>;\n  readonly linkUpdateProgressReporter: LinkUpdateProgressReporter | null;\n  readonly newPath: string;\n  readonly oldCache: CachedMetadata | null;\n  readonly oldPath: string;\n  readonly oldPathBacklinksMap: Map<string, Reference[]>;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly resourceLockComponent: null | ResourceLockComponent;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface RenameMapConstructorParams {\n  readonly abortSignal: AbortSignal;\n  readonly app: App;\n  readonly newPath: string;\n  readonly oldCache: CachedMetadata | null;\n  readonly oldPath: string;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface RenameMapInitBacklinksMapParams {\n  /**\n   * The combined backlinks map, keyed by new backlink path, accumulating link-JSON to source-path mappings.\n   */\n  readonly combinedBacklinksMap: Map<string, Map<string, string>>;\n\n  /**\n   * The path whose backlinks are being recorded.\n   */\n  readonly path: string;\n\n  /**\n   * The backlinks map for a single file, keyed by backlink path.\n   */\n  readonly singleBacklinksMap: Map<string, Reference[]>;\n}\n\nconst PATCH_TOKEN = Symbol.for('renameDeleteHandler');\n\ninterface DeleteHandlerConstructorParams {\n  readonly abortSignal: AbortSignal;\n  readonly app: App;\n  readonly deletedMetadataCacheMap: Map<string, CachedMetadata>;\n  readonly file: TAbstractFile;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface DeleteProtectionPatchComponentConstructorParams {\n  readonly app: App;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface DidRescueStillUsedAttachmentParams {\n  readonly app: App;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly rescueParams: RescueStillUsedFileParams;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface FileManagerRunAsyncLinkUpdatePatchComponentConstructorParams {\n  readonly app: App;\n  readonly fileManager: FileManager;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface MetadataDeletedHandlerConstructorParams {\n  readonly deletedMetadataCacheMap: Map<string, CachedMetadata>;\n  readonly file: TAbstractFile;\n  readonly previousCache: CachedMetadata | null;\n  readonly settingsManager: SettingsManager;\n}\n\ninterface RenameDeleteHandlerComponentConstructorParams {\n  readonly abortSignalComponent: AbortSignalComponent;\n  readonly app: App;\n  readonly linkUpdateProgressReporter?: LinkUpdateProgressReporter;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly resourceLockComponent: null | ResourceLockComponent;\n  readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>;\n}\n\nclass DeleteHandler {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly deletedMetadataCacheMap: Map<string, CachedMetadata>;\n  private readonly file: TAbstractFile;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: DeleteHandlerConstructorParams) {\n    this.app = params.app;\n    this.file = params.file;\n    this.abortSignal = params.abortSignal;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.settingsManager = params.settingsManager;\n    this.deletedMetadataCacheMap = params.deletedMetadataCacheMap;\n  }\n\n  public async handle(): Promise<void> {\n    this.abortSignal.throwIfAborted();\n    getObsidianLibDebugger('RenameDeleteHandler:handleDelete')(`Handle Delete ${this.file.path}`);\n    if (!isNote(this.file)) {\n      return;\n    }\n\n    if (await this.app.vault.adapter.exists(this.file.path)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleDelete')(\n        `Skipping delete handler of ${this.file.path} as the file still exists on disk (index-only removal, not a real deletion).`\n      );\n      return;\n    }\n\n    const settings = this.settingsManager.getSettings();\n\n    if (settings.isPathIgnored?.(this.file.path)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleDelete')(`Skipping delete handler of ${this.file.path} as the path is ignored.`);\n      return;\n    }\n\n    const parentFolderPaths = new Set<string>([dirname(this.file.path)]);\n\n    if (settings.shouldHandleDeletions) {\n      const cache = this.deletedMetadataCacheMap.get(this.file.path);\n      this.deletedMetadataCacheMap.delete(this.file.path);\n      if (cache) {\n        const links = getLinks({ cache });\n\n        for (const link of links) {\n          const attachmentFile = extractLinkFile({ app: this.app, link, sourcePathOrFile: this.file.path });\n          if (!attachmentFile || this.settingsManager.isNoteEx(attachmentFile.path)) {\n            continue;\n          }\n\n          parentFolderPaths.add(attachmentFile.parent?.path ?? '');\n          await deleteIfNotUsed({\n            app: this.app,\n            deletedNotePath: this.file.path,\n            pathOrFile: attachmentFile,\n            rescueStillUsedFile: this.rescueStillUsedFile.bind(this),\n            shouldDeleteEmptyFolders: settings.emptyFolderBehavior !== EmptyFolderBehavior.Keep\n          });\n          this.abortSignal.throwIfAborted();\n        }\n      }\n    }\n\n    parentFolderPaths.delete('');\n    await cleanupEmptyFolders({\n      app: this.app,\n      emptyFolderBehavior: settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,\n      folderPaths: [...parentFolderPaths]\n    });\n    this.abortSignal.throwIfAborted();\n\n    if (!settings.shouldHandleDeletions) {\n      return;\n    }\n\n    const attachmentFolderPath = await getAttachmentFolderPath({\n      app: this.app,\n      context: AttachmentPathContext.DeleteNote,\n      notePathOrFile: this.file.path\n    });\n    const attachmentFolder = getFolderOrNull({ app: this.app, pathOrFolder: attachmentFolderPath });\n\n    if (\n      !attachmentFolder || !await hasOwnAttachmentFolder({\n        app: this.app,\n        context: AttachmentPathContext.DeleteNote,\n        path: this.file.path\n      })\n    ) {\n      return;\n    }\n\n    this.abortSignal.throwIfAborted();\n\n    await deleteIfNotUsed({\n      app: this.app,\n      deletedNotePath: this.file.path,\n      pathOrFile: attachmentFolder,\n      rescueStillUsedFile: this.rescueStillUsedFile.bind(this),\n      shouldDeleteEmptyFolders: settings.emptyFolderBehavior !== EmptyFolderBehavior.Keep\n    });\n    this.abortSignal.throwIfAborted();\n  }\n\n  private rescueStillUsedFile(rescueParams: RescueStillUsedFileParams): Promise<boolean> {\n    return didRescueStillUsedAttachment({\n      app: this.app,\n      pluginNoticeComponent: this.pluginNoticeComponent,\n      rescueParams,\n      settingsManager: this.settingsManager\n    });\n  }\n}\n\n/**\n * Keeps a folder deletion from destroying an attachment a note outside that folder still references.\n *\n * Deleting a NOTE is already safe: {@link deleteIfNotUsed} discounts the deleted note's own backlinks, sees\n * another note still referencing the attachment, and keeps it. Deleting a FOLDER was not, because\n * {@link RenameDeleteHandlerComponent} only listens (`vault.on('delete')`) and by the time a folder deletion\n * is reported its children are already gone. Nothing reactive can help, so this component intercepts the\n * deletion primitives instead: `FileManager.trashFile` (what the file-explorer Delete flow reaches through\n * `promptForDeletion`) plus the raw `Vault.delete` / `Vault.trash` a plugin may call directly.\n *\n * A folder deletion is scanned first. When nothing inside it is still referenced from outside \u2014 the\n * overwhelming majority of deletions \u2014 the original runs untouched, so the native behavior is preserved\n * exactly. Only when something would be lost does this take over, replaying the deletion through\n * {@link deleteIfNotUsed}: everything else in the folder goes, the still-referenced attachments and the\n * folders holding them stay, and the `attachmentIsStillUsed` notice fires, mirroring the note case.\n *\n * Files are never intercepted \u2014 deleting a file is the user naming that file explicitly.\n */\nclass DeleteProtectionPatchComponent extends MonkeyAroundComponent {\n  private readonly app: App;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * Roots of the folder deletions currently being replayed. The replay deletes through the UNPATCHED\n   * original, so it cannot re-enter this component directly \u2014 but `FileManager.trashFile` itself calls down\n   * into `Vault.trash` / `Vault.delete`, which are patched too, and re-scanning a subtree already being\n   * walked is pure waste. Scoped by path rather than by a flag so that an unrelated folder deletion\n   * interleaving on an `await` is still protected.\n   */\n  private readonly replayedFolderPaths = new Set<string>();\n\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: DeleteProtectionPatchComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.settingsManager = params.settingsManager;\n  }\n\n  public override onload(): void {\n    this.registerMethodPatch<FileManager, 'trashFile'>({\n      $object: FileManager.prototype,\n      methodName: 'trashFile',\n      patchHandler: ({ fallback, originalArguments: [file], originalMethodBound }) =>\n        this.handleDeletion(file, fallback, async (abstractFile) => {\n          await originalMethodBound(abstractFile);\n        })\n    });\n    this.registerMethodPatch<Vault, 'delete'>({\n      $object: Vault.prototype,\n      methodName: 'delete',\n      patchHandler: ({ fallback, originalArguments: [file, force], originalMethodBound }) =>\n        this.handleDeletion(file, fallback, async (abstractFile) => {\n          await originalMethodBound(abstractFile, force);\n        })\n    });\n    this.registerMethodPatch<Vault, 'trash'>({\n      $object: Vault.prototype,\n      methodName: 'trash',\n      patchHandler: ({ fallback, originalArguments: [file, system], originalMethodBound }) =>\n        this.handleDeletion(file, fallback, async (abstractFile) => {\n          await originalMethodBound(abstractFile, system);\n        })\n    });\n  }\n\n  /**\n   * Collects the paths of every note inside the folder. They are the link sources that disappear along with\n   * the folder, so their backlinks must not keep an attachment alive.\n   *\n   * @param folder - The folder being deleted.\n   * @param settings - The aggregated rename/delete handler settings.\n   * @returns The paths of the notes inside the folder.\n   */\n  private collectDeletedNotePaths(folder: TFolder, settings: Partial<RenameDeleteHandlerSettings>): Set<string> {\n    const deletedNotePaths = new Set<string>();\n    Vault.recurseChildren(folder, (child) => {\n      if (isFile(child) && (settings.isNote?.(child.path) ?? false)) {\n        deletedNotePaths.add(child.path);\n      }\n    });\n    return deletedNotePaths;\n  }\n\n  /**\n   * Finds the attachments inside the folder that a note outside it still references, and would therefore be\n   * destroyed by deleting the folder.\n   *\n   * @param folder - The folder being deleted.\n   * @param deletedNotePaths - The paths of the notes that disappear along with the folder.\n   * @param settings - The aggregated rename/delete handler settings.\n   * @returns The paths of the attachments that must survive the deletion.\n   */\n  private async findStillUsedAttachmentPaths(\n    folder: TFolder,\n    deletedNotePaths: Set<string>,\n    settings: Partial<RenameDeleteHandlerSettings>\n  ): Promise<string[]> {\n    const candidateFiles: TFile[] = [];\n    Vault.recurseChildren(folder, (child) => {\n      if (isFile(child) && !(settings.isNote?.(child.path) ?? false)) {\n        candidateFiles.push(child);\n      }\n    });\n\n    const stillUsedAttachmentPaths: string[] = [];\n\n    for (const candidateFile of candidateFiles) {\n      const backlinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: candidateFile });\n      for (const deletedNotePath of deletedNotePaths) {\n        backlinks.clear(deletedNotePath);\n      }\n      if (backlinks.count() !== 0) {\n        stillUsedAttachmentPaths.push(candidateFile.path);\n      }\n    }\n\n    return stillUsedAttachmentPaths;\n  }\n\n  /**\n   * Decides whether a deletion needs protecting and, if so, replaces it with a protected replay.\n   *\n   * @param file - The abstract file being deleted.\n   * @param fallback - Invokes the intercepted method unchanged.\n   * @param deleteAbstractFile - Deletes a single abstract file through the intercepted method's unpatched original.\n   * @returns A {@link Promise} that resolves when the deletion is done.\n   */\n  private handleDeletion(\n    file: TAbstractFile,\n    fallback: () => Promise<void>,\n    deleteAbstractFile: (abstractFile: TAbstractFile) => Promise<void>\n  ): Promise<void> {\n    return this.shouldConsiderFolder(file) ? this.replayFolderDeletion(file, fallback, deleteAbstractFile) : fallback();\n  }\n\n  /**\n   * Deletes the folder while keeping whatever inside it is still referenced from outside.\n   *\n   * @param folder - The folder being deleted.\n   * @param fallback - Invokes the intercepted method unchanged.\n   * @param deleteAbstractFile - Deletes a single abstract file through the intercepted method's unpatched original.\n   * @returns A {@link Promise} that resolves when the deletion is done.\n   */\n  private async replayFolderDeletion(\n    folder: TFolder,\n    fallback: () => Promise<void>,\n    deleteAbstractFile: (abstractFile: TAbstractFile) => Promise<void>\n  ): Promise<void> {\n    const settings = this.settingsManager.getSettings();\n    const deletedNotePaths = this.collectDeletedNotePaths(folder, settings);\n    const stillUsedAttachmentPaths = await this.findStillUsedAttachmentPaths(folder, deletedNotePaths, settings);\n\n    if (stillUsedAttachmentPaths.length === 0) {\n      getObsidianLibDebugger('RenameDeleteHandler:deleteProtection')(`Nothing to protect in ${folder.path}; deleting it as usual.`);\n      await fallback();\n      return;\n    }\n\n    getObsidianLibDebugger('RenameDeleteHandler:deleteProtection')(\n      `Protecting ${stillUsedAttachmentPaths.length.toString()} still-referenced attachment(s) from the deletion of ${folder.path}: ${toJson(stillUsedAttachmentPaths)}`\n    );\n\n    this.replayedFolderPaths.add(folder.path);\n    try {\n      await deleteIfNotUsed({\n        app: this.app,\n        deleteAbstractFile,\n        deletedNotePaths: [...deletedNotePaths],\n        pathOrFile: folder,\n        pluginNoticeComponent: this.pluginNoticeComponent,\n        rescueStillUsedFile: this.rescueStillUsedFile.bind(this),\n        /*\n         * The user named THIS folder, so it goes even under `EmptyFolderBehavior.Keep` \u2014 that setting\n         * governs folders emptied incidentally, not the one explicitly deleted. `deleteIfNotUsed` still\n         * refuses to remove any folder whose child had to be kept, which is the protection wanted here.\n         */\n        shouldDeleteEmptyFolders: true,\n        /*\n         * A note that others link to is deleted as normal; Obsidian leaves the dangling link. Protecting\n         * notes too would make deleting a folder of linked-to notes impossible.\n         */\n        shouldProtectIfStillUsed: (candidateFile) => !(settings.isNote?.(candidateFile.path) ?? false)\n      });\n    } finally {\n      this.replayedFolderPaths.delete(folder.path);\n    }\n  }\n\n  private rescueStillUsedFile(rescueParams: RescueStillUsedFileParams): Promise<boolean> {\n    return didRescueStillUsedAttachment({\n      app: this.app,\n      pluginNoticeComponent: this.pluginNoticeComponent,\n      rescueParams,\n      settingsManager: this.settingsManager\n    });\n  }\n\n  /**\n   * Checks whether a deletion is a folder deletion this handler is responsible for protecting.\n   *\n   * Every check here is synchronous and cheap, so a file deletion \u2014 the overwhelming majority \u2014 costs one\n   * {@link isFolder} call and reaches the original untouched.\n   *\n   * @param file - The abstract file being deleted.\n   * @returns `true` when the deletion should be scanned before it runs.\n   */\n  private shouldConsiderFolder(file: TAbstractFile): file is TFolder {\n    if (!isFolder(file)) {\n      return false;\n    }\n\n    const settings = this.settingsManager.getSettings();\n    if (!settings.shouldHandleDeletions || (settings.isPathIgnored?.(file.path) ?? false)) {\n      return false;\n    }\n\n    for (const replayedFolderPath of this.replayedFolderPaths) {\n      if (isChildOrSelf({ app: this.app, childPathOrFile: file.path, parentPathOrFile: replayedFolderPath })) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n}\n\nclass FileManagerRunAsyncLinkUpdatePatchComponent extends MonkeyAroundComponent {\n  private readonly app: App;\n  private readonly fileManager: FileManager;\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: FileManagerRunAsyncLinkUpdatePatchComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.fileManager = params.fileManager;\n    this.settingsManager = params.settingsManager;\n  }\n\n  public override onload(): void {\n    this.registerMethodPatch({\n      $object: this.fileManager,\n      methodName: 'runAsyncLinkUpdate',\n      patchHandler: ({\n        fallback,\n        originalArguments: [linkUpdatesHandler],\n        originalMethod,\n        originalMethodBound\n      }) => {\n        if (hasPatchToken(originalMethod, PATCH_TOKEN)) {\n          return fallback();\n        }\n\n        const newHandler: LinkUpdatesHandler = (linkUpdates) => this.wrapLinkUpdatesHandler(linkUpdates, linkUpdatesHandler);\n        return originalMethodBound(newHandler);\n      },\n      /*\n       * Suppressing Obsidian's own link updates is NOT idempotent, so two live copies of this component\n       * would fight over the same method. `PATCH_TOKEN` is a `Symbol.for` and the token registry is\n       * `getObsidianDevUtilsState`-backed, so the arbitration spans independently bundled copies of this\n       * library: the first patcher stays live, a copy that patches afterwards sees the token on its own\n       * `originalMethod` and defers via the guard above, and it takes over on its next call once the\n       * leader unloads and the token is dropped.\n       *\n       * This arbitrates the PATCH only. The component's `vault.on('rename' | 'delete')` and\n       * `metadataCache.on('deleted')` listeners have no equivalent guard \u2014 the plugin-registry election\n       * that used to provide one went with the multi-plugin machinery \u2014 so two live copies would both\n       * handle an event. With one owner that cannot arise; a consumer that must guarantee it refuses to\n       * load beside a conflicting version.\n       *\n       * That refusal used to be described here as \"a plugin's job rather than a library's\", which is no\n       * longer true \u2014 `PluginBase.getPluginDependencies` is where a consumer declares it, and the\n       * `apiVersionRange` it names is exactly the conflicting-version guard. The library owns the\n       * mechanism; the plugin still owns the decision to use it.\n       */\n      patchToken: PATCH_TOKEN\n    });\n  }\n\n  private async wrapLinkUpdatesHandler(linkUpdates: LinkUpdate[], linkUpdatesHandler: LinkUpdatesHandler): Promise<void> {\n    let isRenameCalled = false;\n    let isForeignLockedRenameCalled = false;\n    const eventRef = this.app.vault.on('rename', (file, oldPath) => {\n      isRenameCalled = true;\n      /*\n       * A rename performed inside a foreign plugin's in-flight locked transaction (which locks the\n       * affected folder subtree, e.g. Advanced Note Composer's folder merge) is owned by that\n       * transaction, which is responsible for its own link consistency. This handler deliberately does\n       * NOT rewrite links for it, so suppressing Obsidian's native link update below would leave the\n       * links dangling. Let the native update proceed untouched. See\n       * https://github.com/mnaoumov/obsidian-advanced-note-composer/issues/146.\n       */\n      if (isResourceLockedForPathByAncestor(this.app, file.path) || isResourceLockedForPathByAncestor(this.app, oldPath)) {\n        isForeignLockedRenameCalled = true;\n      }\n    });\n    try {\n      await linkUpdatesHandler(linkUpdates);\n    } finally {\n      this.app.vault.offref(eventRef);\n    }\n    const settings = this.settingsManager.getSettings();\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It might changed in `rename` event handler. ESLint mistakenly does not recognize it.\n    if (!isRenameCalled || !settings.shouldHandleRenames || isForeignLockedRenameCalled) {\n      return;\n    }\n\n    filterInPlace(\n      linkUpdates,\n      (linkUpdate) => {\n        if (settings.isPathIgnored?.(linkUpdate.sourceFile.path)) {\n          getObsidianLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n            `Roll back to default link update of source file ${linkUpdate.sourceFile.path} as the path is ignored.`\n          );\n          return true;\n        }\n\n        if (settings.isPathIgnored?.(linkUpdate.resolvedFile.path)) {\n          getObsidianLibDebugger('RenameDeleteHandler:runAsyncLinkUpdate')(\n            `Roll back to default link update of resolved file ${linkUpdate.resolvedFile.path} as the path is ignored.`\n          );\n          return true;\n        }\n\n        return this.app.internalPlugins.getEnabledPluginById(InternalPluginName.Canvas) !== null && !hasBacklinkCachePlugin(this.app)\n          && (linkUpdate.sourceFile.extension === CANVAS_FILE_EXTENSION || linkUpdate.resolvedFile.extension === CANVAS_FILE_EXTENSION);\n      }\n    );\n  }\n}\n\nclass HandledRenames {\n  private readonly map = new Map<string, HandledRenameKey>();\n\n  public add(oldPath: string, newPath: string): void {\n    this.map.set(this.keyToString(oldPath, newPath), { newPath, oldPath });\n  }\n\n  public delete(oldPath: string, newPath: string): void {\n    this.map.delete(this.keyToString(oldPath, newPath));\n  }\n\n  public has(oldPath: string, newPath: string): boolean {\n    return this.map.has(this.keyToString(oldPath, newPath));\n  }\n\n  public keys(): IterableIterator<HandledRenameKey> {\n    return this.map.values();\n  }\n\n  private keyToString(oldPath: string, newPath: string): string {\n    return `${oldPath} -> ${newPath}`;\n  }\n}\n\nclass MetadataDeletedHandler {\n  private readonly deletedMetadataCacheMap: Map<string, CachedMetadata>;\n  private readonly file: TAbstractFile;\n  private readonly previousCache: CachedMetadata | null;\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: MetadataDeletedHandlerConstructorParams) {\n    this.deletedMetadataCacheMap = params.deletedMetadataCacheMap;\n    this.file = params.file;\n    this.previousCache = params.previousCache;\n    this.settingsManager = params.settingsManager;\n  }\n\n  public handle(): void {\n    const settings = this.settingsManager.getSettings();\n\n    if (!settings.shouldHandleDeletions) {\n      return;\n    }\n\n    if (settings.isPathIgnored?.(this.file.path)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleMetadataDeleted')(`Skipping metadata delete handler of ${this.file.path} as the path is ignored.`);\n      return;\n    }\n\n    if (isMarkdownFile(this.file) && this.previousCache) {\n      this.deletedMetadataCacheMap.set(this.file.path, this.previousCache);\n    }\n  }\n}\n\nclass RenameHandler {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly handledRenames: HandledRenames;\n  private readonly interruptedCombinedBacklinksMap: Map<string, Map<string, string>>;\n  private readonly interruptedRenamesMap: Map<string, InterruptedRename[]>;\n  private readonly linkUpdateProgressReporter: LinkUpdateProgressReporter | null;\n  private readonly newPath: string;\n  private readonly oldCache: CachedMetadata | null;\n  private readonly oldPath: string;\n  private readonly oldPathBacklinksMap: Map<string, Reference[]>;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly resourceLockComponent: null | ResourceLockComponent;\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: RenameHandlerConstructorParams) {\n    this.abortSignal = params.abortSignal;\n    this.app = params.app;\n    this.resourceLockComponent = params.resourceLockComponent;\n    this.handledRenames = params.handledRenames;\n    this.interruptedCombinedBacklinksMap = params.interruptedCombinedBacklinksMap ?? new Map<string, Map<string, string>>();\n    this.interruptedRenamesMap = params.interruptedRenamesMap;\n    this.linkUpdateProgressReporter = params.linkUpdateProgressReporter;\n    this.newPath = params.newPath;\n    this.oldCache = params.oldCache;\n    this.oldPath = params.oldPath;\n    this.oldPathBacklinksMap = params.oldPathBacklinksMap;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.settingsManager = params.settingsManager;\n  }\n\n  public async handle(): Promise<void> {\n    if (this.oldPath === this.newPath) {\n      return;\n    }\n    this.abortSignal.throwIfAborted();\n\n    /*\n     * The rename that triggered this handler is very likely still inside Obsidian's own\n     * `FileManager.runAsyncLinkUpdate` cycle, which is about to decide \u2014 synchronously \u2014 which links to\n     * rewrite, by re-resolving each one. Everything below temporarily registers a phantom file at the\n     * old path (`registerFiles`, directly here and inside `RenameMap`) and holds it across an `await`;\n     * seen mid-decision, that phantom makes the old path still resolve, so Obsidian concludes nothing\n     * changed and rewrites nothing. Standing invariant: never touch the vault index while Obsidian is\n     * mid-decision. See https://github.com/mnaoumov/obsidian-custom-attachment-location/issues/47.\n     */\n    await waitForPendingLinkUpdates(this.app);\n    this.abortSignal.throwIfAborted();\n\n    await this.continueInterruptedRenames();\n    this.abortSignal.throwIfAborted();\n\n    // The refreshed backlinks feed `oldPathBacklinksMap`, which only the link-rewrite steps below read, and those are gated on the same flag.\n    if (this.settingsManager.getSettings().shouldHandleRenames) {\n      await this.refreshLinks();\n      this.abortSignal.throwIfAborted();\n    }\n\n    if (await this.handleCaseCollision()) {\n      return;\n    }\n\n    this.abortSignal.throwIfAborted();\n\n    const pluginNoticeComponent = this.pluginNoticeComponent;\n\n    const renamedFilePaths = getObsidianDevUtilsState('renamedFilePaths', new Set<string>()).value;\n    const renamedLinks = getObsidianDevUtilsState('renamedLinkPaths', new Set<string>()).value;\n\n    try {\n      const renameMap = new RenameMap({\n        abortSignal: this.abortSignal,\n        app: this.app,\n        newPath: this.newPath,\n        oldCache: this.oldCache,\n        oldPath: this.oldPath,\n        settingsManager: this.settingsManager\n      });\n      await renameMap.fill();\n      this.abortSignal.throwIfAborted();\n\n      const settings = this.settingsManager.getSettings();\n\n      const combinedBacklinksMap = new Map<string, Map<string, string>>();\n\n      // Backlinks are only consumed by the link-rewrite steps below, which are gated on\n      // `shouldHandleRenames`. Skip gathering them (a backlink fetch per attachment) on a move-only rename.\n      if (settings.shouldHandleRenames) {\n        renameMap.initOriginalLinksMap(combinedBacklinksMap);\n        renameMap.initBacklinksMap({\n          combinedBacklinksMap,\n          path: this.oldPath,\n          singleBacklinksMap: this.oldPathBacklinksMap\n        });\n\n        for (const attachmentOldPath of renameMap.keys()) {\n          if (attachmentOldPath === this.oldPath) {\n            continue;\n          }\n          const attachmentOldPathBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: attachmentOldPath });\n          const attachmentOldPathBacklinksMap = attachmentOldPathBacklinks.data;\n          this.abortSignal.throwIfAborted();\n          renameMap.initBacklinksMap({\n            combinedBacklinksMap,\n            path: attachmentOldPath,\n            singleBacklinksMap: attachmentOldPathBacklinksMap\n          });\n        }\n      }\n\n      const parentFolderPaths = new Set<string>();\n\n      for (const [oldAttachmentPath, newAttachmentPath] of renameMap.entries()) {\n        if (oldAttachmentPath !== this.oldPath) {\n          const fixedNewAttachmentPath = await this.renameHandled(oldAttachmentPath, newAttachmentPath);\n          this.abortSignal.throwIfAborted();\n          renameMap.set(oldAttachmentPath, fixedNewAttachmentPath);\n        }\n        if (!this.settingsManager.isNoteEx(oldAttachmentPath)) {\n          parentFolderPaths.add(dirname(oldAttachmentPath));\n        }\n      }\n\n      await cleanupEmptyFolders({\n        app: this.app,\n        emptyFolderBehavior: settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,\n        folderPaths: [...parentFolderPaths]\n      });\n      this.abortSignal.throwIfAborted();\n\n      /*\n       * The attachment move above runs regardless of `shouldHandleRenames` (that is the point of decoupling\n       * \"Move attachments with note\" from \"Update links\"). The remaining steps only rewrite links, so skip\n       * them when link updates are disabled; the `finally` block below still runs.\n       */\n      if (!settings.shouldHandleRenames) {\n        return;\n      }\n\n      /*\n       * A resumed rename brings its own snapshot along. Merge it INTO the current one rather than\n       * concatenating the two: a file named by both would otherwise be opened and rewritten twice, which is\n       * the very thing a combined snapshot exists to avoid. The current rename's entry wins a key collision,\n       * because it describes where the target is now.\n       */\n      for (const [interruptedBacklinkPath, interruptedLinkKeyToPathMap] of this.interruptedCombinedBacklinksMap) {\n        const linkKeyToPathMap = combinedBacklinksMap.get(interruptedBacklinkPath);\n        if (!linkKeyToPathMap) {\n          combinedBacklinksMap.set(interruptedBacklinkPath, interruptedLinkKeyToPathMap);\n          continue;\n        }\n\n        for (const [linkKey, oldTargetPath] of interruptedLinkKeyToPathMap) {\n          if (!linkKeyToPathMap.has(linkKey)) {\n            linkKeyToPathMap.set(linkKey, oldTargetPath);\n          }\n        }\n      }\n\n      const linkIndexes = new Map<string, number>();\n      await editBacklinksSnapshot(normalizeOptionalProperties<EditBacklinksSnapshotParams<string>>({\n        abortSignal: this.abortSignal,\n        app: this.app,\n        linkConverter: ({ link, payload: oldAttachmentPath, sourcePath: newBacklinkPath }) => {\n          const linkIndex = (linkIndexes.get(newBacklinkPath) ?? 0) + 1;\n          linkIndexes.set(newBacklinkPath, linkIndex);\n\n          if (!oldAttachmentPath) {\n            /*\n             * A link that is not in the snapshot was either never ours to rewrite, or was already\n             * rewritten by someone else (leaving it correct). Either way there is nothing to do -\n             * but log it, because a silent skip here is exactly how\n             * https://github.com/mnaoumov/obsidian-custom-attachment-location/issues/60 stayed\n             * invisible: every skipped link left a broken embed and reported nothing.\n             */\n            getObsidianLibDebugger('RenameDeleteHandler:updateBacklinks')(\n              `No snapshot entry for link ${toJson(link)} in ${newBacklinkPath}; leaving it unchanged.`\n            );\n            return;\n          }\n\n          const newAttachmentPath = renameMap.get(oldAttachmentPath) ?? oldAttachmentPath;\n\n          renamedFilePaths.add(newBacklinkPath);\n          renamedLinks.add(`${newBacklinkPath}//${String(linkIndex)}`);\n\n          return updateLink(normalizeOptionalProperties<UpdateLinkParams>({\n            app: this.app,\n            link,\n            newSourcePathOrFile: newBacklinkPath,\n            newTargetPathOrFile: newAttachmentPath,\n            oldTargetPathOrFile: oldAttachmentPath,\n            shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n          }));\n        },\n        linkUpdateProgressReporter: this.linkUpdateProgressReporter ?? undefined,\n        pluginNoticeComponent,\n        resourceLockComponent: this.resourceLockComponent,\n        shouldFailOnMissingFile: false,\n        // The converter logs every link it declines, so it has to be shown the ones the snapshot does not name.\n        shouldVisitUnmatchedLinks: true,\n        snapshot: combinedBacklinksMap\n      }));\n      this.abortSignal.throwIfAborted();\n\n      if (isNote(this.newPath)) {\n        await updateLinksInFile(normalizeOptionalProperties<UpdateLinksInFileParams>({\n          app: this.app,\n          newSourcePathOrFile: this.newPath,\n          oldSourcePathOrFile: this.oldPath,\n          pluginNoticeComponent,\n          resourceLockComponent: this.resourceLockComponent,\n          shouldFailOnMissingFile: false,\n          shouldUpdateFileNameAlias: settings.shouldUpdateFileNameAliases\n        }));\n        this.abortSignal.throwIfAborted();\n      }\n\n      if (!getFileOrNull({ app: this.app, pathOrFile: this.newPath })) {\n        let interruptedRenames = this.interruptedRenamesMap.get(this.newPath);\n        if (!interruptedRenames) {\n          interruptedRenames = [];\n          this.interruptedRenamesMap.set(this.newPath, interruptedRenames);\n        }\n        interruptedRenames.push({\n          combinedBacklinksMap,\n          oldPath: this.oldPath\n        });\n      }\n    } finally {\n      const orphanKeys = [...this.handledRenames.keys()];\n      addToQueue({\n        abortSignal: this.abortSignal,\n        operationFunction: () => {\n          for (const orphanKey of orphanKeys) {\n            this.handledRenames.delete(orphanKey.oldPath, orphanKey.newPath);\n          }\n\n          if (renamedLinks.size === 0) {\n            return;\n          }\n          pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.renameDeleteHandler.updatedLinks, { filesCount: renamedFilePaths.size, linksCount: renamedLinks.size }));\n          renamedFilePaths.clear();\n          renamedLinks.clear();\n        },\n        operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleOrphanedRenames)\n      });\n    }\n  }\n\n  private async continueInterruptedRenames(): Promise<void> {\n    const interruptedRenames = this.interruptedRenamesMap.get(this.oldPath);\n    if (!interruptedRenames) {\n      return;\n    }\n\n    this.interruptedRenamesMap.delete(this.oldPath);\n    for (const interruptedRename of interruptedRenames) {\n      await new RenameHandler({\n        abortSignal: this.abortSignal,\n        app: this.app,\n        handledRenames: this.handledRenames,\n        interruptedCombinedBacklinksMap: interruptedRename.combinedBacklinksMap,\n        interruptedRenamesMap: this.interruptedRenamesMap,\n        linkUpdateProgressReporter: this.linkUpdateProgressReporter,\n        newPath: this.newPath,\n        oldCache: this.oldCache,\n        oldPath: interruptedRename.oldPath,\n        oldPathBacklinksMap: this.oldPathBacklinksMap,\n        pluginNoticeComponent: this.pluginNoticeComponent,\n        resourceLockComponent: this.resourceLockComponent,\n        settingsManager: this.settingsManager\n      }).handle();\n    }\n  }\n\n  private async handleCaseCollision(): Promise<boolean> {\n    if (!getDataAdapterEx(this.app).insensitive || this.oldPath.toLowerCase() !== this.newPath.toLowerCase()) {\n      return false;\n    }\n\n    const temporaryPath = join(dirname(this.newPath), `__temp__${basename(this.newPath)}`);\n    await this.renameHandled(this.newPath, temporaryPath);\n\n    await new RenameHandler({\n      abortSignal: this.abortSignal,\n      app: this.app,\n      handledRenames: this.handledRenames,\n      interruptedRenamesMap: this.interruptedRenamesMap,\n      linkUpdateProgressReporter: this.linkUpdateProgressReporter,\n      newPath: temporaryPath,\n      oldCache: this.oldCache,\n      oldPath: this.oldPath,\n      oldPathBacklinksMap: this.oldPathBacklinksMap,\n      pluginNoticeComponent: this.pluginNoticeComponent,\n      resourceLockComponent: this.resourceLockComponent,\n      settingsManager: this.settingsManager\n    }).handle();\n\n    await this.app.fileManager.renameFile(getFile({ app: this.app, pathOrFile: temporaryPath }), this.newPath);\n    return true;\n  }\n\n  private async refreshLinks(): Promise<void> {\n    const fakeOldFile = getFile({ app: this.app, pathOrFile: this.oldPath, shouldIncludeNonExisting: true });\n    let oldPathBacklinksMapRefreshed: Map<string, Reference[]>;\n    {\n      using _registration = registerFiles(this.app, [fakeOldFile]);\n      const fakeOldFileBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: fakeOldFile });\n      oldPathBacklinksMapRefreshed = fakeOldFileBacklinks.data;\n    }\n\n    for (const [backlinkPath, refreshedLinks] of oldPathBacklinksMapRefreshed) {\n      let oldLinks = this.oldPathBacklinksMap.get(backlinkPath);\n      if (!oldLinks) {\n        oldLinks = [];\n        this.oldPathBacklinksMap.set(backlinkPath, oldLinks);\n      }\n\n      for (const link of refreshedLinks) {\n        if (oldLinks.includes(link)) {\n          continue;\n        }\n        oldLinks.push(link);\n      }\n    }\n  }\n\n  private async renameHandled(oldPath: string, newPath: string): Promise<string> {\n    newPath = getSafeRenamePath({ app: this.app, newPath, oldPathOrAbstractFile: oldPath });\n    if (oldPath === newPath) {\n      return newPath;\n    }\n    this.handledRenames.add(oldPath, newPath);\n    newPath = await renameSafe({ app: this.app, newPath, oldPathOrAbstractFile: oldPath });\n    return newPath;\n  }\n}\n\nclass RenameMap {\n  private readonly abortSignal: AbortSignal;\n  private readonly app: App;\n  private readonly map = new Map<string, string>();\n  private readonly newPath: string;\n  private readonly oldCache: CachedMetadata | null;\n  private readonly oldPath: string;\n  private readonly oldPathLinks: Reference[];\n  private readonly settingsManager: SettingsManager;\n\n  public constructor(params: RenameMapConstructorParams) {\n    this.abortSignal = params.abortSignal;\n    this.app = params.app;\n    this.settingsManager = params.settingsManager;\n    this.oldCache = params.oldCache;\n    this.oldPath = params.oldPath;\n    this.newPath = params.newPath;\n    this.oldPathLinks = this.oldCache ? getLinks({ cache: this.oldCache }) : [];\n  }\n\n  public entries(): IterableIterator<[string, string]> {\n    return this.map.entries();\n  }\n\n  public async fill(): Promise<void> {\n    this.abortSignal.throwIfAborted();\n    this.map.set(this.oldPath, this.newPath);\n\n    if (!isNote(this.oldPath)) {\n      return;\n    }\n\n    // Obsidian does not index a canvas file into the metadata cache.\n    // The cache-derived `oldPathLinks` is empty for a canvas, hiding its embedded attachments.\n    // Reading the canvas references directly moves them with the canvas (mirroring note behavior).\n    // The file already lives at the new path after the rename, so read the references from there.\n    if (isCanvasFile(this.oldPath)) {\n      const canvasReferences = await getCanvasReferences(this.app, this.newPath);\n      this.oldPathLinks.push(...canvasReferences);\n    }\n\n    const settings = this.settingsManager.getSettings();\n\n    const oldFile = getFile({ app: this.app, pathOrFile: this.oldPath, shouldIncludeNonExisting: true });\n    const oldAttachmentFolderPath = await this.getOldAttachmentFolderPath(oldFile);\n\n    const newAttachmentFolderPath = settings.shouldRenameAttachmentFolder\n      ? await getAttachmentFolderPath({\n        app: this.app,\n        context: AttachmentPathContext.RenameNote,\n        notePathOrFile: this.newPath\n      })\n      : oldAttachmentFolderPath;\n\n    const isOldAttachmentFolderAtRoot = oldAttachmentFolderPath === '/';\n\n    const oldAttachmentFolder = getFolderOrNull({ app: this.app, pathOrFolder: oldAttachmentFolderPath });\n\n    if (!oldAttachmentFolder || (oldAttachmentFolderPath === newAttachmentFolderPath && !settings.shouldRenameAttachmentFiles)) {\n      return;\n    }\n\n    const oldAttachmentFiles: TFile[] = [];\n\n    if (\n      await hasOwnAttachmentFolder({\n        app: this.app,\n        context: AttachmentPathContext.RenameNote,\n        path: this.oldPath\n      })\n    ) {\n      Vault.recurseChildren(oldAttachmentFolder, (oldAttachmentFile) => {\n        this.abortSignal.throwIfAborted();\n        if (isFile(oldAttachmentFile)) {\n          oldAttachmentFiles.push(oldAttachmentFile);\n        }\n      });\n    } else {\n      for (const oldPathLink of this.oldPathLinks) {\n        this.abortSignal.throwIfAborted();\n        const oldAttachmentFile = extractLinkFile({ app: this.app, link: oldPathLink, sourcePathOrFile: this.oldPath });\n        if (!oldAttachmentFile || (!isOldAttachmentFolderAtRoot && !oldAttachmentFile.path.startsWith(oldAttachmentFolderPath))) {\n          continue;\n        }\n\n        const oldAttachmentBacklinks = await getBacklinksForFileSafe({ app: this.app, pathOrFile: oldAttachmentFile });\n        this.abortSignal.throwIfAborted();\n        const keys = new Set<string>(oldAttachmentBacklinks.keys());\n        keys.delete(this.oldPath);\n        keys.delete(this.newPath);\n        if (keys.size === 0) {\n          oldAttachmentFiles.push(oldAttachmentFile);\n        }\n      }\n    }\n\n    for (const oldAttachmentFile of oldAttachmentFiles) {\n      this.abortSignal.throwIfAborted();\n      if (this.settingsManager.isNoteEx(oldAttachmentFile.path)) {\n        continue;\n      }\n\n      let newAttachmentFilePath: string;\n      if (settings.shouldRenameAttachmentFiles) {\n        newAttachmentFilePath = await getAttachmentFilePath({\n          app: this.app,\n          context: AttachmentPathContext.RenameNote,\n          notePathOrFile: this.newPath,\n          oldAttachmentPathOrFile: oldAttachmentFile,\n          oldNotePathOrFile: this.oldPath,\n          shouldSkipDuplicateCheck: true\n        });\n        this.abortSignal.throwIfAborted();\n      } else {\n        const relativePath = isOldAttachmentFolderAtRoot ? oldAttachmentFile.path : relative(oldAttachmentFolderPath, oldAttachmentFile.path);\n        const newFolder = join(newAttachmentFolderPath, dirname(relativePath));\n        newAttachmentFilePath = join(newFolder, oldAttachmentFile.name);\n      }\n\n      if (oldAttachmentFile.path === newAttachmentFilePath) {\n        continue;\n      }\n      if (settings.shouldDeleteConflictingAttachments) {\n        const newAttachmentFile = getFileOrNull({ app: this.app, pathOrFile: newAttachmentFilePath });\n        if (newAttachmentFile) {\n          getObsidianLibDebugger('RenameDeleteHandler:fillRenameMap')(`Removing conflicting attachment ${newAttachmentFile.path}.`);\n          await trashSafe(this.app, newAttachmentFile);\n          this.abortSignal.throwIfAborted();\n        }\n      } else {\n        const directory = dirname(newAttachmentFilePath);\n        const extension = extname(newAttachmentFilePath);\n        const baseName = basename(newAttachmentFilePath, extension);\n        newAttachmentFilePath = this.app.vault.getAvailablePath(join(directory, baseName), extension.slice(1));\n      }\n      this.map.set(oldAttachmentFile.path, newAttachmentFilePath);\n    }\n  }\n\n  public get(oldPath: string): string | undefined {\n    return this.map.get(oldPath);\n  }\n\n  public initBacklinksMap(params: RenameMapInitBacklinksMapParams): void {\n    const {\n      combinedBacklinksMap,\n      path,\n      singleBacklinksMap\n    } = params;\n    buildBacklinksSnapshot<string>({\n      backlinks: singleBacklinksMap,\n      linkIdentityKeyProvider: getLinkIdentityKey,\n      pathRemapper: (backlinkPath) => this.map.get(backlinkPath) ?? backlinkPath,\n      payloadProvider: () => path,\n      target: combinedBacklinksMap\n    });\n  }\n\n  public initOriginalLinksMap(combinedBacklinksMap: Map<string, Map<string, string>>): void {\n    for (const oldPathLink of this.oldPathLinks) {\n      const oldAttachmentFile = extractLinkFile({ app: this.app, link: oldPathLink, sourcePathOrFile: this.oldPath });\n      if (!oldAttachmentFile) {\n        continue;\n      }\n      const backlinksMap = new Map<string, Reference[]>([[this.newPath, [oldPathLink]]]);\n      this.initBacklinksMap({\n        combinedBacklinksMap,\n        path: oldAttachmentFile.path,\n        singleBacklinksMap: backlinksMap\n      });\n    }\n  }\n\n  public keys(): IterableIterator<string> {\n    return this.map.keys();\n  }\n\n  public set(oldPath: string, newPath: string): void {\n    this.map.set(oldPath, newPath);\n  }\n\n  private async getOldAttachmentFolderPath(oldFile: TFile): Promise<string> {\n    using _registration = registerFiles(this.app, [oldFile]);\n    using _cacheRegistration = this.oldCache && oldFile.deleted\n      ? registerFileCacheForNonExistingFile({ app: this.app, cache: this.oldCache, pathOrFile: oldFile })\n      : undefined;\n    return await getAttachmentFolderPath({\n      app: this.app,\n      context: AttachmentPathContext.RenameNote,\n      notePathOrFile: this.oldPath\n    });\n  }\n}\n\n/**\n * Resolves the settings the handler runs with.\n *\n * There is exactly one contributor: the component's own `settingsBuilder`. Earlier versions aggregated a\n * registry of contributors and OR-merged their answers, because several plugins could each register a\n * handler against the one shared vault. They no longer do, so there is no longer any question of whose\n * setting wins.\n *\n * What remains is defaulting: the builder returns a `Partial`, so the two predicates and the empty-folder\n * behavior need a value when it does not supply one.\n */\nclass SettingsManager {\n  private readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>;\n\n  public constructor(settingsBuilder: () => Partial<RenameDeleteHandlerSettings>) {\n    this.settingsBuilder = settingsBuilder;\n  }\n\n  public getSettings(): Partial<RenameDeleteHandlerSettings> {\n    const builtSettings = this.settingsBuilder();\n    return {\n      ...builtSettings,\n      emptyFolderBehavior: builtSettings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep,\n      isNote: (path: string): boolean => builtSettings.isNote?.(path) ?? isNote(path),\n      isPathIgnored: (path: string): boolean => builtSettings.isPathIgnored?.(path) ?? false\n    };\n  }\n\n  public isNoteEx(path: string): boolean {\n    const settings = this.getSettings();\n    return settings.isNote?.(path) ?? false;\n  }\n}\n\n/**\n * Component that handles rename and delete events in Obsidian.\n * It listens to rename and delete events and updates links accordingly.\n * It also handles edge cases such as case-only renames and collisions with existing files.\n */\nexport class RenameDeleteHandlerComponent extends ComponentEx {\n  /**\n   * The abort signal component whose signal cancels in-flight rename operations.\n   */\n  protected readonly abortSignalComponent: AbortSignalComponent;\n\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n  /**\n   * An optional reporter invoked once per backlink file whose links are updated during a rename/move,\n   * with the running count of processed files and the total. When `null`, no progress is reported.\n   */\n  protected readonly linkUpdateProgressReporter: LinkUpdateProgressReporter | null;\n  /**\n   * The notice component used to report updated links to the user.\n   */\n  protected readonly pluginNoticeComponent: PluginNoticeComponent;\n  /**\n   * The resource lock component used to guard link updates, or `null` if none is used.\n   */\n  protected readonly resourceLockComponent: null | ResourceLockComponent;\n\n  /**\n   * Builds this plugin's rename/delete handler settings.\n   */\n  protected readonly settingsBuilder: () => Partial<RenameDeleteHandlerSettings>;\n\n  /**\n   * The manager that aggregates rename/delete handler settings across registered plugins.\n   */\n  protected readonly settingsManager: SettingsManager;\n\n  private readonly deletedMetadataCacheMap = new Map<string, CachedMetadata>();\n\n  private readonly handledRenames = new HandledRenames();\n\n  private readonly interruptedRenamesMap = new Map<string, InterruptedRename[]>();\n\n  /**\n   * Creates an instance of RenameDeleteHandlerComponent.\n   *\n   * @param params - The parameters for the RenameDeleteHandlerComponent.\n   */\n  public constructor(params: RenameDeleteHandlerComponentConstructorParams) {\n    super();\n    this.abortSignalComponent = params.abortSignalComponent;\n    this.app = params.app;\n    this.linkUpdateProgressReporter = params.linkUpdateProgressReporter ?? null;\n    this.resourceLockComponent = params.resourceLockComponent;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.settingsBuilder = params.settingsBuilder;\n    this.settingsManager = new SettingsManager(this.settingsBuilder);\n  }\n\n  /**\n   * Loads the component\n   */\n  public override onload(): void {\n    this.registerEvent(this.app.vault.on('delete', this.handleDelete.bind(this)));\n    this.registerEvent(this.app.vault.on('rename', this.handleRename.bind(this)));\n    this.registerEvent(this.app.metadataCache.on('deleted', this.handleMetadataDeleted.bind(this)));\n\n    this.addChild(\n      new FileManagerRunAsyncLinkUpdatePatchComponent({\n        app: this.app,\n        fileManager: this.app.fileManager,\n        settingsManager: this.settingsManager\n      })\n    );\n\n    this.addChild(\n      new DeleteProtectionPatchComponent({\n        app: this.app,\n        pluginNoticeComponent: this.pluginNoticeComponent,\n        settingsManager: this.settingsManager\n      })\n    );\n  }\n\n  private handleDelete(file: TAbstractFile): void {\n    addToQueue({\n      operationFunction: (abortSignal) =>\n        new DeleteHandler({\n          abortSignal,\n          app: this.app,\n          deletedMetadataCacheMap: this.deletedMetadataCacheMap,\n          file,\n          pluginNoticeComponent: this.pluginNoticeComponent,\n          settingsManager: this.settingsManager\n        }).handle(),\n      operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleDelete, { filePath: file.path })\n    });\n  }\n\n  private handleMetadataDeleted(file: TAbstractFile, previousCache: CachedMetadata | null): void {\n    new MetadataDeletedHandler({\n      deletedMetadataCacheMap: this.deletedMetadataCacheMap,\n      file,\n      previousCache,\n      settingsManager: this.settingsManager\n    }).handle();\n  }\n\n  private handleRename(file: TAbstractFile, oldPath: string): void {\n    if (!isFile(file)) {\n      return;\n    }\n\n    const newPath = file.path;\n\n    getObsidianLibDebugger('RenameDeleteHandler:handleRename')(`Handle Rename ${oldPath} -> ${newPath}`);\n    if (this.handledRenames.has(oldPath, newPath)) {\n      this.handledRenames.delete(oldPath, newPath);\n      return;\n    }\n\n    /*\n     * A rename occurring inside a foreign plugin's in-flight locked transaction (which locks the\n     * affected folder subtree, e.g. Advanced Note Composer's folder merge) is orchestrated by that\n     * transaction's owner, which takes responsibility for its own link consistency. Reacting to it\n     * here would (a) perturb Obsidian's native post-rename link update and leave links dangling, and\n     * (b) collide with the foreign transaction \u2014 an async abort from this handler aborts an\n     * already-committed transaction, throwing \"Cannot roll back a committed transaction\". This\n     * handler's own attachment moves are already excluded above via `handledRenames`, so a lock still\n     * held here always belongs to a foreign operation; stay out of its way. See\n     * https://github.com/mnaoumov/obsidian-advanced-note-composer/issues/146.\n     */\n    if (isResourceLockedForPathByAncestor(this.app, oldPath) || isResourceLockedForPathByAncestor(this.app, newPath)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleRename')(\n        `Skipping rename handler of ${oldPath} -> ${newPath} as it occurs inside a foreign locked transaction.`\n      );\n      return;\n    }\n\n    const settings = this.settingsManager.getSettings();\n    if (!settings.shouldHandleRenames && !settings.shouldRenameAttachmentFolder && !settings.shouldRenameAttachmentFiles) {\n      return;\n    }\n\n    if (this.isNoOpRename(settings, oldPath, newPath)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleRename')(\n        `Skipping rename handler of ${oldPath} -> ${newPath} as it is not a note and there is nothing to do with link updates disabled.`\n      );\n      return;\n    }\n\n    if (settings.isPathIgnored?.(oldPath)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of old path ${oldPath} as the path is ignored.`);\n      return;\n    }\n\n    if (settings.isPathIgnored?.(newPath)) {\n      getObsidianLibDebugger('RenameDeleteHandler:handleRename')(`Skipping rename handler of new path ${newPath} as the path is ignored.`);\n      return;\n    }\n\n    const oldCache = this.app.metadataCache.getCache(oldPath) ?? this.app.metadataCache.getCache(newPath);\n    const oldPathBacklinksMap = getBacklinksForFileOrPath(this.app, oldPath).data;\n    addToQueue({\n      abortSignal: this.abortSignalComponent.abortSignal,\n      operationFunction: (abortSignal) =>\n        new RenameHandler({\n          abortSignal,\n          app: this.app,\n          handledRenames: this.handledRenames,\n          interruptedRenamesMap: this.interruptedRenamesMap,\n          linkUpdateProgressReporter: this.linkUpdateProgressReporter,\n          newPath,\n          oldCache,\n          oldPath,\n          oldPathBacklinksMap,\n          pluginNoticeComponent: this.pluginNoticeComponent,\n          resourceLockComponent: this.resourceLockComponent,\n          settingsManager: this.settingsManager\n        }).handle(),\n      operationName: t(($) => $.obsidianDevUtils.renameDeleteHandler.handleRename, { newPath, oldPath })\n    });\n  }\n\n  /**\n   * With link rewriting off, the handler's only remaining jobs are moving a NOTE's attachments and pruning\n   * the folder a moved file vacated. A non-note rename needs neither when empty folders are kept, so there\n   * is nothing to queue.\n   *\n   * @param settings - The aggregated rename/delete handler settings.\n   * @param oldPath - The path the file was renamed from.\n   * @param newPath - The path the file was renamed to.\n   * @returns `true` when the handler would do no work for this rename.\n   */\n  private isNoOpRename(settings: Partial<RenameDeleteHandlerSettings>, oldPath: string, newPath: string): boolean {\n    return !settings.shouldHandleRenames\n      && !(settings.isNote?.(oldPath) ?? false)\n      && !(settings.isNote?.(newPath) ?? false)\n      && (settings.emptyFolderBehavior ?? EmptyFolderBehavior.Keep) === EmptyFolderBehavior.Keep;\n  }\n}\n\n/**\n * Moves an attachment a deletion would otherwise strand to wherever the consuming plugin says it belongs.\n *\n * Shared by both delete paths \u2014 the note delete in {@link DeleteHandler} and the folder delete replayed by\n * {@link DeleteProtectionPatchComponent} \u2014 because both reach the same point: {@link deleteIfNotUsed} has\n * decided the attachment must survive, and without this it would survive in a folder nothing owns any more.\n *\n * A consumer that does not implement {@link RenameDeleteHandlerSettings.getRescuePath}, or that answers\n * `null`, gets exactly the behavior it had before this existed: the attachment stays put.\n *\n * @param params - The parameters for the function.\n * @returns A {@link Promise} that resolves to whether the attachment was moved.\n */\nasync function didRescueStillUsedAttachment(params: DidRescueStillUsedAttachmentParams): Promise<boolean> {\n  const settings = params.settingsManager.getSettings();\n  if (!settings.getRescuePath) {\n    return false;\n  }\n\n  const attachmentPath = params.rescueParams.file.path;\n  const rescuePath = await settings.getRescuePath({\n    attachmentPath,\n    survivingNotePaths: params.rescueParams.survivingNotePaths\n  });\n\n  if (rescuePath === null) {\n    getObsidianLibDebugger('RenameDeleteHandler:didRescueStillUsedAttachment')(`No rescue path for ${attachmentPath}; keeping it where it is.`);\n    return false;\n  }\n\n  try {\n    /*\n     * `renameSafe` creates the destination folder, resolves a collision via `getSafeRenamePath`, and moves\n     * through `app.fileManager.renameFile`, so the surviving notes' links follow the attachment.\n     */\n    const newAttachmentPath = await renameSafe({\n      app: params.app,\n      newPath: rescuePath,\n      oldPathOrAbstractFile: params.rescueParams.file\n    });\n\n    if (newAttachmentPath === attachmentPath) {\n      /*\n       * The attachment is already where it belongs. This is the normal second look at a file the folder\n       * delete just rescued: the owning note's own deletion is reported afterwards and walks its links\n       * again. Nothing moved, so nothing is claimed \u2014 the caller keeps it in place, which is the truth.\n       */\n      getObsidianLibDebugger('RenameDeleteHandler:didRescueStillUsedAttachment')(`${attachmentPath} already sits at its rescue path; nothing to move.`);\n      return false;\n    }\n\n    /*\n     * The move fires `vault.on('rename')`, so this handler's own `RenameHandler` picks it up like any other\n     * attachment move. It is deliberately NOT registered in `handledRenames`:\n     * `FileManagerRunAsyncLinkUpdatePatchComponent` already discards Obsidian's native link update while\n     * `shouldHandleRenames` is on, so suppressing the handler as well would leave dangling exactly the links\n     * this rescue exists to preserve. Let the rewrite settle before the delete walk carries on.\n     */\n    await waitForPendingLinkUpdates(params.app);\n\n    getObsidianLibDebugger('RenameDeleteHandler:didRescueStillUsedAttachment')(`Rescued ${attachmentPath} to ${newAttachmentPath}.`);\n    params.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.notices.attachmentRescued, { attachmentPath, newAttachmentPath }));\n    return true;\n  } catch (error) {\n    /*\n     * A rescue that half happened must not read as success \u2014 reporting `false` falls back to keeping the\n     * attachment in place with the `attachmentIsStillUsed` notice, which is still safe.\n     */\n    printError(new Error(`Failed to rescue ${attachmentPath} to ${rescuePath}`, { cause: error }));\n    return false;\n  }\n}\n\n/**\n * Builds the key under which a link is remembered while a rename is in flight.\n *\n * The rewrite has to match links captured BEFORE the attachments moved against the links the metadata cache\n * reports AFTER they moved, and the only thing that reliably survives that gap is the link's TEXT.\n * Deliberately excludes `position`: keying on the whole {@link Reference} meant that as soon as anything\n * edited the file in between \u2014 a co-installed plugin rewriting its own links, most often \u2014 every link below\n * the edit shifted its offsets, missed its key, and was skipped in silence, leaving the note with some embeds\n * rewritten and the rest broken. See\n * https://github.com/mnaoumov/obsidian-custom-attachment-location/issues/60.\n *\n * Two links with identical text in one file necessarily resolve to the same target, so collapsing them onto\n * one key loses nothing.\n *\n * @param link - The link to build the key for.\n * @returns The key identifying the link by its text alone.\n */\nfunction getLinkIdentityKey(link: Reference): string {\n  return toJson({\n    link: link.link,\n    original: link.original\n  });\n}\n\n/* v8 ignore stop */\n\nexport { EmptyFolderBehavior } from '../vault.ts';\n"],
  "mappings": "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",
  "names": ["EmptyFolderBehavior"]
}
