@shikijs/rehype 3.23.0 → 4.0.1

package/dist/core.d.mts

@@ -1,10 +1,9 @@
-import { HighlighterGeneric } from '@shikijs/types';
-import { Root } from 'hast';
-import { Transformer } from 'unified';
-import { R as RehypeShikiCoreOptions } from './shared/rehype.DcMmi29I.mjs';
-export { M as MapLike, a as RehypeShikiExtraOptions } from './shared/rehype.DcMmi29I.mjs';
-import 'shiki';
+import { n as RehypeShikiCoreOptions, r as RehypeShikiExtraOptions, t as MapLike } from "./types-Wi2EaRpk.mjs";
+import { HighlighterGeneric } from "@shikijs/types";
+import { Root } from "hast";
+import { Transformer } from "unified";
 
+//#region src/core.d.ts
 declare function rehypeShikiFromHighlighter(highlighter: HighlighterGeneric<any, any>, options: RehypeShikiCoreOptions): Transformer<Root, Root>;
-
-export { RehypeShikiCoreOptions, rehypeShikiFromHighlighter as default };
+//#endregion
+export { MapLike, RehypeShikiCoreOptions, RehypeShikiExtraOptions, rehypeShikiFromHighlighter as default };

package/dist/core.mjs

@@ -1,167 +1,92 @@
-import { isSpecialLang } from 'shiki/core';
-import { visit } from 'unist-util-visit';
-import { toString } from 'hast-util-to-string';
-
-const InlineCodeHandlers = {
-  "tailing-curly-colon": (_tree, node) => {
-    const raw = toString(node);
-    const match = raw.match(/(.+)\{:([\w-]+)\}$/);
-    if (!match)
-      return;
-    return {
-      type: "inline",
-      code: match[1] ?? raw,
-      lang: match.at(2)
-    };
-  }
-};
-const languagePrefix$1 = "language-";
-const PreHandler = (_tree, node) => {
-  const head = node.children[0];
-  if (!head || head.type !== "element" || head.tagName !== "code" || !head.properties) {
-    return;
-  }
-  const classes = head.properties.className;
-  const languageClass = Array.isArray(classes) ? classes.find(
-    (d) => typeof d === "string" && d.startsWith(languagePrefix$1)
-  ) : void 0;
-  return {
-    type: "pre",
-    lang: typeof languageClass === "string" ? languageClass.slice(languagePrefix$1.length) : void 0,
-    code: toString(head),
-    meta: head.data?.meta ?? head.properties.metastring?.toString() ?? ""
-  };
-};
+import { n as PreHandler, t as InlineCodeHandlers } from "./handlers-DyniaZhL.mjs";
+import { isSpecialLang } from "shiki/core";
+import { visit } from "unist-util-visit";
 
