@astrojs/mdx 0.19.1 → 0.19.2

package/src/index.ts

@@ -1,226 +0,0 @@
-import { markdownConfigDefaults } from '@astrojs/markdown-remark';
-import { toRemarkInitializeAstroData } from '@astrojs/markdown-remark/dist/internal.js';
-import { compile as mdxCompile } from '@mdx-js/mdx';
-import type { PluggableList } from '@mdx-js/mdx/lib/core.js';
-import mdxPlugin, { type Options as MdxRollupPluginOptions } from '@mdx-js/rollup';
-import type { AstroIntegration, ContentEntryType, HookParameters } from 'astro';
-import { parse as parseESM } from 'es-module-lexer';
-import fs from 'node:fs/promises';
-import { fileURLToPath } from 'node:url';
-import type { Options as RemarkRehypeOptions } from 'remark-rehype';
-import { SourceMapGenerator } from 'source-map';
-import { VFile } from 'vfile';
-import type { Plugin as VitePlugin } from 'vite';
-import { getRehypePlugins, getRemarkPlugins, recmaInjectImportMetaEnvPlugin } from './plugins.js';
-import { getFileInfo, ignoreStringPlugins, parseFrontmatter } from './utils.js';
-
-export type MdxOptions = Omit<typeof markdownConfigDefaults, 'remarkPlugins' | 'rehypePlugins'> & {
-	extendMarkdownConfig: boolean;
-	recmaPlugins: PluggableList;
-	// Markdown allows strings as remark and rehype plugins.
-	// This is not supported by the MDX compiler, so override types here.
-	remarkPlugins: PluggableList;
-	rehypePlugins: PluggableList;
-	remarkRehype: RemarkRehypeOptions;
-};
-
-type SetupHookParams = HookParameters<'astro:config:setup'> & {
-	// `addPageExtension` and `contentEntryType` are not a public APIs
-	// Add type defs here
-	addPageExtension: (extension: string) => void;
-	addContentEntryType: (contentEntryType: ContentEntryType) => void;
-};
-
-export default function mdx(partialMdxOptions: Partial<MdxOptions> = {}): AstroIntegration {
-	return {
-		name: '@astrojs/mdx',
-		hooks: {
-			'astro:config:setup': async (params) => {
-				const { updateConfig, config, addPageExtension, addContentEntryType, command } =
-					params as SetupHookParams;
-
-				addPageExtension('.mdx');
-				addContentEntryType({
-					extensions: ['.mdx'],
-					async getEntryInfo({ fileUrl, contents }: { fileUrl: URL; contents: string }) {
-						const parsed = parseFrontmatter(contents, fileURLToPath(fileUrl));
-						return {
-							data: parsed.data,
-							body: parsed.content,
-							slug: parsed.data.slug,
-							rawData: parsed.matter,
-						};
-					},
-					contentModuleTypes: await fs.readFile(
-						new URL('../template/content-module-types.d.ts', import.meta.url),
-						'utf-8'
-					),
-				});
-
-				const extendMarkdownConfig =
-					partialMdxOptions.extendMarkdownConfig ?? defaultMdxOptions.extendMarkdownConfig;
-
-				const mdxOptions = applyDefaultOptions({
-					options: partialMdxOptions,
-					defaults: markdownConfigToMdxOptions(
-						extendMarkdownConfig ? config.markdown : markdownConfigDefaults
-					),
-				});
-
-				const mdxPluginOpts: MdxRollupPluginOptions = {
-					remarkPlugins: await getRemarkPlugins(mdxOptions, config),
-					rehypePlugins: getRehypePlugins(mdxOptions),
-					recmaPlugins: mdxOptions.recmaPlugins,
-					remarkRehypeOptions: mdxOptions.remarkRehype,
-					jsx: true,
-					jsxImportSource: 'astro',
-					// Note: disable `.md` (and other alternative extensions for markdown files like `.markdown`) support
-					format: 'mdx',
-					mdExtensions: [],
-				};
-
-				let importMetaEnv: Record<string, any> = {
-					SITE: config.site,
-				};
-
-				updateConfig({
-					vite: {
-						plugins: [
-							{
-								enforce: 'pre',
-								...mdxPlugin(mdxPluginOpts),
-								configResolved(resolved) {
-									importMetaEnv = { ...importMetaEnv, ...resolved.env };
-								},
-								// Override transform to alter code before MDX compilation
-								// ex. inject layouts
-								async transform(_, id) {
-									if (!id.endsWith('mdx')) return;
-
-									// Read code from file manually to prevent Vite from parsing `import.meta.env` expressions
-									const { fileId } = getFileInfo(id, config);
-									const code = await fs.readFile(fileId, 'utf-8');
-
-									const { data: frontmatter, content: pageContent } = parseFrontmatter(code, id);
-									const compiled = await mdxCompile(new VFile({ value: pageContent, path: id }), {
-										...mdxPluginOpts,
-										elementAttributeNameCase: 'html',
-										remarkPlugins: [
-											// Ensure `data.astro` is available to all remark plugins
-											toRemarkInitializeAstroData({ userFrontmatter: frontmatter }),
-											...(mdxPluginOpts.remarkPlugins ?? []),
-										],
-										recmaPlugins: [
-											...(mdxPluginOpts.recmaPlugins ?? []),
-											() => recmaInjectImportMetaEnvPlugin({ importMetaEnv }),
-										],
-										SourceMapGenerator: config.vite.build?.sourcemap
-											? SourceMapGenerator
-											: undefined,
-									});
-
-									return {
-										code: escapeViteEnvReferences(String(compiled.value)),
-										map: compiled.map,
-									};
-								},
-							},
-							{
-								name: '@astrojs/mdx-postprocess',
-								// These transforms must happen *after* JSX runtime transformations
-								transform(code, id) {
-									if (!id.endsWith('.mdx')) return;
-
-									const [moduleImports, moduleExports] = parseESM(code);
-
-									// Fragment import should already be injected, but check just to be safe.
-									const importsFromJSXRuntime = moduleImports
-										.filter(({ n }) => n === 'astro/jsx-runtime')
-										.map(({ ss, se }) => code.substring(ss, se));
-									const hasFragmentImport = importsFromJSXRuntime.some((statement) =>
-										/[\s,{](Fragment,|Fragment\s*})/.test(statement)
-									);
-									if (!hasFragmentImport) {
-										code = 'import { Fragment } from "astro/jsx-runtime"\n' + code;
-									}
-
-									const { fileUrl, fileId } = getFileInfo(id, config);
-									if (!moduleExports.find(({ n }) => n === 'url')) {
-										code += `\nexport const url = ${JSON.stringify(fileUrl)};`;
-									}
-									if (!moduleExports.find(({ n }) => n === 'file')) {
-										code += `\nexport const file = ${JSON.stringify(fileId)};`;
-									}
-									if (!moduleExports.find(({ n }) => n === 'Content')) {
-										// Make `Content` the default export so we can wrap `MDXContent` and pass in `Fragment`
-										code = code.replace('export default MDXContent;', '');
-										code += `\nexport const Content = (props = {}) => MDXContent({
-											...props,
-											components: { Fragment, ...props.components },
-										});
-										export default Content;`;
-									}
-
-									// Ensures styles and scripts are injected into a `<head>`
-									// When a layout is not applied
-									code += `\nContent[Symbol.for('astro.needsHeadRendering')] = !Boolean(frontmatter.layout);`;
-									code += `\nContent.moduleId = ${JSON.stringify(id)};`;
-
-									if (command === 'dev') {
-										// TODO: decline HMR updates until we have a stable approach
-										code += `\nif (import.meta.hot) {
-											import.meta.hot.decline();
-										}`;
-									}
-									return { code: escapeViteEnvReferences(code), map: null };
-								},
-							},
-						] as VitePlugin[],
-					},
-				});
-			},
-		},
-	};
-}
-
-const defaultMdxOptions = {
-	extendMarkdownConfig: true,
-	recmaPlugins: [],
-};
-
-function markdownConfigToMdxOptions(markdownConfig: typeof markdownConfigDefaults): MdxOptions {
-	return {
-		...defaultMdxOptions,
-		...markdownConfig,
-		remarkPlugins: ignoreStringPlugins(markdownConfig.remarkPlugins),
-		rehypePlugins: ignoreStringPlugins(markdownConfig.rehypePlugins),
-		remarkRehype: (markdownConfig.remarkRehype as any) ?? {},
-	};
-}
-
-function applyDefaultOptions({
-	options,
-	defaults,
-}: {
-	options: Partial<MdxOptions>;
-	defaults: MdxOptions;
-}): MdxOptions {
-	return {
-		syntaxHighlight: options.syntaxHighlight ?? defaults.syntaxHighlight,
-		extendMarkdownConfig: options.extendMarkdownConfig ?? defaults.extendMarkdownConfig,
-		recmaPlugins: options.recmaPlugins ?? defaults.recmaPlugins,
-		remarkRehype: options.remarkRehype ?? defaults.remarkRehype,
-		gfm: options.gfm ?? defaults.gfm,
-		smartypants: options.smartypants ?? defaults.smartypants,
-		remarkPlugins: options.remarkPlugins ?? defaults.remarkPlugins,
-		rehypePlugins: options.rehypePlugins ?? defaults.rehypePlugins,
-		shikiConfig: options.shikiConfig ?? defaults.shikiConfig,
-	};
-}
-
-// Converts the first dot in `import.meta.env` to its Unicode escape sequence,
-// which prevents Vite from replacing strings like `import.meta.env.SITE`
-// in our JS representation of loaded Markdown files
-function escapeViteEnvReferences(code: string) {
-	return code.replace(/import\.meta\.env/g, 'import\\u002Emeta.env');
-}

