@mnaoumov/obsidian-lib 10.4.1 → 10.5.1

package/dist/lib/esm/bug-report.mjs

@@ -0,0 +1,141 @@
+/*
+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"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+
+import {
+  apiVersion,
+  Platform
+} from "obsidian";
+import { getMobileAppInfo } from "./mobile-app-info.mjs";
+var BugReportIssueFormFieldId = /* @__PURE__ */ ((BugReportIssueFormFieldId2) => {
+  BugReportIssueFormFieldId2["Environment"] = "environment";
+  BugReportIssueFormFieldId2["ObsidianVersion"] = "obsidian-version";
+  BugReportIssueFormFieldId2["OperatingSystem"] = "operating-system";
+  BugReportIssueFormFieldId2["PluginVersion"] = "plugin-version";
+  return BugReportIssueFormFieldId2;
+})(BugReportIssueFormFieldId || {});
+const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+const UNKNOWN = "unknown";
+function formatBugReportEnvironment(environment) {
+  const enabledPlugins = environment.enabledPlugins.length === 0 ? "none" : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(", ");
+  return `- Plugin: ${formatPluginInfo(environment.plugin)}
+- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})
+- Platform: ${environment.platform}
+- Operating system: ${environment.operatingSystem}
+- Other enabled plugins: ${enabledPlugins}`;
+}
+async function getBugReportEnvironment(params) {
+  const { app, pluginId } = params;
+  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();
+  return {
+    enabledPlugins: [...app.plugins.enabledPlugins].filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
+    installerVersion,
+    obsidianVersion: apiVersion,
+    operatingSystem,
+    platform: getPlatformName(),
+    plugin: getPluginInfo(app, pluginId)
+  };
+}
+async function getBugReportIssueFormUrl(params) {
+  const environment = await getBugReportEnvironment(params);
+  return getGitHubIssueFormUrl({
+    fields: {
+      ["environment" /* Environment */]: formatBugReportEnvironment(environment),
+      ["obsidian-version" /* ObsidianVersion */]: environment.obsidianVersion,
+      ["operating-system" /* OperatingSystem */]: environment.operatingSystem,
+      ["plugin-version" /* PluginVersion */]: environment.plugin.version ?? UNKNOWN
+    },
+    gitHubRepo: params.gitHubRepo,
+    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,
+    ...params.title !== void 0 && { title: params.title }
+  });
+}
+function getGitHubIssueFormUrl(params) {
+  const searchParams = new URLSearchParams({ template: params.template });
+  if (params.title !== void 0) {
+    searchParams.set("title", params.title);
+  }
+  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {
+    searchParams.set(fieldId, value);
+  }
+  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;
+}
+function formatPluginInfo(pluginInfo) {
+  return `\`${pluginInfo.id}\` ${pluginInfo.version ?? UNKNOWN}`;
+}
+async function getAppAndOperatingSystem() {
+  if (Platform.isMobileApp) {
+    const mobileAppInfo = await getMobileAppInfo();
+    return {
+      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,
+      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN
+    };
+  }
+  if (!Platform.isDesktopApp) {
+    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };
+  }
+  const { getDesktopOperatingSystem } = await import("./desktop-operating-system.mjs");
+  const build = Platform.build;
+  return {
+    installerVersion: typeof build === "string" ? build : UNKNOWN,
+    operatingSystem: getDesktopOperatingSystem()
+  };
+}
+function getPlatformName() {
+  if (Platform.isAndroidApp) {
+    return "Android";
+  }
+  if (Platform.isIosApp) {
+    return "iOS";
+  }
+  if (Platform.isMacOS) {
+    return "macOS";
+  }
+  if (Platform.isWin) {
+    return "Windows";
+  }
+  return Platform.isLinux ? "Linux" : UNKNOWN;
+}
+function getPluginInfo(app, pluginId) {
+  return {
+    id: pluginId,
+    version: app.plugins.manifests[pluginId]?.version ?? null
+  };
+}
+export {
+  BUG_REPORT_ISSUE_FORM_TEMPLATE,
+  BugReportIssueFormFieldId,
+  formatBugReportEnvironment,
+  getBugReportEnvironment,
+  getBugReportIssueFormUrl,
+  getGitHubIssueFormUrl
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/bug-report.ts"],"sourcesContent":["/**\n * @file\n *\n * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form\n * prefilled with it.\n *\n * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported\n * dynamically, on desktop only.\n *\n * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop\n * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read\n * structurally here, and reads as `unknown` if a later version drops it.\n */\n\nimport type { App } from 'obsidian';\n\nimport {\n  apiVersion,\n  Platform\n} from 'obsidian';\n\nimport { getMobileAppInfo } from './mobile-app-info.ts';\n\n/**\n * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub\n * prefills a field from a query parameter named after the field's `id`, so a form must give its fields\n * these ids for them to be filled.\n */\nexport enum BugReportIssueFormFieldId {\n  /**\n   * The whole environment, as {@link formatBugReportEnvironment} renders it.\n   */\n  Environment = 'environment',\n\n  /**\n   * The Obsidian version.\n   */\n  ObsidianVersion = 'obsidian-version',\n\n  /**\n   * The operating system.\n   */\n  OperatingSystem = 'operating-system',\n\n  /**\n   * The reporting plugin's version.\n   */\n  PluginVersion = 'plugin-version'\n}\n\n/**\n * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.\n */\nexport const BUG_REPORT_ISSUE_FORM_TEMPLATE = 'bug_report.yml';\n\n/**\n * The environment a bug report needs.\n */\nexport interface BugReportEnvironment {\n  /**\n   * The other enabled plugins, sorted by id.\n   */\n  readonly enabledPlugins: readonly BugReportPluginInfo[];\n\n  /**\n   * The installed app's version, which can lag behind {@link obsidianVersion}.\n   */\n  readonly installerVersion: string;\n\n  /**\n   * The Obsidian version.\n   */\n  readonly obsidianVersion: string;\n\n  /**\n   * The operating system's name and version.\n   */\n  readonly operatingSystem: string;\n\n  /**\n   * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.\n   */\n  readonly platform: string;\n\n  /**\n   * The reporting plugin.\n   */\n  readonly plugin: BugReportPluginInfo;\n}\n\n/**\n * A plugin, as a bug report names it.\n */\nexport interface BugReportPluginInfo {\n  /**\n   * The plugin's id.\n   */\n  readonly id: string;\n\n  /**\n   * The plugin's installed version, or `null` when its manifest is not known.\n   */\n  readonly version: null | string;\n}\n\n/**\n * Parameters for {@link getBugReportEnvironment}.\n */\nexport interface GetBugReportEnvironmentParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the reporting plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getBugReportIssueFormUrl}.\n */\nexport interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {\n  /**\n   * The plugin's GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\n/**\n * Parameters for {@link getGitHubIssueFormUrl}.\n */\nexport interface GetGitHubIssueFormUrlParams {\n  /**\n   * The values to prefill, keyed by field `id`.\n   */\n  readonly fields?: Readonly<Record<string, string>>;\n\n  /**\n   * The GitHub repository, as `owner/name`.\n   */\n  readonly gitHubRepo: string;\n\n  /**\n   * The form's file name, under `.github/ISSUE_TEMPLATE`.\n   */\n  readonly template: string;\n\n  /**\n   * The issue's title. Leave it out to keep the form's own default title.\n   */\n  readonly title?: string;\n}\n\ninterface AppAndOperatingSystem {\n  readonly installerVersion: string;\n  readonly operatingSystem: string;\n}\n\ninterface PlatformWithBuild {\n  readonly build?: unknown;\n}\n\nconst UNKNOWN = 'unknown';\n\n/**\n * Renders a bug report's environment as a Markdown list.\n *\n * @param environment - The environment.\n * @returns The Markdown.\n */\nexport function formatBugReportEnvironment(environment: BugReportEnvironment): string {\n  const enabledPlugins = environment.enabledPlugins.length === 0\n    ? 'none'\n    : environment.enabledPlugins.map((pluginInfo) => formatPluginInfo(pluginInfo)).join(', ');\n\n  return `- Plugin: ${formatPluginInfo(environment.plugin)}\\n`\n    + `- Obsidian: ${environment.obsidianVersion} (installer ${environment.installerVersion})\\n`\n    + `- Platform: ${environment.platform}\\n`\n    + `- Operating system: ${environment.operatingSystem}\\n`\n    + `- Other enabled plugins: ${enabledPlugins}`;\n}\n\n/**\n * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the\n * Obsidian and installer versions, the platform and the operating system.\n *\n * @param params - The parameters.\n * @returns The environment.\n */\nexport async function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment> {\n  const { app, pluginId } = params;\n  const { installerVersion, operatingSystem } = await getAppAndOperatingSystem();\n\n  return {\n    enabledPlugins: [...app.plugins.enabledPlugins]\n      .filter((id) => id !== pluginId)\n      .sort()\n      .map((id) => getPluginInfo(app, id)),\n    installerVersion,\n    obsidianVersion: apiVersion,\n    operatingSystem,\n    platform: getPlatformName(),\n    plugin: getPluginInfo(app, pluginId)\n  };\n}\n\n/**\n * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with\n * the environment, in the fields {@link BugReportIssueFormFieldId} names.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport async function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string> {\n  const environment = await getBugReportEnvironment(params);\n\n  return getGitHubIssueFormUrl({\n    fields: {\n      [BugReportIssueFormFieldId.Environment]: formatBugReportEnvironment(environment),\n      [BugReportIssueFormFieldId.ObsidianVersion]: environment.obsidianVersion,\n      [BugReportIssueFormFieldId.OperatingSystem]: environment.operatingSystem,\n      [BugReportIssueFormFieldId.PluginVersion]: environment.plugin.version ?? UNKNOWN\n    },\n    gitHubRepo: params.gitHubRepo,\n    template: BUG_REPORT_ISSUE_FORM_TEMPLATE,\n    ...params.title !== undefined && { title: params.title }\n  });\n}\n\n/**\n * Gets a link that opens a GitHub issue form with fields prefilled.\n *\n * @param params - The parameters.\n * @returns The link.\n */\nexport function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string {\n  const searchParams = new URLSearchParams({ template: params.template });\n  if (params.title !== undefined) {\n    searchParams.set('title', params.title);\n  }\n\n  for (const [fieldId, value] of Object.entries(params.fields ?? {})) {\n    searchParams.set(fieldId, value);\n  }\n\n  return `https://github.com/${params.gitHubRepo}/issues/new?${searchParams.toString()}`;\n}\n\nfunction formatPluginInfo(pluginInfo: BugReportPluginInfo): string {\n  return `\\`${pluginInfo.id}\\` ${pluginInfo.version ?? UNKNOWN}`;\n}\n\nasync function getAppAndOperatingSystem(): Promise<AppAndOperatingSystem> {\n  if (Platform.isMobileApp) {\n    const mobileAppInfo = await getMobileAppInfo();\n    return {\n      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,\n      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN\n    };\n  }\n\n  if (!Platform.isDesktopApp) {\n    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };\n  }\n\n  // Conditional import of the desktop-only lookup, which reads `node:os`; this branch runs only on desktop.\n  const { getDesktopOperatingSystem } = await import('./desktop-operating-system.ts');\n  const build = (Platform as PlatformWithBuild).build;\n  return {\n    installerVersion: typeof build === 'string' ? build : UNKNOWN,\n    operatingSystem: getDesktopOperatingSystem()\n  };\n}\n\nfunction getPlatformName(): string {\n  if (Platform.isAndroidApp) {\n    return 'Android';\n  }\n  if (Platform.isIosApp) {\n    return 'iOS';\n  }\n  if (Platform.isMacOS) {\n    return 'macOS';\n  }\n  if (Platform.isWin) {\n    return 'Windows';\n  }\n  return Platform.isLinux ? 'Linux' : UNKNOWN;\n}\n\nfunction getPluginInfo(app: App, pluginId: string): BugReportPluginInfo {\n  return {\n    id: pluginId,\n    version: app.plugins.manifests[pluginId]?.version ?? null\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,wBAAwB;AAO1B,IAAK,4BAAL,kBAAKA,+BAAL;AAIL,EAAAA,2BAAA,iBAAc;AAKd,EAAAA,2BAAA,qBAAkB;AAKlB,EAAAA,2BAAA,qBAAkB;AAKlB,EAAAA,2BAAA,mBAAgB;AAnBN,SAAAA;AAAA,GAAA;AAyBL,MAAM,iCAAiC;AAoH9C,MAAM,UAAU;AAQT,SAAS,2BAA2B,aAA2C;AACpF,QAAM,iBAAiB,YAAY,eAAe,WAAW,IACzD,SACA,YAAY,eAAe,IAAI,CAAC,eAAe,iBAAiB,UAAU,CAAC,EAAE,KAAK,IAAI;AAE1F,SAAO,aAAa,iBAAiB,YAAY,MAAM,CAAC;AAAA,cACrC,YAAY,eAAe,eAAe,YAAY,gBAAgB;AAAA,cACtE,YAAY,QAAQ;AAAA,sBACZ,YAAY,eAAe;AAAA,2BACtB,cAAc;AAChD;AASA,eAAsB,wBAAwB,QAAsE;AAClH,QAAM,EAAE,KAAK,SAAS,IAAI;AAC1B,QAAM,EAAE,kBAAkB,gBAAgB,IAAI,MAAM,yBAAyB;AAE7E,SAAO;AAAA,IACL,gBAAgB,CAAC,GAAG,IAAI,QAAQ,cAAc,EAC3C,OAAO,CAAC,OAAO,OAAO,QAAQ,EAC9B,KAAK,EACL,IAAI,CAAC,OAAO,cAAc,KAAK,EAAE,CAAC;AAAA,IACrC;AAAA,IACA,iBAAiB;AAAA,IACjB;AAAA,IACA,UAAU,gBAAgB;AAAA,IAC1B,QAAQ,cAAc,KAAK,QAAQ;AAAA,EACrC;AACF;AASA,eAAsB,yBAAyB,QAAyD;AACtG,QAAM,cAAc,MAAM,wBAAwB,MAAM;AAExD,SAAO,sBAAsB;AAAA,IAC3B,QAAQ;AAAA,MACN,CAAC,+BAAqC,GAAG,2BAA2B,WAAW;AAAA,MAC/E,CAAC,wCAAyC,GAAG,YAAY;AAAA,MACzD,CAAC,wCAAyC,GAAG,YAAY;AAAA,MACzD,CAAC,oCAAuC,GAAG,YAAY,OAAO,WAAW;AAAA,IAC3E;AAAA,IACA,YAAY,OAAO;AAAA,IACnB,UAAU;AAAA,IACV,GAAG,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EACzD,CAAC;AACH;AAQO,SAAS,sBAAsB,QAA6C;AACjF,QAAM,eAAe,IAAI,gBAAgB,EAAE,UAAU,OAAO,SAAS,CAAC;AACtE,MAAI,OAAO,UAAU,QAAW;AAC9B,iBAAa,IAAI,SAAS,OAAO,KAAK;AAAA,EACxC;AAEA,aAAW,CAAC,SAAS,KAAK,KAAK,OAAO,QAAQ,OAAO,UAAU,CAAC,CAAC,GAAG;AAClE,iBAAa,IAAI,SAAS,KAAK;AAAA,EACjC;AAEA,SAAO,sBAAsB,OAAO,UAAU,eAAe,aAAa,SAAS,CAAC;AACtF;AAEA,SAAS,iBAAiB,YAAyC;AACjE,SAAO,KAAK,WAAW,EAAE,MAAM,WAAW,WAAW,OAAO;AAC9D;AAEA,eAAe,2BAA2D;AACxE,MAAI,SAAS,aAAa;AACxB,UAAM,gBAAgB,MAAM,iBAAiB;AAC7C,WAAO;AAAA,MACL,kBAAkB,eAAe,oBAAoB;AAAA,MACrD,iBAAiB,eAAe,mBAAmB;AAAA,IACrD;AAAA,EACF;AAEA,MAAI,CAAC,SAAS,cAAc;AAC1B,WAAO,EAAE,kBAAkB,SAAS,iBAAiB,QAAQ;AAAA,EAC/D;AAGA,QAAM,EAAE,0BAA0B,IAAI,MAAM,OAAO,+BAA+B;AAClF,QAAM,QAAS,SAA+B;AAC9C,SAAO;AAAA,IACL,kBAAkB,OAAO,UAAU,WAAW,QAAQ;AAAA,IACtD,iBAAiB,0BAA0B;AAAA,EAC7C;AACF;AAEA,SAAS,kBAA0B;AACjC,MAAI,SAAS,cAAc;AACzB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,UAAU;AACrB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,SAAS;AACpB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,OAAO;AAClB,WAAO;AAAA,EACT;AACA,SAAO,SAAS,UAAU,UAAU;AACtC;AAEA,SAAS,cAAc,KAAU,UAAuC;AACtE,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,SAAS,IAAI,QAAQ,UAAU,QAAQ,GAAG,WAAW;AAAA,EACvD;AACF;","names":["BugReportIssueFormFieldId"]}

package/dist/lib/esm/bulk-operation-progress.d.mts

@@ -10,6 +10,11 @@
  * {@link loop} reports after every item it processes. Code that drives a bulk operation without `loop()` calls
  * {@link reportBulkOperationProgress} itself.
  *
+ * An operation waiting on the user (a confirmation, a picker) makes no progress, yet it is not hung. While such a
+ * dialog is open, {@link holdBulkOperationWhile} reports on an interval, scoped to that one promise: the timer
+ * stops the moment the dialog settles, so a hung operation outside a dialog still goes stale. Every modal helper of
+ * this library already holds through `showModal`.
+ *
  * The listener set lives in the shared-state bag under a versioned key, so a `loop()` bundled by one plugin's copy
  * of this library reaches a listener registered by another's. Its shape is a cross-copy wire format: a `Set` of
  * plain functions, read structurally.
@@ -18,6 +23,23 @@
  * A listener notified whenever a bulk operation makes progress.
  */
 export type BulkOperationProgressListener = () => void;
+/**
+ * How often {@link holdBulkOperationWhile} reports progress while its promise is pending, well inside the lock's
+ * staleness window.
+ */
+export declare const BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS = 10000;
+/**
+ * Keeps a bulk operation's lease lock fresh while it waits on something that is not progress but not a hang either,
+ * such as a dialog waiting for the user.
+ *
+ * Reports progress at once, then every {@link BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS} while the promise is
+ * pending, and once more when it settles. Outside a bulk operation it costs one interval and nothing else.
+ *
+ * @typeParam T - The type of the promise's value.
+ * @param promise - The promise to wait for.
+ * @returns The promise's value.
+ */
+export declare function holdBulkOperationWhile<T>(promise: Promise<T>): Promise<T>;
 /**
  * Subscribes to bulk-operation progress.
  *

package/dist/lib/esm/bulk-operation-progress.mjs

@@ -5,6 +5,17 @@ if you want to view the source, please visit the github repository of this plugi
 
 import { getObsidianLibState } from "./obsidian-lib-state.mjs";
 const BULK_OPERATION_PROGRESS_STATE_KEY = "bulkOperationProgressV1";
+const BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS = 1e4;
+async function holdBulkOperationWhile(promise) {
+  reportBulkOperationProgress();
+  const intervalId = window.setInterval(reportBulkOperationProgress, BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS);
+  try {
+    return await promise;
+  } finally {
+    window.clearInterval(intervalId);
+    reportBulkOperationProgress();
+  }
+}
 function registerBulkOperationProgressListener(listener) {
   const listeners = getListeners();
   listeners.add(listener);
@@ -25,7 +36,9 @@ function getListeners() {
   return getObsidianLibState(BULK_OPERATION_PROGRESS_STATE_KEY, /* @__PURE__ */ new Set()).value;
 }
 export {
+  BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS,
+  holdBulkOperationWhile,
   registerBulkOperationProgressListener,
   reportBulkOperationProgress
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/case-insensitive-file-index.mjs

@@ -31,6 +31,7 @@ ensureBrowserProcess();
 })();
 
 import { snapshot } from "@mnaoumov/typescript-lib/array";
