obsidian-dev-utils 85.0.0 → 86.0.0

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

@@ -49,12 +49,15 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["OkButton"] = "ok-button";
   CssClass2["OverlayValidator"] = "overlay-validator";
   CssClass2["PasswordComponent"] = "password-component";
+  CssClass2["PluginNoticeCloseButton"] = "plugin-notice-close-button";
   CssClass2["PluginNoticeContent"] = "plugin-notice-content";
   CssClass2["PluginNoticeName"] = "plugin-notice-name";
+  CssClass2["PluginNoticeRequiresConfirmation"] = "plugin-notice-requires-confirmation";
   CssClass2["PluginSettingsTab"] = "plugin-settings-tab";
   CssClass2["PromptModal"] = "prompt-modal";
   CssClass2["RestoreButton"] = "restore-button";
   CssClass2["SelectItemModal"] = "select-item-modal";
+  CssClass2["SelectOptionModal"] = "select-option-modal";
   CssClass2["SettingComponentWrapper"] = "setting-component-wrapper";
   CssClass2["TelephoneComponent"] = "telephone-component";
   CssClass2["TextBox"] = "text-box";
@@ -72,4 +75,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 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   * 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 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 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 for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\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 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 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,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;AAKhB,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,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;AAMpB,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,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;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAlON,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 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   * 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 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 close confirmation, used to\n   * make its whole area non-dismissible.\n   */\n  PluginNoticeRequiresConfirmation = 'plugin-notice-requires-confirmation',\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 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 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,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;AAKhB,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,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,sCAAmC;AAKnC,EAAAA,UAAA,uBAAoB;AAKpB,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;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAlPN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}


package/dist/lib/esm/obsidian/desktop-demo-vault-opener.d.mts

@@ -0,0 +1,45 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).
+ *
+ * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see
+ * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository
+ * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a
+ * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new
+ * window. When the installed plugin version is behind the latest release, the user is offered a choice
+ * between the two versions.
+ */
+import type { App, PluginManifest } from 'obsidian';
+import type { PluginNoticeComponent } from './components/plugin-notice-component.mjs';
+/**
+ * Parameters for {@link openDemoVault}.
+ */
+export interface OpenDemoVaultParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its
+     * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.
+     */
+    readonly manifest: PluginManifest;
+    /**
+     * The notice component used to report problems (plugin not in the registry, missing archive).
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+}
+/**
+ * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.
+ *
+ * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise
+ * the user chooses between the latest and the currently-installed version. The chosen version's
+ * archive is downloaded and extracted once, then reused from a per-version cache folder.
+ *
+ * @param params - The {@link OpenDemoVaultParams}.
+ * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has
+ * been reported as not possible (notice shown) or cancelled by the user.
+ */
+export declare function openDemoVault(params: OpenDemoVaultParams): Promise<void>;

package/dist/lib/esm/obsidian/desktop-demo-vault-opener.mjs