package/src/plugins.ts

@@ -1,185 +0,0 @@
-import { rehypeHeadingIds, remarkCollectImages } from '@astrojs/markdown-remark';
-import {
-	InvalidAstroDataError,
-	safelyGetAstroData,
-} from '@astrojs/markdown-remark/dist/internal.js';
-import { nodeTypes } from '@mdx-js/mdx';
-import type { PluggableList } from '@mdx-js/mdx/lib/core.js';
-import type { Options as MdxRollupPluginOptions } from '@mdx-js/rollup';
-import type { AstroConfig } from 'astro';
-import type { Literal, MemberExpression } from 'estree';
-import { visit as estreeVisit } from 'estree-util-visit';
-import rehypeRaw from 'rehype-raw';
-import remarkGfm from 'remark-gfm';
-import remarkSmartypants from 'remark-smartypants';
-import type { VFile } from 'vfile';
-import type { MdxOptions } from './index.js';
-import { rehypeInjectHeadingsExport } from './rehype-collect-headings.js';
-import rehypeMetaString from './rehype-meta-string.js';
-import { remarkImageToComponent } from './remark-images-to-component.js';
-import remarkPrism from './remark-prism.js';
-import remarkShiki from './remark-shiki.js';
-import { jsToTreeNode } from './utils.js';
-
-// Skip nonessential plugins during performance benchmark runs
-const isPerformanceBenchmark = Boolean(process.env.ASTRO_PERFORMANCE_BENCHMARK);
-
-export function recmaInjectImportMetaEnvPlugin({
-	importMetaEnv,
-}: {
-	importMetaEnv: Record<string, any>;
-}) {
-	return (tree: any) => {
-		estreeVisit(tree, (node) => {
-			if (node.type === 'MemberExpression') {
-				// attempt to get "import.meta.env" variable name
-				const envVarName = getImportMetaEnvVariableName(node as MemberExpression);
-				if (typeof envVarName === 'string') {
-					// clear object keys to replace with envVarLiteral
-					for (const key in node) {
-						delete (node as any)[key];
-					}
-					const envVarLiteral: Literal = {
-						type: 'Literal',
-						value: importMetaEnv[envVarName],
-						raw: JSON.stringify(importMetaEnv[envVarName]),
-					};
-					Object.assign(node, envVarLiteral);
-				}
-			}
-		});
-	};
-}
-
-export function rehypeApplyFrontmatterExport() {
-	return function (tree: any, vfile: VFile) {
-		const astroData = safelyGetAstroData(vfile.data);
-		if (astroData instanceof InvalidAstroDataError)
-			throw new Error(
-				// Copied from Astro core `errors-data`
-				// TODO: find way to import error data from core
-				'[MDX] A remark or rehype plugin attempted to inject invalid frontmatter. Ensure "astro.frontmatter" is set to a valid JSON object that is not `null` or `undefined`.'
-			);
-		const { frontmatter } = astroData;
-		const exportNodes = [
-			jsToTreeNode(`export const frontmatter = ${JSON.stringify(frontmatter)};`),
-		];
-		if (frontmatter.layout) {
-			// NOTE(bholmesdev) 08-22-2022
-			// Using an async layout import (i.e. `const Layout = (await import...)`)
-			// Preserves the dev server import cache when globbing a large set of MDX files
-			// Full explanation: 'https://github.com/withastro/astro/pull/4428'
-			exportNodes.unshift(
-				jsToTreeNode(
-					/** @see 'vite-plugin-markdown' for layout props reference */
-					`import { jsx as layoutJsx } from 'astro/jsx-runtime';
-
-				export default async function ({ children }) {
-					const Layout = (await import(${JSON.stringify(frontmatter.layout)})).default;
-					const { layout, ...content } = frontmatter;
-					content.file = file;
-					content.url = url;
-					return layoutJsx(Layout, {
-						file,
-						url,
-						content,
-						frontmatter: content,
-						headings: getHeadings(),
-						'server:root': true,
-						children,
-					});
-				};`
-				)
-			);
-		}
-		tree.children = exportNodes.concat(tree.children);
-	};
-}
-
-export async function getRemarkPlugins(
-	mdxOptions: MdxOptions,
-	config: AstroConfig
-): Promise<MdxRollupPluginOptions['remarkPlugins']> {
-	let remarkPlugins: PluggableList = [
-		...(config.experimental.assets ? [remarkCollectImages, remarkImageToComponent] : []),
-	];
-
-	if (!isPerformanceBenchmark) {
-		if (mdxOptions.gfm) {
-			remarkPlugins.push(remarkGfm);
-		}
-		if (mdxOptions.smartypants) {
-			remarkPlugins.push(remarkSmartypants);
-		}
-	}
-
-	remarkPlugins = [...remarkPlugins, ...mdxOptions.remarkPlugins];
-
-	if (!isPerformanceBenchmark) {
-		// Apply syntax highlighters after user plugins to match `markdown/remark` behavior
-		if (mdxOptions.syntaxHighlight === 'shiki') {
-			remarkPlugins.push([await remarkShiki(mdxOptions.shikiConfig)]);
-		}
-		if (mdxOptions.syntaxHighlight === 'prism') {
-			remarkPlugins.push(remarkPrism);
-		}
-	}
-
-	return remarkPlugins;
-}
-
-export function getRehypePlugins(mdxOptions: MdxOptions): MdxRollupPluginOptions['rehypePlugins'] {
-	let rehypePlugins: PluggableList = [
-		// ensure `data.meta` is preserved in `properties.metastring` for rehype syntax highlighters
-		rehypeMetaString,
-		// rehypeRaw allows custom syntax highlighters to work without added config
-		[rehypeRaw, { passThrough: nodeTypes }] as any,
-	];
-
-	rehypePlugins = [
-		...rehypePlugins,
-		...mdxOptions.rehypePlugins,
-		// getHeadings() is guaranteed by TS, so this must be included.
-		// We run `rehypeHeadingIds` _last_ to respect any custom IDs set by user plugins.
-		...(isPerformanceBenchmark ? [] : [rehypeHeadingIds, rehypeInjectHeadingsExport]),
-		// computed from `astro.data.frontmatter` in VFile data
-		rehypeApplyFrontmatterExport,
-	];
-	return rehypePlugins;
-}
-
-/**
- * Check if estree entry is "import.meta.env.VARIABLE"
- * If it is, return the variable name (i.e. "VARIABLE")
- */
-function getImportMetaEnvVariableName(node: MemberExpression): string | Error {
-	try {
-		// check for ".[ANYTHING]"
-		if (node.object.type !== 'MemberExpression' || node.property.type !== 'Identifier')
-			return new Error();
-
-		const nestedExpression = node.object;
-		// check for ".env"
-		if (nestedExpression.property.type !== 'Identifier' || nestedExpression.property.name !== 'env')
-			return new Error();
-
-		const envExpression = nestedExpression.object;
-		// check for ".meta"
-		if (
-			envExpression.type !== 'MetaProperty' ||
-			envExpression.property.type !== 'Identifier' ||
-			envExpression.property.name !== 'meta'
-		)
-			return new Error();
-
-		// check for "import"
-		if (envExpression.meta.name !== 'import') return new Error();
-
-		return node.property.name;
-	} catch (e) {
-		if (e instanceof Error) {
-			return e;
-		}
-		return new Error('Unknown parsing error');
-	}
-}

