obsidian-dev-utils 83.3.0 → 84.1.0

package/dist/lib/esm/obsidian/resource-lock.mjs

@@ -0,0 +1,799 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
+import {
+  FileManager,
+  MarkdownView,
+  Menu,
+  setIcon,
+  setTooltip,
+  Vault
+} from "obsidian";
+import { convertAsyncToSync } from "../async.mjs";
+import {
+  CallbackDisposable,
+  MultipleDisposeBehavior
+} from "../disposable.mjs";
+import { noop } from "../function.mjs";
+import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
+import { assertNonNullable } from "../type-guards.mjs";
+import { ComponentEx } from "./components/component-ex.mjs";
+import { MonkeyAroundComponent } from "./components/monkey-around-component.mjs";
+import { toggleEditorReadOnly } from "./editor.mjs";
+import { getPath } from "./file-system.mjs";
+import { appendCodeBlock } from "./html-element.mjs";
+import { t } from "./i18n/i18n.mjs";
+import { confirm } from "./modals/confirm.mjs";
+import {
+  isChild,
+  isChildOrSelf
+} from "./vault.mjs";
+const BEEP_DURATION_SECONDS = 0.08;
+const BEEP_FREQUENCY_HZ = 660;
+const BEEP_GAIN = 0.05;
+const BEEP_THROTTLE_MILLISECONDS = 200;
+const RESOURCE_LOCK_STATE_KEY = "resourceLock";
+const LOCK_ICON_ID = "lock";
+const LOCK_INDICATOR_CSS_CLASS = "obsidian-dev-utils-lock-indicator";
+const LOCK_INDICATOR_FLASH_CSS_CLASS = "obsidian-dev-utils-lock-indicator-flash";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+const STATUS_BAR_CSS_SELECTOR = ".status-bar";
+const UNLOCK_ICON_ID = "unlock";
+class ResourceLockEventsComponent extends ComponentEx {
+  app;
+  onChange;
+  onExternalMutation;
+  onFileMenu;
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.onChange = params.onChange;
+    this.onExternalMutation = params.onExternalMutation;
+    this.onFileMenu = params.onFileMenu;
+  }
+  onload() {
+    super.onload();
+    this.registerEvent(this.app.workspace.on("active-leaf-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("layout-change", this.onChange));
+    this.registerEvent(this.app.workspace.on("file-open", this.onChange));
+    this.registerEvent(this.app.workspace.on("file-menu", this.onFileMenu));
+    this.registerEvent(this.app.vault.on("create", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.vault.on("delete", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.vault.on("rename", (file, oldPath) => {
+      this.onExternalMutation(oldPath);
+      this.onExternalMutation(file.path);
+    }));
+    this.registerEvent(this.app.metadataCache.on("deleted", (file) => {
+      this.onExternalMutation(file.path);
+    }));
+  }
+}
+class ResourceLockMutationBlockerComponent extends MonkeyAroundComponent {
+  shouldBlockMutation;
+  constructor(params) {
+    super();
+    this.shouldBlockMutation = params.shouldBlockMutation;
+  }
+  onload() {
+    super.onload();
+    this.registerMethodPatch({
+      methodName: "append",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "copy",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [, newPath] }) => {
+        this.assertNotBlocked([newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "create",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "createBinary",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "createFolder",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [path] }) => {
+        this.assertNotBlocked([path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "delete",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "modify",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "modifyBinary",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "process",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "rename",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file, newPath] }) => {
+        this.assertNotBlocked([file.path, newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "trash",
+      obj: Vault.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "renameFile",
+      obj: FileManager.prototype,
+      patchHandler: ({ fallback, originalArgs: [file, newPath] }) => {
+        this.assertNotBlocked([file.path, newPath]);
+        return fallback();
+      }
+    });
+    this.registerMethodPatch({
+      methodName: "trashFile",
+      obj: FileManager.prototype,
+      patchHandler: ({ fallback, originalArgs: [file] }) => {
+        this.assertNotBlocked([file.path]);
+        return fallback();
+      }
+    });
+  }
+  assertNotBlocked(paths) {
+    for (const path of paths) {
+      if (this.shouldBlockMutation(path)) {
+        throw new ResourceLockedError(path);
+      }
+    }
+  }
+}
+class ResourceLockManager {
+  audioContext = null;
+  bypassPathSets = /* @__PURE__ */ new Set();
+  eventsComponent = null;
+  indicatorsByView = /* @__PURE__ */ new Map();
+  lastBeepMilliseconds = 0;
+  lockEntriesByPath = /* @__PURE__ */ new Map();
+  mutationBlockerComponent = null;
+  statusBarItemEl = null;
+  bypass(app, pathsOrFiles) {
+    const bypassedPaths = new Set(pathsOrFiles.map((pathOrFile) => getPath(app, pathOrFile)));
+    this.bypassPathSets.add(bypassedPaths);
+    return new CallbackDisposable({
+      callback: () => {
+        this.bypassPathSets.delete(bypassedPaths);
+      },
+      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+    });
+  }
+  isLocked(app, pathOrFile) {
+    return this.isPathLocked(getPath(app, pathOrFile));
+  }
+  /**
+   * Checks whether the given path is locked directly or is covered by a `subtree`-locked ancestor
+   * folder.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if the path is itself locked or lies under a `subtree`-locked folder.
+   */
+  isLockedByAncestor(app, pathOrFile) {
+    return this.resolveLockOwnerPath(app, getPath(app, pathOrFile)) !== null;
+  }
+  /**
+   * Checks whether the given path is covered by a mutation-blocking lock (one taken with
+   * `blocksMutations`) directly or on a `subtree`-locked ancestor folder.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if a mutation of the path is currently blocked.
+   */
+  isMutationBlockedByAncestor(app, pathOrFile) {
+    const path = getPath(app, pathOrFile);
+    const exactEntries = this.lockEntriesByPath.get(path);
+    if (exactEntries?.some((entry) => entry.blocksMutations)) {
+      return true;
+    }
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      if (entries.some((entry) => entry.mode === "subtree" && entry.blocksMutations) && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath })) {
+        return true;
+      }
+    }
+    return false;
+  }
+  lock(app, pathOrFile, pluginId, options = {}) {
+    const path = getPath(app, pathOrFile);
+    const entry = {
+      abortController: options.abortController ?? null,
+      blocksMutations: options.blocksMutations ?? false,
+      mode: options.mode ?? "file",
+      pluginId
+    };
+    let entries = this.lockEntriesByPath.get(path);
+    if (!entries) {
+      entries = [];
+      this.lockEntriesByPath.set(path, entries);
+    }
+    entries.push(entry);
+    this.ensureSubscribed(app);
+    if (entry.blocksMutations) {
+      this.ensureBlockerInstalled(app);
+    }
+    this.reconcile(app);
+    return new CallbackDisposable({
+      callback: () => {
+        this.removeEntry(app, path, entry);
+      },
+      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore
+    });
+  }
+  /**
+   * Aborts every {@link AbortController} currently registered for the note at the given path, which
+   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`
+   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller
+   * is registered for the path.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pathOrFile - The path or file of the note to request an unlock for.
+   */
+  requestUnlock(app, pathOrFile) {
+    const entries = this.lockEntriesByPath.get(getPath(app, pathOrFile));
+    if (!entries) {
+      return;
+    }
+    for (const entry of entries) {
+      entry.abortController?.abort();
+    }
+  }
+  unlock(app, pathOrFile, pluginId) {
+    const path = getPath(app, pathOrFile);
+    const entries = this.lockEntriesByPath.get(path);
+    if (!entries) {
+      return;
+    }
+    const index = entries.findIndex((entry) => entry.pluginId === pluginId);
+    if (index === -1) {
+      return;
+    }
+    entries.splice(index, 1);
+    if (entries.length === 0) {
+      this.lockEntriesByPath.delete(path);
+    }
+    this.reconcileAndCleanup(app);
+  }
+  unlockAllForPlugin(app, pluginId) {
+    for (const [path, entries] of this.lockEntriesByPath) {
+      const remaining = entries.filter((entry) => entry.pluginId !== pluginId);
+      if (remaining.length === 0) {
+        this.lockEntriesByPath.delete(path);
+      } else if (remaining.length !== entries.length) {
+        this.lockEntriesByPath.set(path, remaining);
+      }
+    }
+    this.reconcileAndCleanup(app);
+  }
+  addUnlockMenuItem(app, menu, path) {
+    menu.addItem((item) => {
+      item.setTitle(t(($) => $.obsidianDevUtils.resourceLock.unlockMenuItem)).setIcon(UNLOCK_ICON_ID).onClick(convertAsyncToSync(async () => {
+        const isConfirmed = await confirm({
+          app,
+          message: this.unlockConfirmMessage(app, path),
+          title: t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmTitle)
+        });
+        if (isConfirmed) {
+          this.requestUnlock(app, path);
+        }
+      }));
+    });
+  }
+  beep() {
+    const nowMilliseconds = Date.now();
+    if (nowMilliseconds - this.lastBeepMilliseconds < BEEP_THROTTLE_MILLISECONDS) {
+      return;
+    }
+    this.lastBeepMilliseconds = nowMilliseconds;
+    const AudioContextClass = window.AudioContext;
+    if (!AudioContextClass) {
+      return;
+    }
+    this.audioContext ??= new AudioContextClass();
+    const audioContext = this.audioContext;
+    const oscillator = audioContext.createOscillator();
+    const gainNode = audioContext.createGain();
+    oscillator.type = "sine";
+    oscillator.frequency.value = BEEP_FREQUENCY_HZ;
+    gainNode.gain.value = BEEP_GAIN;
+    oscillator.connect(gainNode);
+    gainNode.connect(audioContext.destination);
+    oscillator.start();
+    oscillator.stop(audioContext.currentTime + BEEP_DURATION_SECONDS);
+  }
+  createIndicators(app, view, path, tooltip) {
+    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);
+    this.registerUnlockMenu(app, actionIconEl, () => path);
+    let tabIconEl = null;
+    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;
+    if (tabStatusContainerEl) {
+      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });
+      setIcon(tabIconEl, LOCK_ICON_ID);
+      setTooltip(tabIconEl, tooltip);
+      this.registerUnlockMenu(app, tabIconEl, () => path);
+    }
+    const onTypeAttempt = () => {
+      this.flashIndicators(view);
+      this.beep();
+    };
+    view.contentEl.addEventListener("beforeinput", onTypeAttempt);
+    return {
+      actionIconEl,
+      disposeTypeListener: () => {
+        view.contentEl.removeEventListener("beforeinput", onTypeAttempt);
+      },
+      tabIconEl
+    };
+  }
+  ensureBlockerInstalled(app) {
+    if (this.mutationBlockerComponent) {
+      return;
+    }
+    this.mutationBlockerComponent = new ResourceLockMutationBlockerComponent({
+      shouldBlockMutation: (path) => this.shouldBlockMutation(app, path)
+    });
+    this.mutationBlockerComponent.load();
+  }
+  ensureSubscribed(app) {
+    if (this.eventsComponent) {
+      return;
+    }
+    this.eventsComponent = new ResourceLockEventsComponent({
+      app,
+      onChange: () => {
+        this.reconcile(app);
+      },
+      onExternalMutation: (path) => {
+        this.handleExternalMutation(app, path);
+      },
+      onFileMenu: (menu, file) => {
+        this.handleFileMenu(app, menu, file);
+      }
+    });
+    this.eventsComponent.load();
+  }
+  flashElement(el) {
+    el.removeClass(LOCK_INDICATOR_FLASH_CSS_CLASS);
+    el.getBoundingClientRect();
+    el.addClass(LOCK_INDICATOR_FLASH_CSS_CLASS);
+  }
+  flashIndicators(view) {
+    const indicators = this.indicatorsByView.get(view);
+    for (const el of [indicators?.actionIconEl, indicators?.tabIconEl, this.statusBarItemEl]) {
+      if (el) {
+        this.flashElement(el);
+      }
+    }
+  }
+  /**
+   * Reacts to a vault/metadata event on a path. If the path is mutation-blocked and NOT covered by an
+   * active bypass scope, the change bypassed the blocker patch (sync / filesystem / a raw-adapter
+   * write) — an intruder. Abort the `abortController` of every mutation-blocking lock covering the path
+   * so the owning operation cancels and rolls back. A no-op for the owner's own (bypassed) mutations,
+   * for unblocked paths, and for blocking locks with no `abortController`.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path the event fired on.
+   */
+  handleExternalMutation(app, path) {
+    if (!this.isMutationBlockedByAncestor(app, path)) {
+      return;
+    }
+    if (this.isBypassed(app, path)) {
+      return;
+    }
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      for (const entry of entries) {
+        if (!entry.blocksMutations || !entry.abortController) {
+          continue;
+        }
+        const coversPath = lockedPath === path || entry.mode === "subtree" && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath });
+        if (coversPath) {
+          entry.abortController.abort();
+        }
+      }
+    }
+  }
+  handleFileMenu(app, menu, file) {
+    const ownerPath = this.resolveLockOwnerPath(app, file.path);
+    if (ownerPath === null) {
+      return;
+    }
+    this.addUnlockMenuItem(app, menu, ownerPath);
+  }
+  hasBlockingLock() {
+    for (const entries of this.lockEntriesByPath.values()) {
+      if (entries.some((entry) => entry.blocksMutations)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Checks whether the path is covered by an active {@link ResourceLockManager.bypass} scope — the
+   * owner declaring that its own mutations of the path (and, for a folder, its subtree) are sanctioned.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path being mutated.
+   * @returns `true` if some active bypass scope covers the path.
+   */
+  isBypassed(app, path) {
+    for (const bypassedPaths of this.bypassPathSets) {
+      for (const bypassedPath of bypassedPaths) {
+        if (isChildOrSelf({ app, childPathOrFile: path, parentPathOrFile: bypassedPath })) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  isPathLocked(path) {
+    return (this.lockEntriesByPath.get(path)?.length ?? 0) > 0;
+  }
+  lockingPluginNames(app, path) {
+    const entries = this.lockEntriesByPath.get(path);
+    assertNonNullable(entries);
+    const pluginIds = [...new Set(entries.map((entry) => entry.pluginId))];
+    return pluginIds.map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);
+  }
+  lockTooltip(app, path) {
+    const header = t(($) => $.obsidianDevUtils.resourceLock.lockedByTooltip);
+    return [header, ...this.lockingPluginNames(app, path)].join("\n");
+  }
+  reconcile(app) {
+    const viewsToLock = /* @__PURE__ */ new Set();
+    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+      const view = leaf.view;
+      if (!(view instanceof MarkdownView)) {
+        continue;
+      }
+      const path = view.file?.path;
+      if (path === void 0) {
+        continue;
+      }
+      const ownerPath = this.resolveLockOwnerPath(app, path);
+      if (ownerPath !== null) {
+        viewsToLock.add(view);
+        const tooltip = this.lockTooltip(app, ownerPath);
+        toggleEditorReadOnly(view.editor, true);
+        const indicators = this.indicatorsByView.get(view);
+        if (indicators) {
+          this.updateIndicatorTooltips(indicators, tooltip);
+        } else {
+          this.indicatorsByView.set(view, this.createIndicators(app, view, ownerPath, tooltip));
+        }
+      }
+    }
+    for (const [view, indicators] of this.indicatorsByView) {
+      if (!viewsToLock.has(view)) {
+        toggleEditorReadOnly(view.editor, false);
+        indicators.disposeTypeListener();
+        indicators.actionIconEl.remove();
+        indicators.tabIconEl?.remove();
+        this.indicatorsByView.delete(view);
+      }
+    }
+    this.updateStatusBar(app);
+  }
+  reconcileAndCleanup(app) {
+    this.reconcile(app);
+    if (this.lockEntriesByPath.size === 0) {
+      this.eventsComponent?.unload();
+      this.eventsComponent = null;
+    }
+    if (!this.hasBlockingLock()) {
+      this.mutationBlockerComponent?.unload();
+      this.mutationBlockerComponent = null;
+    }
+  }
+  registerUnlockMenu(app, el, getContextPath) {
+    el.addEventListener("contextmenu", (evt) => {
+      evt.preventDefault();
+      const path = getContextPath();
+      if (path === void 0) {
+        return;
+      }
+      const menu = new Menu();
+      this.addUnlockMenuItem(app, menu, path);
+      menu.showAtMouseEvent(evt);
+    });
+  }
+  removeEntry(app, path, entry) {
+    const entries = this.lockEntriesByPath.get(path);
+    if (!entries) {
+      return;
+    }
+    const index = entries.indexOf(entry);
+    if (index === -1) {
+      return;
+    }
+    entries.splice(index, 1);
+    if (entries.length === 0) {
+      this.lockEntriesByPath.delete(path);
+    }
+    this.reconcileAndCleanup(app);
+  }
+  /**
+   * Resolves which locked path (if any) covers the given path: the path itself when directly locked,
+   * otherwise the longest `subtree`-locked ancestor folder that contains it (longest so a nested
+   * subtree lock wins deterministically over an outer one).
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path to resolve an owner lock for.
+   * @returns The covering locked path, or `null` when nothing covers it.
+   */
+  resolveLockOwnerPath(app, path) {
+    if (this.isPathLocked(path)) {
+      return path;
+    }
+    let bestOwnerPath = null;
+    for (const [lockedPath, entries] of this.lockEntriesByPath) {
+      const hasSubtreeLock = entries.some((entry) => entry.mode === "subtree");
+      if (hasSubtreeLock && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }) && (bestOwnerPath === null || lockedPath.length > bestOwnerPath.length)) {
+        bestOwnerPath = lockedPath;
+      }
+    }
+    return bestOwnerPath;
+  }
+  /**
+   * Decides whether a mutation of the path must be blocked: `true` when the path is mutation-blocked
+   * and not covered by any active {@link ResourceLockManager.bypass} scope.
+   *
+   * @param app - The Obsidian app instance.
+   * @param path - The path being mutated.
+   * @returns `true` to reject the mutation, `false` to allow it.
+   */
+  shouldBlockMutation(app, path) {
+    if (!this.isMutationBlockedByAncestor(app, path)) {
+      return false;
+    }
+    return !this.isBypassed(app, path);
+  }
+  unlockConfirmMessage(app, path) {
+    const fragment = createFragment();
+    fragment.appendText(t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmMessage));
+    for (const name of this.lockingPluginNames(app, path)) {
+      fragment.createEl("br");
+      appendCodeBlock(fragment, name);
+    }
+    return fragment;
+  }
+  updateIndicatorTooltips(indicators, tooltip) {
+    setTooltip(indicators.actionIconEl, tooltip);
+    if (indicators.tabIconEl) {
+      setTooltip(indicators.tabIconEl, tooltip);
+    }
+  }
+  updateStatusBar(app) {
+    const activeView = app.workspace.getActiveViewOfType(MarkdownView);
+    const activePath = activeView?.file?.path;
+    const activeOwnerPath = activePath === void 0 ? null : this.resolveLockOwnerPath(app, activePath);
+    if (activeOwnerPath === null || !activeView) {
+      this.statusBarItemEl?.remove();
+      this.statusBarItemEl = null;
+      return;
+    }
+    if (!this.statusBarItemEl) {
+      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector(STATUS_BAR_CSS_SELECTOR);
+      if (!statusBarEl) {
+        return;
+      }
+      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });
+      setIcon(this.statusBarItemEl, LOCK_ICON_ID);
+      this.registerUnlockMenu(app, this.statusBarItemEl, () => {
+        const path = app.workspace.getActiveViewOfType(MarkdownView)?.file?.path;
+        return path === void 0 ? void 0 : this.resolveLockOwnerPath(app, path) ?? void 0;
+      });
+    }
+    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activeOwnerPath));
+  }
+}
+class ResourceLockComponent extends ComponentEx {
+  app;
+  pluginId;
+  /**
+   * Creates an resource-lock handle owned by a plugin.
+   *
+   * @param app - The Obsidian app instance.
+   * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to
+   * it for reference-counting and the indicators' "locked by" tooltip.
+   */
+  constructor(app, pluginId) {
+    super();
+    this.app = app;
+    this.pluginId = pluginId;
+  }
+  /**
+   * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this
+   * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the
+   * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path
+   * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around
+   * the operation that legitimately mutates resources it has locked with
+   * {@link ResourceLockComponentLockForPathOptions.shouldBlockMutations}:
+   *
+   * ```ts
+   * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);
+   * // ... the operation's own vault mutations of those paths are allowed ...
+   * // scope end: the paths are enforced again
+   * ```
+   *
+   * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.
+   * @returns A {@link Disposable} that ends the bypass scope when disposed.
+   */
+  bypassBlockedMutations(pathsOrFiles) {
+    return getManager().bypass(this.app, pathsOrFiles);
+  }
+  /**
+   * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.
+   *
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.
+   */
+  isLockedByAncestorForPath(pathOrFile) {
+    return getManager().isLockedByAncestor(this.app, pathOrFile);
+  }
+  /**
+   * Checks whether the note at the given path is currently locked by any plugin.
+   *
+   * @param pathOrFile - The path or file of the note to check.
+   * @returns `true` if the note has at least one active lock, `false` otherwise.
+   */
+  isLockedForPath(pathOrFile) {
+    return getManager().isLocked(this.app, pathOrFile);
+  }
+  /**
+   * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock
+   * on the path itself or on a `subtree`-locked ancestor folder.
+   *
+   * @param pathOrFile - The path or file to check.
+   * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a
+   * {@link ResourceLockedError}.
+   */
+  isMutationBlockedByAncestorForPath(pathOrFile) {
+    return getManager().isMutationBlockedByAncestor(this.app, pathOrFile);
+  }
+  /**
+   * Locks the note at the given path on behalf of this plugin, making it read-only in every current
+   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call
+   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.
+   *
+   * @param pathOrFile - The path or file of the note to lock.
+   * @param options - Optional locking options. Pass an
+   * {@link ResourceLockComponentLockForPathOptions.abortController} to make the lock cancelable via the
+   * indicator's right-click "unlock" menu or {@link requestResourceUnlockForPath}.
+   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.
+   */
+  lockForPath(pathOrFile, options) {
+    return getManager().lock(this.app, pathOrFile, this.pluginId, { abortController: options?.abortController, blocksMutations: options?.shouldBlockMutations, mode: options?.mode });
+  }
+  /**
+   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,
+   * so no note is left stuck read-only by an operation that never completed.
+   */
+  onunload() {
+    getManager().unlockAllForPlugin(this.app, this.pluginId);
+    super.onunload();
+  }
+  /**
+   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.
+   *
+   * @param pathOrFile - The path or file of the note to unlock.
+   */
+  unlockForPath(pathOrFile) {
+    getManager().unlock(this.app, pathOrFile, this.pluginId);
+  }
+}
+class ResourceLockedError extends Error {
+  /**
+   * The vault path whose mutation was blocked.
+   */
+  path;
+  /**
+   * Creates a {@link ResourceLockedError}.
+   *
+   * @param path - The vault path whose mutation was blocked.
+   */
+  constructor(path) {
+    super(`The resource "${path}" is locked and cannot be mutated.`);
+    this.name = "ResourceLockedError";
+    this.path = path;
+  }
+}
+function isResourceLockedForPath(app, pathOrFile) {
+  return getManager().isLocked(app, pathOrFile);
+}
+function lockResourceForPath(app, pathOrFile, pluginId) {
+  return getManager().lock(app, pathOrFile, pluginId);
+}
+function requestResourceUnlockForPath(app, pathOrFile) {
+  getManager().requestUnlock(app, pathOrFile);
+}
+function unlockResourceForPath(app, pathOrFile, pluginId) {
+  getManager().unlock(app, pathOrFile, pluginId);
+}
+function getManager() {
+  return getObsidianDevUtilsState(RESOURCE_LOCK_STATE_KEY, new ResourceLockManager()).value;
+}
+export {
+  ResourceLockComponent,
+  ResourceLockedError,
+  isResourceLockedForPath,
+  lockResourceForPath,
+  requestResourceUnlockForPath,
+  unlockResourceForPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/resource-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Path-scoped resource locking for vault files and folders, with three enforcement layers over one\n * shared locked-path set:\n *\n * 1. **Editor read-only** \u2014 while a path is locked, every current and future {@link MarkdownView} of\n *    that note (in any window, including popouts) is made read-only and shows a lock indicator in its\n *    tab header, its view action bar, and the status bar; a note inside a `subtree`-locked folder is\n *    covered too. Locks are reference-counted per locking plugin (the indicators' tooltip lists which\n *    plugins hold a lock), so nested/concurrent operations are safe \u2014 the path is unlocked only when\n *    the last lock is released.\n * 2. **Vault-mutation blocking** (opt-in via `shouldBlockMutations`) \u2014 any edit/delete/rename/move/\n *    create of a locked path through the `Vault`/`FileManager` API throws {@link ResourceLockedError},\n *    unless the owning operation has opened a {@link ResourceLockComponent.bypassBlockedMutations} scope\n *    over that path.\n * 3. **External-change detection** \u2014 a vault/metadata event on a locked path that no bypass scope\n *    covers is treated as an intruder (Sync / raw filesystem / another plugin) and aborts the owning\n *    operation's {@link AbortController}.\n *\n * The acquirers return a {@link Disposable}, so the preferred call style is a `using` declaration that\n * releases automatically at scope exit (including on throw):\n *\n * ```ts\n * using _lock = lockResourceForPath(app, path, this.manifest.id);\n * // ... long-running work (process, processFrontMatter, merge/split) ...\n * // auto-unlocked at scope exit\n * ```\n *\n * The explicit {@link unlockResourceForPath} pair remains available for non-`using` call sites.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  FileManager,\n  MarkdownView,\n  Menu,\n  setIcon,\n  setTooltip,\n  Vault\n} from 'obsidian';\n\nimport type { PathOrFile } from './file-system.ts';\n\nimport { convertAsyncToSync } from '../async.ts';\nimport {\n  CallbackDisposable,\n  MultipleDisposeBehavior\n} from '../disposable.ts';\nimport { noop } from '../function.ts';\nimport { getObsidianDevUtilsState } from '../obsidian-dev-utils-state.ts';\nimport { assertNonNullable } from '../type-guards.ts';\nimport { ComponentEx } from './components/component-ex.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { toggleEditorReadOnly } from './editor.ts';\nimport { getPath } from './file-system.ts';\nimport { appendCodeBlock } from './html-element.ts';\nimport { t } from './i18n/i18n.ts';\nimport { confirm } from './modals/confirm.ts';\nimport {\n  isChild,\n  isChildOrSelf\n} from './vault.ts';\n\nconst BEEP_DURATION_SECONDS = 0.08;\nconst BEEP_FREQUENCY_HZ = 660;\nconst BEEP_GAIN = 0.05;\nconst BEEP_THROTTLE_MILLISECONDS = 200;\nconst RESOURCE_LOCK_STATE_KEY = 'resourceLock';\nconst LOCK_ICON_ID = 'lock';\nconst LOCK_INDICATOR_CSS_CLASS = 'obsidian-dev-utils-lock-indicator';\nconst LOCK_INDICATOR_FLASH_CSS_CLASS = 'obsidian-dev-utils-lock-indicator-flash';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\nconst STATUS_BAR_CSS_SELECTOR = '.status-bar';\nconst UNLOCK_ICON_ID = 'unlock';\n\n/**\n * Options for {@link ResourceLockComponent.lockForPath}.\n */\nexport interface ResourceLockComponentLockForPathOptions {\n  /**\n   * An optional {@link AbortController} associated with the lock. When the lock indicator is\n   * right-clicked and the user confirms an unlock (or {@link requestResourceUnlockForPath} is called for\n   * the path), this controller is aborted so the operation holding the lock can cancel itself and\n   * release the lock in its own cleanup.\n   */\n  readonly abortController?: AbortController;\n\n  /**\n   * The lock scope. `'subtree'` also locks every descendant of a folder path; `'file'` locks only the\n   * exact path. A `subtree` lock must be released via the returned {@link Disposable} (not the\n   * explicit {@link ResourceLockComponent.unlockForPath}).\n   *\n   * @default `'file'`\n   */\n  readonly mode?: ResourceLockMode;\n\n  /**\n   * When `true`, the lock also **blocks vault mutations** of the covered path(s): any attempt to edit,\n   * delete, rename, move, or (re)create the resource through the `Vault`/`FileManager` API throws a\n   * {@link ResourceLockedError}. Installed lazily on the first such lock and removed when the last one\n   * is released. When `false` (the default) the lock only makes the editor read-only \u2014 legacy behavior,\n   * so existing consumers that write to a note they hold an editor lock on are unaffected.\n   *\n   * @default `false`\n   */\n  readonly shouldBlockMutations?: boolean;\n}\n\n/**\n * The scope of a lock.\n *\n * - `'file'` locks only the exact path.\n * - `'subtree'` locks the path and every descendant under it (its whole folder subtree), so a file\n *   inside a `subtree`-locked folder is treated as locked too.\n */\nexport type ResourceLockMode = 'file' | 'subtree';\n\ninterface LockEntry {\n  readonly abortController: AbortController | null;\n  readonly blocksMutations: boolean;\n  readonly mode: ResourceLockMode;\n  readonly pluginId: string;\n}\n\ninterface LockIndicators {\n  readonly actionIconEl: HTMLElement;\n  disposeTypeListener(): void;\n  readonly tabIconEl: HTMLElement | null;\n}\n\ninterface ManagerLockOptions {\n  readonly abortController?: AbortController | undefined;\n  readonly blocksMutations?: boolean | undefined;\n  readonly mode?: ResourceLockMode | undefined;\n}\n\n/**\n * Constructor parameters for {@link ResourceLockEventsComponent}.\n */\ninterface ResourceLockEventsComponentConstructorParams {\n  readonly app: App;\n  onChange(this: void): void;\n  onExternalMutation(this: void, path: string): void;\n  onFileMenu(this: void, menu: Menu, file: TAbstractFile): void;\n}\n\ninterface ResourceLockMutationBlockerComponentConstructorParams {\n  shouldBlockMutation(this: void, path: string): boolean;\n}\n\n/**\n * Subscribes to the workspace events that should trigger a lock reconcile (and the file context-menu\n * event that offers an \"Unlock\" item). Implemented as a {@link ComponentEx} so the subscriptions are\n * registered on `load()` and automatically removed on `unload()`, instead of being tracked by hand.\n */\nclass ResourceLockEventsComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly onChange: () => void;\n  private readonly onExternalMutation: (path: string) => void;\n  private readonly onFileMenu: (menu: Menu, file: TAbstractFile) => void;\n\n  public constructor(params: ResourceLockEventsComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.onChange = params.onChange;\n    this.onExternalMutation = params.onExternalMutation;\n    this.onFileMenu = params.onFileMenu;\n  }\n\n  public override onload(): void {\n    super.onload();\n    this.registerEvent(this.app.workspace.on('active-leaf-change', this.onChange));\n    this.registerEvent(this.app.workspace.on('layout-change', this.onChange));\n    // Same-leaf navigation to another note fires no leaf/layout change; without this it stays read-only.\n    this.registerEvent(this.app.workspace.on('file-open', this.onChange));\n    // Adds an \"Unlock\" item to a locked note's tab/file context menu (alongside the indicator menus).\n    this.registerEvent(this.app.workspace.on('file-menu', this.onFileMenu));\n    // External-change backstop: a vault/metadata event on a mutation-blocked path not covered by an active bypass scope is an intruder (a sync/FS/adapter change that bypassed the blocker patch).\n    this.registerEvent(this.app.vault.on('create', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.vault.on('delete', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.vault.on('rename', (file, oldPath): void => {\n      this.onExternalMutation(oldPath);\n      this.onExternalMutation(file.path);\n    }));\n    this.registerEvent(this.app.metadataCache.on('deleted', (file): void => {\n      this.onExternalMutation(file.path);\n    }));\n  }\n}\n\n/**\n * Monkey-patches the vault-mutation choke points on `Vault`/`FileManager` so that any edit, delete,\n * rename, move, or (re)create of a mutation-blocked path throws a {@link ResourceLockedError}.\n * Installed lazily by {@link ResourceLockManager} on the first `shouldBlockMutations` lock and removed\n * when the last one is released; being a {@link MonkeyAroundComponent}, every patch is torn down on\n * `unload`. Rename/copy check both source and destination; the other methods check their single path.\n */\nclass ResourceLockMutationBlockerComponent extends MonkeyAroundComponent {\n  private readonly shouldBlockMutation: (path: string) => boolean;\n\n  public constructor(params: ResourceLockMutationBlockerComponentConstructorParams) {\n    super();\n    this.shouldBlockMutation = params.shouldBlockMutation;\n  }\n\n  public override onload(): void {\n    super.onload();\n\n    this.registerMethodPatch<Vault, 'append'>({\n      methodName: 'append',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'copy'>({\n      methodName: 'copy',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [, newPath] }) => {\n        this.assertNotBlocked([newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'create'>({\n      methodName: 'create',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'createBinary'>({\n      methodName: 'createBinary',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'createFolder'>({\n      methodName: 'createFolder',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [path] }) => {\n        this.assertNotBlocked([path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'delete'>({\n      methodName: 'delete',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'modify'>({\n      methodName: 'modify',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'modifyBinary'>({\n      methodName: 'modifyBinary',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'process'>({\n      methodName: 'process',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'rename'>({\n      methodName: 'rename',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file, newPath] }) => {\n        this.assertNotBlocked([file.path, newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<Vault, 'trash'>({\n      methodName: 'trash',\n      obj: Vault.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<FileManager, 'renameFile'>({\n      methodName: 'renameFile',\n      obj: FileManager.prototype,\n      patchHandler: ({ fallback, originalArgs: [file, newPath] }) => {\n        this.assertNotBlocked([file.path, newPath]);\n        return fallback();\n      }\n    });\n    this.registerMethodPatch<FileManager, 'trashFile'>({\n      methodName: 'trashFile',\n      obj: FileManager.prototype,\n      patchHandler: ({ fallback, originalArgs: [file] }) => {\n        this.assertNotBlocked([file.path]);\n        return fallback();\n      }\n    });\n  }\n\n  private assertNotBlocked(paths: string[]): void {\n    for (const path of paths) {\n      if (this.shouldBlockMutation(path)) {\n        throw new ResourceLockedError(path);\n      }\n    }\n  }\n}\n\n/**\n * Tracks path-scoped editor locks and keeps every open {@link MarkdownView} in sync with the locked\n * set. A single instance lives on the shared `obsidian-dev-utils` state. Each lock is one\n * {@link LockEntry} in a per-path list, so a path can be held by several plugins (or several times by\n * one) concurrently and is released only when its last entry is removed; the indicators report which\n * plugins currently hold a lock.\n */\nclass ResourceLockManager {\n  private audioContext: AudioContext | null = null;\n  private readonly bypassPathSets = new Set<ReadonlySet<string>>();\n  private eventsComponent: null | ResourceLockEventsComponent = null;\n  private readonly indicatorsByView = new Map<MarkdownView, LockIndicators>();\n  private lastBeepMilliseconds = 0;\n  private readonly lockEntriesByPath = new Map<string, LockEntry[]>();\n  private mutationBlockerComponent: null | ResourceLockMutationBlockerComponent = null;\n  private statusBarItemEl: HTMLElement | null = null;\n\n  public bypass(app: App, pathsOrFiles: readonly PathOrFile[]): Disposable {\n    const bypassedPaths: ReadonlySet<string> = new Set(pathsOrFiles.map((pathOrFile) => getPath(app, pathOrFile)));\n    this.bypassPathSets.add(bypassedPaths);\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.bypassPathSets.delete(bypassedPaths);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  public isLocked(app: App, pathOrFile: PathOrFile): boolean {\n    return this.isPathLocked(getPath(app, pathOrFile));\n  }\n\n  /**\n   * Checks whether the given path is locked directly or is covered by a `subtree`-locked ancestor\n   * folder.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if the path is itself locked or lies under a `subtree`-locked folder.\n   */\n  public isLockedByAncestor(app: App, pathOrFile: PathOrFile): boolean {\n    return this.resolveLockOwnerPath(app, getPath(app, pathOrFile)) !== null;\n  }\n\n  /**\n   * Checks whether the given path is covered by a mutation-blocking lock (one taken with\n   * `blocksMutations`) directly or on a `subtree`-locked ancestor folder.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if a mutation of the path is currently blocked.\n   */\n  public isMutationBlockedByAncestor(app: App, pathOrFile: PathOrFile): boolean {\n    const path = getPath(app, pathOrFile);\n    const exactEntries = this.lockEntriesByPath.get(path);\n    if (exactEntries?.some((entry) => entry.blocksMutations)) {\n      return true;\n    }\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      if (entries.some((entry) => entry.mode === 'subtree' && entry.blocksMutations) && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath })) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  public lock(app: App, pathOrFile: PathOrFile, pluginId: string, options: ManagerLockOptions = {}): Disposable {\n    const path = getPath(app, pathOrFile);\n    const entry: LockEntry = {\n      abortController: options.abortController ?? null,\n      blocksMutations: options.blocksMutations ?? false,\n      mode: options.mode ?? 'file',\n      pluginId\n    };\n    let entries = this.lockEntriesByPath.get(path);\n    if (!entries) {\n      entries = [];\n      this.lockEntriesByPath.set(path, entries);\n    }\n    entries.push(entry);\n    this.ensureSubscribed(app);\n    if (entry.blocksMutations) {\n      this.ensureBlockerInstalled(app);\n    }\n    this.reconcile(app);\n\n    return new CallbackDisposable({\n      callback: (): void => {\n        this.removeEntry(app, path, entry);\n      },\n      multipleDisposeBehavior: MultipleDisposeBehavior.Ignore\n    });\n  }\n\n  /**\n   * Aborts every {@link AbortController} currently registered for the note at the given path, which\n   * cancels the operations holding the lock. Each operation releases its own lock in its `finally`\n   * when it observes the abort, so this does not unlock the path directly. A no-op when no controller\n   * is registered for the path.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pathOrFile - The path or file of the note to request an unlock for.\n   */\n  public requestUnlock(app: App, pathOrFile: PathOrFile): void {\n    const entries = this.lockEntriesByPath.get(getPath(app, pathOrFile));\n    if (!entries) {\n      return;\n    }\n    for (const entry of entries) {\n      entry.abortController?.abort();\n    }\n  }\n\n  public unlock(app: App, pathOrFile: PathOrFile, pluginId: string): void {\n    const path = getPath(app, pathOrFile);\n    const entries = this.lockEntriesByPath.get(path);\n    if (!entries) {\n      return;\n    }\n    const index = entries.findIndex((entry) => entry.pluginId === pluginId);\n    if (index === -1) {\n      return;\n    }\n    entries.splice(index, 1);\n    if (entries.length === 0) {\n      this.lockEntriesByPath.delete(path);\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  public unlockAllForPlugin(app: App, pluginId: string): void {\n    for (const [path, entries] of this.lockEntriesByPath) {\n      const remaining = entries.filter((entry) => entry.pluginId !== pluginId);\n      if (remaining.length === 0) {\n        this.lockEntriesByPath.delete(path);\n      } else if (remaining.length !== entries.length) {\n        this.lockEntriesByPath.set(path, remaining);\n      }\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  private addUnlockMenuItem(app: App, menu: Menu, path: string): void {\n    menu.addItem((item) => {\n      item\n        .setTitle(t(($) => $.obsidianDevUtils.resourceLock.unlockMenuItem))\n        .setIcon(UNLOCK_ICON_ID)\n        .onClick(convertAsyncToSync(async () => {\n          const isConfirmed = await confirm({\n            app,\n            message: this.unlockConfirmMessage(app, path),\n            title: t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmTitle)\n          });\n          if (isConfirmed) {\n            this.requestUnlock(app, path);\n          }\n        }));\n    });\n  }\n\n  private beep(): void {\n    // Throttle so a burst of keystrokes does not stack overlapping tones into a buzz.\n    const nowMilliseconds = Date.now();\n    if (nowMilliseconds - this.lastBeepMilliseconds < BEEP_THROTTLE_MILLISECONDS) {\n      return;\n    }\n    this.lastBeepMilliseconds = nowMilliseconds;\n\n    // `lib.dom` types `AudioContext` as always present, but it is absent in some runtimes\n    // (e.g. the jsdom test environment), so this guard is real, not redundant.\n    const AudioContextClass = window.AudioContext;\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- see the comment above.\n    if (!AudioContextClass) {\n      return;\n    }\n    this.audioContext ??= new AudioContextClass();\n    const audioContext = this.audioContext;\n    const oscillator = audioContext.createOscillator();\n    const gainNode = audioContext.createGain();\n    oscillator.type = 'sine';\n    oscillator.frequency.value = BEEP_FREQUENCY_HZ;\n    gainNode.gain.value = BEEP_GAIN;\n    oscillator.connect(gainNode);\n    gainNode.connect(audioContext.destination);\n    oscillator.start();\n    oscillator.stop(audioContext.currentTime + BEEP_DURATION_SECONDS);\n  }\n\n  private createIndicators(app: App, view: MarkdownView, path: string, tooltip: string): LockIndicators {\n    const actionIconEl = view.addAction(LOCK_ICON_ID, tooltip, noop);\n    this.registerUnlockMenu(app, actionIconEl, () => path);\n\n    let tabIconEl: HTMLElement | null = null;\n    const tabStatusContainerEl = view.leaf.tabHeaderStatusContainerEl;\n    if (tabStatusContainerEl) {\n      tabIconEl = tabStatusContainerEl.createSpan({ cls: LOCK_INDICATOR_CSS_CLASS });\n      setIcon(tabIconEl, LOCK_ICON_ID);\n      setTooltip(tabIconEl, tooltip);\n      this.registerUnlockMenu(app, tabIconEl, () => path);\n    }\n\n    // A locked view is read-only but still editable-focusable, so a keystroke fires `beforeinput`.\n    // On that rejected attempt, flash the indicators and beep so it's clear the note is locked.\n    // The listener is removed on unlock.\n    const onTypeAttempt = (): void => {\n      this.flashIndicators(view);\n      this.beep();\n    };\n    view.contentEl.addEventListener('beforeinput', onTypeAttempt);\n\n    return {\n      actionIconEl,\n      disposeTypeListener: (): void => {\n        view.contentEl.removeEventListener('beforeinput', onTypeAttempt);\n      },\n      tabIconEl\n    };\n  }\n\n  private ensureBlockerInstalled(app: App): void {\n    if (this.mutationBlockerComponent) {\n      return;\n    }\n    this.mutationBlockerComponent = new ResourceLockMutationBlockerComponent({\n      shouldBlockMutation: (path): boolean => this.shouldBlockMutation(app, path)\n    });\n    this.mutationBlockerComponent.load();\n  }\n\n  private ensureSubscribed(app: App): void {\n    if (this.eventsComponent) {\n      return;\n    }\n    this.eventsComponent = new ResourceLockEventsComponent({\n      app,\n      onChange: (): void => {\n        this.reconcile(app);\n      },\n      onExternalMutation: (path): void => {\n        this.handleExternalMutation(app, path);\n      },\n      onFileMenu: (menu, file): void => {\n        this.handleFileMenu(app, menu, file);\n      }\n    });\n    this.eventsComponent.load();\n  }\n\n  private flashElement(el: HTMLElement): void {\n    el.removeClass(LOCK_INDICATOR_FLASH_CSS_CLASS);\n    // Read layout to force a reflow so the flash animation restarts on every rejected keystroke.\n    el.getBoundingClientRect();\n    el.addClass(LOCK_INDICATOR_FLASH_CSS_CLASS);\n  }\n\n  private flashIndicators(view: MarkdownView): void {\n    const indicators = this.indicatorsByView.get(view);\n    for (const el of [indicators?.actionIconEl, indicators?.tabIconEl, this.statusBarItemEl]) {\n      if (el) {\n        this.flashElement(el);\n      }\n    }\n  }\n\n  /**\n   * Reacts to a vault/metadata event on a path. If the path is mutation-blocked and NOT covered by an\n   * active bypass scope, the change bypassed the blocker patch (sync / filesystem / a raw-adapter\n   * write) \u2014 an intruder. Abort the `abortController` of every mutation-blocking lock covering the path\n   * so the owning operation cancels and rolls back. A no-op for the owner's own (bypassed) mutations,\n   * for unblocked paths, and for blocking locks with no `abortController`.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path the event fired on.\n   */\n  private handleExternalMutation(app: App, path: string): void {\n    if (!this.isMutationBlockedByAncestor(app, path)) {\n      return;\n    }\n    if (this.isBypassed(app, path)) {\n      return;\n    }\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      for (const entry of entries) {\n        if (!entry.blocksMutations || !entry.abortController) {\n          continue;\n        }\n        const coversPath = lockedPath === path || (entry.mode === 'subtree' && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }));\n        if (coversPath) {\n          entry.abortController.abort();\n        }\n      }\n    }\n  }\n\n  private handleFileMenu(app: App, menu: Menu, file: TAbstractFile): void {\n    // Offer \"Unlock\" for a directly-locked file/folder, or anything covered by a `subtree` lock on an ancestor. The menu targets the owner lock's path.\n    const ownerPath = this.resolveLockOwnerPath(app, file.path);\n    if (ownerPath === null) {\n      return;\n    }\n    this.addUnlockMenuItem(app, menu, ownerPath);\n  }\n\n  private hasBlockingLock(): boolean {\n    for (const entries of this.lockEntriesByPath.values()) {\n      if (entries.some((entry) => entry.blocksMutations)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Checks whether the path is covered by an active {@link ResourceLockManager.bypass} scope \u2014 the\n   * owner declaring that its own mutations of the path (and, for a folder, its subtree) are sanctioned.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path being mutated.\n   * @returns `true` if some active bypass scope covers the path.\n   */\n  private isBypassed(app: App, path: string): boolean {\n    for (const bypassedPaths of this.bypassPathSets) {\n      for (const bypassedPath of bypassedPaths) {\n        if (isChildOrSelf({ app, childPathOrFile: path, parentPathOrFile: bypassedPath })) {\n          return true;\n        }\n      }\n    }\n    return false;\n  }\n\n  private isPathLocked(path: string): boolean {\n    return (this.lockEntriesByPath.get(path)?.length ?? 0) > 0;\n  }\n\n  private lockingPluginNames(app: App, path: string): string[] {\n    const entries = this.lockEntriesByPath.get(path);\n    // `lockingPluginNames` is only ever called for a locked path, so its entries are always present.\n    assertNonNullable(entries);\n    const pluginIds = [...new Set(entries.map((entry) => entry.pluginId))];\n    return pluginIds.map((pluginId) => app.plugins.manifests[pluginId]?.name ?? pluginId);\n  }\n\n  private lockTooltip(app: App, path: string): string {\n    const header = t(($) => $.obsidianDevUtils.resourceLock.lockedByTooltip);\n    // A runtime-length list of plugin names, one per line under the header.\n    return [header, ...this.lockingPluginNames(app, path)].join('\\n');\n  }\n\n  private reconcile(app: App): void {\n    const viewsToLock = new Set<MarkdownView>();\n    for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {\n      const view = leaf.view;\n      if (!(view instanceof MarkdownView)) {\n        continue;\n      }\n\n      const path = view.file?.path;\n      if (path === undefined) {\n        continue;\n      }\n\n      // Resolve the lock covering this view: the exact path when directly locked, otherwise the enclosing `subtree`-locked folder. Indicators/tooltip/unlock menu key off that owner path.\n      const ownerPath = this.resolveLockOwnerPath(app, path);\n      if (ownerPath !== null) {\n        viewsToLock.add(view);\n        const tooltip = this.lockTooltip(app, ownerPath);\n        // Re-apply the read-only toggle on every reconcile, not only the first time a view is tracked.\n        // The toggle is idempotent, so re-applying to an already-locked view is cheap.\n        // A view opened after the lock is reconciled synchronously, before its CodeMirror is ready.\n        // Its first toggle is therefore a no-op; re-applying makes the lock take hold once it settles.\n        toggleEditorReadOnly(view.editor, true);\n        const indicators = this.indicatorsByView.get(view);\n        if (indicators) {\n          this.updateIndicatorTooltips(indicators, tooltip);\n        } else {\n          this.indicatorsByView.set(view, this.createIndicators(app, view, ownerPath, tooltip));\n        }\n      }\n    }\n\n    for (const [view, indicators] of this.indicatorsByView) {\n      if (!viewsToLock.has(view)) {\n        toggleEditorReadOnly(view.editor, false);\n        indicators.disposeTypeListener();\n        indicators.actionIconEl.remove();\n        indicators.tabIconEl?.remove();\n        this.indicatorsByView.delete(view);\n      }\n    }\n\n    this.updateStatusBar(app);\n  }\n\n  private reconcileAndCleanup(app: App): void {\n    this.reconcile(app);\n    if (this.lockEntriesByPath.size === 0) {\n      this.eventsComponent?.unload();\n      this.eventsComponent = null;\n    }\n    if (!this.hasBlockingLock()) {\n      this.mutationBlockerComponent?.unload();\n      this.mutationBlockerComponent = null;\n    }\n  }\n\n  private registerUnlockMenu(app: App, el: HTMLElement, getContextPath: () => string | undefined): void {\n    // A plain listener dies with the element when it is `.remove()`d on unlock, so it never leaks.\n    el.addEventListener('contextmenu', (evt) => {\n      evt.preventDefault();\n      const path = getContextPath();\n      if (path === undefined) {\n        return;\n      }\n      const menu = new Menu();\n      this.addUnlockMenuItem(app, menu, path);\n      menu.showAtMouseEvent(evt);\n    });\n  }\n\n  private removeEntry(app: App, path: string, entry: LockEntry): void {\n    const entries = this.lockEntriesByPath.get(path);\n    if (!entries) {\n      return;\n    }\n    const index = entries.indexOf(entry);\n    if (index === -1) {\n      return;\n    }\n    entries.splice(index, 1);\n    if (entries.length === 0) {\n      this.lockEntriesByPath.delete(path);\n    }\n    this.reconcileAndCleanup(app);\n  }\n\n  /**\n   * Resolves which locked path (if any) covers the given path: the path itself when directly locked,\n   * otherwise the longest `subtree`-locked ancestor folder that contains it (longest so a nested\n   * subtree lock wins deterministically over an outer one).\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path to resolve an owner lock for.\n   * @returns The covering locked path, or `null` when nothing covers it.\n   */\n  private resolveLockOwnerPath(app: App, path: string): null | string {\n    if (this.isPathLocked(path)) {\n      return path;\n    }\n    let bestOwnerPath: null | string = null;\n    for (const [lockedPath, entries] of this.lockEntriesByPath) {\n      const hasSubtreeLock = entries.some((entry) => entry.mode === 'subtree');\n      if (hasSubtreeLock && isChild({ app, childPathOrFile: path, parentPathOrFile: lockedPath }) && (bestOwnerPath === null || lockedPath.length > bestOwnerPath.length)) {\n        bestOwnerPath = lockedPath;\n      }\n    }\n    return bestOwnerPath;\n  }\n\n  /**\n   * Decides whether a mutation of the path must be blocked: `true` when the path is mutation-blocked\n   * and not covered by any active {@link ResourceLockManager.bypass} scope.\n   *\n   * @param app - The Obsidian app instance.\n   * @param path - The path being mutated.\n   * @returns `true` to reject the mutation, `false` to allow it.\n   */\n  private shouldBlockMutation(app: App, path: string): boolean {\n    if (!this.isMutationBlockedByAncestor(app, path)) {\n      return false;\n    }\n    return !this.isBypassed(app, path);\n  }\n\n  private unlockConfirmMessage(app: App, path: string): DocumentFragment {\n    const fragment = createFragment();\n    fragment.appendText(t(($) => $.obsidianDevUtils.resourceLock.unlockConfirmMessage));\n    // A runtime-length list of the plugins currently holding a lock, each as a code block on its own line.\n    for (const name of this.lockingPluginNames(app, path)) {\n      fragment.createEl('br');\n      appendCodeBlock(fragment, name);\n    }\n    return fragment;\n  }\n\n  private updateIndicatorTooltips(indicators: LockIndicators, tooltip: string): void {\n    setTooltip(indicators.actionIconEl, tooltip);\n    if (indicators.tabIconEl) {\n      setTooltip(indicators.tabIconEl, tooltip);\n    }\n  }\n\n  private updateStatusBar(app: App): void {\n    const activeView = app.workspace.getActiveViewOfType(MarkdownView);\n    const activePath = activeView?.file?.path;\n    const activeOwnerPath = activePath === undefined ? null : this.resolveLockOwnerPath(app, activePath);\n\n    if (activeOwnerPath === null || !activeView) {\n      this.statusBarItemEl?.remove();\n      this.statusBarItemEl = null;\n      return;\n    }\n\n    if (!this.statusBarItemEl) {\n      const statusBarEl = activeView.containerEl.ownerDocument.body.querySelector<HTMLElement>(STATUS_BAR_CSS_SELECTOR);\n      if (!statusBarEl) {\n        return;\n      }\n      this.statusBarItemEl = statusBarEl.createDiv({ cls: [STATUS_BAR_ITEM_CSS_CLASS, LOCK_INDICATOR_CSS_CLASS] });\n      setIcon(this.statusBarItemEl, LOCK_ICON_ID);\n      // The single status-bar item is reused across active-note switches.\n      // It must resolve the currently active note's owner lock at click time rather than capturing one path.\n      this.registerUnlockMenu(app, this.statusBarItemEl, () => {\n        const path = app.workspace.getActiveViewOfType(MarkdownView)?.file?.path;\n        return path === undefined ? undefined : this.resolveLockOwnerPath(app, path) ?? undefined;\n      });\n    }\n\n    setTooltip(this.statusBarItemEl, this.lockTooltip(app, activeOwnerPath));\n  }\n}\n\n/**\n * A per-plugin handle for path-scoped resource locking (editor read-only, optional vault-mutation\n * blocking, and external-change detection \u2014 see the file overview). Add it as a child of your plugin\n * (`this.addChild(new ResourceLockComponent(this.app))`) so that any locks it still holds are released\n * automatically when the plugin unloads \u2014 a resource can never be left stuck locked because the plugin\n * that locked it was disabled or reloaded mid-operation.\n *\n * Locks are reference-counted and attributed to this plugin, so the lock indicators' tooltip names it\n * among the plugins currently holding a lock.\n */\nexport class ResourceLockComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly pluginId: string;\n\n  /**\n   * Creates an resource-lock handle owned by a plugin.\n   *\n   * @param app - The Obsidian app instance.\n   * @param pluginId - The id of the owning plugin (e.g. its `manifest.id`). Locks are attributed to\n   * it for reference-counting and the indicators' \"locked by\" tooltip.\n   */\n  public constructor(app: App, pluginId: string) {\n    super();\n    this.app = app;\n    this.pluginId = pluginId;\n  }\n\n  /**\n   * Opens an **ambient bypass scope**: while the returned {@link Disposable} is not disposed, this\n   * plugin's own mutations of the given paths (and, for a folder, its whole subtree) pass through the\n   * mutation blocker instead of throwing {@link ResourceLockedError}. Any mutation of a blocked path\n   * NOT covered by an active bypass scope is still rejected. Use it with a `using` declaration around\n   * the operation that legitimately mutates resources it has locked with\n   * {@link ResourceLockComponentLockForPathOptions.shouldBlockMutations}:\n   *\n   * ```ts\n   * using _bypass = component.bypassBlockedMutations([sourceFile, targetFile]);\n   * // ... the operation's own vault mutations of those paths are allowed ...\n   * // scope end: the paths are enforced again\n   * ```\n   *\n   * @param pathsOrFiles - The paths (or files/folders) whose mutation by this operation is sanctioned.\n   * @returns A {@link Disposable} that ends the bypass scope when disposed.\n   */\n  public bypassBlockedMutations(pathsOrFiles: readonly PathOrFile[]): Disposable {\n    return getManager().bypass(this.app, pathsOrFiles);\n  }\n\n  /**\n   * Checks whether the path is locked directly or lies under a `subtree`-locked ancestor folder.\n   *\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if the path is itself locked or is covered by a `subtree` lock on an ancestor.\n   */\n  public isLockedByAncestorForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isLockedByAncestor(this.app, pathOrFile);\n  }\n\n  /**\n   * Checks whether the note at the given path is currently locked by any plugin.\n   *\n   * @param pathOrFile - The path or file of the note to check.\n   * @returns `true` if the note has at least one active lock, `false` otherwise.\n   */\n  public isLockedForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isLocked(this.app, pathOrFile);\n  }\n\n  /**\n   * Checks whether a vault mutation of the path is currently blocked by a `shouldBlockMutations` lock\n   * on the path itself or on a `subtree`-locked ancestor folder.\n   *\n   * @param pathOrFile - The path or file to check.\n   * @returns `true` if editing/deleting/renaming/moving/creating the path would throw a\n   * {@link ResourceLockedError}.\n   */\n  public isMutationBlockedByAncestorForPath(pathOrFile: PathOrFile): boolean {\n    return getManager().isMutationBlockedByAncestor(this.app, pathOrFile);\n  }\n\n  /**\n   * Locks the note at the given path on behalf of this plugin, making it read-only in every current\n   * and future {@link MarkdownView} until the lock is released. Reference-counted: balance each call\n   * with a dispose of the returned {@link Disposable} (ideally via `using`) or {@link unlockForPath}.\n   *\n   * @param pathOrFile - The path or file of the note to lock.\n   * @param options - Optional locking options. Pass an\n   * {@link ResourceLockComponentLockForPathOptions.abortController} to make the lock cancelable via the\n   * indicator's right-click \"unlock\" menu or {@link requestResourceUnlockForPath}.\n   * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n   */\n  public lockForPath(pathOrFile: PathOrFile, options?: ResourceLockComponentLockForPathOptions): Disposable {\n    return getManager().lock(this.app, pathOrFile, this.pluginId, { abortController: options?.abortController, blocksMutations: options?.shouldBlockMutations, mode: options?.mode });\n  }\n\n  /**\n   * Releases every lock still held by this plugin when the component (and thus the plugin) unloads,\n   * so no note is left stuck read-only by an operation that never completed.\n   */\n  public override onunload(): void {\n    getManager().unlockAllForPlugin(this.app, this.pluginId);\n    super.onunload();\n  }\n\n  /**\n   * Releases one lock previously acquired for the note at the given path via {@link lockForPath}.\n   *\n   * @param pathOrFile - The path or file of the note to unlock.\n   */\n  public unlockForPath(pathOrFile: PathOrFile): void {\n    getManager().unlock(this.app, pathOrFile, this.pluginId);\n  }\n}\n\n/**\n * Thrown by the vault-mutation blocker when a plugin tries to edit, delete, rename, move, or create a\n * resource whose path is covered by a lock taken with\n * {@link ResourceLockComponentLockForPathOptions.shouldBlockMutations}.\n */\nexport class ResourceLockedError extends Error {\n  /**\n   * The vault path whose mutation was blocked.\n   */\n  public readonly path: string;\n\n  /**\n   * Creates a {@link ResourceLockedError}.\n   *\n   * @param path - The vault path whose mutation was blocked.\n   */\n  public constructor(path: string) {\n    super(`The resource \"${path}\" is locked and cannot be mutated.`);\n    this.name = 'ResourceLockedError';\n    this.path = path;\n  }\n}\n\n/**\n * Checks whether the note at the given path is currently locked.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to check.\n * @returns `true` if the note has at least one active lock, `false` otherwise.\n */\nexport function isResourceLockedForPath(app: App, pathOrFile: PathOrFile): boolean {\n  return getManager().isLocked(app, pathOrFile);\n}\n\n/**\n * Locks the note at the given path, making it read-only in every current and future\n * {@link MarkdownView} until the lock is released, and showing a lock indicator in the tab header,\n * view action bar, and (while active) the status bar. The indicators' tooltip lists the plugins\n * that currently hold a lock on the note.\n *\n * The lock is reference-counted per calling plugin: each call must be balanced by exactly one\n * release (either disposing the returned {@link Disposable} \u2014 ideally via a `using` declaration \u2014 or\n * a matching {@link unlockResourceForPath} call).\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to lock.\n * @param pluginId - The id of the locking plugin (e.g. its `manifest.id`). The lock is attributed to\n * it for reference-counting and the indicators' \"locked by\" tooltip.\n * @returns A {@link Disposable} that releases this lock when disposed. Disposing more than once is a no-op.\n */\nexport function lockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): Disposable {\n  return getManager().lock(app, pathOrFile, pluginId);\n}\n\n/**\n * Requests an unlock of the note at the given path by aborting every {@link AbortController} that was\n * associated with a lock on it (via {@link ResourceLockComponent.lockForPath}'s\n * {@link ResourceLockComponentLockForPathOptions.abortController}). The operations holding the lock\n * observe the abort and release their own locks. A no-op when no abortable lock is registered for the\n * path.\n *\n * This lets a consuming plugin wire its own \"unlock active note\" command without reaching into the\n * lock manager directly.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to request an unlock for.\n */\nexport function requestResourceUnlockForPath(app: App, pathOrFile: PathOrFile): void {\n  getManager().requestUnlock(app, pathOrFile);\n}\n\n/**\n * Releases one lock previously acquired for the note at the given path via {@link lockResourceForPath}.\n *\n * When the last lock is released the note becomes fully editable again and its lock indicators are\n * removed. Calling this when the note is not locked is a no-op.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrFile - The path or file of the note to unlock.\n * @param pluginId - The id of the plugin that holds the lock (e.g. its `manifest.id`); one of its\n * locks on the note is released.\n */\nexport function unlockResourceForPath(app: App, pathOrFile: PathOrFile, pluginId: string): void {\n  getManager().unlock(app, pathOrFile, pluginId);\n}\n\nfunction getManager(): ResourceLockManager {\n  return getObsidianDevUtilsState<ResourceLockManager>(RESOURCE_LOCK_STATE_KEY, new ResourceLockManager()).value;\n}\n"],
  "mappings": "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",
  "names": []
}