+//#region src/core.ts
 const languagePrefix = "language-";
 function rehypeShikiFromHighlighter(highlighter, options) {
-  const {
-    addLanguageClass = false,
-    parseMetaString,
-    cache,
-    defaultLanguage,
-    fallbackLanguage,
-    onError,
-    stripEndNewline = true,
-    inline = false,
-    lazy = false,
-    ...rest
-  } = options;
-  function highlight(lang, code, metaString = "", meta = {}) {
-    const cacheKey = `${lang}:${metaString}:${code}`;
-    const cachedValue = cache?.get(cacheKey);
-    if (cachedValue) {
-      return cachedValue;
-    }
-    const codeOptions = {
-      ...rest,
-      lang,
-      meta: {
-        ...rest.meta,
-        ...meta,
-        __raw: metaString
-      }
-    };
-    if (addLanguageClass) {
-      codeOptions.transformers = [
-        ...codeOptions.transformers ?? [],
-        {
-          name: "rehype-shiki:code-language-class",
-          code(node) {
-            this.addClassToHast(node, `${languagePrefix}${lang}`);
-            return node;
-          }
-        }
-      ];
-    }
-    if (stripEndNewline && code.endsWith("\n"))
-      code = code.slice(0, -1);
-    try {
-      const fragment = highlighter.codeToHast(code, codeOptions);
-      cache?.set(cacheKey, fragment);
-      return fragment;
-    } catch (error) {
-      if (onError)
-        onError(error);
-      else
-        throw error;
-    }
-  }
-  return (tree) => {
-    const queue = [];
-    visit(tree, "element", (node, index, parent) => {
-      let handler;
-      if (!parent || index == null)
-        return;
-      if (node.tagName === "pre") {
-        handler = PreHandler;
-      } else if (node.tagName === "code" && inline) {
-        handler = InlineCodeHandlers[inline];
-      } else {
-        return;
-      }
-      const parsed = handler(tree, node);
-      if (!parsed)
-        return;
-      let lang;
-      let lazyLoad = false;
-      if (!parsed.lang) {
-        lang = defaultLanguage;
-      } else if (highlighter.getLoadedLanguages().includes(parsed.lang) || isSpecialLang(parsed.lang)) {
-        lang = parsed.lang;
-      } else if (lazy) {
-        lazyLoad = true;
-        lang = parsed.lang;
-      } else if (fallbackLanguage) {
-        lang = fallbackLanguage;
-      }
-      if (!lang)
-        return;
-      const meta = parsed.meta ? parseMetaString?.(parsed.meta, node, tree) : void 0;
-      const processNode = (targetLang) => {
-        const fragment = highlight(targetLang, parsed.code, parsed.meta, meta ?? {});
-        if (!fragment)
-          return;
-        if (parsed.type === "inline") {
-          const head = fragment.children[0];
-          if (head.type === "element" && head.tagName === "pre") {
-            head.tagName = "span";
-          }
-        }
-        parent.children[index] = fragment;
-      };
-      if (lazyLoad) {
-        try {
-          queue.push(
-            highlighter.loadLanguage(lang).then(() => processNode(lang)).catch((error) => {
-              if (fallbackLanguage) {
-                processNode(fallbackLanguage);
-              } else if (onError) {
-                onError(error);
-              } else {
-                throw error;
-              }
-            })
-          );
-        } catch (error) {
-          if (fallbackLanguage)
-            return processNode(fallbackLanguage);
-          else if (onError)
-            onError(error);
-          else throw error;
-        }
-      } else {
-        processNode(lang);
-      }
-      return "skip";
-    });
-    if (queue.length > 0) {
-      async function run() {
-        await Promise.all(queue);
-      }
-      return run();
-    }
-  };
+	const { addLanguageClass = false, parseMetaString, cache, defaultLanguage, fallbackLanguage, onError, stripEndNewline = true, inline = false, lazy = false, ...rest } = options;
+	function highlight(lang, code, metaString = "", meta = {}) {
+		const cacheKey = `${lang}:${metaString}:${code}`;
+		const cachedValue = cache?.get(cacheKey);
+		if (cachedValue) return cachedValue;
+		const codeOptions = {
+			...rest,
+			lang,
+			meta: {
+				...rest.meta,
+				...meta,
+				__raw: metaString
+			}
+		};
+		if (addLanguageClass) codeOptions.transformers = [...codeOptions.transformers ?? [], {
+			name: "rehype-shiki:code-language-class",
+			code(node) {
+				this.addClassToHast(node, `${languagePrefix}${lang}`);
+				return node;
+			}
+		}];
+		if (stripEndNewline && code.endsWith("\n")) code = code.slice(0, -1);
+		try {
+			const fragment = highlighter.codeToHast(code, codeOptions);
+			cache?.set(cacheKey, fragment);
+			return fragment;
+		} catch (error) {
+			if (onError) onError(error);
+			else throw error;
+		}
+	}
+	return (tree) => {
+		const queue = [];
+		visit(tree, "element", (node, index, parent) => {
+			let handler;
+			if (!parent || index == null) return;
+			if (node.tagName === "pre") handler = PreHandler;
+			else if (node.tagName === "code" && inline) handler = InlineCodeHandlers[inline];
+			else return;
+			const parsed = handler(tree, node);
+			if (!parsed) return;
+			let lang;
+			let lazyLoad = false;
+			if (!parsed.lang) lang = defaultLanguage;
+			else if (highlighter.getLoadedLanguages().includes(parsed.lang) || isSpecialLang(parsed.lang)) lang = parsed.lang;
+			else if (lazy) {
+				lazyLoad = true;
+				lang = parsed.lang;
+			} else if (fallbackLanguage) lang = fallbackLanguage;
+			if (!lang) return;
+			const meta = parsed.meta ? parseMetaString?.(parsed.meta, node, tree) : void 0;
+			const processNode = (targetLang) => {
+				const fragment = highlight(targetLang, parsed.code, parsed.meta, meta ?? {});
+				if (!fragment) return;
+				if (parsed.type === "inline") {
+					const head = fragment.children[0];
+					if (head.type === "element" && head.tagName === "pre") head.tagName = "span";
+				}
+				parent.children[index] = fragment;
+			};
+			if (lazyLoad) try {
+				queue.push(highlighter.loadLanguage(lang).then(() => processNode(lang)).catch((error) => {
+					if (fallbackLanguage) processNode(fallbackLanguage);
+					else if (onError) onError(error);
+					else throw error;
+				}));
+			} catch (error) {
+				if (fallbackLanguage) return processNode(fallbackLanguage);
+				else if (onError) onError(error);
+				else throw error;
+			}
+			else processNode(lang);
+			return "skip";
+		});
+		if (queue.length > 0) {
+			async function run() {
+				await Promise.all(queue);
+			}
+			return run();
+		}
+	};
 }
 