package/src/rehype-collect-headings.ts

@@ -1,11 +0,0 @@
-import type { MarkdownHeading, MarkdownVFile } from '@astrojs/markdown-remark';
-import { jsToTreeNode } from './utils.js';
-
-export function rehypeInjectHeadingsExport() {
-	return function (tree: any, file: MarkdownVFile) {
-		const headings: MarkdownHeading[] = file.data.__astroHeadings || [];
-		tree.children.unshift(
-			jsToTreeNode(`export function getHeadings() { return ${JSON.stringify(headings)} }`)
-		);
-	};
-}

package/src/rehype-meta-string.ts

@@ -1,17 +0,0 @@
-import { visit } from 'unist-util-visit';
-
-/**
- * Moves `data.meta` to `properties.metastring` for the `code` element node
- * as `rehype-raw` strips `data` from all nodes, which may contain useful information.
- * e.g. ```js {1:3} => metastring: "{1:3}"
- */
-export default function rehypeMetaString() {
-	return function (tree: any) {
-		visit(tree, (node) => {
-			if (node.type === 'element' && node.tagName === 'code' && node.data?.meta) {
-				node.properties ??= {};
-				node.properties.metastring = node.data.meta;
-			}
-		});
-	};
-}

package/src/remark-images-to-component.ts