@@ -0,0 +1,121 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import AdmZip from "adm-zip";
+import { compareVersions } from "compare-versions";
+import { Buffer } from "node:buffer";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { requestUrl } from "obsidian";
+import { join } from "../path.mjs";
+import { getCommunityPluginRepo } from "./community-plugins.mjs";
+import { selectOption } from "./modals/select-option.mjs";
+const DEMO_VAULTS_CACHE_FOLDER = "obsidian-demo-vaults";
+const HTTP_STATUS_OK = 200;
+async function openDemoVault(params) {
+  const {
+    app,
+    manifest,
+    pluginNoticeComponent
+  } = params;
+  const repo = await getCommunityPluginRepo(manifest.id);
+  if (!repo) {
+    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);
+    return;
+  }
+  const currentVersion = manifest.version;
+  const latestVersion = await getLatestReleaseVersion(repo);
+  let versionToOpen;
+  if (compareVersions(currentVersion, latestVersion) >= 0) {
+    versionToOpen = currentVersion;
+  } else {
+    const chosenVersion = await selectOption({
+      app,
+      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,
+      options: [
+        {
+          isCta: true,
+          text: `Open demo vault for latest version (v${latestVersion})`,
+          value: latestVersion
+        },
+        {
+          text: `Open demo vault for current version (v${currentVersion})`,
+          value: currentVersion
+        },
+        {
+          text: "Cancel",
+          value: null
+        }
+      ],
+      title: manifest.name
+    });
+    if (chosenVersion === null) {
+      return;
+    }
+    versionToOpen = chosenVersion;
+  }
+  const cacheDir = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);
+  if (!existsSync(cacheDir)) {
+    const isExtracted = await downloadAndExtractDemoVault({
+      cacheDir,
+      manifest,
+      pluginNoticeComponent,
+      repo,
+      version: versionToOpen
+    });
+    if (!isExtracted) {
+      return;
+    }
+  }
+  window.electron.ipcRenderer.sendSync("vault-open", cacheDir, false);
+}
+async function downloadAndExtractDemoVault(params) {
+  const {
+    cacheDir,
+    manifest,
+    pluginNoticeComponent,
+    repo,
+    version
+  } = params;
+  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;
+  const response = await requestUrl({
+    throw: false,
+    url: assetUrl
+  });
+  if (response.status !== HTTP_STATUS_OK) {
+    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);
+    return false;
+  }
+  const zip = new AdmZip(Buffer.from(response.arrayBuffer));
+  zip.extractAllTo(cacheDir, true);
+  return true;
+}
+async function getLatestReleaseVersion(repo) {
+  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);
+  const release = response.json;
+  return release.tag_name;
+}
+export {
+  openDemoVault
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-demo-vault-opener.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Downloads and opens a plugin's shipped demo vault in a new Obsidian window (desktop only).\n *\n * A plugin can attach a `demo-vault-<version>.zip` archive to each GitHub release (see\n * `archivePluginDemoVault` in `script-utils/demo-vault.ts`). This resolves the plugin's repository\n * from Obsidian's community registry, downloads the archive for the chosen version, extracts it to a\n * per-version cache folder under the OS temp directory, and opens that folder as a vault in a new\n * window. When the installed plugin version is behind the latest release, the user is offered a choice\n * between the two versions.\n */\n\nimport type {\n  App,\n  PluginManifest\n} from 'obsidian';\n\nimport AdmZip from 'adm-zip';\nimport { compareVersions } from 'compare-versions';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { Buffer } from 'node:buffer';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { existsSync } from 'node:fs';\n// eslint-disable-next-line import-x/no-nodejs-modules -- Desktop-only feature gated by `Platform.isDesktopApp`; the command is hidden on mobile so this Node API is never reached there.\nimport { tmpdir } from 'node:os';\nimport { requestUrl } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './components/plugin-notice-component.ts';\n\nimport { join } from '../path.ts';\nimport { getCommunityPluginRepo } from './community-plugins.ts';\nimport { selectOption } from './modals/select-option.ts';\n\n/**\n * Parameters for {@link openDemoVault}.\n */\nexport interface OpenDemoVaultParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The manifest of the plugin whose demo vault is opened. Its `id` locates the GitHub repository, its\n   * `version` selects the archive, and its `name` labels the notices and the version-choice dialog.\n   */\n  readonly manifest: PluginManifest;\n\n  /**\n   * The notice component used to report problems (plugin not in the registry, missing archive).\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n}\n\ninterface DownloadAndExtractDemoVaultParams {\n  readonly cacheDir: string;\n  readonly manifest: PluginManifest;\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n  readonly repo: string;\n  readonly version: string;\n}\n\ninterface GitHubRelease {\n  /**\n   * The release tag, a bare version such as `1.2.3`.\n   */\n  readonly tag_name: string;\n}\n\nconst DEMO_VAULTS_CACHE_FOLDER = 'obsidian-demo-vaults';\nconst HTTP_STATUS_OK = 200;\n\n/**\n * Downloads and opens the plugin's demo vault in a new Obsidian window. Desktop only.\n *\n * If the installed plugin version is the latest (or newer), its demo vault opens directly; otherwise\n * the user chooses between the latest and the currently-installed version. The chosen version's\n * archive is downloaded and extracted once, then reused from a per-version cache folder.\n *\n * @param params - The {@link OpenDemoVaultParams}.\n * @returns A {@link Promise} that resolves once the vault has been opened, or once the operation has\n * been reported as not possible (notice shown) or cancelled by the user.\n */\nexport async function openDemoVault(params: OpenDemoVaultParams): Promise<void> {\n  const {\n    app,\n    manifest,\n    pluginNoticeComponent\n  } = params;\n\n  const repo = await getCommunityPluginRepo(manifest.id);\n  if (!repo) {\n    pluginNoticeComponent.showNotice(`Could not find plugin ${manifest.name} in the community plugins registry.`);\n    return;\n  }\n\n  const currentVersion = manifest.version;\n  const latestVersion = await getLatestReleaseVersion(repo);\n\n  let versionToOpen: string;\n  if (compareVersions(currentVersion, latestVersion) >= 0) {\n    versionToOpen = currentVersion;\n  } else {\n    const chosenVersion = await selectOption<null | string>({\n      app,\n      message: `Current version of plugin ${manifest.name} v${currentVersion} is not the latest (v${latestVersion})`,\n      options: [\n        {\n          isCta: true,\n          text: `Open demo vault for latest version (v${latestVersion})`,\n          value: latestVersion\n        },\n        {\n          text: `Open demo vault for current version (v${currentVersion})`,\n          value: currentVersion\n        },\n        {\n          text: 'Cancel',\n          value: null\n        }\n      ],\n      title: manifest.name\n    });\n    if (chosenVersion === null) {\n      return;\n    }\n    versionToOpen = chosenVersion;\n  }\n\n  const cacheDir = join(tmpdir(), DEMO_VAULTS_CACHE_FOLDER, manifest.id, versionToOpen);\n  if (!existsSync(cacheDir)) {\n    const isExtracted = await downloadAndExtractDemoVault({\n      cacheDir,\n      manifest,\n      pluginNoticeComponent,\n      repo,\n      version: versionToOpen\n    });\n    if (!isExtracted) {\n      return;\n    }\n  }\n\n  window.electron.ipcRenderer.sendSync('vault-open', cacheDir, false);\n}\n\nasync function downloadAndExtractDemoVault(params: DownloadAndExtractDemoVaultParams): Promise<boolean> {\n  const {\n    cacheDir,\n    manifest,\n    pluginNoticeComponent,\n    repo,\n    version\n  } = params;\n\n  const assetUrl = `https://github.com/${repo}/releases/download/${version}/demo-vault-${version}.zip`;\n  const response = await requestUrl({\n    throw: false,\n    url: assetUrl\n  });\n  if (response.status !== HTTP_STATUS_OK) {\n    pluginNoticeComponent.showNotice(`No demo vault is available for plugin ${manifest.name} v${version}.`);\n    return false;\n  }\n\n  const zip = new AdmZip(Buffer.from(response.arrayBuffer));\n  zip.extractAllTo(cacheDir, true);\n  return true;\n}\n\nasync function getLatestReleaseVersion(repo: string): Promise<string> {\n  const response = await requestUrl(`https://api.github.com/repos/${repo}/releases/latest`);\n  const release = response.json as GitHubRelease;\n  return release.tag_name;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAkBA,OAAO,YAAY;AACnB,SAAS,uBAAuB;AAEhC,SAAS,cAAc;AAEvB,SAAS,kBAAkB;AAE3B,SAAS,cAAc;AACvB,SAAS,kBAAkB;AAI3B,SAAS,YAAY;AACrB,SAAS,8BAA8B;AACvC,SAAS,oBAAoB;AAsC7B,MAAM,2BAA2B;AACjC,MAAM,iBAAiB;AAavB,eAAsB,cAAc,QAA4C;AAC9E,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,OAAO,MAAM,uBAAuB,SAAS,EAAE;AACrD,MAAI,CAAC,MAAM;AACT,0BAAsB,WAAW,yBAAyB,SAAS,IAAI,qCAAqC;AAC5G;AAAA,EACF;AAEA,QAAM,iBAAiB,SAAS;AAChC,QAAM,gBAAgB,MAAM,wBAAwB,IAAI;AAExD,MAAI;AACJ,MAAI,gBAAgB,gBAAgB,aAAa,KAAK,GAAG;AACvD,oBAAgB;AAAA,EAClB,OAAO;AACL,UAAM,gBAAgB,MAAM,aAA4B;AAAA,MACtD;AAAA,MACA,SAAS,6BAA6B,SAAS,IAAI,KAAK,cAAc,wBAAwB,aAAa;AAAA,MAC3G,SAAS;AAAA,QACP;AAAA,UACE,OAAO;AAAA,UACP,MAAM,wCAAwC,aAAa;AAAA,UAC3D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM,yCAAyC,cAAc;AAAA,UAC7D,OAAO;AAAA,QACT;AAAA,QACA;AAAA,UACE,MAAM;AAAA,UACN,OAAO;AAAA,QACT;AAAA,MACF;AAAA,MACA,OAAO,SAAS;AAAA,IAClB,CAAC;AACD,QAAI,kBAAkB,MAAM;AAC1B;AAAA,IACF;AACA,oBAAgB;AAAA,EAClB;AAEA,QAAM,WAAW,KAAK,OAAO,GAAG,0BAA0B,SAAS,IAAI,aAAa;AACpF,MAAI,CAAC,WAAW,QAAQ,GAAG;AACzB,UAAM,cAAc,MAAM,4BAA4B;AAAA,MACpD;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,IACX,CAAC;AACD,QAAI,CAAC,aAAa;AAChB;AAAA,IACF;AAAA,EACF;AAEA,SAAO,SAAS,YAAY,SAAS,cAAc,UAAU,KAAK;AACpE;AAEA,eAAe,4BAA4B,QAA6D;AACtG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,WAAW,sBAAsB,IAAI,sBAAsB,OAAO,eAAe,OAAO;AAC9F,QAAM,WAAW,MAAM,WAAW;AAAA,IAChC,OAAO;AAAA,IACP,KAAK;AAAA,EACP,CAAC;AACD,MAAI,SAAS,WAAW,gBAAgB;AACtC,0BAAsB,WAAW,yCAAyC,SAAS,IAAI,KAAK,OAAO,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,IAAI,OAAO,OAAO,KAAK,SAAS,WAAW,CAAC;AACxD,MAAI,aAAa,UAAU,IAAI;AAC/B,SAAO;AACT;AAEA,eAAe,wBAAwB,MAA+B;AACpE,QAAM,WAAW,MAAM,WAAW,gCAAgC,IAAI,kBAAkB;AACxF,QAAM,UAAU,SAAS;AACzB,SAAO,QAAQ;AACjB;",
  "names": []
}


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