-export { rehypeShikiFromHighlighter as default };
+//#endregion
+export { rehypeShikiFromHighlighter as default };

package/dist/handlers-DyniaZhL.mjs

@@ -0,0 +1,29 @@
+import { toString } from "hast-util-to-string";
+
+//#region src/handlers.ts
+const InlineCodeHandlers = { "tailing-curly-colon": (_tree, node) => {
+	const raw = toString(node);
+	const match = raw.match(/(.+)\{:([\w-]+)\}$/);
+	if (!match) return;
+	return {
+		type: "inline",
+		code: match[1] ?? raw,
+		lang: match.at(2)
+	};
+} };
+const languagePrefix = "language-";
+const PreHandler = (_tree, node) => {
+	const head = node.children[0];
+	if (!head || head.type !== "element" || head.tagName !== "code" || !head.properties) return;
+	const classes = head.properties.className;
+	const languageClass = Array.isArray(classes) ? classes.find((d) => typeof d === "string" && d.startsWith(languagePrefix)) : void 0;
+	return {
+		type: "pre",
+		lang: typeof languageClass === "string" ? languageClass.slice(9) : void 0,
+		code: toString(head),
+		meta: head.data?.meta ?? head.properties.metastring?.toString() ?? ""
+	};
+};
+
+//#endregion
+export { PreHandler as n, InlineCodeHandlers as t };

package/dist/index.d.mts

@@ -1,23 +1,23 @@
-import { LanguageInput } from '@shikijs/types';
-import { Root } from 'hast';
-import { BuiltinLanguage } from 'shiki';
-import { Plugin } from 'unified';
-import { R as RehypeShikiCoreOptions } from './shared/rehype.DcMmi29I.mjs';
+import { n as RehypeShikiCoreOptions } from "./types-Wi2EaRpk.mjs";
+import { BuiltinLanguage } from "shiki";
+import { LanguageInput } from "@shikijs/types";
+import { Root } from "hast";
+import { Plugin } from "unified";
 
+//#region src/index.d.ts
 type RehypeShikiOptions = RehypeShikiCoreOptions & {
-    /**
-     * Language names to include.
-     *
-     * @default Object.keys(bundledLanguages)
-     */
-    langs?: Array<LanguageInput | BuiltinLanguage>;
-    /**
-     * Alias of languages
-     * @example { 'my-lang': 'javascript' }
-     */
-    langAlias?: Record<string, string>;
+  /**
+   * Language names to include.
+   *
+   * @default Object.keys(bundledLanguages)
+   */
+  langs?: Array<LanguageInput | BuiltinLanguage>;
+  /**
+   * Alias of languages
+   * @example { 'my-lang': 'javascript' }
+   */
+  langAlias?: Record<string, string>;
 };
 declare const rehypeShiki: Plugin<[RehypeShikiOptions], Root>;
