@mnaoumov/obsidian-lib 10.4.1 → 10.5.1

package/dist/lib/cjs/bug-report.cjs

@@ -0,0 +1,241 @@
+/*
+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();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault($module) {
+    return $module && $module.__esModule && "default" in $module ? $module.default : $module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        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);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bug_report_exports = {};
+__export(bug_report_exports, {
+  BUG_REPORT_ISSUE_FORM_TEMPLATE: () => BUG_REPORT_ISSUE_FORM_TEMPLATE,
+  BugReportIssueFormFieldId: () => BugReportIssueFormFieldId,
+  formatBugReportEnvironment: () => formatBugReportEnvironment,
+  getBugReportEnvironment: () => getBugReportEnvironment,
+  getBugReportIssueFormUrl: () => getBugReportIssueFormUrl,
+  getGitHubIssueFormUrl: () => getGitHubIssueFormUrl
+});
+module.exports = __toCommonJS(bug_report_exports);
+var import_obsidian = require('obsidian');
+var import_mobile_app_info = require('./mobile-app-info.cjs');
+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: import_obsidian.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 (import_obsidian.Platform.isMobileApp) {
+    const mobileAppInfo = await (0, import_mobile_app_info.getMobileAppInfo)();
+    return {
+      installerVersion: mobileAppInfo?.installerVersion ?? UNKNOWN,
+      operatingSystem: mobileAppInfo?.operatingSystem ?? UNKNOWN
+    };
+  }
+  if (!import_obsidian.Platform.isDesktopApp) {
+    return { installerVersion: UNKNOWN, operatingSystem: UNKNOWN };
+  }
+  const { getDesktopOperatingSystem } = await import("./desktop-operating-system.cjs");
+  const build = import_obsidian.Platform.build;
+  return {
+    installerVersion: typeof build === "string" ? build : UNKNOWN,
+    operatingSystem: getDesktopOperatingSystem()
+  };
+}
+function getPlatformName() {
+  if (import_obsidian.Platform.isAndroidApp) {
+    return "Android";
+  }
+  if (import_obsidian.Platform.isIosApp) {
+    return "iOS";
+  }
+  if (import_obsidian.Platform.isMacOS) {
+    return "macOS";
+  }
+  if (import_obsidian.Platform.isWin) {
+    return "Windows";
+  }
+  return import_obsidian.Platform.isLinux ? "Linux" : UNKNOWN;
+}
+function getPluginInfo(app, pluginId) {
+  return {
+    id: pluginId,
+    version: app.plugins.manifests[pluginId]?.version ?? null
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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":"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","names":["BugReportIssueFormFieldId"]}

package/dist/lib/cjs/bug-report.d.cts

@@ -0,0 +1,161 @@
+/// <reference path="./library-references.d.cts" />
+/**
+ * @file
+ *
+ * Helpers for a plugin's bug reports: the environment a report needs, and a link to a GitHub issue form
+ * prefilled with it.
+ *
+ * Cross-platform-loadable: the desktop operating-system lookup reads `node:os`, so it is imported
+ * dynamically, on desktop only.
+ *
+ * The desktop installer version is `Platform.build`, which no public typing declares: Obsidian's desktop
+ * startup sets it from Electron's `app.getVersion()` (read from Obsidian `1.15.0`), so it is read
+ * structurally here, and reads as `unknown` if a later version drops it.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * The ids of the bug-report issue form's fields that {@link getBugReportIssueFormUrl} prefills. GitHub
+ * prefills a field from a query parameter named after the field's `id`, so a form must give its fields
+ * these ids for them to be filled.
+ */
+export declare enum BugReportIssueFormFieldId {
+    /**
+     * The whole environment, as {@link formatBugReportEnvironment} renders it.
+     */
+    Environment = "environment",
+    /**
+     * The Obsidian version.
+     */
+    ObsidianVersion = "obsidian-version",
+    /**
+     * The operating system.
+     */
+    OperatingSystem = "operating-system",
+    /**
+     * The reporting plugin's version.
+     */
+    PluginVersion = "plugin-version"
+}
+/**
+ * The file name of the bug-report issue form, under `.github/ISSUE_TEMPLATE`.
+ */
+export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
+/**
+ * The environment a bug report needs.
+ */
+export interface BugReportEnvironment {
+    /**
+     * The other enabled plugins, sorted by id.
+     */
+    readonly enabledPlugins: readonly BugReportPluginInfo[];
+    /**
+     * The installed app's version, which can lag behind {@link obsidianVersion}.
+     */
+    readonly installerVersion: string;
+    /**
+     * The Obsidian version.
+     */
+    readonly obsidianVersion: string;
+    /**
+     * The operating system's name and version.
+     */
+    readonly operatingSystem: string;
+    /**
+     * The platform: `Android`, `iOS`, `macOS`, `Windows`, `Linux` or `unknown`.
+     */
+    readonly platform: string;
+    /**
+     * The reporting plugin.
+     */
+    readonly plugin: BugReportPluginInfo;
+}
+/**
+ * A plugin, as a bug report names it.
+ */
+export interface BugReportPluginInfo {
+    /**
+     * The plugin's id.
+     */
+    readonly id: string;
+    /**
+     * The plugin's installed version, or `null` when its manifest is not known.
+     */
+    readonly version: null | string;
+}
+/**
+ * Parameters for {@link getBugReportEnvironment}.
+ */
+export interface GetBugReportEnvironmentParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The id of the reporting plugin.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Parameters for {@link getBugReportIssueFormUrl}.
+ */
+export interface GetBugReportIssueFormUrlParams extends GetBugReportEnvironmentParams {
+    /**
+     * The plugin's GitHub repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The issue's title. Leave it out to keep the form's own default title.
+     */
+    readonly title?: string;
+}
+/**
+ * Parameters for {@link getGitHubIssueFormUrl}.
+ */
+export interface GetGitHubIssueFormUrlParams {
+    /**
+     * The values to prefill, keyed by field `id`.
+     */
+    readonly fields?: Readonly<Record<string, string>>;
+    /**
+     * The GitHub repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+    /**
+     * The form's file name, under `.github/ISSUE_TEMPLATE`.
+     */
+    readonly template: string;
+    /**
+     * The issue's title. Leave it out to keep the form's own default title.
+     */
+    readonly title?: string;
+}
+/**
+ * Renders a bug report's environment as a Markdown list.
+ *
+ * @param environment - The environment.
+ * @returns The Markdown.
+ */
+export declare function formatBugReportEnvironment(environment: BugReportEnvironment): string;
+/**
+ * Gets the environment a bug report needs: the plugin's version, the other enabled plugins, the
+ * Obsidian and installer versions, the platform and the operating system.
+ *
+ * @param params - The parameters.
+ * @returns The environment.
+ */
+export declare function getBugReportEnvironment(params: GetBugReportEnvironmentParams): Promise<BugReportEnvironment>;
+/**
+ * Gets a link to a plugin's bug-report issue form ({@link BUG_REPORT_ISSUE_FORM_TEMPLATE}), prefilled with
+ * the environment, in the fields {@link BugReportIssueFormFieldId} names.
+ *
+ * @param params - The parameters.
+ * @returns The link.
+ */
+export declare function getBugReportIssueFormUrl(params: GetBugReportIssueFormUrlParams): Promise<string>;
+/**
+ * Gets a link that opens a GitHub issue form with fields prefilled.
+ *
+ * @param params - The parameters.
+ * @returns The link.
+ */
+export declare function getGitHubIssueFormUrl(params: GetGitHubIssueFormUrlParams): string;