@@ -1,98 +0,0 @@
-import type { MarkdownVFile } from '@astrojs/markdown-remark';
-import { type Image, type Parent } from 'mdast';
-import type { MdxjsEsm, MdxJsxFlowElement } from 'mdast-util-mdx';
-import { visit } from 'unist-util-visit';
-import { jsToTreeNode } from './utils.js';
-
-export function remarkImageToComponent() {
-	return function (tree: any, file: MarkdownVFile) {
-		if (!file.data.imagePaths) return;
-
-		const importsStatements: MdxjsEsm[] = [];
-		const importedImages = new Map<string, string>();
-
-		visit(tree, 'image', (node: Image, index: number | null, parent: Parent | null) => {
-			// Use the imagePaths set from the remark-collect-images so we don't have to duplicate the logic for
-			// checking if an image should be imported or not
-			if (file.data.imagePaths?.has(node.url)) {
-				let importName = importedImages.get(node.url);
-
-				// If we haven't already imported this image, add an import statement
-				if (!importName) {
-					importName = `__${importedImages.size}_${node.url.replace(/\W/g, '_')}__`;
-
-					importsStatements.push({
-						type: 'mdxjsEsm',
-						value: '',
-						data: {
-							estree: {
-								type: 'Program',
-								sourceType: 'module',
-								body: [
-									{
-										type: 'ImportDeclaration',
-										source: { type: 'Literal', value: node.url, raw: JSON.stringify(node.url) },
-										specifiers: [
-											{
-												type: 'ImportDefaultSpecifier',
-												local: { type: 'Identifier', name: importName },
-											},
-										],
-									},
-								],
-							},
-						},
-					});
-					importedImages.set(node.url, importName);
-				}
-
-				// Build a component that's equivalent to <Image src={importName} alt={node.alt} title={node.title} />
-				const componentElement: MdxJsxFlowElement = {
-					name: '__AstroImage__',
-					type: 'mdxJsxFlowElement',
-					attributes: [
-						{
-							name: 'src',
-							type: 'mdxJsxAttribute',
-							value: {
-								type: 'mdxJsxAttributeValueExpression',
-								value: importName,
-								data: {
-									estree: {
-										type: 'Program',
-										sourceType: 'module',
-										comments: [],
-										body: [
-											{
-												type: 'ExpressionStatement',
-												expression: { type: 'Identifier', name: importName },
-											},
-										],
-									},
-								},
-							},
-						},
-						{ name: 'alt', type: 'mdxJsxAttribute', value: node.alt || '' },
-					],
-					children: [],
-				};
-
-				if (node.title) {
-					componentElement.attributes.push({
-						type: 'mdxJsxAttribute',
-						name: 'title',
-						value: node.title,
-					});
-				}
-
-				parent!.children.splice(index!, 1, componentElement);
-			}
-		});
-
-		// Add all the import statements to the top of the file for the images
-		tree.children.unshift(...importsStatements);
-
-		// Add an import statement for the Astro Image component, we rename it to avoid conflicts
-		tree.children.unshift(jsToTreeNode(`import { Image as __AstroImage__ } from "astro:assets";`));
-	};
-}

