obsidian-dev-utils 101.5.0 → 101.6.0

package/dist/integration-test-plugin/main.js

@@ -10411,6 +10411,7 @@ __export(merged_exports, {
   SetTransformer: () => SetTransformer,
   SettingEx: () => SettingEx,
   SettingGroupEx: () => SettingGroupEx,
+  SettingsMigrationComponent: () => SettingsMigrationComponent,
   SilentError: () => SilentError,
   SkipPrivatePropertyTransformer: () => SkipPrivatePropertyTransformer,
   SpellcheckMode: () => SpellcheckMode,
@@ -32232,195 +32233,660 @@ var RmdirGuardComponent = class extends MonkeyAroundComponent {
   }
 };
 
-// src/obsidian/components/syntax-highlighting-component.ts
-var syntax_highlighting_component_exports = {};
-__export(syntax_highlighting_component_exports, {
-  SyntaxHighlightingComponent: () => SyntaxHighlightingComponent
+// src/obsidian/components/settings-migration-component.ts
+var settings_migration_component_exports = {};
+__export(settings_migration_component_exports, {
+  SettingsMigrationComponent: () => SettingsMigrationComponent
 });
-init_error();
-init_component_ex();
-var SyntaxHighlightingComponent = class extends ComponentEx {
+init_async();
+init_object_utils();
+
+// src/obsidian/plugin/plugin-api.ts
+var plugin_api_exports = {};
+__export(plugin_api_exports, {
+  PluginApiPayloadKind: () => PluginApiPayloadKind,
+  PluginApiRevokedError: () => PluginApiRevokedError,
+  PluginApiUnavailabilityReason: () => PluginApiUnavailabilityReason,
+  PluginApiUnavailableError: () => PluginApiUnavailableError,
+  PluginApiValidationError: () => PluginApiValidationError,
+  publishPluginApi: () => publishPluginApi,
+  watchPluginApi: () => watchPluginApi
+});
+var import_compare_versions3 = __toESM(require_umd(), 1);
+init_array();
+init_async_events();
+init_async();
+init_debug();
+init_object_utils();
+init_obsidian_dev_utils_state();
+var PLUGIN_API_DEBUGGER_NAMESPACE = "PluginApi";
+var PLUGIN_API_REGISTRY_STATE_KEY = "pluginApiRegistry";
+var DEFAULT_WHEN_AVAILABLE_TIMEOUT_IN_MILLISECONDS = 1e4;
+var PluginApiPayloadKind = /* @__PURE__ */ ((PluginApiPayloadKind2) => {
+  PluginApiPayloadKind2["Input"] = "input";
+  PluginApiPayloadKind2["Output"] = "output";
+  return PluginApiPayloadKind2;
+})(PluginApiPayloadKind || {});
+var PluginApiUnavailabilityReason = /* @__PURE__ */ ((PluginApiUnavailabilityReason2) => {
+  PluginApiUnavailabilityReason2["NotEnabled"] = "notEnabled";
+  PluginApiUnavailabilityReason2["NotInstalled"] = "notInstalled";
+  PluginApiUnavailabilityReason2["NotPublished"] = "notPublished";
+  PluginApiUnavailabilityReason2["Revoked"] = "revoked";
+  PluginApiUnavailabilityReason2["ShapeMismatch"] = "shapeMismatch";
+  PluginApiUnavailabilityReason2["VersionMismatch"] = "versionMismatch";
+  return PluginApiUnavailabilityReason2;
+})(PluginApiUnavailabilityReason || {});
+var PluginApiWatchBase = class {
+  // A `protected` constructor is not assignable to `AbstractConstructor<object>`, which is what
+  // `mixinAsyncEvents` accepts, so this stays public even though only the subclass below calls it.
+  constructor(params) {
+    this.params = params;
+  }
+  params;
+  handle = null;
+  record = null;
   /**
-   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
-   *
-   * @param params - The parameters for registering the language.
-   * @returns A {@link Promise} that resolves when the language is registered.
+   * Builds the error describing why the API is not available right now.
    *
-   * @example
-   * ```ts
-   * await component.registerCodeBlockLanguage({
-   *   editorMode: 'text/typescript',
-   *   language: 'my-language',
-   *   prismGrammar: 'typescript'
-   * });
-   * ```
+   * @returns The classified error.
    */
-  async registerCodeBlockLanguage(params) {
-    const {
-      editorMode,
-      language,
-      prismGrammar
-    } = params;
-    this.ensureLoaded();
-    if (prismGrammar !== void 0) {
-      await this.registerPrismLanguage({
-        grammar: prismGrammar,
-        language
+  createUnavailableError() {
+    return new PluginApiUnavailableError({
+      pluginId: this.params.pluginId,
+      reason: resolveUnavailabilityReason(this.params)
+    });
+  }
+};
+var PluginApiRefImpl = class extends mixinAsyncEvents()(PluginApiWatchBase) {
+  get value() {
+    return castTo(this.handle);
+  }
+  constructor(params) {
+    super(params);
+  }
+  /**
+   * Recomputes the current value from the registry, firing `change` only when it actually changed.
+   */
+  refresh() {
+    const record = selectRecord(this.params);
+    if (record === this.record) {
+      return;
+    }
+    this.record = record;
+    this.handle = record === null ? null : createRevocableHandle(record, this.params.contract);
+    this.trigger("change");
+  }
+  async whenAvailable(options) {
+    const currentValue = this.value;
+    if (currentValue !== null) {
+      return currentValue;
+    }
+    try {
+      return await runWithTimeout({
+        operationFunction: async (abortSignal) => await this.waitForValue(abortSignal),
+        operationName: `watchPluginApi("${this.params.pluginId}").whenAvailable`,
+        timeoutInMilliseconds: options?.timeoutInMilliseconds ?? DEFAULT_WHEN_AVAILABLE_TIMEOUT_IN_MILLISECONDS
       });
+    } catch {
+      throw this.createUnavailableError();
     }
-    this.ensureLoaded();
-    const previousModeFactory = window.CodeMirror.modes[language];
-    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));
-    this.register(() => {
-      if (previousModeFactory !== void 0) {
-        window.CodeMirror.modes[language] = previousModeFactory;
-        return;
+  }
+  async waitForValue(abortSignal) {
+    return await new Promise((resolve2, reject) => {
+      const eventRef = this.on("change", () => {
+        handleChange();
+      });
+      function cleanUp() {
+        eventRef.asyncEventSource.offref(eventRef);
+        abortSignal.removeEventListener("abort", handleAbort);
       }
-      delete window.CodeMirror.modes[language];
+      function handleAbort() {
+        cleanUp();
+        reject(abortSignal.reason);
+      }
+      const handleChange = () => {
+        const value = this.value;
+        if (value !== null) {
+          cleanUp();
+          resolve2(value);
+        }
+      };
+      abortSignal.addEventListener("abort", handleAbort);
+      handleChange();
     });
   }
+};
+var PluginApiUnavailableError = class extends Error {
   /**
-   * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
-   * {@link CodeHighlighterComponent} settings field.
-   *
-   * @param params - The parameters for registering the language.
-   * @returns A {@link Promise} that resolves when the language is registered.
+   * The `manifest.id` of the plugin whose API was requested.
+   */
+  pluginId;
+  /**
+   * Which of the five failures occurred.
+   */
+  reason;
+  /**
+   * Creates a {@link PluginApiUnavailableError}.
    *
-   * @example
-   * ```ts
-   * await component.registerPrismLanguage({
-   *   grammar: {
-   *     keyword: /\bfoo\b/
-   *   },
-   *   language: 'my-language'
-   * });
-   * ```
+   * @param params - The parameters for the error.
    */
-  async registerPrismLanguage(params) {
-    const {
-      grammar,
-      language
-    } = params;
-    this.ensureLoaded();
-    const prism = await loadPrism();
-    this.ensureLoaded();
-    const previousGrammar = prism.languages[language];
-    prism.languages[language] = this.resolveGrammar(prism, grammar);
-    this.register(() => {
-      if (previousGrammar !== void 0) {
-        prism.languages[language] = previousGrammar;
-        return;
-      }
-      delete prism.languages[language];
-    });
+  constructor(params) {
+    super(params.message ?? `The API of the plugin "${params.pluginId}" is unavailable: ${params.reason}.`);
+    this.name = "PluginApiUnavailableError";
+    this.pluginId = params.pluginId;
+    this.reason = params.reason;
   }
+};
+var PluginApiRevokedError = class extends PluginApiUnavailableError {
   /**
-   * Returns the grammar of an already registered Prism language.
+   * Creates a {@link PluginApiRevokedError}.
    *
-   * @param prism - The loaded Prism module.
-   * @param language - The language to look up.
-   * @returns The grammar of the language.
-   * @throws An {@link Error} if the language is not registered.
+   * @param pluginId - The `manifest.id` of the plugin whose API was revoked.
    */
-  requirePrismLanguage(prism, language) {
-    return prism.languages[language] ?? throwExpression(new Error(`Prism language "${language}" is not registered.`));
+  constructor(pluginId) {
+    super({
+      message: `The API of the plugin "${pluginId}" has been revoked, because the plugin was unloaded.`,
+      pluginId,
+      reason: "revoked" /* Revoked */
+    });
+    this.name = "PluginApiRevokedError";
   }
+};
+var PluginApiValidationError = class extends Error {
   /**
-   * Resolves a grammar source into the grammar to register.
+   * The issues the schema reported.
+   */
+  issues;
+  /**
+   * The name of the method whose payload failed validation.
+   */
+  methodName;
+  /**
+   * The `manifest.id` of the providing plugin.
+   */
+  pluginId;
+  /**
+   * Creates a {@link PluginApiValidationError}.
    *
-   * @param prism - The loaded Prism module.
-   * @param grammarSource - The grammar source to resolve.
-   * @returns The resolved grammar.
+   * @param params - The parameters for the error.
    */
-  resolveGrammar(prism, grammarSource) {
-    if (typeof grammarSource === "string") {
-      return this.requirePrismLanguage(prism, grammarSource);
-    }
-    if (typeof grammarSource === "function") {
-      return grammarSource({
-        prism,
-        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)
-      });
-    }
-    return grammarSource;
+  constructor(params) {
+    super(
+      `The ${params.payloadKind} of "${params.pluginId}" API method "${params.methodName}" failed validation: ${formatIssues(params.issues)}`
+    );
+    this.name = "PluginApiValidationError";
+    this.issues = params.issues;
+    this.methodName = params.methodName;
+    this.pluginId = params.pluginId;
   }
 };
-
-// src/obsidian/constructors/get-dom-events-handlers-constructor.ts
-var get_dom_events_handlers_constructor_exports = {};
-__export(get_dom_events_handlers_constructor_exports, {
-  getDomEventsHandlersConstructor: () => getDomEventsHandlersConstructor
-});
-var import_obsidian121 = require("obsidian");
-init_async();
-init_type_guards();
-init_monkey_around_component();
-var MarkdownPreviewRendererRegisterDomEventsPatchComponent = class extends MonkeyAroundComponent {
-  domEventsHandlersConstructor = null;
-  onload() {
-    this.registerMethodPatch({
-      $object: import_obsidian121.MarkdownPreviewRenderer,
-      methodName: "registerDomEvents",
-      patchHandler: ({
-        fallback,
-        originalArguments: [, handlers]
-      }) => {
-        this.domEventsHandlersConstructor = handlers.constructor;
-        fallback();
-      }
-    });
-  }
-};
-async function getDomEventsHandlersConstructor(app) {
-  let mdFile = app.vault.getMarkdownFiles()[0];
-  let shouldDelete = false;
-  if (!mdFile) {
-    mdFile = await app.vault.create("__temp.md", "");
-    shouldDelete = true;
+function publishPluginApi(params) {
+  const pluginId = params.plugin.manifest.id;
+  const registry = getRegistry();
+  const records = registry.records[pluginId] ?? [];
+  registry.records[pluginId] = records;
+  if (records.some((record2) => record2.apiVersion === params.apiVersion)) {
+    throw new Error(`The plugin "${pluginId}" has already published the API version "${params.apiVersion}".`);
   }
-  try {
-    var _stack = [];
-    try {
-      const patch = __using(_stack, new MarkdownPreviewRendererRegisterDomEventsPatchComponent());
-      patch.load();
-      const leaf = app.workspace.getLeaf(true);
-      await leaf.openFile(mdFile, {
-        active: true,
-        state: { mode: "preview" }
+  const record = {
+    api: params.api,
+    apiVersion: params.apiVersion,
+    contract: params.contract ?? {},
+    isRevoked: false,
+    pluginId
+  };
+  records.push(record);
+  notifySubscribers();
+  params.plugin.register(() => {
+    revokeRecord(record);
+  });
+}
+function watchPluginApi(params) {
+  const ref = new PluginApiRefImpl(params);
+  const unsubscribe = subscribe(() => {
+    ref.refresh();
+  });
+  params.component.register(unsubscribe);
+  ref.refresh();
+  return ref;
+}
+function checkIsPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function checkMatchesContractShape(record, consumerContract) {
+  const contract = consumerContract ?? record.contract;
+  return Object.keys(contract).every((methodName) => typeof getMember(record.api, methodName) === "function");
+}
+function createMethodWrapper(params) {
+  return function pluginApiMethod(...$arguments) {
+    const method = castTo(getMember(params.target, params.propertyKey));
+    const methodContract = params.methodContract;
+    if (methodContract === void 0 || !getPluginApiDebugger().enabled) {
+      return method.apply(params.target, $arguments);
+    }
+    if (methodContract.input) {
+      validatePayload({
+        methodName: params.methodName,
+        payloadKind: "input" /* Input */,
+        pluginId: params.pluginId,
+        schema: methodContract.input,
+        value: $arguments
       });
-      try {
-        await retryWithTimeout({
-          operationFunction: () => patch.domEventsHandlersConstructor !== null,
-          operationName: "getDomEventsHandlersConstructor"
+    }
+    const returnValue = method.apply(params.target, $arguments);
+    const outputSchema = methodContract.output;
+    if (!outputSchema) {
+      return returnValue;
+    }
+    if (checkIsPromiseLike(returnValue)) {
+      return returnValue.then((resolvedValue) => {
+        validatePayload({
+          methodName: params.methodName,
+          payloadKind: "output" /* Output */,
+          pluginId: params.pluginId,
+          schema: outputSchema,
+          value: resolvedValue
         });
-      } finally {
-        leaf.detach();
+        return resolvedValue;
+      });
+    }
+    validatePayload({
+      methodName: params.methodName,
+      payloadKind: "output" /* Output */,
+      pluginId: params.pluginId,
+      schema: outputSchema,
+      value: returnValue
+    });
+    return returnValue;
+  };
+}
+function createRevocableHandle(record, consumerContract) {
+  const contract = consumerContract ?? record.contract;
+  const methodCache = /* @__PURE__ */ new Map();
+  return new Proxy(record.api, {
+    get(target, propertyKey) {
+      if (record.isRevoked) {
+        throw new PluginApiRevokedError(record.pluginId);
       }
-      assertNonNullable(patch.domEventsHandlersConstructor, "Failed to get register dom events handlers constructor");
-      return patch.domEventsHandlersConstructor;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      __callDispose(_stack, _error, _hasError);
+      const value = getMember(target, propertyKey);
+      if (typeof value !== "function") {
+        return value;
+      }
+      let method = methodCache.get(propertyKey);
+      if (method === void 0) {
+        method = createMethodWrapper({
+          methodContract: typeof propertyKey === "string" ? contract[propertyKey] : void 0,
+          methodName: String(propertyKey),
+          pluginId: record.pluginId,
+          propertyKey,
+          target
+        });
+        methodCache.set(propertyKey, method);
+      }
+      return method;
     }
-  } finally {
-    if (shouldDelete) {
-      await trashSafe(app, mdFile);
+  });
+}
+function formatIssues(issues) {
+  return issues.map((issue) => {
+    const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
+    return path ? `${path}: ${issue.message}` : issue.message;
+  }).join("; ");
+}
+function getLiveRecords(pluginId) {
+  return (getRegistry().records[pluginId] ?? []).filter((record) => !record.isRevoked);
+}
+function getMember(api, methodName) {
+  return Reflect.get(api, methodName);
+}
+function getPluginApiDebugger() {
+  return getLibDebugger(PLUGIN_API_DEBUGGER_NAMESPACE);
+}
+function getRegistry() {
+  const wrapper = getObsidianDevUtilsState(PLUGIN_API_REGISTRY_STATE_KEY, {});
+  const registry = wrapper.value;
+  registry.records ??= {};
+  registry.subscribers ??= [];
+  return castTo(registry);
+}
+function notifySubscribers() {
+  for (const subscriber of snapshot(getRegistry().subscribers)) {
+    subscriber();
+  }
+}
+function resolveUnavailabilityReason(params) {
+  if (!Object.hasOwn(params.app.plugins.manifests, params.pluginId)) {
+    return "notInstalled" /* NotInstalled */;
+  }
+  if (!params.app.plugins.enabledPlugins.has(params.pluginId)) {
+    return "notEnabled" /* NotEnabled */;
+  }
+  const records = getLiveRecords(params.pluginId);
+  if (records.length === 0) {
+    return "notPublished" /* NotPublished */;
+  }
+  if (records.every((record) => !(0, import_compare_versions3.satisfies)(record.apiVersion, params.apiVersionRange))) {
+    return "versionMismatch" /* VersionMismatch */;
+  }
+  return "shapeMismatch" /* ShapeMismatch */;
+}
+function revokeRecord(record) {
+  record.isRevoked = true;
+  const registry = getRegistry();
+  const records = registry.records[record.pluginId];
+  if (records) {
+    registry.records[record.pluginId] = records.filter((candidate) => candidate !== record);
+  }
+  notifySubscribers();
+}
+function selectRecord(params) {
+  const candidates = getLiveRecords(params.pluginId).filter((record) => (0, import_compare_versions3.satisfies)(record.apiVersion, params.apiVersionRange)).filter((record) => checkMatchesContractShape(record, params.contract)).sort((a2, b) => (0, import_compare_versions3.compareVersions)(b.apiVersion, a2.apiVersion));
+  return candidates[0] ?? null;
+}
+function subscribe(subscriber) {
+  const registry = getRegistry();
+  registry.subscribers.push(subscriber);
+  return () => {
+    const index2 = registry.subscribers.indexOf(subscriber);
+    if (index2 !== -1) {
+      registry.subscribers.splice(index2, 1);
     }
+  };
+}
+function validatePayload(params) {
+  const result = params.schema["~standard"].validate(params.value);
+  if (checkIsPromiseLike(result)) {
+    invokeAsyncSafely(async () => {
+      const asyncResult = await result;
+      if (asyncResult.issues) {
+        getPluginApiDebugger()(
+          'Asynchronous validation of the %s of "%s" API method "%s" failed: %s',
+          params.payloadKind,
+          params.pluginId,
+          params.methodName,
+          formatIssues(asyncResult.issues)
+        );
+      }
+    });
+    return;
+  }
+  if (result.issues) {
+    throw new PluginApiValidationError({
+      issues: result.issues,
+      methodName: params.methodName,
+      payloadKind: params.payloadKind,
+      pluginId: params.pluginId
+    });
   }
 }
 
-// src/__merged.ts
-init_css_class();
-
-// src/obsidian/data-handler.ts
-var data_handler_exports = {};
-__export(data_handler_exports, {
-  PluginDataHandler: () => PluginDataHandler
-});
-var PluginDataHandler = class {
+// src/obsidian/components/settings-migration-component.ts
+init_component_ex();
+var SettingsMigrationComponent = class extends ComponentEx {
+  apiVersionRange;
+  app;
+  contract;
+  getProposedSettings;
+  isProposing = false;
+  pluginSettingsComponent;
+  providerPluginId;
+  retireProposedSettings;
+  sourcePluginId;
   /**
-   * Creates a new plugin data handler.
+   * Creates an instance of {@link SettingsMigrationComponent}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.apiVersionRange = params.apiVersionRange;
+    this.app = params.app;
+    this.contract = params.contract;
+    this.getProposedSettings = params.getProposedSettings;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
+    this.providerPluginId = params.providerPluginId;
+    this.retireProposedSettings = params.retireProposedSettings;
+    this.sourcePluginId = params.sourcePluginId;
+  }
+  /**
+   * Loads the component, wiring both edges that can make an offer possible.
+   */
+  onload() {
+    const ref = watchPluginApi(normalizeOptionalProperties({
+      apiVersionRange: this.apiVersionRange,
+      app: this.app,
+      component: this,
+      contract: this.contract,
+      pluginId: this.providerPluginId
+    }));
+    registerAsyncEvent(
+      this,
+      ref.on("change", () => {
+        this.handleChange(ref);
+      })
+    );
+    registerAsyncEvent(
+      this,
+      this.pluginSettingsComponent.on("loadSettings", () => {
+        this.handleChange(ref);
+      })
+    );
+    this.handleChange(ref);
+  }
+  handleChange(ref) {
+    invokeAsyncSafely(async () => {
+      await this.propose(ref.value);
+    });
+  }
+  async propose(api) {
+    const proposedSettings = this.getProposedSettings();
+    if (!api || this.isProposing || proposedSettings === null) {
+      return;
+    }
+    this.isProposing = true;
+    try {
+      const result = await api.migrateSettings({
+        proposedSettings,
+        sourcePluginId: this.sourcePluginId
+      });
+      if (result.isApplied) {
+        await this.retireProposedSettings();
+      }
+    } finally {
+      this.isProposing = false;
+    }
+  }
+};
+
+// src/obsidian/components/syntax-highlighting-component.ts
+var syntax_highlighting_component_exports = {};
+__export(syntax_highlighting_component_exports, {
+  SyntaxHighlightingComponent: () => SyntaxHighlightingComponent
+});
+init_error();
+init_component_ex();
+var SyntaxHighlightingComponent = class extends ComponentEx {
+  /**
+   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerCodeBlockLanguage({
+   *   editorMode: 'text/typescript',
+   *   language: 'my-language',
+   *   prismGrammar: 'typescript'
+   * });
+   * ```
+   */
+  async registerCodeBlockLanguage(params) {
+    const {
+      editorMode,
+      language,
+      prismGrammar
+    } = params;
+    this.ensureLoaded();
+    if (prismGrammar !== void 0) {
+      await this.registerPrismLanguage({
+        grammar: prismGrammar,
+        language
+      });
+    }
+    this.ensureLoaded();
+    const previousModeFactory = window.CodeMirror.modes[language];
+    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));
+    this.register(() => {
+      if (previousModeFactory !== void 0) {
+        window.CodeMirror.modes[language] = previousModeFactory;
+        return;
+      }
+      delete window.CodeMirror.modes[language];
+    });
+  }
+  /**
+   * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+   * {@link CodeHighlighterComponent} settings field.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerPrismLanguage({
+   *   grammar: {
+   *     keyword: /\bfoo\b/
+   *   },
+   *   language: 'my-language'
+   * });
+   * ```
+   */
+  async registerPrismLanguage(params) {
+    const {
+      grammar,
+      language
+    } = params;
+    this.ensureLoaded();
+    const prism = await loadPrism();
+    this.ensureLoaded();
+    const previousGrammar = prism.languages[language];
+    prism.languages[language] = this.resolveGrammar(prism, grammar);
+    this.register(() => {
+      if (previousGrammar !== void 0) {
+        prism.languages[language] = previousGrammar;
+        return;
+      }
+      delete prism.languages[language];
+    });
+  }
+  /**
+   * Returns the grammar of an already registered Prism language.
+   *
+   * @param prism - The loaded Prism module.
+   * @param language - The language to look up.
+   * @returns The grammar of the language.
+   * @throws An {@link Error} if the language is not registered.
+   */
+  requirePrismLanguage(prism, language) {
+    return prism.languages[language] ?? throwExpression(new Error(`Prism language "${language}" is not registered.`));
+  }
+  /**
+   * Resolves a grammar source into the grammar to register.
+   *
+   * @param prism - The loaded Prism module.
+   * @param grammarSource - The grammar source to resolve.
+   * @returns The resolved grammar.
+   */
+  resolveGrammar(prism, grammarSource) {
+    if (typeof grammarSource === "string") {
+      return this.requirePrismLanguage(prism, grammarSource);
+    }
+    if (typeof grammarSource === "function") {
+      return grammarSource({
+        prism,
+        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)
+      });
+    }
+    return grammarSource;
+  }
+};
+
+// src/obsidian/constructors/get-dom-events-handlers-constructor.ts
+var get_dom_events_handlers_constructor_exports = {};
+__export(get_dom_events_handlers_constructor_exports, {
+  getDomEventsHandlersConstructor: () => getDomEventsHandlersConstructor
+});
+var import_obsidian121 = require("obsidian");
+init_async();
+init_type_guards();
+init_monkey_around_component();
+var MarkdownPreviewRendererRegisterDomEventsPatchComponent = class extends MonkeyAroundComponent {
+  domEventsHandlersConstructor = null;
+  onload() {
+    this.registerMethodPatch({
+      $object: import_obsidian121.MarkdownPreviewRenderer,
+      methodName: "registerDomEvents",
+      patchHandler: ({
+        fallback,
+        originalArguments: [, handlers]
+      }) => {
+        this.domEventsHandlersConstructor = handlers.constructor;
+        fallback();
+      }
+    });
+  }
+};
+async function getDomEventsHandlersConstructor(app) {
+  let mdFile = app.vault.getMarkdownFiles()[0];
+  let shouldDelete = false;
+  if (!mdFile) {
+    mdFile = await app.vault.create("__temp.md", "");
+    shouldDelete = true;
+  }
+  try {
+    var _stack = [];
+    try {
+      const patch = __using(_stack, new MarkdownPreviewRendererRegisterDomEventsPatchComponent());
+      patch.load();
+      const leaf = app.workspace.getLeaf(true);
+      await leaf.openFile(mdFile, {
+        active: true,
+        state: { mode: "preview" }
+      });
+      try {
+        await retryWithTimeout({
+          operationFunction: () => patch.domEventsHandlersConstructor !== null,
+          operationName: "getDomEventsHandlersConstructor"
+        });
+      } finally {
+        leaf.detach();
+      }
+      assertNonNullable(patch.domEventsHandlersConstructor, "Failed to get register dom events handlers constructor");
+      return patch.domEventsHandlersConstructor;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  } finally {
+    if (shouldDelete) {
+      await trashSafe(app, mdFile);
+    }
+  }
+}
+
+// src/__merged.ts
+init_css_class();
+
+// src/obsidian/data-handler.ts
+var data_handler_exports = {};
+__export(data_handler_exports, {
+  PluginDataHandler: () => PluginDataHandler
+});
+var PluginDataHandler = class {
+  /**
+   * Creates a new plugin data handler.
    *
    * @param plugin - The plugin instance.
    */
@@ -33592,1604 +34058,1225 @@ var MINIMIZE_ICON_ID = "minus";
 var RESTORE_ICON_ID = "maximize-2";
 var CANCEL_ICON_ID = "x";
 var NAVIGATION_KEYS = /* @__PURE__ */ new Set([
-  "ArrowDown",
-  "ArrowLeft",
-  "ArrowRight",
-  "ArrowUp",
-  "End",
-  "Home",
-  "PageDown",
-  "PageUp"
-]);
-var MODIFIER_KEYS = /* @__PURE__ */ new Set([
-  "Alt",
-  "Control",
-  "Meta",
-  "Shift"
-]);
-var peekLockEntries = /* @__PURE__ */ new Set();
-var beeper = new Beeper();
-var PeekLockComponent = class extends MonkeyAroundComponent {
-  /**
-   * Constructs a new instance.
-   *
-   * @param app - The app whose settings modal is guarded and whose windows suppress input while locked.
-   */
-  constructor(app) {
-    super();
-    this.app = app;
-  }
-  app;
-  /**
-   * Registers the `open` patches and the input suppressors.
-   */
-  onload() {
-    super.onload();
-    this.registerMethodPatch({
-      $object: import_obsidian132.Modal.prototype,
-      methodName: "open",
-      patchHandler: ({ fallback, originalThis }) => {
-        blockOrFallback(originalThis, fallback);
-      }
-    });
-    this.registerMethodPatch({
-      $object: this.app.setting,
-      methodName: "open",
-      patchHandler: ({ fallback, originalThis }) => {
-        blockOrFallback(originalThis, fallback);
-      }
-    });
-    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
-    allWindowsEventComponent.registerAllWindowsDomEvent({
-      callback: suppressKeydownWhilePeekLocked,
-      options: { capture: true },
-      type: "keydown"
-    });
-    allWindowsEventComponent.registerAllWindowsDomEvent({
-      callback: suppressWhilePeekLocked,
-      options: { capture: true },
-      type: "beforeinput"
-    });
-    allWindowsEventComponent.registerAllWindowsDomEvent({
-      callback: suppressWhilePeekLocked,
-      options: { capture: true },
-      type: "contextmenu"
-    });
-  }
-};
-var MinimizableModal = class {
-  /**
-   * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).
-   */
-  modal;
-  /**
-   * Whether the modal is currently minimized.
-   *
-   * @returns `true` if the modal is currently minimized, `false` otherwise.
-   */
-  get isMinimized() {
-    return this.isMinimizedValue;
-  }
-  /**
-   * Patches the wrapped modal's `onClose` to run cleanup. Persists for the wrapper's whole life (a
-   * modal can be reopened, so the patch must survive each close), hence a dedicated component that is
-   * never unloaded — distinct from `peekLockComponent`, whose patches live only while minimized.
-   * Exposed to subclasses so they can register additional lifetime-scoped patches on the wrapper.
-   */
-  closePatchComponent = new MonkeyAroundComponent();
-  isMinimizedValue = false;
-  minimizeButtonEl;
-  minimizedBarEl = null;
-  peekLockComponent = null;
-  peekLockEntry = null;
-  shouldMinimizeOnClickOutside;
-  shouldShowCancelButton;
-  /**
-   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
-   *
-   * @param modal - The modal instance to make minimizable.
-   * @param options - Options controlling the minimized bar. See {@link MinimizableModalConstructorOptions}.
-   */
-  constructor(modal, options = {}) {
-    this.modal = modal;
-    this.shouldMinimizeOnClickOutside = options.shouldMinimizeOnClickOutside ?? true;
-    this.shouldShowCancelButton = options.shouldShowCancelButton ?? true;
-    addPluginCssClasses(modal.containerEl, ["minimizable-modal" /* MinimizableModal */]);
-    this.minimizeButtonEl = this.createMinimizeButton();
-    if (this.shouldMinimizeOnClickOutside) {
-      modal.containerEl.addEventListener("click", ($event) => {
-        this.handleContainerClick($event);
-      }, { capture: true });
-    }
-    this.closePatchComponent.load();
-    this.patchOnClose(modal);
-  }
-  /**
-   * Minimizes the modal: hides the modal and its backdrop, shows a floating bar with a restore button,
-   * and puts the app into the peek-only lock. A no-op if the modal is already minimized.
-   */
-  minimize() {
-    if (this.isMinimizedValue) {
-      return;
-    }
-    this.isMinimizedValue = true;
-    this.minimizeButtonEl.hide();
-    this.modal.containerEl.hide();
-    this.modal.app.keymap.popScope(this.modal.scope);
-    this.minimizedBarEl = this.createMinimizedBar();
-    this.enablePeekLock(this.minimizedBarEl);
-  }
-  /**
-   * Restores the modal from the minimized state, removing the floating bar and lifting the peek-only
-   * lock. A no-op if the modal is not minimized.
-   */
-  restore() {
-    if (!this.isMinimizedValue) {
-      return;
-    }
-    this.isMinimizedValue = false;
-    this.disablePeekLock();
-    this.removeMinimizedBar();
-    this.modal.app.keymap.pushScope(this.modal.scope);
-    this.modal.containerEl.show();
-    this.minimizeButtonEl.show();
-  }
-  createMinimizeButton() {
-    const buttonEl = this.modal.modalEl.createEl("button", { cls: "minimize-button" /* MinimizeButton */ });
-    (0, import_obsidian132.setIcon)(buttonEl, MINIMIZE_ICON_ID);
-    buttonEl.addEventListener("click", () => {
-      this.minimize();
-    });
-    return buttonEl;
-  }
-  createMinimizedBar() {
-    const barEl = this.modal.containerEl.ownerDocument.body.createDiv();
-    addPluginCssClasses(barEl, ["minimized-modal-bar" /* MinimizedModalBar */]);
-    barEl.createSpan({
-      cls: "minimized-modal-bar-title" /* MinimizedModalBarTitle */,
-      text: this.modal.titleEl.textContent
-    });
-    const restoreButtonEl = barEl.createEl("button", { cls: "restore-button" /* RestoreButton */ });
-    (0, import_obsidian132.setIcon)(restoreButtonEl, RESTORE_ICON_ID);
-    if (this.shouldShowCancelButton) {
-      const cancelButtonEl = barEl.createEl("button", { cls: "cancel-button" /* CancelButton */ });
-      (0, import_obsidian132.setIcon)(cancelButtonEl, CANCEL_ICON_ID);
-      (0, import_obsidian132.setTooltip)(cancelButtonEl, "Cancel");
-      cancelButtonEl.addEventListener("click", ($event) => {
-        $event.stopPropagation();
-        this.modal.close();
-      });
-    }
-    barEl.addEventListener("click", () => {
-      this.restore();
-    });
-    barEl.addEventListener("animationend", () => {
-      barEl.removeClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
-    });
-    return barEl;
-  }
-  disablePeekLock() {
-    if (!this.peekLockEntry) {
-      return;
-    }
-    peekLockEntries.delete(this.peekLockEntry);
-    this.peekLockEntry = null;
-    this.peekLockComponent?.unload();
-    this.peekLockComponent = null;
-  }
-  enablePeekLock(barEl) {
-    this.peekLockEntry = {
-      barEl,
-      flash: () => {
-        this.flashBar(barEl);
-      },
-      innerModal: this.modal
-    };
-    peekLockEntries.add(this.peekLockEntry);
-    this.peekLockComponent = new PeekLockComponent(this.modal.app);
-    this.peekLockComponent.load();
-  }
-  flashBar(barEl) {
-    barEl.removeClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
-    barEl.getBoundingClientRect();
-    barEl.addClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
-  }
-  handleClose() {
-    this.disablePeekLock();
-    this.removeMinimizedBar();
-    this.isMinimizedValue = false;
-  }
-  handleContainerClick($event) {
-    if (this.isMinimizedValue) {
-      return;
-    }
-    if ($event.composedPath().includes(this.modal.modalEl)) {
-      return;
-    }
-    if ($event.target === this.modal.containerEl) {
-      return;
-    }
-    $event.preventDefault();
-    $event.stopImmediatePropagation();
-    this.minimize();
-  }
-  patchOnClose(modal) {
-    this.closePatchComponent.registerMethodPatch({
-      $object: modal,
-      methodName: "onClose",
-      patchHandler: ({ fallback }) => {
-        fallback();
-        this.handleClose();
-      }
-    });
-  }
-  removeMinimizedBar() {
-    this.minimizedBarEl?.remove();
-    this.minimizedBarEl = null;
-  }
-};
-function blockEvent($event) {
-  $event.preventDefault();
-  $event.stopImmediatePropagation();
-  signalBlockedAttempt();
-}
-function blockOrFallback(modal, fallback) {
-  if (shouldBlockOpen(modal)) {
-    signalBlockedAttempt();
-    return;
-  }
-  fallback();
-}
-function flashMinimizedBars() {
-  for (const entry of peekLockEntries) {
-    entry.flash();
-  }
-}
-function isMinimizedInnerModal(modal) {
-  for (const entry of peekLockEntries) {
-    if (entry.innerModal === modal) {
-      return true;
-    }
-  }
-  return false;
-}
-function isPeekAllowedKey($event) {
-  if (NAVIGATION_KEYS.has($event.key)) {
-    return !$event.shiftKey;
-  }
-  return MODIFIER_KEYS.has($event.key);
-}
-function isPeekLocked() {
-  for (const entry of peekLockEntries) {
-    if (!entry.barEl.isConnected) {
-      peekLockEntries.delete(entry);
-    }
-  }
-  return peekLockEntries.size > 0;
-}
-function shouldBlockOpen(modal) {
-  return isPeekLocked() && !isMinimizedInnerModal(modal);
-}
-function signalBlockedAttempt() {
-  flashMinimizedBars();
-  beeper.beep();
-}
-function suppressKeydownWhilePeekLocked($event) {
-  if (!isPeekLocked() || isPeekAllowedKey($event)) {
-    return;
-  }
-  blockEvent($event);
-}
-function suppressWhilePeekLocked($event) {
-  if (!isPeekLocked()) {
-    return;
-  }
-  blockEvent($event);
-}
-
-// src/obsidian/modals/modal-command-builder.ts
-var modal_command_builder_exports = {};
-__export(modal_command_builder_exports, {
-  ModalCommandBuilder: () => ModalCommandBuilder,
-  ModalCommandsRenderMode: () => ModalCommandsRenderMode
-});
-var import_obsidian133 = require("obsidian");
-init_css_class();
-init_plugin_context();
-var KEYS_MAP = /* @__PURE__ */ new Map([
-  ["Enter", "\u21B5"],
-  ["UpDown", "\u2191\u2193"]
-]);
-var ModalCommandsRenderMode = /* @__PURE__ */ ((ModalCommandsRenderMode2) => {
-  ModalCommandsRenderMode2["Buttons"] = "buttons";
-  ModalCommandsRenderMode2["Instructions"] = "instructions";
-  return ModalCommandsRenderMode2;
-})(ModalCommandsRenderMode || {});
-var NOOP_MODAL_COMMANDS = {
-  refresh: () => {
-  }
-};
-var ModalCommandBuilder = class {
-  entries = [];
-  /**
-   * Adds an interactive checkbox to the control strip, bound to a modifier+key shortcut that toggles it.
-   *
-   * @param command - The checkbox command to add.
-   * @returns The builder instance for chaining.
-   */
-  addCheckbox(command) {
-    this.entries.push({
-      checkIsAvailable: command.checkIsAvailable ?? null,
-      commandText: this.buildCommandText(command),
-      initButton: (buttonEl, scope) => {
-        const checkboxEl = createEl("input", { type: "checkbox" });
-        initCheckbox(checkboxEl, scope);
-        buttonEl.addEventListener("click", () => {
-          toggleCheckbox(checkboxEl);
-        });
-        return {
-          checkIsOn: () => checkboxEl.checked,
-          setDisabled: (isDisabled) => {
-            checkboxEl.disabled = isDisabled;
-            buttonEl.disabled = isDisabled;
-          }
-        };
-      },
-      initInstruction: (purposeEl, scope) => {
-        const checkboxEl = purposeEl.createEl("input", { type: "checkbox" });
-        addPluginCssClasses(checkboxEl, "modal-command-control" /* ModalCommandControl */);
-        return initCheckbox(checkboxEl, scope);
-      },
-      isDropDown: false,
-      purpose: command.purpose,
-      registerScope: null
-    });
-    return this;
-    function initCheckbox(checkboxEl, scope) {
-      command.onInit(checkboxEl);
-      checkboxEl.addEventListener("change", () => {
-        command.onChange(checkboxEl.checked);
-      });
-      scope.register(command.modifiers ?? [], command.key, () => {
-        toggleCheckbox(checkboxEl);
-      });
-      return {
-        setDisabled: (isDisabled) => {
-          checkboxEl.disabled = isDisabled;
-        }
-      };
-    }
-  }
-  /**
-   * Adds a dropdown to the control strip, bound to a modifier+key shortcut that cycles through its
-   * options.
-   *
-   * @param command - The dropdown command to add.
-   * @returns The builder instance for chaining.
-   */
-  addDropDown(command) {
-    this.entries.push({
-      checkIsAvailable: command.checkIsAvailable ?? null,
-      commandText: this.buildCommandText(command),
-      initButton: null,
-      initInstruction: (purposeEl, scope) => {
-        const dropdownComponent = new import_obsidian133.DropdownComponent(purposeEl);
-        addPluginCssClasses(dropdownComponent.selectEl, "modal-command-control" /* ModalCommandControl */);
-        command.onInit(dropdownComponent);
-        dropdownComponent.onChange((value) => {
-          command.onChange(value);
-        });
-        scope.register(command.modifiers ?? [], command.key, () => {
-          if (dropdownComponent.disabled) {
-            return;
-          }
-          const selectEl = dropdownComponent.selectEl;
-          selectEl.selectedIndex = (selectEl.selectedIndex + 1) % selectEl.options.length;
-          selectEl.trigger("change");
-        });
-        return {
-          setDisabled: (isDisabled) => {
-            dropdownComponent.setDisabled(isDisabled);
-          }
-        };
-      },
-      isDropDown: true,
-      purpose: command.purpose,
-      registerScope: null
-    });
-    return this;
-  }
-  /**
-   * Adds a keyboard command to the control strip. When {@link KeyboardCommand.onKey} is provided, its
-   * handler is registered with the modal scope; otherwise the command is a hint only.
-   *
-   * @param command - The keyboard command to add.
-   * @returns The builder instance for chaining.
-   */
-  addKeyboardCommand(command) {
-    const checkIsOn = command.checkIsOn ?? (() => false);
-    const onActivate = command.onActivate ?? null;
-    const onKey = command.onKey?.bind(command) ?? null;
-    this.entries.push({
-      checkIsAvailable: command.checkIsAvailable ?? null,
-      commandText: this.buildCommandText(command),
-      initButton: onActivate ? (buttonEl) => {
-        buttonEl.addEventListener("click", ($event) => {
-          onActivate($event);
-        });
-        return {
-          checkIsOn,
-          setDisabled: (isDisabled) => {
-            buttonEl.disabled = isDisabled;
-          }
-        };
-      } : null,
-      initInstruction: null,
-      isDropDown: false,
-      purpose: command.purpose,
-      registerScope: onKey ? (scope) => {
-        scope.register(command.modifiers ?? [], command.key, onKey);
-      } : null
-    });
-    return this;
-  }
-  /**
-   * Applies the accumulated commands to a modal. Always registers the essential navigation/action key
-   * handlers; only renders the control strip and registers the option-toggle shortcuts when
-   * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.
-   *
-   * @param target - The modal, or the bare element + scope, to apply the commands to.
-   * @param options - The build options.
-   * @returns A handle whose {@link ModalCommands.refresh} re-states every rendered control.
-   */
-  build(target, options = {}) {
-    const {
-      renderMode = "instructions" /* Instructions */,
-      shouldShowInstructions = true
-    } = options;
-    const scope = target.scope;
-    for (const entry of this.entries) {
-      entry.registerScope?.(scope);
-    }
-    if (!shouldShowInstructions) {
-      return NOOP_MODAL_COMMANDS;
-    }
-    const refreshers = renderMode === "buttons" /* Buttons */ ? this.renderButtons(target, scope) : this.renderInstructions(target, scope);
-    const modalCommands = {
-      refresh: () => {
-        for (const refreshControl of refreshers) {
-          refreshControl();
-        }
-      }
-    };
-    modalCommands.refresh();
-    return modalCommands;
-  }
-  buildCommandText(command) {
-    let commandText = KEYS_MAP.get(command.key) ?? command.key;
-    for (const modifier of command.modifiers ?? []) {
-      commandText = `${this.getModifierString(modifier)} ${commandText}`;
-    }
-    return commandText;
-  }
-  getModifierString(modifier) {
-    switch (modifier) {
-      case "Alt": {
-        return "alt";
-      }
-      case "Ctrl": {
-        return "ctrl";
-      }
-      case "Meta": {
-        return import_obsidian133.Platform.isMacOS ? "cmd" : "win";
-      }
-      case "Mod": {
-        return import_obsidian133.Platform.isMacOS ? "cmd" : "ctrl";
-      }
-      case "Shift": {
-        return "shift";
-      }
-      default: {
-        return modifier;
-      }
-    }
-  }
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "ArrowUp",
+  "End",
+  "Home",
+  "PageDown",
+  "PageUp"
+]);
+var MODIFIER_KEYS = /* @__PURE__ */ new Set([
+  "Alt",
+  "Control",
+  "Meta",
+  "Shift"
+]);
+var peekLockEntries = /* @__PURE__ */ new Set();
+var beeper = new Beeper();
+var PeekLockComponent = class extends MonkeyAroundComponent {
   /**
-   * Resolves the element a self-created strip is appended to.
-   *
-   * A {@link Modal} carries both `modalEl` and a `containerEl` that is the OUTER `.modal-container`, so
-   * `modalEl` has to win — otherwise the strip lands outside the modal frame. Discriminated with `in`
-   * rather than a property read, because tests hand `build` a `strictProxy` mock whose `get` trap throws
-   * on unmocked members.
+   * Constructs a new instance.
    *
-   * @param target - The build target.
-   * @returns The element to append the strip to.
+   * @param app - The app whose settings modal is guarded and whose windows suppress input while locked.
    */
-  getStripContainerEl(target) {
-    return "modalEl" in target ? target.modalEl : target.containerEl;
-  }
-  renderButtons(target, scope) {
-    const stripEl = this.getStripContainerEl(target).createDiv();
-    addPluginCssClasses(stripEl, "modal-commands" /* ModalCommands */);
-    const refreshers = [];
-    for (const entry of this.entries) {
-      if (entry.isDropDown) {
-        throw new Error(`Cannot render dropdown command "${entry.purpose}" as a button: a control that cycles has no button form.`);
-      }
-      if (!entry.initButton) {
-        continue;
-      }
-      const buttonEl = stripEl.createEl("button", { type: "button" });
-      addPluginCssClasses(buttonEl, "modal-command" /* ModalCommand */);
-      buttonEl.createSpan({ text: entry.purpose });
-      if (!import_obsidian133.Platform.isMobile) {
-        const hotkeyEl = buttonEl.createSpan({ text: entry.commandText });
-        addPluginCssClasses(hotkeyEl, "modal-command-hotkey" /* ModalCommandHotkey */);
-      }
-      buttonEl.addEventListener("mousedown", ($event) => {
-        $event.preventDefault();
-      });
-      const buttonControl = entry.initButton(buttonEl, scope);
-      const checkIsAvailable = entry.checkIsAvailable;
-      refreshers.push(() => {
-        if (checkIsAvailable) {
-          buttonControl.setDisabled(!checkIsAvailable());
-        }
-        const isOn = buttonControl.checkIsOn();
-        buttonEl.toggleClass("is-active" /* IsActive */, isOn);
-        buttonEl.setAttribute("aria-pressed", String(isOn));
-      });
-    }
-    return refreshers;
+  constructor(app) {
+    super();
+    this.app = app;
   }
-  renderInstructions(target, scope) {
-    const instructions = this.entries.map((entry) => ({
-      command: entry.commandText,
-      entry,
-      purpose: entry.purpose
-    }));
-    const purposeEls = "setInstructions" in target ? this.renderNativeInstructions(target, instructions) : this.renderOwnInstructions(this.getStripContainerEl(target), instructions);
-    const refreshers = [];
-    for (const [index2, instruction] of instructions.entries()) {
-      const purposeEl = purposeEls[index2];
-      if (!purposeEl) {
-        continue;
+  app;
+  /**
+   * Registers the `open` patches and the input suppressors.
+   */
+  onload() {
+    super.onload();
+    this.registerMethodPatch({
+      $object: import_obsidian132.Modal.prototype,
+      methodName: "open",
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
       }
-      const instructionControl = instruction.entry.initInstruction?.(purposeEl, scope);
-      const checkIsAvailable = instruction.entry.checkIsAvailable;
-      if (instructionControl && checkIsAvailable) {
-        refreshers.push(() => {
-          instructionControl.setDisabled(!checkIsAvailable());
-        });
+    });
+    this.registerMethodPatch({
+      $object: this.app.setting,
+      methodName: "open",
+      patchHandler: ({ fallback, originalThis }) => {
+        blockOrFallback(originalThis, fallback);
       }
-    }
-    return refreshers;
+    });
+    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressKeydownWhilePeekLocked,
+      options: { capture: true },
+      type: "keydown"
+    });
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressWhilePeekLocked,
+      options: { capture: true },
+      type: "beforeinput"
+    });
+    allWindowsEventComponent.registerAllWindowsDomEvent({
+      callback: suppressWhilePeekLocked,
+      options: { capture: true },
+      type: "contextmenu"
+    });
   }
+};
+var MinimizableModal = class {
   /**
-   * Renders through Obsidian's own instruction bar, the way every {@link SuggestModal} consumer has always
-   * had it.
+   * The wrapped modal. Open, close, and populate it as usual (e.g. `minimizable.modal.open()`).
+   */
+  modal;
+  /**
+   * Whether the modal is currently minimized.
    *
-   * @param modal - The suggest modal.
-   * @param instructions - The instructions to render.
-   * @returns The purpose element of each rendered instruction.
+   * @returns `true` if the modal is currently minimized, `false` otherwise.
    */
-  renderNativeInstructions(modal, instructions) {
-    modal.setInstructions(instructions);
-    return [...modal.instructionsEl.findAll(".prompt-instruction > span:nth-child(2)")];
+  get isMinimized() {
+    return this.isMinimizedValue;
   }
   /**
-   * Renders an instruction bar of the builder's own, for a host that has none.
-   *
-   * The markup mirrors what `setInstructions` produces — including
-   * {@link CssClass.PromptInstructionCommand} on the key hint, which is not decoration: Obsidian's rule
-   * for that class is what supplies the hint's bold weight and the `margin-inline-end` separating it
-   * from the purpose text. Every class here is unscoped in the app's stylesheet, so all of it reaches a
-   * plain {@link Modal} as readily as it reaches the quick switcher.
+   * Patches the wrapped modal's `onClose` to run cleanup. Persists for the wrapper's whole life (a
+   * modal can be reopened, so the patch must survive each close), hence a dedicated component that is
+   * never unloaded — distinct from `peekLockComponent`, whose patches live only while minimized.
+   * Exposed to subclasses so they can register additional lifetime-scoped patches on the wrapper.
+   */
+  closePatchComponent = new MonkeyAroundComponent();
+  isMinimizedValue = false;
+  minimizeButtonEl;
+  minimizedBarEl = null;
+  peekLockComponent = null;
+  peekLockEntry = null;
+  shouldMinimizeOnClickOutside;
+  shouldShowCancelButton;
+  /**
+   * Wraps the given modal, adding a minimize button and wiring up cleanup on close.
    *
-   * @param containerEl - The element to append the bar to.
-   * @param instructions - The instructions to render.
-   * @returns The purpose element of each rendered instruction.
+   * @param modal - The modal instance to make minimizable.
+   * @param options - Options controlling the minimized bar. See {@link MinimizableModalConstructorOptions}.
    */
-  renderOwnInstructions(containerEl, instructions) {
-    const instructionsEl = containerEl.createDiv("prompt-instructions" /* PromptInstructions */);
-    addPluginCssClasses(instructionsEl, "modal-commands" /* ModalCommands */);
-    return instructions.map((instruction) => {
-      const instructionEl = instructionsEl.createDiv("prompt-instruction" /* PromptInstruction */);
-      instructionEl.createSpan({ cls: "prompt-instruction-command" /* PromptInstructionCommand */, text: instruction.command });
-      return instructionEl.createSpan({ text: instruction.purpose });
-    });
-  }
-};
-function toggleCheckbox(checkboxEl) {
-  if (checkboxEl.disabled) {
-    return;
+  constructor(modal, options = {}) {
+    this.modal = modal;
+    this.shouldMinimizeOnClickOutside = options.shouldMinimizeOnClickOutside ?? true;
+    this.shouldShowCancelButton = options.shouldShowCancelButton ?? true;
+    addPluginCssClasses(modal.containerEl, ["minimizable-modal" /* MinimizableModal */]);
+    this.minimizeButtonEl = this.createMinimizeButton();
+    if (this.shouldMinimizeOnClickOutside) {
+      modal.containerEl.addEventListener("click", ($event) => {
+        this.handleContainerClick($event);
+      }, { capture: true });
+    }
+    this.closePatchComponent.load();
+    this.patchOnClose(modal);
   }
-  checkboxEl.checked = !checkboxEl.checked;
-  checkboxEl.trigger("change");
-}
-
-// src/__merged.ts
-init_modal();
-
-// src/obsidian/modals/prompt.ts
-var prompt_exports = {};
-__export(prompt_exports, {
-  prompt: () => prompt
-});
-var import_obsidian134 = require("obsidian");
-init_async();
-init_function();
-init_object_utils();
-init_css_class();
-init_i18n();
-init_modal();
-var PromptModal = class extends ModalBase {
-  cancelButtonText;
-  commandBuilder;
-  commandsRenderMode;
-  isOkClicked = false;
-  isTouched = false;
-  okButtonText;
-  placeholder;
-  spellcheckMode;
-  title;
-  value;
-  valueValidator;
-  constructor(params) {
-    super(params);
-    this.addCssClasses("prompt-modal" /* PromptModal */);
-    this.cancelButtonText = params.cancelButtonText ?? t2(($) => $.obsidianDevUtils.buttons.cancel);
-    this.commandBuilder = params.commandBuilder ?? null;
-    this.commandsRenderMode = params.commandsRenderMode;
-    this.okButtonText = params.okButtonText ?? t2(($) => $.obsidianDevUtils.buttons.ok);
-    this.placeholder = params.placeholder ?? "";
-    this.spellcheckMode = params.spellcheckMode ?? "FollowObsidianSetting" /* FollowObsidianSetting */;
-    this.title = params.title ?? "";
-    this.valueValidator = params.valueValidator ?? noop;
-    this.value = params.defaultValue ?? "";
+  /**
+   * Minimizes the modal: hides the modal and its backdrop, shows a floating bar with a restore button,
+   * and puts the app into the peek-only lock. A no-op if the modal is already minimized.
+   */
+  minimize() {
+    if (this.isMinimizedValue) {
+      return;
+    }
+    this.isMinimizedValue = true;
+    this.minimizeButtonEl.hide();
+    this.modal.containerEl.hide();
+    this.modal.app.keymap.popScope(this.modal.scope);
+    this.minimizedBarEl = this.createMinimizedBar();
+    this.enablePeekLock(this.minimizedBarEl);
   }
-  onClose() {
-    this.promiseResolve(this.isOkClicked ? this.value : null);
+  /**
+   * Restores the modal from the minimized state, removing the floating bar and lifting the peek-only
+   * lock. A no-op if the modal is not minimized.
+   */
+  restore() {
+    if (!this.isMinimizedValue) {
+      return;
+    }
+    this.isMinimizedValue = false;
+    this.disablePeekLock();
+    this.removeMinimizedBar();
+    this.modal.app.keymap.pushScope(this.modal.scope);
+    this.modal.containerEl.show();
+    this.minimizeButtonEl.show();
   }
-  onOpen() {
-    this.titleEl.setText(this.title);
-    const textComponent = new import_obsidian134.TextComponent(this.contentEl);
-    const inputEl = textComponent.inputEl;
-    applySpellcheckMode({
-      app: this.app,
-      element: inputEl,
-      spellcheckMode: this.spellcheckMode
+  createMinimizeButton() {
+    const buttonEl = this.modal.modalEl.createEl("button", { cls: "minimize-button" /* MinimizeButton */ });
+    (0, import_obsidian132.setIcon)(buttonEl, MINIMIZE_ICON_ID);
+    buttonEl.addEventListener("click", () => {
+      this.minimize();
     });
-    const validate = async (shouldReport) => {
-      const errorMessage = await this.valueValidator(inputEl.value);
-      inputEl.setCustomValidity(errorMessage ?? "");
-      if (shouldReport) {
-        inputEl.reportValidity();
-      }
-    };
-    const handleInput = async () => {
-      this.markTouched(inputEl);
-      await validate(true);
-    };
-    const handleFocus = async () => {
-      await validate(this.isTouched);
-    };
-    textComponent.setValue(this.value);
-    textComponent.inputEl.select();
-    textComponent.setPlaceholder(this.placeholder);
-    inputEl.addClass("text-box" /* TextBox */);
-    inputEl.addClass("untouched" /* Untouched */);
-    textComponent.onChange((newValue) => {
-      this.value = newValue;
+    return buttonEl;
+  }
+  createMinimizedBar() {
+    const barEl = this.modal.containerEl.ownerDocument.body.createDiv();
+    addPluginCssClasses(barEl, ["minimized-modal-bar" /* MinimizedModalBar */]);
+    barEl.createSpan({
+      cls: "minimized-modal-bar-title" /* MinimizedModalBarTitle */,
+      text: this.modal.titleEl.textContent
     });
-    inputEl.addEventListener("keydown", (event) => {
-      if (event.key === "Enter") {
-        this.handleOk(event, textComponent);
-      } else if (event.key === "Escape") {
-        this.close();
-      }
+    const restoreButtonEl = barEl.createEl("button", { cls: "restore-button" /* RestoreButton */ });
+    (0, import_obsidian132.setIcon)(restoreButtonEl, RESTORE_ICON_ID);
+    if (this.shouldShowCancelButton) {
+      const cancelButtonEl = barEl.createEl("button", { cls: "cancel-button" /* CancelButton */ });
+      (0, import_obsidian132.setIcon)(cancelButtonEl, CANCEL_ICON_ID);
+      (0, import_obsidian132.setTooltip)(cancelButtonEl, "Cancel");
+      cancelButtonEl.addEventListener("click", ($event) => {
+        $event.stopPropagation();
+        this.modal.close();
+      });
+    }
+    barEl.addEventListener("click", () => {
+      this.restore();
     });
-    inputEl.addEventListener("input", convertAsyncToSync(handleInput));
-    inputEl.addEventListener("focus", convertAsyncToSync(handleFocus));
-    invokeAsyncSafely(() => validate(false));
-    const okButton = new import_obsidian134.ButtonComponent(this.contentEl);
-    okButton.setButtonText(this.okButtonText);
-    okButton.setCta();
-    okButton.onClick((event) => {
-      this.handleOk(event, textComponent);
+    barEl.addEventListener("animationend", () => {
+      barEl.removeClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
     });
-    okButton.setClass("ok-button" /* OkButton */);
-    const cancelButton = new import_obsidian134.ButtonComponent(this.contentEl);
-    cancelButton.setButtonText(this.cancelButtonText);
-    cancelButton.onClick(this.close.bind(this));
-    cancelButton.setClass("cancel-button" /* CancelButton */);
-    this.commandBuilder?.build(this, normalizeOptionalProperties({ renderMode: this.commandsRenderMode }));
+    return barEl;
   }
-  handleOk(event, textComponent) {
-    event.preventDefault();
-    if (!textComponent.inputEl.checkValidity()) {
-      this.markTouched(textComponent.inputEl);
-      textComponent.inputEl.reportValidity();
+  disablePeekLock() {
+    if (!this.peekLockEntry) {
       return;
     }
-    this.isOkClicked = true;
-    this.close();
-  }
-  markTouched(inputEl) {
-    this.isTouched = true;
-    inputEl.removeClass("untouched" /* Untouched */);
-  }
-};
-async function prompt(params) {
-  return await showModal(
-    (promiseResolve) => new PromptModal({
-      ...params,
-      promiseResolve
-    })
-  );
-}
-
-// src/obsidian/modals/select-item.ts
-var select_item_exports = {};
-__export(select_item_exports, {
-  selectItem: () => selectItem
-});
-var import_obsidian135 = require("obsidian");
-init_css_class();
-init_plugin_context();
-init_modal();
-var ItemSelectModal = class extends import_obsidian135.FuzzySuggestModal {
-  isSelected = false;
-  items;
-  itemTextFunction;
-  placeholder;
-  promiseResolve;
-  spellcheckMode;
-  constructor(params) {
-    super(params.app);
-    this.items = params.items;
-    this.itemTextFunction = params.itemTextFunction;
-    this.placeholder = params.placeholder;
-    this.promiseResolve = params.promiseResolve;
-    this.spellcheckMode = params.spellcheckMode ?? "Off" /* Off */;
-    this.setPlaceholder(this.placeholder ?? "");
-    addPluginCssClasses(this.containerEl, params.cssClasses);
-    addPluginCssClasses(this.containerEl, "select-item-modal" /* SelectItemModal */);
+    peekLockEntries.delete(this.peekLockEntry);
+    this.peekLockEntry = null;
+    this.peekLockComponent?.unload();
+    this.peekLockComponent = null;
   }
-  getItems() {
-    return this.items;
+  enablePeekLock(barEl) {
+    this.peekLockEntry = {
+      barEl,
+      flash: () => {
+        this.flashBar(barEl);
+      },
+      innerModal: this.modal
+    };
+    peekLockEntries.add(this.peekLockEntry);
+    this.peekLockComponent = new PeekLockComponent(this.modal.app);
+    this.peekLockComponent.load();
   }
-  getItemText(item) {
-    return this.itemTextFunction(item);
+  flashBar(barEl) {
+    barEl.removeClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
+    barEl.getBoundingClientRect();
+    barEl.addClass("minimized-modal-bar-attention" /* MinimizedModalBarAttention */);
   }
-  onChooseItem(item) {
-    this.promiseResolve(item);
+  handleClose() {
+    this.disablePeekLock();
+    this.removeMinimizedBar();
+    this.isMinimizedValue = false;
   }
-  onClose() {
-    if (!this.isSelected) {
-      this.promiseResolve(null);
+  handleContainerClick($event) {
+    if (this.isMinimizedValue) {
+      return;
+    }
+    if ($event.composedPath().includes(this.modal.modalEl)) {
+      return;
+    }
+    if ($event.target === this.modal.containerEl) {
+      return;
     }
+    $event.preventDefault();
+    $event.stopImmediatePropagation();
+    this.minimize();
   }
-  onOpen() {
-    super.onOpen();
-    applySpellcheckMode({
-      app: this.app,
-      element: this.inputEl,
-      spellcheckMode: this.spellcheckMode
+  patchOnClose(modal) {
+    this.closePatchComponent.registerMethodPatch({
+      $object: modal,
+      methodName: "onClose",
+      patchHandler: ({ fallback }) => {
+        fallback();
+        this.handleClose();
+      }
     });
   }
-  selectSuggestion(value, $event) {
-    this.isSelected = true;
-    super.selectSuggestion(value, $event);
+  removeMinimizedBar() {
+    this.minimizedBarEl?.remove();
+    this.minimizedBarEl = null;
   }
 };
-async function selectItem(params) {
-  return await showModal(
-    (promiseResolve) => new ItemSelectModal({
-      ...params,
-      promiseResolve
-    })
-  );
-}
-
-// src/__merged.ts
-init_select_option();
-
-// src/obsidian/modals/suggest-modal-command-builder.ts
-var suggest_modal_command_builder_exports = {};
-__export(suggest_modal_command_builder_exports, {
-  SuggestModalCommandBuilder: () => SuggestModalCommandBuilder
-});
-var SuggestModalCommandBuilder = ModalCommandBuilder;
-
-// src/obsidian/note-priority.ts
-var note_priority_exports = {};
-__export(note_priority_exports, {
-  NO_PRIORITY_MATCH: () => NO_PRIORITY_MATCH,
-  NoPriorityWinnerReason: () => NoPriorityWinnerReason,
-  filterHighestPriorityNotePaths: () => filterHighestPriorityNotePaths,
-  findNoPriorityWinnerReason: () => findNoPriorityWinnerReason,
-  findNotePriorityRank: () => findNotePriorityRank,
-  pickHighestPriorityNotePath: () => pickHighestPriorityNotePath
-});
-init_reg_exp();
-var PROPERTY_PREFIX = "property:";
-var REG_EXP_DELIMITER = "/";
-var EXTENSION_PREFIX = ".";
-var PROPERTY_VALUE_SEPARATOR = "=";
-var NoPriorityWinnerReason = /* @__PURE__ */ ((NoPriorityWinnerReason2) => {
-  NoPriorityWinnerReason2["EmptyList"] = "EmptyList";
-  NoPriorityWinnerReason2["NoMatch"] = "NoMatch";
-  NoPriorityWinnerReason2["Tie"] = "Tie";
-  return NoPriorityWinnerReason2;
-})(NoPriorityWinnerReason || {});
-var NO_PRIORITY_MATCH = Infinity;
-function filterHighestPriorityNotePaths(params) {
-  const rankedNotePaths = params.notePaths.map((notePath) => ({
-    notePath,
-    rank: params.rank(notePath)
-  }));
-  let bestRank = NO_PRIORITY_MATCH;
-  for (const ranked of rankedNotePaths) {
-    if (ranked.rank < bestRank) {
-      bestRank = ranked.rank;
-    }
+function blockEvent($event) {
+  $event.preventDefault();
+  $event.stopImmediatePropagation();
+  signalBlockedAttempt();
+}
+function blockOrFallback(modal, fallback) {
+  if (shouldBlockOpen(modal)) {
+    signalBlockedAttempt();
+    return;
   }
-  return rankedNotePaths.filter((ranked) => ranked.rank === bestRank).map((ranked) => ranked.notePath);
+  fallback();
 }
-function findNoPriorityWinnerReason(params) {
-  if (params.entries.length === 0) {
-    return "EmptyList" /* EmptyList */;
+function flashMinimizedBars() {
+  for (const entry of peekLockEntries) {
+    entry.flash();
   }
-  let bestRank = NO_PRIORITY_MATCH;
-  for (const notePath of params.notePaths) {
-    const currentRank = params.rank(notePath);
-    if (currentRank < bestRank) {
-      bestRank = currentRank;
+}
+function isMinimizedInnerModal(modal) {
+  for (const entry of peekLockEntries) {
+    if (entry.innerModal === modal) {
+      return true;
     }
   }
-  return bestRank === NO_PRIORITY_MATCH ? "NoMatch" /* NoMatch */ : "Tie" /* Tie */;
+  return false;
 }
-function findNotePriorityRank(params) {
-  let bestRank = NO_PRIORITY_MATCH;
-  let bestLength = -1;
-  for (const [index2, entry] of params.entries.entries()) {
-    if (entry.length <= bestLength) {
-      continue;
-    }
-    if (!checkEntryMatches(entry, params)) {
-      continue;
-    }
-    bestRank = index2;
-    bestLength = entry.length;
+function isPeekAllowedKey($event) {
+  if (NAVIGATION_KEYS.has($event.key)) {
+    return !$event.shiftKey;
   }
-  return bestRank;
+  return MODIFIER_KEYS.has($event.key);
 }
-function pickHighestPriorityNotePath(params) {
-  let bestRank = NO_PRIORITY_MATCH;
-  let bestNotePath = null;
-  let bestCount = 0;
-  for (const notePath of params.notePaths) {
-    const currentRank = params.rank(notePath);
-    if (currentRank < bestRank) {
-      bestRank = currentRank;
-      bestNotePath = notePath;
-      bestCount = 1;
-    } else if (currentRank === bestRank) {
-      bestCount++;
+function isPeekLocked() {
+  for (const entry of peekLockEntries) {
+    if (!entry.barEl.isConnected) {
+      peekLockEntries.delete(entry);
     }
   }
-  if (bestCount !== 1 || bestRank === NO_PRIORITY_MATCH) {
-    return null;
-  }
-  return bestNotePath;
+  return peekLockEntries.size > 0;
 }
-function checkEntryMatches(entry, params) {
-  if (!entry) {
-    return false;
-  }
-  if (entry.startsWith(PROPERTY_PREFIX)) {
-    return checkPropertyMatches(entry.slice(PROPERTY_PREFIX.length), params.frontmatter);
-  }
-  if (entry.length > 1 && entry.startsWith(REG_EXP_DELIMITER) && entry.endsWith(REG_EXP_DELIMITER)) {
-    const source = entry.slice(1, -1);
-    return isValidRegExp(source) && new RegExp(source).test(params.notePath);
-  }
-  if (entry.startsWith(EXTENSION_PREFIX)) {
-    return params.notePath.toLowerCase().endsWith(entry.toLowerCase());
-  }
-  const prefix = entry.endsWith("/") ? entry : `${entry}/`;
-  return params.notePath === entry || params.notePath.startsWith(prefix);
+function shouldBlockOpen(modal) {
+  return isPeekLocked() && !isMinimizedInnerModal(modal);
 }
-function checkPropertyMatches(specifier, frontmatter) {
-  if (!frontmatter) {
-    return false;
-  }
-  const separatorIndex = specifier.indexOf(PROPERTY_VALUE_SEPARATOR);
-  if (separatorIndex === -1) {
-    return Object.hasOwn(frontmatter, specifier);
-  }
-  const propertyName = specifier.slice(0, separatorIndex);
-  const expectedValue = specifier.slice(separatorIndex + 1);
-  if (!Object.hasOwn(frontmatter, propertyName)) {
-    return false;
-  }
-  const actualValue = frontmatter[propertyName];
-  if (Array.isArray(actualValue)) {
-    return actualValue.some((item) => String(item) === expectedValue);
-  }
-  return String(actualValue) === expectedValue;
+function signalBlockedAttempt() {
+  flashMinimizedBars();
+  beeper.beep();
 }
-
-// src/obsidian/obsidian-protocol-handler-registrar.ts
-var obsidian_protocol_handler_registrar_exports = {};
-__export(obsidian_protocol_handler_registrar_exports, {
-  PluginObsidianProtocolHandlerRegistrar: () => PluginObsidianProtocolHandlerRegistrar
-});
-init_async();
-var PluginObsidianProtocolHandlerRegistrar = class {
-  /**
-   * The Obsidian plugin instance the protocol handlers are registered with.
-   */
-  plugin;
-  /**
-   * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
-   *
-   * @param plugin - The plugin to register the protocol handler with.
-   */
-  constructor(plugin) {
-    this.plugin = plugin;
+function suppressKeydownWhilePeekLocked($event) {
+  if (!isPeekLocked() || isPeekAllowedKey($event)) {
+    return;
   }
-  /**
-   * Registers an Obsidian protocol handler.
-   *
-   * @param params - The parameters for the Obsidian protocol handler registration.
-   */
-  registerObsidianProtocolHandler(params) {
-    this.plugin.registerObsidianProtocolHandler(params.action, (obsidianProtocolData) => normalizePromisable(params.handler(obsidianProtocolData)));
+  blockEvent($event);
+}
+function suppressWhilePeekLocked($event) {
+  if (!isPeekLocked()) {
+    return;
   }
-};
+  blockEvent($event);
+}
 
-// src/obsidian/path-settings.ts
-var path_settings_exports = {};
-__export(path_settings_exports, {
-  PathSettings: () => PathSettings,
-  pathsValidator: () => pathsValidator
+// src/obsidian/modals/modal-command-builder.ts
+var modal_command_builder_exports = {};
+__export(modal_command_builder_exports, {
+  ModalCommandBuilder: () => ModalCommandBuilder,
+  ModalCommandsRenderMode: () => ModalCommandsRenderMode
 });
-init_reg_exp();
-init_string();
-init_type_guards();
-init_i18n();
-var PathSetting = class {
-  constructor(type) {
-    this.type = type;
-    this.defaultRegExp = getDefaultRegExp(type);
-    this.regExp = this.defaultRegExp;
-  }
-  type;
-  get array() {
-    return this._array;
-  }
-  set array(value) {
-    this._array = value.filter(Boolean);
-    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;
-  }
-  _array = [];
-  defaultRegExp;
-  regExp;
-  isPathIgnored(path) {
-    switch (this.type) {
-      /* v8 ignore stop */
-      case "Exclude" /* Exclude */: {
-        return this.regExp.test(path);
-      }
-      case "Include" /* Include */: {
-        return !this.regExp.test(path);
-      }
-      default: {
-        assertNever(this.type);
-      }
-    }
+var import_obsidian133 = require("obsidian");
+init_css_class();
+init_plugin_context();
+var KEYS_MAP = /* @__PURE__ */ new Map([
+  ["Enter", "\u21B5"],
+  ["UpDown", "\u2191\u2193"]
+]);
+var ModalCommandsRenderMode = /* @__PURE__ */ ((ModalCommandsRenderMode2) => {
+  ModalCommandsRenderMode2["Buttons"] = "buttons";
+  ModalCommandsRenderMode2["Instructions"] = "instructions";
+  return ModalCommandsRenderMode2;
+})(ModalCommandsRenderMode || {});
+var NOOP_MODAL_COMMANDS = {
+  refresh: () => {
   }
 };
-var PathSettings = class {
-  /**
-   * Gets the exclude paths.
-   *
-   * @returns The exclude paths.
-   */
-  get excludePaths() {
-    return this._excludePaths.array;
-  }
+var ModalCommandBuilder = class {
+  entries = [];
   /**
-   * Sets the exclude paths.
+   * Adds an interactive checkbox to the control strip, bound to a modifier+key shortcut that toggles it.
    *
-   * @param value - The exclude paths.
+   * @param command - The checkbox command to add.
+   * @returns The builder instance for chaining.
    */
-  set excludePaths(value) {
-    this._excludePaths.array = value;
+  addCheckbox(command) {
+    this.entries.push({
+      checkIsAvailable: command.checkIsAvailable ?? null,
+      commandText: this.buildCommandText(command),
+      initButton: (buttonEl, scope) => {
+        const checkboxEl = createEl("input", { type: "checkbox" });
+        initCheckbox(checkboxEl, scope);
+        buttonEl.addEventListener("click", () => {
+          toggleCheckbox(checkboxEl);
+        });
+        return {
+          checkIsOn: () => checkboxEl.checked,
+          setDisabled: (isDisabled) => {
+            checkboxEl.disabled = isDisabled;
+            buttonEl.disabled = isDisabled;
+          }
+        };
+      },
+      initInstruction: (purposeEl, scope) => {
+        const checkboxEl = purposeEl.createEl("input", { type: "checkbox" });
+        addPluginCssClasses(checkboxEl, "modal-command-control" /* ModalCommandControl */);
+        return initCheckbox(checkboxEl, scope);
+      },
+      isDropDown: false,
+      purpose: command.purpose,
+      registerScope: null
+    });
+    return this;
+    function initCheckbox(checkboxEl, scope) {
+      command.onInit(checkboxEl);
+      checkboxEl.addEventListener("change", () => {
+        command.onChange(checkboxEl.checked);
+      });
+      scope.register(command.modifiers ?? [], command.key, () => {
+        toggleCheckbox(checkboxEl);
+      });
+      return {
+        setDisabled: (isDisabled) => {
+          checkboxEl.disabled = isDisabled;
+        }
+      };
+    }
   }
   /**
-   * Gets the include paths.
+   * Adds a dropdown to the control strip, bound to a modifier+key shortcut that cycles through its
+   * options.
    *
-   * @returns The include paths.
+   * @param command - The dropdown command to add.
+   * @returns The builder instance for chaining.
    */
-  get includePaths() {
-    return this._includePaths.array;
+  addDropDown(command) {
+    this.entries.push({
+      checkIsAvailable: command.checkIsAvailable ?? null,
+      commandText: this.buildCommandText(command),
+      initButton: null,
+      initInstruction: (purposeEl, scope) => {
+        const dropdownComponent = new import_obsidian133.DropdownComponent(purposeEl);
+        addPluginCssClasses(dropdownComponent.selectEl, "modal-command-control" /* ModalCommandControl */);
+        command.onInit(dropdownComponent);
+        dropdownComponent.onChange((value) => {
+          command.onChange(value);
+        });
+        scope.register(command.modifiers ?? [], command.key, () => {
+          if (dropdownComponent.disabled) {
+            return;
+          }
+          const selectEl = dropdownComponent.selectEl;
+          selectEl.selectedIndex = (selectEl.selectedIndex + 1) % selectEl.options.length;
+          selectEl.trigger("change");
+        });
+        return {
+          setDisabled: (isDisabled) => {
+            dropdownComponent.setDisabled(isDisabled);
+          }
+        };
+      },
+      isDropDown: true,
+      purpose: command.purpose,
+      registerScope: null
+    });
+    return this;
   }
   /**
-   * Sets the include paths.
+   * Adds a keyboard command to the control strip. When {@link KeyboardCommand.onKey} is provided, its
+   * handler is registered with the modal scope; otherwise the command is a hint only.
    *
-   * @param value - The include paths.
+   * @param command - The keyboard command to add.
+   * @returns The builder instance for chaining.
    */
-  set includePaths(value) {
-    this._includePaths.array = value;
+  addKeyboardCommand(command) {
+    const checkIsOn = command.checkIsOn ?? (() => false);
+    const onActivate = command.onActivate ?? null;
+    const onKey = command.onKey?.bind(command) ?? null;
+    this.entries.push({
+      checkIsAvailable: command.checkIsAvailable ?? null,
+      commandText: this.buildCommandText(command),
+      initButton: onActivate ? (buttonEl) => {
+        buttonEl.addEventListener("click", ($event) => {
+          onActivate($event);
+        });
+        return {
+          checkIsOn,
+          setDisabled: (isDisabled) => {
+            buttonEl.disabled = isDisabled;
+          }
+        };
+      } : null,
+      initInstruction: null,
+      isDropDown: false,
+      purpose: command.purpose,
+      registerScope: onKey ? (scope) => {
+        scope.register(command.modifiers ?? [], command.key, onKey);
+      } : null
+    });
+    return this;
   }
-  _excludePaths = new PathSetting("Exclude" /* Exclude */);
-  _includePaths = new PathSetting("Include" /* Include */);
   /**
-   * Checks if a path is ignored by the include/exclude path settings.
+   * Applies the accumulated commands to a modal. Always registers the essential navigation/action key
+   * handlers; only renders the control strip and registers the option-toggle shortcuts when
+   * {@link ModalCommandBuilderBuildOptions.shouldShowInstructions} is `true`.
    *
-   * @param path - The path to check.
-   * @returns `true` if the path is ignored, `false` otherwise.
+   * @param target - The modal, or the bare element + scope, to apply the commands to.
+   * @param options - The build options.
+   * @returns A handle whose {@link ModalCommands.refresh} re-states every rendered control.
    */
-  isPathIgnored(path) {
-    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);
-  }
-};
-function pathsValidator(paths) {
-  for (const path of paths) {
-    if (path.startsWith("/") && path.endsWith("/") && !isValidRegExp(path.slice(1, -1))) {
-      return t2(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });
+  build(target, options = {}) {
+    const {
+      renderMode = "instructions" /* Instructions */,
+      shouldShowInstructions = true
+    } = options;
+    const scope = target.scope;
+    for (const entry of this.entries) {
+      entry.registerScope?.(scope);
     }
-  }
-}
-function getDefaultRegExp(type) {
-  switch (type) {
-    /* v8 ignore stop */
-    case "Exclude" /* Exclude */: {
-      return NEVER_MATCH_REG_EXP;
+    if (!shouldShowInstructions) {
+      return NOOP_MODAL_COMMANDS;
     }
-    case "Include" /* Include */: {
-      return ALWAYS_MATCH_REG_EXP;
+    const refreshers = renderMode === "buttons" /* Buttons */ ? this.renderButtons(target, scope) : this.renderInstructions(target, scope);
+    const modalCommands = {
+      refresh: () => {
+        for (const refreshControl of refreshers) {
+          refreshControl();
+        }
+      }
+    };
+    modalCommands.refresh();
+    return modalCommands;
+  }
+  buildCommandText(command) {
+    let commandText = KEYS_MAP.get(command.key) ?? command.key;
+    for (const modifier of command.modifiers ?? []) {
+      commandText = `${this.getModifierString(modifier)} ${commandText}`;
     }
-    default: {
-      assertNever(type);
+    return commandText;
+  }
+  getModifierString(modifier) {
+    switch (modifier) {
+      case "Alt": {
+        return "alt";
+      }
+      case "Ctrl": {
+        return "ctrl";
+      }
+      case "Meta": {
+        return import_obsidian133.Platform.isMacOS ? "cmd" : "win";
+      }
+      case "Mod": {
+        return import_obsidian133.Platform.isMacOS ? "cmd" : "ctrl";
+      }
+      case "Shift": {
+        return "shift";
+      }
+      default: {
+        return modifier;
+      }
     }
   }
-}
-function makeRegExp(paths, defaultRegExp) {
-  if (paths.length === 0) {
-    return defaultRegExp;
+  /**
+   * Resolves the element a self-created strip is appended to.
+   *
+   * A {@link Modal} carries both `modalEl` and a `containerEl` that is the OUTER `.modal-container`, so
+   * `modalEl` has to win — otherwise the strip lands outside the modal frame. Discriminated with `in`
+   * rather than a property read, because tests hand `build` a `strictProxy` mock whose `get` trap throws
+   * on unmocked members.
+   *
+   * @param target - The build target.
+   * @returns The element to append the strip to.
+   */
+  getStripContainerEl(target) {
+    return "modalEl" in target ? target.modalEl : target.containerEl;
   }
-  const regExpStringCombined = paths.map((path) => {
-    if (path === "/") {
-      return defaultRegExp.source;
-    }
-    if (path.startsWith("/") && path.endsWith("/")) {
-      return path.slice(1, -1);
+  renderButtons(target, scope) {
+    const stripEl = this.getStripContainerEl(target).createDiv();
+    addPluginCssClasses(stripEl, "modal-commands" /* ModalCommands */);
+    const refreshers = [];
+    for (const entry of this.entries) {
+      if (entry.isDropDown) {
+        throw new Error(`Cannot render dropdown command "${entry.purpose}" as a button: a control that cycles has no button form.`);
+      }
+      if (!entry.initButton) {
+        continue;
+      }
+      const buttonEl = stripEl.createEl("button", { type: "button" });
+      addPluginCssClasses(buttonEl, "modal-command" /* ModalCommand */);
+      buttonEl.createSpan({ text: entry.purpose });
+      if (!import_obsidian133.Platform.isMobile) {
+        const hotkeyEl = buttonEl.createSpan({ text: entry.commandText });
+        addPluginCssClasses(hotkeyEl, "modal-command-hotkey" /* ModalCommandHotkey */);
+      }
+      buttonEl.addEventListener("mousedown", ($event) => {
+        $event.preventDefault();
+      });
+      const buttonControl = entry.initButton(buttonEl, scope);
+      const checkIsAvailable = entry.checkIsAvailable;
+      refreshers.push(() => {
+        if (checkIsAvailable) {
+          buttonControl.setDisabled(!checkIsAvailable());
+        }
+        const isOn = buttonControl.checkIsOn();
+        buttonEl.toggleClass("is-active" /* IsActive */, isOn);
+        buttonEl.setAttribute("aria-pressed", String(isOn));
+      });
     }
-    path = trimEnd({
-      $string: path,
-      suffix: "/"
-    });
-    return `^${escapeRegExp(path)}(/|$)`;
-  }).map((regExpString) => `(${regExpString})`).join("|");
-  try {
-    return new RegExp(regExpStringCombined);
-  } catch {
-    return null;
-  }
-}
-
-// src/obsidian/pdf.ts
-var pdf_exports = {};
-__export(pdf_exports, {
-  printToPdf: () => printToPdf
-});
-var import_obsidian136 = require("obsidian");
-var ELECTRON_PRINT_TO_PDF_CHANNEL = "print-to-pdf";
-async function printToPdf(element, options) {
-  if (import_obsidian136.Platform.isMobile) {
-    throw new Error("Printing to PDF is not supported on mobile devices.");
+    return refreshers;
   }
-  const printDiv = activeDocument.body.createDiv("print");
-  printDiv.append(element);
-  await ensureLoaded(printDiv);
-  const DEFAULT_SCALE_FACTOR = 100;
-  const DEFAULT_OPTIONS = {
-    filepath: "Untitled.pdf",
-    includeName: false,
-    landscape: false,
-    marginsType: 0,
-    open: true,
-    pageSize: "A4",
-    scale: 1,
-    scaleFactor: DEFAULT_SCALE_FACTOR
-  };
-  const fullOptions = { ...DEFAULT_OPTIONS, ...options };
-  try {
-    await new Promise((resolve2) => {
-      activeWindow.electron.ipcRenderer.once(ELECTRON_PRINT_TO_PDF_CHANNEL, resolve2);
-      activeWindow.electron.ipcRenderer.send(ELECTRON_PRINT_TO_PDF_CHANNEL, fullOptions);
-    });
-  } finally {
-    printDiv.remove();
+  renderInstructions(target, scope) {
+    const instructions = this.entries.map((entry) => ({
+      command: entry.commandText,
+      entry,
+      purpose: entry.purpose
+    }));
+    const purposeEls = "setInstructions" in target ? this.renderNativeInstructions(target, instructions) : this.renderOwnInstructions(this.getStripContainerEl(target), instructions);
+    const refreshers = [];
+    for (const [index2, instruction] of instructions.entries()) {
+      const purposeEl = purposeEls[index2];
+      if (!purposeEl) {
+        continue;
+      }
+      const instructionControl = instruction.entry.initInstruction?.(purposeEl, scope);
+      const checkIsAvailable = instruction.entry.checkIsAvailable;
+      if (instructionControl && checkIsAvailable) {
+        refreshers.push(() => {
+          instructionControl.setDisabled(!checkIsAvailable());
+        });
+      }
+    }
+    return refreshers;
   }
-}
-
-// src/obsidian/plugin-cli-handler-registrar.ts
-var plugin_cli_handler_registrar_exports = {};
-__export(plugin_cli_handler_registrar_exports, {
-  PluginCliHandlerRegistrar: () => PluginCliHandlerRegistrar
-});
-var import_obsidian137 = require("obsidian");
-init_async();
-var PluginCliHandlerRegistrar = class {
   /**
-   * Creates a new instance of the {@link PluginCliHandlerRegistrar} class.
+   * Renders through Obsidian's own instruction bar, the way every {@link SuggestModal} consumer has always
+   * had it.
    *
-   * @param plugin - The Obsidian plugin instance.
+   * @param modal - The suggest modal.
+   * @param instructions - The instructions to render.
+   * @returns The purpose element of each rendered instruction.
    */
-  constructor(plugin) {
-    this.plugin = plugin;
+  renderNativeInstructions(modal, instructions) {
+    modal.setInstructions(instructions);
+    return [...modal.instructionsEl.findAll(".prompt-instruction > span:nth-child(2)")];
   }
-  plugin;
   /**
-   * Registers a CLI handler.
+   * Renders an instruction bar of the builder's own, for a host that has none.
    *
-   * @param params - The parameters for the CLI handler registration.
+   * The markup mirrors what `setInstructions` produces — including
+   * {@link CssClass.PromptInstructionCommand} on the key hint, which is not decoration: Obsidian's rule
+   * for that class is what supplies the hint's bold weight and the `margin-inline-end` separating it
+   * from the purpose text. Every class here is unscoped in the app's stylesheet, so all of it reaches a
+   * plain {@link Modal} as readily as it reaches the quick switcher.
+   *
+   * @param containerEl - The element to append the bar to.
+   * @param instructions - The instructions to render.
+   * @returns The purpose element of each rendered instruction.
    */
-  registerCliHandler(params) {
-    this.plugin.registerCliHandler(params.command, params.description, params.flags, (cliData) => normalizePromisable(params.handler(cliData)));
+  renderOwnInstructions(containerEl, instructions) {
+    const instructionsEl = containerEl.createDiv("prompt-instructions" /* PromptInstructions */);
+    addPluginCssClasses(instructionsEl, "modal-commands" /* ModalCommands */);
+    return instructions.map((instruction) => {
+      const instructionEl = instructionsEl.createDiv("prompt-instruction" /* PromptInstruction */);
+      instructionEl.createSpan({ cls: "prompt-instruction-command" /* PromptInstructionCommand */, text: instruction.command });
+      return instructionEl.createSpan({ text: instruction.purpose });
+    });
   }
 };
+function toggleCheckbox(checkboxEl) {
+  if (checkboxEl.disabled) {
+    return;
+  }
+  checkboxEl.checked = !checkboxEl.checked;
+  checkboxEl.trigger("change");
+}
 
-// src/obsidian/plugin/obsidian-plugin-repo-paths.ts
-var obsidian_plugin_repo_paths_exports = {};
-__export(obsidian_plugin_repo_paths_exports, {
-  ObsidianPluginRepoPaths: () => ObsidianPluginRepoPaths
-});
-var ObsidianPluginRepoPaths = /* @__PURE__ */ ((ObsidianPluginRepoPaths2) => {
-  ObsidianPluginRepoPaths2["AnyAndroidCaptureIntegrationTestTs"] = "*.android-capture.integration.test.ts";
-  ObsidianPluginRepoPaths2["AnyAndroidIntegrationTestTs"] = "*.android.integration.test.ts";
-  ObsidianPluginRepoPaths2["AnyCjs"] = "*.cjs";
-  ObsidianPluginRepoPaths2["AnyDesktopTs"] = "desktop-*.ts";
-  ObsidianPluginRepoPaths2["AnyIntegrationTestTs"] = "*.integration.test.ts";
-  ObsidianPluginRepoPaths2["AnyJs"] = "*.js";
-  ObsidianPluginRepoPaths2["AnyMjs"] = "*.mjs";
-  ObsidianPluginRepoPaths2["AnyPath"] = "**";
-  ObsidianPluginRepoPaths2["AnyTestTs"] = "*.test.ts";
-  ObsidianPluginRepoPaths2["AnyTs"] = "*.ts";
-  ObsidianPluginRepoPaths2["AnyTsx"] = "*.tsx";
-  ObsidianPluginRepoPaths2["AppJson"] = "app.json";
-  ObsidianPluginRepoPaths2["ChangelogMd"] = "CHANGELOG.md";
-  ObsidianPluginRepoPaths2["CommitlintConfigTs"] = "commitlint.config.ts";
-  ObsidianPluginRepoPaths2["CurrentFolder"] = ".";
-  ObsidianPluginRepoPaths2["DemoVault"] = "demo-vault";
-  ObsidianPluginRepoPaths2["Dist"] = "dist";
-  ObsidianPluginRepoPaths2["DistBuild"] = "dist/build";
-  ObsidianPluginRepoPaths2["DistDev"] = "dist/dev";
-  ObsidianPluginRepoPaths2["DotObsidian"] = ".obsidian";
-  ObsidianPluginRepoPaths2["EslintConfigCjs"] = "eslint.config.cjs";
-  ObsidianPluginRepoPaths2["EslintConfigCts"] = "eslint.config.cts";
-  ObsidianPluginRepoPaths2["EslintConfigJs"] = "eslint.config.js";
-  ObsidianPluginRepoPaths2["EslintConfigMjs"] = "eslint.config.mjs";
-  ObsidianPluginRepoPaths2["EslintConfigMts"] = "eslint.config.mts";
-  ObsidianPluginRepoPaths2["EslintConfigTs"] = "eslint.config.ts";
-  ObsidianPluginRepoPaths2["HotReload"] = ".hotreload";
-  ObsidianPluginRepoPaths2["License"] = "LICENSE";
-  ObsidianPluginRepoPaths2["MainCss"] = "main.css";
-  ObsidianPluginRepoPaths2["MainJs"] = "main.js";
-  ObsidianPluginRepoPaths2["MainTs"] = "main.ts";
-  ObsidianPluginRepoPaths2["ManifestBetaJson"] = "manifest-beta.json";
-  ObsidianPluginRepoPaths2["ManifestJson"] = "manifest.json";
-  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigCjs"] = ".markdownlint-cli2.cjs";
-  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigJsonc"] = ".markdownlint-cli2.jsonc";
-  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigMjs"] = ".markdownlint-cli2.mjs";
-  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigYaml"] = ".markdownlint-cli2.yaml";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigCjs"] = ".markdownlint.cjs";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigJson"] = ".markdownlint.json";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigJsonc"] = ".markdownlint.jsonc";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigMjs"] = ".markdownlint.mjs";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigYaml"] = ".markdownlint.yaml";
-  ObsidianPluginRepoPaths2["MarkdownlintConfigYml"] = ".markdownlint.yml";
-  ObsidianPluginRepoPaths2["Mocks"] = "src/test-helpers";
-  ObsidianPluginRepoPaths2["NodeModules"] = "node_modules";
-  ObsidianPluginRepoPaths2["NpmShrinkwrapJson"] = "npm-shrinkwrap.json";
-  ObsidianPluginRepoPaths2["PackageJson"] = "package.json";
-  ObsidianPluginRepoPaths2["PackageLockJson"] = "package-lock.json";
-  ObsidianPluginRepoPaths2["Plugins"] = "plugins";
-  ObsidianPluginRepoPaths2["Scripts"] = "scripts";
-  ObsidianPluginRepoPaths2["ScriptUtils"] = "src/script-utils";
-  ObsidianPluginRepoPaths2["Src"] = "src";
-  ObsidianPluginRepoPaths2["StylesCss"] = "styles.css";
-  ObsidianPluginRepoPaths2["Tests"] = "__tests__";
-  ObsidianPluginRepoPaths2["TsConfigJson"] = "tsconfig.json";
-  ObsidianPluginRepoPaths2["VersionsJson"] = "versions.json";
-  ObsidianPluginRepoPaths2["VitestConfigTs"] = "vitest.config.ts";
-  return ObsidianPluginRepoPaths2;
-})(ObsidianPluginRepoPaths || {});
+// src/__merged.ts
+init_modal();
 
-// src/obsidian/plugin/plugin-api.ts
-var plugin_api_exports = {};
-__export(plugin_api_exports, {
-  PluginApiPayloadKind: () => PluginApiPayloadKind,
-  PluginApiRevokedError: () => PluginApiRevokedError,
-  PluginApiUnavailabilityReason: () => PluginApiUnavailabilityReason,
-  PluginApiUnavailableError: () => PluginApiUnavailableError,
-  PluginApiValidationError: () => PluginApiValidationError,
-  publishPluginApi: () => publishPluginApi,
-  watchPluginApi: () => watchPluginApi
+// src/obsidian/modals/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  prompt: () => prompt
+});
+var import_obsidian134 = require("obsidian");
+init_async();
+init_function();
+init_object_utils();
+init_css_class();
+init_i18n();
+init_modal();
+var PromptModal = class extends ModalBase {
+  cancelButtonText;
+  commandBuilder;
+  commandsRenderMode;
+  isOkClicked = false;
+  isTouched = false;
+  okButtonText;
+  placeholder;
+  spellcheckMode;
+  title;
+  value;
+  valueValidator;
+  constructor(params) {
+    super(params);
+    this.addCssClasses("prompt-modal" /* PromptModal */);
+    this.cancelButtonText = params.cancelButtonText ?? t2(($) => $.obsidianDevUtils.buttons.cancel);
+    this.commandBuilder = params.commandBuilder ?? null;
+    this.commandsRenderMode = params.commandsRenderMode;
+    this.okButtonText = params.okButtonText ?? t2(($) => $.obsidianDevUtils.buttons.ok);
+    this.placeholder = params.placeholder ?? "";
+    this.spellcheckMode = params.spellcheckMode ?? "FollowObsidianSetting" /* FollowObsidianSetting */;
+    this.title = params.title ?? "";
+    this.valueValidator = params.valueValidator ?? noop;
+    this.value = params.defaultValue ?? "";
+  }
+  onClose() {
+    this.promiseResolve(this.isOkClicked ? this.value : null);
+  }
+  onOpen() {
+    this.titleEl.setText(this.title);
+    const textComponent = new import_obsidian134.TextComponent(this.contentEl);
+    const inputEl = textComponent.inputEl;
+    applySpellcheckMode({
+      app: this.app,
+      element: inputEl,
+      spellcheckMode: this.spellcheckMode
+    });
+    const validate = async (shouldReport) => {
+      const errorMessage = await this.valueValidator(inputEl.value);
+      inputEl.setCustomValidity(errorMessage ?? "");
+      if (shouldReport) {
+        inputEl.reportValidity();
+      }
+    };
+    const handleInput = async () => {
+      this.markTouched(inputEl);
+      await validate(true);
+    };
+    const handleFocus = async () => {
+      await validate(this.isTouched);
+    };
+    textComponent.setValue(this.value);
+    textComponent.inputEl.select();
+    textComponent.setPlaceholder(this.placeholder);
+    inputEl.addClass("text-box" /* TextBox */);
+    inputEl.addClass("untouched" /* Untouched */);
+    textComponent.onChange((newValue) => {
+      this.value = newValue;
+    });
+    inputEl.addEventListener("keydown", (event) => {
+      if (event.key === "Enter") {
+        this.handleOk(event, textComponent);
+      } else if (event.key === "Escape") {
+        this.close();
+      }
+    });
+    inputEl.addEventListener("input", convertAsyncToSync(handleInput));
+    inputEl.addEventListener("focus", convertAsyncToSync(handleFocus));
+    invokeAsyncSafely(() => validate(false));
+    const okButton = new import_obsidian134.ButtonComponent(this.contentEl);
+    okButton.setButtonText(this.okButtonText);
+    okButton.setCta();
+    okButton.onClick((event) => {
+      this.handleOk(event, textComponent);
+    });
+    okButton.setClass("ok-button" /* OkButton */);
+    const cancelButton = new import_obsidian134.ButtonComponent(this.contentEl);
+    cancelButton.setButtonText(this.cancelButtonText);
+    cancelButton.onClick(this.close.bind(this));
+    cancelButton.setClass("cancel-button" /* CancelButton */);
+    this.commandBuilder?.build(this, normalizeOptionalProperties({ renderMode: this.commandsRenderMode }));
+  }
+  handleOk(event, textComponent) {
+    event.preventDefault();
+    if (!textComponent.inputEl.checkValidity()) {
+      this.markTouched(textComponent.inputEl);
+      textComponent.inputEl.reportValidity();
+      return;
+    }
+    this.isOkClicked = true;
+    this.close();
+  }
+  markTouched(inputEl) {
+    this.isTouched = true;
+    inputEl.removeClass("untouched" /* Untouched */);
+  }
+};
+async function prompt(params) {
+  return await showModal(
+    (promiseResolve) => new PromptModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+
+// src/obsidian/modals/select-item.ts
+var select_item_exports = {};
+__export(select_item_exports, {
+  selectItem: () => selectItem
 });
-var import_compare_versions3 = __toESM(require_umd(), 1);
-init_array();
-init_async_events();
-init_async();
-init_debug();
-init_object_utils();
-init_obsidian_dev_utils_state();
-var PLUGIN_API_DEBUGGER_NAMESPACE = "PluginApi";
-var PLUGIN_API_REGISTRY_STATE_KEY = "pluginApiRegistry";
-var DEFAULT_WHEN_AVAILABLE_TIMEOUT_IN_MILLISECONDS = 1e4;
-var PluginApiPayloadKind = /* @__PURE__ */ ((PluginApiPayloadKind2) => {
-  PluginApiPayloadKind2["Input"] = "input";
-  PluginApiPayloadKind2["Output"] = "output";
-  return PluginApiPayloadKind2;
-})(PluginApiPayloadKind || {});
-var PluginApiUnavailabilityReason = /* @__PURE__ */ ((PluginApiUnavailabilityReason2) => {
-  PluginApiUnavailabilityReason2["NotEnabled"] = "notEnabled";
-  PluginApiUnavailabilityReason2["NotInstalled"] = "notInstalled";
-  PluginApiUnavailabilityReason2["NotPublished"] = "notPublished";
-  PluginApiUnavailabilityReason2["Revoked"] = "revoked";
-  PluginApiUnavailabilityReason2["ShapeMismatch"] = "shapeMismatch";
-  PluginApiUnavailabilityReason2["VersionMismatch"] = "versionMismatch";
-  return PluginApiUnavailabilityReason2;
-})(PluginApiUnavailabilityReason || {});
-var PluginApiWatchBase = class {
-  // A `protected` constructor is not assignable to `AbstractConstructor<object>`, which is what
-  // `mixinAsyncEvents` accepts, so this stays public even though only the subclass below calls it.
+var import_obsidian135 = require("obsidian");
+init_css_class();
+init_plugin_context();
+init_modal();
+var ItemSelectModal = class extends import_obsidian135.FuzzySuggestModal {
+  isSelected = false;
+  items;
+  itemTextFunction;
+  placeholder;
+  promiseResolve;
+  spellcheckMode;
   constructor(params) {
-    this.params = params;
+    super(params.app);
+    this.items = params.items;
+    this.itemTextFunction = params.itemTextFunction;
+    this.placeholder = params.placeholder;
+    this.promiseResolve = params.promiseResolve;
+    this.spellcheckMode = params.spellcheckMode ?? "Off" /* Off */;
+    this.setPlaceholder(this.placeholder ?? "");
+    addPluginCssClasses(this.containerEl, params.cssClasses);
+    addPluginCssClasses(this.containerEl, "select-item-modal" /* SelectItemModal */);
   }
-  params;
-  handle = null;
-  record = null;
-  /**
-   * Builds the error describing why the API is not available right now.
-   *
-   * @returns The classified error.
-   */
-  createUnavailableError() {
-    return new PluginApiUnavailableError({
-      pluginId: this.params.pluginId,
-      reason: resolveUnavailabilityReason(this.params)
+  getItems() {
+    return this.items;
+  }
+  getItemText(item) {
+    return this.itemTextFunction(item);
+  }
+  onChooseItem(item) {
+    this.promiseResolve(item);
+  }
+  onClose() {
+    if (!this.isSelected) {
+      this.promiseResolve(null);
+    }
+  }
+  onOpen() {
+    super.onOpen();
+    applySpellcheckMode({
+      app: this.app,
+      element: this.inputEl,
+      spellcheckMode: this.spellcheckMode
     });
   }
+  selectSuggestion(value, $event) {
+    this.isSelected = true;
+    super.selectSuggestion(value, $event);
+  }
 };
-var PluginApiRefImpl = class extends mixinAsyncEvents()(PluginApiWatchBase) {
-  get value() {
-    return castTo(this.handle);
+async function selectItem(params) {
+  return await showModal(
+    (promiseResolve) => new ItemSelectModal({
+      ...params,
+      promiseResolve
+    })
+  );
+}
+
+// src/__merged.ts
+init_select_option();
+
+// src/obsidian/modals/suggest-modal-command-builder.ts
+var suggest_modal_command_builder_exports = {};
+__export(suggest_modal_command_builder_exports, {
+  SuggestModalCommandBuilder: () => SuggestModalCommandBuilder
+});
+var SuggestModalCommandBuilder = ModalCommandBuilder;
+
+// src/obsidian/note-priority.ts
+var note_priority_exports = {};
+__export(note_priority_exports, {
+  NO_PRIORITY_MATCH: () => NO_PRIORITY_MATCH,
+  NoPriorityWinnerReason: () => NoPriorityWinnerReason,
+  filterHighestPriorityNotePaths: () => filterHighestPriorityNotePaths,
+  findNoPriorityWinnerReason: () => findNoPriorityWinnerReason,
+  findNotePriorityRank: () => findNotePriorityRank,
+  pickHighestPriorityNotePath: () => pickHighestPriorityNotePath
+});
+init_reg_exp();
+var PROPERTY_PREFIX = "property:";
+var REG_EXP_DELIMITER = "/";
+var EXTENSION_PREFIX = ".";
+var PROPERTY_VALUE_SEPARATOR = "=";
+var NoPriorityWinnerReason = /* @__PURE__ */ ((NoPriorityWinnerReason2) => {
+  NoPriorityWinnerReason2["EmptyList"] = "EmptyList";
+  NoPriorityWinnerReason2["NoMatch"] = "NoMatch";
+  NoPriorityWinnerReason2["Tie"] = "Tie";
+  return NoPriorityWinnerReason2;
+})(NoPriorityWinnerReason || {});
+var NO_PRIORITY_MATCH = Infinity;
+function filterHighestPriorityNotePaths(params) {
+  const rankedNotePaths = params.notePaths.map((notePath) => ({
+    notePath,
+    rank: params.rank(notePath)
+  }));
+  let bestRank = NO_PRIORITY_MATCH;
+  for (const ranked of rankedNotePaths) {
+    if (ranked.rank < bestRank) {
+      bestRank = ranked.rank;
+    }
   }
-  constructor(params) {
-    super(params);
+  return rankedNotePaths.filter((ranked) => ranked.rank === bestRank).map((ranked) => ranked.notePath);
+}
+function findNoPriorityWinnerReason(params) {
+  if (params.entries.length === 0) {
+    return "EmptyList" /* EmptyList */;
   }
-  /**
-   * Recomputes the current value from the registry, firing `change` only when it actually changed.
-   */
-  refresh() {
-    const record = selectRecord(this.params);
-    if (record === this.record) {
-      return;
+  let bestRank = NO_PRIORITY_MATCH;
+  for (const notePath of params.notePaths) {
+    const currentRank = params.rank(notePath);
+    if (currentRank < bestRank) {
+      bestRank = currentRank;
     }
-    this.record = record;
-    this.handle = record === null ? null : createRevocableHandle(record, this.params.contract);
-    this.trigger("change");
   }
-  async whenAvailable(options) {
-    const currentValue = this.value;
-    if (currentValue !== null) {
-      return currentValue;
+  return bestRank === NO_PRIORITY_MATCH ? "NoMatch" /* NoMatch */ : "Tie" /* Tie */;
+}
+function findNotePriorityRank(params) {
+  let bestRank = NO_PRIORITY_MATCH;
+  let bestLength = -1;
+  for (const [index2, entry] of params.entries.entries()) {
+    if (entry.length <= bestLength) {
+      continue;
     }
-    try {
-      return await runWithTimeout({
-        operationFunction: async (abortSignal) => await this.waitForValue(abortSignal),
-        operationName: `watchPluginApi("${this.params.pluginId}").whenAvailable`,
-        timeoutInMilliseconds: options?.timeoutInMilliseconds ?? DEFAULT_WHEN_AVAILABLE_TIMEOUT_IN_MILLISECONDS
-      });
-    } catch {
-      throw this.createUnavailableError();
+    if (!checkEntryMatches(entry, params)) {
+      continue;
     }
+    bestRank = index2;
+    bestLength = entry.length;
   }
-  async waitForValue(abortSignal) {
-    return await new Promise((resolve2, reject) => {
-      const eventRef = this.on("change", () => {
-        handleChange();
-      });
-      function cleanUp() {
-        eventRef.asyncEventSource.offref(eventRef);
-        abortSignal.removeEventListener("abort", handleAbort);
-      }
-      function handleAbort() {
-        cleanUp();
-        reject(abortSignal.reason);
-      }
-      const handleChange = () => {
-        const value = this.value;
-        if (value !== null) {
-          cleanUp();
-          resolve2(value);
-        }
-      };
-      abortSignal.addEventListener("abort", handleAbort);
-      handleChange();
-    });
+  return bestRank;
+}
+function pickHighestPriorityNotePath(params) {
+  let bestRank = NO_PRIORITY_MATCH;
+  let bestNotePath = null;
+  let bestCount = 0;
+  for (const notePath of params.notePaths) {
+    const currentRank = params.rank(notePath);
+    if (currentRank < bestRank) {
+      bestRank = currentRank;
+      bestNotePath = notePath;
+      bestCount = 1;
+    } else if (currentRank === bestRank) {
+      bestCount++;
+    }
+  }
+  if (bestCount !== 1 || bestRank === NO_PRIORITY_MATCH) {
+    return null;
+  }
+  return bestNotePath;
+}
+function checkEntryMatches(entry, params) {
+  if (!entry) {
+    return false;
+  }
+  if (entry.startsWith(PROPERTY_PREFIX)) {
+    return checkPropertyMatches(entry.slice(PROPERTY_PREFIX.length), params.frontmatter);
+  }
+  if (entry.length > 1 && entry.startsWith(REG_EXP_DELIMITER) && entry.endsWith(REG_EXP_DELIMITER)) {
+    const source = entry.slice(1, -1);
+    return isValidRegExp(source) && new RegExp(source).test(params.notePath);
+  }
+  if (entry.startsWith(EXTENSION_PREFIX)) {
+    return params.notePath.toLowerCase().endsWith(entry.toLowerCase());
+  }
+  const prefix = entry.endsWith("/") ? entry : `${entry}/`;
+  return params.notePath === entry || params.notePath.startsWith(prefix);
+}
+function checkPropertyMatches(specifier, frontmatter) {
+  if (!frontmatter) {
+    return false;
   }
-};
-var PluginApiUnavailableError = class extends Error {
-  /**
-   * The `manifest.id` of the plugin whose API was requested.
-   */
-  pluginId;
+  const separatorIndex = specifier.indexOf(PROPERTY_VALUE_SEPARATOR);
+  if (separatorIndex === -1) {
+    return Object.hasOwn(frontmatter, specifier);
+  }
+  const propertyName = specifier.slice(0, separatorIndex);
+  const expectedValue = specifier.slice(separatorIndex + 1);
+  if (!Object.hasOwn(frontmatter, propertyName)) {
+    return false;
+  }
+  const actualValue = frontmatter[propertyName];
+  if (Array.isArray(actualValue)) {
+    return actualValue.some((item) => String(item) === expectedValue);
+  }
+  return String(actualValue) === expectedValue;
+}
+
+// src/obsidian/obsidian-protocol-handler-registrar.ts
+var obsidian_protocol_handler_registrar_exports = {};
+__export(obsidian_protocol_handler_registrar_exports, {
+  PluginObsidianProtocolHandlerRegistrar: () => PluginObsidianProtocolHandlerRegistrar
+});
+init_async();
+var PluginObsidianProtocolHandlerRegistrar = class {
   /**
-   * Which of the five failures occurred.
+   * The Obsidian plugin instance the protocol handlers are registered with.
    */
-  reason;
+  plugin;
   /**
-   * Creates a {@link PluginApiUnavailableError}.
+   * Creates a new instance of the {@link PluginObsidianProtocolHandlerRegistrar} class.
    *
-   * @param params - The parameters for the error.
+   * @param plugin - The plugin to register the protocol handler with.
    */
-  constructor(params) {
-    super(params.message ?? `The API of the plugin "${params.pluginId}" is unavailable: ${params.reason}.`);
-    this.name = "PluginApiUnavailableError";
-    this.pluginId = params.pluginId;
-    this.reason = params.reason;
+  constructor(plugin) {
+    this.plugin = plugin;
   }
-};
-var PluginApiRevokedError = class extends PluginApiUnavailableError {
   /**
-   * Creates a {@link PluginApiRevokedError}.
+   * Registers an Obsidian protocol handler.
    *
-   * @param pluginId - The `manifest.id` of the plugin whose API was revoked.
+   * @param params - The parameters for the Obsidian protocol handler registration.
    */
-  constructor(pluginId) {
-    super({
-      message: `The API of the plugin "${pluginId}" has been revoked, because the plugin was unloaded.`,
-      pluginId,
-      reason: "revoked" /* Revoked */
-    });
-    this.name = "PluginApiRevokedError";
+  registerObsidianProtocolHandler(params) {
+    this.plugin.registerObsidianProtocolHandler(params.action, (obsidianProtocolData) => normalizePromisable(params.handler(obsidianProtocolData)));
   }
 };
-var PluginApiValidationError = class extends Error {
-  /**
-   * The issues the schema reported.
-   */
-  issues;
-  /**
-   * The name of the method whose payload failed validation.
-   */
-  methodName;
-  /**
-   * The `manifest.id` of the providing plugin.
-   */
-  pluginId;
-  /**
-   * Creates a {@link PluginApiValidationError}.
-   *
-   * @param params - The parameters for the error.
-   */
-  constructor(params) {
-    super(
-      `The ${params.payloadKind} of "${params.pluginId}" API method "${params.methodName}" failed validation: ${formatIssues(params.issues)}`
-    );
-    this.name = "PluginApiValidationError";
-    this.issues = params.issues;
-    this.methodName = params.methodName;
-    this.pluginId = params.pluginId;
+
+// src/obsidian/path-settings.ts
+var path_settings_exports = {};
+__export(path_settings_exports, {
+  PathSettings: () => PathSettings,
+  pathsValidator: () => pathsValidator
+});
+init_reg_exp();
+init_string();
+init_type_guards();
+init_i18n();
+var PathSetting = class {
+  constructor(type) {
+    this.type = type;
+    this.defaultRegExp = getDefaultRegExp(type);
+    this.regExp = this.defaultRegExp;
   }
-};
-function publishPluginApi(params) {
-  const pluginId = params.plugin.manifest.id;
-  const registry = getRegistry();
-  const records = registry.records[pluginId] ?? [];
-  registry.records[pluginId] = records;
-  if (records.some((record2) => record2.apiVersion === params.apiVersion)) {
-    throw new Error(`The plugin "${pluginId}" has already published the API version "${params.apiVersion}".`);
+  type;
+  get array() {
+    return this._array;
   }
-  const record = {
-    api: params.api,
-    apiVersion: params.apiVersion,
-    contract: params.contract ?? {},
-    isRevoked: false,
-    pluginId
-  };
-  records.push(record);
-  notifySubscribers();
-  params.plugin.register(() => {
-    revokeRecord(record);
-  });
-}
-function watchPluginApi(params) {
-  const ref = new PluginApiRefImpl(params);
-  const unsubscribe = subscribe(() => {
-    ref.refresh();
-  });
-  params.component.register(unsubscribe);
-  ref.refresh();
-  return ref;
-}
-function checkIsPromiseLike(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function checkMatchesContractShape(record, consumerContract) {
-  const contract = consumerContract ?? record.contract;
-  return Object.keys(contract).every((methodName) => typeof getMember(record.api, methodName) === "function");
-}
-function createMethodWrapper(params) {
-  return function pluginApiMethod(...$arguments) {
-    const method = castTo(getMember(params.target, params.propertyKey));
-    const methodContract = params.methodContract;
-    if (methodContract === void 0 || !getPluginApiDebugger().enabled) {
-      return method.apply(params.target, $arguments);
-    }
-    if (methodContract.input) {
-      validatePayload({
-        methodName: params.methodName,
-        payloadKind: "input" /* Input */,
-        pluginId: params.pluginId,
-        schema: methodContract.input,
-        value: $arguments
-      });
-    }
-    const returnValue = method.apply(params.target, $arguments);
-    const outputSchema = methodContract.output;
-    if (!outputSchema) {
-      return returnValue;
-    }
-    if (checkIsPromiseLike(returnValue)) {
-      return returnValue.then((resolvedValue) => {
-        validatePayload({
-          methodName: params.methodName,
-          payloadKind: "output" /* Output */,
-          pluginId: params.pluginId,
-          schema: outputSchema,
-          value: resolvedValue
-        });
-        return resolvedValue;
-      });
-    }
-    validatePayload({
-      methodName: params.methodName,
-      payloadKind: "output" /* Output */,
-      pluginId: params.pluginId,
-      schema: outputSchema,
-      value: returnValue
-    });
-    return returnValue;
-  };
-}
-function createRevocableHandle(record, consumerContract) {
-  const contract = consumerContract ?? record.contract;
-  const methodCache = /* @__PURE__ */ new Map();
-  return new Proxy(record.api, {
-    get(target, propertyKey) {
-      if (record.isRevoked) {
-        throw new PluginApiRevokedError(record.pluginId);
+  set array(value) {
+    this._array = value.filter(Boolean);
+    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;
+  }
+  _array = [];
+  defaultRegExp;
+  regExp;
+  isPathIgnored(path) {
+    switch (this.type) {
+      /* v8 ignore stop */
+      case "Exclude" /* Exclude */: {
+        return this.regExp.test(path);
       }
-      const value = getMember(target, propertyKey);
-      if (typeof value !== "function") {
-        return value;
+      case "Include" /* Include */: {
+        return !this.regExp.test(path);
       }
-      let method = methodCache.get(propertyKey);
-      if (method === void 0) {
-        method = createMethodWrapper({
-          methodContract: typeof propertyKey === "string" ? contract[propertyKey] : void 0,
-          methodName: String(propertyKey),
-          pluginId: record.pluginId,
-          propertyKey,
-          target
-        });
-        methodCache.set(propertyKey, method);
+      default: {
+        assertNever(this.type);
       }
-      return method;
     }
-  });
-}
-function formatIssues(issues) {
-  return issues.map((issue) => {
-    const path = issue.path?.map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".");
-    return path ? `${path}: ${issue.message}` : issue.message;
-  }).join("; ");
-}
-function getLiveRecords(pluginId) {
-  return (getRegistry().records[pluginId] ?? []).filter((record) => !record.isRevoked);
-}
-function getMember(api, methodName) {
-  return Reflect.get(api, methodName);
-}
-function getPluginApiDebugger() {
-  return getLibDebugger(PLUGIN_API_DEBUGGER_NAMESPACE);
-}
-function getRegistry() {
-  const wrapper = getObsidianDevUtilsState(PLUGIN_API_REGISTRY_STATE_KEY, {});
-  const registry = wrapper.value;
-  registry.records ??= {};
-  registry.subscribers ??= [];
-  return castTo(registry);
-}
-function notifySubscribers() {
-  for (const subscriber of snapshot(getRegistry().subscribers)) {
-    subscriber();
   }
-}
-function resolveUnavailabilityReason(params) {
-  if (!Object.hasOwn(params.app.plugins.manifests, params.pluginId)) {
-    return "notInstalled" /* NotInstalled */;
+};
+var PathSettings = class {
+  /**
+   * Gets the exclude paths.
+   *
+   * @returns The exclude paths.
+   */
+  get excludePaths() {
+    return this._excludePaths.array;
+  }
+  /**
+   * Sets the exclude paths.
+   *
+   * @param value - The exclude paths.
+   */
+  set excludePaths(value) {
+    this._excludePaths.array = value;
   }
-  if (!params.app.plugins.enabledPlugins.has(params.pluginId)) {
-    return "notEnabled" /* NotEnabled */;
+  /**
+   * Gets the include paths.
+   *
+   * @returns The include paths.
+   */
+  get includePaths() {
+    return this._includePaths.array;
   }
-  const records = getLiveRecords(params.pluginId);
-  if (records.length === 0) {
-    return "notPublished" /* NotPublished */;
+  /**
+   * Sets the include paths.
+   *
+   * @param value - The include paths.
+   */
+  set includePaths(value) {
+    this._includePaths.array = value;
   }
-  if (records.every((record) => !(0, import_compare_versions3.satisfies)(record.apiVersion, params.apiVersionRange))) {
-    return "versionMismatch" /* VersionMismatch */;
+  _excludePaths = new PathSetting("Exclude" /* Exclude */);
+  _includePaths = new PathSetting("Include" /* Include */);
+  /**
+   * Checks if a path is ignored by the include/exclude path settings.
+   *
+   * @param path - The path to check.
+   * @returns `true` if the path is ignored, `false` otherwise.
+   */
+  isPathIgnored(path) {
+    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);
   }
-  return "shapeMismatch" /* ShapeMismatch */;
-}
-function revokeRecord(record) {
-  record.isRevoked = true;
-  const registry = getRegistry();
-  const records = registry.records[record.pluginId];
-  if (records) {
-    registry.records[record.pluginId] = records.filter((candidate) => candidate !== record);
+};
+function pathsValidator(paths) {
+  for (const path of paths) {
+    if (path.startsWith("/") && path.endsWith("/") && !isValidRegExp(path.slice(1, -1))) {
+      return t2(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });
+    }
   }
-  notifySubscribers();
-}
-function selectRecord(params) {
-  const candidates = getLiveRecords(params.pluginId).filter((record) => (0, import_compare_versions3.satisfies)(record.apiVersion, params.apiVersionRange)).filter((record) => checkMatchesContractShape(record, params.contract)).sort((a2, b) => (0, import_compare_versions3.compareVersions)(b.apiVersion, a2.apiVersion));
-  return candidates[0] ?? null;
 }
-function subscribe(subscriber) {
-  const registry = getRegistry();
-  registry.subscribers.push(subscriber);
-  return () => {
-    const index2 = registry.subscribers.indexOf(subscriber);
-    if (index2 !== -1) {
-      registry.subscribers.splice(index2, 1);
+function getDefaultRegExp(type) {
+  switch (type) {
+    /* v8 ignore stop */
+    case "Exclude" /* Exclude */: {
+      return NEVER_MATCH_REG_EXP;
     }
-  };
+    case "Include" /* Include */: {
+      return ALWAYS_MATCH_REG_EXP;
+    }
+    default: {
+      assertNever(type);
+    }
+  }
 }
-function validatePayload(params) {
-  const result = params.schema["~standard"].validate(params.value);
-  if (checkIsPromiseLike(result)) {
-    invokeAsyncSafely(async () => {
-      const asyncResult = await result;
-      if (asyncResult.issues) {
-        getPluginApiDebugger()(
-          'Asynchronous validation of the %s of "%s" API method "%s" failed: %s',
-          params.payloadKind,
-          params.pluginId,
-          params.methodName,
-          formatIssues(asyncResult.issues)
-        );
-      }
+function makeRegExp(paths, defaultRegExp) {
+  if (paths.length === 0) {
+    return defaultRegExp;
+  }
+  const regExpStringCombined = paths.map((path) => {
+    if (path === "/") {
+      return defaultRegExp.source;
+    }
+    if (path.startsWith("/") && path.endsWith("/")) {
+      return path.slice(1, -1);
+    }
+    path = trimEnd({
+      $string: path,
+      suffix: "/"
     });
-    return;
+    return `^${escapeRegExp(path)}(/|$)`;
+  }).map((regExpString) => `(${regExpString})`).join("|");
+  try {
+    return new RegExp(regExpStringCombined);
+  } catch {
+    return null;
   }
-  if (result.issues) {
-    throw new PluginApiValidationError({
-      issues: result.issues,
-      methodName: params.methodName,
-      payloadKind: params.payloadKind,
-      pluginId: params.pluginId
+}
+
+// src/obsidian/pdf.ts
+var pdf_exports = {};
+__export(pdf_exports, {
+  printToPdf: () => printToPdf
+});
+var import_obsidian136 = require("obsidian");
+var ELECTRON_PRINT_TO_PDF_CHANNEL = "print-to-pdf";
+async function printToPdf(element, options) {
+  if (import_obsidian136.Platform.isMobile) {
+    throw new Error("Printing to PDF is not supported on mobile devices.");
+  }
+  const printDiv = activeDocument.body.createDiv("print");
+  printDiv.append(element);
+  await ensureLoaded(printDiv);
+  const DEFAULT_SCALE_FACTOR = 100;
+  const DEFAULT_OPTIONS = {
+    filepath: "Untitled.pdf",
+    includeName: false,
+    landscape: false,
+    marginsType: 0,
+    open: true,
+    pageSize: "A4",
+    scale: 1,
+    scaleFactor: DEFAULT_SCALE_FACTOR
+  };
+  const fullOptions = { ...DEFAULT_OPTIONS, ...options };
+  try {
+    await new Promise((resolve2) => {
+      activeWindow.electron.ipcRenderer.once(ELECTRON_PRINT_TO_PDF_CHANNEL, resolve2);
+      activeWindow.electron.ipcRenderer.send(ELECTRON_PRINT_TO_PDF_CHANNEL, fullOptions);
     });
+  } finally {
+    printDiv.remove();
   }
 }
 
+// src/obsidian/plugin-cli-handler-registrar.ts
+var plugin_cli_handler_registrar_exports = {};
+__export(plugin_cli_handler_registrar_exports, {
+  PluginCliHandlerRegistrar: () => PluginCliHandlerRegistrar
+});
+var import_obsidian137 = require("obsidian");
+init_async();
+var PluginCliHandlerRegistrar = class {
+  /**
+   * Creates a new instance of the {@link PluginCliHandlerRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers a CLI handler.
+   *
+   * @param params - The parameters for the CLI handler registration.
+   */
+  registerCliHandler(params) {
+    this.plugin.registerCliHandler(params.command, params.description, params.flags, (cliData) => normalizePromisable(params.handler(cliData)));
+  }
+};
+
+// src/obsidian/plugin/obsidian-plugin-repo-paths.ts
+var obsidian_plugin_repo_paths_exports = {};
+__export(obsidian_plugin_repo_paths_exports, {
+  ObsidianPluginRepoPaths: () => ObsidianPluginRepoPaths
+});
+var ObsidianPluginRepoPaths = /* @__PURE__ */ ((ObsidianPluginRepoPaths2) => {
+  ObsidianPluginRepoPaths2["AnyAndroidCaptureIntegrationTestTs"] = "*.android-capture.integration.test.ts";
+  ObsidianPluginRepoPaths2["AnyAndroidIntegrationTestTs"] = "*.android.integration.test.ts";
+  ObsidianPluginRepoPaths2["AnyCjs"] = "*.cjs";
+  ObsidianPluginRepoPaths2["AnyDesktopTs"] = "desktop-*.ts";
+  ObsidianPluginRepoPaths2["AnyIntegrationTestTs"] = "*.integration.test.ts";
+  ObsidianPluginRepoPaths2["AnyJs"] = "*.js";
+  ObsidianPluginRepoPaths2["AnyMjs"] = "*.mjs";
+  ObsidianPluginRepoPaths2["AnyPath"] = "**";
+  ObsidianPluginRepoPaths2["AnyTestTs"] = "*.test.ts";
+  ObsidianPluginRepoPaths2["AnyTs"] = "*.ts";
+  ObsidianPluginRepoPaths2["AnyTsx"] = "*.tsx";
+  ObsidianPluginRepoPaths2["AppJson"] = "app.json";
+  ObsidianPluginRepoPaths2["ChangelogMd"] = "CHANGELOG.md";
+  ObsidianPluginRepoPaths2["CommitlintConfigTs"] = "commitlint.config.ts";
+  ObsidianPluginRepoPaths2["CurrentFolder"] = ".";
+  ObsidianPluginRepoPaths2["DemoVault"] = "demo-vault";
+  ObsidianPluginRepoPaths2["Dist"] = "dist";
+  ObsidianPluginRepoPaths2["DistBuild"] = "dist/build";
+  ObsidianPluginRepoPaths2["DistDev"] = "dist/dev";
+  ObsidianPluginRepoPaths2["DotObsidian"] = ".obsidian";
+  ObsidianPluginRepoPaths2["EslintConfigCjs"] = "eslint.config.cjs";
+  ObsidianPluginRepoPaths2["EslintConfigCts"] = "eslint.config.cts";
+  ObsidianPluginRepoPaths2["EslintConfigJs"] = "eslint.config.js";
+  ObsidianPluginRepoPaths2["EslintConfigMjs"] = "eslint.config.mjs";
+  ObsidianPluginRepoPaths2["EslintConfigMts"] = "eslint.config.mts";
+  ObsidianPluginRepoPaths2["EslintConfigTs"] = "eslint.config.ts";
+  ObsidianPluginRepoPaths2["HotReload"] = ".hotreload";
+  ObsidianPluginRepoPaths2["License"] = "LICENSE";
+  ObsidianPluginRepoPaths2["MainCss"] = "main.css";
+  ObsidianPluginRepoPaths2["MainJs"] = "main.js";
+  ObsidianPluginRepoPaths2["MainTs"] = "main.ts";
+  ObsidianPluginRepoPaths2["ManifestBetaJson"] = "manifest-beta.json";
+  ObsidianPluginRepoPaths2["ManifestJson"] = "manifest.json";
+  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigCjs"] = ".markdownlint-cli2.cjs";
+  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigJsonc"] = ".markdownlint-cli2.jsonc";
+  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigMjs"] = ".markdownlint-cli2.mjs";
+  ObsidianPluginRepoPaths2["MarkdownlintCli2ConfigYaml"] = ".markdownlint-cli2.yaml";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigCjs"] = ".markdownlint.cjs";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigJson"] = ".markdownlint.json";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigJsonc"] = ".markdownlint.jsonc";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigMjs"] = ".markdownlint.mjs";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigYaml"] = ".markdownlint.yaml";
+  ObsidianPluginRepoPaths2["MarkdownlintConfigYml"] = ".markdownlint.yml";
+  ObsidianPluginRepoPaths2["Mocks"] = "src/test-helpers";
+  ObsidianPluginRepoPaths2["NodeModules"] = "node_modules";
+  ObsidianPluginRepoPaths2["NpmShrinkwrapJson"] = "npm-shrinkwrap.json";
+  ObsidianPluginRepoPaths2["PackageJson"] = "package.json";
+  ObsidianPluginRepoPaths2["PackageLockJson"] = "package-lock.json";
+  ObsidianPluginRepoPaths2["Plugins"] = "plugins";
+  ObsidianPluginRepoPaths2["Scripts"] = "scripts";
+  ObsidianPluginRepoPaths2["ScriptUtils"] = "src/script-utils";
+  ObsidianPluginRepoPaths2["Src"] = "src";
+  ObsidianPluginRepoPaths2["StylesCss"] = "styles.css";
+  ObsidianPluginRepoPaths2["Tests"] = "__tests__";
+  ObsidianPluginRepoPaths2["TsConfigJson"] = "tsconfig.json";
+  ObsidianPluginRepoPaths2["VersionsJson"] = "versions.json";
+  ObsidianPluginRepoPaths2["VitestConfigTs"] = "vitest.config.ts";
+  return ObsidianPluginRepoPaths2;
+})(ObsidianPluginRepoPaths || {});
+
 // src/__merged.ts
 init_plugin_context();
 
@@ -39191,6 +39278,7 @@ __export(components_exports, {
   "registry-component": () => registry_component_exports,
   "rename-delete-handler-component": () => rename_delete_handler_component_exports,
   "rmdir-guard-component": () => rmdir_guard_component_exports,
+  "settings-migration-component": () => settings_migration_component_exports,
   "syntax-highlighting-component": () => syntax_highlighting_component_exports
 });
 init_component_ex();
@@ -39276,10 +39364,14 @@ __export(plugin_exports2, {
   "plugin-api": () => plugin_api_exports,
   "plugin-context": () => plugin_context_exports,
   "plugin-event-source": () => plugin_event_source_exports,
-  "plugin-settings-tab": () => plugin_settings_tab_exports
+  "plugin-settings-tab": () => plugin_settings_tab_exports,
+  "settings-migration-api": () => settings_migration_api_exports
 });
 init_plugin_context();
 
+// src/obsidian/plugin/settings-migration-api.ts
+var settings_migration_api_exports = {};
+
 // src/obsidian/popovers/index.ts
 var popovers_exports = {};
 __export(popovers_exports, {