@shikijs/rehype 1.0.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Pine Wu
+Copyright (c) 2023 Anthony Fu <https://github.com/antfu>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# rehype-shiki
+
+[rehype](https://github.com/rehypejs/rehype) plugin for [shiki](https://github.com/shikijs/shiki).
+
+[Documentation](https://shiki.style/packages/rehype)
+
+## License
+
+MIT

package/dist/core.d.mts

@@ -0,0 +1,52 @@
+import { CodeOptionsThemes, TransformerOptions, CodeOptionsMeta, HighlighterGeneric } from 'shiki/core';
+import { Element, Root } from 'hast';
+import { BuiltinTheme } from 'shiki';
+import { Plugin } from 'unified';
+
+interface MapLike<K = any, V = any> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+}
+interface RehypeShikiExtraOptions {
+    /**
+     * Add `highlighted` class to lines defined in after codeblock
+     *
+     * @deprecated Use [transformerNotationHighlight](https://shiki.style/packages/transformers#transformernotationhighlight) instead
+     * @default false
+     */
+    highlightLines?: boolean | string;
+    /**
+     * Add `language-*` class to code element
+     *
+     * @default false
+     */
+    addLanguageClass?: 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;
+declare module 'hast' {
+    interface Data {
+        meta?: string;
+    }
+    interface Properties {
+        metastring?: string;
+    }
+}
+declare const rehypeShikiFromHighlighter: Plugin<[HighlighterGeneric<any, any>, RehypeShikiCoreOptions], Root>;
+
+export { type MapLike, type RehypeShikiCoreOptions, type RehypeShikiExtraOptions, rehypeShikiFromHighlighter as default };

package/dist/core.d.ts

@@ -0,0 +1,52 @@
+import { CodeOptionsThemes, TransformerOptions, CodeOptionsMeta, HighlighterGeneric } from 'shiki/core';
+import { Element, Root } from 'hast';
+import { BuiltinTheme } from 'shiki';
+import { Plugin } from 'unified';
+
+interface MapLike<K = any, V = any> {
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+}
+interface RehypeShikiExtraOptions {
+    /**
+     * Add `highlighted` class to lines defined in after codeblock
+     *
+     * @deprecated Use [transformerNotationHighlight](https://shiki.style/packages/transformers#transformernotationhighlight) instead
+     * @default false
+     */
+    highlightLines?: boolean | string;
+    /**
+     * Add `language-*` class to code element
+     *
+     * @default false
+     */
+    addLanguageClass?: 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;
+declare module 'hast' {
+    interface Data {
+        meta?: string;
+    }
+    interface Properties {
+        metastring?: string;
+    }
+}
+declare const rehypeShikiFromHighlighter: Plugin<[HighlighterGeneric<any, any>, RehypeShikiCoreOptions], Root>;
+
+export { type MapLike, type RehypeShikiCoreOptions, type RehypeShikiExtraOptions, rehypeShikiFromHighlighter as default };

package/dist/core.mjs

@@ -0,0 +1,79 @@
+import { addClassToHast } from 'shiki/core';
+import { toString } from 'hast-util-to-string';
+import { visit } from 'unist-util-visit';
+import { transformerMetaHighlight } from '@shikijs/transformers';
+
+const rehypeShikiFromHighlighter = function(highlighter, options) {
+  const {
+    highlightLines = false,
+    addLanguageClass = false,
+    parseMetaString,
+    cache,
+    ...rest
+  } = options;
+  const prefix = "language-";
+  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)
+        return;
+      const classes = head.properties.className;
+      if (!Array.isArray(classes))
+        return;
+      const language = classes.find(
+        (d) => typeof d === "string" && d.startsWith(prefix)
+      );
+      if (typeof language !== "string")
+        return;
+      const code = toString(head);
+      const cachedValue = cache?.get(code);
+      if (cachedValue) {
+        parent.children.splice(index, 1, ...cachedValue);
+        return;
+      }
+      const metaString = head.data?.meta ?? head.properties.metastring ?? "";
+      const meta = parseMetaString?.(metaString, node, tree) || {};
+      const codeOptions = {
+        ...rest,
+        lang: language.slice(prefix.length),
+        meta: {
+          ...rest.meta,
+          ...meta,
+          __raw: metaString
+        }
+      };
+      if (addLanguageClass) {
+        codeOptions.transformers || (codeOptions.transformers = []);
+        codeOptions.transformers.push({
+          name: "rehype-shiki:code-language-class",
+          code(node2) {
+            addClassToHast(node2, language);
+            return node2;
+          }
+        });
+      }
+      if (highlightLines && typeof metaString === "string") {
+        codeOptions.transformers || (codeOptions.transformers = []);
+        codeOptions.transformers.push(
+          transformerMetaHighlight({
+            className: highlightLines === true ? "highlighted" : highlightLines
+          })
+        );
+      }
+      try {
+        const fragment = highlighter.codeToHast(code, codeOptions);
+        cache?.set(code, fragment.children);
+        parent.children.splice(index, 1, ...fragment.children);
+      } catch (error) {
+        if (options.onError)
+          options.onError(error);
+        else
+          throw error;
+      }
+    });
+  };
+};
+
+export { rehypeShikiFromHighlighter as default };