-
-export { rehypeShiki as default };
-export type { RehypeShikiOptions };
+//#endregion
+export { RehypeShikiOptions, rehypeShiki as default };

package/dist/index.mjs

@@ -1,25 +1,21 @@
-import { bundledLanguages, getSingletonHighlighter } from 'shiki';
-import rehypeShikiFromHighlighter from './core.mjs';
-import 'shiki/core';
-import 'unist-util-visit';
-import 'hast-util-to-string';
+import rehypeShikiFromHighlighter from "./core.mjs";
+import { bundledLanguages, getSingletonHighlighter } from "shiki";
 
+//#region src/index.ts
 const rehypeShiki = function(options = {}) {
-  const themeNames = ("themes" in options ? Object.values(options.themes) : [options.theme]).filter(Boolean);
-  const langs = options.langs || Object.keys(bundledLanguages);
-  const langAlias = options.langAlias || {};
-  let getHandler;
-  return async (tree) => {
-    if (!getHandler) {
-      getHandler = getSingletonHighlighter({
-        themes: themeNames,
-        langs,
-        langAlias
-      }).then((highlighter) => rehypeShikiFromHighlighter.call(this, highlighter, options));
-    }
-    const handler = await getHandler;
-    return handler(tree);
-  };
+	const themeNames = ("themes" in options ? Object.values(options.themes) : [options.theme]).filter(Boolean);
+	const langs = options.langs || Object.keys(bundledLanguages);
+	const langAlias = options.langAlias || {};
+	let getHandler;
+	return async (tree) => {
+		if (!getHandler) getHandler = getSingletonHighlighter({
+			themes: themeNames,
+			langs,
+			langAlias
+		}).then((highlighter) => rehypeShikiFromHighlighter.call(this, highlighter, options));
+		return (await getHandler)(tree);
+	};
 };
 
-export { rehypeShiki as default };
+//#endregion
+export { rehypeShiki as default };

package/dist/types-Wi2EaRpk.d.mts

