@shikijs/rehype 1.14.1 → 1.15.0

package/dist/core.d.mts

@@ -1,54 +1,10 @@
-import { CodeOptionsThemes, TransformerOptions, CodeOptionsMeta, CodeToHastOptionsCommon, HighlighterGeneric } from 'shiki/core';
-import { Element, Root } from 'hast';
-import { BuiltinTheme } from 'shiki';
+import { HighlighterGeneric } from 'shiki/core';
+import { Root } from 'hast';
 import { Transformer } from 'unified';
+import { R as RehypeShikiCoreOptions } from './shared/rehype.198b1df4.mjs';
+export { M as MapLike, a as RehypeShikiExtraOptions } from './shared/rehype.198b1df4.mjs';
+import '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
-     */
-    fallbackLanguage?: string;
-    /**
-     * `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;
-    /**
-     * Custom map to cache transformed codeToHast result
-     *
-     * @default undefined
-     */
-    cache?: MapLike;
-    /**
-     * 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'>;
 declare function rehypeShikiFromHighlighter(highlighter: HighlighterGeneric<any, any>, options: RehypeShikiCoreOptions): Transformer<Root, Root>;
 
-export { type MapLike, type RehypeShikiCoreOptions, type RehypeShikiExtraOptions, rehypeShikiFromHighlighter as default };
+export { RehypeShikiCoreOptions, rehypeShikiFromHighlighter as default };

package/dist/core.d.ts

@@ -1,54 +1,10 @@
-import { CodeOptionsThemes, TransformerOptions, CodeOptionsMeta, CodeToHastOptionsCommon, HighlighterGeneric } from 'shiki/core';
-import { Element, Root } from 'hast';
-import { BuiltinTheme } from 'shiki';
+import { HighlighterGeneric } from 'shiki/core';
+import { Root } from 'hast';
 import { Transformer } from 'unified';
+import { R as RehypeShikiCoreOptions } from './shared/rehype.198b1df4.js';
+export { M as MapLike, a as RehypeShikiExtraOptions } from './shared/rehype.198b1df4.js';
+import '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
-     */
-    fallbackLanguage?: string;
-    /**
-     * `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;
-    /**
-     * Custom map to cache transformed codeToHast result
-     *
-     * @default undefined
-     */
-    cache?: MapLike;
-    /**
-     * 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'>;
 declare function rehypeShikiFromHighlighter(highlighter: HighlighterGeneric<any, any>, options: RehypeShikiCoreOptions): Transformer<Root, Root>;
 
-export { type MapLike, type RehypeShikiCoreOptions, type RehypeShikiExtraOptions, rehypeShikiFromHighlighter as default };
+export { RehypeShikiCoreOptions, rehypeShikiFromHighlighter as default };

package/dist/core.mjs

@@ -1,6 +1,27 @@
 import { toString } from 'hast-util-to-string';
 import { visit } from 'unist-util-visit';
 
+const InlineCodeProcessors = {
+  "tailing-curly-colon": ({ node, getLanguage, highlight }) => {
+    const raw = toString(node);
+    const match = raw.match(/(.+)\{:([\w-]+)\}$/);
+    if (!match)
+      return;
+    const lang = getLanguage(match[2]);
+    if (!lang)
+      return;
+    const code = match[1] ?? raw;
+    const fragment = highlight(lang, code);
+    if (!fragment)
+      return;
+    const head = fragment.children[0];
+    if (head.type === "element" && head.tagName === "pre") {
+      head.tagName = "span";
+    }
+    return fragment;
+  }
+};
+
 const languagePrefix = "language-";
 function rehypeShikiFromHighlighter(highlighter, options) {
   const langs = highlighter.getLoadedLanguages();
@@ -12,63 +33,89 @@ function rehypeShikiFromHighlighter(highlighter, options) {
     fallbackLanguage,
     onError,
     stripEndNewline = true,
+    inline = false,
     ...rest
   } = options;
+  function getLanguage(lang = defaultLanguage) {
+    if (lang && fallbackLanguage && !langs.includes(lang))
+      return fallbackLanguage;
+    return lang;
+  }
+  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;
+    }
+  }
+  function processPre(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;
+    const lang = getLanguage(
+      typeof languageClass === "string" ? languageClass.slice(languagePrefix.length) : void 0
+    );
+    if (!lang)
+      return;
+    const code = toString(head);
+    const metaString = head.data?.meta ?? head.properties.metastring?.toString() ?? "";
+    const meta = parseMetaString?.(metaString, node, tree) || {};
+    return highlight(lang, code, metaString, meta);
+  }
   return function(tree) {
     visit(tree, "element", (node, index, parent) => {
-      if (!parent || index == null || node.tagName !== "pre")
-        return;
-      const head = node.children[0];
-      if (!head || head.type !== "element" || head.tagName !== "code" || !head.properties) {
+      if (!parent || index == null)
         return;
-      }
-      const classes = head.properties.className;
-      const languageClass = Array.isArray(classes) ? classes.find(
-        (d) => typeof d === "string" && d.startsWith(languagePrefix)
-      ) : void 0;
-      let lang = typeof languageClass === "string" ? languageClass.slice(languagePrefix.length) : defaultLanguage;
-      if (!lang)
-        return;
-      if (fallbackLanguage && !langs.includes(lang))
-        lang = fallbackLanguage;
-      let code = toString(head);
-      if (stripEndNewline && code.endsWith("\n"))
-        code = code.slice(0, -1);
-      const cachedValue = cache?.get(code);
-      if (cachedValue) {
-        parent.children.splice(index, 1, ...cachedValue);
-        return;
-      }
-      const metaString = head.data?.meta ?? head.properties.metastring?.toString() ?? "";
-      const meta = parseMetaString?.(metaString, node, tree) || {};
-      const codeOptions = {
-        ...rest,
-        lang,
-        meta: {
-          ...rest.meta,
-          ...meta,
-          __raw: metaString
+      if (node.tagName === "pre") {
+        const result = processPre(tree, node);
+        if (result) {
+          parent.children.splice(index, 1, ...result.children);
         }
-      };
-      if (addLanguageClass) {
-        codeOptions.transformers || (codeOptions.transformers = []);
-        codeOptions.transformers.push({
-          name: "rehype-shiki:code-language-class",
-          code(node2) {
-            this.addClassToHast(node2, `${languagePrefix}${lang}`);
-            return node2;
-          }
-        });
+        return "skip";
       }
-      try {
-        const fragment = highlighter.codeToHast(code, codeOptions);
-        cache?.set(code, fragment.children);
-        parent.children.splice(index, 1, ...fragment.children);
-      } catch (error) {
-        if (onError)
-          onError(error);
-        else
-          throw error;
+      if (node.tagName === "code" && inline) {
+        const result = InlineCodeProcessors[inline]?.({ node, getLanguage, highlight });
+        if (result) {
+          parent.children.splice(index, 1, ...result.children);
+        }
       }
     });
   };

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { LanguageInput } from 'shiki/core';
 import { BuiltinLanguage } from 'shiki';
 import { Plugin } from 'unified';
 import { Root } from 'hast';
-import { RehypeShikiCoreOptions } from './core.mjs';
+import { R as RehypeShikiCoreOptions } from './shared/rehype.198b1df4.mjs';
 
 type RehypeShikiOptions = RehypeShikiCoreOptions & {
     /**

package/dist/index.d.ts

@@ -2,7 +2,7 @@ import { LanguageInput } from 'shiki/core';
 import { BuiltinLanguage } from 'shiki';
 import { Plugin } from 'unified';
 import { Root } from 'hast';
-import { RehypeShikiCoreOptions } from './core.js';
+import { R as RehypeShikiCoreOptions } from './shared/rehype.198b1df4.js';
 
 type RehypeShikiOptions = RehypeShikiCoreOptions & {
     /**

package/dist/shared/rehype.198b1df4.d.mts

@@ -0,0 +1,61 @@
+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
+     */
+    fallbackLanguage?: string;
+    /**
+     * `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 };

package/dist/shared/rehype.198b1df4.d.ts

@@ -0,0 +1,61 @@
+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
+     */
+    fallbackLanguage?: string;
+    /**
+     * `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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shikijs/rehype",
   "type": "module",
-  "version": "1.14.1",
+  "version": "1.15.0",
   "description": "rehype integration for shiki",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -49,8 +49,8 @@
     "hast-util-to-string": "^3.0.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",
-    "shiki": "1.14.1",
-    "@shikijs/transformers": "1.14.1"
+    "@shikijs/transformers": "1.15.0",
+    "shiki": "1.15.0"
   },
   "devDependencies": {
     "rehype-raw": "^7.0.0",