package/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { LanguageInput } from 'shiki/core';
+import { BuiltinLanguage } from 'shiki';
+import { Plugin } from 'unified';
+import { Root } from 'hast';
+import { RehypeShikiCoreOptions } from './core.mjs';
+
+type RehypeShikiOptions = RehypeShikiCoreOptions & {
+    /**
+     * Language names to include.
+     *
+     * @default Object.keys(bundledLanguages)
+     */
+    langs?: Array<LanguageInput | BuiltinLanguage>;
+};
+declare const rehypeShiki: Plugin<[RehypeShikiOptions], Root>;
+
+export { type RehypeShikiOptions, rehypeShiki as default };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { LanguageInput } from 'shiki/core';
+import { BuiltinLanguage } from 'shiki';
+import { Plugin } from 'unified';
+import { Root } from 'hast';
+import { RehypeShikiCoreOptions } from './core.js';
+
+type RehypeShikiOptions = RehypeShikiCoreOptions & {
+    /**
+     * Language names to include.
+     *
+     * @default Object.keys(bundledLanguages)
+     */
+    langs?: Array<LanguageInput | BuiltinLanguage>;
+};
+declare const rehypeShiki: Plugin<[RehypeShikiOptions], Root>;
+
+export { type RehypeShikiOptions, rehypeShiki as default };

package/dist/index.mjs

@@ -0,0 +1,25 @@
+import { bundledLanguages, getHighlighter } from 'shiki';
+import rehypeShikiFromHighlighter from './core.mjs';
+import 'shiki/core';
+import 'hast-util-to-string';
+import 'unist-util-visit';
+import '@shikijs/transformers';
+
+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 ctx = this;
+  let promise;
+  return async function(tree) {
+    if (!promise) {
+      promise = getHighlighter({
+        themes: themeNames,
+        langs
+      }).then((highlighter) => rehypeShikiFromHighlighter.call(ctx, highlighter, options));
+    }
+    const handler = await promise;
+    return handler(tree);
+  };
+};
+
+export { rehypeShiki as default };

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@shikijs/rehype",
+  "type": "module",
+  "version": "1.0.0-beta.0",
+  "description": "rehype integration for shiki",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/shikijs/shiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shikijs/shiki.git",
+    "directory": "packages/rehype"
+  },
+  "bugs": "https://github.com/shikijs/shiki/issues",
+  "keywords": [
+    "shiki",
+    "rehype"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./core": {
+      "types": "./dist/core.d.mts",
+      "default": "./dist/core.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "typesVersions": {
+    "*": {
+      "core": [
+        "./dist/core.d.mts"
+      ],
+      "*": [
+        "./dist/*",
+        "./*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@types/hast": "^3.0.3",
+    "hast-util-to-string": "^3.0.0",
+    "unified": "^11.0.4",
+    "unist-util-visit": "^5.0.0",
+    "@shikijs/transformers": "1.0.0-beta.0",
+    "shiki": "1.0.0-beta.0"
+  },
+  "devDependencies": {
+    "rehype-raw": "^7.0.0",
+    "rehype-stringify": "^10.0.0",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.0"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub"
+  }
+}