@astrojs/markdown-remark 0.12.0 → 0.14.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
-@astrojs/markdown-remark:build: cache hit, replaying output 1546942a008a83f6
+@astrojs/markdown-remark:build: cache hit, replaying output f2df71f430c1c421
 @astrojs/markdown-remark:build: 
-@astrojs/markdown-remark:build: > @astrojs/markdown-remark@0.12.0 build /home/runner/work/astro/astro/packages/markdown/remark
+@astrojs/markdown-remark:build: > @astrojs/markdown-remark@0.14.1 build /home/runner/work/astro/astro/packages/markdown/remark
 @astrojs/markdown-remark:build: > astro-scripts build "src/**/*.ts" && tsc -p tsconfig.json
 @astrojs/markdown-remark:build: 

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @astrojs/markdown-remark
 
+## 0.14.1
+
+### Patch Changes
+
+- [#4176](https://github.com/withastro/astro/pull/4176) [`2675b8633`](https://github.com/withastro/astro/commit/2675b8633c5d5c45b237ec87940d5eaf1bfb1b4b) Thanks [@bholmesdev](https://github.com/bholmesdev)! - Support frontmatter injection for MD and MDX using remark and rehype plugins
+
+* [#4137](https://github.com/withastro/astro/pull/4137) [`471c6f784`](https://github.com/withastro/astro/commit/471c6f784e21399676c8b2002665ffdf83a1c59e) Thanks [@bholmesdev](https://github.com/bholmesdev)! - Speed up internal markdown builds with new vite-plugin markdown
+
+- [#4169](https://github.com/withastro/astro/pull/4169) [`16034f0dd`](https://github.com/withastro/astro/commit/16034f0dd5b3683e9e022dbd413e85bd18d2b031) Thanks [@hippotastic](https://github.com/hippotastic)! - Fix double-escaping of non-highlighted code blocks in Astro-flavored markdown
+
+## 0.14.0
+
+### Minor Changes
+
+- [#4114](https://github.com/withastro/astro/pull/4114) [`64432bcb8`](https://github.com/withastro/astro/commit/64432bcb873efd0e4297c00fc9583a1fe516dfe7) Thanks [@Princesseuh](https://github.com/Princesseuh)! - Refactor `@astrojs/mdx` and `@astrojs/markdown-remark` to use `@astrojs/prism` instead of duplicating the code
+
+### Patch Changes
+
+- Updated dependencies [[`64432bcb8`](https://github.com/withastro/astro/commit/64432bcb873efd0e4297c00fc9583a1fe516dfe7)]:
+  - @astrojs/prism@0.7.0
+
+## 0.13.0
+
+### Minor Changes
+
+- [`ba11b3399`](https://github.com/withastro/astro/commit/ba11b33996d79c32da947986edb0f32dbcc04aaf) Thanks [@RafidMuhymin](https://github.com/RafidMuhymin)! - fixed generated slugs in markdown that ends with a dash
+
+* [#4016](https://github.com/withastro/astro/pull/4016) [`00fab4ce1`](https://github.com/withastro/astro/commit/00fab4ce135eb799cac69140403d7724686733d6) Thanks [@bholmesdev](https://github.com/bholmesdev)! - The use of components and JSX expressions in Markdown are no longer supported by default.
+
+  For long term support, migrate to the `@astrojs/mdx` integration for MDX support (including `.mdx` pages!).
+
+  Not ready to migrate to MDX? Add the legacy flag to your Astro config to re-enable the previous Markdown support.
+
+  ```js
+  // https://astro.build/config
+  export default defineConfig({
+    legacy: {
+      astroFlavoredMarkdown: true,
+    },
+  });
+  ```
+
+- [#4031](https://github.com/withastro/astro/pull/4031) [`6e27a5fdc`](https://github.com/withastro/astro/commit/6e27a5fdc21276cad26cd50e16a2709a40a7cbac) Thanks [@natemoo-re](https://github.com/natemoo-re)! - **BREAKING** Renamed Markdown utility function `getHeaders()` to `getHeadings()`.
+
+### Patch Changes
+
+- [#4008](https://github.com/withastro/astro/pull/4008) [`399d7e269`](https://github.com/withastro/astro/commit/399d7e269834d11c046b390705a9a53d3738f3cf) Thanks [@bholmesdev](https://github.com/bholmesdev)! - Avoid parsing JSX, components, and Astro islands when using "plain" md mode. This brings `markdown.mode: 'md'` in-line with our docs description.
+
 ## 0.12.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -3,4 +3,4 @@ export * from './types.js';
 export declare const DEFAULT_REMARK_PLUGINS: string[];
 export declare const DEFAULT_REHYPE_PLUGINS: never[];
 /** Shared utility for rendering markdown */
-export declare function renderMarkdown(content: string, opts?: MarkdownRenderingOptions): Promise<MarkdownRenderingResult>;
+export declare function renderMarkdown(content: string, opts: MarkdownRenderingOptions): Promise<MarkdownRenderingResult>;

package/dist/index.js

@@ -1,10 +1,11 @@
 import { loadPlugins } from "./load-plugins.js";
-import createCollectHeaders from "./rehype-collect-headers.js";
+import createCollectHeadings from "./rehype-collect-headings.js";
 import rehypeEscape from "./rehype-escape.js";
 import rehypeExpressions from "./rehype-expressions.js";
 import rehypeIslands from "./rehype-islands.js";
 import rehypeJsx from "./rehype-jsx.js";
 import remarkEscape from "./remark-escape.js";
+import { remarkInitializeAstroData } from "./remark-initialize-astro-data.js";
 import remarkMarkAndUnravel from "./remark-mark-and-unravel.js";
 import remarkMdxish from "./remark-mdxish.js";
 import remarkPrism from "./remark-prism.js";
@@ -20,21 +21,20 @@ import { VFile } from "vfile";
 export * from "./types.js";
 const DEFAULT_REMARK_PLUGINS = ["remark-gfm", "remark-smartypants"];
 const DEFAULT_REHYPE_PLUGINS = [];
-async function renderMarkdown(content, opts = {}) {
+async function renderMarkdown(content, opts) {
   var _a;
   let {
     fileURL,
-    mode = "mdx",
     syntaxHighlight = "shiki",
     shikiConfig = {},
     remarkPlugins = [],
-    rehypePlugins = []
+    rehypePlugins = [],
+    isAstroFlavoredMd = false
   } = opts;
   const input = new VFile({ value: content, path: fileURL });
   const scopedClassName = (_a = opts.$) == null ? void 0 : _a.scopedClassName;
-  const isMDX = mode === "mdx";
-  const { headers, rehypeCollectHeaders } = createCollectHeaders();
-  let parser = unified().use(markdown).use(isMDX ? [remarkMdxish, remarkMarkAndUnravel] : []).use([remarkUnwrap, remarkEscape]);
+  const { headings, rehypeCollectHeadings } = createCollectHeadings();
+  let parser = unified().use(markdown).use(remarkInitializeAstroData).use(isAstroFlavoredMd ? [remarkMdxish, remarkMarkAndUnravel, remarkUnwrap, remarkEscape] : []);
   if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
     remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
     rehypePlugins = [...DEFAULT_REHYPE_PLUGINS];
@@ -57,32 +57,34 @@ async function renderMarkdown(content, opts = {}) {
       markdownToHtml,
       {
         allowDangerousHtml: true,
-        passThrough: [
+        passThrough: isAstroFlavoredMd ? [
           "raw",
           "mdxFlowExpression",
           "mdxJsxFlowElement",
           "mdxJsxTextElement",
           "mdxTextExpression"
-        ]
+        ] : []
       }
     ]
   ]);
   loadedRehypePlugins.forEach(([plugin, pluginOpts]) => {
     parser.use([[plugin, pluginOpts]]);
   });
-  parser.use(isMDX ? [rehypeJsx, rehypeExpressions] : [rehypeRaw]).use(rehypeEscape).use(rehypeIslands).use([rehypeCollectHeaders]).use(rehypeStringify, { allowDangerousHtml: true });
-  let result;
+  parser.use(
+    isAstroFlavoredMd ? [rehypeJsx, rehypeExpressions, rehypeEscape, rehypeIslands, rehypeCollectHeadings] : [rehypeCollectHeadings, rehypeRaw]
+  ).use(rehypeStringify, { allowDangerousHtml: true });
+  let vfile;
   try {
-    const vfile = await parser.process(input);
-    result = vfile.toString();
+    vfile = await parser.process(input);
   } catch (err) {
     err = prefixError(err, `Failed to parse Markdown file "${input.path}"`);
     console.error(err);
     throw err;
   }
   return {
-    metadata: { headers, source: content, html: result.toString() },
-    code: result.toString()
+    metadata: { headings, source: content, html: String(vfile.value) },
+    code: String(vfile.value),
+    vfile
   };
 }
 function prefixError(err, prefix) {

package/dist/mdxjs.js

@@ -5,11 +5,14 @@ import { mdxExpression } from "micromark-extension-mdx-expression";
 import { mdxMd } from "micromark-extension-mdx-md";
 import { combineExtensions } from "micromark-util-combine-extensions";
 function mdxjs(options) {
-  const settings = Object.assign({
-    acorn: Parser.extend(acornJsx()),
-    acornOptions: { ecmaVersion: 2020, sourceType: "module" },
-    addResult: true
-  }, options);
+  const settings = Object.assign(
+    {
+      acorn: Parser.extend(acornJsx()),
+      acornOptions: { ecmaVersion: 2020, sourceType: "module" },
+      addResult: true
+    },
+    options
+  );
   return combineExtensions([mdxExpression(settings), mdxJsx(settings), mdxMd]);
 }
 export {

package/dist/rehype-collect-headings.d.ts

@@ -0,0 +1,5 @@
+import type { MarkdownHeading, RehypePlugin } from './types.js';
+export default function createCollectHeadings(): {
+    headings: MarkdownHeading[];
+    rehypeCollectHeadings: () => ReturnType<RehypePlugin>;
+};

package/dist/{rehype-collect-headers.js → rehype-collect-headings.js}

@@ -1,10 +1,10 @@
 import Slugger from "github-slugger";
 import { toHtml } from "hast-util-to-html";
 import { visit } from "unist-util-visit";
-function createCollectHeaders() {
-  const headers = [];
+function createCollectHeadings() {
+  const headings = [];
   const slugger = new Slugger();
-  function rehypeCollectHeaders() {
+  function rehypeCollectHeadings() {
     return function(tree) {
       visit(tree, (node) => {
         if (node.type !== "element")
@@ -44,18 +44,21 @@ function createCollectHeaders() {
             node.type = "raw";
             node.value = `<${node.tagName} id={${node.properties.id}}>${raw}</${node.tagName}>`;
           } else {
-            node.properties.id = slugger.slug(text);
+            let slug = slugger.slug(text);
+            if (slug.endsWith("-"))
+              slug = slug.slice(0, -1);
+            node.properties.id = slug;
           }
         }
-        headers.push({ depth, slug: node.properties.id, text });
+        headings.push({ depth, slug: node.properties.id, text });
       });
     };
   }
   return {
-    headers,
-    rehypeCollectHeaders
+    headings,
+    rehypeCollectHeadings
   };
 }
 export {
-  createCollectHeaders as default
+  createCollectHeadings as default
 };

package/dist/rehype-escape.d.ts

@@ -1 +1,2 @@
+export declare function escapeEntities(value: string): string;
 export default function rehypeEscape(): any;

package/dist/rehype-escape.js

@@ -1,17 +1,21 @@
-import { visit } from "unist-util-visit";
+import { SKIP, visit } from "unist-util-visit";
+function escapeEntities(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 function rehypeEscape() {
   return function(node) {
     return visit(node, "element", (el) => {
       if (el.tagName === "code" || el.tagName === "pre") {
         el.properties["is:raw"] = true;
         visit(el, "raw", (raw) => {
-          raw.value = raw.value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+          raw.value = escapeEntities(raw.value);
         });
+        return SKIP;
       }
-      return el;
     });
   };
 }
 export {
-  rehypeEscape as default
+  rehypeEscape as default,
+  escapeEntities
 };

package/dist/remark-initialize-astro-data.d.ts

@@ -0,0 +1,2 @@
+import type { VFile } from 'vfile';
+export declare function remarkInitializeAstroData(): (tree: any, vfile: VFile) => void;

package/dist/remark-initialize-astro-data.js

@@ -0,0 +1,10 @@
+function remarkInitializeAstroData() {
+  return function(tree, vfile) {
+    if (!vfile.data.astro) {
+      vfile.data.astro = { frontmatter: {} };
+    }
+  };
+}
+export {
+  remarkInitializeAstroData
+};

package/dist/remark-prism.js

@@ -1,49 +1,19 @@
-import { addAstro } from "@astrojs/prism/internal";
-import Prism from "prismjs";
-import loadLanguages from "prismjs/components/index.js";
+import { runHighlighterWithAstro } from "@astrojs/prism/dist/highlighter";
 import { visit } from "unist-util-visit";
 const noVisit = /* @__PURE__ */ new Set(["root", "html", "text"]);
-const languageMap = /* @__PURE__ */ new Map([["ts", "typescript"]]);
-function runHighlighter(lang, code) {
-  let classLanguage = `language-${lang}`;
-  if (lang == null) {
-    lang = "plaintext";
-  }
-  const ensureLoaded = (language) => {
-    if (language && !Prism.languages[language]) {
-      loadLanguages([language]);
-    }
-  };
-  if (languageMap.has(lang)) {
-    ensureLoaded(languageMap.get(lang));
-  } else if (lang === "astro") {
-    ensureLoaded("typescript");
-    addAstro(Prism);
-  } else {
-    ensureLoaded("markup-templating");
-    ensureLoaded(lang);
-  }
-  if (lang && !Prism.languages[lang]) {
-    console.warn(`Unable to load the language: ${lang}`);
-  }
-  const grammar = Prism.languages[lang];
-  let html = code;
-  if (grammar) {
-    html = Prism.highlight(code, grammar, lang);
-  }
-  return { classLanguage, html };
-}
 function transformer(className) {
   return function(tree) {
     const visitor = (node) => {
       let { lang, value } = node;
       node.type = "html";
-      let { html, classLanguage } = runHighlighter(lang, value);
+      let { html, classLanguage } = runHighlighterWithAstro(lang, value);
       let classes = [classLanguage];
       if (className) {
         classes.push(className);
       }
-      node.value = `<pre class="${classes.join(" ")}"><code is:raw class="${classLanguage}">${html}</code></pre>`;
+      node.value = `<pre class="${classes.join(
+        " "
+      )}"><code is:raw class="${classLanguage}">${html}</code></pre>`;
       return node;
     };
     return visit(tree, "code", visitor);

package/dist/remark-shiki.js

@@ -27,15 +27,27 @@ const remarkShiki = async ({ langs = [], theme = "github-dark", wrap = false },
         lang = "plaintext";
       }
       let html = highlighter.codeToHtml(node.value, { lang });
-      html = html.replace('<pre class="shiki"', `<pre is:raw class="astro-code${scopedClassName ? " " + scopedClassName : ""}"`);
-      html = html.replace(/style="(background-)?color: var\(--shiki-/g, 'style="$1color: var(--astro-code-');
+      html = html.replace(
+        '<pre class="shiki"',
+        `<pre is:raw class="astro-code${scopedClassName ? " " + scopedClassName : ""}"`
+      );
+      html = html.replace(
+        /style="(background-)?color: var\(--shiki-/g,
+        'style="$1color: var(--astro-code-'
+      );
       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>');
+        html = html.replace(
+          /<span class="line"><span style="(.*?)">([\+|\-])/g,
+          '<span class="line"><span style="$1"><span style="user-select: none;">$2</span>'
+        );
       }
       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;"');
+        html = html.replace(
+          /style="(.*?)"/,
+          'style="$1; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;"'
+        );
       }
       if (scopedClassName) {
         html = html.replace(/\<span class="line"\>/g, `<span class="line ${scopedClassName}"`);

package/dist/types.d.ts

@@ -2,6 +2,7 @@ import type * as hast from 'hast';
 import type * as mdast from 'mdast';
 import type { ILanguageRegistration, IThemeRegistration, Theme } from 'shiki';
 import type * as unified from 'unified';
+import type { VFile } from 'vfile';
 export type { Node } from 'unist';
 export declare type RemarkPlugin<PluginParameters extends any[] = any[]> = unified.Plugin<PluginParameters, mdast.Root>;
 export declare type RemarkPlugins = (string | [string, any] | RemarkPlugin | [RemarkPlugin, any])[];
@@ -27,18 +28,20 @@ export interface MarkdownRenderingOptions extends AstroMarkdownOptions {
     $?: {
         scopedClassName: string | null;
     };
+    isAstroFlavoredMd?: boolean;
 }
-export interface MarkdownHeader {
+export interface MarkdownHeading {
     depth: number;
     slug: string;
     text: string;
 }
 export interface MarkdownMetadata {
-    headers: MarkdownHeader[];
+    headings: MarkdownHeading[];
     source: string;
     html: string;
 }
 export interface MarkdownRenderingResult {
     metadata: MarkdownMetadata;
+    vfile: VFile;
     code: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/markdown-remark",
-  "version": "0.12.0",
+  "version": "0.14.1",
   "type": "module",
   "author": "withastro",
   "license": "MIT",
@@ -17,18 +17,15 @@
   },
   "dependencies": {
     "@astrojs/micromark-extension-mdx-jsx": "^1.0.3",
-    "@astrojs/prism": "^0.6.1",
+    "@astrojs/prism": "^0.7.0",
     "acorn": "^8.7.1",
     "acorn-jsx": "^5.3.2",
-    "assert": "^2.0.0",
     "github-slugger": "^1.4.0",
     "mdast-util-mdx-expression": "^1.2.1",
     "mdast-util-mdx-jsx": "^1.2.0",
-    "mdast-util-to-string": "^3.1.0",
     "micromark-extension-mdx-expression": "^1.0.3",
     "micromark-extension-mdx-md": "^1.0.0",
     "micromark-util-combine-extensions": "^1.0.0",
-    "prismjs": "^1.28.0",
     "rehype-raw": "^6.1.1",
     "rehype-stringify": "^9.0.3",
     "remark-gfm": "^3.0.1",
@@ -47,7 +44,6 @@
     "@types/hast": "^2.3.4",
     "@types/mdast": "^3.0.10",
     "@types/mocha": "^9.1.1",
-    "@types/prismjs": "^1.26.0",
     "@types/unist": "^2.0.6",
     "astro-scripts": "0.0.6",
     "chai": "^4.3.6",

package/src/index.ts

@@ -1,12 +1,13 @@
 import type { MarkdownRenderingOptions, MarkdownRenderingResult } from './types';
 
 import { loadPlugins } from './load-plugins.js';
-import createCollectHeaders from './rehype-collect-headers.js';
+import createCollectHeadings from './rehype-collect-headings.js';
 import rehypeEscape from './rehype-escape.js';
 import rehypeExpressions from './rehype-expressions.js';
 import rehypeIslands from './rehype-islands.js';
 import rehypeJsx from './rehype-jsx.js';
 import remarkEscape from './remark-escape.js';
+import { remarkInitializeAstroData } from './remark-initialize-astro-data.js';
 import remarkMarkAndUnravel from './remark-mark-and-unravel.js';
 import remarkMdxish from './remark-mdxish.js';
 import remarkPrism from './remark-prism.js';
@@ -29,25 +30,24 @@ export const DEFAULT_REHYPE_PLUGINS = [];
 /** Shared utility for rendering markdown */
 export async function renderMarkdown(
 	content: string,
-	opts: MarkdownRenderingOptions = {}
+	opts: MarkdownRenderingOptions
 ): Promise<MarkdownRenderingResult> {
 	let {
 		fileURL,
-		mode = 'mdx',
 		syntaxHighlight = 'shiki',
 		shikiConfig = {},
 		remarkPlugins = [],
 		rehypePlugins = [],
+		isAstroFlavoredMd = false,
 	} = opts;
 	const input = new VFile({ value: content, path: fileURL });
 	const scopedClassName = opts.$?.scopedClassName;
-	const isMDX = mode === 'mdx';
-	const { headers, rehypeCollectHeaders } = createCollectHeaders();
+	const { headings, rehypeCollectHeadings } = createCollectHeadings();
 
 	let parser = unified()
 		.use(markdown)
-		.use(isMDX ? [remarkMdxish, remarkMarkAndUnravel] : [])
-		.use([remarkUnwrap, remarkEscape]);
+		.use(remarkInitializeAstroData)
+		.use(isAstroFlavoredMd ? [remarkMdxish, remarkMarkAndUnravel, remarkUnwrap, remarkEscape] : []);
 
 	if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
 		remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
@@ -76,13 +76,15 @@ export async function renderMarkdown(
 			markdownToHtml as any,
 			{
 				allowDangerousHtml: true,
-				passThrough: [
-					'raw',
-					'mdxFlowExpression',
-					'mdxJsxFlowElement',
-					'mdxJsxTextElement',
-					'mdxTextExpression',
-				],
+				passThrough: isAstroFlavoredMd
+					? [
+							'raw',
+							'mdxFlowExpression',
+							'mdxJsxFlowElement',
+							'mdxJsxTextElement',
+							'mdxTextExpression',
+					  ]
+					: [],
 			},
 		],
 	]);
@@ -92,16 +94,16 @@ export async function renderMarkdown(
 	});
 
 	parser
-		.use(isMDX ? [rehypeJsx, rehypeExpressions] : [rehypeRaw])
-		.use(rehypeEscape)
-		.use(rehypeIslands)
-		.use([rehypeCollectHeaders])
+		.use(
+			isAstroFlavoredMd
+				? [rehypeJsx, rehypeExpressions, rehypeEscape, rehypeIslands, rehypeCollectHeadings]
+				: [rehypeCollectHeadings, rehypeRaw]
+		)
 		.use(rehypeStringify, { allowDangerousHtml: true });
 
-	let result: string;
+	let vfile: VFile;
 	try {
-		const vfile = await parser.process(input);
-		result = vfile.toString();
+		vfile = await parser.process(input);
 	} catch (err) {
 		// Ensure that the error message contains the input filename
 		// to make it easier for the user to fix the issue
@@ -112,8 +114,9 @@ export async function renderMarkdown(
 	}
 
 	return {
-		metadata: { headers, source: content, html: result.toString() },
-		code: result.toString(),
+		metadata: { headings, source: content, html: String(vfile.value) },
+		code: String(vfile.value),
+		vfile,
 	};
 }
 

package/src/{rehype-collect-headers.ts → rehype-collect-headings.ts}

@@ -2,13 +2,13 @@ import Slugger from 'github-slugger';
 import { toHtml } from 'hast-util-to-html';
 import { visit } from 'unist-util-visit';
 
-import type { MarkdownHeader, RehypePlugin } from './types.js';
+import type { MarkdownHeading, RehypePlugin } from './types.js';
 
-export default function createCollectHeaders() {
-	const headers: MarkdownHeader[] = [];
+export default function createCollectHeadings() {
+	const headings: MarkdownHeading[] = [];
 	const slugger = new Slugger();
 
-	function rehypeCollectHeaders(): ReturnType<RehypePlugin> {
+	function rehypeCollectHeadings(): ReturnType<RehypePlugin> {
 		return function (tree) {
 			visit(tree, (node) => {
 				if (node.type !== 'element') return;
@@ -53,17 +53,21 @@ export default function createCollectHeaders() {
 							node as any
 						).value = `<${node.tagName} id={${node.properties.id}}>${raw}</${node.tagName}>`;
 					} else {
-						node.properties.id = slugger.slug(text);
+						let slug = slugger.slug(text);
+
+						if (slug.endsWith('-')) slug = slug.slice(0, -1);
+
+						node.properties.id = slug;
 					}
 				}
 
-				headers.push({ depth, slug: node.properties.id, text });
+				headings.push({ depth, slug: node.properties.id, text });
 			});
 		};
 	}
 
 	return {
-		headers,
-		rehypeCollectHeaders,
+		headings,
+		rehypeCollectHeadings,
 	};
 }

package/src/rehype-escape.ts

@@ -1,4 +1,8 @@
-import { visit } from 'unist-util-visit';
+import { SKIP, visit } from 'unist-util-visit';
+
+export function escapeEntities(value: string): string {
+	return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
 
 export default function rehypeEscape(): any {
 	return function (node: any): any {
@@ -8,10 +12,11 @@ export default function rehypeEscape(): any {
 				// Visit all raw children and escape HTML tags to prevent Markdown code
 				// like "This is a `<script>` tag" from actually opening a script tag
 				visit(el, 'raw', (raw) => {
-					raw.value = raw.value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+					raw.value = escapeEntities(raw.value);
 				});
+				// Do not visit children to prevent double escaping
+				return SKIP;
 			}
-			return el;
 		});
 	};
 }

package/src/remark-escape.ts

@@ -2,7 +2,7 @@ import type { Literal } from 'unist';
 import { visit } from 'unist-util-visit';
 
 // In code blocks, this removes the JS comment wrapper added to
-// HTML comments by vite-plugin-markdown.
+// HTML comments by vite-plugin-markdown-legacy.
 export default function remarkEscape() {
 	return (tree: any) => {
 		visit(tree, 'code', removeCommentWrapper);

package/src/remark-initialize-astro-data.ts

@@ -0,0 +1,9 @@
+import type { VFile } from 'vfile';
+
+export function remarkInitializeAstroData() {
+	return function (tree: any, vfile: VFile) {
+		if (!vfile.data.astro) {
+			vfile.data.astro = { frontmatter: {} };
+		}
+	};
+}

package/src/remark-prism.ts

@@ -1,48 +1,7 @@
-import { addAstro } from '@astrojs/prism/internal';
-import Prism from 'prismjs';
-import loadLanguages from 'prismjs/components/index.js';
+import { runHighlighterWithAstro } from '@astrojs/prism/dist/highlighter';
 import { visit } from 'unist-util-visit';
 const noVisit = new Set(['root', 'html', 'text']);
 
-const languageMap = new Map([['ts', 'typescript']]);
-
-function runHighlighter(lang: string, code: string) {
-	let classLanguage = `language-${lang}`;
-
-	if (lang == null) {
-		lang = 'plaintext';
-	}
-
-	const ensureLoaded = (language: string) => {
-		if (language && !Prism.languages[language]) {
-			loadLanguages([language]);
-		}
-	};
-
-	if (languageMap.has(lang)) {
-		ensureLoaded(languageMap.get(lang)!);
-	} else if (lang === 'astro') {
-		ensureLoaded('typescript');
-		addAstro(Prism);
-	} else {
-		ensureLoaded('markup-templating'); // Prism expects this to exist for a number of other langs
-		ensureLoaded(lang);
-	}
-
-	if (lang && !Prism.languages[lang]) {
-		// eslint-disable-next-line no-console
-		console.warn(`Unable to load the language: ${lang}`);
-	}
-
-	const grammar = Prism.languages[lang];
-	let html = code;
-	if (grammar) {
-		html = Prism.highlight(code, grammar, lang);
-	}
-
-	return { classLanguage, html };
-}
-
 type MaybeString = string | null | undefined;
 
 /**  */
@@ -52,7 +11,7 @@ function transformer(className: MaybeString) {
 			let { lang, value } = node;
 			node.type = 'html';
 
-			let { html, classLanguage } = runHighlighter(lang, value);
+			let { html, classLanguage } = runHighlighterWithAstro(lang, value);
 			let classes = [classLanguage];
 			if (className) {
 				classes.push(className);

package/src/types.ts

@@ -2,6 +2,7 @@ import type * as hast from 'hast';
 import type * as mdast from 'mdast';
 import type { ILanguageRegistration, IThemeRegistration, Theme } from 'shiki';
 import type * as unified from 'unified';
+import type { VFile } from 'vfile';
 
 export type { Node } from 'unist';
 
@@ -41,21 +42,23 @@ export interface MarkdownRenderingOptions extends AstroMarkdownOptions {
 	$?: {
 		scopedClassName: string | null;
 	};
+	isAstroFlavoredMd?: boolean;
 }
 
-export interface MarkdownHeader {
+export interface MarkdownHeading {
 	depth: number;
 	slug: string;
 	text: string;
 }
 
 export interface MarkdownMetadata {
-	headers: MarkdownHeader[];
+	headings: MarkdownHeading[];
 	source: string;
 	html: string;
 }
 
 export interface MarkdownRenderingResult {
 	metadata: MarkdownMetadata;
+	vfile: VFile;
 	code: string;
 }

package/test/autolinking.test.js

@@ -2,91 +2,107 @@ import { renderMarkdown } from '../dist/index.js';
 import chai from 'chai';
 
 describe('autolinking', () => {
-	it('autolinks URLs starting with a protocol in plain text', async () => {
-		const { code } = await renderMarkdown(`See https://example.com for more.`, {});
+	describe('plain md', () => {
+		it('autolinks URLs starting with a protocol in plain text', async () => {
+			const { code } = await renderMarkdown(`See https://example.com for more.`, {});
 
-		chai
-			.expect(code.replace(/\n/g, ''))
-			.to.equal(`<p>See <a href="https://example.com">https://example.com</a> for more.</p>`);
-	});
+			chai
+				.expect(code.replace(/\n/g, ''))
+				.to.equal(`<p>See <a href="https://example.com">https://example.com</a> for more.</p>`);
+		});
 
-	it('autolinks URLs starting with "www." in plain text', async () => {
-		const { code } = await renderMarkdown(`See www.example.com for more.`, {});
+		it('autolinks URLs starting with "www." in plain text', async () => {
+			const { code } = await renderMarkdown(`See www.example.com for more.`, {});
 
-		chai
-			.expect(code.trim())
-			.to.equal(`<p>See <a href="http://www.example.com">www.example.com</a> for more.</p>`);
-	});
+			chai
+				.expect(code.trim())
+				.to.equal(`<p>See <a href="http://www.example.com">www.example.com</a> for more.</p>`);
+		});
 
-	it('does not autolink URLs in code blocks', async () => {
-		const { code } = await renderMarkdown(
-			'See `https://example.com` or `www.example.com` for more.',
-			{}
-		);
-
-		chai
-			.expect(code.trim())
-			.to.equal(
-				`<p>See <code is:raw>https://example.com</code> or ` +
-					`<code is:raw>www.example.com</code> for more.</p>`
+		it('does not autolink URLs in code blocks', async () => {
+			const { code } = await renderMarkdown(
+				'See `https://example.com` or `www.example.com` for more.',
+				{}
 			);
+
+			chai
+				.expect(code.trim())
+				.to.equal(
+					`<p>See <code>https://example.com</code> or ` +
+						`<code>www.example.com</code> for more.</p>`
+				);
+		});
 	});
 
-	it('does not autolink URLs in fenced code blocks', async () => {
-		const { code } = await renderMarkdown(
-			'Example:\n```\nGo to https://example.com or www.example.com now.\n```',
-			{}
-		);
+	describe('astro-flavored md', () => {
+		const renderAstroMd = (text) => renderMarkdown(text, { isAstroFlavoredMd: true });
 
-		chai
-			.expect(code)
-			.to.contain(`<pre is:raw`)
-			.to.contain(`Go to https://example.com or www.example.com now.`);
-	});
+		it('does not autolink URLs in code blocks', async () => {
+			const { code } = await renderAstroMd(
+				'See `https://example.com` or `www.example.com` for more.',
+				{}
+			);
+
+			chai
+				.expect(code.trim())
+				.to.equal(
+					`<p>See <code is:raw>https://example.com</code> or ` +
+						`<code is:raw>www.example.com</code> for more.</p>`
+				);
+		});
 
-	it('does not autolink URLs starting with a protocol when nested inside links', async () => {
-		const { code } = await renderMarkdown(
-			`See [http://example.com](http://example.com) or ` +
-				`<a test href="https://example.com">https://example.com</a>`,
-			{}
-		);
-
-		chai
-			.expect(code.replace(/\n/g, ''))
-			.to.equal(
-				`<p>See <a href="http://example.com">http://example.com</a> or ` +
-					`<a test href="https://example.com">https://example.com</a></p>`
+		it('does not autolink URLs in fenced code blocks', async () => {
+			const { code } = await renderAstroMd(
+				'Example:\n```\nGo to https://example.com or www.example.com now.\n```'
 			);
-	});
 
-	it('does not autolink URLs starting with "www." when nested inside links', async () => {
-		const { code } = await renderMarkdown(
-			`See [www.example.com](https://www.example.com) or ` +
-				`<a test href="https://www.example.com">www.example.com</a>`,
-			{}
-		);
-
-		chai
-			.expect(code.replace(/\n/g, ''))
-			.to.equal(
-				`<p>See <a href="https://www.example.com">www.example.com</a> or ` +
-					`<a test href="https://www.example.com">www.example.com</a></p>`
+			chai
+				.expect(code)
+				.to.contain(`<pre is:raw`)
+				.to.contain(`Go to https://example.com or www.example.com now.`);
+		});
+
+		it('does not autolink URLs starting with a protocol when nested inside links', async () => {
+			const { code } = await renderAstroMd(
+				`See [http://example.com](http://example.com) or ` +
+					`<a test href="https://example.com">https://example.com</a>`
 			);
-	});
 
-	it('does not autolink URLs when nested several layers deep inside links', async () => {
-		const { code } = await renderMarkdown(
-			`<a href="https://www.example.com">**Visit _our www.example.com or ` +
-				`http://localhost pages_ for more!**</a>`,
-			{}
-		);
-
-		chai
-			.expect(code.replace(/\n/g, ''))
-			.to.equal(
-				`<a href="https://www.example.com"><strong>` +
-					`Visit <em>our www.example.com or http://localhost pages</em> for more!` +
-					`</strong></a>`
+			chai
+				.expect(code.replace(/\n/g, ''))
+				.to.equal(
+					`<p>See <a href="http://example.com">http://example.com</a> or ` +
+						`<a test href="https://example.com">https://example.com</a></p>`
+				);
+		});
+
+		it('does not autolink URLs starting with "www." when nested inside links', async () => {
+			const { code } = await renderAstroMd(
+				`See [www.example.com](https://www.example.com) or ` +
+					`<a test href="https://www.example.com">www.example.com</a>`
 			);
+
+			chai
+				.expect(code.replace(/\n/g, ''))
+				.to.equal(
+					`<p>See <a href="https://www.example.com">www.example.com</a> or ` +
+						`<a test href="https://www.example.com">www.example.com</a></p>`
+				);
+		});
+
+		it('does not autolink URLs when nested several layers deep inside links', async () => {
+			const { code } = await renderAstroMd(
+				`<a href="https://www.example.com">**Visit _our www.example.com or ` +
+					`http://localhost pages_ for more!**</a>`
+			);
+
+			chai
+				.expect(code.replace(/\n/g, ''))
+				.to.equal(
+					`<a href="https://www.example.com"><strong>` +
+						`Visit <em>our www.example.com or http://localhost pages</em> for more!` +
+						`</strong></a>`
+				);
+		});
 	});
 });

package/test/components.test.js

@@ -2,32 +2,34 @@ import { renderMarkdown } from '../dist/index.js';
 import chai from 'chai';
 
 describe('components', () => {
+	const renderAstroMd = (text) => renderMarkdown(text, { isAstroFlavoredMd: true });
+
 	it('should be able to serialize string', async () => {
-		const { code } = await renderMarkdown(`<Component str="cool!" />`, {});
+		const { code } = await renderAstroMd(`<Component str="cool!" />`);
 
 		chai.expect(code).to.equal(`<Component str="cool!" />`);
 	});
 
 	it('should be able to serialize boolean attribute', async () => {
-		const { code } = await renderMarkdown(`<Component bool={true} />`, {});
+		const { code } = await renderAstroMd(`<Component bool={true} />`);
 
 		chai.expect(code).to.equal(`<Component bool={true} />`);
 	});
 
 	it('should be able to serialize array', async () => {
-		const { code } = await renderMarkdown(`<Component prop={["a", "b", "c"]} />`, {});
+		const { code } = await renderAstroMd(`<Component prop={["a", "b", "c"]} />`);
 
 		chai.expect(code).to.equal(`<Component prop={["a", "b", "c"]} />`);
 	});
 
 	it('should be able to serialize object', async () => {
-		const { code } = await renderMarkdown(`<Component prop={{ a: 0, b: 1, c: 2 }} />`, {});
+		const { code } = await renderAstroMd(`<Component prop={{ a: 0, b: 1, c: 2 }} />`);
 
 		chai.expect(code).to.equal(`<Component prop={{ a: 0, b: 1, c: 2 }} />`);
 	});
 
 	it('should be able to serialize empty attribute', async () => {
-		const { code } = await renderMarkdown(`<Component empty />`, {});
+		const { code } = await renderAstroMd(`<Component empty />`);
 
 		chai.expect(code).to.equal(`<Component empty />`);
 	});
@@ -35,25 +37,25 @@ describe('components', () => {
 	// Notable omission: shorthand attribute
 
 	it('should be able to serialize spread attribute', async () => {
-		const { code } = await renderMarkdown(`<Component {...spread} />`, {});
+		const { code } = await renderAstroMd(`<Component {...spread} />`);
 
 		chai.expect(code).to.equal(`<Component {...spread} />`);
 	});
 
 	it('should allow client:* directives', async () => {
-		const { code } = await renderMarkdown(`<Component client:load />`, {});
+		const { code } = await renderAstroMd(`<Component client:load />`);
 
 		chai.expect(code).to.equal(`<Component client:load />`);
 	});
 
 	it('should normalize children', async () => {
-		const { code } = await renderMarkdown(`<Component bool={true}>Hello world!</Component>`, {});
+		const { code } = await renderAstroMd(`<Component bool={true}>Hello world!</Component>`);
 
 		chai.expect(code).to.equal(`<Component bool={true}>Hello world!</Component>`);
 	});
 
 	it('should be able to nest components', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<Component bool={true}><Component>Hello world!</Component></Component>`,
 			{}
 		);
@@ -64,7 +66,7 @@ describe('components', () => {
 	});
 
 	it('should allow markdown without many spaces', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<Component>
 # Hello world!
 </Component>`,

package/test/entities.test.js

@@ -0,0 +1,23 @@
+import { renderMarkdown } from '../dist/index.js';
+import { expect } from 'chai';
+
+describe('entities', () => {
+	it('should not unescape entities in regular Markdown', async () => {
+		const { code } = await renderMarkdown(`<i>This should NOT be italic</i>`, {
+			isAstroFlavoredMd: false,
+		});
+
+		expect(code).to.equal(`<p>&#x3C;i>This should NOT be italic&#x3C;/i></p>`);
+	});
+
+	it('should not escape entities in code blocks twice in Astro-flavored markdown', async () => {
+		const { code } = await renderMarkdown(`\`\`\`astro\n<h1>{x && x.name || ''}!</h1>\n\`\`\``, {
+			isAstroFlavoredMd: true,
+			syntaxHighlight: false,
+		});
+
+		expect(code).to.equal(
+			`<pre is:raw><code class="language-astro">&lt;h1&gt;{x &amp;&amp; x.name || ''}!&lt;/h1&gt;\n</code></pre>`
+		);
+	});
+});

package/test/expressions.test.js

@@ -1,21 +1,23 @@
 import { renderMarkdown } from '../dist/index.js';
-import chai, { expect } from 'chai';
+import chai from 'chai';
 
 describe('expressions', () => {
+	const renderAstroMd = (text, opts) => renderMarkdown(text, { isAstroFlavoredMd: true, ...opts });
+
 	it('should be able to serialize bare expression', async () => {
-		const { code } = await renderMarkdown(`{a}`, {});
+		const { code } = await renderAstroMd(`{a}`, {});
 
 		chai.expect(code).to.equal(`{a}`);
 	});
 
 	it('should be able to serialize expression inside component', async () => {
-		const { code } = await renderMarkdown(`<Component>{a}</Component>`, {});
+		const { code } = await renderAstroMd(`<Component>{a}</Component>`, {});
 
 		chai.expect(code).to.equal(`<Component>{a}</Component>`);
 	});
 
 	it('should be able to serialize expression inside markdown', async () => {
-		const { code } = await renderMarkdown(`# {frontmatter.title}`, {});
+		const { code } = await renderAstroMd(`# {frontmatter.title}`, {});
 
 		chai
 			.expect(code)
@@ -23,7 +25,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to serialize complex expression inside markdown', async () => {
-		const { code } = await renderMarkdown(`# Hello {frontmatter.name}`, {});
+		const { code } = await renderAstroMd(`# Hello {frontmatter.name}`, {});
 
 		chai
 			.expect(code)
@@ -31,7 +33,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to serialize complex expression with markup inside markdown', async () => {
-		const { code } = await renderMarkdown(`# Hello <span>{frontmatter.name}</span>`, {});
+		const { code } = await renderAstroMd(`# Hello <span>{frontmatter.name}</span>`, {});
 
 		chai
 			.expect(code)
@@ -41,7 +43,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to avoid evaluating JSX-like expressions in an inline code & generate a slug for id', async () => {
-		const { code } = await renderMarkdown(`# \`{frontmatter.title}\``, {});
+		const { code } = await renderAstroMd(`# \`{frontmatter.title}\``, {});
 
 		chai
 			.expect(code)
@@ -49,17 +51,17 @@ describe('expressions', () => {
 	});
 
 	it('should be able to avoid evaluating JSX-like expressions in inline codes', async () => {
-		const { code } = await renderMarkdown(`# \`{ foo }\` is a shorthand for \`{ foo: foo }\``, {});
+		const { code } = await renderAstroMd(`# \`{ foo }\` is a shorthand for \`{ foo: foo }\``, {});
 
 		chai
 			.expect(code)
 			.to.equal(
-				'<h1 id="-foo--is-a-shorthand-for--foo-foo-"><code is:raw>{ foo }</code> is a shorthand for <code is:raw>{ foo: foo }</code></h1>'
+				'<h1 id="-foo--is-a-shorthand-for--foo-foo"><code is:raw>{ foo }</code> is a shorthand for <code is:raw>{ foo: foo }</code></h1>'
 			);
 	});
 
 	it('should be able to avoid evaluating JSX-like expressions & escape HTML tag characters in inline codes', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`###### \`{}\` is equivalent to \`Record<never, never>\` <small>(at TypeScript v{frontmatter.version})</small>`,
 			{}
 		);
@@ -72,7 +74,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to encode ampersand characters in code blocks', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			'The ampersand in `&nbsp;` must be encoded in code blocks.',
 			{}
 		);
@@ -85,7 +87,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to encode ampersand characters in fenced code blocks', async () => {
-		const { code } = await renderMarkdown(`
+		const { code } = await renderAstroMd(`
 		\`\`\`md
 			The ampersand in \`&nbsp;\` must be encoded in code blocks.
 		\`\`\`
@@ -95,7 +97,7 @@ describe('expressions', () => {
 	});
 
 	it('should be able to serialize function expression', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`{frontmatter.list.map(item => <p id={item}>{item}</p>)}`,
 			{}
 		);
@@ -104,13 +106,13 @@ describe('expressions', () => {
 	});
 
 	it('should unwrap HTML comments in inline code blocks', async () => {
-		const { code } = await renderMarkdown(`\`{/*<!-- HTML comment -->*/}\``);
+		const { code } = await renderAstroMd(`\`{/*<!-- HTML comment -->*/}\``);
 
 		chai.expect(code).to.equal('<p><code is:raw>&lt;!-- HTML comment --&gt;</code></p>');
 	});
 
 	it('should unwrap HTML comments in code fences', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`
 			  \`\`\`
 				<!-- HTML comment -->

package/test/strictness.test.js

@@ -1,9 +1,11 @@
 import { renderMarkdown } from '../dist/index.js';
 import chai from 'chai';
 
-describe('strictness', () => {
+describe('strictness in Astro-flavored markdown', () => {
+	const renderAstroMd = (text, opts) => renderMarkdown(text, { isAstroFlavoredMd: true, ...opts });
+
 	it('should allow self-closing HTML tags (void elements)', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`Use self-closing void elements<br>like word<wbr>break and images: <img src="hi.jpg">`,
 			{}
 		);
@@ -17,25 +19,25 @@ describe('strictness', () => {
 	});
 
 	it('should allow attribute names starting with ":" after element names', async () => {
-		const { code } = await renderMarkdown(`<div :class="open ? '' : 'hidden'">Test</div>`, {});
+		const { code } = await renderAstroMd(`<div :class="open ? '' : 'hidden'">Test</div>`, {});
 
 		chai.expect(code.trim()).to.equal(`<div :class="open ? '' : 'hidden'">Test</div>`);
 	});
 
 	it('should allow attribute names starting with ":" after local element names', async () => {
-		const { code } = await renderMarkdown(`<div.abc :class="open ? '' : 'hidden'">x</div.abc>`, {});
+		const { code } = await renderAstroMd(`<div.abc :class="open ? '' : 'hidden'">x</div.abc>`, {});
 
 		chai.expect(code.trim()).to.equal(`<div.abc :class="open ? '' : 'hidden'">x</div.abc>`);
 	});
 
 	it('should allow attribute names starting with ":" after attribute names', async () => {
-		const { code } = await renderMarkdown(`<input type="text" disabled :placeholder="hi">`, {});
+		const { code } = await renderAstroMd(`<input type="text" disabled :placeholder="hi">`, {});
 
 		chai.expect(code.trim()).to.equal(`<input type="text" disabled :placeholder="hi" />`);
 	});
 
 	it('should allow attribute names starting with ":" after local attribute names', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<input type="text" x-test:disabled :placeholder="hi">`,
 			{}
 		);
@@ -44,19 +46,19 @@ describe('strictness', () => {
 	});
 
 	it('should allow attribute names starting with ":" after attribute values', async () => {
-		const { code } = await renderMarkdown(`<input type="text" :placeholder="placeholder">`, {});
+		const { code } = await renderAstroMd(`<input type="text" :placeholder="placeholder">`, {});
 
 		chai.expect(code.trim()).to.equal(`<input type="text" :placeholder="placeholder" />`);
 	});
 
 	it('should allow attribute names starting with "@" after element names', async () => {
-		const { code } = await renderMarkdown(`<button @click="handleClick">Test</button>`, {});
+		const { code } = await renderAstroMd(`<button @click="handleClick">Test</button>`, {});
 
 		chai.expect(code.trim()).to.equal(`<button @click="handleClick">Test</button>`);
 	});
 
 	it('should allow attribute names starting with "@" after local element names', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<button.local @click="handleClick">Test</button.local>`,
 			{}
 		);
@@ -65,16 +67,13 @@ describe('strictness', () => {
 	});
 
 	it('should allow attribute names starting with "@" after attribute names', async () => {
-		const { code } = await renderMarkdown(
-			`<button disabled @click="handleClick">Test</button>`,
-			{}
-		);
+		const { code } = await renderAstroMd(`<button disabled @click="handleClick">Test</button>`, {});
 
 		chai.expect(code.trim()).to.equal(`<button disabled @click="handleClick">Test</button>`);
 	});
 
 	it('should allow attribute names starting with "@" after local attribute names', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<button x-test:disabled @click="handleClick">Test</button>`,
 			{}
 		);
@@ -83,7 +82,7 @@ describe('strictness', () => {
 	});
 
 	it('should allow attribute names starting with "@" after attribute values', async () => {
-		const { code } = await renderMarkdown(
+		const { code } = await renderAstroMd(
 			`<button type="submit" @click="handleClick">Test</button>`,
 			{}
 		);
@@ -92,7 +91,7 @@ describe('strictness', () => {
 	});
 
 	it('should allow attribute names containing dots', async () => {
-		const { code } = await renderMarkdown(`<input x-on:input.debounce.500ms="fetchResults">`, {});
+		const { code } = await renderAstroMd(`<input x-on:input.debounce.500ms="fetchResults">`, {});
 
 		chai.expect(code.trim()).to.equal(`<input x-on:input.debounce.500ms="fetchResults" />`);
 	});

package/dist/rehype-collect-headers.d.ts

@@ -1,5 +0,0 @@
-import type { MarkdownHeader, RehypePlugin } from './types.js';
-export default function createCollectHeaders(): {
-    headers: MarkdownHeader[];
-    rehypeCollectHeaders: () => ReturnType<RehypePlugin>;
-};