@nuxtjs/mdc 0.3.2 → 0.4.0

package/dist/config.cjs

@@ -0,0 +1 @@
+module.exports = {}; module.exports.defineConfig = configs => configs

package/dist/config.d.mts

@@ -0,0 +1,49 @@
+import { Highlighter, ShikiTransformer, HighlighterCore } from 'shiki';
+import { Processor } from 'unified';
+import { M as MdcThemeOptions, H as HighlighterOptions } from './shared/mdc.a6f76af4.mjs';
+
+type Awaitable<T> = T | Promise<T>;
+interface MdcConfig {
+    /**
+     * Hooks for the unified markdown pipeline
+     */
+    unified?: {
+        /**
+         * Custom setup for unified processor before other plugins
+         */
+        pre?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after remark but before rehype
+         */
+        remark?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after rehype
+         */
+        rehype?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after all plugins
+         */
+        post?: (processor: Processor) => Awaitable<void | Processor>;
+    };
+    /**
+     * Custom hightlighter, available when `highlighter` is set to `custom`
+     */
+    highlighter?: Highlighter;
+    /**
+     * Hooks for shiki
+     */
+    shiki?: {
+        /**
+         * Get transformers for shiki
+         */
+        transformers?: ShikiTransformer[] | ((code: string, lang: string, theme: MdcThemeOptions, options: Partial<HighlighterOptions>) => Awaitable<ShikiTransformer[]>);
+        /**
+         * Custom setup for shiki instance, only called once on server or client
+         */
+        setup?: (highlighter: HighlighterCore) => Awaitable<void>;
+    };
+}
+
+declare function defineConfig(config: MdcConfig): MdcConfig;
+
+export { defineConfig };

package/dist/config.d.ts

@@ -0,0 +1,49 @@
+import { Highlighter, ShikiTransformer, HighlighterCore } from 'shiki';
+import { Processor } from 'unified';
+import { M as MdcThemeOptions, H as HighlighterOptions } from './shared/mdc.a6f76af4.js';
+
+type Awaitable<T> = T | Promise<T>;
+interface MdcConfig {
+    /**
+     * Hooks for the unified markdown pipeline
+     */
+    unified?: {
+        /**
+         * Custom setup for unified processor before other plugins
+         */
+        pre?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after remark but before rehype
+         */
+        remark?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after rehype
+         */
+        rehype?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after all plugins
+         */
+        post?: (processor: Processor) => Awaitable<void | Processor>;
+    };
+    /**
+     * Custom hightlighter, available when `highlighter` is set to `custom`
+     */
+    highlighter?: Highlighter;
+    /**
+     * Hooks for shiki
+     */
+    shiki?: {
+        /**
+         * Get transformers for shiki
+         */
+        transformers?: ShikiTransformer[] | ((code: string, lang: string, theme: MdcThemeOptions, options: Partial<HighlighterOptions>) => Awaitable<ShikiTransformer[]>);
+        /**
+         * Custom setup for shiki instance, only called once on server or client
+         */
+        setup?: (highlighter: HighlighterCore) => Awaitable<void>;
+    };
+}
+
+declare function defineConfig(config: MdcConfig): MdcConfig;
+
+export { defineConfig };

package/dist/config.mjs

@@ -0,0 +1,5 @@
+function defineConfig(config) {
+  return config;
+}
+
+export { defineConfig };

package/dist/module.d.mts

