obsidian-dev-utils 88.5.0 → 88.7.0

package/dist/lib/cjs/obsidian/components/index.cjs

@@ -154,7 +154,8 @@ __export(components_exports, {
   "plugin-settings-tab-component": () => plugin_settings_tab_component,
   "pointer-position-component": () => pointer_position_component,
   "registry-component": () => registry_component,
-  "rename-delete-handler-component": () => rename_delete_handler_component
+  "rename-delete-handler-component": () => rename_delete_handler_component,
+  "syntax-highlighting-component": () => syntax_highlighting_component
 });
 module.exports = __toCommonJS(components_exports);
 var abort_signal_component = __toESM(__extractDefault(require('./abort-signal-component.cjs')), 1);
@@ -177,6 +178,7 @@ var plugin_settings_tab_component = __toESM(__extractDefault(require('./plugin-s
 var pointer_position_component = __toESM(__extractDefault(require('./pointer-position-component.cjs')), 1);
 var registry_component = __toESM(__extractDefault(require('./registry-component.cjs')), 1);
 var rename_delete_handler_component = __toESM(__extractDefault(require('./rename-delete-handler-component.cjs')), 1);
+var syntax_highlighting_component = __toESM(__extractDefault(require('./syntax-highlighting-component.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   "abort-signal-component": null,
@@ -198,6 +200,7 @@ var rename_delete_handler_component = __toESM(__extractDefault(require('./rename
   "plugin-settings-tab-component": null,
   "pointer-position-component": null,
   "registry-component": null,
-  "rename-delete-handler-component": null
+  "rename-delete-handler-component": null,
+  "syntax-highlighting-component": null
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/index.d.cts

@@ -19,3 +19,4 @@ export * as 'plugin-settings-tab-component' from './plugin-settings-tab-componen
 export * as 'pointer-position-component' from './pointer-position-component.cjs';
 export * as 'registry-component' from './registry-component.cjs';
 export * as 'rename-delete-handler-component' from './rename-delete-handler-component.cjs';
+export * as 'syntax-highlighting-component' from './syntax-highlighting-component.cjs';

package/dist/lib/cjs/obsidian/components/syntax-highlighting-component.cjs

@@ -0,0 +1,244 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var syntax_highlighting_component_exports = {};
+__export(syntax_highlighting_component_exports, {
+  SyntaxHighlightingComponent: () => SyntaxHighlightingComponent
+});
+module.exports = __toCommonJS(syntax_highlighting_component_exports);
+var import_implementations = require('@obsidian-typings/obsidian-public-latest/implementations');
+var import_error = require('../../error.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class SyntaxHighlightingComponent extends import_component_ex.ComponentEx {
+  /**
+   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerCodeBlockLanguageAsync({
+   *   editorMode: 'text/typescript',
+   *   language: 'my-language',
+   *   prismGrammar: 'typescript'
+   * });
+   * ```
+   */
+  async registerCodeBlockLanguageAsync(params) {
+    const {
+      editorMode,
+      language,
+      prismGrammar
+    } = params;
+    this.ensureLoaded();
+    if (prismGrammar !== void 0) {
+      await this.registerPrismLanguageAsync({
+        grammar: prismGrammar,
+        language
+      });
+    }
+    this.ensureLoaded();
+    const previousModeFactory = window.CodeMirror.modes[language];
+    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));
+    this.register(() => {
+      if (previousModeFactory !== void 0) {
+        window.CodeMirror.modes[language] = previousModeFactory;
+        return;
+      }
+      delete window.CodeMirror.modes[language];
+    });
+  }
+  /**
+   * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+   * {@link CodeHighlighterComponent} settings field.
+   *
+   * @param params - The parameters for registering the language.
+   * @returns A {@link Promise} that resolves when the language is registered.
+   *
+   * @example
+   * ```ts
+   * await component.registerPrismLanguageAsync({
+   *   grammar: {
+   *     keyword: /\bfoo\b/
+   *   },
+   *   language: 'my-language'
+   * });
+   * ```
+   */
+  async registerPrismLanguageAsync(params) {
+    const {
+      grammar,
+      language
+    } = params;
+    this.ensureLoaded();
+    const prism = await (0, import_implementations.loadPrism)();
+    this.ensureLoaded();
+    const previousGrammar = prism.languages[language];
+    prism.languages[language] = this.resolveGrammar(prism, grammar);
+    this.register(() => {
+      if (previousGrammar !== void 0) {
+        prism.languages[language] = previousGrammar;
+        return;
+      }
+      delete prism.languages[language];
+    });
+  }
+  /**
+   * Returns the grammar of an already registered Prism language.
+   *
+   * @param prism - The loaded Prism module.
+   * @param language - The language to look up.
+   * @returns The grammar of the language.
+   * @throws An {@link Error} if the language is not registered.
+   */
+  requirePrismLanguage(prism, language) {
+    return prism.languages[language] ?? (0, import_error.throwExpression)(new Error(`Prism language "${language}" is not registered.`));
+  }
+  /**
+   * Resolves a grammar source into the grammar to register.
+   *
+   * @param prism - The loaded Prism module.
+   * @param grammarSource - The grammar source to resolve.
+   * @returns The resolved grammar.
+   */
+  resolveGrammar(prism, grammarSource) {
+    if (typeof grammarSource === "string") {
+      return this.requirePrismLanguage(prism, grammarSource);
+    }
+    if (typeof grammarSource === "function") {
+      return grammarSource({
+        prism,
+        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)
+      });
+    }
+    return grammarSource;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SyntaxHighlightingComponent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/syntax-highlighting-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains class {@link SyntaxHighlightingComponent} that registers syntax highlighting languages.\n *\n * Obsidian highlights code in two independent places, through two separate registries, and a plugin adding\n * its own language usually has to touch both:\n *\n * - **Prism** (`prism.languages[language]`) highlights code in reading view and in every `<pre><code>` the\n *   library renders \u2014 including the {@link CodeHighlighterComponent} settings field.\n * - **The CodeMirror 5 mode registry** (`window.CodeMirror.modes[language]`) highlights a fenced code block\n *   inside the editor.\n *\n * The CodeMirror 5 half looks like legacy that should be migrated to CodeMirror 6. **It is not** \u2014 verified\n * against the Obsidian 1.13.4 runtime:\n *\n * - Obsidian's own CodeMirror 6 editor language is a bridged CodeMirror 5 mode:\n *   `StreamLanguage.define(CodeMirror.getMode({}, { name: 'hypermd' }))`.\n * - Obsidian registers that `hypermd` mode through `window.CodeMirror.defineMode` with\n *   `fencedCodeBlockHighlighting: true`, and that option resolves each fence's language through the\n *   **CodeMirror 5 mode registry**.\n * - There is no public or internal CodeMirror 6 language-registration API for fences.\n *\n * So `window.CodeMirror.defineMode` is the sanctioned extension point, not legacy debt. Do not reopen this\n * as a migration.\n *\n * Teardown REMOVES the mode rather than redefining it to `null`. Plugins predating this component redefined\n * the mode to `null` on unload, because it was unclear whether CodeMirror's `getMode` needs the entry to\n * stay present. It does not \u2014 verified against a live Obsidian 1.13.4 by\n * `syntax-highlighting-component.obsidian.integration.test.ts`: after the entry is deleted, the fence\n * renders its text with no error and drops back to the exact token count it had before the language was\n * ever registered.\n */\n\nimport type {\n  Grammar,\n  PrismModule\n} from '@obsidian-typings/obsidian-public-latest';\n\nimport { loadPrism } from '@obsidian-typings/obsidian-public-latest/implementations';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars -- We need to import `CodeHighlighterComponent` to use it in the tsdocs.\nimport type { CodeHighlighterComponent } from '../setting-components/code-highlighter-component.ts';\n\nimport { throwExpression } from '../../error.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The loaded Prism module, handed to a grammar factory.\n */\nexport interface SyntaxHighlightingComponentGrammarFactoryParams {\n  /**\n   * The loaded Prism module.\n   */\n  readonly prism: PrismModule;\n\n  /**\n   * Returns the grammar of an already registered Prism language, for nesting into the built grammar.\n   *\n   * @param language - The language to look up.\n   * @returns The grammar of the language.\n   * @throws An {@link Error} if the language is not registered.\n   */\n  requirePrismLanguage(language: string): Grammar;\n}\n\n/**\n * A grammar, the name of an already registered language to alias, or a factory that builds the grammar from\n * the loaded Prism module.\n */\nexport type SyntaxHighlightingComponentGrammarSource = ((params: SyntaxHighlightingComponentGrammarFactoryParams) => Grammar) | Grammar | string;\n\n/**\n * Parameters for {@link SyntaxHighlightingComponent.registerCodeBlockLanguageAsync}.\n */\nexport interface SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams {\n  /**\n   * The CodeMirror 5 mode name or MIME type the editor highlights the fence as, e.g. `text/typescript`.\n   */\n  readonly editorMode: string;\n\n  /**\n   * The fence language, e.g. the `foo` in a ` ```foo ` code block.\n   */\n  readonly language: string;\n\n  /**\n   * The grammar highlighting the fence in reading view. Omit when the fence is replaced in reading view \u2014\n   * e.g. a fence rendered as a button.\n   */\n  readonly prismGrammar?: SyntaxHighlightingComponentGrammarSource | undefined;\n}\n\n/**\n * Parameters for {@link SyntaxHighlightingComponent.registerPrismLanguageAsync}.\n */\nexport interface SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams {\n  /**\n   * The grammar to register.\n   */\n  readonly grammar: SyntaxHighlightingComponentGrammarSource;\n\n  /**\n   * The language to register the grammar as.\n   */\n  readonly language: string;\n}\n\n/**\n * A component that registers and unregisters syntax highlighting languages.\n *\n * @remarks\n * Every registration is undone when the component is unloaded: the previous entry is restored if the\n * language was already registered, otherwise the entry is removed.\n */\nexport class SyntaxHighlightingComponent extends ComponentEx {\n  /**\n   * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.\n   *\n   * @param params - The parameters for registering the language.\n   * @returns A {@link Promise} that resolves when the language is registered.\n   *\n   * @example\n   * ```ts\n   * await component.registerCodeBlockLanguageAsync({\n   *   editorMode: 'text/typescript',\n   *   language: 'my-language',\n   *   prismGrammar: 'typescript'\n   * });\n   * ```\n   */\n  public async registerCodeBlockLanguageAsync(params: SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams): Promise<void> {\n    const {\n      editorMode,\n      language,\n      prismGrammar\n    } = params;\n\n    this.ensureLoaded();\n\n    if (prismGrammar !== undefined) {\n      await this.registerPrismLanguageAsync({\n        grammar: prismGrammar,\n        language\n      });\n    }\n\n    this.ensureLoaded();\n\n    const previousModeFactory = window.CodeMirror.modes[language];\n    window.CodeMirror.defineMode(language, (config) => window.CodeMirror.getMode(config, editorMode));\n\n    this.register(() => {\n      if (previousModeFactory !== undefined) {\n        window.CodeMirror.modes[language] = previousModeFactory;\n        return;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The language is only known at runtime.\n      delete window.CodeMirror.modes[language];\n    });\n  }\n\n  /**\n   * Registers a Prism language, highlighting it everywhere Prism renders code \u2014 reading view and the\n   * {@link CodeHighlighterComponent} settings field.\n   *\n   * @param params - The parameters for registering the language.\n   * @returns A {@link Promise} that resolves when the language is registered.\n   *\n   * @example\n   * ```ts\n   * await component.registerPrismLanguageAsync({\n   *   grammar: {\n   *     keyword: /\\bfoo\\b/\n   *   },\n   *   language: 'my-language'\n   * });\n   * ```\n   */\n  public async registerPrismLanguageAsync(params: SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams): Promise<void> {\n    const {\n      grammar,\n      language\n    } = params;\n\n    this.ensureLoaded();\n\n    const prism = await loadPrism();\n\n    // The component might have been unloaded while Prism was loading.\n    this.ensureLoaded();\n\n    const previousGrammar = prism.languages[language];\n    prism.languages[language] = this.resolveGrammar(prism, grammar);\n\n    this.register(() => {\n      if (previousGrammar !== undefined) {\n        prism.languages[language] = previousGrammar;\n        return;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The language is only known at runtime.\n      delete prism.languages[language];\n    });\n  }\n\n  /**\n   * Returns the grammar of an already registered Prism language.\n   *\n   * @param prism - The loaded Prism module.\n   * @param language - The language to look up.\n   * @returns The grammar of the language.\n   * @throws An {@link Error} if the language is not registered.\n   */\n  private requirePrismLanguage(prism: PrismModule, language: string): Grammar {\n    return prism.languages[language] ?? throwExpression(new Error(`Prism language \"${language}\" is not registered.`));\n  }\n\n  /**\n   * Resolves a grammar source into the grammar to register.\n   *\n   * @param prism - The loaded Prism module.\n   * @param grammarSource - The grammar source to resolve.\n   * @returns The resolved grammar.\n   */\n  private resolveGrammar(prism: PrismModule, grammarSource: SyntaxHighlightingComponentGrammarSource): Grammar {\n    if (typeof grammarSource === 'string') {\n      return this.requirePrismLanguage(prism, grammarSource);\n    }\n\n    if (typeof grammarSource === 'function') {\n      return grammarSource({\n        prism,\n        requirePrismLanguage: (language) => this.requirePrismLanguage(prism, language)\n      });\n    }\n\n    return grammarSource;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuCA,6BAA0B;AAK1B,mBAAgC;AAChC,0BAA4B;AAsErB,MAAM,oCAAoC,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgB3D,MAAa,+BAA+B,QAAwF;AAClI,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,SAAK,aAAa;AAElB,QAAI,iBAAiB,QAAW;AAC9B,YAAM,KAAK,2BAA2B;AAAA,QACpC,SAAS;AAAA,QACT;AAAA,MACF,CAAC;AAAA,IACH;AAEA,SAAK,aAAa;AAElB,UAAM,sBAAsB,OAAO,WAAW,MAAM,QAAQ;AAC5D,WAAO,WAAW,WAAW,UAAU,CAAC,WAAW,OAAO,WAAW,QAAQ,QAAQ,UAAU,CAAC;AAEhG,SAAK,SAAS,MAAM;AAClB,UAAI,wBAAwB,QAAW;AACrC,eAAO,WAAW,MAAM,QAAQ,IAAI;AACpC;AAAA,MACF;AAGA,aAAO,OAAO,WAAW,MAAM,QAAQ;AAAA,IACzC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,MAAa,2BAA2B,QAAoF;AAC1H,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,IACF,IAAI;AAEJ,SAAK,aAAa;AAElB,UAAM,QAAQ,UAAM,kCAAU;AAG9B,SAAK,aAAa;AAElB,UAAM,kBAAkB,MAAM,UAAU,QAAQ;AAChD,UAAM,UAAU,QAAQ,IAAI,KAAK,eAAe,OAAO,OAAO;AAE9D,SAAK,SAAS,MAAM;AAClB,UAAI,oBAAoB,QAAW;AACjC,cAAM,UAAU,QAAQ,IAAI;AAC5B;AAAA,MACF;AAGA,aAAO,MAAM,UAAU,QAAQ;AAAA,IACjC,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,qBAAqB,OAAoB,UAA2B;AAC1E,WAAO,MAAM,UAAU,QAAQ,SAAK,8BAAgB,IAAI,MAAM,mBAAmB,QAAQ,sBAAsB,CAAC;AAAA,EAClH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,eAAe,OAAoB,eAAkE;AAC3G,QAAI,OAAO,kBAAkB,UAAU;AACrC,aAAO,KAAK,qBAAqB,OAAO,aAAa;AAAA,IACvD;AAEA,QAAI,OAAO,kBAAkB,YAAY;AACvC,aAAO,cAAc;AAAA,QACnB;AAAA,QACA,sBAAsB,CAAC,aAAa,KAAK,qBAAqB,OAAO,QAAQ;AAAA,MAC/E,CAAC;AAAA,IACH;AAEA,WAAO;AAAA,EACT;AACF;",
  "names": []
}


package/dist/lib/cjs/obsidian/components/syntax-highlighting-component.d.cts

@@ -0,0 +1,149 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * Contains class {@link SyntaxHighlightingComponent} that registers syntax highlighting languages.
+ *
+ * Obsidian highlights code in two independent places, through two separate registries, and a plugin adding
+ * its own language usually has to touch both:
+ *
+ * - **Prism** (`prism.languages[language]`) highlights code in reading view and in every `<pre><code>` the
+ *   library renders — including the {@link CodeHighlighterComponent} settings field.
+ * - **The CodeMirror 5 mode registry** (`window.CodeMirror.modes[language]`) highlights a fenced code block
+ *   inside the editor.
+ *
+ * The CodeMirror 5 half looks like legacy that should be migrated to CodeMirror 6. **It is not** — verified
+ * against the Obsidian 1.13.4 runtime:
+ *
+ * - Obsidian's own CodeMirror 6 editor language is a bridged CodeMirror 5 mode:
+ *   `StreamLanguage.define(CodeMirror.getMode({}, { name: 'hypermd' }))`.
+ * - Obsidian registers that `hypermd` mode through `window.CodeMirror.defineMode` with
+ *   `fencedCodeBlockHighlighting: true`, and that option resolves each fence's language through the
+ *   **CodeMirror 5 mode registry**.
+ * - There is no public or internal CodeMirror 6 language-registration API for fences.
+ *
+ * So `window.CodeMirror.defineMode` is the sanctioned extension point, not legacy debt. Do not reopen this
+ * as a migration.
+ *
+ * Teardown REMOVES the mode rather than redefining it to `null`. Plugins predating this component redefined
+ * the mode to `null` on unload, because it was unclear whether CodeMirror's `getMode` needs the entry to
+ * stay present. It does not — verified against a live Obsidian 1.13.4 by
+ * `syntax-highlighting-component.obsidian.integration.test.ts`: after the entry is deleted, the fence
+ * renders its text with no error and drops back to the exact token count it had before the language was
+ * ever registered.
+ */
+import type { Grammar, PrismModule } from '@obsidian-typings/obsidian-public-latest' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * The loaded Prism module, handed to a grammar factory.
+ */
+export interface SyntaxHighlightingComponentGrammarFactoryParams {
+    /**
+     * The loaded Prism module.
+     */
+    readonly prism: PrismModule;
+    /**
+     * Returns the grammar of an already registered Prism language, for nesting into the built grammar.
+     *
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    requirePrismLanguage(language: string): Grammar;
+}
+/**
+ * A grammar, the name of an already registered language to alias, or a factory that builds the grammar from
+ * the loaded Prism module.
+ */
+export type SyntaxHighlightingComponentGrammarSource = ((params: SyntaxHighlightingComponentGrammarFactoryParams) => Grammar) | Grammar | string;
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerCodeBlockLanguageAsync}.
+ */
+export interface SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams {
+    /**
+     * The CodeMirror 5 mode name or MIME type the editor highlights the fence as, e.g. `text/typescript`.
+     */
+    readonly editorMode: string;
+    /**
+     * The fence language, e.g. the `foo` in a ` ```foo ` code block.
+     */
+    readonly language: string;
+    /**
+     * The grammar highlighting the fence in reading view. Omit when the fence is replaced in reading view —
+     * e.g. a fence rendered as a button.
+     */
+    readonly prismGrammar?: SyntaxHighlightingComponentGrammarSource | undefined;
+}
+/**
+ * Parameters for {@link SyntaxHighlightingComponent.registerPrismLanguageAsync}.
+ */
+export interface SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams {
+    /**
+     * The grammar to register.
+     */
+    readonly grammar: SyntaxHighlightingComponentGrammarSource;
+    /**
+     * The language to register the grammar as.
+     */
+    readonly language: string;
+}
+/**
+ * A component that registers and unregisters syntax highlighting languages.
+ *
+ * @remarks
+ * Every registration is undone when the component is unloaded: the previous entry is restored if the
+ * language was already registered, otherwise the entry is removed.
+ */
+export declare class SyntaxHighlightingComponent extends ComponentEx {
+    /**
+     * Registers a fenced code block language, highlighting it in the editor and, optionally, in reading view.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerCodeBlockLanguageAsync({
+     *   editorMode: 'text/typescript',
+     *   language: 'my-language',
+     *   prismGrammar: 'typescript'
+     * });
+     * ```
+     */
+    registerCodeBlockLanguageAsync(params: SyntaxHighlightingComponentRegisterCodeBlockLanguageAsyncParams): Promise<void>;
+    /**
+     * Registers a Prism language, highlighting it everywhere Prism renders code — reading view and the
+     * {@link CodeHighlighterComponent} settings field.
+     *
+     * @param params - The parameters for registering the language.
+     * @returns A {@link Promise} that resolves when the language is registered.
+     *
+     * @example
+     * ```ts
+     * await component.registerPrismLanguageAsync({
+     *   grammar: {
+     *     keyword: /\bfoo\b/
+     *   },
+     *   language: 'my-language'
+     * });
+     * ```
+     */
+    registerPrismLanguageAsync(params: SyntaxHighlightingComponentRegisterPrismLanguageAsyncParams): Promise<void>;
+    /**
+     * Returns the grammar of an already registered Prism language.
+     *
+     * @param prism - The loaded Prism module.
+     * @param language - The language to look up.
+     * @returns The grammar of the language.
+     * @throws An {@link Error} if the language is not registered.
+     */
+    private requirePrismLanguage;
+    /**
+     * Resolves a grammar source into the grammar to register.
+     *
+     * @param prism - The loaded Prism module.
+     * @param grammarSource - The grammar source to resolve.
+     * @returns The resolved grammar.
+     */
+    private resolveGrammar;
+}