@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { assertNever } from "@mnaoumov/typescript-lib/type-guards";
+import { Platform } from "obsidian";
+const INPUT_POLL_INTERVAL_IN_MILLISECONDS = 50;
+const INPUT_TIMEOUT_IN_MILLISECONDS = 5e3;
+const CENTER_DIVISOR = 2;
+const SINGLE_CLICK_COUNT = 1;
+async function clickElement(params) {
+  const { button = "left", element, modifiers = [] } = params;
+  const rect = element.getBoundingClientRect();
+  await clickMouse({
+    button,
+    modifiers,
+    window: getElementWindow(element),
+    x: rect.left + rect.width / CENTER_DIVISOR,
+    y: rect.top + rect.height / CENTER_DIVISOR
+  });
+}
+async function clickMouse(params) {
+  const { button = "left", modifiers = [], x, y } = params;
+  const electronModifiers = toElectronModifiers(modifiers);
+  const roundedX = Math.round(x);
+  const roundedY = Math.round(y);
+  const webContents = getTargetWebContents(params.window);
+  webContents.sendInputEvent({ modifiers: electronModifiers, type: "mouseMove", x: roundedX, y: roundedY });
+  webContents.sendInputEvent({
+    button,
+    clickCount: SINGLE_CLICK_COUNT,
+    modifiers: electronModifiers,
+    type: "mouseDown",
+    x: roundedX,
+    y: roundedY
+  });
+  webContents.sendInputEvent({
+    button,
+    clickCount: SINGLE_CLICK_COUNT,
+    modifiers: electronModifiers,
+    type: "mouseUp",
+    x: roundedX,
+    y: roundedY
+  });
+}
+async function hoverElement(params) {
+  const { element } = params;
+  const rect = element.getBoundingClientRect();
+  await moveMouse({
+    window: getElementWindow(element),
+    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);
+  }
+  if (!element.matches(":hover")) {
+    throw new Error(
+      `The pointer was moved to the center of the element, but it never matched \`:hover\` within ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. Most often the center belongs to something on top of the element, or the element moved after its box was read.`
+    );
+  }
+}
+async function moveMouse(params) {
+  getTargetWebContents(params.window).sendInputEvent({ type: "mouseMove", x: Math.round(params.x), y: Math.round(params.y) });
+}
+async function pressKey(params) {
+  const { key, modifiers = [] } = params;
+  const electronModifiers = toElectronModifiers(modifiers);
+  const webContents = getTargetWebContents(params.window);
+  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();
+  const targetWindow = getEditorWindow(editor);
+  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) {
+    await pressKey({ key: char, window: targetWindow });
+  }
+  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 ? Math.floor(rect.left) - OUTSIDE_OFFSET_IN_PIXELS : Math.ceil(rect.right) + OUTSIDE_OFFSET_IN_PIXELS;
+  const y = rect.top + rect.height / CENTER_DIVISOR;
+  await moveMouse({ window: getElementWindow(element), x, y });
+  const startTime = Date.now();
+  while (element.matches(":hover") && Date.now() - startTime < INPUT_TIMEOUT_IN_MILLISECONDS) {
+    await sleep(INPUT_POLL_INTERVAL_IN_MILLISECONDS);
+  }
+  if (element.matches(":hover")) {
+    throw new Error(
+      `The pointer was moved outside the element's box, but it still matched \`:hover\` after ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. An element that spans the full viewport has no point outside its box to move to \u2014 use \`moveMouse\` to a known empty coordinate instead.`
+    );
+  }
+}
+function getEditorWindow(editor) {
+  return editor.cm.dom.ownerDocument.defaultView ?? window;
+}
+function getElementWindow(element) {
+  return element.ownerDocument.defaultView ?? window;
+}
+function getTargetWebContents(targetWindow) {
+  if (targetWindow === void 0 || targetWindow === window) {
+    return window.electron.remote.getCurrentWebContents();
+  }
+  const { electron } = targetWindow;
+  if (!electron) {
+    throw new Error(
+      "Trusted input cannot reach this window: it has no Electron bridge (`window.electron`). Pass an Obsidian window, the main one or a popout (`leaf.view.containerEl.win`), not an iframe's."
+    );
+  }
+  return electron.remote.getCurrentWebContents();
+}
+function toElectronModifiers(modifiers) {
+  const isMacOS = Platform.isMacOS;
+  return 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);
+      }
+    }
+  });
+}
+export {
+  clickElement,
+  clickMouse,
+  hoverElement,
+  moveMouse,
+  pressKey,
+  typeIntoEditor,
+  unhoverElement
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/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, pointer moves and clicks flow through the same trusted\n * input pipeline a real user produces (unlike untrusted `dispatchEvent`, which CodeMirror, the CSS\n * `:hover` engine and every `e.isTrusted` guard in Obsidian 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 * This is the **desktop arm**. Import it directly only as a deliberate platform commitment; the\n * cross-platform entry point is the {@link ./trusted-input.ts | trusted-input} facade, which dispatches\n * to this module or to {@link ./mobile-trusted-input.ts | mobile-trusted-input} per call.\n */\n\nimport type {\n  Editor,\n  Modifier\n} from 'obsidian';\n\nimport { assertNever } from '@mnaoumov/typescript-lib/type-guards';\nimport { Platform } from 'obsidian';\n\n/**\n * Parameters for {@link clickElement}.\n */\nexport interface ClickElementParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\n\n  /**\n   * The element to click. The pointer is moved to its center.\n   *\n   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\n   */\n  readonly element: HTMLElement;\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 clickMouse}.\n */\nexport interface ClickMouseParams {\n  /**\n   * The mouse button to click with.\n   *\n   * @default `'left'`\n   */\n  readonly button?: MouseButton;\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   * The Obsidian window to click in: the main window or a popout. Pass the window that owns the target,\n   * e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own Electron web\n   * contents, so a click sent to one never reaches another, and the coordinates are in the named window's\n   * viewport.\n   *\n   * **On mobile** there are no popouts, so any window but the main one throws.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\n\n  /**\n   * The x coordinate (web-contents DIP) to click at.\n   */\n  readonly x: number;\n\n  /**\n   * The y coordinate (web-contents DIP) to click at.\n   */\n  readonly y: number;\n}\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   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\n   */\n  readonly element: HTMLElement;\n}\n\n/**\n * The mouse button a trusted click presses, in Electron's `sendInputEvent` spelling.\n */\nexport type MouseButton = NonNullable<ElectronMouseInputEvent['button']>;\n\n/**\n * Parameters for {@link moveMouse}.\n */\nexport interface MoveMouseParams {\n  /**\n   * The Obsidian window to move the pointer in: the main window or a popout. Each Obsidian window is its\n   * own Electron web contents with its own pointer, and the coordinates are in the named window's viewport.\n   *\n   * Mobile has no pointer to move, so {@link moveMouse} throws there whatever this is.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\n\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   * The Obsidian window to press the key in: the main window or a popout. Pass the window that owns the\n   * focused target, e.g. `leaf.view.containerEl.win` for a popout leaf. Each Obsidian window is its own\n   * Electron web contents, so the key goes to the DOM-focused element of the window named here, whichever\n   * window the OS has focused, and never reaches another window.\n   *\n   * **On mobile** there are no popouts, so any window but the main one throws.\n   *\n   * @default the main window (`window`)\n   */\n  readonly window?: Window;\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   * The keystrokes go to the window that owns the editor, so an editor in a popout is typed into in that\n   * popout with no extra parameter.\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   * The input goes to the window that owns the element (its `ownerDocument.defaultView`), so an element in\n   * a popout is driven in that popout with no extra parameter.\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// The pointer variant of the `sendInputEvent` union, picked out by the coordinates only it carries.\n// Derived from the web-contents type so it stays in sync with the Electron typings.\ntype ElectronMouseInputEvent = Extract<Parameters<CurrentWebContents['sendInputEvent']>[0], PointerCoordinates>;\n\n// The shape that discriminates a pointer `sendInputEvent` payload from a keyboard one.\ninterface PointerCoordinates {\n  x: number;\n}\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 * The `clickCount` a single (non-double) trusted click carries.\n */\nconst SINGLE_CLICK_COUNT = 1;\n\n/**\n * Clicks the center of an element using **trusted** Electron pointer input.\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 * **Must be awaited.** Nothing here needs to wait, but the cross-platform twins do \u2014 on mobile the\n * injection is a round-trip to the host, because the renderer cannot produce a trusted event itself \u2014 so\n * the signature is the same on both platforms and a caller never rewrites its `await`s when it grows a\n * mobile lane.\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 { button = 'left', element, modifiers = [] } = params;\n\n  // Viewport coords equal web-contents DIP coords for the full-window `BrowserWindow`. The rect is in the\n  // viewport of the window that owns the element, so the click goes to that window.\n  const rect = element.getBoundingClientRect();\n  await clickMouse({\n    button,\n    modifiers,\n    window: getElementWindow(element),\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\n}\n\n/**\n * Clicks at the given web-contents coordinates using **trusted** Electron pointer input, so Chromium\n * synthesizes a real `click` (or `contextmenu`, for the right button) with `isTrusted === true`.\n *\n * This is what `element.dispatchEvent(new MouseEvent('click'))` cannot do: Obsidian and CodeMirror gate\n * on `isTrusted`, so a dispatched event silently exercises nothing while the test still passes. Obsidian\n * 1.13.7's markdown viewport (margin) menu, for example, opens from\n * `cm.scrollDOM.addEventListener('contextmenu', (e) => { if (!e.defaultPrevented && e.isTrusted && \u2026) })`\n * \u2014 a dispatched `contextmenu` never gets past that check.\n *\n * It is the low-level primitive: a single trusted `mouseMove` \u2192 `mouseDown` \u2192 `mouseUp` at one point,\n * with no waiting for any effect (callers poll their own readiness signal). The leading move is what puts\n * the pointer over the hit-test target before the button goes down. Prefer {@link clickElement} for\n * element-relative clicks.\n *\n * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to click at, the button to press and any modifiers to\n * hold.\n * @returns A {@link Promise} that resolves once the click has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function clickMouse(params: ClickMouseParams): Promise<void> {\n  const { button = 'left', modifiers = [], x, y } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const roundedX = Math.round(x);\n  const roundedY = Math.round(y);\n  const webContents = getTargetWebContents(params.window);\n\n  webContents.sendInputEvent({ modifiers: electronModifiers, type: 'mouseMove', x: roundedX, y: roundedY });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseDown',\n    x: roundedX,\n    y: roundedY\n  });\n  webContents.sendInputEvent({\n    button,\n    clickCount: SINGLE_CLICK_COUNT,\n    modifiers: electronModifiers,\n    type: 'mouseUp',\n    x: roundedX,\n    y: roundedY\n  });\n}\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 * @throws When the element never matches `:hover`. Resolving quietly there would let a test read an\n * element that is not hovered and pass on whatever its base style happens to be.\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  await moveMouse({\n    window: getElementWindow(element),\n    x: rect.left + rect.width / CENTER_DIVISOR,\n    y: rect.top + rect.height / CENTER_DIVISOR\n  });\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  if (!element.matches(':hover')) {\n    throw new Error(\n      `The pointer was moved to the center of the element, but it never matched \\`:hover\\` within ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. `\n        + 'Most often the center belongs to something on top of the element, or the element moved after its box was read.'\n    );\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 * **Must be awaited** \u2014 see {@link clickElement}.\n *\n * @param params - The web-contents DIP coordinates to move to.\n * @returns A {@link Promise} that resolves once the move has been injected.\n */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  getTargetWebContents(params.window).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 * **Must be awaited** \u2014 see {@link clickElement}.\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 */\n// eslint-disable-next-line @typescript-eslint/require-await -- The `async` is the cross-platform contract, not an implementation need: the mobile twin awaits a host round-trip, this one has nothing to await.\nexport async function pressKey(params: PressKeyParams): Promise<void> {\n  const { key, modifiers = [] } = params;\n\n  const electronModifiers = toElectronModifiers(modifiers);\n  const webContents = getTargetWebContents(params.window);\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  const targetWindow = getEditorWindow(editor);\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    await pressKey({ key: char, window: targetWindow });\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 * @throws When the element keeps matching `:hover`, which is what a full-viewport element does.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  const OUTSIDE_OFFSET_IN_PIXELS = 1;\n\n  const { element } = params;\n\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   *\n   * The edge is SNAPPED away from the box before the offset is applied, and that is the whole correctness\n   * of this function. A layout box rarely lands on a whole pixel, and `moveMouse` rounds \u2014 so subtracting\n   * one from a fractional left edge rounds straight back onto the element's own pixel column and the\n   * pointer never leaves. Measured on a bar whose `left` was 859.796875: the plain `left - 1` becomes 859\n   * and `:hover` never clears, while `Math.floor(left) - 1` becomes 858 and it clears in 26 ms. Snapping\n   * first means the offset is a whole pixel of real clearance instead of whatever the fraction leaves.\n   */\n  const rect = element.getBoundingClientRect();\n  const x = rect.left >= OUTSIDE_OFFSET_IN_PIXELS\n    ? Math.floor(rect.left) - OUTSIDE_OFFSET_IN_PIXELS\n    : Math.ceil(rect.right) + OUTSIDE_OFFSET_IN_PIXELS;\n  const y = rect.top + rect.height / CENTER_DIVISOR;\n  await moveMouse({ window: getElementWindow(element), 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  if (element.matches(':hover')) {\n    throw new Error(\n      `The pointer was moved outside the element's box, but it still matched \\`:hover\\` after ${String(INPUT_TIMEOUT_IN_MILLISECONDS)}ms. `\n        + 'An element that spans the full viewport has no point outside its box to move to \u2014 use `moveMouse` to a known empty coordinate instead.'\n    );\n  }\n}\n\n// The window that owns an editor's DOM, so typing into an editor in a popout goes to that popout.\nfunction getEditorWindow(editor: Editor): Window {\n  return editor.cm.dom.ownerDocument.defaultView ?? window;\n}\n\n// The window that owns an element, which is the window its viewport coordinates belong to.\nfunction getElementWindow(element: Element): Window {\n  return element.ownerDocument.defaultView ?? window;\n}\n\n/*\n * The Electron web contents trusted input is injected into. Every Obsidian window, the main one and each\n * popout, is its own web contents, and `remote.getCurrentWebContents()` answers for the window whose\n * `electron` bridge it is called through. So asking the TARGET window's own bridge is what aims the input\n * there; asking the main window's always delivered it to the main window, whatever the caller meant.\n * A window with no bridge (an iframe's) throws: falling back to the main window would be exactly that\n * misdirection.\n */\nfunction getTargetWebContents(targetWindow: undefined | Window): CurrentWebContents {\n  if (targetWindow === undefined || targetWindow === window) {\n    return window.electron.remote.getCurrentWebContents();\n  }\n\n  const { electron } = targetWindow as Partial<Pick<Window, 'electron'>>;\n  if (!electron) {\n    throw new Error(\n      'Trusted input cannot reach this window: it has no Electron bridge (`window.electron`). '\n        + 'Pass an Obsidian window, the main one or a popout (`leaf.view.containerEl.win`), not an iframe\\'s.'\n    );\n  }\n\n  return electron.remote.getCurrentWebContents();\n}\n\n// Maps Obsidian's `Modifier` names to Electron's lowercase `sendInputEvent` modifier names.\n// Shared by every trusted-input helper, so a key press and a click cannot disagree on `'Mod'`.\nfunction toElectronModifiers(modifiers: readonly Modifier[]): ElectronModifier[] {\n  // 'Mod' is Obsidian's platform-agnostic modifier: Cmd (meta) on macOS, Ctrl elsewhere.\n  const isMacOS = Platform.isMacOS;\n\n  return modifiers.map((modifier): ElectronModifier => {\n    switch (modifier) {\n      case 'Alt': {\n        return 'alt';\n      }\n      case 'Ctrl': {\n        return 'control';\n      }\n      case 'Meta': {\n        return 'meta';\n      }\n      case 'Mod': {\n        return isMacOS ? 'meta' : 'control';\n      }\n      case 'Shift': {\n        return 'shift';\n      }\n      default: {\n        return assertNever(modifier);\n      }\n    }\n  });\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/editor-extension-registrar.d.mts

@@ -0,0 +1,37 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Editor extension registrars.
+ */
+import type { Extension } from '@codemirror/state';
+import { Plugin } from 'obsidian';
+/**
+ * Editor extension registrar.
+ */
+export interface EditorExtensionRegistrar {
+    /**
+     * Registers an editor extension.
+     *
+     * @param extension - The editor extension to register.
+     */
+    registerEditorExtension: (extension: Extension) => void;
+}
+/**
+ * Editor extension registrar in an Obsidian plugin.
+ */
+export declare class PluginEditorExtensionRegistrar implements EditorExtensionRegistrar {
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginEditorExtensionRegistrar} class.
+     *
+     * @param plugin - The Obsidian plugin instance.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers an editor extension.
+     *
+     * @param extension - The editor extension to register.
+     */
+    registerEditorExtension(extension: Extension): void;
+}

package/dist/lib/esm/editor-extension-registrar.mjs

@@ -0,0 +1,73 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { Plugin } from "obsidian";
+class PluginEditorExtensionRegistrar {
+  /**
+   * Creates a new instance of the {@link PluginEditorExtensionRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers an editor extension.
+   *
+   * @param extension - The editor extension to register.
+   */
+  registerEditorExtension(extension) {
+    this.plugin.registerEditorExtension(extension);
+  }
+}
+export {
+  PluginEditorExtensionRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VkaXRvci1leHRlbnNpb24tcmVnaXN0cmFyLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogRWRpdG9yIGV4dGVuc2lvbiByZWdpc3RyYXJzLlxuICovXG5cbmltcG9ydCB0eXBlIHsgRXh0ZW5zaW9uIH0gZnJvbSAnQGNvZGVtaXJyb3Ivc3RhdGUnO1xuXG5pbXBvcnQgeyBQbHVnaW4gfSBmcm9tICdvYnNpZGlhbic7XG5cbi8qKlxuICogRWRpdG9yIGV4dGVuc2lvbiByZWdpc3RyYXIuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRWRpdG9yRXh0ZW5zaW9uUmVnaXN0cmFyIHtcbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhbiBlZGl0b3IgZXh0ZW5zaW9uLlxuICAgKlxuICAgKiBAcGFyYW0gZXh0ZW5zaW9uIC0gVGhlIGVkaXRvciBleHRlbnNpb24gdG8gcmVnaXN0ZXIuXG4gICAqL1xuICByZWdpc3RlckVkaXRvckV4dGVuc2lvbjogKGV4dGVuc2lvbjogRXh0ZW5zaW9uKSA9PiB2b2lkO1xufVxuXG4vKipcbiAqIEVkaXRvciBleHRlbnNpb24gcmVnaXN0cmFyIGluIGFuIE9ic2lkaWFuIHBsdWdpbi5cbiAqL1xuZXhwb3J0IGNsYXNzIFBsdWdpbkVkaXRvckV4dGVuc2lvblJlZ2lzdHJhciBpbXBsZW1lbnRzIEVkaXRvckV4dGVuc2lvblJlZ2lzdHJhciB7XG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IGluc3RhbmNlIG9mIHRoZSB7QGxpbmsgUGx1Z2luRWRpdG9yRXh0ZW5zaW9uUmVnaXN0cmFyfSBjbGFzcy5cbiAgICpcbiAgICogQHBhcmFtIHBsdWdpbiAtIFRoZSBPYnNpZGlhbiBwbHVnaW4gaW5zdGFuY2UuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IocHJvdGVjdGVkIHJlYWRvbmx5IHBsdWdpbjogUGx1Z2luKSB7fVxuXG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYW4gZWRpdG9yIGV4dGVuc2lvbi5cbiAgICpcbiAgICogQHBhcmFtIGV4dGVuc2lvbiAtIFRoZSBlZGl0b3IgZXh0ZW5zaW9uIHRvIHJlZ2lzdGVyLlxuICAgKi9cbiAgcHVibGljIHJlZ2lzdGVyRWRpdG9yRXh0ZW5zaW9uKGV4dGVuc2lvbjogRXh0ZW5zaW9uKTogdm9pZCB7XG4gICAgdGhpcy5wbHVnaW4ucmVnaXN0ZXJFZGl0b3JFeHRlbnNpb24oZXh0ZW5zaW9uKTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVFBLFNBQVMsY0FBYztBQWlCaEIsTUFBTSwrQkFBbUU7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNdkUsWUFBK0IsUUFBZ0I7QUFBaEI7QUFBQSxFQUFpQjtBQUFBLEVBQWpCO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBTy9CLHdCQUF3QixXQUE0QjtBQUN6RCxTQUFLLE9BQU8sd0JBQXdCLFNBQVM7QUFBQSxFQUMvQztBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/editor-suggest-registrar.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Editor suggest registrars.
+ */
+import { EditorSuggest, Plugin } from 'obsidian';
+/**
+ * Editor suggest registrar.
+ */
+export interface EditorSuggestRegistrar {
+    /**
+     * Registers an editor suggest.
+     *
+     * @param editorSuggest - The editor suggest to register.
+     */
+    registerEditorSuggest: (editorSuggest: EditorSuggest<unknown>) => void;
+}
+/**
+ * Editor suggest registrar in an Obsidian plugin.
+ */
+export declare class PluginEditorSuggestRegistrar implements EditorSuggestRegistrar {
+    protected readonly plugin: Plugin;
+    /**
+     * Creates a new instance of the {@link PluginEditorSuggestRegistrar} class.
+     *
+     * @param plugin - The Obsidian plugin instance.
+     */
+    constructor(plugin: Plugin);
+    /**
+     * Registers an editor suggest.
+     *
+     * @param editorSuggest - The editor suggest to register.
+     */
+    registerEditorSuggest(editorSuggest: EditorSuggest<unknown>): void;
+}

package/dist/lib/esm/editor-suggest-registrar.mjs

@@ -0,0 +1,76 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+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() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  EditorSuggest,
+  Plugin
+} from "obsidian";
+class PluginEditorSuggestRegistrar {
+  /**
+   * Creates a new instance of the {@link PluginEditorSuggestRegistrar} class.
+   *
+   * @param plugin - The Obsidian plugin instance.
+   */
+  constructor(plugin) {
+    this.plugin = plugin;
+  }
+  plugin;
+  /**
+   * Registers an editor suggest.
+   *
+   * @param editorSuggest - The editor suggest to register.
+   */
+  registerEditorSuggest(editorSuggest) {
+    this.plugin.registerEditorSuggest(editorSuggest);
+  }
+}
+export {
+  PluginEditorSuggestRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2VkaXRvci1zdWdnZXN0LXJlZ2lzdHJhci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEVkaXRvciBzdWdnZXN0IHJlZ2lzdHJhcnMuXG4gKi9cblxuaW1wb3J0IHtcbiAgRWRpdG9yU3VnZ2VzdCxcbiAgUGx1Z2luXG59IGZyb20gJ29ic2lkaWFuJztcblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciB7XG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYW4gZWRpdG9yIHN1Z2dlc3QuXG4gICAqXG4gICAqIEBwYXJhbSBlZGl0b3JTdWdnZXN0IC0gVGhlIGVkaXRvciBzdWdnZXN0IHRvIHJlZ2lzdGVyLlxuICAgKi9cbiAgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0OiAoZWRpdG9yU3VnZ2VzdDogRWRpdG9yU3VnZ2VzdDx1bmtub3duPikgPT4gdm9pZDtcbn1cblxuLyoqXG4gKiBFZGl0b3Igc3VnZ2VzdCByZWdpc3RyYXIgaW4gYW4gT2JzaWRpYW4gcGx1Z2luLlxuICovXG5leHBvcnQgY2xhc3MgUGx1Z2luRWRpdG9yU3VnZ2VzdFJlZ2lzdHJhciBpbXBsZW1lbnRzIEVkaXRvclN1Z2dlc3RSZWdpc3RyYXIge1xuICAvKipcbiAgICogQ3JlYXRlcyBhIG5ldyBpbnN0YW5jZSBvZiB0aGUge0BsaW5rIFBsdWdpbkVkaXRvclN1Z2dlc3RSZWdpc3RyYXJ9IGNsYXNzLlxuICAgKlxuICAgKiBAcGFyYW0gcGx1Z2luIC0gVGhlIE9ic2lkaWFuIHBsdWdpbiBpbnN0YW5jZS5cbiAgICovXG4gIHB1YmxpYyBjb25zdHJ1Y3Rvcihwcm90ZWN0ZWQgcmVhZG9ubHkgcGx1Z2luOiBQbHVnaW4pIHt9XG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhbiBlZGl0b3Igc3VnZ2VzdC5cbiAgICpcbiAgICogQHBhcmFtIGVkaXRvclN1Z2dlc3QgLSBUaGUgZWRpdG9yIHN1Z2dlc3QgdG8gcmVnaXN0ZXIuXG4gICAqL1xuICBwdWJsaWMgcmVnaXN0ZXJFZGl0b3JTdWdnZXN0KGVkaXRvclN1Z2dlc3Q6IEVkaXRvclN1Z2dlc3Q8dW5rbm93bj4pOiB2b2lkIHtcbiAgICB0aGlzLnBsdWdpbi5yZWdpc3RlckVkaXRvclN1Z2dlc3QoZWRpdG9yU3VnZ2VzdCk7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFNQTtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsT0FDSztBQWlCQSxNQUFNLDZCQUErRDtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU1uRSxZQUErQixRQUFnQjtBQUFoQjtBQUFBLEVBQWlCO0FBQUEsRUFBakI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPL0Isc0JBQXNCLGVBQTZDO0FBQ3hFLFNBQUssT0FBTyxzQkFBc0IsYUFBYTtBQUFBLEVBQ2pEO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/editor.d.mts

@@ -0,0 +1,45 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * This module provides utility functions for working with markdown editors in Obsidian
+ */
+import type { App, Editor } from 'obsidian';
+import type { PathOrFile } from './file-system.mjs';
+/**
+ * Overwrites the buffer of every open {@link MarkdownView} currently showing the given path so that
+ * it reflects `content`, in any window or popout.
+ *
+ * This is the fix for a subtle data-loss window: when a note is open in an editor with a **dirty
+ * buffer** (a pending, not-yet-saved edit) and its file content is rewritten on disk out from under
+ * the editor, the editor's next autosave re-writes its stale buffer and clobbers the on-disk content.
+ * A caller that restores a file's content on disk (e.g. rolling back a transaction) must also reset
+ * the open editor's buffer to the same content, so its next save is a no-op instead of a clobber.
+ *
+ * Only the view whose {@link MarkdownView.file} still matches `pathOrFile` is touched — if the editor
+ * has since navigated to another note, it is left alone. The buffer is replaced only when it actually
+ * differs from `content`, so a clean editor already in sync is not disturbed (no cursor reset).
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrFile - The path or file whose open editors should be synchronized.
+ * @param content - The content to overwrite each matching editor's buffer with.
+ */
+export declare function syncOpenEditorBuffersForPath(app: App, pathOrFile: PathOrFile, content: string): void;
+/**
+ * Toggles the read-only state of a single CodeMirror instance — the low-level primitive behind
+ * editor locking.
+ *
+ * When read-only, the editor stays focusable and interactive (selection, copy, and app hotkeys such
+ * as the command palette keep working) — only document edits are prevented, via the CodeMirror
+ * `readOnly` state plus a change filter that drops any user-originated change (see
+ * {@link readOnlyExtension}).
+ *
+ * This toggles ONE CodeMirror instance, not "a file": an Obsidian {@link Editor} is reused as its
+ * leaf navigates between notes, so this primitive does not follow a note around. To lock a note
+ * across every editor that shows it (current and future, in any window), use `lockResourceForPath`
+ * from `./resource-lock.ts`.
+ *
+ * @param editor - The editor whose CodeMirror instance to toggle.
+ * @param isReadOnly - `true` to make the editor read-only, `false` to make it editable again.
+ */
+export declare function toggleEditorReadOnly(editor: Editor, isReadOnly: boolean): void;