+import { TFolder } from "obsidian";
 import { getObsidianLibState } from "./obsidian-lib-state.mjs";
 const STATE_KEY = "caseInsensitiveFileIndex";
 class CaseInsensitiveFileIndex {
@@ -60,7 +61,11 @@ class CaseInsensitiveFileIndex {
    */
   delete(path) {
     const key = path.toLowerCase();
+    const abstractFile = this.map.get(key);
     this.map.delete(key);
+    if (abstractFile && !(abstractFile instanceof TFolder)) {
+      return;
+    }
     const descendantPrefix = `${key}/`;
     for (const existingKey of snapshot(this.map.keys())) {
       if (existingKey.startsWith(descendantPrefix)) {
@@ -102,6 +107,9 @@ class CaseInsensitiveFileIndex {
     const newKey = newAbstractFile.path.toLowerCase();
     this.map.delete(oldKey);
     this.map.set(newKey, newAbstractFile);
+    if (!(newAbstractFile instanceof TFolder)) {
+      return;
+    }
     const oldDescendantPrefix = `${oldKey}/`;
     const newDescendantPrefix = `${newKey}/`;
     for (const [existingKey, existingValue] of snapshot(this.map)) {
@@ -132,4 +140,4 @@ export {
   setCaseInsensitiveFileIndex,
   unsetCaseInsensitiveFileIndex
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/case-insensitive-file-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.\n *\n * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves\n * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an\n * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension\n * checks and cache lookups are performed on already-removed paths. This module backs the\n * case-insensitive lookup with a `lowercase-path → TAbstractFile` index so misses are O(1) too.\n *\n * The index is explicitly opt-in: a consumer installs it by loading a\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in\n * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,\n * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\nconst STATE_KEY = 'caseInsensitiveFileIndex';\n\n/**\n * An O(1) case-insensitive index of the loaded files and folders of a single vault.\n *\n * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept\n * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.\n */\nexport class CaseInsensitiveFileIndex {\n  private readonly map = new Map<string, TAbstractFile>();\n\n  /**\n   * Creates a new case-insensitive file index.\n   *\n   * @param app - The Obsidian application instance whose vault this index mirrors.\n   */\n  public constructor(protected readonly app: App) {}\n\n  /**\n   * Adds an abstract file to the index.\n   *\n   * @param abstractFile - The abstract file to add.\n   */\n  public add(abstractFile: TAbstractFile): void {\n    this.map.set(abstractFile.path.toLowerCase(), abstractFile);\n  }\n\n  /**\n   * Removes the abstract file at the given path from the index, along with all of its descendants\n   * (for folder deletions, where Obsidian removes the whole subtree).\n   *\n   * @param path - The path of the abstract file to remove.\n   */\n  public delete(path: string): void {\n    const key = path.toLowerCase();\n    this.map.delete(key);\n    const descendantPrefix = `${key}/`;\n    for (const existingKey of snapshot(this.map.keys())) {\n      if (existingKey.startsWith(descendantPrefix)) {\n        this.map.delete(existingKey);\n      }\n    }\n  }\n\n  /**\n   * Resolves an abstract file by its path, case-insensitively, in O(1).\n   *\n   * @param path - The path to resolve.\n   * @returns The abstract file if found, otherwise `null`.\n   */\n  public get(path: string): null | TAbstractFile {\n    return this.map.get(path.toLowerCase()) ?? null;\n  }\n\n  /**\n   * Checks whether this index mirrors the given application's vault.\n   *\n   * @param app - The application instance to check against.\n   * @returns `true` if this index belongs to the given application, `false` otherwise.\n   */\n  public ownsApp(app: App): boolean {\n    return this.app === app;\n  }\n\n  /**\n   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.\n   *\n   * Obsidian fires a single `rename` event for the renamed abstract file and updates its\n   * descendants' paths in place without firing per-descendant events, so descendant keys are\n   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the\n   * old and new keys coincide).\n   *\n   * @param oldPath - The path the abstract file had before the rename.\n   * @param newAbstractFile - The abstract file with its updated (post-rename) path.\n   */\n  public rename(oldPath: string, newAbstractFile: TAbstractFile): void {\n    const oldKey = oldPath.toLowerCase();\n    const newKey = newAbstractFile.path.toLowerCase();\n    this.map.delete(oldKey);\n    this.map.set(newKey, newAbstractFile);\n\n    const oldDescendantPrefix = `${oldKey}/`;\n    const newDescendantPrefix = `${newKey}/`;\n    for (const [existingKey, existingValue] of snapshot(this.map)) {\n      if (!existingKey.startsWith(oldDescendantPrefix)) {\n        continue;\n      }\n\n      this.map.delete(existingKey);\n      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);\n    }\n  }\n}\n\n/**\n * Retrieves the installed case-insensitive file index for the given application, if any.\n *\n * @param app - The application instance whose index to retrieve.\n * @returns The index if one is installed for this application, otherwise `null`.\n */\nexport function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null {\n  const index = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value;\n  return index?.ownsApp(app) ? index : null;\n}\n\n/**\n * Installs a case-insensitive file index as the active resolver.\n *\n * @param index - The index to install.\n */\nexport function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value = index;\n}\n\n/**\n * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.\n *\n * @param index - The index to uninstall.\n */\nexport function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  const wrapper = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null);\n  if (wrapper.value === index) {\n    wrapper.value = null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,gBAAgB;AAEzB,SAAS,2BAA2B;AAEpC,MAAM,YAAY;AAQX,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7B,YAA+B,KAAU;AAAV;AAAA,EAAW;AAAA,EAAX;AAAA,EAPrB,MAAM,oBAAI,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc/C,IAAI,cAAmC;AAC5C,SAAK,IAAI,IAAI,aAAa,KAAK,YAAY,GAAG,YAAY;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,MAAoB;AAChC,UAAM,MAAM,KAAK,YAAY;AAC7B,SAAK,IAAI,OAAO,GAAG;AACnB,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,eAAe,SAAS,KAAK,IAAI,KAAK,CAAC,GAAG;AACnD,UAAI,YAAY,WAAW,gBAAgB,GAAG;AAC5C,aAAK,IAAI,OAAO,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,MAAoC;AAC7C,WAAO,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,KAAmB;AAChC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,OAAO,SAAiB,iBAAsC;AACnE,UAAM,SAAS,QAAQ,YAAY;AACnC,UAAM,SAAS,gBAAgB,KAAK,YAAY;AAChD,SAAK,IAAI,OAAO,MAAM;AACtB,SAAK,IAAI,IAAI,QAAQ,eAAe;AAEpC,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,KAAK,SAAS,KAAK,GAAG,GAAG;AAC7D,UAAI,CAAC,YAAY,WAAW,mBAAmB,GAAG;AAChD;AAAA,MACF;AAEA,WAAK,IAAI,OAAO,WAAW;AAC3B,WAAK,IAAI,IAAI,sBAAsB,YAAY,MAAM,oBAAoB,MAAM,GAAG,aAAa;AAAA,IACjG;AAAA,EACF;AACF;AAQO,SAAS,4BAA4B,KAA2C;AACrF,QAAM,QAAQ,oBAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,sBAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,UAAU,oBAAqD,WAAW,IAAI;AACpF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/case-insensitive-file-index.ts"],"sourcesContent":["/**\n * @file\n *\n * Provides an opt-in O(1) case-insensitive resolver for Obsidian vaults.\n *\n * Obsidian's native {@link https://docs.obsidian.md/Reference/TypeScript+API/Vault | Vault} resolves\n * a string path case-insensitively (the Windows/macOS default) in O(1) on a hit but with an\n * O(vault) scan on a miss. The miss case is the hot one during deletion cascades, where extension\n * checks and cache lookups are performed on already-removed paths. This module backs the\n * case-insensitive lookup with a `lowercase-path → TAbstractFile` index so misses are O(1) too.\n *\n * The index is explicitly opt-in: a consumer installs it by loading a\n * {@link https://docs.obsidian.md/Reference/TypeScript+API/Component | Component} that keeps it in\n * sync with `create`/`delete`/`rename` events (see `CaseInsensitiveFileIndexComponent`). Until then,\n * the resolution layer falls back to the native (O(vault)-on-miss) lookup, so behavior is unchanged.\n */\n\nimport type {\n  App,\n  TAbstractFile\n} from 'obsidian';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { TFolder } from 'obsidian';\n\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\nconst STATE_KEY = 'caseInsensitiveFileIndex';\n\n/**\n * An O(1) case-insensitive index of the loaded files and folders of a single vault.\n *\n * The index maps the lowercased path of each abstract file to the abstract file itself. It is kept\n * in sync by an owning component that forwards `create`/`delete`/`rename` vault events.\n */\nexport class CaseInsensitiveFileIndex {\n  private readonly map = new Map<string, TAbstractFile>();\n\n  /**\n   * Creates a new case-insensitive file index.\n   *\n   * @param app - The Obsidian application instance whose vault this index mirrors.\n   */\n  public constructor(protected readonly app: App) {}\n\n  /**\n   * Adds an abstract file to the index.\n   *\n   * @param abstractFile - The abstract file to add.\n   */\n  public add(abstractFile: TAbstractFile): void {\n    this.map.set(abstractFile.path.toLowerCase(), abstractFile);\n  }\n\n  /**\n   * Removes the abstract file at the given path from the index, along with all of its descendants\n   * (for folder deletions, where Obsidian removes the whole subtree).\n   *\n   * @param path - The path of the abstract file to remove.\n   */\n  public delete(path: string): void {\n    const key = path.toLowerCase();\n    const abstractFile = this.map.get(key);\n    this.map.delete(key);\n    // Only a folder has descendants; scanning the whole index for a file's made every delete O(vault).\n    if (abstractFile && !(abstractFile instanceof TFolder)) {\n      return;\n    }\n    const descendantPrefix = `${key}/`;\n    for (const existingKey of snapshot(this.map.keys())) {\n      if (existingKey.startsWith(descendantPrefix)) {\n        this.map.delete(existingKey);\n      }\n    }\n  }\n\n  /**\n   * Resolves an abstract file by its path, case-insensitively, in O(1).\n   *\n   * @param path - The path to resolve.\n   * @returns The abstract file if found, otherwise `null`.\n   */\n  public get(path: string): null | TAbstractFile {\n    return this.map.get(path.toLowerCase()) ?? null;\n  }\n\n  /**\n   * Checks whether this index mirrors the given application's vault.\n   *\n   * @param app - The application instance to check against.\n   * @returns `true` if this index belongs to the given application, `false` otherwise.\n   */\n  public ownsApp(app: App): boolean {\n    return this.app === app;\n  }\n\n  /**\n   * Re-keys an abstract file (and, for folders, all of its descendants) after a rename.\n   *\n   * Obsidian fires a single `rename` event for the renamed abstract file and updates its\n   * descendants' paths in place without firing per-descendant events, so descendant keys are\n   * recomputed here by swapping the old path prefix for the new one. Handles case-only renames (the\n   * old and new keys coincide).\n   *\n   * @param oldPath - The path the abstract file had before the rename.\n   * @param newAbstractFile - The abstract file with its updated (post-rename) path.\n   */\n  public rename(oldPath: string, newAbstractFile: TAbstractFile): void {\n    const oldKey = oldPath.toLowerCase();\n    const newKey = newAbstractFile.path.toLowerCase();\n    this.map.delete(oldKey);\n    this.map.set(newKey, newAbstractFile);\n    // Only a folder has descendants; scanning the whole index for a file's made every rename O(vault).\n    if (!(newAbstractFile instanceof TFolder)) {\n      return;\n    }\n\n    const oldDescendantPrefix = `${oldKey}/`;\n    const newDescendantPrefix = `${newKey}/`;\n    for (const [existingKey, existingValue] of snapshot(this.map)) {\n      if (!existingKey.startsWith(oldDescendantPrefix)) {\n        continue;\n      }\n\n      this.map.delete(existingKey);\n      this.map.set(newDescendantPrefix + existingKey.slice(oldDescendantPrefix.length), existingValue);\n    }\n  }\n}\n\n/**\n * Retrieves the installed case-insensitive file index for the given application, if any.\n *\n * @param app - The application instance whose index to retrieve.\n * @returns The index if one is installed for this application, otherwise `null`.\n */\nexport function getCaseInsensitiveFileIndex(app: App): CaseInsensitiveFileIndex | null {\n  const index = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value;\n  return index?.ownsApp(app) ? index : null;\n}\n\n/**\n * Installs a case-insensitive file index as the active resolver.\n *\n * @param index - The index to install.\n */\nexport function setCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null).value = index;\n}\n\n/**\n * Uninstalls a case-insensitive file index, but only if it is the currently-installed one.\n *\n * @param index - The index to uninstall.\n */\nexport function unsetCaseInsensitiveFileIndex(index: CaseInsensitiveFileIndex): void {\n  const wrapper = getObsidianLibState<CaseInsensitiveFileIndex | null>(STATE_KEY, null);\n  if (wrapper.value === index) {\n    wrapper.value = null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAS,gBAAgB;AACzB,SAAS,eAAe;AAExB,SAAS,2BAA2B;AAEpC,MAAM,YAAY;AAQX,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ7B,YAA+B,KAAU;AAAV;AAAA,EAAW;AAAA,EAAX;AAAA,EAPrB,MAAM,oBAAI,IAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAc/C,IAAI,cAAmC;AAC5C,SAAK,IAAI,IAAI,aAAa,KAAK,YAAY,GAAG,YAAY;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,OAAO,MAAoB;AAChC,UAAM,MAAM,KAAK,YAAY;AAC7B,UAAM,eAAe,KAAK,IAAI,IAAI,GAAG;AACrC,SAAK,IAAI,OAAO,GAAG;AAEnB,QAAI,gBAAgB,EAAE,wBAAwB,UAAU;AACtD;AAAA,IACF;AACA,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,eAAe,SAAS,KAAK,IAAI,KAAK,CAAC,GAAG;AACnD,UAAI,YAAY,WAAW,gBAAgB,GAAG;AAC5C,aAAK,IAAI,OAAO,WAAW;AAAA,MAC7B;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,IAAI,MAAoC;AAC7C,WAAO,KAAK,IAAI,IAAI,KAAK,YAAY,CAAC,KAAK;AAAA,EAC7C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,QAAQ,KAAmB;AAChC,WAAO,KAAK,QAAQ;AAAA,EACtB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaO,OAAO,SAAiB,iBAAsC;AACnE,UAAM,SAAS,QAAQ,YAAY;AACnC,UAAM,SAAS,gBAAgB,KAAK,YAAY;AAChD,SAAK,IAAI,OAAO,MAAM;AACtB,SAAK,IAAI,IAAI,QAAQ,eAAe;AAEpC,QAAI,EAAE,2BAA2B,UAAU;AACzC;AAAA,IACF;AAEA,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,KAAK,SAAS,KAAK,GAAG,GAAG;AAC7D,UAAI,CAAC,YAAY,WAAW,mBAAmB,GAAG;AAChD;AAAA,MACF;AAEA,WAAK,IAAI,OAAO,WAAW;AAC3B,WAAK,IAAI,IAAI,sBAAsB,YAAY,MAAM,oBAAoB,MAAM,GAAG,aAAa;AAAA,IACjG;AAAA,EACF;AACF;AAQO,SAAS,4BAA4B,KAA2C;AACrF,QAAM,QAAQ,oBAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,sBAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,UAAU,oBAAqD,WAAW,IAAI;AACpF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;","names":[]}

package/dist/lib/esm/codemirror/incremental-parse-state-field.d.mts

@@ -0,0 +1,37 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * A {@link StateField} holding a Lezer syntax tree of the whole document, parsed again incrementally on every change.
+ *
+ * Each change maps the previous parse's {@link TreeFragment}s through the changed ranges and hands them to the
+ * parser, which reuses every fragment the change did not touch. The parse is synchronous and runs to the end of
+ * the document, so it suits a grammar a plugin owns (a markup extension, a small DSL) rather than a full language
+ * on a large document, where `@codemirror/language`'s time-sliced parser is the better tool.
+ *
+ * `@lezer/common` is in the module map Obsidian hands to plugins, so this costs a consuming plugin no bundle.
+ */
+import type { Parser, Tree } from '@lezer/common';
+import { StateField } from '@codemirror/state';
+import { TreeFragment } from '@lezer/common';
+/**
+ * The value of an incremental parse state field.
+ */
+export interface IncrementalParse {
+    /**
+     * The fragments of {@link IncrementalParse.tree} that the next parse may reuse.
+     */
+    readonly fragments: readonly TreeFragment[];
+    /**
+     * The syntax tree of the whole document.
+     */
+    readonly tree: Tree;
+}
+/**
+ * Creates a state field that parses the document with the given parser when the state is created, and parses it again
+ * incrementally on every document change, reusing the fragments the change left intact.
+ *
+ * @param parser - The Lezer parser to parse the document with.
+ * @returns The state field. Add it to the editor's extensions and read it with `state.field(field).tree`.
+ */
+export declare function createIncrementalParseStateField(parser: Parser): StateField<IncrementalParse>;

package/dist/lib/esm/codemirror/incremental-parse-state-field.mjs

@@ -0,0 +1,74 @@
+/*
+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"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { StateField } from "@codemirror/state";
+import { TreeFragment } from "@lezer/common";
+function createIncrementalParseStateField(parser) {
+  return StateField.define({
+    create(state) {
+      const tree = parser.parse(createTextInput(state.doc));
+      return { fragments: TreeFragment.addTree(tree), tree };
+    },
+    update(value, transaction) {
+      if (!transaction.docChanged) {
+        return value;
+      }
+      const changedRanges = [];
+      transaction.changes.iterChangedRanges((fromA, toA, fromB, toB) => {
+        changedRanges.push({ fromA, fromB, toA, toB });
+      });
+      const reusableFragments = TreeFragment.applyChanges(value.fragments, changedRanges);
+      const tree = parser.parse(createTextInput(transaction.newDoc), reusableFragments);
+      return { fragments: TreeFragment.addTree(tree, reusableFragments), tree };
+    }
+  });
+}
+function createTextInput(text) {
+  return {
+    chunk(from) {
+      const line = text.lineAt(from);
+      if (from < line.to) {
+        return text.sliceString(from, line.to);
+      }
+      return line.number < text.lines ? "\n" : "";
+    },
+    length: text.length,
+    lineChunks: true,
+    read(from, to) {
+      return text.sliceString(from, to);
+    }
+  };
+}
+export {
+  createIncrementalParseStateField
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,2 +1,5 @@
 /// <reference path="../library-references.d.mts" />
+export * as 'incremental-parse-state-field' from './incremental-parse-state-field.mjs';
+export * as 'markdown-editor-views' from './markdown-editor-views.mjs';
+export * as 'range-set' from './range-set.mjs';
 export * as 'state-field-spec' from './state-field-spec.mjs';

package/dist/lib/esm/codemirror/index.mjs

@@ -3,8 +3,14 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import * as incremental_parse_state_field from "./incremental-parse-state-field.mjs";
+import * as markdown_editor_views from "./markdown-editor-views.mjs";
+import * as range_set from "./range-set.mjs";
 import * as state_field_spec from "./state-field-spec.mjs";
 export {
+  incremental_parse_state_field as "incremental-parse-state-field",
+  markdown_editor_views as "markdown-editor-views",
+  range_set as "range-set",
   state_field_spec as "state-field-spec"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvZGVtaXJyb3IvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnc3RhdGUtZmllbGQtc3BlYycgZnJvbSAnLi9zdGF0ZS1maWVsZC1zcGVjLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWUEsc0JBQXdCOyIsCiAgIm5hbWVzIjogWyJzdGF0ZS1maWVsZC1zcGVjIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvZGVtaXJyb3IvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQnIGZyb20gJy4vaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQudHMnO1xuZXhwb3J0ICogYXMgJ21hcmtkb3duLWVkaXRvci12aWV3cycgZnJvbSAnLi9tYXJrZG93bi1lZGl0b3Itdmlld3MudHMnO1xuZXhwb3J0ICogYXMgJ3JhbmdlLXNldCcgZnJvbSAnLi9yYW5nZS1zZXQudHMnO1xuZXhwb3J0ICogYXMgJ3N0YXRlLWZpZWxkLXNwZWMnIGZyb20gJy4vc3RhdGUtZmllbGQtc3BlYy50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVlBLG1DQUFxQztBQUNqRCxZQUFZQywyQkFBNkI7QUFDekMsWUFBWUMsZUFBaUI7QUFDN0IsWUFBWUMsc0JBQXdCOyIsCiAgIm5hbWVzIjogWyJpbmNyZW1lbnRhbC1wYXJzZS1zdGF0ZS1maWVsZCIsICJtYXJrZG93bi1lZGl0b3Itdmlld3MiLCAicmFuZ2Utc2V0IiwgInN0YXRlLWZpZWxkLXNwZWMiXQp9Cg==

package/dist/lib/esm/codemirror/markdown-editor-views.d.mts

@@ -0,0 +1,34 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Reaches the CodeMirror {@link EditorView} of every open Markdown view, in every window.
+ *
+ * A Markdown view in Reading mode is included on purpose: it keeps its source editor alive while hidden, and a
+ * reconfigure or state change that skipped it would leave that editor stale when the user switches back.
+ *
+ * Only editors that live in a workspace leaf are reached. An editor Obsidian builds elsewhere (a canvas card, an
+ * editable embed, a hover popover) has no leaf, so it picks up registered extensions when it is created rather
+ * than through these helpers.
+ */
+import type { TransactionSpec } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+import type { App } from 'obsidian';
+/**
+ * Dispatches the given transaction specs to the editor of every open Markdown view, in every window.
+ *
+ * Each editor receives its own transaction built from the same specs, so a spec must not carry positions that
+ * only make sense in one document. Annotations and state effects (such as a compartment reconfigure) are the
+ * intended payload.
+ *
+ * @param app - The Obsidian app instance.
+ * @param specs - The transaction specs to dispatch to every editor.
+ */
+export declare function dispatchToAllMarkdownEditorViews(app: App, ...specs: TransactionSpec[]): void;
+/**
+ * Gets the editor of every open Markdown view, in every window, Reading mode included.
+ *
+ * @param app - The Obsidian app instance.
+ * @returns The CodeMirror editor views.
+ */
+export declare function getAllMarkdownEditorViews(app: App): EditorView[];

package/dist/lib/esm/codemirror/markdown-editor-views.mjs

@@ -0,0 +1,53 @@
+/*
+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"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ViewType } from "@obsidian-typings/obsidian-public-latest/implementations";
+import { MarkdownView } from "obsidian";
+function dispatchToAllMarkdownEditorViews(app, ...specs) {
+  for (const editorView of getAllMarkdownEditorViews(app)) {
+    editorView.dispatch(...specs);
+  }
+}
+function getAllMarkdownEditorViews(app) {
+  const editorViews = [];
+  for (const leaf of app.workspace.getLeavesOfType(ViewType.Markdown)) {
+    if (leaf.view instanceof MarkdownView) {
+      editorViews.push(leaf.view.editor.cm);
+    }
+  }
+  return editorViews;
+}
+export {
+  dispatchToAllMarkdownEditorViews,
+  getAllMarkdownEditorViews
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/codemirror/range-set.d.mts

@@ -0,0 +1,35 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Helpers for CodeMirror {@link RangeSet}s.
+ */
+import type { RangeSet, RangeValue } from '@codemirror/state';
+/**
+ * One range of a {@link RangeSet}, as plain data.
+ *
+ * @typeParam Value - The type of the range value.
+ */
+export interface RangeSetEntry<Value extends RangeValue> {
+    /**
+     * The start of the range.
+     */
+    readonly from: number;
+    /**
+     * The end of the range.
+     */
+    readonly to: number;
+    /**
+     * The value of the range.
+     */
+    readonly value: Value;
+}
+/**
+ * Lists the ranges of a {@link RangeSet} in document order, for assertions in tests and for debugging.
+ *
+ * @typeParam Value - The type of the range values.
+ * @param rangeSet - The range set to list, e.g. a `DecorationSet`.
+ * @param from - The position to start listing from. Ranges ending before it are skipped. Defaults to `0`.
+ * @returns The ranges as plain `{ from, to, value }` objects.
+ */
+export declare function rangeSetToArray<Value extends RangeValue>(rangeSet: RangeSet<Value>, from?: number): RangeSetEntry<Value>[];

package/dist/lib/esm/codemirror/range-set.mjs

@@ -0,0 +1,18 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function rangeSetToArray(rangeSet, from = 0) {
+  const entries = [];
+  const cursor = rangeSet.iter(from);
+  while (cursor.value !== null) {
+    entries.push({ from: cursor.from, to: cursor.to, value: cursor.value });
+    cursor.next();
+  }
+  return entries;
+}
+export {
+  rangeSetToArray
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvZGVtaXJyb3IvcmFuZ2Utc2V0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogSGVscGVycyBmb3IgQ29kZU1pcnJvciB7QGxpbmsgUmFuZ2VTZXR9cy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIFJhbmdlU2V0LFxuICBSYW5nZVZhbHVlXG59IGZyb20gJ0Bjb2RlbWlycm9yL3N0YXRlJztcblxuLyoqXG4gKiBPbmUgcmFuZ2Ugb2YgYSB7QGxpbmsgUmFuZ2VTZXR9LCBhcyBwbGFpbiBkYXRhLlxuICpcbiAqIEB0eXBlUGFyYW0gVmFsdWUgLSBUaGUgdHlwZSBvZiB0aGUgcmFuZ2UgdmFsdWUuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmFuZ2VTZXRFbnRyeTxWYWx1ZSBleHRlbmRzIFJhbmdlVmFsdWU+IHtcbiAgLyoqXG4gICAqIFRoZSBzdGFydCBvZiB0aGUgcmFuZ2UuXG4gICAqL1xuICByZWFkb25seSBmcm9tOiBudW1iZXI7XG5cbiAgLyoqXG4gICAqIFRoZSBlbmQgb2YgdGhlIHJhbmdlLlxuICAgKi9cbiAgcmVhZG9ubHkgdG86IG51bWJlcjtcblxuICAvKipcbiAgICogVGhlIHZhbHVlIG9mIHRoZSByYW5nZS5cbiAgICovXG4gIHJlYWRvbmx5IHZhbHVlOiBWYWx1ZTtcbn1cblxuLyoqXG4gKiBMaXN0cyB0aGUgcmFuZ2VzIG9mIGEge0BsaW5rIFJhbmdlU2V0fSBpbiBkb2N1bWVudCBvcmRlciwgZm9yIGFzc2VydGlvbnMgaW4gdGVzdHMgYW5kIGZvciBkZWJ1Z2dpbmcuXG4gKlxuICogQHR5cGVQYXJhbSBWYWx1ZSAtIFRoZSB0eXBlIG9mIHRoZSByYW5nZSB2YWx1ZXMuXG4gKiBAcGFyYW0gcmFuZ2VTZXQgLSBUaGUgcmFuZ2Ugc2V0IHRvIGxpc3QsIGUuZy4gYSBgRGVjb3JhdGlvblNldGAuXG4gKiBAcGFyYW0gZnJvbSAtIFRoZSBwb3NpdGlvbiB0byBzdGFydCBsaXN0aW5nIGZyb20uIFJhbmdlcyBlbmRpbmcgYmVmb3JlIGl0IGFyZSBza2lwcGVkLiBEZWZhdWx0cyB0byBgMGAuXG4gKiBAcmV0dXJucyBUaGUgcmFuZ2VzIGFzIHBsYWluIGB7IGZyb20sIHRvLCB2YWx1ZSB9YCBvYmplY3RzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcmFuZ2VTZXRUb0FycmF5PFZhbHVlIGV4dGVuZHMgUmFuZ2VWYWx1ZT4ocmFuZ2VTZXQ6IFJhbmdlU2V0PFZhbHVlPiwgZnJvbSA9IDApOiBSYW5nZVNldEVudHJ5PFZhbHVlPltdIHtcbiAgY29uc3QgZW50cmllczogUmFuZ2VTZXRFbnRyeTxWYWx1ZT5bXSA9IFtdO1xuICBjb25zdCBjdXJzb3IgPSByYW5nZVNldC5pdGVyKGZyb20pO1xuICB3aGlsZSAoY3Vyc29yLnZhbHVlICE9PSBudWxsKSB7XG4gICAgZW50cmllcy5wdXNoKHsgZnJvbTogY3Vyc29yLmZyb20sIHRvOiBjdXJzb3IudG8sIHZhbHVlOiBjdXJzb3IudmFsdWUgfSk7XG4gICAgY3Vyc29yLm5leHQoKTtcbiAgfVxuICByZXR1cm4gZW50cmllcztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBeUNPLFNBQVMsZ0JBQTBDLFVBQTJCLE9BQU8sR0FBMkI7QUFDckgsUUFBTSxVQUFrQyxDQUFDO0FBQ3pDLFFBQU0sU0FBUyxTQUFTLEtBQUssSUFBSTtBQUNqQyxTQUFPLE9BQU8sVUFBVSxNQUFNO0FBQzVCLFlBQVEsS0FBSyxFQUFFLE1BQU0sT0FBTyxNQUFNLElBQUksT0FBTyxJQUFJLE9BQU8sT0FBTyxNQUFNLENBQUM7QUFDdEUsV0FBTyxLQUFLO0FBQUEsRUFDZDtBQUNBLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/command-handlers/index.d.mts

@@ -6,6 +6,7 @@ export * as 'editor-command-handler' from './editor-command-handler.mjs';
 export * as 'file-command-handler' from './file-command-handler.mjs';
 export * as 'folder-command-handler' from './folder-command-handler.mjs';
 export * as 'global-command-handler' from './global-command-handler.mjs';
+export * as 'open-bug-report-command-handler' from './open-bug-report-command-handler.mjs';
 export * as 'open-demo-vault-command-handler' from './open-demo-vault-command-handler.mjs';
 export * as 'open-settings-command-handler' from './open-settings-command-handler.mjs';
 export * as 'undo-bulk-operation-command-handler' from './undo-bulk-operation-command-handler.mjs';