package/dist/lib/cjs/bulk-operation-progress.cjs

@@ -87,12 +87,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var bulk_operation_progress_exports = {};
 __export(bulk_operation_progress_exports, {
+  BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS: () => BULK_OPERATION_HOLD_INTERVAL_IN_MILLISECONDS,
+  holdBulkOperationWhile: () => holdBulkOperationWhile,
   registerBulkOperationProgressListener: () => registerBulkOperationProgressListener,
   reportBulkOperationProgress: () => reportBulkOperationProgress
 });
 module.exports = __toCommonJS(bulk_operation_progress_exports);
 var import_obsidian_lib_state = require('./obsidian-lib-state.cjs');
 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);
@@ -114,7 +127,9 @@ function getListeners() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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/cjs/bulk-operation-progress.d.cts

@@ -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/cjs/case-insensitive-file-index.cjs

@@ -121,6 +121,7 @@ __export(case_insensitive_file_index_exports, {
 });
 module.exports = __toCommonJS(case_insensitive_file_index_exports);
 var import_array = require('@mnaoumov/typescript-lib/array');
+var import_obsidian = require('obsidian');
 var import_obsidian_lib_state = require('./obsidian-lib-state.cjs');
 const STATE_KEY = "caseInsensitiveFileIndex";
 class CaseInsensitiveFileIndex {
@@ -150,7 +151,11 @@ class CaseInsensitiveFileIndex {
    */
   delete(path) {
     const key = path.toLowerCase();
+    const abstractFile = this.map.get(key);
     this.map.delete(key);
+    if (abstractFile && !(abstractFile instanceof import_obsidian.TFolder)) {
+      return;
+    }
     const descendantPrefix = `${key}/`;
     for (const existingKey of (0, import_array.snapshot)(this.map.keys())) {
       if (existingKey.startsWith(descendantPrefix)) {
@@ -192,6 +197,9 @@ class CaseInsensitiveFileIndex {
     const newKey = newAbstractFile.path.toLowerCase();
     this.map.delete(oldKey);
     this.map.set(newKey, newAbstractFile);
+    if (!(newAbstractFile instanceof import_obsidian.TFolder)) {
+      return;
+    }
     const oldDescendantPrefix = `${oldKey}/`;
     const newDescendantPrefix = `${newKey}/`;
     for (const [existingKey, existingValue] of (0, import_array.snapshot)(this.map)) {
@@ -223,4 +231,4 @@ function unsetCaseInsensitiveFileIndex(index) {
   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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,mBAAyB;AAEzB,gCAAoC;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,mBAAe,uBAAS,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,SAAK,uBAAS,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,YAAQ,+CAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,qDAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,cAAU,+CAAqD,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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,mBAAyB;AACzB,sBAAwB;AAExB,gCAAoC;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,0BAAU;AACtD;AAAA,IACF;AACA,UAAM,mBAAmB,GAAG,GAAG;AAC/B,eAAW,mBAAe,uBAAS,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,0BAAU;AACzC;AAAA,IACF;AAEA,UAAM,sBAAsB,GAAG,MAAM;AACrC,UAAM,sBAAsB,GAAG,MAAM;AACrC,eAAW,CAAC,aAAa,aAAa,SAAK,uBAAS,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,YAAQ,+CAAqD,WAAW,IAAI,EAAE;AACpF,SAAO,OAAO,QAAQ,GAAG,IAAI,QAAQ;AACvC;AAOO,SAAS,4BAA4B,OAAuC;AACjF,qDAAqD,WAAW,IAAI,EAAE,QAAQ;AAChF;AAOO,SAAS,8BAA8B,OAAuC;AACnF,QAAM,cAAU,+CAAqD,WAAW,IAAI;AACpF,MAAI,QAAQ,UAAU,OAAO;AAC3B,YAAQ,QAAQ;AAAA,EAClB;AACF;","names":[]}