package/src/remark-prism.ts

@@ -1,18 +0,0 @@
-import { runHighlighterWithAstro } from '@astrojs/prism/dist/highlighter';
-import { visit } from 'unist-util-visit';
-
-/**  */
-export default function remarkPrism() {
-	return (tree: any) =>
-		visit(tree, 'code', (node: any) => {
-			let { lang, value } = node;
-			node.type = 'html';
-
-			let { html, classLanguage } = runHighlighterWithAstro(lang, value);
-			let classes = [classLanguage];
-			node.value = `<pre class="${classes.join(
-				' '
-			)}"><code class="${classLanguage}">${html}</code></pre>`;
-			return node;
-		});
-}

package/src/remark-shiki.ts

@@ -1,115 +0,0 @@
-import type { ShikiConfig } from 'astro';
-import type * as shiki from 'shiki';
-import { getHighlighter } from 'shiki';
-import { visit } from 'unist-util-visit';
-
-/**
- * getHighlighter() is the most expensive step of Shiki. Instead of calling it on every page,
- * cache it here as much as possible. Make sure that your highlighters can be cached, state-free.
- * We make this async, so that multiple calls to parse markdown still share the same highlighter.
- */
-const highlighterCacheAsync = new Map<string, Promise<shiki.Highlighter>>();
-
-// Map of old theme names to new names to preserve compatibility when we upgrade shiki
-const compatThemes: Record<string, string> = {
-	'material-darker': 'material-theme-darker',
-	'material-default': 'material-theme',
-	'material-lighter': 'material-theme-lighter',
-	'material-ocean': 'material-theme-ocean',
-	'material-palenight': 'material-theme-palenight',
-};
-
-const normalizeTheme = (theme: string | shiki.IShikiTheme) => {
-	if (typeof theme === 'string') {
-		return compatThemes[theme] || theme;
-	} else if (compatThemes[theme.name]) {
-		return { ...theme, name: compatThemes[theme.name] };
-	} else {
-		return theme;
-	}
-};
-
-const remarkShiki = async ({ langs = [], theme = 'github-dark', wrap = false }: ShikiConfig) => {
-	theme = normalizeTheme(theme);
-	const cacheID: string = typeof theme === 'string' ? theme : theme.name;
-	let highlighterAsync = highlighterCacheAsync.get(cacheID);
-	if (!highlighterAsync) {
-		highlighterAsync = getHighlighter({ theme }).then((hl) => {
-			hl.setColorReplacements({
-				'#000001': 'var(--astro-code-color-text)',
-				'#000002': 'var(--astro-code-color-background)',
-				'#000004': 'var(--astro-code-token-constant)',
-				'#000005': 'var(--astro-code-token-string)',
-				'#000006': 'var(--astro-code-token-comment)',
-				'#000007': 'var(--astro-code-token-keyword)',
-				'#000008': 'var(--astro-code-token-parameter)',
-				'#000009': 'var(--astro-code-token-function)',
-				'#000010': 'var(--astro-code-token-string-expression)',
-				'#000011': 'var(--astro-code-token-punctuation)',
-				'#000012': 'var(--astro-code-token-link)',
-			});
-			return hl;
-		});
-		highlighterCacheAsync.set(cacheID, highlighterAsync);
-	}
-	const highlighter = await highlighterAsync;
-
-	// NOTE: There may be a performance issue here for large sites that use `lang`.
-	// Since this will be called on every page load. Unclear how to fix this.
-	for (const lang of langs) {
-		await highlighter.loadLanguage(lang);
-	}
-
-	return () => (tree: any) => {
-		visit(tree, 'code', (node) => {
-			let lang: string;
-
-			if (typeof node.lang === 'string') {
-				const langExists = highlighter.getLoadedLanguages().includes(node.lang);
-				if (langExists) {
-					lang = node.lang;
-				} else {
-					// eslint-disable-next-line no-console
-					console.warn(`The language "${node.lang}" doesn't exist, falling back to plaintext.`);
-					lang = 'plaintext';
-				}
-			} else {
-				lang = 'plaintext';
-			}
-
-			let html = highlighter!.codeToHtml(node.value, { lang });
-
-			// Q: Couldn't these regexes match on a user's inputted code blocks?
-			// A: Nope! All rendered HTML is properly escaped.
-			// Ex. If a user typed `<span class="line"` into a code block,
-			// It would become this before hitting our regexes:
-			// &lt;span class=&quot;line&quot;
-
-			// Replace "shiki" class naming with "astro".
-			html = html.replace(/<pre class="(.*?)shiki(.*?)"/, `<pre class="$1astro-code$2"`);
-			// Add "user-select: none;" for "+"/"-" diff symbols
-			if (node.lang === 'diff') {
-				html = html.replace(
-					/<span class="line"><span style="(.*?)">([\+|\-])/g,
-					'<span class="line"><span style="$1"><span style="user-select: none;">$2</span>'
-				);
-			}
-			// Handle code wrapping
-			// if wrap=null, do nothing.
-			if (wrap === false) {
-				html = html.replace(/style="(.*?)"/, 'style="$1; overflow-x: auto;"');
-			} else if (wrap === true) {
-				html = html.replace(
-					/style="(.*?)"/,
-					'style="$1; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;"'
-				);
-			}
-
-			node.type = 'html';
-			node.value = html;
-			node.children = [];
-		});
-	};
-};
-
-export default remarkShiki;