@@ -1,23 +1,47 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { BuiltinTheme } from 'shikiji';
-
-type Theme = BuiltinTheme | Record<string, BuiltinTheme>;
+import { M as MdcThemeOptions } from './shared/mdc.a6f76af4.mjs';
+import { BundledLanguage, LanguageRegistration, BundledTheme, ThemeRegistrationAny } from 'shiki';
 
 interface UnistPlugin {
     src?: string;
     options?: Record<string, any>;
 }
 interface ModuleOptions {
+    /**
+     * A map of remark plugins to be used for processing markdown.
+     */
     remarkPlugins?: Record<string, UnistPlugin>;
+    /**
+     * A map of remark plugins to be used for processing markdown.
+     */
     rehypePlugins?: Record<string, UnistPlugin>;
     highlight?: {
-        highlighter?: string;
+        /**
+         * The highlighter to be used for highlighting code blocks.
+         *
+         * Set to `custom` to provide your own highlighter function in `mdc.config.ts`.
+         * Set to `shiki` to use the builtin highlighter based on Shiki.
+         * Or provide the path to your own highlighter module with the default export.
+         *
+         * @default 'shiki'
+         */
+        highlighter?: 'shiki' | 'custom' | string;
         /**
          * Default theme that will be used for highlighting code blocks.
          */
-        theme?: Theme;
+        theme?: MdcThemeOptions;
+        /**
+         * Languages to be bundled loaded by Shiki
+         */
+        langs?: (BundledLanguage | LanguageRegistration)[];
+        /**
+         * Additional themes to be bundled loaded by Shiki
+         */
+        themes?: (BundledTheme | ThemeRegistrationAny)[];
         /**
          * Preloaded languages that will be available for highlighting code blocks.
+         *
+         * @deprecated use `langs` instead.
          */
         preload?: string[];
         /**
@@ -41,14 +65,8 @@ interface ModuleOptions {
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
 
 declare module '@nuxt/schema' {
-    interface RuntimeConfig {
-        mdc: {
-            highlight: {
-                theme?: Theme;
-                preload?: string[];
-                wrapperStyle?: boolean | string;
-            };
-        };
+    interface NuxtHooks {
+        'mdc:configSources': (configs: string[]) => void;
     }
     interface PublicRuntimeConfig {
         mdc: {

package/dist/module.d.ts

@@ -1,23 +1,47 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { BuiltinTheme } from 'shikiji';
-
-type Theme = BuiltinTheme | Record<string, BuiltinTheme>;
+import { M as MdcThemeOptions } from './shared/mdc.a6f76af4.js';
+import { BundledLanguage, LanguageRegistration, BundledTheme, ThemeRegistrationAny } from 'shiki';
 
 interface UnistPlugin {
     src?: string;
     options?: Record<string, any>;
 }
 interface ModuleOptions {
+    /**
+     * A map of remark plugins to be used for processing markdown.
+     */
     remarkPlugins?: Record<string, UnistPlugin>;
+    /**
+     * A map of remark plugins to be used for processing markdown.
+     */
     rehypePlugins?: Record<string, UnistPlugin>;
     highlight?: {
-        highlighter?: string;
+        /**
+         * The highlighter to be used for highlighting code blocks.
+         *
+         * Set to `custom` to provide your own highlighter function in `mdc.config.ts`.
+         * Set to `shiki` to use the builtin highlighter based on Shiki.
+         * Or provide the path to your own highlighter module with the default export.
+         *
+         * @default 'shiki'
+         */
+        highlighter?: 'shiki' | 'custom' | string;
         /**
          * Default theme that will be used for highlighting code blocks.
          */
-        theme?: Theme;
+        theme?: MdcThemeOptions;
+        /**
+         * Languages to be bundled loaded by Shiki
+         */
+        langs?: (BundledLanguage | LanguageRegistration)[];
+        /**
+         * Additional themes to be bundled loaded by Shiki
+         */
+        themes?: (BundledTheme | ThemeRegistrationAny)[];
         /**
          * Preloaded languages that will be available for highlighting code blocks.
+         *
+         * @deprecated use `langs` instead.
          */
         preload?: string[];
         /**
@@ -41,14 +65,8 @@ interface ModuleOptions {
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
 
 declare module '@nuxt/schema' {
-    interface RuntimeConfig {
-        mdc: {
-            highlight: {
-                theme?: Theme;
-                preload?: string[];
-                wrapperStyle?: boolean | string;
-            };
-        };
+    interface NuxtHooks {
+        'mdc:configSources': (configs: string[]) => void;
     }
     interface PublicRuntimeConfig {
         mdc: {

package/dist/module.json

@@ -1,5 +1,5 @@
 {
   "name": "@nuxtjs/mdc",
   "configKey": "mdc",
-  "version": "0.3.2"
+  "version": "0.4.0"
 }

package/dist/module.mjs

@@ -1,52 +1,9 @@
-import { createResolver, extendViteConfig, defineNuxtModule, useNitro, addServerHandler, addTemplate, addComponent, addImports, addServerImports, addComponentsDir } from '@nuxt/kit';
-import fs from 'fs';
-import { pascalCase } from 'scule';
+import { extendViteConfig, defineNuxtModule, createResolver, useNitro, addServerHandler, addComponent, addImports, addServerImports, addComponentsDir, addTemplate } from '@nuxt/kit';
+import fs$1, { existsSync } from 'fs';
 import { defu } from 'defu';
-import { pathToFileURL } from 'url';
-
-const mdcImportTemplate = async ({ nuxt, options }) => {
-  const resolver = createResolver(import.meta.url);
-  const imports = [];
-  const { imports: remarkImports, definitions: remarkDefinitions } = processUnistPlugins(options.remarkPlugins);
-  const { imports: rehypeImports, definitions: rehypeDefinitions } = processUnistPlugins(options.rehypePlugins);
-  let highlighter = "false";
-  if (options.highlight) {
-    highlighter = JSON.stringify(options.highlight);
-    if (options.highlight.highlighter) {
-      const path = await resolver.resolvePath(options.highlight.highlighter, { alias: nuxt.options.alias });
-      imports.push(`import syntaxHighlighter from '${path}'`);
-      highlighter = highlighter.replace(`"${options.highlight.highlighter}"`, "syntaxHighlighter");
-    }
-  }
-  return [
-    ...remarkImports,
-    ...rehypeImports,
-    ...imports,
-    "",
-    "export const remarkPlugins = {",
-    ...remarkDefinitions,
-    "}",
-    "",
-    "export const rehypePlugins = {",
-    ...rehypeDefinitions,
-    "}",
-    "",
-    `export const highlight = ${highlighter}`
-  ].join("\n");
-};
-function processUnistPlugins(plugins) {
-  const imports = [];
-  const definitions = [];
-  Object.entries(plugins).forEach(([name, plugin]) => {
-    imports.push(`import ${pascalCase(name)} from '${plugin.src || name}'`);
-    if (Object.keys(plugin).length) {
-      definitions.push(`  '${name}': { instance: ${pascalCase(name)}, options: ${JSON.stringify(plugin.options || plugin)} },`);
-    } else {
-      definitions.push(`  '${name}': { instance: ${pascalCase(name)} },`);
-    }
-  });
-  return { imports, definitions };
-}
+import { resolve } from 'pathe';
+import fs from 'fs/promises';
+import { pascalCase } from 'scule';
 
 const registerMDCSlotTransformer = (resolver) => {
   extendViteConfig((config) => {
@@ -81,6 +38,127 @@ const registerMDCSlotTransformer = (resolver) => {
   });
 };
 
+async function mdcConfigs({ options }) {
+  return [
+    "let configs",
+    "export function getMdcConfigs () {",
+    "if (!configs) {",
+    "  configs = Promise.all([",
+    ...options.configs.map((item) => `    import('${item}').then(m => m.default),`),
+    "  ])",
+    "}",
+    "return configs",
+    "}"
+  ].join("\n");
+}
+
+async function mdcHighlighter({
+  options: {
+    shikiPath,
+    options
+  }
+}) {
+  if (!options || !options.highlighter)
+    return "export default () => { throw new Error('[@nuxtjs/mdc] No highlighter specified') }";
+  if (options.highlighter === "shiki") {
+    const file = [
+      shikiPath,
+      shikiPath + ".mjs"
+    ].find((file2) => existsSync(file2));
+    if (!file)
+      throw new Error(`[@nuxtjs/mdc] Could not find shiki highlighter: ${shikiPath}`);
+    const code = await fs.readFile(file, "utf-8");
+    const { bundledLanguagesInfo } = await import('shiki/langs');
+    const langsMap = /* @__PURE__ */ new Map();
+    options.langs?.forEach((lang) => {
+      if (typeof lang === "string") {
+        const info = bundledLanguagesInfo.find((i) => i.aliases?.includes?.(lang) || i.id === lang);
+        if (!info) {
+          throw new Error(`[@nuxtjs/mdc] Could not find shiki language: ${lang}`);
+        }
+        langsMap.set(info.id, info.id);
+        for (const alias of info.aliases || []) {
+          langsMap.set(alias, info.id);
+        }
+      } else {
+        langsMap.set(lang.name, lang);
+      }
+    });
+    const themes = Array.from(/* @__PURE__ */ new Set([
+      ...typeof options?.theme === "string" ? [options?.theme] : Object.values(options?.theme || {}),
+      ...options?.themes || []
+    ]));
+    return [
+      "import { getMdcConfigs } from '#mdc-configs'",
+      code,
+      "const bundledLangs = {",
+      ...Array.from(langsMap.entries()).map(([name, lang]) => typeof lang === "string" ? JSON.stringify(name) + `: () => import('shiki/langs/${lang}.mjs'),` : JSON.stringify(name) + ": " + JSON.stringify(lang) + ","),
+      "}",
+      "const bundledThemes = {",
+      ...themes.map((theme) => typeof theme === "string" ? JSON.stringify(theme) + `: () => import('shiki/themes/${theme}.mjs').then(r => r.default),` : JSON.stringify(theme.name) + ": " + JSON.stringify(theme) + ","),
+      "}",
+      "const options = " + JSON.stringify({
+        theme: options.theme,
+        wrapperStyle: options.wrapperStyle
+      }),
+      "const highlighter = createShikiHighlighter({ bundledLangs, bundledThemes, options, getMdcConfigs })",
+      "export default highlighter"
+    ].join("\n");
+  }
+  if (options.highlighter === "custom") {
+    return [
+      "import { getMdcConfigs } from '#mdc-configs'",
+      `export default function (...args) {
+        '  const configs = await getMdcConfigs()`,
+      "  for (const config of configs) {",
+      "    if (config.highlighter) {",
+      "      return config.highlighter(...args)",
+      "    }",
+      "  }",
+      "  throw new Error('[@nuxtjs/mdc] No custom highlighter specified')",
+      "}"
+    ].join("\n");
+  }
+  return "export { default } from " + JSON.stringify(options.highlighter);
+}
+
+async function mdcImports({ options }) {
+  const imports = [];
+  const { imports: remarkImports, definitions: remarkDefinitions } = processUnistPlugins(options.remarkPlugins);
+  const { imports: rehypeImports, definitions: rehypeDefinitions } = processUnistPlugins(options.rehypePlugins);
+  return [
+    ...remarkImports,
+    ...rehypeImports,
+    ...imports,
+    "",
+    "export const remarkPlugins = {",
+    ...remarkDefinitions,
+    "}",
+    "",
+    "export const rehypePlugins = {",
+    ...rehypeDefinitions,
+    "}",
+    "",
+    `export const highlight = ${JSON.stringify({
+      theme: options.highlight?.theme,
+      wrapperStyle: options.highlight?.wrapperStyle
+    })}`
+  ].join("\n");
+}
+function processUnistPlugins(plugins) {
+  const imports = [];
+  const definitions = [];
+  Object.entries(plugins).forEach(([name, plugin]) => {
+    imports.push(`import ${pascalCase(name)} from '${plugin.src || name}'`);
+    if (Object.keys(plugin).length) {
+      definitions.push(`  '${name}': { instance: ${pascalCase(name)}, options: ${JSON.stringify(plugin.options || plugin)} },`);
+    } else {
+      definitions.push(`  '${name}': { instance: ${pascalCase(name)} },`);
+    }
+  });
+  return { imports, definitions };
+}
+
 const module = defineNuxtModule({
   meta: {
     name: "@nuxtjs/mdc",
@@ -107,6 +185,7 @@ const module = defineNuxtModule({
     }
   },
   async setup(options, nuxt) {
+    resolveOptions(options);
     const resolver = createResolver(import.meta.url);
     nuxt.options.runtimeConfig.public.mdc = defu(nuxt.options.runtimeConfig.public.mdc, {
       components: {
@@ -115,24 +194,6 @@ const module = defineNuxtModule({
       },
       headings: options.headings
     });
-    nuxt.options.runtimeConfig.mdc = defu(nuxt.options.runtimeConfig.mdc, {
-      highlight: options.highlight ? {
-        theme: options.highlight.theme,
-        preload: options.highlight.preload,
-        wrapperStyle: options.highlight.wrapperStyle
-      } : {}
-    });
-    nuxt.hook("vite:extendConfig", (viteConfig) => {
-      const optimizeList = ["debug", "flat", "node-emoji", "extend", "hast-util-raw"];
-      viteConfig.optimizeDeps ||= {};
-      viteConfig.optimizeDeps.include ||= [];
-      const list = viteConfig.optimizeDeps.include;
-      optimizeList.forEach((pkg) => {
-        if (!list.includes(pkg)) {
-          list.push(pkg);
-        }
-      });
-    });
     if (options.highlight) {
       nuxt.hook("ready", () => {
         const nitro = useNitro();
@@ -156,15 +217,63 @@ const module = defineNuxtModule({
           addWasmSupport(prerenderer);
         });
       });
-      addServerHandler({ route: "/api/_mdc/highlight", handler: resolver.resolve("./runtime/shiki/event-handler") });
-      options.rehypePlugins = options.rehypePlugins || {};
-      options.rehypePlugins.highlight = options.rehypePlugins.highlight || {};
-      options.rehypePlugins.highlight.src = options.rehypePlugins.highlight.src || await resolver.resolvePath("./runtime/shiki/index");
+      addServerHandler({
+        route: "/api/_mdc/highlight",
+        handler: resolver.resolve("./runtime/highlighter/event-handler")
+      });
+      options.rehypePlugins ||= {};
+      options.rehypePlugins.highlight ||= {};
+      options.rehypePlugins.highlight.src ||= await resolver.resolvePath("./runtime/highlighter/rehype");
+      options.rehypePlugins.highlight.options ||= {};
+    }
+    const registerTemplate = (options2) => {
+      const name = options2.filename.replace(/\.m?js$/, "");
+      const alias = "#" + name;
+      const results = addTemplate({
+        ...options2,
+        write: true
+        // Write to disk for Nitro to consume
+      });
+      nuxt.options.nitro.alias ||= {};
+      nuxt.options.nitro.externals ||= {};
+      nuxt.options.nitro.externals.inline ||= [];
+      nuxt.options.alias[alias] = results.dst;
+      nuxt.options.nitro.alias[alias] = nuxt.options.alias[alias];
+      nuxt.options.nitro.externals.inline.push(nuxt.options.alias[alias]);
+      nuxt.options.nitro.externals.inline.push(alias);
+      return results;
+    };
+    const mdcConfigs$1 = [];
+    for (const layer of nuxt.options._layers) {
+      let path = resolve(layer.config.srcDir, "mdc.config.ts");
+      if (fs$1.existsSync(path)) {
+        mdcConfigs$1.push(path);
+      } else {
+        path = resolve(layer.config.srcDir, "mdc.config.js");
+        if (fs$1.existsSync(path)) {
+          mdcConfigs$1.push(path);
+        }
+      }
     }
-    const { dst: templatePath } = addTemplate({ filename: "mdc-imports.mjs", getContents: mdcImportTemplate, options, write: true });
-    nuxt.options.alias["#mdc-imports"] = process.env.NODE_ENV === "development" ? pathToFileURL(templatePath).href : templatePath;
-    nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
-    nuxt.options.nitro.alias["#mdc-imports"] = nuxt.options.alias["#mdc-imports"];
+    await nuxt.callHook("mdc:configSources", mdcConfigs$1);
+    registerTemplate({
+      filename: "mdc-configs.mjs",
+      getContents: mdcConfigs,
+      options: { configs: mdcConfigs$1 }
+    });
+    registerTemplate({
+      filename: "mdc-highlighter.mjs",
+      getContents: mdcHighlighter,
+      options: {
+        shikiPath: resolver.resolve("../dist/runtime/highlighter/shiki"),
+        options: options.highlight
+      }
+    });
+    registerTemplate({
+      filename: "mdc-imports.mjs",
+      getContents: mdcImports,
+      options
+    });
     addComponent({ name: "MDC", filePath: resolver.resolve("./runtime/components/MDC") });
     addComponent({ name: "MDCRenderer", filePath: resolver.resolve("./runtime/components/MDCRenderer") });
     addComponent({ name: "MDCSlot", filePath: resolver.resolve("./runtime/components/MDCSlot") });
@@ -180,15 +289,49 @@ const module = defineNuxtModule({
       });
     }
     extendViteConfig((config) => {
-      config.optimizeDeps = config.optimizeDeps || {};
-      config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
-      config.optimizeDeps.exclude.push("@nuxtjs/mdc");
+      const include = [
+        "remark-gfm",
+        // from runtime/parser/index.ts
+        "remark-emoji",
+        // from runtime/parser/index.ts
+        "remark-mdc",
+        // from runtime/parser/index.ts
+        "remark-rehype",
+        // from runtime/parser/index.ts
+        "rehype-raw",
+        // from runtime/parser/index.ts
+        "parse5",
+        // transitive deps of rehype
+        "unist-util-visit",
+        // from runtime/highlighter/rehype.ts
+        "unified",
+        // deps by all the plugins
+        "debug"
+        // deps by many libraries but it's not an ESM
+      ];
+      const exclude = [
+        "@nuxtjs/mdc"
+        // package itself, it's a build time module
+      ];
+      config.optimizeDeps ||= {};
+      config.optimizeDeps.exclude ||= [];
+      config.optimizeDeps.include ||= [];
+      for (const pkg of include) {
+        if (!config.optimizeDeps.include.includes(pkg)) {
+          config.optimizeDeps.include.push(pkg);
+        }
+      }
+      for (const pkg of exclude) {
+        if (!config.optimizeDeps.exclude.includes(pkg)) {
+          config.optimizeDeps.exclude.push(pkg);
+        }
+      }
     });
     const _layers = [...nuxt.options._layers].reverse();
     for (const layer of _layers) {
       const srcDir = layer.config.srcDir;
       const globalComponents = resolver.resolve(srcDir, "components/mdc");
-      const dirStat = await fs.promises.stat(globalComponents).catch(() => null);
+      const dirStat = await fs$1.promises.stat(globalComponents).catch(() => null);
       if (dirStat && dirStat.isDirectory()) {
         nuxt.hook("components:dirs", (dirs) => {
           dirs.unshift({
@@ -203,5 +346,27 @@ const module = defineNuxtModule({
     registerMDCSlotTransformer(resolver);
   }
 });
+function resolveOptions(options) {
+  if (options.highlight !== false) {
+    options.highlight ||= {};
+    options.highlight.highlighter ||= "shiki";
+    options.highlight.theme ||= {
+      default: "github-light",
+      dark: "github-dark"
+    };
+    options.highlight.langs ||= [
+      "js",
+      "ts",
+      "vue",
+      "css",
+      "html",
+      "vue",
+      "shell"
+    ];
+    if (options.highlight.preload) {
+      options.highlight.langs.push(...options.highlight.preload || []);
+    }
+  }
+}
 
 export { module as default };

package/dist/runtime/components/MDCRenderer.vue

@@ -72,8 +72,8 @@ export default defineComponent({
     }
     const meta = { ...data, tags };
     const component = tag !== false ? resolveVueComponent(tag || meta.component?.name || meta.component || "div") : void 0;
-    const childrenRendrer = renderSlots(body, h, meta, meta);
-    return component ? h(component, { ...meta.component?.props, ...this.$attrs, key: contentKey }, childrenRendrer) : childrenRendrer.default?.();
+    const childrenRenderer = renderSlots(body, h, meta, meta);
+    return component ? h(component, { ...meta.component?.props, ...this.$attrs, key: contentKey }, childrenRenderer) : childrenRenderer.default?.();
   }
 });
 function renderNode(node, h2, documentMeta, parentScope = {}) {

package/dist/runtime/{shiki → highlighter}/event-handler.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("./types").HighlightResult>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/highlighter/event-handler.mjs

@@ -0,0 +1,8 @@
+import { eventHandler, getQuery } from "h3";
+import highlighter from "#mdc-highlighter";
+export default eventHandler(async (event) => {
+  const { code, lang, theme: themeString, options: optionsStr } = getQuery(event);
+  const theme = JSON.parse(themeString);
+  const options = optionsStr ? JSON.parse(optionsStr) : {};
+  return await highlighter(code, lang, theme, options);
+});

package/dist/runtime/highlighter/rehype.d.ts

@@ -0,0 +1,8 @@
+import type { Root } from 'hast';
+import type { Highlighter, MdcThemeOptions } from './types';
+export interface RehypeHighlightOption {
+    theme?: MdcThemeOptions;
+    highlighter?: Highlighter;
+}
+export default rehypeHighlight;
+export declare function rehypeHighlight(opts?: RehypeHighlightOption): (tree: Root) => Promise<void>;