obsidian-dev-utils 101.5.0 → 101.7.0

package/dist/lib/esm/obsidian/components/settings-migration-component.d.mts

@@ -0,0 +1,120 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that offers settings this plugin used to own to the plugin that owns them now, once, through
+ * that plugin's public API.
+ *
+ * This is the other half of {@link obsidian/components/plugin-suggestion-component!PluginSuggestionComponent}.
+ * The suggestion asks the user to install the plugin that took a feature over; this carries the settings they
+ * had configured for it across, so taking the suggestion does not mean re-entering everything by hand.
+ *
+ * A proposing plugin never writes into another plugin's `data.json`. It PROPOSES: the other plugin owns the
+ * settings, so it owns the dialog, and the user approves, edits or declines. Only an applied migration retires
+ * the pending values.
+ *
+ * The offer is made whenever it CAN succeed, which needs two independent things to have happened — the
+ * provider's API being available, and this plugin's own settings having arrived from disk. Either can land
+ * first, so both edges are wired and each re-reads the current state rather than assuming the other has
+ * already happened.
+ */
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { PluginApiContract } from '../plugin/plugin-api.mjs';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Parameters for the {@link SettingsMigrationComponent} constructor.
+ *
+ * @typeParam TMigratableSettings - The settings this plugin may hand over.
+ */
+export interface SettingsMigrationComponentConstructorParams<TMigratableSettings extends object> {
+    /**
+     * The semver range of contract versions this plugin compiled against, e.g. `'^1'`.
+     *
+     * @remarks
+     * Evaluated by `compare-versions`, which does NOT accept a bare `*`. Spell "any version" as `'>=0.0.0'`.
+     */
+    readonly apiVersionRange: string;
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The contract this plugin expects of the provider, which wins over the provider's own when supplied.
+     *
+     * Worth supplying, and worth keeping NARROW. A migration usually needs one method that has existed since the
+     * provider's first contract version, while the same plugin may read other parts of that API through a much
+     * newer one. Declaring the wider expectation here would refuse to offer the migration to a user on an older
+     * provider — which is precisely the user who still has settings to migrate.
+     */
+    readonly contract?: PluginApiContract;
+    /**
+     * Reads the values currently waiting to be handed over.
+     *
+     * Called afresh on every edge rather than once, so an implementation simply reads its plugin's settings.
+     * Return `null` when there is nothing pending — after a migration has been applied, or on a vault that never
+     * had these settings configured.
+     *
+     * @returns The values to propose, or `null` when there is nothing to offer.
+     */
+    getProposedSettings(this: void): null | TMigratableSettings;
+    /**
+     * The settings component of the plugin making the proposal.
+     *
+     * Taken as a whole component rather than as a bare "ready" flag so the host cannot forget to wire the wait:
+     * whatever {@link getProposedSettings} reads is meaningless until this component has read `data.json`.
+     */
+    readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
+    /**
+     * The `manifest.id` of the plugin that owns these settings now, as listed in Obsidian's community plugin
+     * registry.
+     */
+    readonly providerPluginId: string;
+    /**
+     * Records that the pending values have been handed over, so the offer is not made again.
+     *
+     * Called ONLY when the user actually applied the migration.
+     *
+     * @returns A {@link Promise} that resolves once the retirement is persisted.
+     *
+     * @remarks
+     * An implementation must PERSIST the retirement — `pluginSettingsComponent.editAndSave(…)`, not
+     * `setProperty(…)`. The latter only edits the in-memory state, so the retirement is forgotten on the next
+     * reload and the migration is offered again forever.
+     */
+    retireProposedSettings(this: void): Promisable<void>;
+    /**
+     * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings these
+     * are.
+     */
+    readonly sourcePluginId: string;
+}
+/**
+ * Offers settings this plugin used to own to the plugin that owns them now.
+ *
+ * @typeParam TMigratableSettings - The settings this plugin may hand over.
+ */
+export declare class SettingsMigrationComponent<TMigratableSettings extends object> extends ComponentEx {
+    private readonly apiVersionRange;
+    private readonly app;
+    private readonly contract;
+    private readonly getProposedSettings;
+    private isProposing;
+    private readonly pluginSettingsComponent;
+    private readonly providerPluginId;
+    private readonly retireProposedSettings;
+    private readonly sourcePluginId;
+    /**
+     * Creates an instance of {@link SettingsMigrationComponent}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: SettingsMigrationComponentConstructorParams<TMigratableSettings>);
+    /**
+     * Loads the component, wiring both edges that can make an offer possible.
+     */
+    onload(): void;
+    private handleChange;
+    private propose;
+}

package/dist/lib/esm/obsidian/components/settings-migration-component.mjs

