@mnaoumov/obsidian-lib 10.5.1 → 10.7.0

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

@@ -155,7 +155,9 @@ 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)),
+    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id
+    // whose folder was deleted, or whose load failed.
+    enabledPlugins: Object.keys(app.plugins.plugins).filter((id) => id !== pluginId).sort().map((id) => getPluginInfo(app, id)),
     installerVersion,
     obsidianVersion: import_obsidian.apiVersion,
     operatingSystem,
@@ -238,4 +240,4 @@ function getPluginInfo(app, pluginId) {
   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"]}
+//# 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 loaded 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    // The loaded plugins, as Obsidian's Show debug info lists them: `enabledPlugins` also holds an id\n    // whose folder was deleted, or whose load failed.\n    enabledPlugins: Object.keys(app.plugins.plugins)\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

@@ -45,7 +45,7 @@ export declare const BUG_REPORT_ISSUE_FORM_TEMPLATE = "bug_report.yml";
  */
 export interface BugReportEnvironment {
     /**
-     * The other enabled plugins, sorted by id.
+     * The other loaded plugins, sorted by id.
      */
     readonly enabledPlugins: readonly BugReportPluginInfo[];
     /**

package/dist/lib/cjs/code-block-render-handoff.cjs

@@ -0,0 +1,272 @@
+/*
+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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var code_block_render_handoff_exports = {};
+__export(code_block_render_handoff_exports, {
+  CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS: () => CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,
+  captureCodeBlockFocus: () => captureCodeBlockFocus,
+  claimCodeBlockRenderHandoff: () => claimCodeBlockRenderHandoff,
+  recordCodeBlockRenderHandoff: () => recordCodeBlockRenderHandoff,
+  restoreCodeBlockFocus: () => restoreCodeBlockFocus
+});
+module.exports = __toCommonJS(code_block_render_handoff_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_code_block_reg_exp = require('./code-block-reg-exp.cjs');
+var import_obsidian_lib_state = require('./obsidian-lib-state.cjs');
+const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 1e4;
+const HANDOFF_STATE_KEY = "codeBlockRenderHandoffV1";
+const MAX_FRAMES_TO_WAIT_FOR_CONNECTION = 60;
+function captureCodeBlockFocus(el) {
+  const activeElement = el.ownerDocument.activeElement;
+  if (!activeElement || activeElement === el || !el.contains(activeElement)) {
+    return null;
+  }
+  const childIndexPath = [];
+  let current = activeElement;
+  while (current && current !== el) {
+    let index = 0;
+    for (let sibling = current.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+      index++;
+    }
+    childIndexPath.unshift(index);
+    current = current.parentElement;
+  }
+  return {
+    childIndexPath,
+    selection: getTextSelection(activeElement)
+  };
+}
+function claimCodeBlockRenderHandoff(params) {
+  const { context, el, source } = params;
+  const entries = getHandoffEntries();
+  pruneExpiredEntries(entries);
+  const key = getHandoffKey(context.sourcePath, getLanguageFromElement(el), (0, import_string.ensureLfEndings)(source));
+  const queue = entries.get(key);
+  const entry = queue?.shift();
+  if (!queue || !entry) {
+    return null;
+  }
+  if (queue.length === 0) {
+    entries.delete(key);
+  }
+  return {
+    hasFocus: entry.focus !== null,
+    async restoreFocus() {
+      return entry.focus ? await restoreCodeBlockFocus(el, entry.focus) : false;
+    },
+    state: entry.state
+  };
+}
+function recordCodeBlockRenderHandoff(params) {
+  const { focus, newCodeBlock, sourcePath, state } = params;
+  const matches = [...(0, import_string.ensureLfEndings)(newCodeBlock).matchAll((0, import_code_block_reg_exp.createCodeBlockRegExp)())];
+  const match = matches[0];
+  if (matches.length !== 1 || !match) {
+    return false;
+  }
+  const linePrefix = (0, import_reg_exp.getMandatoryNamedGroup)(match, "LinePrefix");
+  const language = (0, import_reg_exp.getMandatoryNamedGroup)(match, "CodeBlockLanguage");
+  const content = ((0, import_reg_exp.getOptionalNamedGroup)(match, "CodeBlockContent") ?? "").split("\n").map((line) => line.slice(linePrefix.length)).join("\n");
+  const entries = getHandoffEntries();
+  pruneExpiredEntries(entries);
+  const key = getHandoffKey(sourcePath, language, content);
+  let queue = entries.get(key);
+  if (!queue) {
+    queue = [];
+    entries.set(key, queue);
+  }
+  queue.push({
+    expiresAt: Date.now() + CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,
+    focus,
+    state
+  });
+  return true;
+}
+async function restoreCodeBlockFocus(el, focus) {
+  for (let frame = 0; !el.isConnected && frame < MAX_FRAMES_TO_WAIT_FOR_CONNECTION; frame++) {
+    await (0, import_async.requestAnimationFrameAsync)();
+  }
+  if (!el.isConnected) {
+    return false;
+  }
+  let target = el;
+  for (const index of focus.childIndexPath) {
+    target = target.children[index];
+    if (!target) {
+      return false;
+    }
+  }
+  if (!isHTMLElementLike(target)) {
+    return false;
+  }
+  target.focus({ preventScroll: true });
+  if (el.ownerDocument.activeElement !== target) {
+    return false;
+  }
+  if (focus.selection && isTextSelectionElement(target)) {
+    target.setSelectionRange(focus.selection.start, focus.selection.end, focus.selection.direction);
+  }
+  return true;
+}
+function getHandoffEntries() {
+  return (0, import_obsidian_lib_state.getObsidianLibState)(HANDOFF_STATE_KEY, /* @__PURE__ */ new Map()).value;
+}
+function getHandoffKey(sourcePath, language, content) {
+  return JSON.stringify([sourcePath, language, content]);
+}
+function getLanguageFromElement(element) {
+  const BLOCK_LANGUAGE_PREFIX = "block-language-";
+  return [...element.classList].find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? "";
+}
+function getTextSelection(element) {
+  if (!isTextSelectionElement(element)) {
+    return null;
+  }
+  if (element.selectionStart === null || element.selectionEnd === null) {
+    return null;
+  }
+  return {
+    direction: element.selectionDirection ?? "none",
+    end: element.selectionEnd,
+    start: element.selectionStart
+  };
+}
+function isHTMLElementLike(element) {
+  return typeof element.focus === "function";
+}
+function isTextSelectionElement(element) {
+  return element.tagName === "INPUT" || element.tagName === "TEXTAREA";
+}
+function pruneExpiredEntries(entries) {
+  const now = Date.now();
+  for (const [key, queue] of entries) {
+    const liveEntries = queue.filter((entry) => entry.expiresAt > now);
+    if (liveEntries.length === 0) {
+      entries.delete(key);
+    } else if (liveEntries.length !== queue.length) {
+      entries.set(key, liveEntries);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,
+  captureCodeBlockFocus,
+  claimCodeBlockRenderHandoff,
+  recordCodeBlockRenderHandoff,
+  restoreCodeBlockFocus
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/code-block-render-handoff.ts"],"sourcesContent":["/**\n * @file\n *\n * Carries focus and plugin state from a code block to its next render.\n *\n * Obsidian renders a code block again whenever its source text changes: Reading view re-renders the section and Live\n * Preview replaces the widget. So a block that edits its own source (a counter, a checkbox, a settings form) loses the\n * element the user was interacting with, its focus and whatever the plugin kept on it. The element itself cannot be\n * kept without patching Obsidian's renderers, so the write records a handoff instead, and the processor rendering the\n * new source claims it: it gets back the state the write passed and can put the focus back on the same element.\n *\n * The handoff is matched by source path, language and the new block content, and it lives for\n * {@link CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS}. The first render to claim it consumes it, so when the\n * note is open in two panes only one of the new renders gets it.\n */\n\nimport type { MarkdownPostProcessorContext } from 'obsidian';\n\nimport { requestAnimationFrameAsync } from '@mnaoumov/typescript-lib/async';\nimport {\n  getMandatoryNamedGroup,\n  getOptionalNamedGroup\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { ensureLfEndings } from '@mnaoumov/typescript-lib/string';\n\nimport { createCodeBlockRegExp } from './code-block-reg-exp.ts';\nimport { getObsidianLibState } from './obsidian-lib-state.ts';\n\n/**\n * How long a recorded handoff waits for the render that claims it.\n */\nexport const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 10_000;\n\nconst HANDOFF_STATE_KEY = 'codeBlockRenderHandoffV1';\nconst MAX_FRAMES_TO_WAIT_FOR_CONNECTION = 60;\n\n/**\n * Options for {@link claimCodeBlockRenderHandoff}.\n */\nexport interface ClaimCodeBlockRenderHandoffParams {\n  /**\n   * The {@link MarkdownPostProcessorContext} the processor received.\n   */\n  readonly context: MarkdownPostProcessorContext;\n\n  /**\n   * The element the processor renders into.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The source the processor received.\n   */\n  readonly source: string;\n}\n\n/**\n * Where the focus was inside a rendered code block.\n */\nexport interface CodeBlockFocusSnapshot {\n  /**\n   * The child indices leading from the code block element to the focused element.\n   */\n  readonly childIndexPath: readonly number[];\n\n  /**\n   * The text selection of a focused input or text area.\n   */\n  readonly selection: null | TextSelection;\n}\n\n/**\n * A handoff claimed by the render of a code block whose source a write just changed.\n */\nexport interface CodeBlockRenderHandoff {\n  /**\n   * Whether the write recorded a focused element to restore.\n   */\n  readonly hasFocus: boolean;\n\n  /**\n   * Puts the focus back on the element at the same position inside the new render, with the same text selection.\n   *\n   * Call it once the processor has rendered the block. It waits for the element to be attached to a document.\n   *\n   * @returns Whether an element was focused.\n   */\n  readonly restoreFocus: () => Promise<boolean>;\n\n  /**\n   * The state passed to the write, or `undefined` when none was.\n   */\n  readonly state: unknown;\n}\n\n/**\n * Options for {@link recordCodeBlockRenderHandoff}.\n */\nexport interface RecordCodeBlockRenderHandoffParams {\n  /**\n   * The focus captured from the old render with {@link captureCodeBlockFocus}.\n   */\n  readonly focus: CodeBlockFocusSnapshot | null;\n\n  /**\n   * The code block written to the note, fences included.\n   */\n  readonly newCodeBlock: string;\n\n  /**\n   * The path of the note the code block is in.\n   */\n  readonly sourcePath: string;\n\n  /**\n   * The state to pass to the next render.\n   */\n  readonly state: unknown;\n}\n\ninterface HandoffEntry {\n  readonly expiresAt: number;\n  readonly focus: CodeBlockFocusSnapshot | null;\n  readonly state: unknown;\n}\n\ninterface TextSelection {\n  readonly direction: 'backward' | 'forward' | 'none';\n  readonly end: number;\n  readonly start: number;\n}\n\ninterface TextSelectionElement extends HTMLElement {\n  readonly selectionDirection: 'backward' | 'forward' | 'none' | null;\n  readonly selectionEnd: null | number;\n  readonly selectionStart: null | number;\n  readonly setSelectionRange: (start: number, end: number, direction?: 'backward' | 'forward' | 'none') => void;\n}\n\n/**\n * Captures where the focus is inside a rendered code block.\n *\n * @param el - The code block element.\n * @returns The snapshot, or `null` when the focus is not inside the element.\n */\nexport function captureCodeBlockFocus(el: HTMLElement): CodeBlockFocusSnapshot | null {\n  const activeElement = el.ownerDocument.activeElement;\n  if (!activeElement || activeElement === el || !el.contains(activeElement)) {\n    return null;\n  }\n\n  const childIndexPath: number[] = [];\n  let current: Element | null = activeElement;\n  while (current && current !== el) {\n    let index = 0;\n    for (let sibling = current.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {\n      index++;\n    }\n    childIndexPath.unshift(index);\n    current = current.parentElement;\n  }\n\n  return {\n    childIndexPath,\n    selection: getTextSelection(activeElement)\n  };\n}\n\n/**\n * Claims the handoff a write recorded for the code block being rendered.\n *\n * Call it from a code block processor. It returns `null` when no write is waiting for this render.\n *\n * @param params - The parameters for the function.\n * @returns The handoff, or `null`.\n */\nexport function claimCodeBlockRenderHandoff(params: ClaimCodeBlockRenderHandoffParams): CodeBlockRenderHandoff | null {\n  const { context, el, source } = params;\n  const entries = getHandoffEntries();\n  pruneExpiredEntries(entries);\n\n  const key = getHandoffKey(context.sourcePath, getLanguageFromElement(el), ensureLfEndings(source));\n  const queue = entries.get(key);\n  const entry = queue?.shift();\n  if (!queue || !entry) {\n    return null;\n  }\n\n  if (queue.length === 0) {\n    entries.delete(key);\n  }\n\n  return {\n    hasFocus: entry.focus !== null,\n    async restoreFocus(): Promise<boolean> {\n      return entry.focus ? (await restoreCodeBlockFocus(el, entry.focus)) : false;\n    },\n    state: entry.state\n  };\n}\n\n/**\n * Records a handoff for the next render of a code block a write is about to change.\n *\n * @param params - The parameters for the function.\n * @returns Whether a handoff was recorded: `false` when the new text is not exactly one code block.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- A verb names the action; the boolean only reports whether it took place.\nexport function recordCodeBlockRenderHandoff(params: RecordCodeBlockRenderHandoffParams): boolean {\n  const { focus, newCodeBlock, sourcePath, state } = params;\n  const matches = [...ensureLfEndings(newCodeBlock).matchAll(createCodeBlockRegExp())];\n  const match = matches[0];\n  if (matches.length !== 1 || !match) {\n    return false;\n  }\n\n  const linePrefix = getMandatoryNamedGroup(match, 'LinePrefix');\n  const language = getMandatoryNamedGroup(match, 'CodeBlockLanguage');\n  const content = (getOptionalNamedGroup(match, 'CodeBlockContent') ?? '').split('\\n').map((line) => line.slice(linePrefix.length)).join('\\n');\n\n  const entries = getHandoffEntries();\n  pruneExpiredEntries(entries);\n  const key = getHandoffKey(sourcePath, language, content);\n  let queue = entries.get(key);\n  if (!queue) {\n    queue = [];\n    entries.set(key, queue);\n  }\n  queue.push({\n    expiresAt: Date.now() + CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS,\n    focus,\n    state\n  });\n  return true;\n}\n\n/**\n * Puts the focus back on the element a {@link CodeBlockFocusSnapshot} describes.\n *\n * @param el - The new code block element.\n * @param focus - The snapshot captured from the old render.\n * @returns Whether an element was focused.\n */\n// eslint-disable-next-line unicorn/consistent-boolean-name -- A verb names the action; the boolean only reports whether it took place.\nexport async function restoreCodeBlockFocus(el: HTMLElement, focus: CodeBlockFocusSnapshot): Promise<boolean> {\n  for (let frame = 0; !el.isConnected && frame < MAX_FRAMES_TO_WAIT_FOR_CONNECTION; frame++) {\n    await requestAnimationFrameAsync();\n  }\n\n  if (!el.isConnected) {\n    return false;\n  }\n\n  let target: Element | undefined = el;\n  for (const index of focus.childIndexPath) {\n    target = target.children[index];\n    if (!target) {\n      return false;\n    }\n  }\n\n  if (!isHTMLElementLike(target)) {\n    return false;\n  }\n\n  target.focus({ preventScroll: true });\n  if (el.ownerDocument.activeElement !== target) {\n    return false;\n  }\n\n  if (focus.selection && isTextSelectionElement(target)) {\n    target.setSelectionRange(focus.selection.start, focus.selection.end, focus.selection.direction);\n  }\n\n  return true;\n}\n\nfunction getHandoffEntries(): Map<string, HandoffEntry[]> {\n  return getObsidianLibState(HANDOFF_STATE_KEY, new Map<string, HandoffEntry[]>()).value;\n}\n\nfunction getHandoffKey(sourcePath: string, language: string, content: string): string {\n  return JSON.stringify([sourcePath, language, content]);\n}\n\nfunction getLanguageFromElement(element: HTMLElement): string {\n  const BLOCK_LANGUAGE_PREFIX = 'block-language-';\n  return [...element.classList].find((cls) => cls.startsWith(BLOCK_LANGUAGE_PREFIX))?.slice(BLOCK_LANGUAGE_PREFIX.length) ?? '';\n}\n\nfunction getTextSelection(element: Element): null | TextSelection {\n  if (!isTextSelectionElement(element)) {\n    return null;\n  }\n\n  // An input type without a text selection (a checkbox, a number field) reads `null` here.\n  if (element.selectionStart === null || element.selectionEnd === null) {\n    return null;\n  }\n\n  return {\n    direction: element.selectionDirection ?? 'none',\n    end: element.selectionEnd,\n    start: element.selectionStart\n  };\n}\n\nfunction isHTMLElementLike(element: Element): element is HTMLElement {\n  return typeof (element as Partial<HTMLElement>).focus === 'function';\n}\n\nfunction isTextSelectionElement(element: Element): element is TextSelectionElement {\n  return element.tagName === 'INPUT' || element.tagName === 'TEXTAREA';\n}\n\nfunction pruneExpiredEntries(entries: Map<string, HandoffEntry[]>): void {\n  const now = Date.now();\n  for (const [key, queue] of entries) {\n    const liveEntries = queue.filter((entry) => entry.expiresAt > now);\n    if (liveEntries.length === 0) {\n      entries.delete(key);\n    } else if (liveEntries.length !== queue.length) {\n      entries.set(key, liveEntries);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/cjs/code-block-render-handoff.d.cts

@@ -0,0 +1,131 @@
+/// <reference path="./library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Carries focus and plugin state from a code block to its next render.
+ *
+ * Obsidian renders a code block again whenever its source text changes: Reading view re-renders the section and Live
+ * Preview replaces the widget. So a block that edits its own source (a counter, a checkbox, a settings form) loses the
+ * element the user was interacting with, its focus and whatever the plugin kept on it. The element itself cannot be
+ * kept without patching Obsidian's renderers, so the write records a handoff instead, and the processor rendering the
+ * new source claims it: it gets back the state the write passed and can put the focus back on the same element.
+ *
+ * The handoff is matched by source path, language and the new block content, and it lives for
+ * {@link CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS}. The first render to claim it consumes it, so when the
+ * note is open in two panes only one of the new renders gets it.
+ */
+import type { MarkdownPostProcessorContext } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * How long a recorded handoff waits for the render that claims it.
+ */
+export declare const CODE_BLOCK_RENDER_HANDOFF_LIFETIME_IN_MILLISECONDS = 10000;
+/**
+ * Options for {@link claimCodeBlockRenderHandoff}.
+ */
+export interface ClaimCodeBlockRenderHandoffParams {
+    /**
+     * The {@link MarkdownPostProcessorContext} the processor received.
+     */
+    readonly context: MarkdownPostProcessorContext;
+    /**
+     * The element the processor renders into.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The source the processor received.
+     */
+    readonly source: string;
+}
+/**
+ * Where the focus was inside a rendered code block.
+ */
+export interface CodeBlockFocusSnapshot {
+    /**
+     * The child indices leading from the code block element to the focused element.
+     */
+    readonly childIndexPath: readonly number[];
+    /**
+     * The text selection of a focused input or text area.
+     */
+    readonly selection: null | TextSelection;
+}
+/**
+ * A handoff claimed by the render of a code block whose source a write just changed.
+ */
+export interface CodeBlockRenderHandoff {
+    /**
+     * Whether the write recorded a focused element to restore.
+     */
+    readonly hasFocus: boolean;
+    /**
+     * Puts the focus back on the element at the same position inside the new render, with the same text selection.
+     *
+     * Call it once the processor has rendered the block. It waits for the element to be attached to a document.
+     *
+     * @returns Whether an element was focused.
+     */
+    readonly restoreFocus: () => Promise<boolean>;
+    /**
+     * The state passed to the write, or `undefined` when none was.
+     */
+    readonly state: unknown;
+}
+/**
+ * Options for {@link recordCodeBlockRenderHandoff}.
+ */
+export interface RecordCodeBlockRenderHandoffParams {
+    /**
+     * The focus captured from the old render with {@link captureCodeBlockFocus}.
+     */
+    readonly focus: CodeBlockFocusSnapshot | null;
+    /**
+     * The code block written to the note, fences included.
+     */
+    readonly newCodeBlock: string;
+    /**
+     * The path of the note the code block is in.
+     */
+    readonly sourcePath: string;
+    /**
+     * The state to pass to the next render.
+     */
+    readonly state: unknown;
+}
+interface TextSelection {
+    readonly direction: 'backward' | 'forward' | 'none';
+    readonly end: number;
+    readonly start: number;
+}
+/**
+ * Captures where the focus is inside a rendered code block.
+ *
+ * @param el - The code block element.
+ * @returns The snapshot, or `null` when the focus is not inside the element.
+ */
+export declare function captureCodeBlockFocus(el: HTMLElement): CodeBlockFocusSnapshot | null;
+/**
+ * Claims the handoff a write recorded for the code block being rendered.
+ *
+ * Call it from a code block processor. It returns `null` when no write is waiting for this render.
+ *
+ * @param params - The parameters for the function.
+ * @returns The handoff, or `null`.
+ */
+export declare function claimCodeBlockRenderHandoff(params: ClaimCodeBlockRenderHandoffParams): CodeBlockRenderHandoff | null;
+/**
+ * Records a handoff for the next render of a code block a write is about to change.
+ *
+ * @param params - The parameters for the function.
+ * @returns Whether a handoff was recorded: `false` when the new text is not exactly one code block.
+ */
+export declare function recordCodeBlockRenderHandoff(params: RecordCodeBlockRenderHandoffParams): boolean;
+/**
+ * Puts the focus back on the element a {@link CodeBlockFocusSnapshot} describes.
+ *
+ * @param el - The new code block element.
+ * @param focus - The snapshot captured from the old render.
+ * @returns Whether an element was focused.
+ */
+export declare function restoreCodeBlockFocus(el: HTMLElement, focus: CodeBlockFocusSnapshot): Promise<boolean>;
+export {};

package/dist/lib/cjs/codemirror/index.cjs

@@ -98,20 +98,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var codemirror_exports = {};
 __export(codemirror_exports, {
   "incremental-parse-state-field": () => incremental_parse_state_field,
+  "inline-token-widgets": () => inline_token_widgets,
   "markdown-editor-views": () => markdown_editor_views,
   "range-set": () => range_set,
+  "settings-facet": () => settings_facet,
   "state-field-spec": () => state_field_spec
 });
 module.exports = __toCommonJS(codemirror_exports);
 var incremental_parse_state_field = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./incremental-parse-state-field.cjs')), 1);
+var inline_token_widgets = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./inline-token-widgets.cjs')), 1);
 var markdown_editor_views = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./markdown-editor-views.cjs')), 1);
 var range_set = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./range-set.cjs')), 1);
+var settings_facet = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./settings-facet.cjs')), 1);
 var state_field_spec = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./state-field-spec.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "incremental-parse-state-field": null,
+  "inline-token-widgets": null,
   "markdown-editor-views": null,
   "range-set": null,
+  "settings-facet": null,
   "state-field-spec": null
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb2RlbWlycm9yL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQnIGZyb20gJy4vaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQudHMnO1xuZXhwb3J0ICogYXMgJ21hcmtkb3duLWVkaXRvci12aWV3cycgZnJvbSAnLi9tYXJrZG93bi1lZGl0b3Itdmlld3MudHMnO1xuZXhwb3J0ICogYXMgJ3JhbmdlLXNldCcgZnJvbSAnLi9yYW5nZS1zZXQudHMnO1xuZXhwb3J0ICogYXMgJ3N0YXRlLWZpZWxkLXNwZWMnIGZyb20gJy4vc3RhdGUtZmllbGQtc3BlYy50cyc7XG4iXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUEseUNBQUFBO0FBQUEsRUFBQSwrQkFBQUM7QUFBQSxFQUFBLG1CQUFBQztBQUFBLEVBQUEsMEJBQUFDO0FBQUE7QUFBQTtBQUVBLElBQUFILGdDQUFpRDtBQUNqRCxJQUFBQyx3QkFBeUM7QUFDekMsSUFBQUMsWUFBNkI7QUFDN0IsSUFBQUMsbUJBQW9DOyIsIm5hbWVzIjpbImluY3JlbWVudGFsLXBhcnNlLXN0YXRlLWZpZWxkIiwibWFya2Rvd24tZWRpdG9yLXZpZXdzIiwicmFuZ2Utc2V0Iiwic3RhdGUtZmllbGQtc3BlYyJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9jb2RlbWlycm9yL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQnIGZyb20gJy4vaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQudHMnO1xuZXhwb3J0ICogYXMgJ2lubGluZS10b2tlbi13aWRnZXRzJyBmcm9tICcuL2lubGluZS10b2tlbi13aWRnZXRzLnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bi1lZGl0b3Itdmlld3MnIGZyb20gJy4vbWFya2Rvd24tZWRpdG9yLXZpZXdzLnRzJztcbmV4cG9ydCAqIGFzICdyYW5nZS1zZXQnIGZyb20gJy4vcmFuZ2Utc2V0LnRzJztcbmV4cG9ydCAqIGFzICdzZXR0aW5ncy1mYWNldCcgZnJvbSAnLi9zZXR0aW5ncy1mYWNldC50cyc7XG5leHBvcnQgKiBhcyAnc3RhdGUtZmllbGQtc3BlYycgZnJvbSAnLi9zdGF0ZS1maWVsZC1zcGVjLnRzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQSx5Q0FBQUE7QUFBQSxFQUFBLDhCQUFBQztBQUFBLEVBQUEsK0JBQUFDO0FBQUEsRUFBQSxtQkFBQUM7QUFBQSxFQUFBLHdCQUFBQztBQUFBLEVBQUEsMEJBQUFDO0FBQUE7QUFBQTtBQUVBLElBQUFMLGdDQUFpRDtBQUNqRCxJQUFBQyx1QkFBd0M7QUFDeEMsSUFBQUMsd0JBQXlDO0FBQ3pDLElBQUFDLFlBQTZCO0FBQzdCLElBQUFDLGlCQUFrQztBQUNsQyxJQUFBQyxtQkFBb0M7IiwibmFtZXMiOlsiaW5jcmVtZW50YWwtcGFyc2Utc3RhdGUtZmllbGQiLCJpbmxpbmUtdG9rZW4td2lkZ2V0cyIsIm1hcmtkb3duLWVkaXRvci12aWV3cyIsInJhbmdlLXNldCIsInNldHRpbmdzLWZhY2V0Iiwic3RhdGUtZmllbGQtc3BlYyJdfQ==

package/dist/lib/cjs/codemirror/index.d.cts

@@ -1,5 +1,7 @@
 /// <reference path="../library-references.d.cts" />
 export * as 'incremental-parse-state-field' from './incremental-parse-state-field.cjs';
+export * as 'inline-token-widgets' from './inline-token-widgets.cjs';
 export * as 'markdown-editor-views' from './markdown-editor-views.cjs';
 export * as 'range-set' from './range-set.cjs';
+export * as 'settings-facet' from './settings-facet.cjs';
 export * as 'state-field-spec' from './state-field-spec.cjs';