@@ -0,0 +1,69 @@
+import { BuiltinTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, TransformerOptions } from "shiki";
+import { Element, Root } from "hast";
+
+//#region src/types.d.ts
+interface MapLike<K = any, V = any> {
+  get: (key: K) => V | undefined;
+  set: (key: K, value: V) => this;
+}
+interface RehypeShikiExtraOptions {
+  /**
+   * Add `language-*` class to code element
+   *
+   * @default false
+   */
+  addLanguageClass?: boolean;
+  /**
+   * The default language to use when is not specified
+   */
+  defaultLanguage?: string;
+  /**
+   * The fallback language to use when specified language is not loaded, or not included in the bundle
+   */
+  fallbackLanguage?: string;
+  /**
+   * Load languages and themes on-demand.
+   * When enable, this would make requires the unified pipeline to be async.
+   *
+   * @default false
+   */
+  lazy?: boolean;
+  /**
+   * `mdast-util-to-hast` adds a newline to the end of code blocks
+   *
+   * This option strips that newline from the code block
+   *
+   * @default true
+   * @see https://github.com/syntax-tree/mdast-util-to-hast/blob/f511a93817b131fb73419bf7d24d73a5b8b0f0c2/lib/handlers/code.js#L22
+   */
+  stripEndNewline?: boolean;
+  /**
+   * Custom meta string parser
+   * Return an object to merge with `meta`
+   */
+  parseMetaString?: (metaString: string, node: Element, tree: Root) => Record<string, any> | undefined | null;
+  /**
+   * Highlight inline code blocks
+   *
+   * - `false`: disable inline code block highlighting
+   * - `tailing-curly-colon`: highlight with `\`code{:lang}\``
+   *
+   * @see https://shiki.style/packages/rehype#inline-code
+   * @default false
+   */
+  inline?: false | 'tailing-curly-colon';
+  /**
+   * Custom map to cache transformed codeToHast result
+   *
+   * @default undefined
+   */
+  cache?: MapLike<string, Root>;
+  /**
+   * Chance to handle the error
+   * If not provided, the error will be thrown
+   */
+  onError?: (error: unknown) => void;
+}
+type RehypeShikiCoreOptions = CodeOptionsThemes<BuiltinTheme> & TransformerOptions & CodeOptionsMeta & RehypeShikiExtraOptions & Omit<CodeToHastOptionsCommon, 'lang'>;
+//#endregion
+export { RehypeShikiCoreOptions as n, RehypeShikiExtraOptions as r, MapLike as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/rehype",
   "type": "module",
-  "version": "3.23.0",
+  "version": "4.0.1",
   "description": "rehype integration for shiki",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -27,23 +27,26 @@
   "files": [
     "dist"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "dependencies": {
     "@types/hast": "^3.0.4",
     "hast-util-to-string": "^3.0.1",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.1.0",
-    "@shikijs/types": "3.23.0",
-    "shiki": "3.23.0"
+    "shiki": "4.0.1",
+    "@shikijs/types": "4.0.1"
   },
   "devDependencies": {
     "rehype-raw": "^7.0.0",
     "rehype-stringify": "^10.0.1",
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
-    "@shikijs/transformers": "3.23.0"
+    "@shikijs/transformers": "4.0.1"
   },
   "scripts": {
-    "build": "unbuild",
-    "dev": "unbuild --stub"
+    "build": "tsdown",
+    "dev": "tsdown --watch"
   }
 }

package/dist/shared/rehype.DcMmi29I.d.mts

@@ -1,68 +0,0 @@
-import { Element, Root } from 'hast';
-import { CodeOptionsThemes, BuiltinTheme, TransformerOptions, CodeOptionsMeta, CodeToHastOptionsCommon } from 'shiki';
-
-interface MapLike<K = any, V = any> {
-    get: (key: K) => V | undefined;
-    set: (key: K, value: V) => this;
-}
-interface RehypeShikiExtraOptions {
-    /**
-     * Add `language-*` class to code element
-     *
-     * @default false
-     */
-    addLanguageClass?: boolean;
-    /**
-     * The default language to use when is not specified
-     */
-    defaultLanguage?: string;
-    /**
-     * The fallback language to use when specified language is not loaded, or not included in the bundle
-     */
-    fallbackLanguage?: string;
-    /**
-     * Load languages and themes on-demand.
-     * When enable, this would make requires the unified pipeline to be async.
-     *
-     * @default false
-     */
-    lazy?: boolean;
-    /**
-     * `mdast-util-to-hast` adds a newline to the end of code blocks
-     *
-     * This option strips that newline from the code block
-     *
-     * @default true
-     * @see https://github.com/syntax-tree/mdast-util-to-hast/blob/f511a93817b131fb73419bf7d24d73a5b8b0f0c2/lib/handlers/code.js#L22
-     */
-    stripEndNewline?: boolean;
-    /**
-     * Custom meta string parser
-     * Return an object to merge with `meta`
-     */
-    parseMetaString?: (metaString: string, node: Element, tree: Root) => Record<string, any> | undefined | null;
-    /**
-     * Highlight inline code blocks
-     *
-     * - `false`: disable inline code block highlighting
-     * - `tailing-curly-colon`: highlight with `\`code{:lang}\``
-     *
-     * @see https://shiki.style/packages/rehype#inline-code
-     * @default false
-     */
-    inline?: false | 'tailing-curly-colon';
-    /**
-     * Custom map to cache transformed codeToHast result
-     *
-     * @default undefined
-     */
-    cache?: MapLike<string, Root>;
-    /**
-     * Chance to handle the error
-     * If not provided, the error will be thrown
-     */
-    onError?: (error: unknown) => void;
-}
-type RehypeShikiCoreOptions = CodeOptionsThemes<BuiltinTheme> & TransformerOptions & CodeOptionsMeta & RehypeShikiExtraOptions & Omit<CodeToHastOptionsCommon, 'lang'>;
-
-export type { MapLike as M, RehypeShikiCoreOptions as R, RehypeShikiExtraOptions as a };