@@ -0,0 +1,127 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureBrowserProcess();
+})();
+})();
+
+import { invokeAsyncSafely } from "../../async.mjs";
+import { normalizeOptionalProperties } from "../../object-utils.mjs";
+import { watchPluginApi } from "../plugin/plugin-api.mjs";
+import { registerAsyncEvent } from "./async-events-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class SettingsMigrationComponent extends ComponentEx {
+  apiVersionRange;
+  app;
+  contract;
+  getProposedSettings;
+  isProposing = false;
+  pluginSettingsComponent;
+  providerPluginId;
+  retireProposedSettings;
+  sourcePluginId;
+  /**
+   * 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;
+    }
+  }
+}
+export {
+  SettingsMigrationComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/settings-migration-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that offers settings this plugin used to own to the plugin that owns them now, once, through\n * that plugin's public API.\n *\n * This is the other half of {@link obsidian/components/plugin-suggestion-component!PluginSuggestionComponent}.\n * The suggestion asks the user to install the plugin that took a feature over; this carries the settings they\n * had configured for it across, so taking the suggestion does not mean re-entering everything by hand.\n *\n * A proposing plugin never writes into another plugin's `data.json`. It PROPOSES: the other plugin owns the\n * settings, so it owns the dialog, and the user approves, edits or declines. Only an applied migration retires\n * the pending values.\n *\n * The offer is made whenever it CAN succeed, which needs two independent things to have happened \u2014 the\n * provider's API being available, and this plugin's own settings having arrived from disk. Either can land\n * first, so both edges are wired and each re-reads the current state rather than assuming the other has\n * already happened.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type {\n  PluginApiContract,\n  PluginApiRef,\n  WatchPluginApiParams\n} from '../plugin/plugin-api.ts';\nimport type { SettingsMigrationApi } from '../plugin/settings-migration-api.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport { normalizeOptionalProperties } from '../../object-utils.ts';\nimport { watchPluginApi } from '../plugin/plugin-api.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * Parameters for the {@link SettingsMigrationComponent} constructor.\n *\n * @typeParam TMigratableSettings - The settings this plugin may hand over.\n */\nexport interface SettingsMigrationComponentConstructorParams<TMigratableSettings extends object> {\n  /**\n   * The semver range of contract versions this plugin compiled against, e.g. `'^1'`.\n   *\n   * @remarks\n   * Evaluated by `compare-versions`, which does NOT accept a bare `*`. Spell \"any version\" as `'>=0.0.0'`.\n   */\n  readonly apiVersionRange: string;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The contract this plugin expects of the provider, which wins over the provider's own when supplied.\n   *\n   * Worth supplying, and worth keeping NARROW. A migration usually needs one method that has existed since the\n   * provider's first contract version, while the same plugin may read other parts of that API through a much\n   * newer one. Declaring the wider expectation here would refuse to offer the migration to a user on an older\n   * provider \u2014 which is precisely the user who still has settings to migrate.\n   */\n  readonly contract?: PluginApiContract;\n\n  /**\n   * Reads the values currently waiting to be handed over.\n   *\n   * Called afresh on every edge rather than once, so an implementation simply reads its plugin's settings.\n   * Return `null` when there is nothing pending \u2014 after a migration has been applied, or on a vault that never\n   * had these settings configured.\n   *\n   * @returns The values to propose, or `null` when there is nothing to offer.\n   */\n  getProposedSettings(this: void): null | TMigratableSettings;\n\n  /**\n   * The settings component of the plugin making the proposal.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag so the host cannot forget to wire the wait:\n   * whatever {@link getProposedSettings} reads is meaningless until this component has read `data.json`.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * The `manifest.id` of the plugin that owns these settings now, as listed in Obsidian's community plugin\n   * registry.\n   */\n  readonly providerPluginId: string;\n\n  /**\n   * Records that the pending values have been handed over, so the offer is not made again.\n   *\n   * Called ONLY when the user actually applied the migration.\n   *\n   * @returns A {@link Promise} that resolves once the retirement is persisted.\n   *\n   * @remarks\n   * An implementation must PERSIST the retirement \u2014 `pluginSettingsComponent.editAndSave(\u2026)`, not\n   * `setProperty(\u2026)`. The latter only edits the in-memory state, so the retirement is forgotten on the next\n   * reload and the migration is offered again forever.\n   */\n  retireProposedSettings(this: void): Promisable<void>;\n\n  /**\n   * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings these\n   * are.\n   */\n  readonly sourcePluginId: string;\n}\n\n/**\n * Offers settings this plugin used to own to the plugin that owns them now.\n *\n * @typeParam TMigratableSettings - The settings this plugin may hand over.\n */\nexport class SettingsMigrationComponent<TMigratableSettings extends object> extends ComponentEx {\n  private readonly apiVersionRange: string;\n  private readonly app: App;\n  private readonly contract: PluginApiContract | undefined;\n  private readonly getProposedSettings: () => null | TMigratableSettings;\n  private isProposing = false;\n  private readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n  private readonly providerPluginId: string;\n  private readonly retireProposedSettings: () => Promisable<void>;\n  private readonly sourcePluginId: string;\n\n  /**\n   * Creates an instance of {@link SettingsMigrationComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: SettingsMigrationComponentConstructorParams<TMigratableSettings>) {\n    super();\n    this.apiVersionRange = params.apiVersionRange;\n    this.app = params.app;\n    this.contract = params.contract;\n    this.getProposedSettings = params.getProposedSettings;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.providerPluginId = params.providerPluginId;\n    this.retireProposedSettings = params.retireProposedSettings;\n    this.sourcePluginId = params.sourcePluginId;\n  }\n\n  /**\n   * Loads the component, wiring both edges that can make an offer possible.\n   */\n  public override onload(): void {\n    // Nothing is gated on the pending values HERE. The settings component is a sibling whose own load is still\n    // In flight at this point, so it still holds the DEFAULTS \u2014 reading the pending values now would see\n    // Nothing on exactly the vaults that have something, register no watch, and lose the migration for good.\n    // Both edges are wired instead, and `propose` re-reads the values each time it runs.\n    const ref = watchPluginApi<SettingsMigrationApi<TMigratableSettings>>(normalizeOptionalProperties<WatchPluginApiParams>({\n      apiVersionRange: this.apiVersionRange,\n      app: this.app,\n      component: this,\n      contract: this.contract,\n      pluginId: this.providerPluginId\n    }));\n\n    // Driven by the ref's own event rather than by `whenAvailable()`, deliberately. That wait blocks for ten\n    // Seconds and then throws when the provider is simply not installed, which would stall this plugin's load\n    // For every user who declines the suggestion. Watching costs nothing while the provider is absent and\n    // Offers the migration the moment it appears \u2014 including right after the user installs it from the\n    // Suggestion banner.\n    registerAsyncEvent(\n      this,\n      ref.on('change', () => {\n        this.handleChange(ref);\n      })\n    );\n\n    // The second edge: this plugin's own settings arriving from disk. It may fire before or after the first.\n    registerAsyncEvent(\n      this,\n      this.pluginSettingsComponent.on('loadSettings', () => {\n        this.handleChange(ref);\n      })\n    );\n\n    this.handleChange(ref);\n  }\n\n  private handleChange(ref: PluginApiRef<SettingsMigrationApi<TMigratableSettings>>): void {\n    invokeAsyncSafely(async () => {\n      await this.propose(ref.value);\n    });\n  }\n\n  private async propose(api: null | SettingsMigrationApi<TMigratableSettings>): Promise<void> {\n    const proposedSettings = this.getProposedSettings();\n    if (!api || this.isProposing || proposedSettings === null) {\n      return;\n    }\n\n    // Both edges can fire while the provider's dialog is open, and each would raise a second one.\n    this.isProposing = true;\n    try {\n      const result = await api.migrateSettings({\n        proposedSettings,\n        sourcePluginId: this.sourcePluginId\n      });\n\n      // A cancel is not an answer, so the values stay pending and the offer comes back \u2014 on the next load, or\n      // As soon as the provider reloads. Only an applied migration retires them.\n      if (result.isApplied) {\n        await this.retireProposedSettings();\n      }\n    } finally {\n      this.isProposing = false;\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAS,yBAAyB;AAClC,SAAS,mCAAmC;AAC5C,SAAS,sBAAsB;AAC/B,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AAkFrB,MAAM,mCAAuE,YAAY;AAAA,EAC7E;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACT,cAAc;AAAA,EACL;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAA0E;AAC3F,UAAM;AACN,SAAK,kBAAkB,OAAO;AAC9B,SAAK,MAAM,OAAO;AAClB,SAAK,WAAW,OAAO;AACvB,SAAK,sBAAsB,OAAO;AAClC,SAAK,0BAA0B,OAAO;AACtC,SAAK,mBAAmB,OAAO;AAC/B,SAAK,yBAAyB,OAAO;AACrC,SAAK,iBAAiB,OAAO;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA,EAKgB,SAAe;AAK7B,UAAM,MAAM,eAA0D,4BAAkD;AAAA,MACtH,iBAAiB,KAAK;AAAA,MACtB,KAAK,KAAK;AAAA,MACV,WAAW;AAAA,MACX,UAAU,KAAK;AAAA,MACf,UAAU,KAAK;AAAA,IACjB,CAAC,CAAC;AAOF;AAAA,MACE;AAAA,MACA,IAAI,GAAG,UAAU,MAAM;AACrB,aAAK,aAAa,GAAG;AAAA,MACvB,CAAC;AAAA,IACH;AAGA;AAAA,MACE;AAAA,MACA,KAAK,wBAAwB,GAAG,gBAAgB,MAAM;AACpD,aAAK,aAAa,GAAG;AAAA,MACvB,CAAC;AAAA,IACH;AAEA,SAAK,aAAa,GAAG;AAAA,EACvB;AAAA,EAEQ,aAAa,KAAoE;AACvF,sBAAkB,YAAY;AAC5B,YAAM,KAAK,QAAQ,IAAI,KAAK;AAAA,IAC9B,CAAC;AAAA,EACH;AAAA,EAEA,MAAc,QAAQ,KAAsE;AAC1F,UAAM,mBAAmB,KAAK,oBAAoB;AAClD,QAAI,CAAC,OAAO,KAAK,eAAe,qBAAqB,MAAM;AACzD;AAAA,IACF;AAGA,SAAK,cAAc;AACnB,QAAI;AACF,YAAM,SAAS,MAAM,IAAI,gBAAgB;AAAA,QACvC;AAAA,QACA,gBAAgB,KAAK;AAAA,MACvB,CAAC;AAID,UAAI,OAAO,WAAW;AACpB,cAAM,KAAK,uBAAuB;AAAA,MACpC;AAAA,IACF,UAAE;AACA,WAAK,cAAc;AAAA,IACrB;AAAA,EACF;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/css-class.d.mts

@@ -149,6 +149,15 @@ export declare enum CssClass {
      * A CSS class for the password component.
      */
     PasswordComponent = "password-component",
+    /**
+     * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.
+     */
+    PluginConflictBanner = "plugin-conflict-banner",
+    /**
+     * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory
+     * dependency it is waiting for.
+     */
+    PluginDependencyBanner = "plugin-dependency-banner",
     /**
      * A CSS class for the close button of a notice that requires close confirmation.
      */

package/dist/lib/esm/obsidian/css-class.mjs

@@ -76,6 +76,8 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["OkButton"] = "ok-button";
   CssClass2["OverlayValidator"] = "overlay-validator";
   CssClass2["PasswordComponent"] = "password-component";
+  CssClass2["PluginConflictBanner"] = "plugin-conflict-banner";
+  CssClass2["PluginDependencyBanner"] = "plugin-dependency-banner";
   CssClass2["PluginNoticeCloseButton"] = "plugin-notice-close-button";
   CssClass2["PluginNoticeContent"] = "plugin-notice-content";
   CssClass2["PluginNoticeName"] = "plugin-notice-name";
@@ -108,4 +110,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 export {
   CssClass
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text \u2014 a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AA9TN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text \u2014 a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,0BAAuB;AAMvB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAzUN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}


package/dist/lib/esm/obsidian/html-element.d.mts

@@ -60,3 +60,39 @@ export declare function appendCodeBlock(element: DocumentFragment | HTMLElement,
  * @param params - The parameters for applying the spellcheck mode.
  */
 export declare function applySpellcheckMode(params: ApplySpellcheckModeParams): void;
+/**
+ * Marks a value so that {@link createFragmentWithCodeBlocks} renders it as an inline code block.
+ *
+ * Wrap a value with this before handing it to `t()`, and the translated message comes back with the value
+ * already in place, delimited:
+ *
+ * ```ts
+ * createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginSuggestion.installed, {
+ *   pluginName: asCodeBlock(pluginName)
+ * }));
+ * ```
+ *
+ * The marker travels WITH the value rather than being a positional placeholder the caller matches up
+ * afterwards. That distinction is the whole point: a message naming two plugins is interpolated by name,
+ * and a translation is free to put them in either order, so anything that re-associated values with
+ * placeholders by position would silently swap them the moment a sentence read the other way round.
+ *
+ * @param value - The value to render as a code block.
+ * @returns The value, delimited for {@link createFragmentWithCodeBlocks}.
+ */
+export declare function asCodeBlock(value: string): string;
+/**
+ * Builds a {@link DocumentFragment} from an already-translated message, rendering every value that was
+ * wrapped in {@link asCodeBlock} as an inline code block and the rest as plain text.
+ *
+ * The message stays ONE translatable unit. Splitting a sentence into a prefix and a suffix around the value
+ * is the obvious alternative and it does not survive translation: a language that reorders the clause, or
+ * that needs different case on the surrounding words, cannot express that through two fixed halves. Here
+ * the value sits wherever the translation puts it, and only its rendering is decided.
+ *
+ * A message with nothing marked comes back as plain text, so this is safe to apply to any message.
+ *
+ * @param message - The translated message, with its code values wrapped by {@link asCodeBlock}.
+ * @returns The fragment.
+ */
+export declare function createFragmentWithCodeBlocks(message: string): DocumentFragment;

package/dist/lib/esm/obsidian/html-element.mjs

@@ -46,6 +46,8 @@ import {
   isSpellcheckEnabledForMode,
   SpellcheckMode
 } from "./obsidian-settings.mjs";
+const PRIVATE_USE_AREA_FIRST_CODE_POINT = 57344;
+const CODE_BLOCK_DELIMITER = String.fromCodePoint(PRIVATE_USE_AREA_FIRST_CODE_POINT);
 function appendCodeBlock(element, code) {
   element.createEl("strong", { cls: `${CssClass.MarkdownRendered} ${CssClass.Code}` }, (strong) => {
     strong.createEl("code", { text: code });
@@ -59,8 +61,28 @@ function applySpellcheckMode(params) {
   } = params;
   element.setAttribute("spellcheck", String(isSpellcheckEnabledForMode(app, spellcheckMode)));
 }
+function asCodeBlock(value) {
+  return `${CODE_BLOCK_DELIMITER}${value}${CODE_BLOCK_DELIMITER}`;
+}
+function createFragmentWithCodeBlocks(message) {
+  const fragment = createFragment();
+  let isCodeSegment = false;
+  for (const segment of message.split(CODE_BLOCK_DELIMITER)) {
+    if (segment !== "") {
+      if (isCodeSegment) {
+        appendCodeBlock(fragment, segment);
+      } else {
+        fragment.appendText(segment);
+      }
+    }
+    isCodeSegment = !isCodeSegment;
+  }
+  return fragment;
+}
 export {
   appendCodeBlock,
-  applySpellcheckMode
+  applySpellcheckMode,
+  asCodeBlock,
+  createFragmentWithCodeBlocks
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2h0bWwtZWxlbWVudC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIE9ic2lkaWFuLXNwZWNpZmljIEhUTUwgZWxlbWVudCBoZWxwZXJzLlxuICpcbiAqIFVubGlrZSB0aGUgT2JzaWRpYW4tcnVudGltZS1hZ25vc3RpYyBoZWxwZXJzIGluIGBzcmMvaHRtbC1lbGVtZW50LnRzYCwgdGhlc2UgZGVwZW5kIG9uXG4gKiBPYnNpZGlhbi1zcGVjaWZpYyBwcmVzZW50YXRpb24gXHUyMDE0IHRoZSBgbWFya2Rvd24tcmVuZGVyZWRgIENTUyBjbGFzcyB0aGF0IHN0eWxlcyByZW5kZXJlZCBtYXJrZG93biwgYW5kXG4gKiB0aGUgYEVkaXRvciA+IFNwZWxsY2hlY2tgIHZhdWx0IHNldHRpbmcgXHUyMDE0IHNvIHRoZXkgbGl2ZSBpbiB0aGUgT2JzaWRpYW4gbGF5ZXIgYW5kIHVzZSBPYnNpZGlhbidzXG4gKiBgY3JlYXRlRWxgIERPTSBhdWdtZW50YXRpb24uXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBBcHAgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB7IENzc0NsYXNzIH0gZnJvbSAnLi9jc3MtY2xhc3MudHMnO1xuaW1wb3J0IHtcbiAgaXNTcGVsbGNoZWNrRW5hYmxlZEZvck1vZGUsXG4gIFNwZWxsY2hlY2tNb2RlXG59IGZyb20gJy4vb2JzaWRpYW4tc2V0dGluZ3MudHMnO1xuXG4vKipcbiAqIE9wdGlvbnMgZm9yIHtAbGluayBhcHBseVNwZWxsY2hlY2tNb2RlfS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBBcHBseVNwZWxsY2hlY2tNb2RlUGFyYW1zIHtcbiAgLyoqXG4gICAqIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gICAqL1xuICByZWFkb25seSBhcHA6IEFwcDtcblxuICAvKipcbiAgICogVGhlIGVsZW1lbnQgdG8gc2V0IHRoZSBgc3BlbGxjaGVja2AgYXR0cmlidXRlIG9uLlxuICAgKi9cbiAgcmVhZG9ubHkgZWxlbWVudDogSFRNTEVsZW1lbnQ7XG5cbiAgLyoqXG4gICAqIFRoZSBtb2RlIGRlY2lkaW5nIHdoZXRoZXIgdGhlIGVsZW1lbnQgaXMgc3BlbGwtY2hlY2tlZC5cbiAgICpcbiAgICogQGRlZmF1bHQgYFNwZWxsY2hlY2tNb2RlLk9mZmBcbiAgICovXG4gIHJlYWRvbmx5IHNwZWxsY2hlY2tNb2RlPzogU3BlbGxjaGVja01vZGU7XG59XG5cbi8qKlxuICogQXBwZW5kcyBhIGNvZGUgYmxvY2sgdG8gdGhlIGdpdmVuIERvY3VtZW50RnJhZ21lbnQgb3IgSFRNTEVsZW1lbnQsIHN0eWxlZCB0byBtYXRjaCBPYnNpZGlhbidzXG4gKiByZW5kZXJlZC1tYXJrZG93biBpbmxpbmUgY29kZS5cbiAqXG4gKiBAcGFyYW0gZWxlbWVudCAtIFRoZSBEb2N1bWVudEZyYWdtZW50IG9yIEhUTUxFbGVtZW50IHRvIGFwcGVuZCB0aGUgY29kZSBibG9jayB0by5cbiAqIEBwYXJhbSBjb2RlIC0gVGhlIGNvZGUgdG8gYmUgZGlzcGxheWVkIGluIHRoZSBjb2RlIGJsb2NrLlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXBwZW5kQ29kZUJsb2NrKGVsZW1lbnQ6IERvY3VtZW50RnJhZ21lbnQgfCBIVE1MRWxlbWVudCwgY29kZTogc3RyaW5nKTogdm9pZCB7XG4gIGVsZW1lbnQuY3JlYXRlRWwoJ3N0cm9uZycsIHsgY2xzOiBgJHtDc3NDbGFzcy5NYXJrZG93blJlbmRlcmVkfSAke0Nzc0NsYXNzLkNvZGV9YCB9LCAoc3Ryb25nKSA9PiB7XG4gICAgc3Ryb25nLmNyZWF0ZUVsKCdjb2RlJywgeyB0ZXh0OiBjb2RlIH0pO1xuICB9KTtcbn1cblxuLyoqXG4gKiBTZXRzIHRoZSBgc3BlbGxjaGVja2AgYXR0cmlidXRlIG9uIGFuIGVsZW1lbnQgZnJvbSBhIHtAbGluayBTcGVsbGNoZWNrTW9kZX0uXG4gKlxuICogVGhlIGF0dHJpYnV0ZSBoYXMgdG8gYmUgc2V0IGV4cGxpY2l0bHksIGJlY2F1c2UgYm90aCBvZiB0aGUgc3VyZmFjZXMgdGhhdCBuZWVkIHRoaXMgYXJlIGJvcm4gd2l0aFxuICogYHNwZWxsY2hlY2s9XCJmYWxzZVwiYDogYEFic3RyYWN0VGV4dENvbXBvbmVudGAgZm9yY2VzIGl0IG9udG8gZXZlcnkgdGV4dCBjb21wb25lbnQsIGFuZCBPYnNpZGlhbiBidWlsZHNcbiAqIGV2ZXJ5IGBTdWdnZXN0TW9kYWxgIGlucHV0IHdpdGggaXQgd2l0aG91dCBjb25zdWx0aW5nIGBFZGl0b3IgPiBTcGVsbGNoZWNrYCBhdCBhbGwuXG4gKlxuICogV2hpY2ggb2YgdGhvc2UgYSBnaXZlbiBib3ggd2FudHMgaXMgYSBjYWxsLXNpdGUgZGVjaXNpb24sIGFuZCB0aGUgZGlzdGluY3Rpb24gdGhhdCBob2xkcyB1cCBpcyB3aGF0IHRoZVxuICogYm94IGlzIEZPUjogb25lIHRoYXQgb25seSBGSU5EUyBzb21ldGhpbmcgaXMgYSBzZWFyY2ggZmllbGQgYW5kIHN0YXlzIHVuY2hlY2tlZCwgYmVjYXVzZSBzcXVpZ2dsZXMgdW5kZXJcbiAqIGhhbGYtdHlwZWQgZnJhZ21lbnRzIGFyZSBub2lzZTsgb25lIHRoYXQgTkFNRVMgc29tZXRoaW5nIGlzIGEgcHJvc2UgZmllbGQgYW5kIGZvbGxvd3MgdGhlIHNldHRpbmcsIHRoZVxuICogd2F5IE9ic2lkaWFuJ3Mgb3duIGlubGluZSB0aXRsZSBhbmQgZmlsZS1leHBsb3JlciByZW5hbWUgZG8uXG4gKlxuICogQ2FsbCBpdCBhZ2FpbiB3aGVuZXZlciB0aGF0IGFuc3dlciBjaGFuZ2VzIFx1MjAxNCBhIHBpY2tlciB0aGF0IHN3aXRjaGVzIGJldHdlZW4gZmluZGluZyBhbmQgY3JlYXRpbmcgZmxpcHNcbiAqIG1vZGVzIG1pZC1vcGVuLCBhbmQgdGhlIGF0dHJpYnV0ZSBoYXMgdG8gZm9sbG93LlxuICpcbiAqIFRoZSBuYW1lIGJlaW5nIHR5cGVkIG1heSBiZSBhIFBBVEggcmF0aGVyIHRoYW4gYSBiYXJlIGJhc2VuYW1lLCBzbyBmb2xkZXIgc2VnbWVudHMgZ2V0IGNoZWNrZWQgdG9vLlxuICogVGhhdCBpcyB3aGF0IE9ic2lkaWFuJ3Mgb3duIGlubGluZSByZW5hbWUgZG9lcywgYW5kIHRoZSBhbHRlcm5hdGl2ZSBcdTIwMTQgY2hlY2tpbmcgb25seSB0aGUgbGFzdCBzZWdtZW50IFx1MjAxNFxuICogY2Fubm90IGJlIGV4cHJlc3NlZCBhcyBhbiBhdHRyaWJ1dGUuXG4gKlxuICogQHBhcmFtIHBhcmFtcyAtIFRoZSBwYXJhbWV0ZXJzIGZvciBhcHBseWluZyB0aGUgc3BlbGxjaGVjayBtb2RlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXBwbHlTcGVsbGNoZWNrTW9kZShwYXJhbXM6IEFwcGx5U3BlbGxjaGVja01vZGVQYXJhbXMpOiB2b2lkIHtcbiAgY29uc3Qge1xuICAgIGFwcCxcbiAgICBlbGVtZW50LFxuICAgIHNwZWxsY2hlY2tNb2RlID0gU3BlbGxjaGVja01vZGUuT2ZmXG4gIH0gPSBwYXJhbXM7XG4gIGVsZW1lbnQuc2V0QXR0cmlidXRlKCdzcGVsbGNoZWNrJywgU3RyaW5nKGlzU3BlbGxjaGVja0VuYWJsZWRGb3JNb2RlKGFwcCwgc3BlbGxjaGVja01vZGUpKSk7XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBYUEsU0FBUyxnQkFBZ0I7QUFDekI7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUErQkEsU0FBUyxnQkFBZ0IsU0FBeUMsTUFBb0I7QUFDM0YsVUFBUSxTQUFTLFVBQVUsRUFBRSxLQUFLLEdBQUcsU0FBUyxnQkFBZ0IsSUFBSSxTQUFTLElBQUksR0FBRyxHQUFHLENBQUMsV0FBVztBQUMvRixXQUFPLFNBQVMsUUFBUSxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBQUEsRUFDeEMsQ0FBQztBQUNIO0FBdUJPLFNBQVMsb0JBQW9CLFFBQXlDO0FBQzNFLFFBQU07QUFBQSxJQUNKO0FBQUEsSUFDQTtBQUFBLElBQ0EsaUJBQWlCLGVBQWU7QUFBQSxFQUNsQyxJQUFJO0FBQ0osVUFBUSxhQUFhLGNBQWMsT0FBTywyQkFBMkIsS0FBSyxjQUFjLENBQUMsQ0FBQztBQUM1RjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/html-element.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Obsidian-specific HTML element helpers.\n *\n * Unlike the Obsidian-runtime-agnostic helpers in `src/html-element.ts`, these depend on\n * Obsidian-specific presentation \u2014 the `markdown-rendered` CSS class that styles rendered markdown, and\n * the `Editor > Spellcheck` vault setting \u2014 so they live in the Obsidian layer and use Obsidian's\n * `createEl` DOM augmentation.\n */\n\nimport type { App } from 'obsidian';\n\nimport { CssClass } from './css-class.ts';\nimport {\n  isSpellcheckEnabledForMode,\n  SpellcheckMode\n} from './obsidian-settings.ts';\n\n// The first code point of the Basic Multilingual Plane's Private Use Area. Written as a code point and\n// Composed at runtime rather than as a string escape, so the constant below stays legible in the source\n// Instead of being an invisible character no reader can identify.\nconst PRIVATE_USE_AREA_FIRST_CODE_POINT = 0xE0_00;\n\n// Wraps a value that should render as a code block. A private-use code point, so it cannot collide with\n// Anything a translator would legitimately write, and so a message that somehow reaches the user with\n// Its delimiters intact is visibly wrong rather than plausibly intentional.\nconst CODE_BLOCK_DELIMITER = String.fromCodePoint(PRIVATE_USE_AREA_FIRST_CODE_POINT);\n\n/**\n * Options for {@link applySpellcheckMode}.\n */\nexport interface ApplySpellcheckModeParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The element to set the `spellcheck` attribute on.\n   */\n  readonly element: HTMLElement;\n\n  /**\n   * The mode deciding whether the element is spell-checked.\n   *\n   * @default `SpellcheckMode.Off`\n   */\n  readonly spellcheckMode?: SpellcheckMode;\n}\n\n/**\n * Appends a code block to the given DocumentFragment or HTMLElement, styled to match Obsidian's\n * rendered-markdown inline code.\n *\n * @param element - The DocumentFragment or HTMLElement to append the code block to.\n * @param code - The code to be displayed in the code block.\n */\nexport function appendCodeBlock(element: DocumentFragment | HTMLElement, code: string): void {\n  element.createEl('strong', { cls: `${CssClass.MarkdownRendered} ${CssClass.Code}` }, (strong) => {\n    strong.createEl('code', { text: code });\n  });\n}\n\n/**\n * Sets the `spellcheck` attribute on an element from a {@link SpellcheckMode}.\n *\n * The attribute has to be set explicitly, because both of the surfaces that need this are born with\n * `spellcheck=\"false\"`: `AbstractTextComponent` forces it onto every text component, and Obsidian builds\n * every `SuggestModal` input with it without consulting `Editor > Spellcheck` at all.\n *\n * Which of those a given box wants is a call-site decision, and the distinction that holds up is what the\n * box is FOR: one that only FINDS something is a search field and stays unchecked, because squiggles under\n * half-typed fragments are noise; one that NAMES something is a prose field and follows the setting, the\n * way Obsidian's own inline title and file-explorer rename do.\n *\n * Call it again whenever that answer changes \u2014 a picker that switches between finding and creating flips\n * modes mid-open, and the attribute has to follow.\n *\n * The name being typed may be a PATH rather than a bare basename, so folder segments get checked too.\n * That is what Obsidian's own inline rename does, and the alternative \u2014 checking only the last segment \u2014\n * cannot be expressed as an attribute.\n *\n * @param params - The parameters for applying the spellcheck mode.\n */\nexport function applySpellcheckMode(params: ApplySpellcheckModeParams): void {\n  const {\n    app,\n    element,\n    spellcheckMode = SpellcheckMode.Off\n  } = params;\n  element.setAttribute('spellcheck', String(isSpellcheckEnabledForMode(app, spellcheckMode)));\n}\n\n/**\n * Marks a value so that {@link createFragmentWithCodeBlocks} renders it as an inline code block.\n *\n * Wrap a value with this before handing it to `t()`, and the translated message comes back with the value\n * already in place, delimited:\n *\n * ```ts\n * createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginSuggestion.installed, {\n *   pluginName: asCodeBlock(pluginName)\n * }));\n * ```\n *\n * The marker travels WITH the value rather than being a positional placeholder the caller matches up\n * afterwards. That distinction is the whole point: a message naming two plugins is interpolated by name,\n * and a translation is free to put them in either order, so anything that re-associated values with\n * placeholders by position would silently swap them the moment a sentence read the other way round.\n *\n * @param value - The value to render as a code block.\n * @returns The value, delimited for {@link createFragmentWithCodeBlocks}.\n */\nexport function asCodeBlock(value: string): string {\n  return `${CODE_BLOCK_DELIMITER}${value}${CODE_BLOCK_DELIMITER}`;\n}\n\n/**\n * Builds a {@link DocumentFragment} from an already-translated message, rendering every value that was\n * wrapped in {@link asCodeBlock} as an inline code block and the rest as plain text.\n *\n * The message stays ONE translatable unit. Splitting a sentence into a prefix and a suffix around the value\n * is the obvious alternative and it does not survive translation: a language that reorders the clause, or\n * that needs different case on the surrounding words, cannot express that through two fixed halves. Here\n * the value sits wherever the translation puts it, and only its rendering is decided.\n *\n * A message with nothing marked comes back as plain text, so this is safe to apply to any message.\n *\n * @param message - The translated message, with its code values wrapped by {@link asCodeBlock}.\n * @returns The fragment.\n */\nexport function createFragmentWithCodeBlocks(message: string): DocumentFragment {\n  const fragment = createFragment();\n\n  // Delimiters come in pairs, so the segments between them alternate: plain text, code value, plain text.\n  let isCodeSegment = false;\n  for (const segment of message.split(CODE_BLOCK_DELIMITER)) {\n    if (segment !== '') {\n      if (isCodeSegment) {\n        appendCodeBlock(fragment, segment);\n      } else {\n        fragment.appendText(segment);\n      }\n    }\n\n    isCodeSegment = !isCodeSegment;\n  }\n\n  return fragment;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,SAAS,gBAAgB;AACzB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAKP,MAAM,oCAAoC;AAK1C,MAAM,uBAAuB,OAAO,cAAc,iCAAiC;AA+B5E,SAAS,gBAAgB,SAAyC,MAAoB;AAC3F,UAAQ,SAAS,UAAU,EAAE,KAAK,GAAG,SAAS,gBAAgB,IAAI,SAAS,IAAI,GAAG,GAAG,CAAC,WAAW;AAC/F,WAAO,SAAS,QAAQ,EAAE,MAAM,KAAK,CAAC;AAAA,EACxC,CAAC;AACH;AAuBO,SAAS,oBAAoB,QAAyC;AAC3E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA,iBAAiB,eAAe;AAAA,EAClC,IAAI;AACJ,UAAQ,aAAa,cAAc,OAAO,2BAA2B,KAAK,cAAc,CAAC,CAAC;AAC5F;AAsBO,SAAS,YAAY,OAAuB;AACjD,SAAO,GAAG,oBAAoB,GAAG,KAAK,GAAG,oBAAoB;AAC/D;AAgBO,SAAS,6BAA6B,SAAmC;AAC9E,QAAM,WAAW,eAAe;AAGhC,MAAI,gBAAgB;AACpB,aAAW,WAAW,QAAQ,MAAM,oBAAoB,GAAG;AACzD,QAAI,YAAY,IAAI;AAClB,UAAI,eAAe;AACjB,wBAAgB,UAAU,OAAO;AAAA,MACnC,OAAO;AACL,iBAAS,WAAW,OAAO;AAAA,MAC7B;AAAA,IACF;AAEA,oBAAgB,CAAC;AAAA,EACnB;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/obsidian/i18n/locales/en.d.mts

@@ -44,6 +44,20 @@ export declare const en: {
         readonly pathSettings: {
             readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
         };
+        readonly pluginConflict: {
+            readonly blockedNotice: "{{pluginName}} does nothing while {{conflictingPluginName}} is enabled. Update or disable it to continue.";
+            readonly conflictAppearedNotice: "{{conflictingPluginName}} is now enabled, so {{pluginName}} has stopped working. Update or disable it to resume.";
+            readonly disable: "Disable {{conflictingPluginName}}";
+            readonly settingsHeading: "Conflicting plugin";
+            readonly warningNotice: "{{pluginName}} and {{conflictingPluginName}} overlap, and both are running.";
+        };
+        readonly pluginDependency: {
+            readonly blockedNotice: "{{pluginName}} does nothing until {{dependencyPluginName}} is installed and enabled.";
+            readonly dependencyLostNotice: "{{dependencyPluginName}} is no longer available, so {{pluginName}} has stopped working. Bring it back to resume.";
+            readonly openDependencySettings: "Open {{dependencyPluginName}} settings";
+            readonly settingsHeading: "Required plugin missing";
+            readonly versionMismatchNotice: "{{pluginName}} needs a newer version of {{dependencyPluginName}}. Update it to resume.";
+        };
         readonly pluginSuggestion: {
             readonly enable: "Enable";
             readonly install: "Install and enable";

package/dist/lib/esm/obsidian/i18n/locales/en.mjs

@@ -78,6 +78,20 @@ const en = {
     pathSettings: {
       invalidRegularExpression: "Invalid regular expression: {{regExp}}"
     },
+    pluginConflict: {
+      blockedNotice: "{{pluginName}} does nothing while {{conflictingPluginName}} is enabled. Update or disable it to continue.",
+      conflictAppearedNotice: "{{conflictingPluginName}} is now enabled, so {{pluginName}} has stopped working. Update or disable it to resume.",
+      disable: "Disable {{conflictingPluginName}}",
+      settingsHeading: "Conflicting plugin",
+      warningNotice: "{{pluginName}} and {{conflictingPluginName}} overlap, and both are running."
+    },
+    pluginDependency: {
+      blockedNotice: "{{pluginName}} does nothing until {{dependencyPluginName}} is installed and enabled.",
+      dependencyLostNotice: "{{dependencyPluginName}} is no longer available, so {{pluginName}} has stopped working. Bring it back to resume.",
+      openDependencySettings: "Open {{dependencyPluginName}} settings",
+      settingsHeading: "Required plugin missing",
+      versionMismatchNotice: "{{pluginName}} needs a newer version of {{dependencyPluginName}}. Update it to resume."
+    },
     pluginSuggestion: {
       enable: "Enable",
       install: "Install and enable",
@@ -109,4 +123,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2kxOG4vbG9jYWxlcy9lbi50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFRoaXMgZmlsZSBkZWZpbmVzIHRoZSBFbmdsaXNoIHRyYW5zbGF0aW9ucyBmb3IgdGhlIGBpMThuYCBtb2R1bGUuXG4gKi9cblxuLyoqXG4gKiBUaGUgRW5nbGlzaCB0cmFuc2xhdGlvbnMuXG4gKi9cbmV4cG9ydCBjb25zdCBlbiA9IHtcbiAgb2JzaWRpYW5EZXZVdGlsczoge1xuICAgIGFzeW5jV2l0aE5vdGljZToge1xuICAgICAgbWlsbGlzZWNvbmRzOiAnbWlsbGlzZWNvbmRzLi4uJyxcbiAgICAgIG9wZXJhdGlvbjogJ09wZXJhdGlvbicsXG4gICAgICBydW5uaW5nRm9yOiAnUnVubmluZyBmb3InLFxuICAgICAgdGVybWluYXRlT3BlcmF0aW9uOiAnWW91IGNhbiB0ZXJtaW5hdGUgdGhlIG9wZXJhdGlvbiBieSBjbGlja2luZyB0aGUgYnV0dG9uIGJlbG93LCBidXQgYmUgYXdhcmUgaXQgbWlnaHQgbGVhdmUgdGhlIHZhdWx0IGluIGFuIGluY29uc2lzdGVudCBzdGF0ZS4nLFxuICAgICAgdGltZWRPdXQ6ICdUaGUgb3BlcmF0aW9uIHRpbWVkIG91dCBhZnRlciB7e2R1cmF0aW9uLCBudW1iZXJ9fSBtaWxsaXNlY29uZHMuJ1xuICAgIH0sXG4gICAgYnV0dG9uczoge1xuICAgICAgY2FuY2VsOiAnQ2FuY2VsJyxcbiAgICAgIG9rOiAnT0snXG4gICAgfSxcbiAgICBjYWxsb3V0OiB7XG4gICAgICBsb2FkQ29udGVudDogJ0xvYWQgY29udGVudCBmb3IgY2FsbG91dCdcbiAgICB9LFxuICAgIGRhdGF2aWV3OiB7XG4gICAgICBpdGVtc1BlclBhZ2U6ICdJdGVtcyBwZXIgcGFnZTonLFxuICAgICAganVtcFRvUGFnZTogJ0p1bXAgdG8gcGFnZTonLFxuICAgICAgcGFnZUhlYWRlcjogJ1BhZ2Uge3twYWdlTnVtYmVyLCBudW1iZXJ9fSBvZiB7e3RvdGFsUGFnZXMsIG51bWJlcn19LCBUb3RhbCBpdGVtczoge3t0b3RhbEl0ZW1zLCBudW1iZXJ9fSdcbiAgICB9LFxuICAgIG1lbnU6IHtcbiAgICAgIGNvcHk6ICdDb3B5J1xuICAgIH0sXG4gICAgbWV0YWRhdGFDYWNoZToge1xuICAgICAgZ2V0QmFja2xpbmtzRm9yRmlsZVBhdGg6ICdHZXQgYmFja2xpbmtzIGZvciB7e2ZpbGVQYXRofX0nXG4gICAgfSxcbiAgICBub3RpY2VzOiB7XG4gICAgICBhdHRhY2htZW50SXNTdGlsbFVzZWQ6ICdBdHRhY2htZW50IHt7YXR0YWNobWVudFBhdGh9fSBpcyBzdGlsbCB1c2VkIGJ5IG90aGVyIG5vdGVzLiBJdCB3aWxsIG5vdCBiZSBkZWxldGVkLicsXG4gICAgICBhdHRhY2htZW50UmVzY3VlZDogJ0F0dGFjaG1lbnQge3thdHRhY2htZW50UGF0aH19IGlzIHN0aWxsIHVzZWQgYnkgb3RoZXIgbm90ZXMuIEl0IHdhcyBtb3ZlZCB0byB7e25ld0F0dGFjaG1lbnRQYXRofX0uJyxcbiAgICAgIGNsb3NlQXJpYUxhYmVsOiAnQ2xvc2UnLFxuICAgICAgZmFpbGVkVG9PcGVuVXJsOiAnRmFpbGVkIHRvIG9wZW4ge3t1cmx9fScsXG4gICAgICB1bmhhbmRsZWRFcnJvcjogJ0FuIHVuaGFuZGxlZCBlcnJvciBvY2N1cnJlZC4gUGxlYXNlIGNoZWNrIHRoZSBjb25zb2xlIGZvciBtb3JlIGluZm9ybWF0aW9uLidcbiAgICB9LFxuICAgIHBhdGhTZXR0aW5nczoge1xuICAgICAgaW52YWxpZFJlZ3VsYXJFeHByZXNzaW9uOiAnSW52YWxpZCByZWd1bGFyIGV4cHJlc3Npb246IHt7cmVnRXhwfX0nXG4gICAgfSxcbiAgICBwbHVnaW5Db25mbGljdDoge1xuICAgICAgYmxvY2tlZE5vdGljZTogJ3t7cGx1Z2luTmFtZX19IGRvZXMgbm90aGluZyB3aGlsZSB7e2NvbmZsaWN0aW5nUGx1Z2luTmFtZX19IGlzIGVuYWJsZWQuIFVwZGF0ZSBvciBkaXNhYmxlIGl0IHRvIGNvbnRpbnVlLicsXG4gICAgICBjb25mbGljdEFwcGVhcmVkTm90aWNlOiAne3tjb25mbGljdGluZ1BsdWdpbk5hbWV9fSBpcyBub3cgZW5hYmxlZCwgc28ge3twbHVnaW5OYW1lfX0gaGFzIHN0b3BwZWQgd29ya2luZy4gVXBkYXRlIG9yIGRpc2FibGUgaXQgdG8gcmVzdW1lLicsXG4gICAgICBkaXNhYmxlOiAnRGlzYWJsZSB7e2NvbmZsaWN0aW5nUGx1Z2luTmFtZX19JyxcbiAgICAgIHNldHRpbmdzSGVhZGluZzogJ0NvbmZsaWN0aW5nIHBsdWdpbicsXG4gICAgICB3YXJuaW5nTm90aWNlOiAne3twbHVnaW5OYW1lfX0gYW5kIHt7Y29uZmxpY3RpbmdQbHVnaW5OYW1lfX0gb3ZlcmxhcCwgYW5kIGJvdGggYXJlIHJ1bm5pbmcuJ1xuICAgIH0sXG4gICAgcGx1Z2luRGVwZW5kZW5jeToge1xuICAgICAgYmxvY2tlZE5vdGljZTogJ3t7cGx1Z2luTmFtZX19IGRvZXMgbm90aGluZyB1bnRpbCB7e2RlcGVuZGVuY3lQbHVnaW5OYW1lfX0gaXMgaW5zdGFsbGVkIGFuZCBlbmFibGVkLicsXG4gICAgICBkZXBlbmRlbmN5TG9zdE5vdGljZTogJ3t7ZGVwZW5kZW5jeVBsdWdpbk5hbWV9fSBpcyBubyBsb25nZXIgYXZhaWxhYmxlLCBzbyB7e3BsdWdpbk5hbWV9fSBoYXMgc3RvcHBlZCB3b3JraW5nLiBCcmluZyBpdCBiYWNrIHRvIHJlc3VtZS4nLFxuICAgICAgb3BlbkRlcGVuZGVuY3lTZXR0aW5nczogJ09wZW4ge3tkZXBlbmRlbmN5UGx1Z2luTmFtZX19IHNldHRpbmdzJyxcbiAgICAgIHNldHRpbmdzSGVhZGluZzogJ1JlcXVpcmVkIHBsdWdpbiBtaXNzaW5nJyxcbiAgICAgIHZlcnNpb25NaXNtYXRjaE5vdGljZTogJ3t7cGx1Z2luTmFtZX19IG5lZWRzIGEgbmV3ZXIgdmVyc2lvbiBvZiB7e2RlcGVuZGVuY3lQbHVnaW5OYW1lfX0uIFVwZGF0ZSBpdCB0byByZXN1bWUuJ1xuICAgIH0sXG4gICAgcGx1Z2luU3VnZ2VzdGlvbjoge1xuICAgICAgZW5hYmxlOiAnRW5hYmxlJyxcbiAgICAgIGluc3RhbGw6ICdJbnN0YWxsIGFuZCBlbmFibGUnLFxuICAgICAgaW5zdGFsbGVkOiAne3twbHVnaW5OYW1lfX0gaXMgaW5zdGFsbGVkIGFuZCBlbmFibGVkLicsXG4gICAgICBpbnN0YWxsRmFpbGVkOiAnRmFpbGVkIHRvIGluc3RhbGwge3twbHVnaW5OYW1lfX0uIENoZWNrIHRoZSBjb25zb2xlIGZvciBtb3JlIGluZm9ybWF0aW9uLicsXG4gICAgICBub3ROb3c6ICdOb3Qgbm93J1xuICAgIH0sXG4gICAgcXVldWU6IHtcbiAgICAgIGZsdXNoUXVldWU6ICdGbHVzaCBxdWV1ZSdcbiAgICB9LFxuICAgIHJlbmFtZURlbGV0ZUhhbmRsZXI6IHtcbiAgICAgIGhhbmRsZURlbGV0ZTogJ0hhbmRsZSBkZWxldGU6IHt7ZmlsZVBhdGh9fScsXG4gICAgICBoYW5kbGVPcnBoYW5lZFJlbmFtZXM6ICdIYW5kbGUgb3JwaGFuZWQgcmVuYW1lcycsXG4gICAgICBoYW5kbGVSZW5hbWU6ICdIYW5kbGUgcmVuYW1lOiB7e29sZFBhdGh9fSAtPiB7e25ld1BhdGh9fScsXG4gICAgICB1cGRhdGVkTGlua3M6ICdVcGRhdGVkIHt7bGlua3NDb3VudCwgbnVtYmVyfX0gbGlua3MgaW4ge3tmaWxlc0NvdW50LCBudW1iZXJ9fSBmaWxlcy4nXG4gICAgfSxcbiAgICByZXNvdXJjZUxvY2s6IHtcbiAgICAgIGxvY2tlZEJ5VG9vbHRpcDogJ0xvY2tlZCBieScsXG4gICAgICBsb2NrZWROb3RlVG9vbHRpcDogJ1RoaXMgbm90ZSBpcyBsb2NrZWQgd2hpbGUgYW4gb3BlcmF0aW9uIGlzIGluIHByb2dyZXNzLicsXG4gICAgICB1bmxvY2tDb25maXJtTWVzc2FnZTogJ1RoaXMgd2lsbCBjYW5jZWwgdGhlIG9wZXJhdGlvbihzKSBjdXJyZW50bHkgaG9sZGluZyBhIGxvY2sgb24gdGhpcyBub3RlIGFuZCBtYXkgbGVhdmUgdGhlIHZhdWx0IGluIGFuIGluY29uc2lzdGVudCBzdGF0ZS4gVGhlIG5vdGUgaXMgbG9ja2VkIGJ5OicsXG4gICAgICB1bmxvY2tDb25maXJtVGl0bGU6ICdVbmxvY2sgbm90ZT8nLFxuICAgICAgdW5sb2NrTWVudUl0ZW06ICdVbmxvY2snXG4gICAgfSxcbiAgICB2YXVsdDoge1xuICAgICAgcHJvY2Vzc0ZpbGU6ICdQcm9jZXNzIGZpbGUge3tmaWxlUGF0aH19J1xuICAgIH1cbiAgfVxufSBhcyBjb25zdDtcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFTTyxNQUFNLEtBQUs7QUFBQSxFQUNoQixrQkFBa0I7QUFBQSxJQUNoQixpQkFBaUI7QUFBQSxNQUNmLGNBQWM7QUFBQSxNQUNkLFdBQVc7QUFBQSxNQUNYLFlBQVk7QUFBQSxNQUNaLG9CQUFvQjtBQUFBLE1BQ3BCLFVBQVU7QUFBQSxJQUNaO0FBQUEsSUFDQSxTQUFTO0FBQUEsTUFDUCxRQUFRO0FBQUEsTUFDUixJQUFJO0FBQUEsSUFDTjtBQUFBLElBQ0EsU0FBUztBQUFBLE1BQ1AsYUFBYTtBQUFBLElBQ2Y7QUFBQSxJQUNBLFVBQVU7QUFBQSxNQUNSLGNBQWM7QUFBQSxNQUNkLFlBQVk7QUFBQSxNQUNaLFlBQVk7QUFBQSxJQUNkO0FBQUEsSUFDQSxNQUFNO0FBQUEsTUFDSixNQUFNO0FBQUEsSUFDUjtBQUFBLElBQ0EsZUFBZTtBQUFBLE1BQ2IseUJBQXlCO0FBQUEsSUFDM0I7QUFBQSxJQUNBLFNBQVM7QUFBQSxNQUNQLHVCQUF1QjtBQUFBLE1BQ3ZCLG1CQUFtQjtBQUFBLE1BQ25CLGdCQUFnQjtBQUFBLE1BQ2hCLGlCQUFpQjtBQUFBLE1BQ2pCLGdCQUFnQjtBQUFBLElBQ2xCO0FBQUEsSUFDQSxjQUFjO0FBQUEsTUFDWiwwQkFBMEI7QUFBQSxJQUM1QjtBQUFBLElBQ0EsZ0JBQWdCO0FBQUEsTUFDZCxlQUFlO0FBQUEsTUFDZix3QkFBd0I7QUFBQSxNQUN4QixTQUFTO0FBQUEsTUFDVCxpQkFBaUI7QUFBQSxNQUNqQixlQUFlO0FBQUEsSUFDakI7QUFBQSxJQUNBLGtCQUFrQjtBQUFBLE1BQ2hCLGVBQWU7QUFBQSxNQUNmLHNCQUFzQjtBQUFBLE1BQ3RCLHdCQUF3QjtBQUFBLE1BQ3hCLGlCQUFpQjtBQUFBLE1BQ2pCLHVCQUF1QjtBQUFBLElBQ3pCO0FBQUEsSUFDQSxrQkFBa0I7QUFBQSxNQUNoQixRQUFRO0FBQUEsTUFDUixTQUFTO0FBQUEsTUFDVCxXQUFXO0FBQUEsTUFDWCxlQUFlO0FBQUEsTUFDZixRQUFRO0FBQUEsSUFDVjtBQUFBLElBQ0EsT0FBTztBQUFBLE1BQ0wsWUFBWTtBQUFBLElBQ2Q7QUFBQSxJQUNBLHFCQUFxQjtBQUFBLE1BQ25CLGNBQWM7QUFBQSxNQUNkLHVCQUF1QjtBQUFBLE1BQ3ZCLGNBQWM7QUFBQSxNQUNkLGNBQWM7QUFBQSxJQUNoQjtBQUFBLElBQ0EsY0FBYztBQUFBLE1BQ1osaUJBQWlCO0FBQUEsTUFDakIsbUJBQW1CO0FBQUEsTUFDbkIsc0JBQXNCO0FBQUEsTUFDdEIsb0JBQW9CO0FBQUEsTUFDcEIsZ0JBQWdCO0FBQUEsSUFDbEI7QUFBQSxJQUNBLE9BQU87QUFBQSxNQUNMLGFBQWE7QUFBQSxJQUNmO0FBQUEsRUFDRjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/obsidian/i18n/locales/translations-map.d.mts

@@ -47,6 +47,20 @@ declare const translationsMapImpl: {
             readonly pathSettings: {
                 readonly invalidRegularExpression: "Invalid regular expression: {{regExp}}";
             };
+            readonly pluginConflict: {
+                readonly blockedNotice: "{{pluginName}} does nothing while {{conflictingPluginName}} is enabled. Update or disable it to continue.";
+                readonly conflictAppearedNotice: "{{conflictingPluginName}} is now enabled, so {{pluginName}} has stopped working. Update or disable it to resume.";
+                readonly disable: "Disable {{conflictingPluginName}}";
+                readonly settingsHeading: "Conflicting plugin";
+                readonly warningNotice: "{{pluginName}} and {{conflictingPluginName}} overlap, and both are running.";
+            };
+            readonly pluginDependency: {
+                readonly blockedNotice: "{{pluginName}} does nothing until {{dependencyPluginName}} is installed and enabled.";
+                readonly dependencyLostNotice: "{{dependencyPluginName}} is no longer available, so {{pluginName}} has stopped working. Bring it back to resume.";
+                readonly openDependencySettings: "Open {{dependencyPluginName}} settings";
+                readonly settingsHeading: "Required plugin missing";
+                readonly versionMismatchNotice: "{{pluginName}} needs a newer version of {{dependencyPluginName}}. Update it to resume.";
+            };
             readonly pluginSuggestion: {
                 readonly enable: "Enable";
                 readonly install: "Install and enable";

package/dist/lib/esm/obsidian/mobile-trusted-input.d.mts

@@ -5,7 +5,9 @@
  * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone —
  * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted — so the injection
  * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's
- * binding channel, and the host injects it into the WebView over CDP.
+ * binding channel, and the host injects it into the WebView over CDP — as `Input.dispatchTouchEvent` for
+ * a tap but `Input.synthesizeTapGesture` for a long-press, because `dispatchTouchEvent` injects past
+ * Android's gesture recognizer and so is classified as a tap at any dwell.
  *
  * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the
  * harness rather than reimplementing the wire format: they call
@@ -25,8 +27,8 @@
  */
 import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.mjs';
 /**
- * Clicks the center of an element using **trusted** touch input — a CDP tap in the WebView, injected by
- * the host.
+ * Clicks the center of an element using **trusted** touch input, injected into the WebView by the host
+ * over CDP.
  *
  * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens
  * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing