obsidian-dev-utils 97.0.0 → 99.0.0

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

@@ -0,0 +1,195 @@
+/*
+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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_trusted_input_exports = {};
+__export(mobile_trusted_input_exports, {
+  clickElement: () => clickElement,
+  clickMouse: () => clickMouse,
+  hoverElement: () => hoverElement,
+  moveMouse: () => moveMouse,
+  pressKey: () => pressKey,
+  typeIntoEditor: () => typeIntoEditor,
+  unhoverElement: () => unhoverElement
+});
+module.exports = __toCommonJS(mobile_trusted_input_exports);
+async function clickElement(params) {
+  await getSeamFunction("clickElement")(params);
+}
+async function clickMouse(params) {
+  await getSeamFunction("clickMouse")(params);
+}
+async function hoverElement(params) {
+  await getSeamFunction("hoverElement")(params);
+}
+async function moveMouse(params) {
+  await getSeamFunction("moveMouse")(params);
+}
+async function pressKey(params) {
+  await getSeamFunction("pressKey")(params);
+}
+async function typeIntoEditor(params) {
+  await getSeamFunction("typeIntoEditor")(params);
+}
+async function unhoverElement(params) {
+  await getSeamFunction("unhoverElement")(params);
+}
+function getSeamFunction(name) {
+  const holder = globalThis;
+  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];
+  if (!seamFunction) {
+    throw new Error(
+      `Trusted input is unavailable on mobile: \`window.__obsidianIntegrationTesting.trustedInput.${name}\` is not installed. A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the \`obsidian-integration-testing\` Appium transport's channel \u2014 which means these helpers only work inside an app that harness bootstrapped.`
+    );
+  }
+  return seamFunction;
+}
+// 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/mobile-trusted-input.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone \u2014\n * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted \u2014 so the injection\n * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's\n * binding channel, and the host injects it into the WebView over CDP.\n *\n * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the\n * harness rather than reimplementing the wire format: they call\n * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness\n * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics \u2014\n * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws\n * for the `:hover` helpers \u2014 identical to the harness's own copy for free, instead of a second\n * implementation to hand-sync (see the project `AGENTS.md` **L4**).\n *\n * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in\n * either direction, at runtime or in types.\n *\n * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.\n * Outside one they throw a message saying so, rather than silently doing nothing \u2014 a no-op would recreate\n * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct\n * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.\n */\n\nimport type {\n  ClickElementParams,\n  ClickMouseParams,\n  HoverElementParams,\n  MoveMouseParams,\n  PressKeyParams,\n  TypeIntoEditorParams,\n  UnhoverElementParams\n  // The parameter contracts live with the desktop twin and are shared verbatim, so the two platforms\n  // Cannot drift apart on what a caller passes. A type-only import loads nothing (L5).\n} from './desktop-trusted-input.ts';\n\n/**\n * The global the harness bootstraps its namespace onto.\n */\ninterface ObsidianIntegrationTestingHolder {\n  __obsidianIntegrationTesting: ObsidianIntegrationTestingNamespace;\n}\n\n/**\n * The part of the harness namespace this module reads. Everything else on it is none of this module's\n * business.\n */\ninterface ObsidianIntegrationTestingNamespace {\n  trustedInput?: Partial<TrustedInputSeam>;\n}\n\n/**\n * The trusted-input seam the `obsidian-integration-testing` harness publishes on its namespace.\n *\n * Declared here rather than imported: the harness is not a dependency of this library. It mirrors\n * `namespace-bootstrap.ts`'s `trustedInput` object, and the mirroring is by hand \u2014 the same\n * behavioral-sync obligation the desktop twin carries.\n */\ninterface TrustedInputSeam {\n  clickElement(params: ClickElementParams): Promise<void>;\n  clickMouse(params: ClickMouseParams): Promise<void>;\n  hoverElement(params: HoverElementParams): Promise<void>;\n  moveMouse(params: MoveMouseParams): Promise<void>;\n  pressKey(params: PressKeyParams): Promise<void>;\n  typeIntoEditor(params: TypeIntoEditorParams): Promise<void>;\n  unhoverElement(params: UnhoverElementParams): Promise<void>;\n}\n\n/**\n * Clicks the center of an element using **trusted** touch input \u2014 a CDP tap in the WebView, injected by\n * the host.\n *\n * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens\n * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing\n * one would be worse than saying so.\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  await getSeamFunction('clickElement')(params);\n}\n\n/**\n * Clicks at the given viewport coordinates using **trusted** touch input, injected by the host over CDP.\n *\n * The coordinates are CSS pixels in the WebView's own viewport \u2014 which is what CDP takes \u2014 so\n * `devicePixelRatio` never enters the picture.\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  await getSeamFunction('clickMouse')(params);\n}\n\n/**\n * Always throws: `:hover` has no touch equivalent.\n *\n * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm\n * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with\n * {@link clickElement}.\n *\n * @param params - The element to hover.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function hoverElement(params: HoverElementParams): Promise<void> {\n  await getSeamFunction('hoverElement')(params);\n}\n\n/**\n * Always throws: a touch screen has no persistent pointer to move.\n *\n * @param params - The viewport coordinates to move to.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function moveMouse(params: MoveMouseParams): Promise<void> {\n  await getSeamFunction('moveMouse')(params);\n}\n\n/**\n * Presses a single key using **trusted** keyboard input, injected by the host over CDP.\n *\n * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable\n * characters are supported; 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  await getSeamFunction('pressKey')(params);\n}\n\n/**\n * Types text into a CodeMirror editor using **trusted** keyboard input, injected by the host over CDP.\n *\n * Focuses the editor (caret to the end), presses every code point of the text, then polls until the\n * document reflects the input or a bounded timeout elapses.\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  await getSeamFunction('typeIntoEditor')(params);\n}\n\n/**\n * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.\n *\n * @param params - The element to move the pointer away from.\n * @returns A {@link Promise} that never resolves \u2014 the call throws.\n */\nexport async function unhoverElement(params: UnhoverElementParams): Promise<void> {\n  await getSeamFunction('unhoverElement')(params);\n}\n\nfunction getSeamFunction<Key extends keyof TrustedInputSeam>(name: Key): TrustedInputSeam[Key] {\n  // eslint-disable-next-line obsidianmd/no-global-this -- The harness installs its namespace on the realm global; there is nowhere else to read it from.\n  const holder = globalThis as Partial<ObsidianIntegrationTestingHolder>;\n  const seamFunction = holder.__obsidianIntegrationTesting?.trustedInput?.[name];\n  if (!seamFunction) {\n    throw new Error(\n      `Trusted input is unavailable on mobile: \\`window.__obsidianIntegrationTesting.trustedInput.${name}\\` is not installed. `\n        + 'A phone has no in-renderer route to a trusted event, so the injection is a round-trip to the host over the '\n        + '`obsidian-integration-testing` Appium transport\\'s channel \u2014 which means these helpers only work inside an app that '\n        + 'harness bootstrapped.'\n    );\n  }\n\n  return seamFunction;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgFA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAWA,eAAsB,WAAW,QAAyC;AACxE,QAAM,gBAAgB,YAAY,EAAE,MAAM;AAC5C;AAYA,eAAsB,aAAa,QAA2C;AAC5E,QAAM,gBAAgB,cAAc,EAAE,MAAM;AAC9C;AAQA,eAAsB,UAAU,QAAwC;AACtE,QAAM,gBAAgB,WAAW,EAAE,MAAM;AAC3C;AAWA,eAAsB,SAAS,QAAuC;AACpE,QAAM,gBAAgB,UAAU,EAAE,MAAM;AAC1C;AAWA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAQA,eAAsB,eAAe,QAA6C;AAChF,QAAM,gBAAgB,gBAAgB,EAAE,MAAM;AAChD;AAEA,SAAS,gBAAoD,MAAkC;AAE7F,QAAM,SAAS;AACf,QAAM,eAAe,OAAO,8BAA8B,eAAe,IAAI;AAC7E,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR,8FAA8F,IAAI;AAAA,IAIpG;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -0,0 +1,93 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Mobile-only trusted input helpers. There is no in-renderer route to a trusted event on a phone —
+ * `webContents.sendInputEvent` is Electron-only and a dispatched event is untrusted — so the injection
+ * has to be a round-trip: the request goes to the host over the `obsidian-integration-testing` harness's
+ * binding channel, and the host injects it into the WebView over CDP.
+ *
+ * That channel is installed by the harness's Appium transport, so these helpers **delegate** to the
+ * harness rather than reimplementing the wire format: they call
+ * `window.__obsidianIntegrationTesting.trustedInput.*`, which holds the very function objects the harness
+ * seeds into an `evalInObsidian` closure's `lib` bag. Delegating is what keeps the mobile semantics —
+ * tap, long-press for `button: 'right'`, a throw for `'middle'`, the `pressKey` key set, and the throws
+ * for the `:hover` helpers — identical to the harness's own copy for free, instead of a second
+ * implementation to hand-sync (see the project `AGENTS.md` **L4**).
+ *
+ * The namespace shape is declared **locally**: the harness must never be a dependency of this library, in
+ * either direction, at runtime or in types.
+ *
+ * **Consequence, and it is deliberate:** these helpers only work inside an app the harness bootstrapped.
+ * Outside one they throw a message saying so, rather than silently doing nothing — a no-op would recreate
+ * exactly the false-confidence failure trusted input exists to end. Consumers wanting the platform-correct
+ * helper should import the {@link ../trusted-input.ts | trusted-input} facade instead of this module.
+ */
+import type { ClickElementParams, ClickMouseParams, HoverElementParams, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams } from './desktop-trusted-input.cjs';
+/**
+ * Clicks the center of an element using **trusted** touch input — a CDP tap in the WebView, injected by
+ * the host.
+ *
+ * The element-relative counterpart of {@link clickMouse}. `button: 'right'` is the long-press that opens
+ * Obsidian Mobile's context menu; `'middle'` throws, because touch has no gesture for it and inventing
+ * one would be worse than saying so.
+ *
+ * @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** touch input, injected by the host over CDP.
+ *
+ * The coordinates are CSS pixels in the WebView's own viewport — which is what CDP takes — so
+ * `devicePixelRatio` never enters the picture.
+ *
+ * @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>;
+/**
+ * Always throws: `:hover` has no touch equivalent.
+ *
+ * A silent no-op here would let a hover test pass on a phone without hovering anything, so the mobile arm
+ * refuses instead. Gate the assertion on `Platform.isDesktopApp`, or drive the element with
+ * {@link clickElement}.
+ *
+ * @param params - The element to hover.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function hoverElement(params: HoverElementParams): Promise<void>;
+/**
+ * Always throws: a touch screen has no persistent pointer to move.
+ *
+ * @param params - The viewport coordinates to move to.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function moveMouse(params: MoveMouseParams): Promise<void>;
+/**
+ * Presses a single key using **trusted** keyboard input, injected by the host over CDP.
+ *
+ * Named keys (`'Enter'`, `'Escape'`, `'Tab'`, `'Backspace'`, `'Delete'`, the arrows) and single printable
+ * characters are supported; 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, injected by the host over CDP.
+ *
+ * Focuses the editor (caret to the end), presses every code point of the text, then polls until the
+ * document reflects the input or a bounded timeout elapses.
+ *
+ * @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>;
+/**
+ * Always throws, for the same reason as {@link hoverElement}: there is no `:hover` state to clear.
+ *
+ * @param params - The element to move the pointer away from.
+ * @returns A {@link Promise} that never resolves — the call throws.
+ */
+export declare function unhoverElement(params: UnhoverElementParams): Promise<void>;

package/dist/lib/cjs/obsidian/plugin/obsidian-plugin-repo-paths.cjs

@@ -172,6 +172,7 @@ var ObsidianPluginRepoPaths = /* @__PURE__ */ ((ObsidianPluginRepoPaths2) => {
   ObsidianPluginRepoPaths2["EslintConfigMts"] = "eslint.config.mts";
   ObsidianPluginRepoPaths2["EslintConfigTs"] = "eslint.config.ts";
   ObsidianPluginRepoPaths2["HotReload"] = ".hotreload";
+  ObsidianPluginRepoPaths2["License"] = "LICENSE";
   ObsidianPluginRepoPaths2["MainCss"] = "main.css";
   ObsidianPluginRepoPaths2["MainJs"] = "main.js";
   ObsidianPluginRepoPaths2["MainTs"] = "main.ts";
@@ -207,4 +208,4 @@ var ObsidianPluginRepoPaths = /* @__PURE__ */ ((ObsidianPluginRepoPaths2) => {
 0 && (module.exports = {
   ObsidianPluginRepoPaths
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/obsidian-plugin-repo-paths.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This file defines an enumeration for common file and folder paths used in Obsidian plugin development.\n */\n\n/**\n * Enumeration of commonly used file and folder paths in Obsidian plugin development.\n */\nexport enum ObsidianPluginRepoPaths {\n  /**\n  Any Android capture integration-test TypeScript file.\n   */\n  AnyAndroidCaptureIntegrationTestTs = '*.android-capture.integration.test.ts',\n\n  /**\n  Any Android integration-test TypeScript file.\n   */\n  AnyAndroidIntegrationTestTs = '*.android.integration.test.ts',\n\n  /**\n  CommonJS file.\n   */\n  AnyCjs = '*.cjs',\n\n  /**\n  Any integration-test TypeScript file.\n   */\n  AnyIntegrationTestTs = '*.integration.test.ts',\n\n  /**\n  JavaScript file.\n   */\n  AnyJs = '*.js',\n\n  /**\n  ESM JavaScript file.\n   */\n  AnyMjs = '*.mjs',\n\n  /**\n  Any path recursively.\n   */\n  AnyPath = '**',\n\n  /**\n  Any test TypeScript file.\n   */\n  AnyTestTs = '*.test.ts',\n\n  /**\n  TypeScript file.\n   */\n  AnyTs = '*.ts',\n\n  /**\n  ReactJS TypeScript file.\n   */\n  AnyTsx = '*.tsx',\n\n  /**\n  Obsidian application settings file within an Obsidian configuration folder.\n   */\n  AppJson = 'app.json',\n\n  /**\n  Changelog file.\n   */\n  ChangelogMd = 'CHANGELOG.md',\n\n  /**\n  Commitlint configuration file.\n   */\n  CommitlintConfigTs = 'commitlint.config.ts',\n\n  /**\n  Current folder.\n   */\n  CurrentFolder = '.',\n\n  /**\n  Demo vault folder shipped in a plugin repo root.\n   */\n  DemoVault = 'demo-vault',\n\n  /**\n  Distribution folder.\n   */\n  Dist = 'dist',\n\n  /**\n  Build folder within the {@link Dist} folder.\n   */\n  DistBuild = 'dist/build',\n\n  /**\n  Development folder within the {@link Dist} folder.\n   */\n  DistDev = 'dist/dev',\n\n  /**\n  Obsidian configuration folder within a vault.\n   */\n  // eslint-disable-next-line obsidianmd/hardcoded-config-path -- This is the default config folder name baked into a shipped demo-vault skeleton, not a lookup against a live vault.\n  DotObsidian = '.obsidian',\n\n  /**\n  CommonJS ESLint configuration file.\n   */\n  EslintConfigCjs = 'eslint.config.cjs',\n\n  /**\n  CommonJS TypeScript ESLint configuration file.\n   */\n  EslintConfigCts = 'eslint.config.cts',\n\n  /**\n  JavaScript ESLint configuration file.\n   */\n  EslintConfigJs = 'eslint.config.js',\n\n  /**\n  ESM JavaScript ESLint configuration file.\n   */\n  EslintConfigMjs = 'eslint.config.mjs',\n\n  /**\n  ESM TypeScript ESLint configuration file.\n   */\n  EslintConfigMts = 'eslint.config.mts',\n\n  /**\n  TypeScript ESLint configuration file.\n   */\n  EslintConfigTs = 'eslint.config.ts',\n\n  /**\n  Hot reload file.\n   */\n  HotReload = '.hotreload',\n\n  /**\n  Main CSS file.\n   */\n  MainCss = 'main.css',\n\n  /**\n  Main JavaScript file.\n   */\n  MainJs = 'main.js',\n\n  /**\n  Main TypeScript file.\n   */\n  MainTs = 'main.ts',\n\n  /**\n  Manifest file for beta releases.\n   */\n  ManifestBetaJson = 'manifest-beta.json',\n\n  /**\n  Manifest file.\n   */\n  ManifestJson = 'manifest.json',\n\n  /**\n  CommonJS Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigCjs = '.markdownlint-cli2.cjs',\n\n  /**\n  JSONC Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigJsonc = '.markdownlint-cli2.jsonc',\n\n  /**\n  ESM Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigMjs = '.markdownlint-cli2.mjs',\n\n  /**\n  YAML Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigYaml = '.markdownlint-cli2.yaml',\n\n  /**\n  CommonJS Markdownlint configuration file.\n   */\n  MarkdownlintConfigCjs = '.markdownlint.cjs',\n\n  /**\n  JSON Markdownlint configuration file.\n   */\n  MarkdownlintConfigJson = '.markdownlint.json',\n\n  /**\n  JSONC Markdownlint configuration file.\n   */\n  MarkdownlintConfigJsonc = '.markdownlint.jsonc',\n\n  /**\n  ESM Markdownlint configuration file.\n   */\n  MarkdownlintConfigMjs = '.markdownlint.mjs',\n\n  /**\n  YAML Markdownlint configuration file.\n   */\n  MarkdownlintConfigYaml = '.markdownlint.yaml',\n\n  /**\n  YAML Markdownlint configuration file.\n   */\n  MarkdownlintConfigYml = '.markdownlint.yml',\n\n  /**\n  Mocks folder.\n   */\n  Mocks = 'src/test-helpers',\n\n  /**\n  Node modules folder.\n   */\n  NodeModules = 'node_modules',\n\n  /**\n  NPM shrinkwrap file.\n   */\n  NpmShrinkwrapJson = 'npm-shrinkwrap.json',\n\n  /**\n  Package JSON file.\n   */\n  PackageJson = 'package.json',\n\n  /**\n  Package-lock JSON file.\n   */\n  PackageLockJson = 'package-lock.json',\n\n  /**\n  Plugins folder within an Obsidian configuration folder.\n   */\n  Plugins = 'plugins',\n\n  /**\n  Scripts folder.\n   */\n  Scripts = 'scripts',\n\n  /**\n  Script utilities folder (dev-only tooling that runs in the consumer's Node environment, not the Obsidian runtime).\n   */\n  ScriptUtils = 'src/script-utils',\n\n  /**\n  Source folder.\n   */\n  Src = 'src',\n\n  /**\n  Styles CSS file.\n   */\n  StylesCss = 'styles.css',\n\n  /**\n  Tests folder.\n   */\n  Tests = '__tests__',\n\n  /**\n  TypeScript configuration file.\n   */\n  TsConfigJson = 'tsconfig.json',\n\n  /**\n  Versions JSON file.\n   */\n  VersionsJson = 'versions.json',\n\n  /**\n  Vitest configuration file.\n   */\n  VitestConfigTs = 'vitest.config.ts'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,0BAAL,kBAAKA,6BAAL;AAIL,EAAAA,yBAAA,wCAAqC;AAKrC,EAAAA,yBAAA,iCAA8B;AAK9B,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,0BAAuB;AAKvB,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,wBAAqB;AAKrB,EAAAA,yBAAA,mBAAgB;AAKhB,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,UAAO;AAKP,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,aAAU;AAMV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,oBAAiB;AAKjB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,oBAAiB;AAKjB,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,sBAAmB;AAKnB,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,+BAA4B;AAK5B,EAAAA,yBAAA,iCAA8B;AAK9B,EAAAA,yBAAA,+BAA4B;AAK5B,EAAAA,yBAAA,gCAA6B;AAK7B,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,4BAAyB;AAKzB,EAAAA,yBAAA,6BAA0B;AAK1B,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,4BAAyB;AAKzB,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,uBAAoB;AAKpB,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,SAAM;AAKN,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,oBAAiB;AAnRP,SAAAA;AAAA,GAAA;",
  "names": ["ObsidianPluginRepoPaths"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/obsidian-plugin-repo-paths.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This file defines an enumeration for common file and folder paths used in Obsidian plugin development.\n */\n\n/**\n * Enumeration of commonly used file and folder paths in Obsidian plugin development.\n */\nexport enum ObsidianPluginRepoPaths {\n  /**\n  Any Android capture integration-test TypeScript file.\n   */\n  AnyAndroidCaptureIntegrationTestTs = '*.android-capture.integration.test.ts',\n\n  /**\n  Any Android integration-test TypeScript file.\n   */\n  AnyAndroidIntegrationTestTs = '*.android.integration.test.ts',\n\n  /**\n  CommonJS file.\n   */\n  AnyCjs = '*.cjs',\n\n  /**\n  Any integration-test TypeScript file.\n   */\n  AnyIntegrationTestTs = '*.integration.test.ts',\n\n  /**\n  JavaScript file.\n   */\n  AnyJs = '*.js',\n\n  /**\n  ESM JavaScript file.\n   */\n  AnyMjs = '*.mjs',\n\n  /**\n  Any path recursively.\n   */\n  AnyPath = '**',\n\n  /**\n  Any test TypeScript file.\n   */\n  AnyTestTs = '*.test.ts',\n\n  /**\n  TypeScript file.\n   */\n  AnyTs = '*.ts',\n\n  /**\n  ReactJS TypeScript file.\n   */\n  AnyTsx = '*.tsx',\n\n  /**\n  Obsidian application settings file within an Obsidian configuration folder.\n   */\n  AppJson = 'app.json',\n\n  /**\n  Changelog file.\n   */\n  ChangelogMd = 'CHANGELOG.md',\n\n  /**\n  Commitlint configuration file.\n   */\n  CommitlintConfigTs = 'commitlint.config.ts',\n\n  /**\n  Current folder.\n   */\n  CurrentFolder = '.',\n\n  /**\n  Demo vault folder shipped in a plugin repo root.\n   */\n  DemoVault = 'demo-vault',\n\n  /**\n  Distribution folder.\n   */\n  Dist = 'dist',\n\n  /**\n  Build folder within the {@link Dist} folder.\n   */\n  DistBuild = 'dist/build',\n\n  /**\n  Development folder within the {@link Dist} folder.\n   */\n  DistDev = 'dist/dev',\n\n  /**\n  Obsidian configuration folder within a vault.\n   */\n  // eslint-disable-next-line obsidianmd/hardcoded-config-path -- This is the default config folder name baked into a shipped demo-vault skeleton, not a lookup against a live vault.\n  DotObsidian = '.obsidian',\n\n  /**\n  CommonJS ESLint configuration file.\n   */\n  EslintConfigCjs = 'eslint.config.cjs',\n\n  /**\n  CommonJS TypeScript ESLint configuration file.\n   */\n  EslintConfigCts = 'eslint.config.cts',\n\n  /**\n  JavaScript ESLint configuration file.\n   */\n  EslintConfigJs = 'eslint.config.js',\n\n  /**\n  ESM JavaScript ESLint configuration file.\n   */\n  EslintConfigMjs = 'eslint.config.mjs',\n\n  /**\n  ESM TypeScript ESLint configuration file.\n   */\n  EslintConfigMts = 'eslint.config.mts',\n\n  /**\n  TypeScript ESLint configuration file.\n   */\n  EslintConfigTs = 'eslint.config.ts',\n\n  /**\n  Hot reload file.\n   */\n  HotReload = '.hotreload',\n\n  /**\n  License file.\n   */\n  License = 'LICENSE',\n\n  /**\n  Main CSS file.\n   */\n  MainCss = 'main.css',\n\n  /**\n  Main JavaScript file.\n   */\n  MainJs = 'main.js',\n\n  /**\n  Main TypeScript file.\n   */\n  MainTs = 'main.ts',\n\n  /**\n  Manifest file for beta releases.\n   */\n  ManifestBetaJson = 'manifest-beta.json',\n\n  /**\n  Manifest file.\n   */\n  ManifestJson = 'manifest.json',\n\n  /**\n  CommonJS Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigCjs = '.markdownlint-cli2.cjs',\n\n  /**\n  JSONC Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigJsonc = '.markdownlint-cli2.jsonc',\n\n  /**\n  ESM Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigMjs = '.markdownlint-cli2.mjs',\n\n  /**\n  YAML Markdownlint CLI2 configuration file.\n   */\n  MarkdownlintCli2ConfigYaml = '.markdownlint-cli2.yaml',\n\n  /**\n  CommonJS Markdownlint configuration file.\n   */\n  MarkdownlintConfigCjs = '.markdownlint.cjs',\n\n  /**\n  JSON Markdownlint configuration file.\n   */\n  MarkdownlintConfigJson = '.markdownlint.json',\n\n  /**\n  JSONC Markdownlint configuration file.\n   */\n  MarkdownlintConfigJsonc = '.markdownlint.jsonc',\n\n  /**\n  ESM Markdownlint configuration file.\n   */\n  MarkdownlintConfigMjs = '.markdownlint.mjs',\n\n  /**\n  YAML Markdownlint configuration file.\n   */\n  MarkdownlintConfigYaml = '.markdownlint.yaml',\n\n  /**\n  YAML Markdownlint configuration file.\n   */\n  MarkdownlintConfigYml = '.markdownlint.yml',\n\n  /**\n  Mocks folder.\n   */\n  Mocks = 'src/test-helpers',\n\n  /**\n  Node modules folder.\n   */\n  NodeModules = 'node_modules',\n\n  /**\n  NPM shrinkwrap file.\n   */\n  NpmShrinkwrapJson = 'npm-shrinkwrap.json',\n\n  /**\n  Package JSON file.\n   */\n  PackageJson = 'package.json',\n\n  /**\n  Package-lock JSON file.\n   */\n  PackageLockJson = 'package-lock.json',\n\n  /**\n  Plugins folder within an Obsidian configuration folder.\n   */\n  Plugins = 'plugins',\n\n  /**\n  Scripts folder.\n   */\n  Scripts = 'scripts',\n\n  /**\n  Script utilities folder (dev-only tooling that runs in the consumer's Node environment, not the Obsidian runtime).\n   */\n  ScriptUtils = 'src/script-utils',\n\n  /**\n  Source folder.\n   */\n  Src = 'src',\n\n  /**\n  Styles CSS file.\n   */\n  StylesCss = 'styles.css',\n\n  /**\n  Tests folder.\n   */\n  Tests = '__tests__',\n\n  /**\n  TypeScript configuration file.\n   */\n  TsConfigJson = 'tsconfig.json',\n\n  /**\n  Versions JSON file.\n   */\n  VersionsJson = 'versions.json',\n\n  /**\n  Vitest configuration file.\n   */\n  VitestConfigTs = 'vitest.config.ts'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAK,0BAAL,kBAAKA,6BAAL;AAIL,EAAAA,yBAAA,wCAAqC;AAKrC,EAAAA,yBAAA,iCAA8B;AAK9B,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,0BAAuB;AAKvB,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,wBAAqB;AAKrB,EAAAA,yBAAA,mBAAgB;AAKhB,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,UAAO;AAKP,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,aAAU;AAMV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,oBAAiB;AAKjB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,oBAAiB;AAKjB,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,YAAS;AAKT,EAAAA,yBAAA,sBAAmB;AAKnB,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,+BAA4B;AAK5B,EAAAA,yBAAA,iCAA8B;AAK9B,EAAAA,yBAAA,+BAA4B;AAK5B,EAAAA,yBAAA,gCAA6B;AAK7B,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,4BAAyB;AAKzB,EAAAA,yBAAA,6BAA0B;AAK1B,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,4BAAyB;AAKzB,EAAAA,yBAAA,2BAAwB;AAKxB,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,uBAAoB;AAKpB,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,qBAAkB;AAKlB,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,aAAU;AAKV,EAAAA,yBAAA,iBAAc;AAKd,EAAAA,yBAAA,SAAM;AAKN,EAAAA,yBAAA,eAAY;AAKZ,EAAAA,yBAAA,WAAQ;AAKR,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,kBAAe;AAKf,EAAAA,yBAAA,oBAAiB;AAxRP,SAAAA;AAAA,GAAA;",
  "names": ["ObsidianPluginRepoPaths"]
}


package/dist/lib/cjs/obsidian/plugin/obsidian-plugin-repo-paths.d.cts

@@ -113,6 +113,10 @@ export declare enum ObsidianPluginRepoPaths {
      */
     HotReload = ".hotreload",
     /**
+    License file.
+     */
+    License = "LICENSE",
+    /**
     Main CSS file.
      */
     MainCss = "main.css",

package/dist/lib/cjs/obsidian/reference.cjs

@@ -145,6 +145,7 @@ __export(reference_exports, {
   isCanvasFileNodeReference: () => isCanvasFileNodeReference,
   isCanvasReference: () => isCanvasReference,
   isCanvasTextNodeReference: () => isCanvasTextNodeReference,
+  isReferenceInOffsetRange: () => isReferenceInOffsetRange,
   referenceToFileChange: () => referenceToFileChange,
   sortReferences: () => sortReferences
 });
@@ -160,6 +161,12 @@ function isCanvasReference(reference) {
 function isCanvasTextNodeReference(reference) {
   return isCanvasReference(reference) && reference.type === "text";
 }
+function isReferenceInOffsetRange(reference, offsetRange) {
+  if (!(0, import_implementations.isReferenceCache)(reference)) {
+    return false;
+  }
+  return offsetRange.startOffset <= reference.position.start.offset && reference.position.end.offset <= offsetRange.endOffset;
+}
 function referenceToFileChange(reference, newContent) {
   if ((0, import_frontmatter_link_cache_with_offsets.isFrontmatterLinkCacheWithOffsets)(reference)) {
     return {
@@ -192,7 +199,8 @@ function sortReferences(references) {
   isCanvasFileNodeReference,
   isCanvasReference,
   isCanvasTextNodeReference,
+  isReferenceInOffsetRange,
   referenceToFileChange,
   sortReferences
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/reference.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for handling references in Obsidian.\n */\n\nimport type {\n  FrontmatterLinkCache,\n  Reference\n} from 'obsidian';\n\nimport {\n  isFrontmatterLinkCache,\n  isReferenceCache\n} from '@obsidian-typings/obsidian-public-latest/implementations';\n\nimport type { FileChange } from './file-change.ts';\n\nimport { isFrontmatterLinkCacheWithOffsets } from './frontmatter-link-cache-with-offsets.ts';\n\n/**\n * A reference within a file node in a canvas.\n */\nexport interface CanvasFileNodeReference extends CanvasReference {\n  /**\n   * A type of reference.\n   */\n  type: 'file';\n}\n\n/**\n * A reference within a canvas.\n */\nexport interface CanvasReference extends FrontmatterLinkCache {\n  /**\n   * Whether the reference is a canvas reference.\n   */\n  isCanvas: true;\n\n  /**\n   * An index of the node in the canvas.\n   */\n  nodeIndex: number;\n\n  /**\n   * A type of reference.\n   */\n  type: 'file' | 'text';\n}\n\n/**\n * A reference within a text node in a canvas.\n */\nexport interface CanvasTextNodeReference extends CanvasReference {\n  /**\n   * An original reference.\n   */\n  originalReference: Reference;\n\n  /**\n   * A type of reference.\n   */\n  type: 'text';\n}\n\n/**\n * A range within a file's content, expressed in character offsets.\n *\n * Both bounds are inclusive: a reference whose own offsets coincide exactly with\n * {@link OffsetRange.startOffset} / {@link OffsetRange.endOffset} is inside the range.\n */\nexport interface OffsetRange {\n  /**\n   * An end offset of the range within the file's content.\n   */\n  readonly endOffset: number;\n\n  /**\n   * A start offset of the range within the file's content.\n   */\n  readonly startOffset: number;\n}\n\n/**\n * Checks if a reference is a canvas file node reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas file node reference.\n */\nexport function isCanvasFileNodeReference(reference: Reference): reference is CanvasFileNodeReference {\n  return isCanvasReference(reference) && reference.type === 'file';\n}\n\n/**\n * Checks if a reference is a canvas reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas reference.\n */\nexport function isCanvasReference(reference: Reference): reference is CanvasReference {\n  return isFrontmatterLinkCache(reference) && !!(reference as Partial<CanvasReference>).isCanvas;\n}\n\n/**\n * Checks if a reference is a canvas text node reference.\n *\n * @param reference - The reference to check.\n * @returns Whether the reference is a canvas text node reference.\n */\nexport function isCanvasTextNodeReference(reference: Reference): reference is CanvasTextNodeReference {\n  return isCanvasReference(reference) && reference.type === 'text';\n}\n\n/**\n * Checks if a reference is fully contained within an offset range.\n *\n * Only a reference that carries a position within the file's content can be in a range. A\n * {@link FrontmatterLinkCache} \u2014 a frontmatter link, a multi-link frontmatter value entry, or any canvas\n * reference \u2014 carries no such position and is therefore never in range. Its `startOffset` / `endOffset`,\n * where present, locate the link within its own property value rather than within the file, so they are\n * deliberately not compared against the range.\n *\n * Containment is full and both bounds are inclusive: a reference that only partially overlaps the range is\n * not in it, because rewriting part of a link corrupts it.\n *\n * @param reference - The reference to check.\n * @param offsetRange - The offset range to check against.\n * @returns Whether the reference is fully contained within the offset range.\n */\nexport function isReferenceInOffsetRange(reference: Reference, offsetRange: OffsetRange): boolean {\n  if (!isReferenceCache(reference)) {\n    return false;\n  }\n\n  return offsetRange.startOffset <= reference.position.start.offset && reference.position.end.offset <= offsetRange.endOffset;\n}\n\n/**\n * Converts a reference to a file change.\n *\n * @param reference - The reference to convert.\n * @param newContent - The new content for the reference.\n * @returns The file change.\n */\nexport function referenceToFileChange(reference: Reference, newContent: string): FileChange {\n  if (isFrontmatterLinkCacheWithOffsets(reference)) {\n    return {\n      newContent,\n      oldContent: reference.original.slice(reference.startOffset, reference.endOffset),\n      reference\n    };\n  }\n\n  return {\n    newContent,\n    oldContent: reference.original,\n    reference\n  };\n}\n\n/**\n * Sorts references by their type and position.\n *\n * @param references - The references to sort.\n * @returns The sorted references.\n */\nexport function sortReferences(references: Reference[]): Reference[] {\n  return references.sort((a, b) => {\n    if (isFrontmatterLinkCache(a) && isFrontmatterLinkCache(b)) {\n      const aStartOffset = isFrontmatterLinkCacheWithOffsets(a) ? a.startOffset : 0;\n      /* v8 ignore start -- v8 incorrectly reports this branch as uncovered, but it is covered by `should sort two frontmatter links without offsets` test. */\n      const bStartOffset = isFrontmatterLinkCacheWithOffsets(b) ? b.startOffset : 0;\n      /* v8 ignore stop */\n      return a.key.localeCompare(b.key) || Number(isFrontmatterLinkCacheWithOffsets(b)) - Number(isFrontmatterLinkCacheWithOffsets(a))\n        || aStartOffset - bStartOffset;\n    }\n\n    if (isReferenceCache(a) && isReferenceCache(b)) {\n      return a.position.start.offset - b.position.start.offset;\n    }\n\n    return isFrontmatterLinkCache(a) ? 1 : -1;\n  });\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,6BAGO;AAIP,iDAAkD;AAuE3C,SAAS,0BAA0B,WAA4D;AACpG,SAAO,kBAAkB,SAAS,KAAK,UAAU,SAAS;AAC5D;AAQO,SAAS,kBAAkB,WAAoD;AACpF,aAAO,+CAAuB,SAAS,KAAK,CAAC,CAAE,UAAuC;AACxF;AAQO,SAAS,0BAA0B,WAA4D;AACpG,SAAO,kBAAkB,SAAS,KAAK,UAAU,SAAS;AAC5D;AAkBO,SAAS,yBAAyB,WAAsB,aAAmC;AAChG,MAAI,KAAC,yCAAiB,SAAS,GAAG;AAChC,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,eAAe,UAAU,SAAS,MAAM,UAAU,UAAU,SAAS,IAAI,UAAU,YAAY;AACpH;AASO,SAAS,sBAAsB,WAAsB,YAAgC;AAC1F,UAAI,8EAAkC,SAAS,GAAG;AAChD,WAAO;AAAA,MACL;AAAA,MACA,YAAY,UAAU,SAAS,MAAM,UAAU,aAAa,UAAU,SAAS;AAAA,MAC/E;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA,YAAY,UAAU;AAAA,IACtB;AAAA,EACF;AACF;AAQO,SAAS,eAAe,YAAsC;AACnE,SAAO,WAAW,KAAK,CAAC,GAAG,MAAM;AAC/B,YAAI,+CAAuB,CAAC,SAAK,+CAAuB,CAAC,GAAG;AAC1D,YAAM,mBAAe,8EAAkC,CAAC,IAAI,EAAE,cAAc;AAE5E,YAAM,mBAAe,8EAAkC,CAAC,IAAI,EAAE,cAAc;AAE5E,aAAO,EAAE,IAAI,cAAc,EAAE,GAAG,KAAK,WAAO,8EAAkC,CAAC,CAAC,IAAI,WAAO,8EAAkC,CAAC,CAAC,KAC1H,eAAe;AAAA,IACtB;AAEA,YAAI,yCAAiB,CAAC,SAAK,yCAAiB,CAAC,GAAG;AAC9C,aAAO,EAAE,SAAS,MAAM,SAAS,EAAE,SAAS,MAAM;AAAA,IACpD;AAEA,eAAO,+CAAuB,CAAC,IAAI,IAAI;AAAA,EACzC,CAAC;AACH;",
  "names": []
}


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

@@ -45,6 +45,22 @@ export interface CanvasTextNodeReference extends CanvasReference {
      */
     type: 'text';
 }
+/**
+ * A range within a file's content, expressed in character offsets.
+ *
+ * Both bounds are inclusive: a reference whose own offsets coincide exactly with
+ * {@link OffsetRange.startOffset} / {@link OffsetRange.endOffset} is inside the range.
+ */
+export interface OffsetRange {
+    /**
+     * An end offset of the range within the file's content.
+     */
+    readonly endOffset: number;
+    /**
+     * A start offset of the range within the file's content.
+     */
+    readonly startOffset: number;
+}
 /**
  * Checks if a reference is a canvas file node reference.
  *
@@ -66,6 +82,23 @@ export declare function isCanvasReference(reference: Reference): reference is Ca
  * @returns Whether the reference is a canvas text node reference.
  */
 export declare function isCanvasTextNodeReference(reference: Reference): reference is CanvasTextNodeReference;
+/**
+ * Checks if a reference is fully contained within an offset range.
+ *
+ * Only a reference that carries a position within the file's content can be in a range. A
+ * {@link FrontmatterLinkCache} — a frontmatter link, a multi-link frontmatter value entry, or any canvas
+ * reference — carries no such position and is therefore never in range. Its `startOffset` / `endOffset`,
+ * where present, locate the link within its own property value rather than within the file, so they are
+ * deliberately not compared against the range.
+ *
+ * Containment is full and both bounds are inclusive: a reference that only partially overlaps the range is
+ * not in it, because rewriting part of a link corrupts it.
+ *
+ * @param reference - The reference to check.
+ * @param offsetRange - The offset range to check against.
+ * @returns Whether the reference is fully contained within the offset range.
+ */
+export declare function isReferenceInOffsetRange(reference: Reference, offsetRange: OffsetRange): boolean;
 /**
  * Converts a reference to a file change.
  *