react-shiki 0.11.1 → 0.11.3

package/README.md

@@ -306,6 +306,7 @@ The core inputs, positional arguments on the hook, props/children on the compone
 | Option              | Type               | Default         | Description                                                                   |
 | ------------------- | ------------------ | --------------- | ----------------------------------------------------------------------------- |
 | `delay`             | `number`           | -               | Minimum time between highlights (in milliseconds), no throttling by default   |
+| `cache`             | `Map`              | -               | Keeps highlighted output across unmounts, see [Caching Across Remounts](#caching-across-remounts) |
 | `engine`            | `'javascript' \| 'oniguruma' \| RegexEngine` | `'oniguruma'` | RegExp engine for syntax highlighting; named engines are created and cached internally |
 | `highlighter`       | `Highlighter \| HighlighterCore` | -  | Custom highlighter instance, required for the core bundle                     |
 | `outputFormat`      | `string`           | `'react'`       | Output format: 'react' for React nodes, 'html' for HTML string, or 'tokens' for Shiki tokens (hook only, experimental) |
@@ -798,6 +799,22 @@ const highlightedCode = useShikiHighlighter(code, "tsx", "github-dark", {
 });
 ```
 
+### Caching Across Remounts
+
+Lists that remount their content, like chat transcripts when switching threads or virtualized lists while scrolling, highlight every code block again by default. Pass a `Map` as `cache` and unchanged blocks paint on their first render instead:
+
+```tsx
+const cache = new Map();
+
+<ShikiHighlighter language="tsx" theme="github-dark" cache={cache}>
+  {code}
+</ShikiHighlighter>
+```
+
+- A block's output is stored when it unmounts, so the partial code of a streaming block is never cached.
+- Entries are keyed by code, language, theme and options, so blocks with different settings can share one cache. Transformers are told apart by `name`, so give blocks with different transformers of the same name their own cache.
+- The cache is yours: keep one per app or per conversation and `clear()` it when that content goes away.
+
 ---
 
 Made with ❤️ by [Bassim (AVGVSTVS96)](https://github.com/AVGVSTVS96)

package/dist/core.d.mts

@@ -1,8 +1,7 @@
-import { a as EngineName, c as HighlighterOptionsFor, d as PreloadLanguage, f as Theme, i as Element, l as Language, m as UseShikiHighlighter, n as isInlineCode, o as HighlightResult, p as Themes, r as rehypeInlineCodeProperty, s as HighlighterOptions, t as ShikiHighlighterProps, u as OutputFormat } from "./component-DlK6KonE.mjs";
+import { a as EngineName, c as HighlighterOptions, d as OutputFormat, f as PreloadLanguage, h as UseShikiHighlighter, i as Element, l as HighlighterOptionsFor, m as Themes, n as rehypeInlineCodeProperty, o as HighlightCache, p as Theme, r as ShikiHighlighterProps, s as HighlightResult, t as isInlineCode, u as Language } from "./plugins-DdjjMnbY.mjs";
 import { LanguageRegistration, TokensResult, createHighlighterCore } from "shiki/core";
 import { createOnigurumaEngine } from "shiki/engine/oniguruma";
 import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/engine/javascript";
-//#region src/core.d.ts
 /**
  * Highlight code with shiki (core bundle)
  *
@@ -36,12 +35,10 @@ import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/en
  *
  * Core bundle (minimal). For plug-and-play: `react-shiki` or `react-shiki/web`
  */
-declare const useShikiHighlighter: UseShikiHighlighter;
+export declare const useShikiHighlighter: UseShikiHighlighter;
 /**
  * ShikiHighlighter component using a custom highlighter.
  * Requires a highlighter to be provided.
  */
-declare const ShikiHighlighter: import("react").ForwardRefExoticComponent<ShikiHighlighterProps & import("react").RefAttributes<HTMLElement>>;
-//#endregion
-export { type Element, type EngineName, type HighlightResult, type HighlighterOptions, type HighlighterOptionsFor, type Language, type LanguageRegistration, type OutputFormat, type PreloadLanguage, ShikiHighlighter, ShikiHighlighter as default, type ShikiHighlighterProps, type Theme, type Themes, type TokensResult, type UseShikiHighlighter, createHighlighterCore, createJavaScriptRawEngine, createJavaScriptRegexEngine, createOnigurumaEngine, isInlineCode, rehypeInlineCodeProperty, useShikiHighlighter };
-//# sourceMappingURL=core.d.mts.map
+export declare const ShikiHighlighter: import("react").ForwardRefExoticComponent<ShikiHighlighterProps & import("react").RefAttributes<HTMLElement>>;
+export { type Element, type EngineName, type HighlightCache, type HighlightResult, type HighlighterOptions, type HighlighterOptionsFor, type Language, type LanguageRegistration, type OutputFormat, type PreloadLanguage, ShikiHighlighter as default, type ShikiHighlighterProps, type Theme, type Themes, type TokensResult, type UseShikiHighlighter, createHighlighterCore, createJavaScriptRawEngine, createJavaScriptRegexEngine, createOnigurumaEngine, isInlineCode, rehypeInlineCodeProperty };

package/dist/core.mjs

@@ -1,8 +1,8 @@
-import { i as useHighlight, n as isInlineCode, r as rehypeInlineCodeProperty, t as createShikiHighlighterComponent } from "./component-Cf8Topxy.mjs";
+import { i as useHighlight, n as rehypeInlineCodeProperty, r as createShikiHighlighterComponent, t as isInlineCode } from "./plugins-C0Uf67_P.mjs";
 import { createHighlighterCore } from "shiki/core";
 import { createOnigurumaEngine } from "shiki/engine/oniguruma";
 import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/engine/javascript";
-//#region src/bundles/core.ts
+// src/bundles/core.ts
 /**
 * Validates that a highlighter is provided for the core bundle.
 * The core bundle requires users to provide their own highlighter instance.
@@ -11,8 +11,7 @@ function validateCoreHighlighter(highlighter) {
 	if (!highlighter) throw new Error("react-shiki/core requires a custom highlighter. Use createHighlighterCore() from react-shiki or switch to react-shiki for plug-and-play usage.");
 	return highlighter;
 }
-//#endregion
-//#region src/core.ts
+// src/core.ts
 /**
 * Highlight code with shiki (core bundle)
 *
@@ -58,7 +57,6 @@ const useShikiHighlighter = (code, lang, themeInput, options = {}) => {
 * Requires a highlighter to be provided.
 */
 const ShikiHighlighter = /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);
-//#endregion
 export { ShikiHighlighter, ShikiHighlighter as default, createHighlighterCore, createJavaScriptRawEngine, createJavaScriptRegexEngine, createOnigurumaEngine, isInlineCode, rehypeInlineCodeProperty, useShikiHighlighter };
 
 //# sourceMappingURL=core.mjs.map

package/dist/core.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"core.mjs","names":[],"sources":["../src/bundles/core.ts","../src/core.ts"],"sourcesContent":["import type { HighlighterCore } from 'shiki';\n\n/**\n * Validates that a highlighter is provided for the core bundle.\n * The core bundle requires users to provide their own highlighter instance.\n */\nexport function validateCoreHighlighter(\n  highlighter: HighlighterCore | undefined\n): HighlighterCore {\n  if (!highlighter) {\n    throw new Error(\n      'react-shiki/core requires a custom highlighter. ' +\n        'Use createHighlighterCore() from react-shiki or switch to react-shiki for plug-and-play usage.'\n    );\n  }\n  return highlighter;\n}\n","import { useHighlight } from './lib/hook';\nimport { validateCoreHighlighter } from './bundles/core';\nimport type { UseShikiHighlighter } from './lib/types';\n\nexport { isInlineCode, rehypeInlineCodeProperty } from './lib/plugins';\n\nimport {\n  createShikiHighlighterComponent,\n  type ShikiHighlighterProps,\n} from './lib/component';\n\nexport type { ShikiHighlighterProps };\n\nexport type {\n  UseShikiHighlighter,\n  Language,\n  PreloadLanguage,\n  Theme,\n  Themes,\n  Element,\n  EngineName,\n  HighlighterOptions,\n  HighlighterOptionsFor,\n  HighlightResult,\n  OutputFormat,\n} from './lib/types';\n\nexport { createHighlighterCore } from 'shiki/core';\nexport { createOnigurumaEngine } from 'shiki/engine/oniguruma';\nexport {\n  createJavaScriptRegexEngine,\n  createJavaScriptRawEngine,\n} from 'shiki/engine/javascript';\n\nexport type { LanguageRegistration, TokensResult } from 'shiki/core';\n\n/**\n * Highlight code with shiki (core bundle)\n *\n * @param code - Code to highlight\n * @param lang - Language (bundled or custom)\n * @param theme - Theme (bundled, multi-theme, or custom)\n * @param options - react-shiki options + shiki options\n * @returns Highlighted code as React elements (default), HTML string, or Shiki tokens, based on `outputFormat`\n *\n * @example\n * ```tsx\n * import { createHighlighterCore, createOnigurumaEngine } from 'react-shiki/core';\n *\n *\n * const highlighter = await createHighlighterCore({\n *   themes: [import('@shikijs/themes/github-light'), import('@shikijs/themes/github-dark')],\n *   langs: [import('@shikijs/langs/typescript')],\n *   engine: createOnigurumaEngine(import('shiki/wasm'))\n * });\n *\n * const highlighted = useShikiHighlighter(\n *   'const x = 1;',\n *   'typescript',\n *   {\n *     light: 'github-light',\n *     dark: 'github-dark'\n *   },\n *   { highlighter }\n * );\n * ```\n *\n * Core bundle (minimal). For plug-and-play: `react-shiki` or `react-shiki/web`\n */\nexport const useShikiHighlighter: UseShikiHighlighter = (\n  code,\n  lang,\n  themeInput,\n  options = {}\n) => {\n  const highlighter = validateCoreHighlighter(options.highlighter);\n\n  return useHighlight(\n    code,\n    lang,\n    themeInput,\n    {\n      ...options,\n      highlighter,\n    },\n    async () => highlighter\n  );\n};\n\n/**\n * ShikiHighlighter component using a custom highlighter.\n * Requires a highlighter to be provided.\n */\nexport const ShikiHighlighter =\n  /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);\nexport default ShikiHighlighter;\n"],"mappings":";;;;;;;;;AAMA,SAAgB,wBACd,aACiB;CACjB,IAAI,CAAC,aACH,MAAM,IAAI,MACR,gJAEF;CAEF,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqDA,MAAa,uBACX,MACA,MACA,YACA,UAAU,CAAC,MACR;CACH,MAAM,cAAc,wBAAwB,QAAQ,WAAW;CAE/D,OAAO,aACL,MACA,MACA,YACA;EACE,GAAG;EACH;CACF,GACA,YAAY,WACd;AACF;;;;;AAMA,MAAa,mBACG,8CAAgC,mBAAmB"}
+{"version":3,"file":"core.mjs","names":[],"sources":["../src/bundles/core.ts","../src/core.ts"],"sourcesContent":["import type { HighlighterCore } from 'shiki';\n\n/**\n * Validates that a highlighter is provided for the core bundle.\n * The core bundle requires users to provide their own highlighter instance.\n */\nexport function validateCoreHighlighter(\n  highlighter: HighlighterCore | undefined\n): HighlighterCore {\n  if (!highlighter) {\n    throw new Error(\n      'react-shiki/core requires a custom highlighter. ' +\n        'Use createHighlighterCore() from react-shiki or switch to react-shiki for plug-and-play usage.'\n    );\n  }\n\n  return highlighter;\n}\n","import { useHighlight } from './lib/hook';\nimport { validateCoreHighlighter } from './bundles/core';\nimport type { UseShikiHighlighter } from './lib/types';\nimport { createShikiHighlighterComponent } from './lib/component';\n// oxlint-disable-next-line unicorn/prefer-export-from -- `export type … from` here makes tsdown fold the core entry's declarations into the shared .d.mts chunk\nimport type { ShikiHighlighterProps } from './lib/component';\n\nexport { isInlineCode, rehypeInlineCodeProperty } from './lib/plugins';\n\nexport type { ShikiHighlighterProps };\n\nexport type {\n  UseShikiHighlighter,\n  Language,\n  PreloadLanguage,\n  Theme,\n  Themes,\n  Element,\n  EngineName,\n  HighlighterOptions,\n  HighlighterOptionsFor,\n  HighlightCache,\n  HighlightResult,\n  OutputFormat,\n} from './lib/types';\n\nexport { createHighlighterCore } from 'shiki/core';\n\nexport { createOnigurumaEngine } from 'shiki/engine/oniguruma';\n\nexport {\n  createJavaScriptRegexEngine,\n  createJavaScriptRawEngine,\n} from 'shiki/engine/javascript';\n\nexport type { LanguageRegistration, TokensResult } from 'shiki/core';\n\n/**\n * Highlight code with shiki (core bundle)\n *\n * @param code - Code to highlight\n * @param lang - Language (bundled or custom)\n * @param theme - Theme (bundled, multi-theme, or custom)\n * @param options - react-shiki options + shiki options\n * @returns Highlighted code as React elements (default), HTML string, or Shiki tokens, based on `outputFormat`\n *\n * @example\n * ```tsx\n * import { createHighlighterCore, createOnigurumaEngine } from 'react-shiki/core';\n *\n *\n * const highlighter = await createHighlighterCore({\n *   themes: [import('@shikijs/themes/github-light'), import('@shikijs/themes/github-dark')],\n *   langs: [import('@shikijs/langs/typescript')],\n *   engine: createOnigurumaEngine(import('shiki/wasm'))\n * });\n *\n * const highlighted = useShikiHighlighter(\n *   'const x = 1;',\n *   'typescript',\n *   {\n *     light: 'github-light',\n *     dark: 'github-dark'\n *   },\n *   { highlighter }\n * );\n * ```\n *\n * Core bundle (minimal). For plug-and-play: `react-shiki` or `react-shiki/web`\n */\nexport const useShikiHighlighter: UseShikiHighlighter = (\n  code,\n  lang,\n  themeInput,\n  options = {}\n) => {\n  const highlighter = validateCoreHighlighter(options.highlighter);\n\n  return useHighlight(\n    code,\n    lang,\n    themeInput,\n    {\n      ...options,\n      highlighter,\n    },\n    async () => highlighter\n  );\n};\n\n/**\n * ShikiHighlighter component using a custom highlighter.\n * Requires a highlighter to be provided.\n */\nexport const ShikiHighlighter =\n  // oxlint-disable-next-line eslint/no-inline-comments -- the #__PURE__ annotation lets bundlers drop the component when only the hook is used\n  /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);\n\nexport default ShikiHighlighter;\n"],"mappings":";;;;;;;;;AAMA,SAAgB,wBACd,aACiB;CACjB,IAAI,CAAC,aACH,MAAM,IAAI,MACR,gJAEF;CAGF,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACqDA,MAAa,uBACX,MACA,MACA,YACA,UAAU,CAAC,MACR;CACH,MAAM,cAAc,wBAAwB,QAAQ,WAAW;CAE/D,OAAO,aACL,MACA,MACA,YACA;EACE,GAAG;EACH;CACF,GACA,YAAY,WACd;AACF;;;;;AAMA,MAAa,mBAEG,8CAAgC,mBAAmB"}

package/dist/{factory-DySLHBEo.mjs → factory-Ds5IsDw-.mjs}

@@ -1,17 +1,16 @@
-import { a as isLoadableLanguage } from "./component-Cf8Topxy.mjs";
+import { a as isLoadableLanguage } from "./plugins-C0Uf67_P.mjs";
 import { createOnigurumaEngine } from "shiki/engine/oniguruma";
-//#region src/bundles/factory.ts
+// src/bundles/factory.ts
 /**
 * Builds a highlighter factory for a Shiki bundle (full or web).
 * Unloadable languages are filtered out so unknown ids fall back to
 * plaintext instead of throwing.
 */
-const bundledHighlighterFactory = (getSingletonHighlighter, bundledLanguages) => (langsToLoad, themesToLoad, engine) => getSingletonHighlighter({
+const bundledHighlighterFactory = (getSingletonHighlighter, bundledLanguages) => async (langsToLoad, themesToLoad, engine) => await getSingletonHighlighter({
 	langs: langsToLoad.filter((lang) => isLoadableLanguage(lang, bundledLanguages)),
 	themes: themesToLoad,
 	engine: engine ?? createOnigurumaEngine(import("shiki/wasm"))
 });
-//#endregion
 export { bundledHighlighterFactory as t };
 
-//# sourceMappingURL=factory-DySLHBEo.mjs.map
+//# sourceMappingURL=factory-Ds5IsDw-.mjs.map

package/dist/{factory-DySLHBEo.mjs.map → factory-Ds5IsDw-.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"factory-DySLHBEo.mjs","names":[],"sources":["../src/bundles/factory.ts"],"sourcesContent":["import { createOnigurumaEngine } from 'shiki/engine/oniguruma';\nimport type {\n  Awaitable,\n  DynamicImportLanguageRegistration,\n  HighlighterCore,\n  RegexEngine,\n} from 'shiki/core';\nimport type {\n  HighlighterFactory,\n  PreloadLanguage,\n  Theme,\n} from '../lib/types';\nimport { isLoadableLanguage } from '../lib/language';\n\ntype GetSingletonHighlighter = (options: {\n  langs: NonNullable<PreloadLanguage>[];\n  themes: Theme[];\n  engine: Awaitable<RegexEngine>;\n}) => Promise<HighlighterCore>;\n\n/**\n * Builds a highlighter factory for a Shiki bundle (full or web).\n * Unloadable languages are filtered out so unknown ids fall back to\n * plaintext instead of throwing.\n */\nexport const bundledHighlighterFactory =\n  (\n    getSingletonHighlighter: GetSingletonHighlighter,\n    bundledLanguages: Record<string, DynamicImportLanguageRegistration>\n  ): HighlighterFactory =>\n  (langsToLoad, themesToLoad, engine) =>\n    getSingletonHighlighter({\n      langs: langsToLoad.filter((lang) =>\n        isLoadableLanguage(lang, bundledLanguages)\n      ),\n      themes: themesToLoad,\n      engine: engine ?? createOnigurumaEngine(import('shiki/wasm')),\n    });\n"],"mappings":";;;;;;;;AAyBA,MAAa,6BAET,yBACA,sBAED,aAAa,cAAc,WAC1B,wBAAwB;CACtB,OAAO,YAAY,QAAQ,SACzB,mBAAmB,MAAM,gBAAgB,CAC3C;CACA,QAAQ;CACR,QAAQ,UAAU,sBAAsB,OAAO,aAAa;AAC9D,CAAC"}
+{"version":3,"file":"factory-Ds5IsDw-.mjs","names":[],"sources":["../src/bundles/factory.ts"],"sourcesContent":["import { createOnigurumaEngine } from 'shiki/engine/oniguruma';\nimport type {\n  Awaitable,\n  DynamicImportLanguageRegistration,\n  HighlighterCore,\n  RegexEngine,\n} from 'shiki/core';\nimport type {\n  HighlighterFactory,\n  PreloadLanguage,\n  Theme,\n} from '../lib/types';\nimport { isLoadableLanguage } from '../lib/language';\n\ntype GetSingletonHighlighter = (options: {\n  langs: NonNullable<PreloadLanguage>[];\n  themes: Theme[];\n  engine: Awaitable<RegexEngine>;\n}) => Promise<HighlighterCore>;\n\n/**\n * Builds a highlighter factory for a Shiki bundle (full or web).\n * Unloadable languages are filtered out so unknown ids fall back to\n * plaintext instead of throwing.\n */\nexport const bundledHighlighterFactory =\n  (\n    getSingletonHighlighter: GetSingletonHighlighter,\n    bundledLanguages: Record<string, DynamicImportLanguageRegistration>\n  ): HighlighterFactory =>\n  async (langsToLoad, themesToLoad, engine) =>\n    await getSingletonHighlighter({\n      langs: langsToLoad.filter((lang) =>\n        isLoadableLanguage(lang, bundledLanguages)\n      ),\n      themes: themesToLoad,\n      engine: engine ?? createOnigurumaEngine(import('shiki/wasm')),\n    });\n"],"mappings":";;;;;;;;AAyBA,MAAa,6BAET,yBACA,qBAEF,OAAO,aAAa,cAAc,WAChC,MAAM,wBAAwB;CAC5B,OAAO,YAAY,QAAQ,SACzB,mBAAmB,MAAM,gBAAgB,CAC3C;CACA,QAAQ;CACR,QAAQ,UAAU,sBAAsB,OAAO,aAAa;AAC9D,CAAC"}

package/dist/index.d.mts

@@ -1,7 +1,6 @@
-import { a as EngineName, c as HighlighterOptionsFor, d as PreloadLanguage, f as Theme, i as Element, l as Language, m as UseShikiHighlighter, n as isInlineCode, o as HighlightResult, p as Themes, r as rehypeInlineCodeProperty, s as HighlighterOptions, t as ShikiHighlighterProps, u as OutputFormat } from "./component-DlK6KonE.mjs";
+import { a as EngineName, c as HighlighterOptions, d as OutputFormat, f as PreloadLanguage, h as UseShikiHighlighter, i as Element, l as HighlighterOptionsFor, m as Themes, n as rehypeInlineCodeProperty, o as HighlightCache, p as Theme, r as ShikiHighlighterProps, s as HighlightResult, t as isInlineCode, u as Language } from "./plugins-DdjjMnbY.mjs";
 import { LanguageRegistration, TokensResult } from "shiki";
 import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/engine/javascript";
-//#region src/index.d.ts
 /**
  * Highlight code with shiki (full bundle)
  *
@@ -25,12 +24,10 @@ import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/en
  *
  * Full bundle (~6.4MB minified, 1.2MB gzipped). For smaller bundles: `react-shiki/web` or `react-shiki/core`
  */
-declare const useShikiHighlighter: UseShikiHighlighter;
+export declare const useShikiHighlighter: UseShikiHighlighter;
 /**
  * ShikiHighlighter component using the full bundle.
  * Includes all languages and themes for maximum compatibility.
  */
-declare const ShikiHighlighter: import("react").ForwardRefExoticComponent<ShikiHighlighterProps & import("react").RefAttributes<HTMLElement>>;
-//#endregion
-export { type Element, type EngineName, type HighlightResult, type HighlighterOptions, type HighlighterOptionsFor, type Language, type LanguageRegistration, type OutputFormat, type PreloadLanguage, ShikiHighlighter, ShikiHighlighter as default, type ShikiHighlighterProps, type Theme, type Themes, type TokensResult, type UseShikiHighlighter, createJavaScriptRawEngine, createJavaScriptRegexEngine, isInlineCode, rehypeInlineCodeProperty, useShikiHighlighter };
-//# sourceMappingURL=index.d.mts.map
+export declare const ShikiHighlighter: import("react").ForwardRefExoticComponent<ShikiHighlighterProps & import("react").RefAttributes<HTMLElement>>;
+export { type Element, type EngineName, type HighlightCache, type HighlightResult, type HighlighterOptions, type HighlighterOptionsFor, type Language, type LanguageRegistration, type OutputFormat, type PreloadLanguage, ShikiHighlighter as default, type ShikiHighlighterProps, type Theme, type Themes, type TokensResult, type UseShikiHighlighter, createJavaScriptRawEngine, createJavaScriptRegexEngine, isInlineCode, rehypeInlineCodeProperty };

package/dist/index.mjs

@@ -1,15 +1,14 @@
-import { i as useHighlight, n as isInlineCode, r as rehypeInlineCodeProperty, t as createShikiHighlighterComponent } from "./component-Cf8Topxy.mjs";
-import { t as bundledHighlighterFactory } from "./factory-DySLHBEo.mjs";
+import { i as useHighlight, n as rehypeInlineCodeProperty, r as createShikiHighlighterComponent, t as isInlineCode } from "./plugins-C0Uf67_P.mjs";
+import { t as bundledHighlighterFactory } from "./factory-Ds5IsDw-.mjs";
 import { bundledLanguages, getSingletonHighlighter } from "shiki";
 import { createJavaScriptRawEngine, createJavaScriptRegexEngine } from "shiki/engine/javascript";
-//#region src/bundles/full.ts
+// src/bundles/full.ts
 /**
 * Highlighter factory for the full Shiki bundle: every language and
 * theme, largest size, maximum compatibility.
 */
 const createFullHighlighter = bundledHighlighterFactory(getSingletonHighlighter, bundledLanguages);
-//#endregion
-//#region src/index.ts
+// src/index.ts
 /**
 * Highlight code with shiki (full bundle)
 *
@@ -39,7 +38,6 @@ const useShikiHighlighter = (code, lang, themeInput, options = {}) => useHighlig
 * Includes all languages and themes for maximum compatibility.
 */
 const ShikiHighlighter = /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);
-//#endregion
 export { ShikiHighlighter, ShikiHighlighter as default, createJavaScriptRawEngine, createJavaScriptRegexEngine, isInlineCode, rehypeInlineCodeProperty, useShikiHighlighter };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/bundles/full.ts","../src/index.ts"],"sourcesContent":["import { getSingletonHighlighter, bundledLanguages } from 'shiki';\nimport { bundledHighlighterFactory } from './factory';\n\n/**\n * Highlighter factory for the full Shiki bundle: every language and\n * theme, largest size, maximum compatibility.\n */\nexport const createFullHighlighter = bundledHighlighterFactory(\n  getSingletonHighlighter,\n  bundledLanguages\n);\n","import { useHighlight } from './lib/hook';\nimport { createFullHighlighter } from './bundles/full';\nimport type { UseShikiHighlighter } from './lib/types';\n\nexport { isInlineCode, rehypeInlineCodeProperty } from './lib/plugins';\n\nimport {\n  createShikiHighlighterComponent,\n  type ShikiHighlighterProps,\n} from './lib/component';\n\nexport type { ShikiHighlighterProps };\n\nexport type {\n  UseShikiHighlighter,\n  Language,\n  PreloadLanguage,\n  Theme,\n  Themes,\n  Element,\n  EngineName,\n  HighlighterOptions,\n  HighlighterOptionsFor,\n  HighlightResult,\n  OutputFormat,\n} from './lib/types';\n\nexport {\n  createJavaScriptRegexEngine,\n  createJavaScriptRawEngine,\n} from 'shiki/engine/javascript';\n\nexport type { LanguageRegistration, TokensResult } from 'shiki';\n\n/**\n * Highlight code with shiki (full bundle)\n *\n * @param code - Code to highlight\n * @param lang - Language (bundled or custom)\n * @param theme - Theme (bundled, multi-theme, or custom)\n * @param options - react-shiki options + shiki options\n * @returns Highlighted code as React elements (default), HTML string, or Shiki tokens, based on `outputFormat`\n *\n * @example\n * ```tsx\n * const highlighted = useShikiHighlighter(\n *   'const x = 1;',\n *   'typescript',\n *   {\n *     light: 'github-light',\n *     dark: 'github-dark'\n *   }\n * );\n * ```\n *\n * Full bundle (~6.4MB minified, 1.2MB gzipped). For smaller bundles: `react-shiki/web` or `react-shiki/core`\n */\nexport const useShikiHighlighter: UseShikiHighlighter = (\n  code,\n  lang,\n  themeInput,\n  options = {}\n) => useHighlight(code, lang, themeInput, options, createFullHighlighter);\n\n/**\n * ShikiHighlighter component using the full bundle.\n * Includes all languages and themes for maximum compatibility.\n */\nexport const ShikiHighlighter =\n  /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);\nexport default ShikiHighlighter;\n"],"mappings":";;;;;;;;;AAOA,MAAa,wBAAwB,0BACnC,yBACA,gBACF;;;;;;;;;;;;;;;;;;;;;;;;;;AC+CA,MAAa,uBACX,MACA,MACA,YACA,UAAU,CAAC,MACR,aAAa,MAAM,MAAM,YAAY,SAAS,qBAAqB;;;;;AAMxE,MAAa,mBACG,8CAAgC,mBAAmB"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/bundles/full.ts","../src/index.ts"],"sourcesContent":["import { getSingletonHighlighter, bundledLanguages } from 'shiki';\nimport { bundledHighlighterFactory } from './factory';\n\n/**\n * Highlighter factory for the full Shiki bundle: every language and\n * theme, largest size, maximum compatibility.\n */\nexport const createFullHighlighter = bundledHighlighterFactory(\n  getSingletonHighlighter,\n  bundledLanguages\n);\n","import { useHighlight } from './lib/hook';\nimport { createFullHighlighter } from './bundles/full';\nimport type { UseShikiHighlighter } from './lib/types';\nimport { createShikiHighlighterComponent } from './lib/component';\n// oxlint-disable-next-line unicorn/prefer-export-from -- `export type … from` here makes tsdown fold the core entry's declarations into the shared .d.mts chunk\nimport type { ShikiHighlighterProps } from './lib/component';\n\nexport { isInlineCode, rehypeInlineCodeProperty } from './lib/plugins';\n\nexport type { ShikiHighlighterProps };\n\nexport type {\n  UseShikiHighlighter,\n  Language,\n  PreloadLanguage,\n  Theme,\n  Themes,\n  Element,\n  EngineName,\n  HighlighterOptions,\n  HighlighterOptionsFor,\n  HighlightCache,\n  HighlightResult,\n  OutputFormat,\n} from './lib/types';\n\nexport {\n  createJavaScriptRegexEngine,\n  createJavaScriptRawEngine,\n} from 'shiki/engine/javascript';\n\nexport type { LanguageRegistration, TokensResult } from 'shiki';\n\n/**\n * Highlight code with shiki (full bundle)\n *\n * @param code - Code to highlight\n * @param lang - Language (bundled or custom)\n * @param theme - Theme (bundled, multi-theme, or custom)\n * @param options - react-shiki options + shiki options\n * @returns Highlighted code as React elements (default), HTML string, or Shiki tokens, based on `outputFormat`\n *\n * @example\n * ```tsx\n * const highlighted = useShikiHighlighter(\n *   'const x = 1;',\n *   'typescript',\n *   {\n *     light: 'github-light',\n *     dark: 'github-dark'\n *   }\n * );\n * ```\n *\n * Full bundle (~6.4MB minified, 1.2MB gzipped). For smaller bundles: `react-shiki/web` or `react-shiki/core`\n */\nexport const useShikiHighlighter: UseShikiHighlighter = (\n  code,\n  lang,\n  themeInput,\n  options = {}\n) => useHighlight(code, lang, themeInput, options, createFullHighlighter);\n\n/**\n * ShikiHighlighter component using the full bundle.\n * Includes all languages and themes for maximum compatibility.\n */\nexport const ShikiHighlighter =\n  // oxlint-disable-next-line eslint/no-inline-comments -- the #__PURE__ annotation lets bundlers drop the component when only the hook is used\n  /*#__PURE__*/ createShikiHighlighterComponent(useShikiHighlighter);\n\nexport default ShikiHighlighter;\n"],"mappings":";;;;;;;;;AAOA,MAAa,wBAAwB,0BACnC,yBACA,gBACF;;;;;;;;;;;;;;;;;;;;;;;;;AC8CA,MAAa,uBACX,MACA,MACA,YACA,UAAU,CAAC,MACR,aAAa,MAAM,MAAM,YAAY,SAAS,qBAAqB;;;;;AAMxE,MAAa,mBAEG,8CAAgC,mBAAmB"}

package/dist/{component-Cf8Topxy.mjs → plugins-C0Uf67_P.mjs}

@@ -4,9 +4,9 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 import { dequal } from "dequal";
 import { guessEmbeddedLanguages, isSpecialLang } from "shiki/core";
-import { visit } from "unist-util-visit";
 import { clsx } from "clsx";
-//#region src/lib/utils.ts
+import { visit } from "unist-util-visit";
+// src/lib/utils.ts
 /**
 * Returns a referentially stable version of `value` that only updates when content changes.
 * Uses reference equality as a fast path and deep comparison to prevent unnecessary updates.
@@ -35,14 +35,11 @@ const throttleHighlighting = (performHighlight, timeoutControl, throttleMs) => {
 		timeoutControl.current.nextAllowedTime = Date.now() + throttleMs;
 	}, delay);
 };
-//#endregion
-//#region src/styles/component.css?inline
+// src/styles/component.css?inline
 var component_default = ":where(.rs-root){position:relative}:where(.rs-root.rs-default-styles pre){border-radius:.5rem;padding-block:1.25rem;padding-inline:1.5rem;overflow:auto}:where(.rs-root .rs-language-label){z-index:1;letter-spacing:-.05em;color:#6b7280d9;font-family:monospace;font-size:.75rem;position:absolute;top:.5rem;right:.75rem}\n";
-//#endregion
-//#region src/styles/features.css?inline
+// src/styles/features.css?inline
 var features_default = ":where(.rs-has-line-numbers){counter-reset:line-number calc(var(--line-start,1) - 1)}:where(.rs-has-line-numbers .rs-line-number):before{counter-increment:line-number;content:counter(line-number);box-sizing:content-box;min-width:var(--rs-line-numbers-width,2ch);padding-left:var(--rs-line-numbers-padding-left,0ch);padding-right:var(--rs-line-numbers-padding-right,2ch);color:var(--rs-line-numbers-foreground,#6b728080);font-size:var(--rs-line-numbers-font-size,inherit);font-weight:var(--rs-line-numbers-font-weight,inherit);line-height:var(--rs-line-numbers-line-height,inherit);font-family:var(--rs-line-numbers-font-family,inherit);opacity:var(--rs-line-numbers-opacity,1);user-select:none;pointer-events:none;justify-content:flex-end;align-items:flex-start;display:inline-flex}:where(.rs-has-highlighted-lines){width:fit-content;min-width:100%;display:block}:where(.rs-highlighted-line){--_rs-hl-background:var(--rs-highlighted-line-background,color-mix(in srgb, currentColor 10%, transparent));background-color:var(--_rs-hl-background);width:100%;min-height:1lh;display:inline-block}:where(.rs-default-styles .rs-highlighted-line){border-image:linear-gradient(var(--_rs-hl-background) 0 0) fill 0 / 0 / 0 100vw;background-color:#0000}:where(.rs-has-line-numbers .rs-highlighted-line):before{color:var(--rs-highlighted-line-number-foreground,color-mix(in srgb, currentColor 65%, transparent))}\n";
-//#endregion
-//#region src/lib/styles.ts
+// src/lib/styles.ts
 const injected = /* @__PURE__ */ new Set();
 const useStyleInsertionEffect = React.useInsertionEffect ?? React.useLayoutEffect;
 const inject = (css, key) => {
@@ -71,10 +68,12 @@ const useFeatureStyles = (enabled) => {
 		if (enabled) inject(features_default, "features");
 	}, [enabled]);
 };
-//#endregion
-//#region src/lib/language.ts
+// src/lib/language.ts
 const FALLBACK_LANGUAGE = "plaintext";
-const toArray = (value) => value == null ? [] : Array.isArray(value) ? value : [value];
+const toArray = (value) => {
+	if (value == null) return [];
+	return Array.isArray(value) ? value : [value];
+};
 const isDynamicLanguage = (lang) => typeof lang === "function" || lang instanceof Promise || Array.isArray(lang) || typeof lang === "object" && lang != null && "default" in lang;
 const isRegistration = (lang) => typeof lang === "object" && lang != null && !isDynamicLanguage(lang);
 /** Dedupe identity: strings and registrations by value, dynamic inputs by reference */
@@ -144,17 +143,15 @@ const getEmbeddedLanguages = (code, languageId, highlighter) => {
 	const bundled = highlighter.getBundledLanguages();
 	return guessEmbeddedLanguages(code, languageId).flatMap((language) => bundled[language] ?? []);
 };
-//#endregion
-//#region src/lib/theme.ts
+// src/lib/theme.ts
 const DEFAULT_THEMES = {
 	light: "github-light",
 	dark: "github-dark"
 };
 const isTextmateTheme = (value) => {
 	if (typeof value !== "object" || value === null) return false;
-	const v = value;
-	const hasTokens = Array.isArray(v.tokenColors) || Array.isArray(v.settings);
-	const hasIdentity = typeof v.name === "string" || typeof v.type === "string";
+	const hasTokens = "tokenColors" in value && Array.isArray(value.tokenColors) || "settings" in value && Array.isArray(value.settings);
+	const hasIdentity = "name" in value && typeof value.name === "string" || "type" in value && typeof value.type === "string";
 	return hasTokens && hasIdentity;
 };
 function resolveTheme(themeInput) {
@@ -179,12 +176,17 @@ function resolveTheme(themeInput) {
 		themesToLoad: validEntries.map(([, value]) => value)
 	};
 }
-//#endregion
-//#region src/lib/engine.ts
+// src/lib/engine.ts
 const engines = /* @__PURE__ */ new Map();
 const loaders = {
-	javascript: () => import("shiki/engine/javascript").then((m) => m.createJavaScriptRegexEngine()),
-	oniguruma: () => import("shiki/engine/oniguruma").then((m) => m.createOnigurumaEngine(import("shiki/wasm")))
+	javascript: async () => {
+		const { createJavaScriptRegexEngine } = await import("shiki/engine/javascript");
+		return createJavaScriptRegexEngine();
+	},
+	oniguruma: async () => {
+		const { createOnigurumaEngine } = await import("shiki/engine/oniguruma");
+		return await createOnigurumaEngine(import("shiki/wasm"));
+	}
 };
 /**
 * Resolves a named engine to a lazily created, cached instance.
@@ -195,17 +197,15 @@ const loaders = {
 */
 const resolveEngine = (engine) => {
 	if (typeof engine !== "string") return engine;
-	const load = loaders[engine];
-	if (!load) throw new Error(`[react-shiki] unknown engine '${engine}', expected 'javascript' or 'oniguruma'`);
+	if (!Object.hasOwn(loaders, engine)) throw new Error(`[react-shiki] unknown engine '${engine}', expected 'javascript' or 'oniguruma'`);
 	const cached = engines.get(engine);
 	if (cached) return cached;
-	const instance = load();
+	const instance = loaders[engine]();
 	instance.catch(() => engines.delete(engine));
 	engines.set(engine, instance);
 	return instance;
 };
-//#endregion
-//#region src/lib/transformers.ts
+// src/lib/transformers.ts
 const toLineNumberSet = (lineNumbers) => new Set(lineNumbers.filter(Number.isInteger));
 /**
 * Creates a transformer that enables line numbers display
@@ -249,8 +249,7 @@ function highlightedLinesTransformer(lineNumbers, startLine = 1) {
 		}
 	};
 }
-//#endregion
-//#region src/lib/options.ts
+// src/lib/options.ts
 const buildThemeOptions = (resolvedTheme, defaultColor, cssVariablePrefix) => {
 	if (resolvedTheme.isMulti) return {
 		themes: resolvedTheme.themes,
@@ -261,7 +260,7 @@ const buildThemeOptions = (resolvedTheme, defaultColor, cssVariablePrefix) => {
 };
 const buildShikiOptions = (languageId, resolvedTheme, options) => {
 	const { delay, customLanguages, preloadLanguages, outputFormat, highlighter, langAlias, engine, defaultColor, cssVariablePrefix, showLineNumbers, startingLineNumber, highlightLineNumbers, transformers: userTransformers, ...shikiPassthrough } = options;
-	const transformers = [...userTransformers || []];
+	const transformers = [...userTransformers ?? []];
 	if (showLineNumbers) transformers.push(lineNumbersTransformer(startingLineNumber));
 	if (highlightLineNumbers?.length) transformers.push(highlightedLinesTransformer(highlightLineNumbers, startingLineNumber));
 	return {
@@ -271,8 +270,7 @@ const buildShikiOptions = (languageId, resolvedTheme, options) => {
 		transformers
 	};
 };
-//#endregion
-//#region src/lib/hook.ts
+// src/lib/hook.ts
 async function highlight(code, resolved, opts, factory) {
 	const { languageId, langsToLoad, themesToLoad, shikiOptions } = resolved;
 	const format = opts.outputFormat ?? "react";
@@ -297,12 +295,19 @@ async function highlight(code, resolved, opts, factory) {
 	};
 	return (outputs[format] ?? outputs.react)();
 }
-const useHighlight = (code, lang, themeInput, options = {}, highlighterFactory) => {
-	const [highlightedCode, setHighlightedCode] = useState(null);
-	useFeatureStyles(Boolean(options.showLineNumbers || options.highlightLineNumbers?.length));
+const readCache = (cache, key) => {
+	if (!key) return null;
+	const cached = cache?.get(key);
+	return cached === void 0 || cached === "" ? null : cached;
+};
+const useHighlight = (code, lang, themeInput, optionsInput, highlighterFactory) => {
+	const { cache, ...rest } = optionsInput ?? {};
+	const cacheRef = useRef(cache);
+	cacheRef.current = cache;
+	useFeatureStyles(Boolean(rest.showLineNumbers || rest.highlightLineNumbers?.length));
 	const stableLang = useStableValue(lang);
 	const stableTheme = useStableValue(themeInput);
-	const stableOpts = useStableValue(options);
+	const stableOpts = useStableValue(rest);
 	const resolved = useMemo(() => {
 		const { languageId, langsToLoad } = resolveLanguage(stableLang, stableOpts.customLanguages, stableOpts.langAlias, stableOpts.preloadLanguages);
 		const theme = resolveTheme(stableTheme);
@@ -318,6 +323,27 @@ const useHighlight = (code, lang, themeInput, options = {}, highlighterFactory)
 		stableTheme,
 		stableOpts
 	]);
+	const hasCache = Boolean(cache);
+	const cacheScope = useMemo(() => hasCache ? JSON.stringify([
+		stableOpts.outputFormat ?? "react",
+		resolved.shikiOptions,
+		stableOpts.startingLineNumber,
+		stableOpts.highlightLineNumbers
+	]) : void 0, [
+		hasCache,
+		resolved,
+		stableOpts
+	]);
+	const cacheKey = cacheScope && `${cacheScope}\n${code}`;
+	const [highlightedCode, setHighlightedCode] = useState(() => readCache(cache, cacheKey));
+	const shown = useRef({
+		key: cacheKey,
+		result: highlightedCode
+	});
+	useEffect(() => () => {
+		const { key, result } = shown.current;
+		if (key && result !== null && result !== "") cacheRef.current?.set(key, result);
+	}, []);
 	const requestIdRef = useRef(0);
 	const timeoutControl = useRef({
 		nextAllowedTime: 0,
@@ -327,29 +353,85 @@ const useHighlight = (code, lang, themeInput, options = {}, highlighterFactory)
 	highlighterFactoryRef.current = highlighterFactory;
 	useEffect(() => {
 		const requestId = ++requestIdRef.current;
-		if (!resolved.languageId) return;
+		const timeouts = timeoutControl.current;
+		const show = (result) => {
+			shown.current = {
+				key: cacheKey,
+				result
+			};
+			setHighlightedCode(result);
+		};
 		const run = async () => {
 			try {
 				const result = await highlight(code, resolved, stableOpts, highlighterFactoryRef.current);
-				if (requestId === requestIdRef.current) setHighlightedCode(result);
+				if (requestId === requestIdRef.current) show(result);
 			} catch (error) {
 				console.error("[react-shiki] highlight failed", error);
 			}
 		};
-		if (stableOpts.delay) throttleHighlighting(run, timeoutControl, stableOpts.delay);
+		const cached = readCache(cacheRef.current, cacheKey);
+		if (!resolved.languageId) return () => {
+			clearTimeout(timeouts.timeoutId);
+		};
+		if (cached !== null) {
+			if (shown.current.result !== cached) show(cached);
+		} else if (stableOpts.delay) throttleHighlighting(run, timeoutControl, stableOpts.delay);
 		else run();
 		return () => {
-			clearTimeout(timeoutControl.current.timeoutId);
+			clearTimeout(timeouts.timeoutId);
 		};
 	}, [
 		code,
+		cacheKey,
 		resolved,
 		stableOpts
 	]);
 	return highlightedCode;
 };
-//#endregion
-//#region src/lib/plugins.ts
+// src/lib/component.tsx
+let warnedTokensOutputFormat = false;
+/**
+* The component's props exclude `outputFormat: 'tokens'`, but plain-JS
+* callers can still pass it. Tokens are not renderable React children,
+* so fall back to 'react' instead of crashing the render.
+*/
+const resolveOutputFormat = (outputFormat) => {
+	if (outputFormat !== "tokens") return outputFormat;
+	if (!warnedTokensOutputFormat) {
+		warnedTokensOutputFormat = true;
+		console.warn("[react-shiki] outputFormat 'tokens' is only supported by the useShikiHighlighter hook, falling back to 'react'");
+	}
+	return "react";
+};
+/**
+* Base ShikiHighlighter component factory.
+* This creates a component that uses the provided hook implementation.
+*/
+const createShikiHighlighterComponent = (useShikiHighlighterImpl) => forwardRef(({ language, theme, addDefaultStyles = true, style, langStyle, className, langClassName, showLanguage = true, children: code, as: Element = "div", outputFormat, ...options }, ref) => {
+	useComponentStyles();
+	const displayLanguageId = typeof language === "object" ? language.name || null : language?.trim() || null;
+	const highlightedCode = useShikiHighlighterImpl(code, language, theme, {
+		...options,
+		outputFormat: resolveOutputFormat(outputFormat)
+	});
+	return /* @__PURE__ */ jsxs(Element, {
+		ref,
+		"data-testid": "shiki-container",
+		"data-slot": "container",
+		className: clsx("rs-root", "not-prose", addDefaultStyles && "rs-default-styles", className),
+		style,
+		children: [showLanguage && displayLanguageId ? /* @__PURE__ */ jsx("span", {
+			"data-slot": "language-label",
+			className: clsx("rs-language-label", langClassName),
+			style: langStyle,
+			children: displayLanguageId
+		}) : null, typeof highlightedCode === "string" ? /* @__PURE__ */ jsx("div", {
+			"data-slot": "content",
+			dangerouslySetInnerHTML: { __html: highlightedCode }
+		}) : highlightedCode]
+	});
+});
+// src/lib/plugins.ts
 /**
 * Rehype plugin to add an 'inline' property to <code> elements
 * Sets 'inline' property to true if the <code> is not within a <pre> tag
@@ -374,55 +456,8 @@ function rehypeInlineCodeProperty() {
 * const isInline = node && isInlineCode(node: Element)
 */
 const isInlineCode = (node) => {
-	return !(node.children || []).filter((child) => child.type === "text").map((child) => child.value).join("").includes("\n");
-};
-//#endregion
-//#region src/lib/component.tsx
-let warnedTokensOutputFormat = false;
-/**
-* The component's props exclude `outputFormat: 'tokens'`, but plain-JS
-* callers can still pass it. Tokens are not renderable React children,
-* so fall back to 'react' instead of crashing the render.
-*/
-const resolveOutputFormat = (outputFormat) => {
-	if (outputFormat !== "tokens") return outputFormat;
-	if (!warnedTokensOutputFormat) {
-		warnedTokensOutputFormat = true;
-		console.warn("[react-shiki] outputFormat 'tokens' is only supported by the useShikiHighlighter hook, falling back to 'react'");
-	}
-	return "react";
-};
-/**
-* Base ShikiHighlighter component factory.
-* This creates a component that uses the provided hook implementation.
-*/
-const createShikiHighlighterComponent = (useShikiHighlighterImpl) => {
-	return forwardRef(({ language, theme, addDefaultStyles = true, style, langStyle, className, langClassName, showLanguage = true, children: code, as: Element = "div", outputFormat, ...options }, ref) => {
-		useComponentStyles();
-		const displayLanguageId = typeof language === "object" ? language.name || null : language?.trim() || null;
-		const highlightedCode = useShikiHighlighterImpl(code, language, theme, {
-			...options,
-			outputFormat: resolveOutputFormat(outputFormat)
-		});
-		return /* @__PURE__ */ jsxs(Element, {
-			ref,
-			"data-testid": "shiki-container",
-			"data-slot": "container",
-			className: clsx("rs-root", "not-prose", addDefaultStyles && "rs-default-styles", className),
-			style,
-			children: [showLanguage && displayLanguageId ? /* @__PURE__ */ jsx("span", {
-				"data-slot": "language-label",
-				className: clsx("rs-language-label", langClassName),
-				style: langStyle,
-				children: displayLanguageId
-			}) : null, typeof highlightedCode === "string" ? /* @__PURE__ */ jsx("div", {
-				"data-slot": "content",
-				dangerouslySetInnerHTML: { __html: highlightedCode }
-			}) : highlightedCode]
-		});
-	});
+	return !(node.children ?? []).filter((child) => child.type === "text").map((child) => child.value).join("").includes("\n");
 };
-//#endregion
-export { isLoadableLanguage as a, useHighlight as i, isInlineCode as n, rehypeInlineCodeProperty as r, createShikiHighlighterComponent as t };
+export { isLoadableLanguage as a, useHighlight as i, rehypeInlineCodeProperty as n, createShikiHighlighterComponent as r, isInlineCode as t };
 
-//# sourceMappingURL=component-Cf8Topxy.mjs.map
+//# sourceMappingURL=plugins-C0Uf67_P.mjs.map