@@ -0,0 +1,135 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Desktop-only trusted input helpers that drive the real Electron renderer via
+ * `webContents.sendInputEvent`, so keystrokes and pointer moves flow through the same trusted input
+ * pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror and the CSS `:hover`
+ * engine ignore).
+ *
+ * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness
+ * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project
+ * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.
+ */
+import type { Editor, Modifier } from 'obsidian';
+/**
+ * Parameters for {@link hoverElement}.
+ */
+export interface HoverElementParams {
+    /**
+     * The element to hover. The pointer is moved to its center.
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * Parameters for {@link moveMouse}.
+ */
+export interface MoveMouseParams {
+    /**
+     * The x coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly x: number;
+    /**
+     * The y coordinate (web-contents DIP) to move the pointer to.
+     */
+    readonly y: number;
+}
+/**
+ * Parameters for {@link pressKey}.
+ */
+export interface PressKeyParams {
+    /**
+     * The key to press, given as an Electron Accelerator key name — e.g. `'Enter'`, `'Escape'`, `'Tab'`,
+     * an arrow key, or a printable character (`'a'`, `'1'`).
+     */
+    readonly key: string;
+    /**
+     * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform
+     * (Cmd on macOS, Ctrl elsewhere).
+     *
+     * @default `[]`
+     */
+    readonly modifiers?: readonly Modifier[];
+}
+/**
+ * Parameters for {@link typeIntoEditor}.
+ */
+export interface TypeIntoEditorParams {
+    /**
+     * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes
+     * are injected.
+     */
+    readonly editor: Editor;
+    /**
+     * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.
+     */
+    readonly text: string;
+}
+/**
+ * Parameters for {@link unhoverElement}.
+ */
+export interface UnhoverElementParams {
+    /**
+     * The element to move the pointer away from. The pointer is moved to a point just outside its bounding
+     * box.
+     */
+    readonly element: HTMLElement;
+}
+/**
+ * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls
+ * until the element actually matches `:hover`.
+ *
+ * Because the move is trusted, the real `:hover` state takes effect in the CSS engine — unlike
+ * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the
+ * single window's **global** pointer, so only one element is hovered at a time.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that resolves once the element matches `:hover`.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.
+ *
+ * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This
+ * is the low-level primitive: it performs a single move and does **not** wait for any state to settle
+ * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for
+ * element-relative moves.
+ *
+ * @param params - The web-contents DIP coordinates to move to.
+ */
+export declare function moveMouse(params: MoveMouseParams): void;
+/**
+ * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the
+ * full real key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It injects a trusted `keyDown` → `char` → `keyUp` sequence, delivered to the window's DOM-focused
+ * element — unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.
+ * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does
+ * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ */
+export declare function pressKey(params: PressKeyParams): void;
+/**
+ * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.
+ *
+ * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} — the
+ * same trusted sequence a real user produces — so the text reaches the document **only if the editor
+ * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,
+ * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).
+ *
+ * @param params - The editor to type into and the text to type.
+ * @returns A {@link Promise} that resolves once the keystrokes have settled.
+ */
+export declare function typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;
+/**
+ * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron
+ * pointer move, then polls until the element no longer matches `:hover`.
+ *
+ * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is
+ * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;

package/dist/lib/esm/obsidian/desktop-trusted-input.mjs

@@ -0,0 +1,103 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { Platform } from "obsidian";
+import { assertNever } from "../type-guards.mjs";
+const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
+const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const CENTER_DIVISOR = 2;
+async function hoverElement(params) {
+  const { element } = params;
+  const rect = element.getBoundingClientRect();
+  moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });
+  const startTime = Date.now();
+  while (!element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+}
+function moveMouse(params) {
+  getWebContents().sendInputEvent({ type: "mouseMove", x: Math.round(params.x), y: Math.round(params.y) });
+}
+function pressKey(params) {
+  const { key, modifiers = [] } = params;
+  const isMacOS = Platform.isMacOS;
+  const electronModifiers = modifiers.map((modifier) => {
+    switch (modifier) {
+      case "Alt":
+        return "alt";
+      case "Ctrl":
+        return "control";
+      case "Meta":
+        return "meta";
+      case "Mod":
+        return isMacOS ? "meta" : "control";
+      case "Shift":
+        return "shift";
+      default:
+        return assertNever(modifier);
+    }
+  });
+  const webContents = getWebContents();
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "keyDown" });
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "char" });
+  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: "keyUp" });
+}
+async function typeIntoEditor(params) {
+  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;
+  const { editor, text } = params;
+  const valueBeforeTyping = editor.getValue();
+  editor.focus();
+  const lastLine = editor.lastLine();
+  editor.setCursor(lastLine, editor.getLine(lastLine).length);
+  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);
+  for (const char of text) {
+    pressKey({ key: char });
+  }
+  const startTime = Date.now();
+  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+}
+async function unhoverElement(params) {
+  const OUTSIDE_OFFSET_IN_PIXELS = 1;
+  const { element } = params;
+  const rect = element.getBoundingClientRect();
+  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;
+  const y = rect.top + rect.height / CENTER_DIVISOR;
+  moveMouse({ x, y });
+  const startTime = Date.now();
+  while (element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+}
+function getWebContents() {
+  return window.electron.remote.getCurrentWebContents();
+}
+export {
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/desktop-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Desktop-only trusted input helpers that drive the real Electron renderer via\n * `webContents.sendInputEvent`, so keystrokes and pointer moves flow through the same trusted input\n * pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror and the CSS `:hover`\n * engine ignore).\n *\n * These are the importable-module twins of the base helpers the `obsidian-integration-testing` harness\n * seeds into the `lib` bag; the two copies are kept behaviorally in sync by hand (see the project\n * `CLAUDE.md`). Desktop-only: they depend on `window.electron`.\n */\n\nimport type {\n  Editor,\n  Modifier\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { assertNever } from '../type-guards.ts';\n\n/**\n * Parameters for {@link hoverElement}.\n */\nexport interface HoverElementParams {\n  /**\n   * The element to hover. The pointer is moved to its center.\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * Parameters for {@link moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The x coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to move the pointer to.\n   */\n  readonly y: number;\n}\n\n/**\n * Parameters for {@link pressKey}.\n */\nexport interface PressKeyParams {\n  /**\n   * The key to press, given as an Electron Accelerator key name \u2014 e.g. `'Enter'`, `'Escape'`, `'Tab'`,\n   * an arrow key, or a printable character (`'a'`, `'1'`).\n   */\n  readonly key: string;\n\n  /**\n   * The modifier keys to hold, using Obsidian's {@link Modifier} names. `'Mod'` resolves per-platform\n   * (Cmd on macOS, Ctrl elsewhere).\n   *\n   * @default `[]`\n   */\n  readonly modifiers?: readonly Modifier[];\n}\n\n/**\n * Parameters for {@link typeIntoEditor}.\n */\nexport interface TypeIntoEditorParams {\n  /**\n   * The editor to type into. It is focused (caret moved to the end of the document) before the keystrokes\n   * are injected.\n   */\n  readonly editor: Editor;\n\n  /**\n   * The text to type. Each code point is pressed via {@link pressKey}, exactly as a real user typing.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link unhoverElement}.\n */\nexport interface UnhoverElementParams {\n  /**\n   * The element to move the pointer away from. The pointer is moved to a point just outside its bounding\n   * box.\n   */\n  readonly element: HTMLElement;\n}\n\ntype CurrentWebContents = ReturnType<Window['electron']['remote']['getCurrentWebContents']>;\n\n// The Electron modifier-key names `sendInputEvent` accepts (e.g. 'meta', 'control', 'shift', 'alt').\n// The type is derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronModifier = NonNullable<Parameters<CurrentWebContents['sendInputEvent']>[0]['modifiers']>[number];\n\n/**\n * Interval (in ms) between polls while waiting for a trusted input event to take effect (the editor\n * document updates, or an element's `:hover` state flips).\n */\nconst INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;\n\n/**\n * Maximum time (in ms) to wait for a trusted input event to take effect before giving up (the expected\n * outcome when the input is rejected \u2014 e.g. a read-only editor).\n */\nconst INPUT_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/**\n * Divisor used to find the center of an element's bounding box.\n */\nconst CENTER_DIVISOR = 2;\n\n/**\n * Moves the mouse pointer to the center of an element using **trusted** Electron pointer input, then polls\n * until the element actually matches `:hover`.\n *\n * Because the move is trusted, the real `:hover` state takes effect in the CSS engine \u2014 unlike\n * `dispatchEvent(new MouseEvent('mouseover'))`, which is untrusted and never sets `:hover`. It targets the\n * single window's **global** pointer, so only one element is hovered at a time.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that resolves once the element matches `:hover`.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  const { element } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`.\n  const rect = element.getBoundingClientRect();\n  moveMouse({ x: rect.left + rect.width / CENTER_DIVISOR, y: rect.top + rect.height / CENTER_DIVISOR });\n\n  // Poll until the real `:hover` state has actually taken, instead of a fixed settle.\n  const startTime = Date.now();\n  while (!element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to the given web-contents coordinates using a **trusted** Electron pointer move.\n *\n * A trusted move updates the real pointer state in the CSS engine, so `:hover` rules genuinely apply. This\n * is the low-level primitive: it performs a single move and does **not** wait for any state to settle\n * (callers poll their own readiness signal). Prefer {@link hoverElement} / {@link unhoverElement} for\n * element-relative moves.\n *\n * @param params - The web-contents DIP coordinates to move to.\n */\nexport function moveMouse(params: MoveMouseParams): void {\n  getWebContents().sendInputEvent({ type: 'mouseMove', x: Math.round(params.x), y: Math.round(params.y) });\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** Electron keyboard input, firing the\n * full real key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It injects a trusted `keyDown` \u2192 `char` \u2192 `keyUp` sequence, delivered to the window's DOM-focused\n * element \u2014 unlike `dispatchEvent(new KeyboardEvent(...))`, which is untrusted and ignored by CodeMirror.\n * Use it for special keys (`'Enter'`, `'Escape'`, `'Tab'`, arrow keys) and modifier combinations. It does\n * **not** poll for any effect; the caller focuses the target first, then awaits the expected effect.\n *\n * @param params - The key to press and any modifiers to hold.\n */\nexport function pressKey(params: PressKeyParams): void {\n  const { key, modifiers = [] } = params;\n\n  // 'Mod' is Obsidian's platform-agnostic modifier: Cmd (meta) on macOS, Ctrl elsewhere.\n  const isMacOS = Platform.isMacOS;\n\n  // Map Obsidian's `Modifier` names to Electron's lowercase `sendInputEvent` modifier names.\n  const electronModifiers = modifiers.map((modifier): ElectronModifier => {\n    switch (modifier) {\n      case 'Alt':\n        return 'alt';\n      case 'Ctrl':\n        return 'control';\n      case 'Meta':\n        return 'meta';\n      case 'Mod':\n        return isMacOS ? 'meta' : 'control';\n      case 'Shift':\n        return 'shift';\n      default:\n        return assertNever(modifier);\n    }\n  });\n\n  const webContents = getWebContents();\n\n  // A trusted key press is keyDown -> char -> keyUp: the full real key pipeline.\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyDown' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'char' });\n  webContents.sendInputEvent({ keyCode: key, modifiers: electronModifiers, type: 'keyUp' });\n}\n\n/**\n * Types text into a CodeMirror {@link Editor} using **trusted** Electron keyboard input.\n *\n * This focuses the editor (caret to end) and presses every code point of `text` via {@link pressKey} \u2014 the\n * same trusted sequence a real user produces \u2014 so the text reaches the document **only if the editor\n * genuinely holds focus**. After injecting the keystrokes it polls until the document reflects the input,\n * or a bounded timeout elapses (the expected outcome when the editor is read-only or focus was stolen).\n *\n * @param params - The editor to type into and the text to type.\n * @returns A {@link Promise} that resolves once the keystrokes have settled.\n */\nexport async function typeIntoEditor(params: TypeIntoEditorParams): Promise<void> {\n  const FOCUS_SETTLE_DELAY_IN_MILLISECONDS = 300;\n\n  const { editor, text } = params;\n  const valueBeforeTyping = editor.getValue();\n\n  // Focus the editor and place the caret at the end of the document.\n  editor.focus();\n  const lastLine = editor.lastLine();\n  editor.setCursor(lastLine, editor.getLine(lastLine).length);\n\n  // Let any focus trap (a `setTimeout(0)` re-focus) fire before typing, so stolen focus is detected.\n  await sleep(FOCUS_SETTLE_DELAY_IN_MILLISECONDS);\n\n  // Typing is pressing each character key in turn.\n  for (const char of text) {\n    pressKey({ key: char });\n  }\n\n  // Poll until the document reflects the input or the timeout elapses, instead of a fixed settle.\n  const startTime = Date.now();\n  while (editor.getValue() === valueBeforeTyping && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Moves the mouse pointer to a point just outside an element's bounding box using a **trusted** Electron\n * pointer move, then polls until the element no longer matches `:hover`.\n *\n * The inverse of {@link hoverElement}. When an element spans the full viewport (no point outside its box is\n * reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that resolves once the element no longer matches `:hover`.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n  const { element } = params;\n\n  // Move to a point just outside the element's box. When flush against the viewport's left edge, use just\n  // Past the right edge. A full-viewport-width element should use `moveMouse` directly instead.\n  const rect = element.getBoundingClientRect();\n  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS ? rect.left - OUTSIDE_OFFSET_IN_PIXELS : rect.right + OUTSIDE_OFFSET_IN_PIXELS;\n  const y = rect.top + rect.height / CENTER_DIVISOR;\n  moveMouse({ x, y });\n\n  // Poll until the real `:hover` state has actually cleared, instead of a fixed settle.\n  const startTime = Date.now();\n  while (element.matches(':hover') && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {\n    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\nfunction getWebContents(): CurrentWebContents {\n  return window.electron.remote.getCurrentWebContents();\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,gBAAgB;AAEzB,SAAS,mBAAmB;AAmF5B,MAAM,sCAAsC;AAM5C,MAAM,gCAAgC;AAKtC,MAAM,iBAAiB;AAavB,eAAsB,aAAa,QAA2C;AAC5E,QAAM,EAAE,QAAQ,IAAI;AAGpB,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,YAAU,EAAE,GAAG,KAAK,OAAO,KAAK,QAAQ,gBAAgB,GAAG,KAAK,MAAM,KAAK,SAAS,eAAe,CAAC;AAGpG,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,CAAC,QAAQ,QAAQ,QAAQ,KAAK,KAAK,IAAI,IAAI,YAAY,+BAA+B;AAC3F,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAYO,SAAS,UAAU,QAA+B;AACvD,iBAAe,EAAE,eAAe,EAAE,MAAM,aAAa,GAAG,KAAK,MAAM,OAAO,CAAC,GAAG,GAAG,KAAK,MAAM,OAAO,CAAC,EAAE,CAAC;AACzG;AAaO,SAAS,SAAS,QAA8B;AACrD,QAAM,EAAE,KAAK,YAAY,CAAC,EAAE,IAAI;AAGhC,QAAM,UAAU,SAAS;AAGzB,QAAM,oBAAoB,UAAU,IAAI,CAAC,aAA+B;AACtE,YAAQ,UAAU;AAAA,MAChB,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AACH,eAAO;AAAA,MACT,KAAK;AACH,eAAO,UAAU,SAAS;AAAA,MAC5B,KAAK;AACH,eAAO;AAAA,MACT;AACE,eAAO,YAAY,QAAQ;AAAA,IAC/B;AAAA,EACF,CAAC;AAED,QAAM,cAAc,eAAe;AAGnC,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,UAAU,CAAC;AAC1F,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,OAAO,CAAC;AACvF,cAAY,eAAe,EAAE,SAAS,KAAK,WAAW,mBAAmB,MAAM,QAAQ,CAAC;AAC1F;AAaA,eAAsB,eAAe,QAA6C;AAChF,QAAM,qCAAqC;AAE3C,QAAM,EAAE,QAAQ,KAAK,IAAI;AACzB,QAAM,oBAAoB,OAAO,SAAS;AAG1C,SAAO,MAAM;AACb,QAAM,WAAW,OAAO,SAAS;AACjC,SAAO,UAAU,UAAU,OAAO,QAAQ,QAAQ,EAAE,MAAM;AAG1D,QAAM,MAAM,kCAAkC;AAG9C,aAAW,QAAQ,MAAM;AACvB,aAAS,EAAE,KAAK,KAAK,CAAC;AAAA,EACxB;AAGA,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,OAAO,SAAS,MAAM,qBAAqB,KAAK,IAAI,IAAI,YAAY,+BAA+B;AACxG,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAYA,eAAsB,eAAe,QAA6C;AAChF,QAAM,2BAA2B;AAEjC,QAAM,EAAE,QAAQ,IAAI;AAIpB,QAAM,OAAO,QAAQ,sBAAsB;AAC3C,QAAM,IAAI,KAAK,QAAQ,2BAA2B,KAAK,OAAO,2BAA2B,KAAK,QAAQ;AACtG,QAAM,IAAI,KAAK,MAAM,KAAK,SAAS;AACnC,YAAU,EAAE,GAAG,EAAE,CAAC;AAGlB,QAAM,YAAY,KAAK,IAAI;AAC3B,SAAO,QAAQ,QAAQ,QAAQ,KAAK,KAAK,IAAI,IAAI,YAAY,+BAA+B;AAC1F,UAAM,MAAM,mCAAmC;AAAA,EACjD;AACF;AAEA,SAAS,iBAAqC;AAC5C,SAAO,OAAO,SAAS,OAAO,sBAAsB;AACtD;",
  "names": []
}


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

@@ -33,6 +33,8 @@ export declare const en: {
         };
         readonly notices: {
             readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
+            readonly closeAriaLabel: "Close";
+            readonly closeConfirmMessage: "Are you sure you want to close the notice?";
             readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
         };
         readonly queue: {

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

@@ -47,6 +47,8 @@ const en = {
     },
     notices: {
       attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.",
+      closeAriaLabel: "Close",
+      closeConfirmMessage: "Are you sure you want to close the notice?",
       unhandledError: "An unhandled error occurred. Please check the console for more information."
     },
     queue: {
@@ -73,4 +75,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -36,6 +36,8 @@ declare const translationsMapImpl: {
             };
             readonly notices: {
                 readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
+                readonly closeAriaLabel: "Close";
+                readonly closeConfirmMessage: "Are you sure you want to close the notice?";
                 readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
             };
             readonly queue: {

package/dist/lib/esm/obsidian/index.d.mts

@@ -10,12 +10,15 @@ export * as 'case-insensitive-file-index' from './case-insensitive-file-index.mj
 export * as 'code-block-markdown-information' from './code-block-markdown-information.mjs';
 export * as 'command-handlers' from './command-handlers/index.mjs';
 export * as 'command-registrar' from './command-registrar.mjs';
+export * as 'community-plugins' from './community-plugins.mjs';
 export * as 'components' from './components/index.mjs';
 export * as 'constructors' from './constructors/index.mjs';
 export * as 'css-class' from './css-class.mjs';
 export * as 'data-handler' from './data-handler.mjs';
 export * as 'dataview-link' from './dataview-link.mjs';
 export * as 'dataview' from './dataview.mjs';
+export * as 'desktop-demo-vault-opener' from './desktop-demo-vault-opener.mjs';
+export * as 'desktop-trusted-input' from './desktop-trusted-input.mjs';
 export * as 'editor-extension-registrar' from './editor-extension-registrar.mjs';
 export * as 'editor-suggest-registrar' from './editor-suggest-registrar.mjs';
 export * as 'editor' from './editor.mjs';