@nuxtjs/mdc 0.3.2 → 0.5.0

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>;

package/dist/runtime/{shiki/index.mjs → highlighter/rehype.mjs}

@@ -1,15 +1,10 @@
 import { visit } from "unist-util-visit";
 import { toString } from "hast-util-to-string";
 const defaults = {
-  theme: {
-    default: "github-light",
-    dark: "github-dark"
-  },
-  async highlighter(code, lang, theme, highlights) {
+  theme: {},
+  async highlighter(code, lang, theme, options) {
     if (process.browser && window.sessionStorage.getItem("mdc-shiki-highlighter") === "browser") {
-      return import("./highlighter.mjs").then(({ useShikiHighlighter }) => {
-        return useShikiHighlighter().getHighlightedAST(code, lang, theme, { highlights });
-      });
+      return import("#mdc-highlighter").then((h) => h.default(code, lang, theme, options));
     }
     try {
       return await $fetch("/api/_mdc/highlight", {
@@ -17,20 +12,20 @@ const defaults = {
           code,
           lang,
           theme: JSON.stringify(theme),
-          highlights: JSON.stringify(highlights)
+          options: JSON.stringify(options)
         }
       });
     } catch (e) {
       if (process.browser && e?.response?.status === 404) {
         window.sessionStorage.setItem("mdc-shiki-highlighter", "browser");
-        return this.highlighter?.(code, lang, theme, highlights);
+        return this.highlighter?.(code, lang, theme, options);
       }
     }
     return Promise.resolve({ tree: [{ type: "text", value: code }], className: "", style: "" });
   }
 };
-export default rehypeShiki;
-export function rehypeShiki(opts = {}) {
+export default rehypeHighlight;
+export function rehypeHighlight(opts = {}) {
   const options = { ...defaults, ...opts };
   return async (tree) => {
     const tasks = [];
@@ -40,11 +35,15 @@ export function rehypeShiki(opts = {}) {
       (node) => ["pre", "code"].includes(node.tagName) && !!(node.properties?.language || node.properties?.highlights),
       (node) => {
         const _node = node;
+        const highlights = typeof _node.properties.highlights === "string" ? _node.properties.highlights.split(/[,\s]+/).map(Number) : Array.isArray(_node.properties.highlights) ? _node.properties.highlights.map(Number) : [];
         const task = options.highlighter(
           toString(node),
           _node.properties.language,
           options.theme,
-          _node.properties.highlights ?? []
+          {
+            highlights: highlights.filter(Boolean),
+            meta: _node.properties.meta
+          }
         ).then(({ tree: tree2, className, style, inlineStyle }) => {
           _node.properties.className = ((_node.properties.className || "") + " " + className).trim();
           _node.properties.style = ((_node.properties.style || "") + " " + inlineStyle).trim();

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

@@ -0,0 +1,14 @@
+import type { LanguageInput, ThemeInput } from 'shiki';
+import type { Highlighter } from './types';
+import type { MdcConfig } from '../types/config';
+export interface CreateShikiHighlighterOptions {
+    themes?: ThemeInput[];
+    langs?: LanguageInput[];
+    bundledThemes?: Record<string, ThemeInput>;
+    bundledLangs?: Record<string, LanguageInput>;
+    options?: {
+        wrapperStyle?: string;
+    };
+    getMdcConfigs?: () => Promise<MdcConfig[]>;
+}
+export declare function createShikiHighlighter({ langs, themes, bundledLangs, bundledThemes, getMdcConfigs, options: shikiOptions }?: CreateShikiHighlighterOptions): Highlighter;

package/dist/runtime/highlighter/shiki.mjs

@@ -0,0 +1,159 @@
+import { getHighlighterCore, addClassToHast, isSpecialLang, isSpecialTheme } from "shiki/core";
+import {
+  transformerNotationDiff,
+  transformerNotationErrorLevel,
+  transformerNotationFocus,
+  transformerNotationHighlight
+} from "@shikijs/transformers";
+export function createShikiHighlighter({
+  langs = [],
+  themes = [],
+  bundledLangs = {},
+  bundledThemes = {},
+  getMdcConfigs,
+  options: shikiOptions
+} = {}) {
+  let shiki;
+  let configs;
+  async function _getShiki() {
+    const shiki2 = await getHighlighterCore({
+      langs,
+      themes,
+      loadWasm: () => import("shiki/wasm")
+    });
+    for await (const config of await getConfigs()) {
+      await config.shiki?.setup?.(shiki2);
+    }
+    return shiki2;
+  }
+  async function getShiki() {
+    if (!shiki) {
+      shiki = _getShiki();
+    }
+    return shiki;
+  }
+  async function getConfigs() {
+    if (!configs) {
+      configs = Promise.resolve(getMdcConfigs?.() || []);
+    }
+    return configs;
+  }
+  const baseTransformers = [
+    transformerNotationDiff(),
+    transformerNotationFocus(),
+    transformerNotationHighlight(),
+    transformerNotationErrorLevel()
+  ];
+  const highlighter = async (code, lang, theme, options = {}) => {
+    const shiki2 = await getShiki();
+    const themesObject = typeof theme === "string" ? { default: theme } : theme || {};
+    const loadedThemes = shiki2.getLoadedThemes();
+    const loadedLanguages = shiki2.getLoadedLanguages();
+    if (typeof lang === "string" && !loadedLanguages.includes(lang) && !isSpecialLang(lang)) {
+      if (bundledLangs[lang]) {
+        await shiki2.loadLanguage(bundledLangs[lang]);
+      } else {
+        if (process.dev) {
+          console.warn(`[@nuxtjs/mdc] Language "${lang}" is not loaded to the Shiki highlighter, fallback to plain text. Add the language to "mdc.highlight.langs" to fix this.`);
+        }
+        lang = "text";
+      }
+    }
+    for (const [color, theme2] of Object.entries(themesObject)) {
+      if (typeof theme2 === "string" && !loadedThemes.includes(theme2) && !isSpecialTheme(theme2)) {
+        if (bundledThemes[theme2]) {
+          await shiki2.loadTheme(bundledThemes[theme2]);
+        } else {
+          if (process.dev) {
+            console.warn(`[@nuxtjs/mdc] Theme "${theme2}" is not loaded to the Shiki highlighter. Add the theme to "mdc.highlight.themes" to fix this.`);
+          }
+          themesObject[color] = "none";
+        }
+      }
+    }
+    const transformers = [
+      ...baseTransformers
+    ];
+    for (const config of await getConfigs()) {
+      const newTransformers = typeof config.shiki?.transformers === "function" ? await config.shiki?.transformers(code, lang, theme, options) : config.shiki?.transformers || [];
+      transformers.push(...newTransformers);
+    }
+    const root = shiki2.codeToHast(code.trimEnd(), {
+      lang,
+      themes: themesObject,
+      defaultColor: false,
+      meta: {
+        __raw: options.meta
+      },
+      transformers: [
+        ...transformers,
+        {
+          name: "mdc:highlight",
+          line(node, line) {
+            if (options.highlights?.includes(line))
+              addClassToHast(node, "highlight");
+            node.properties.line = line;
+          }
+        },
+        {
+          name: "mdc:newline",
+          line(node) {
+            if (code?.includes("\n")) {
+              if (node.children.length === 0 || node.children.length === 1 && node.children[0].type === "element" && node.children[0].children.length === 1 && node.children[0].children[0].type === "text" && node.children[0].children[0].value === "") {
+                node.children = [{
+                  type: "element",
+                  tagName: "span",
+                  properties: {
+                    emptyLinePlaceholder: true
+                  },
+                  children: [{ type: "text", value: "\n" }]
+                }];
+                return;
+              }
+              const last = node.children.at(-1);
+              if (last?.type === "element" && last.tagName === "span") {
+                const text = last.children.at(-1);
+                if (text?.type === "text")
+                  text.value += "\n";
+              }
+            }
+          }
+        }
+      ]
+    });
+    const preEl = root.children[0];
+    const codeEl = preEl.children[0];
+    const wrapperStyle = shikiOptions?.wrapperStyle;
+    preEl.properties.style = wrapperStyle ? typeof wrapperStyle === "string" ? wrapperStyle : preEl.properties.style : "";
+    const styles = [];
+    Object.keys(themesObject).forEach((color) => {
+      const colorScheme = color !== "default" ? `.${color}` : "";
+      styles.push(
+        wrapperStyle ? `${colorScheme} .shiki,` : "",
+        `html .${color} .shiki span {`,
+        `color: var(--shiki-${color});`,
+        `background: var(--shiki-${color}-bg);`,
+        `font-style: var(--shiki-${color}-font-style);`,
+        `font-weight: var(--shiki-${color}-font-weight);`,
+        `text-decoration: var(--shiki-${color}-text-decoration);`,
+        "}"
+      );
+      styles.push(
+        `html${colorScheme} .shiki span {`,
+        `color: var(--shiki-${color});`,
+        `background: var(--shiki-${color}-bg);`,
+        `font-style: var(--shiki-${color}-font-style);`,
+        `font-weight: var(--shiki-${color}-font-weight);`,
+        `text-decoration: var(--shiki-${color}-text-decoration);`,
+        "}"
+      );
+    });
+    return {
+      tree: codeEl.children,
+      className: Array.isArray(preEl.properties.class) ? preEl.properties.class.join(" ") : preEl.properties.class,
+      inlineStyle: preEl.properties.style,
+      style: styles.join("")
+    };
+  };
+  return highlighter;
+}

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

@@ -0,0 +1,14 @@
+import type { ElementContent } from 'hast';
+import type { BuiltinTheme } from 'shiki';
+export type MdcThemeOptions = BuiltinTheme | string | Record<string, BuiltinTheme | string>;
+export interface HighlighterOptions {
+    highlights?: number[];
+    meta?: string;
+}
+export interface HighlightResult {
+    tree: ElementContent[];
+    className?: string;
+    style?: string;
+    inlineStyle?: string;
+}
+export type Highlighter = (code: string, lang: string, theme: MdcThemeOptions, options: Partial<HighlighterOptions>) => Promise<HighlightResult>;

package/dist/runtime/index.d.ts

@@ -1,3 +1,2 @@
 export { parseMarkdown } from './parser';
-export { useShikiHighlighter } from './shiki/highlighter';
 export * from './utils/node';

package/dist/runtime/index.mjs

@@ -1,3 +1,2 @@
 export { parseMarkdown } from "./parser/index.mjs";
-export { useShikiHighlighter } from "./shiki/highlighter.mjs";
 export * from "./utils/node.mjs";

package/dist/runtime/parser/compiler.mjs

@@ -39,11 +39,12 @@ export function compileHast() {
       if (node.tagName === "component-slot") {
         node.tagName = "template";
       }
+      const children = (node.tagName === "template" && node.content?.children.length ? node.content.children : node.children).map((child) => compileToJSON(child, node)).filter(Boolean);
       return {
         type: "element",
         tag: node.tagName,
         props: validateProps(node.tagName, node.properties),
-        children: node.children.map((child) => compileToJSON(child, node)).filter(Boolean)
+        children
       };
     }
     if (node.type === "text") {

package/dist/runtime/parser/index.d.ts

@@ -1,5 +1,5 @@
 import type { MDCData, MDCParseOptions, MDCRoot, Toc } from '../types';
-export declare const parseMarkdown: (md: string, opts?: MDCParseOptions) => Promise<{
+export declare const parseMarkdown: (md: string, inlineOptions?: MDCParseOptions) => Promise<{
     data: MDCData;
     body: MDCRoot;
     excerpt: MDCRoot | undefined;

package/dist/runtime/parser/index.mjs

@@ -9,14 +9,36 @@ import { defaults } from "./options.mjs";
 import { generateToc } from "./toc.mjs";
 import { nodeTextContent } from "../utils/node.mjs";
 let moduleOptions;
-export const parseMarkdown = async (md, opts = {}) => {
+let generatedMdcConfigs;
+export const parseMarkdown = async (md, inlineOptions = {}) => {
   if (!moduleOptions) {
     moduleOptions = await import(
       "#mdc-imports"
       /* @vite-ignore */
     ).catch(() => ({}));
   }
-  const options = defu(opts, {
+  if (!generatedMdcConfigs) {
+    generatedMdcConfigs = await import(
+      "#mdc-configs"
+      /* @vite-ignore */
+    ).then((r) => r.getMdcConfigs()).catch(() => []);
+  }
+  const mdcConfigs = [
+    ...generatedMdcConfigs || [],
+    ...inlineOptions.configs || []
+  ];
+  if (inlineOptions.highlight != null && inlineOptions.highlight != false && inlineOptions.highlight.highlighter !== void 0 && typeof inlineOptions.highlight.highlighter !== "function") {
+    if (import.meta.dev)
+      console.warn("[@nuxtjs/mdc] `highlighter` passed to `parseMarkdown` is should be a function, but got " + JSON.stringify(inlineOptions.highlight.highlighter) + ", ignored.");
+    inlineOptions = {
+      ...inlineOptions,
+      highlight: {
+        ...inlineOptions.highlight
+      }
+    };
+    delete inlineOptions.highlight.highlighter;
+  }
+  const options = defu(inlineOptions, {
     remark: { plugins: moduleOptions?.remarkPlugins },
     rehype: { plugins: moduleOptions?.rehypePlugins },
     highlight: moduleOptions?.highlight
@@ -24,13 +46,25 @@ export const parseMarkdown = async (md, opts = {}) => {
   if (options.rehype?.plugins?.highlight) {
     options.rehype.plugins.highlight.options = options.highlight || {};
   }
-  const { content, data: frontmatter } = await parseFrontMatter(md);
-  const processor = unified();
+  let processor = unified();
+  for (const config of mdcConfigs) {
+    processor = await config.unified?.pre?.(processor) || processor;
+  }
   processor.use(remarkParse);
+  for (const config of mdcConfigs) {
+    processor = await config.unified?.remark?.(processor) || processor;
+  }
   await useProcessorPlugins(processor, options.remark?.plugins);
   processor.use(remark2rehype, options.rehype?.options);
+  for (const config of mdcConfigs) {
+    processor = await config.unified?.rehype?.(processor) || processor;
+  }
   await useProcessorPlugins(processor, options.rehype?.plugins);
   processor.use(compileHast);
+  for (const config of mdcConfigs) {
+    processor = await config.unified?.post?.(processor) || processor;
+  }
+  const { content, data: frontmatter } = await parseFrontMatter(md);
   const processedFile = await processor.process({ value: content, data: frontmatter });
   const result = processedFile.result;
   const data = Object.assign(

package/dist/runtime/types/config.d.ts

@@ -0,0 +1,45 @@
+import type { Highlighter, HighlighterCore } from 'shiki';
+import type { ShikiTransformer } from 'shiki';
+import type { Processor } from 'unified';
+import type { MdcThemeOptions, HighlighterOptions } from '../highlighter/types';
+export type Awaitable<T> = T | Promise<T>;
+export 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>;
+    };
+}

package/dist/runtime/types/parser.d.ts

@@ -1,5 +1,6 @@
 import type { Options as RehypeOption } from 'remark-rehype';
-import type { Theme, Highlighter } from '../shiki/types';
+import type { RehypeHighlightOption } from '../highlighter/rehype';
+import type { MdcConfig } from './config';
 export interface RemarkPlugin {
     instance?: any;
     options?: Array<any> | Record<string, any>;
@@ -16,10 +17,7 @@ export interface MDCParseOptions {
         options?: RehypeOption;
         plugins?: Record<string, false | RehypePlugin>;
     };
-    highlight?: {
-        theme?: Theme;
-        highlighter?: Highlighter;
-    } | false;
+    highlight?: RehypeHighlightOption | false;
     toc?: {
         /**
          * Maximum heading depth to include in the table of contents.
@@ -27,4 +25,8 @@ export interface MDCParseOptions {
         depth?: number;
         searchDepth?: number;
     };
+    /**
+     * Inline mdc.config.ts
+     */
+    configs?: MdcConfig[];
 }

package/dist/runtime/utils/node.d.ts

@@ -6,7 +6,7 @@ import type { MDCElement, MDCNode } from '../types';
 export declare const TEXT_TAGS: string[];
 /**
  * Check virtual node's tag
- * @param vnode Virtuel node from Vue virtual DOM
+ * @param vnode Virtual node from Vue virtual DOM
  * @param tag tag name
  * @returns `true` it the virtual node match the tag
  */

package/dist/shared/mdc.a6f76af4.d.mts

@@ -0,0 +1,9 @@
+import { BuiltinTheme } from 'shiki';
+
+type MdcThemeOptions = BuiltinTheme | string | Record<string, BuiltinTheme | string>;
+interface HighlighterOptions {
+    highlights?: number[];
+    meta?: string;
+}
+
+export type { HighlighterOptions as H, MdcThemeOptions as M };

package/dist/shared/mdc.a6f76af4.d.ts

@@ -0,0 +1,9 @@
+import { BuiltinTheme } from 'shiki';
+
+type MdcThemeOptions = BuiltinTheme | string | Record<string, BuiltinTheme | string>;
+interface HighlighterOptions {
+    highlights?: number[];
+    meta?: string;
+}
+
+export type { HighlighterOptions as H, MdcThemeOptions as M };

package/dist/types.d.mts

@@ -5,4 +5,4 @@ import type {  } from './module.js'
 
 
 
-export type { default } from './module.js'
+export type { DefaultHighlightLangs, default } from './module.js'

package/dist/types.d.ts

@@ -5,4 +5,4 @@ import type {  } from './module'
 
 
 
-export type { default } from './module'
+export type { DefaultHighlightLangs, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxtjs/mdc",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "Nuxt MDC module",
   "repository": "nuxt-modules/mdc",
   "license": "MIT",
@@ -11,6 +11,11 @@
       "import": "./dist/module.mjs",
       "require": "./dist/module.cjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "require": "./dist/config.cjs"
+    },
     "./runtime": "./dist/runtime/index.mjs",
     "./dist/runtime": "./dist/runtime/index.mjs",
     "./runtime/*": "./dist/runtime/*.mjs",
@@ -21,6 +26,17 @@
   "files": [
     "dist"
   ],
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/*",
+        "./dist/index.d.ts"
+      ],
+      "config": [
+        "./dist/config.d.ts"
+      ]
+    }
+  },
   "scripts": {
     "prepack": "nuxt-module-build prepare; nuxt-module-build",
     "build": "nuxt-module-build prepare; nuxt-module-build build",
@@ -34,11 +50,13 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.9.3",
-    "@types/hast": "^3.0.3",
+    "@nuxt/kit": "^3.10.0",
+    "@shikijs/transformers": "^1.0.0-beta.6",
+    "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.3",
     "@vue/compiler-core": "^3.4.15",
     "consola": "^3.2.3",
+    "debug": "^4.3.4",
     "defu": "^6.1.4",
     "destr": "^2.0.2",
     "detab": "^3.0.2",
@@ -47,7 +65,9 @@
     "mdast-util-to-hast": "^13.1.0",
     "micromark-util-sanitize-uri": "^2.0.0",
     "ohash": "^1.1.3",
-    "property-information": "^6.4.0",
+    "parse5": "^7.1.2",
+    "pathe": "^1.1.2",
+    "property-information": "^6.4.1",
     "rehype-external-links": "^3.0.0",
     "rehype-raw": "^7.0.0",
     "rehype-slug": "^6.0.0",
@@ -55,12 +75,11 @@
     "rehype-sort-attributes": "^5.0.0",
     "remark-emoji": "^4.0.1",
     "remark-gfm": "^4.0.0",
-    "remark-mdc": "^3.0.1",
+    "remark-mdc": "^3.0.2",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.0",
     "scule": "^1.2.0",
-    "shikiji": "^0.9.19",
-    "shikiji-transformers": "^0.9.19",
+    "shiki": "^1.0.0-beta.6",
     "ufo": "^1.3.2",
     "unified": "^11.0.4",
     "unist-builder": "^4.0.0",
@@ -71,19 +90,19 @@
     "@nuxt/devtools": "latest",
     "@nuxt/eslint-config": "^0.2.0",
     "@nuxt/module-builder": "^0.5.5",
-    "@nuxt/schema": "^3.9.3",
-    "@nuxt/test-utils": "^3.10.0",
-    "@nuxt/ui": "^2.12.2",
+    "@nuxt/schema": "^3.10.0",
+    "@nuxt/test-utils": "^3.11.0",
+    "@nuxt/ui": "^2.13.0",
     "@types/mdurl": "^1.0.5",
-    "@types/node": "^20.11.5",
+    "@types/node": "^20.11.16",
     "changelogen": "^0.5.5",
     "eslint": "^8.56.0",
-    "nuxt": "^3.9.3",
+    "nuxt": "^3.10.0",
     "rehype": "^13.0.1",
-    "release-it": "^17.0.1",
-    "vitest": "^1.2.1"
+    "release-it": "^17.0.3",
+    "vitest": "^1.2.2"
   },
-  "packageManager": "pnpm@8.14.1",
+  "packageManager": "pnpm@8.15.1",
   "release-it": {
     "git": {
       "commitMessage": "chore(release): release v${version}"

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

@@ -1,17 +0,0 @@
-import { loadWasm } from "shikiji";
-import { eventHandler, getQuery, lazyEventHandler } from "h3";
-import { useShikiHighlighter } from "./highlighter.mjs";
-import { useRuntimeConfig } from "#imports";
-export default lazyEventHandler(async () => {
-  const { highlight } = useRuntimeConfig().mdc;
-  await loadWasm(
-    (imports) => import("shikiji/onig.wasm").then((mod) => mod.default(imports)).then((exports) => ({ exports }))
-  );
-  const shiki = useShikiHighlighter(highlight);
-  return eventHandler(async (event) => {
-    const { code, lang, theme: themeString, highlights: highlightsString } = getQuery(event);
-    const theme = JSON.parse(themeString);
-    const highlights = highlightsString ? JSON.parse(highlightsString) : void 0;
-    return await shiki.getHighlightedAST(code, lang, theme, { highlights });
-  });
-});

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

@@ -1,5 +0,0 @@
-import type { HighlightResult, HighlighterOptions, Theme } from './types';
-import type { BuiltinLanguage } from 'shikiji';
-export declare const useShikiHighlighter: (opts?: any) => {
-    getHighlightedAST: (code: string, lang: BuiltinLanguage, theme: Theme, opts?: Partial<HighlighterOptions>) => Promise<HighlightResult>;
-};