@astrojs/markdown-remark 0.12.0 → 0.13.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
-@astrojs/markdown-remark:build: cache hit, replaying output 1546942a008a83f6
-@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: > astro-scripts build "src/**/*.ts" && tsc -p tsconfig.json
-@astrojs/markdown-remark:build: 
+@astrojs/markdown-remark:build: cache hit, replaying output a1025d081834f1c0
+@astrojs/markdown-remark:build: 
+@astrojs/markdown-remark:build: > @astrojs/markdown-remark@0.13.0 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,32 @@
 # @astrojs/markdown-remark
 
+## 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,5 +1,5 @@
 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";
@@ -20,21 +20,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(isAstroFlavoredMd ? [remarkMdxish, remarkMarkAndUnravel, remarkUnwrap, remarkEscape] : []);
   if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
     remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
     rehypePlugins = [...DEFAULT_REHYPE_PLUGINS];
@@ -57,20 +56,22 @@ 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 });
+  parser.use(
+    isAstroFlavoredMd ? [rehypeJsx, rehypeExpressions, rehypeEscape, rehypeIslands, rehypeCollectHeadings] : [rehypeCollectHeadings, rehypeRaw]
+  ).use(rehypeStringify, { allowDangerousHtml: true });
   let result;
   try {
     const vfile = await parser.process(input);
@@ -81,7 +82,7 @@ async function renderMarkdown(content, opts = {}) {
     throw err;
   }
   return {
-    metadata: { headers, source: content, html: result.toString() },
+    metadata: { headings, source: content, html: result.toString() },
     code: result.toString()
   };
 }

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/remark-prism.js

@@ -43,7 +43,9 @@ function transformer(className) {
       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

@@ -27,14 +27,15 @@ 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;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/markdown-remark",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "type": "module",
   "author": "withastro",
   "license": "MIT",

package/src/index.ts

@@ -1,7 +1,7 @@
 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';
@@ -29,25 +29,23 @@ 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(isAstroFlavoredMd ? [remarkMdxish, remarkMarkAndUnravel, remarkUnwrap, remarkEscape] : []);
 
 	if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
 		remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
@@ -76,13 +74,15 @@ export async function renderMarkdown(
 			markdownToHtml as any,
 			{
 				allowDangerousHtml: true,
-				passThrough: [
-					'raw',
-					'mdxFlowExpression',
-					'mdxJsxFlowElement',
-					'mdxJsxTextElement',
-					'mdxTextExpression',
-				],
+				passThrough: isAstroFlavoredMd
+					? [
+							'raw',
+							'mdxFlowExpression',
+							'mdxJsxFlowElement',
+							'mdxJsxTextElement',
+							'mdxTextExpression',
+					  ]
+					: [],
 			},
 		],
 	]);
@@ -92,10 +92,11 @@ 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;
@@ -112,7 +113,7 @@ export async function renderMarkdown(
 	}
 
 	return {
-		metadata: { headers, source: content, html: result.toString() },
+		metadata: { headings, source: content, html: result.toString() },
 		code: result.toString(),
 	};
 }

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/types.ts

@@ -41,16 +41,17 @@ 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;
 }

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/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>;
-};