obsidian-dev-utils 97.0.0 → 99.0.0

package/dist/lib/cjs/obsidian/trusted-input.cjs

@@ -0,0 +1,206 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= keepName;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/highlight',
+  '@lezer/lr',
+  'obsidian']
+  );
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip']
+  );
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trusted_input_exports = {};
+__export(trusted_input_exports, {
+  clickElement: () => clickElement,
+  clickMouse: () => clickMouse,
+  hoverElement: () => hoverElement,
+  moveMouse: () => moveMouse,
+  pressKey: () => pressKey,
+  typeIntoEditor: () => typeIntoEditor,
+  unhoverElement: () => unhoverElement
+});
+module.exports = __toCommonJS(trusted_input_exports);
+var import_obsidian = require('obsidian');
+async function clickElement(params) {
+  const arm = await loadArm();
+  await arm.clickElement(params);
+}
+async function clickMouse(params) {
+  const arm = await loadArm();
+  await arm.clickMouse(params);
+}
+async function hoverElement(params) {
+  const arm = await loadArm();
+  await arm.hoverElement(params);
+}
+async function moveMouse(params) {
+  const arm = await loadArm();
+  await arm.moveMouse(params);
+}
+async function pressKey(params) {
+  const arm = await loadArm();
+  await arm.pressKey(params);
+}
+async function typeIntoEditor(params) {
+  const arm = await loadArm();
+  await arm.typeIntoEditor(params);
+}
+async function unhoverElement(params) {
+  const arm = await loadArm();
+  await arm.unhoverElement(params);
+}
+async function loadArm() {
+  return import_obsidian.Platform.isDesktopApp ? await import("./desktop-trusted-input.cjs") : await import("./mobile-trusted-input.cjs");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Trusted input helpers that work on **either platform** \u2014 the documented entry point for keystrokes,\n * pointer moves and clicks that Obsidian actually believes.\n *\n * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,\n * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises\n * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets\n * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection\n * round-tripped through the harness's host channel on mobile.\n *\n * This module **internalizes that split** (see the project `AGENTS.md` **L6**): it stays\n * cross-platform-loadable \u2014 no platform-only module is on its import graph \u2014 and each helper defers to a\n * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes\n * `await clickElement({ element })` once and never a platform check.\n *\n * The arms remain importable directly, for a caller making a deliberate platform commitment:\n * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and\n * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.\n *\n * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's\n * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has\n * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane\n * does not have to be rewritten.\n *\n * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on\n * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw\n * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.\n * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.\n */\n\nimport { Platform } from 'obsidian';\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\nexport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MouseButton,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n} from './desktop-trusted-input.ts';\n\n// The seven helpers both arms export, with identical signatures. Typed off the mobile arm because it\n// Exports nothing else; the desktop arm additionally exports the parameter contracts both share.\ntype TrustedInputArm = typeof import('./mobile-trusted-input.ts');\n\n/**\n * Clicks the center of an element using **trusted** input \u2014 Electron's `sendInputEvent` on desktop, a CDP\n * touch tap in the WebView on mobile.\n *\n * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /\n * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the\n * element's center \u2014 the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside\n * `.cm-sizer`, so no element's center lands on it.\n *\n * @param params - The element to click, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickElement(params: ClickElementParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.clickElement(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real\n * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * The low-level primitive: one click at one point, with no waiting for any effect \u2014 callers poll their own\n * readiness signal. Prefer {@link clickElement} for element-relative clicks.\n *\n * A real context menu actually opens, so a suite driving a right click must close it (or remove the\n * leftover `.menu` element) before the next test.\n *\n * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the\n * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and\n * `'middle'` throws.\n *\n * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.clickMouse(params);\n}\n\n/**\n * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the\n * element actually matches `:hover`.\n *\n * **Desktop only** \u2014 it throws on mobile, where `:hover` has no touch equivalent.\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 arm = await loadArm();\n  await arm.hoverElement(params);\n}\n\n/**\n * Moves the pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules\n * genuinely apply.\n *\n * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer\n * {@link hoverElement} / {@link unhoverElement} for element-relative moves.\n *\n * **Desktop only** \u2014 it throws on mobile, which has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.moveMouse(params);\n}\n\n/**\n * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real\n * key pipeline \u2014 `keydown` \u2192 `keypress` \u2192 `beforeinput` \u2192 `input` \u2192 `keyup`.\n *\n * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then\n * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the\n * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable\n * characters \u2014 anything else throws rather than pressing nothing.\n *\n * @param params - The key to press and any modifiers to hold.\n * @returns A {@link Promise} that resolves once the key press has been injected.\n */\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  const arm = await loadArm();\n  await arm.pressKey(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input.\n *\n * Focuses the editor (caret to the end) and presses every code point of the text \u2014 the same trusted\n * sequence a real user produces \u2014 so the text reaches the document **only if the editor genuinely holds\n * focus**. Then it polls until the document reflects the input, or a bounded timeout elapses (the expected\n * 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 arm = await loadArm();\n  await arm.typeIntoEditor(params);\n}\n\n/**\n * Moves the pointer to a point just outside an element's bounding box using a **trusted** pointer move,\n * 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\n * is reachable), use {@link moveMouse} directly to move the pointer to a known empty coordinate instead.\n *\n * **Desktop only** \u2014 it throws on mobile, for the same reason {@link hoverElement} does.\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 arm = await loadArm();\n  await arm.unhoverElement(params);\n}\n\nasync function loadArm(): Promise<TrustedInputArm> {\n  // Conditional import of the platform-only arm, at call time: neither arm is on the other platform's\n  // Load path, and the specifiers stay literal so esbuild bundles both.\n  return Platform.isDesktopApp ? await import('./desktop-trusted-input.ts') : await import('./mobile-trusted-input.ts');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCA,sBAAyB;AAuCzB,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAmBA,eAAsB,WAAW,QAAyC;AACxE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,WAAW,MAAM;AAC7B;AAWA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,aAAa,MAAM;AAC/B;AAcA,eAAsB,UAAU,QAAwC;AACtE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,UAAU,MAAM;AAC5B;AAcA,eAAsB,SAAS,QAAuC;AACpE,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,SAAS,MAAM;AAC3B;AAaA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAcA,eAAsB,eAAe,QAA6C;AAChF,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,IAAI,eAAe,MAAM;AACjC;AAEA,eAAe,UAAoC;AAGjD,SAAO,yBAAS,eAAe,MAAM,OAAO,4BAA4B,IAAI,MAAM,OAAO,2BAA2B;AACtH;",
  "names": []
}


package/dist/lib/cjs/obsidian/trusted-input.d.cts

@@ -0,0 +1,126 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Trusted input helpers that work on **either platform** — the documented entry point for keystrokes,
+ * pointer moves and clicks that Obsidian actually believes.
+ *
+ * Untrusted input (`element.dispatchEvent(new MouseEvent('click'))`) is silently ignored by CodeMirror,
+ * by the CSS `:hover` engine and by every `e.isTrusted` guard in Obsidian, so a test driving it exercises
+ * nothing while still passing. A trusted event has to come from outside the renderer, and how it gets
+ * there is platform-specific: Electron's `webContents.sendInputEvent` on desktop, a CDP injection
+ * round-tripped through the harness's host channel on mobile.
+ *
+ * This module **internalizes that split** (see the project `AGENTS.md` **L6**): it stays
+ * cross-platform-loadable — no platform-only module is on its import graph — and each helper defers to a
+ * `Platform`-gated call-time dynamic `import()` of the arm that fits. So a consumer writes
+ * `await clickElement({ element })` once and never a platform check.
+ *
+ * The arms remain importable directly, for a caller making a deliberate platform commitment:
+ * {@link ./desktop-trusted-input.ts | desktop-trusted-input} and
+ * {@link ./mobile-trusted-input.ts | mobile-trusted-input}. Prefer this facade otherwise.
+ *
+ * **Every helper must be awaited.** The desktop arm has nothing to wait for, but the mobile arm's
+ * injection is a round-trip to the host, so a missing `await` lets the assertion run before the input has
+ * landed. The signature is the same on both platforms precisely so that a suite growing a mobile lane
+ * does not have to be rewritten.
+ *
+ * **Not every helper survives the port.** `moveMouse`, `hoverElement` and `unhoverElement` **throw** on
+ * mobile: a touch screen has no persistent pointer and `:hover` has no touch equivalent. They throw
+ * rather than no-op, because a silent no-op is exactly the false confidence trusted input exists to end.
+ * Gate those on `Platform.isDesktopApp`, or drive the element with {@link clickElement} instead.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
+export type { ClickElementParams, ClickMouseParams, HoverElementParams, MouseButton, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
+/**
+ * Clicks the center of an element using **trusted** input — Electron's `sendInputEvent` on desktop, a CDP
+ * touch tap in the WebView on mobile.
+ *
+ * The element-relative counterpart of {@link clickMouse}, mirroring the {@link moveMouse} /
+ * {@link hoverElement} split. Use {@link clickMouse} directly when the point to click is **not** the
+ * element's center — the markdown editor's margin, for instance, lies inside `cm.scrollDOM` but outside
+ * `.cm-sizer`, so no element's center lands on it.
+ *
+ * @param params - The element to click, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickElement(params: ClickElementParams): Promise<void>;
+/**
+ * Clicks at the given viewport coordinates using **trusted** input, so the renderer synthesizes a real
+ * `click` (or `contextmenu`, for the right button) with `isTrusted === true`.
+ *
+ * The low-level primitive: one click at one point, with no waiting for any effect — callers poll their own
+ * readiness signal. Prefer {@link clickElement} for element-relative clicks.
+ *
+ * A real context menu actually opens, so a suite driving a right click must close it (or remove the
+ * leftover `.menu` element) before the next test.
+ *
+ * **On mobile the button model does not survive the port**: touch has no buttons, so `'left'` (the
+ * default) is a **tap**, `'right'` is the **long-press** that opens Obsidian Mobile's context menu, and
+ * `'middle'` throws.
+ *
+ * @param params - The viewport coordinates to click at, the button to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the click has been injected.
+ */
+export declare function clickMouse(params: ClickMouseParams): Promise<void>;
+/**
+ * Moves the pointer to the center of an element using **trusted** pointer input, then polls until the
+ * element actually matches `:hover`.
+ *
+ * **Desktop only** — it throws on mobile, where `:hover` has no touch equivalent.
+ *
+ * @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 pointer to the given viewport coordinates using a **trusted** pointer move, so `:hover` rules
+ * genuinely apply.
+ *
+ * The low-level primitive: a single move that does **not** wait for any state to settle. Prefer
+ * {@link hoverElement} / {@link unhoverElement} for element-relative moves.
+ *
+ * **Desktop only** — it throws on mobile, which has no persistent pointer to move.
+ *
+ * @param params - The viewport coordinates to move to.
+ * @returns A {@link Promise} that resolves once the move has been injected.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key (optionally with modifiers) using **trusted** keyboard input, firing the full real
+ * key pipeline — `keydown` → `keypress` → `beforeinput` → `input` → `keyup`.
+ *
+ * It is delivered to the window's DOM-focused element, so the caller focuses the target first and then
+ * awaits the expected effect; the press itself polls for nothing. On mobile the accepted keys are the
+ * named ones (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) plus single printable
+ * characters — anything else throws rather than pressing nothing.
+ *
+ * @param params - The key to press and any modifiers to hold.
+ * @returns A {@link Promise} that resolves once the key press has been injected.
+ */
+export declare function pressKey(params: PressKeyParams): Promise<void>;
+/**
+ * Types text into a CodeMirror editor using **trusted** keyboard input.
+ *
+ * Focuses the editor (caret to the end) and presses every code point of the text — the same trusted
+ * sequence a real user produces — so the text reaches the document **only if the editor genuinely holds
+ * focus**. Then 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 pointer to a point just outside an element's bounding box using a **trusted** 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.
+ *
+ * **Desktop only** — it throws on mobile, for the same reason {@link hoverElement} does.
+ *
+ * @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/cjs/obsidian/validation.cjs

@@ -147,10 +147,14 @@ __export(validation_exports, {
   WINDOWS_UNSAFE_PATH_CHARS: () => WINDOWS_UNSAFE_PATH_CHARS,
   getOsAndObsidianUnsafePathCharsRegExp: () => getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp: () => getOsUnsafePathCharsRegExp,
-  isValidationMessageHolder: () => isValidationMessageHolder
+  hasWindowsTrailingChars: () => hasWindowsTrailingChars,
+  isValidationMessageHolder: () => isValidationMessageHolder,
+  isWindowsReservedName: () => isWindowsReservedName,
+  trimWindowsTrailingChars: () => trimWindowsTrailingChars
 });
 module.exports = __toCommonJS(validation_exports);
 var import_obsidian = require('obsidian');
+var import_path = require('../path.cjs');
 var import_reg_exp = require('../reg-exp.cjs');
 function isValidationMessageHolder(value) {
   return value.validationMessage !== void 0;
@@ -158,6 +162,8 @@ function isValidationMessageHolder(value) {
 const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\]|]/g;
 const WINDOWS_UNSAFE_PATH_CHARS = /[*\\/<>:|?"]/g;
 const UNIX_UNSAFE_PATH_CHARS = /[\0/]/g;
+const WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;
+const WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;
 function getOsAndObsidianUnsafePathCharsRegExp(isWindows) {
   return (0, import_reg_exp.oneOf)([
     getOsUnsafePathCharsRegExp(isWindows),
@@ -168,6 +174,16 @@ function getOsUnsafePathCharsRegExp(isWindows) {
   isWindows ??= import_obsidian.Platform.isWin;
   return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;
 }
+function hasWindowsTrailingChars(name) {
+  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);
+}
+function isWindowsReservedName(name) {
+  const trimmedName = trimWindowsTrailingChars(name);
+  return WINDOWS_RESERVED_NAME_REG_EXP.test((0, import_path.basename)(trimmedName, (0, import_path.extname)(trimmedName)));
+}
+function trimWindowsTrailingChars(name) {
+  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, "");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   OBSIDIAN_UNSAFE_FILENAME_CHARS,
@@ -175,6 +191,9 @@ function getOsUnsafePathCharsRegExp(isWindows) {
   WINDOWS_UNSAFE_PATH_CHARS,
   getOsAndObsidianUnsafePathCharsRegExp,
   getOsUnsafePathCharsRegExp,
-  isValidationMessageHolder
+  hasWindowsTrailingChars,
+  isValidationMessageHolder,
+  isWindowsReservedName,
+  trimWindowsTrailingChars
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/validation.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Validation utilities.\n */\n\nimport { Platform } from 'obsidian';\n\nimport {\n  basename,\n  extname\n} from '../path.ts';\nimport { oneOf } from '../reg-exp.ts';\n\n/**\n * Holds a validation message.\n */\nexport interface ValidationMessageHolder {\n  /**\n   * A validation message.\n   */\n  validationMessage: string;\n}\n\n/**\n * Type guard to check if a value is a validation message holder.\n *\n * @param value - The value to check.\n * @returns `true` if the value is a validation message holder, `false` otherwise.\n */\nexport function isValidationMessageHolder(value: unknown): value is ValidationMessageHolder {\n  return (value as Partial<ValidationMessageHolder>).validationMessage !== undefined;\n}\n\n/**\n * Matches characters that are not safe to use in file names within Obsidian.\n */\nexport const OBSIDIAN_UNSAFE_FILENAME_CHARS = /[#^[\\]|]/g;\n\n/**\n * Windows-specific unsafe file name path characters.\n */\nexport const WINDOWS_UNSAFE_PATH_CHARS = /[*\\\\/<>:|?\"]/g;\n\n/**\n * Unix-specific unsafe file name path characters.\n */\nexport const UNIX_UNSAFE_PATH_CHARS = /[\\0/]/g;\n\n/**\n * The MS-DOS device names Windows still refuses as a file name, with or without an extension.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM\u00B2` forms are deliberately absent: they are accepted by\n * every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Unlike the exported character sets above, this carries no `g` flag, so `test` may be called on it\n * repeatedly \u2014 a `g`-flagged regexp advances `lastIndex` and answers differently on consecutive calls.\n */\nconst WINDOWS_RESERVED_NAME_REG_EXP = /^(?:AUX|COM[1-9]|CON|LPT[1-9]|NUL|PRN)$/i;\n\n/**\n * The trailing dots and spaces Windows strips from a name before it does anything else with it.\n */\nconst WINDOWS_TRAILING_CHARS_REG_EXP = /[ .]+$/;\n\n/**\n * Returns a regexp matching all unsafe characters in file names/paths.\n *\n * Includes both OS-specific restrictions and Obsidian-specific ones.\n *\n * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.\n * @returns A regexp matching all unsafe characters in file names/paths.\n */\nexport function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolean): RegExp {\n  return oneOf([\n    getOsUnsafePathCharsRegExp(isWindows),\n    OBSIDIAN_UNSAFE_FILENAME_CHARS\n  ]);\n}\n\n/**\n * Returns a regexp matching characters that are not safe to use in file names/paths at the OS level.\n *\n * @param isWindows - Whether to include Windows-specific restrictions. Defaults to `Platform.isWin`.\n * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.\n */\nexport function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp {\n  isWindows ??= Platform.isWin;\n  return isWindows ? WINDOWS_UNSAFE_PATH_CHARS : UNIX_UNSAFE_PATH_CHARS;\n}\n\n/**\n * Checks whether a name ends with the dots or spaces Windows refuses.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, not a path.\n * @returns `true` if the name ends with a dot or a space, `false` otherwise.\n */\nexport function hasWindowsTrailingChars(name: string): boolean {\n  return WINDOWS_TRAILING_CHARS_REG_EXP.test(name);\n}\n\n/**\n * Checks whether a name is one of the MS-DOS device names Windows refuses.\n *\n * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are\n * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as\n * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.\n *\n * `CONIN$` / `CONOUT$` and the superscript `COM\u00B2` forms are deliberately NOT reserved: they are accepted\n * by every Windows version that runs Obsidian, and matching them would rename files that work.\n *\n * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are\n * not necessarily those of the machine asking.\n *\n * @param name - The name to check. A single path segment, with or without its extension.\n * @returns `true` if the name is reserved, `false` otherwise.\n */\nexport function isWindowsReservedName(name: string): boolean {\n  const trimmedName = trimWindowsTrailingChars(name);\n  return WINDOWS_RESERVED_NAME_REG_EXP.test(basename(trimmedName, extname(trimmedName)));\n}\n\n/**\n * Removes the trailing dots and spaces Windows refuses from the end of a name.\n *\n * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into\n * a rejected `CON`. {@link isWindowsReservedName} already does this internally.\n *\n * @param name - The name to trim. A single path segment, not a path.\n * @returns The name without its trailing dots and spaces, which may be empty.\n */\nexport function trimWindowsTrailingChars(name: string): string {\n  return name.replace(WINDOWS_TRAILING_CHARS_REG_EXP, '');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,sBAAyB;AAEzB,kBAGO;AACP,qBAAsB;AAkBf,SAAS,0BAA0B,OAAkD;AAC1F,SAAQ,MAA2C,sBAAsB;AAC3E;AAKO,MAAM,iCAAiC;AAKvC,MAAM,4BAA4B;AAKlC,MAAM,yBAAyB;AAWtC,MAAM,gCAAgC;AAKtC,MAAM,iCAAiC;AAUhC,SAAS,sCAAsC,WAA6B;AACjF,aAAO,sBAAM;AAAA,IACX,2BAA2B,SAAS;AAAA,IACpC;AAAA,EACF,CAAC;AACH;AAQO,SAAS,2BAA2B,WAA6B;AACtE,gBAAc,yBAAS;AACvB,SAAO,YAAY,4BAA4B;AACjD;AAWO,SAAS,wBAAwB,MAAuB;AAC7D,SAAO,+BAA+B,KAAK,IAAI;AACjD;AAkBO,SAAS,sBAAsB,MAAuB;AAC3D,QAAM,cAAc,yBAAyB,IAAI;AACjD,SAAO,8BAA8B,SAAK,sBAAS,iBAAa,qBAAQ,WAAW,CAAC,CAAC;AACvF;AAWO,SAAS,yBAAyB,MAAsB;AAC7D,SAAO,KAAK,QAAQ,gCAAgC,EAAE;AACxD;",
  "names": []
}


package/dist/lib/cjs/obsidian/validation.d.cts

@@ -48,3 +48,40 @@ export declare function getOsAndObsidianUnsafePathCharsRegExp(isWindows?: boolea
  * @returns A regexp matching characters that are not safe to use in file names/paths at the OS level.
  */
 export declare function getOsUnsafePathCharsRegExp(isWindows?: boolean): RegExp;
+/**
+ * Checks whether a name ends with the dots or spaces Windows refuses.
+ *
+ * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are
+ * not necessarily those of the machine asking.
+ *
+ * @param name - The name to check. A single path segment, not a path.
+ * @returns `true` if the name ends with a dot or a space, `false` otherwise.
+ */
+export declare function hasWindowsTrailingChars(name: string): boolean;
+/**
+ * Checks whether a name is one of the MS-DOS device names Windows refuses.
+ *
+ * Two steps the caller would otherwise have to know about happen here: trailing dots and spaces are
+ * trimmed BEFORE the test, because Windows strips them before deciding and `CON ` is therefore as
+ * reserved as `CON`; and the extension is dropped, because `CON.md` is reserved too.
+ *
+ * `CONIN$` / `CONOUT$` and the superscript `COM²` forms are deliberately NOT reserved: they are accepted
+ * by every Windows version that runs Obsidian, and matching them would rename files that work.
+ *
+ * Answers for Windows regardless of the platform in use: a vault is synced, so the rules that matter are
+ * not necessarily those of the machine asking.
+ *
+ * @param name - The name to check. A single path segment, with or without its extension.
+ * @returns `true` if the name is reserved, `false` otherwise.
+ */
+export declare function isWindowsReservedName(name: string): boolean;
+/**
+ * Removes the trailing dots and spaces Windows refuses from the end of a name.
+ *
+ * Trim before testing for a reserved name, never after: trimming afterwards turns an accepted `CON ` into
+ * a rejected `CON`. {@link isWindowsReservedName} already does this internally.
+ *
+ * @param name - The name to trim. A single path segment, not a path.
+ * @returns The name without its trailing dots and spaces, which may be empty.
+ */
+export declare function trimWindowsTrailingChars(name: string): string;