14 files changed, 301 insertions, 301 deletions

diff --git a/packages/markdown/remark/src/index.ts b/packages/markdown/remark/src/index.ts
index 88033db14..e8242279a 100644
--- a/packages/markdown/remark/src/index.ts
+++ b/packages/markdown/remark/src/index.ts
@@ -23,9 +23,9 @@ export { AstroMarkdownOptions, MarkdownRenderingOptions };
 
 /** Internal utility for rendering a full markdown file and extracting Frontmatter data */
 export async function renderMarkdownWithFrontmatter(contents: string, opts?: MarkdownRenderingOptions | null) {
-  const { data: frontmatter, content } = matter(contents);
-  const value = await renderMarkdown(content, opts);
-  return { ...value, frontmatter };
+	const { data: frontmatter, content } = matter(contents);
+	const value = await renderMarkdown(content, opts);
+	return { ...value, frontmatter };
 }
 
 export const DEFAULT_REMARK_PLUGINS = ['remark-gfm', 'remark-smartypants'];
@@ -34,63 +34,63 @@ export const DEFAULT_REHYPE_PLUGINS = ['rehype-slug'];
 
 /** Shared utility for rendering markdown */
 export async function renderMarkdown(content: string, opts?: MarkdownRenderingOptions | null) {
-  let { remarkPlugins = [], rehypePlugins = [] } = opts ?? {};
-  const scopedClassName = opts?.$?.scopedClassName;
-  const mode = opts?.mode ?? 'mdx';
-  const isMDX = mode === 'mdx';
-  const { headers, rehypeCollectHeaders } = createCollectHeaders();
-
-  await Promise.all([loadRemarkExpressions(), loadRemarkJsx()]); // Vite bug: dynamically import() these because of CJS interop (this will cache)
-
-  let parser = unified()
-    .use(markdown)
-    .use(isMDX ? [remarkJsx] : [])
-    .use(isMDX ? [remarkExpressions] : [])
-    .use([remarkUnwrap]);
-
-  if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
-    remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
-    rehypePlugins = [...DEFAULT_REHYPE_PLUGINS];
-  }
-
-  const loadedRemarkPlugins = await Promise.all(loadPlugins(remarkPlugins));
-  const loadedRehypePlugins = await Promise.all(loadPlugins(rehypePlugins));
-
-  loadedRemarkPlugins.forEach(([plugin, opts]) => {
-    parser.use([[plugin, opts]]);
-  });
-
-  if (scopedClassName) {
-    parser.use([scopedStyles(scopedClassName)]);
-  }
-
-  parser.use([remarkPrism(scopedClassName)]);
-  parser.use([[markdownToHtml as any, { allowDangerousHtml: true, passThrough: ['raw', 'mdxTextExpression', 'mdxJsxTextElement', 'mdxJsxFlowElement'] }]]);
-
-  loadedRehypePlugins.forEach(([plugin, opts]) => {
-    parser.use([[plugin, opts]]);
-  });
-
-  parser
-    .use(isMDX ? [rehypeJsx] : [])
-    .use(isMDX ? [rehypeExpressions] : [])
-    .use(isMDX ? [] : [rehypeRaw])
-    .use(isMDX ? [rehypeEscape] : [])
-    .use(rehypeIslands);
-
-  let result: string;
-  try {
-    const vfile = await parser.use([rehypeCollectHeaders]).use(rehypeStringify, { allowDangerousHtml: true }).process(content);
-    result = vfile.toString();
-  } catch (err) {
-    console.error(err);
-    throw err;
-  }
-
-  return {
-    metadata: { headers, source: content, html: result.toString() },
-    code: result.toString(),
-  };
+	let { remarkPlugins = [], rehypePlugins = [] } = opts ?? {};
+	const scopedClassName = opts?.$?.scopedClassName;
+	const mode = opts?.mode ?? 'mdx';
+	const isMDX = mode === 'mdx';
+	const { headers, rehypeCollectHeaders } = createCollectHeaders();
+
+	await Promise.all([loadRemarkExpressions(), loadRemarkJsx()]); // Vite bug: dynamically import() these because of CJS interop (this will cache)
+
+	let parser = unified()
+		.use(markdown)
+		.use(isMDX ? [remarkJsx] : [])
+		.use(isMDX ? [remarkExpressions] : [])
+		.use([remarkUnwrap]);
+
+	if (remarkPlugins.length === 0 && rehypePlugins.length === 0) {
+		remarkPlugins = [...DEFAULT_REMARK_PLUGINS];
+		rehypePlugins = [...DEFAULT_REHYPE_PLUGINS];
+	}
+
+	const loadedRemarkPlugins = await Promise.all(loadPlugins(remarkPlugins));
+	const loadedRehypePlugins = await Promise.all(loadPlugins(rehypePlugins));
+
+	loadedRemarkPlugins.forEach(([plugin, opts]) => {
+		parser.use([[plugin, opts]]);
+	});
+
+	if (scopedClassName) {
+		parser.use([scopedStyles(scopedClassName)]);
+	}
+
+	parser.use([remarkPrism(scopedClassName)]);
+	parser.use([[markdownToHtml as any, { allowDangerousHtml: true, passThrough: ['raw', 'mdxTextExpression', 'mdxJsxTextElement', 'mdxJsxFlowElement'] }]]);
+
+	loadedRehypePlugins.forEach(([plugin, opts]) => {
+		parser.use([[plugin, opts]]);
+	});
+
+	parser
+		.use(isMDX ? [rehypeJsx] : [])
+		.use(isMDX ? [rehypeExpressions] : [])
+		.use(isMDX ? [] : [rehypeRaw])
+		.use(isMDX ? [rehypeEscape] : [])
+		.use(rehypeIslands);
+
+	let result: string;
+	try {
+		const vfile = await parser.use([rehypeCollectHeaders]).use(rehypeStringify, { allowDangerousHtml: true }).process(content);
+		result = vfile.toString();
+	} catch (err) {
+		console.error(err);
+		throw err;
+	}
+
+	return {
+		metadata: { headers, source: content, html: result.toString() },
+		code: result.toString(),
+	};
 }
 
 export default renderMarkdownWithFrontmatter;
diff --git a/packages/markdown/remark/src/load-plugins.ts b/packages/markdown/remark/src/load-plugins.ts
index 6d30e8361..b1e72ae36 100644
--- a/packages/markdown/remark/src/load-plugins.ts
+++ b/packages/markdown/remark/src/load-plugins.ts
@@ -2,26 +2,26 @@ import * as unified from 'unified';
 import type { Plugin, UnifiedPluginImport } from './types';
 
 async function importPlugin(p: string | UnifiedPluginImport): UnifiedPluginImport {
-  if (typeof p === 'string') {
-    return await import(p);
-  }
+	if (typeof p === 'string') {
+		return await import(p);
+	}
 
-  return await p;
+	return await p;
 }
 
 export function loadPlugins(items: Plugin[]): Promise<[unified.Plugin] | [unified.Plugin, any]>[] {
-  return items.map((p) => {
-    return new Promise((resolve, reject) => {
-      if (Array.isArray(p)) {
-        const [plugin, opts] = p;
-        return importPlugin(plugin)
-          .then((m) => resolve([m.default, opts]))
-          .catch((e) => reject(e));
-      }
+	return items.map((p) => {
+		return new Promise((resolve, reject) => {
+			if (Array.isArray(p)) {
+				const [plugin, opts] = p;
+				return importPlugin(plugin)
+					.then((m) => resolve([m.default, opts]))
+					.catch((e) => reject(e));
+			}
 
-      return importPlugin(p)
-        .then((m) => resolve([m.default]))
-        .catch((e) => reject(e));
-    });
-  });
+			return importPlugin(p)
+				.then((m) => resolve([m.default]))
+				.catch((e) => reject(e));
+		});
+	});
 }
diff --git a/packages/markdown/remark/src/rehype-collect-headers.ts b/packages/markdown/remark/src/rehype-collect-headers.ts
index fc157c9b7..45138f624 100644
--- a/packages/markdown/remark/src/rehype-collect-headers.ts
+++ b/packages/markdown/remark/src/rehype-collect-headers.ts
@@ -4,35 +4,35 @@ import slugger from 'github-slugger';
 
 /**  */
 export default function createCollectHeaders() {
-  const headers: any[] = [];
+	const headers: any[] = [];
 
-  function rehypeCollectHeaders() {
-    return function (tree: Root) {
-      visit(tree, (node) => {
-        if (node.type !== 'element') return;
-        const { tagName } = node;
-        if (tagName[0] !== 'h') return;
-        const [_, level] = tagName.match(/h([0-6])/) ?? [];
-        if (!level) return;
-        const depth = Number.parseInt(level);
+	function rehypeCollectHeaders() {
+		return function (tree: Root) {
+			visit(tree, (node) => {
+				if (node.type !== 'element') return;
+				const { tagName } = node;
+				if (tagName[0] !== 'h') return;
+				const [_, level] = tagName.match(/h([0-6])/) ?? [];
+				if (!level) return;
+				const depth = Number.parseInt(level);
 
-        let text = '';
+				let text = '';
 
-        visit(node, 'text', (child) => {
-          text += child.value;
-        });
+				visit(node, 'text', (child) => {
+					text += child.value;
+				});
 
-        let slug = node?.properties?.id || slugger.slug(text);
+				let slug = node?.properties?.id || slugger.slug(text);
 
-        node.properties = node.properties || {};
-        node.properties.id = slug;
-        headers.push({ depth, slug, text });
-      });
-    };
-  }
+				node.properties = node.properties || {};
+				node.properties.id = slug;
+				headers.push({ depth, slug, text });
+			});
+		};
+	}
 
-  return {
-    headers,
-    rehypeCollectHeaders,
-  };
+	return {
+		headers,
+		rehypeCollectHeaders,
+	};
 }
diff --git a/packages/markdown/remark/src/rehype-escape.ts b/packages/markdown/remark/src/rehype-escape.ts
index e0094b463..04c931fbf 100644
--- a/packages/markdown/remark/src/rehype-escape.ts
+++ b/packages/markdown/remark/src/rehype-escape.ts
@@ -1,12 +1,12 @@
 import { SKIP, visit } from 'unist-util-visit';
 
 export default function rehypeEscape(): any {
-  return function (node: any): any {
-    return visit(node, 'element', (el) => {
-      if (el.tagName === 'code' || el.tagName === 'pre') {
-        el.properties['data-astro-raw'] = true;
-      }
-      return el;
-    });
-  };
+	return function (node: any): any {
+		return visit(node, 'element', (el) => {
+			if (el.tagName === 'code' || el.tagName === 'pre') {
+				el.properties['data-astro-raw'] = true;
+			}
+			return el;
+		});
+	};
 }
diff --git a/packages/markdown/remark/src/rehype-expressions.ts b/packages/markdown/remark/src/rehype-expressions.ts
index d296c2afe..26d04623d 100644
--- a/packages/markdown/remark/src/rehype-expressions.ts
+++ b/packages/markdown/remark/src/rehype-expressions.ts
@@ -1,12 +1,12 @@
 import { map } from 'unist-util-map';
 
 export default function rehypeExpressions(): any {
-  return function (node: any): any {
-    return map(node, (child) => {
-      if (child.type === 'mdxTextExpression') {
-        return { type: 'text', value: `{${(child as any).value}}` };
-      }
-      return child;
-    });
-  };
+	return function (node: any): any {
+		return map(node, (child) => {
+			if (child.type === 'mdxTextExpression') {
+				return { type: 'text', value: `{${(child as any).value}}` };
+			}
+			return child;
+		});
+	};
 }
diff --git a/packages/markdown/remark/src/rehype-islands.ts b/packages/markdown/remark/src/rehype-islands.ts
index e3fa09860..868f9096e 100644
--- a/packages/markdown/remark/src/rehype-islands.ts
+++ b/packages/markdown/remark/src/rehype-islands.ts
@@ -9,27 +9,27 @@ const visit = _visit as (node: any, type: string, callback?: (node: any, index:
 // For hydration to work properly, frameworks need the DOM to be the exact same on server/client.
 // This reverts some "helpful corrections" that are applied to our perfectly valid HTML!
 export default function rehypeIslands(): any {
-  return function (node: any): any {
-    return visit(node, 'element', (el) => {
-      // Bugs only happen inside of <astro-root> islands
-      if (el.tagName == 'astro-root') {
-        visit(el, 'text', (child, index, parent) => {
-          if (child.type === 'text') {
-            // Sometimes comments can be trapped as text, which causes them to be escaped
-            // This casts them back to real HTML comments
-            if (parent && child.value.indexOf('<!--') > -1 && index != null) {
-              parent.children.splice(index, 1, { ...child, type: 'comment', value: child.value.replace('<!--', '').replace('-->', '').trim() });
-              return [SKIP, index];
-            }
-            // For some reason `rehype` likes to inject extra linebreaks,
-            // but React and Vue throw hydration errors when they see these!
-            // This removes any extra linebreaks, which is fine because
-            // framework compilers don't preserve them anyway
-            child.value = child.value.replace(/\n+/g, '');
-            return child;
-          }
-        });
-      }
-    });
-  };
+	return function (node: any): any {
+		return visit(node, 'element', (el) => {
+			// Bugs only happen inside of <astro-root> islands
+			if (el.tagName == 'astro-root') {
+				visit(el, 'text', (child, index, parent) => {
+					if (child.type === 'text') {
+						// Sometimes comments can be trapped as text, which causes them to be escaped
+						// This casts them back to real HTML comments
+						if (parent && child.value.indexOf('<!--') > -1 && index != null) {
+							parent.children.splice(index, 1, { ...child, type: 'comment', value: child.value.replace('<!--', '').replace('-->', '').trim() });
+							return [SKIP, index];
+						}
+						// For some reason `rehype` likes to inject extra linebreaks,
+						// but React and Vue throw hydration errors when they see these!
+						// This removes any extra linebreaks, which is fine because
+						// framework compilers don't preserve them anyway
+						child.value = child.value.replace(/\n+/g, '');
+						return child;
+					}
+				});
+			}
+		});
+	};
 }
diff --git a/packages/markdown/remark/src/rehype-jsx.ts b/packages/markdown/remark/src/rehype-jsx.ts
index 94632efed..cccbd5548 100644
--- a/packages/markdown/remark/src/rehype-jsx.ts
+++ b/packages/markdown/remark/src/rehype-jsx.ts
@@ -2,28 +2,28 @@ import { map } from 'unist-util-map';
 
 const MDX_ELEMENTS = new Set(['mdxJsxFlowElement', 'mdxJsxTextElement']);
 export default function rehypeJsx(): any {
-  return function (node: any): any {
-    return map(node, (child: any) => {
-      if (child.type === 'element') {
-        return { ...child, tagName: `${child.tagName}` };
-      }
-      if (MDX_ELEMENTS.has(child.type)) {
-        return {
-          ...child,
-          type: 'element',
-          tagName: `${child.name}`,
-          properties: child.attributes.reduce((acc: any[], entry: any) => {
-            let attr = entry.value;
-            if (attr && typeof attr === 'object') {
-              attr = `{${attr.value}}`;
-            } else if (attr === null) {
-              attr = `{true}`;
-            }
-            return Object.assign(acc, { [entry.name]: attr });
-          }, {}),
-        };
-      }
-      return child;
-    });
-  };
+	return function (node: any): any {
+		return map(node, (child: any) => {
+			if (child.type === 'element') {
+				return { ...child, tagName: `${child.tagName}` };
+			}
+			if (MDX_ELEMENTS.has(child.type)) {
+				return {
+					...child,
+					type: 'element',
+					tagName: `${child.name}`,
+					properties: child.attributes.reduce((acc: any[], entry: any) => {
+						let attr = entry.value;
+						if (attr && typeof attr === 'object') {
+							attr = `{${attr.value}}`;
+						} else if (attr === null) {
+							attr = `{true}`;
+						}
+						return Object.assign(acc, { [entry.name]: attr });
+					}, {}),
+				};
+			}
+			return child;
+		});
+	};
 }
diff --git a/packages/markdown/remark/src/remark-expressions.ts b/packages/markdown/remark/src/remark-expressions.ts
index 0966cc0be..be6bc09ed 100644
--- a/packages/markdown/remark/src/remark-expressions.ts
+++ b/packages/markdown/remark/src/remark-expressions.ts
@@ -4,28 +4,28 @@ let mdxExpressionFromMarkdown: any;
 let mdxExpressionToMarkdown: any;
 
 export function remarkExpressions(this: any, options: any) {
-  let settings = options || {};
-  let data = this.data();
+	let settings = options || {};
+	let data = this.data();
 
-  add('micromarkExtensions', mdxExpression({}));
-  add('fromMarkdownExtensions', mdxExpressionFromMarkdown);
-  add('toMarkdownExtensions', mdxExpressionToMarkdown);
+	add('micromarkExtensions', mdxExpression({}));
+	add('fromMarkdownExtensions', mdxExpressionFromMarkdown);
+	add('toMarkdownExtensions', mdxExpressionToMarkdown);
 
-  function add(field: any, value: any) {
-    /* istanbul ignore if - other extensions. */
-    if (data[field]) data[field].push(value);
-    else data[field] = [value];
-  }
+	function add(field: any, value: any) {
+		/* istanbul ignore if - other extensions. */
+		if (data[field]) data[field].push(value);
+		else data[field] = [value];
+	}
 }
 
 export async function loadRemarkExpressions() {
-  if (!mdxExpression) {
-    const micromarkMdxExpression = await import('micromark-extension-mdx-expression');
-    mdxExpression = micromarkMdxExpression.mdxExpression;
-  }
-  if (!mdxExpressionFromMarkdown || !mdxExpressionToMarkdown) {
-    const mdastUtilMdxExpression = await import('mdast-util-mdx-expression');
-    mdxExpressionFromMarkdown = mdastUtilMdxExpression.mdxExpressionFromMarkdown;
-    mdxExpressionToMarkdown = mdastUtilMdxExpression.mdxExpressionToMarkdown;
-  }
+	if (!mdxExpression) {
+		const micromarkMdxExpression = await import('micromark-extension-mdx-expression');
+		mdxExpression = micromarkMdxExpression.mdxExpression;
+	}
+	if (!mdxExpressionFromMarkdown || !mdxExpressionToMarkdown) {
+		const mdastUtilMdxExpression = await import('mdast-util-mdx-expression');
+		mdxExpressionFromMarkdown = mdastUtilMdxExpression.mdxExpressionFromMarkdown;
+		mdxExpressionToMarkdown = mdastUtilMdxExpression.mdxExpressionToMarkdown;
+	}
 }
diff --git a/packages/markdown/remark/src/remark-jsx.ts b/packages/markdown/remark/src/remark-jsx.ts
index 7c7333781..637bac9ee 100644
--- a/packages/markdown/remark/src/remark-jsx.ts
+++ b/packages/markdown/remark/src/remark-jsx.ts
@@ -4,28 +4,28 @@ let mdxJsxFromMarkdown: any;
 let mdxJsxToMarkdown: any;
 
 export function remarkJsx(this: any, options: any) {
-  let settings = options || {};
-  let data = this.data();
+	let settings = options || {};
+	let data = this.data();
 
-  // TODO this seems to break adding slugs, no idea why add('micromarkExtensions', mdxJsx({}));
-  add('fromMarkdownExtensions', mdxJsxFromMarkdown);
-  add('toMarkdownExtensions', mdxJsxToMarkdown);
+	// TODO this seems to break adding slugs, no idea why add('micromarkExtensions', mdxJsx({}));
+	add('fromMarkdownExtensions', mdxJsxFromMarkdown);
+	add('toMarkdownExtensions', mdxJsxToMarkdown);
 
-  function add(field: any, value: any) {
-    /* istanbul ignore if - other extensions. */
-    if (data[field]) data[field].push(value);
-    else data[field] = [value];
-  }
+	function add(field: any, value: any) {
+		/* istanbul ignore if - other extensions. */
+		if (data[field]) data[field].push(value);
+		else data[field] = [value];
+	}
 }
 
 export async function loadRemarkJsx() {
-  if (!mdxJsx) {
-    const micromarkMdxJsx = await import('micromark-extension-mdx-jsx');
-    mdxJsx = micromarkMdxJsx.mdxJsx;
-  }
-  if (!mdxJsxFromMarkdown || !mdxJsxToMarkdown) {
-    const mdastUtilMdxJsx = await import('mdast-util-mdx-jsx');
-    mdxJsxFromMarkdown = mdastUtilMdxJsx.mdxJsxFromMarkdown;
-    mdxJsxToMarkdown = mdastUtilMdxJsx.mdxJsxToMarkdown;
-  }
+	if (!mdxJsx) {
+		const micromarkMdxJsx = await import('micromark-extension-mdx-jsx');
+		mdxJsx = micromarkMdxJsx.mdxJsx;
+	}
+	if (!mdxJsxFromMarkdown || !mdxJsxToMarkdown) {
+		const mdastUtilMdxJsx = await import('mdast-util-mdx-jsx');
+		mdxJsxFromMarkdown = mdastUtilMdxJsx.mdxJsxFromMarkdown;
+		mdxJsxToMarkdown = mdastUtilMdxJsx.mdxJsxToMarkdown;
+	}
 }
diff --git a/packages/markdown/remark/src/remark-prism.ts b/packages/markdown/remark/src/remark-prism.ts
index d7a4ff996..cb6d1cd8e 100644
--- a/packages/markdown/remark/src/remark-prism.ts
+++ b/packages/markdown/remark/src/remark-prism.ts
@@ -7,64 +7,64 @@ const noVisit = new Set(['root', 'html', 'text']);
 const languageMap = new Map([['ts', 'typescript']]);
 
 function runHighlighter(lang: string, code: string) {
-  let classLanguage = `language-${lang}`;
+	let classLanguage = `language-${lang}`;
 
-  if (lang == null) {
-    lang = 'plaintext';
-  }
+	if (lang == null) {
+		lang = 'plaintext';
+	}
 
-  const ensureLoaded = (lang: string) => {
-    if (lang && !Prism.languages[lang]) {
-      loadLanguages([lang]);
-    }
-  };
+	const ensureLoaded = (lang: string) => {
+		if (lang && !Prism.languages[lang]) {
+			loadLanguages([lang]);
+		}
+	};
 
-  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 (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]) {
-    console.warn(`Unable to load the language: ${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);
-  }
+	const grammar = Prism.languages[lang];
+	let html = code;
+	if (grammar) {
+		html = Prism.highlight(code, grammar, lang);
+	}
 
-  return { classLanguage, html };
+	return { classLanguage, html };
 }
 
 type MaybeString = string | null | undefined;
 
 /**  */
 function transformer(className: MaybeString) {
-  return function (tree: any) {
-    const visitor = (node: any) => {
-      let { lang, value } = node;
-      node.type = 'html';
+	return function (tree: any) {
+		const visitor = (node: any) => {
+			let { lang, value } = node;
+			node.type = 'html';
 
-      let { html, classLanguage } = runHighlighter(lang, value);
-      let classes = [classLanguage];
-      if (className) {
-        classes.push(className);
-      }
-      node.value = `<pre class="${classes.join(' ')}"><code data-astro-raw class="${classLanguage}">${html}</code></pre>`;
-      return node;
-    };
-    return visit(tree, 'code', visitor);
-  };
+			let { html, classLanguage } = runHighlighter(lang, value);
+			let classes = [classLanguage];
+			if (className) {
+				classes.push(className);
+			}
+			node.value = `<pre class="${classes.join(' ')}"><code data-astro-raw class="${classLanguage}">${html}</code></pre>`;
+			return node;
+		};
+		return visit(tree, 'code', visitor);
+	};
 }
 
 function plugin(className: MaybeString) {
-  return transformer.bind(null, className);
+	return transformer.bind(null, className);
 }
 
 export default plugin;
diff --git a/packages/markdown/remark/src/remark-scoped-styles.ts b/packages/markdown/remark/src/remark-scoped-styles.ts
index 9ca70c029..ba8780bb7 100644
--- a/packages/markdown/remark/src/remark-scoped-styles.ts
+++ b/packages/markdown/remark/src/remark-scoped-styles.ts
@@ -3,16 +3,16 @@ const noVisit = new Set(['root', 'html', 'text']);
 
 /**  */
 export default function scopedStyles(className: string) {
-  const visitor = (node: any) => {
-    if (noVisit.has(node.type)) return;
+	const visitor = (node: any) => {
+		if (noVisit.has(node.type)) return;
 
-    const { data } = node;
-    let currentClassName = data?.hProperties?.class ?? '';
-    node.data = node.data || {};
-    node.data.hProperties = node.data.hProperties || {};
-    node.data.hProperties.class = `${className} ${currentClassName}`.trim();
+		const { data } = node;
+		let currentClassName = data?.hProperties?.class ?? '';
+		node.data = node.data || {};
+		node.data.hProperties = node.data.hProperties || {};
+		node.data.hProperties.class = `${className} ${currentClassName}`.trim();
 
-    return node;
-  };
-  return () => (tree: any) => visit(tree, visitor);
+		return node;
+	};
+	return () => (tree: any) => visit(tree, visitor);
 }
diff --git a/packages/markdown/remark/src/remark-slug.ts b/packages/markdown/remark/src/remark-slug.ts
index 4454d1087..6d8ddcf2d 100644
--- a/packages/markdown/remark/src/remark-slug.ts
+++ b/packages/markdown/remark/src/remark-slug.ts
@@ -15,18 +15,18 @@ const slugs = new BananaSlug();
  * @type {import('unified').Plugin<void[], Root>}
  */
 export default function remarkSlug() {
-  return (tree: any) => {
-    slugs.reset();
-    visit(tree, (node) => {
-      console.log(node);
-    });
-    visit(tree, 'heading', (node) => {
-      const data = node.data || (node.data = {});
-      const props = /** @type {Properties} */ data.hProperties || (data.hProperties = {});
-      let id = props.id;
-      id = id ? slugs.slug(String(id), true) : slugs.slug(toString(node));
-      data.id = id;
-      props.id = id;
-    });
-  };
+	return (tree: any) => {
+		slugs.reset();
+		visit(tree, (node) => {
+			console.log(node);
+		});
+		visit(tree, 'heading', (node) => {
+			const data = node.data || (node.data = {});
+			const props = /** @type {Properties} */ data.hProperties || (data.hProperties = {});
+			let id = props.id;
+			id = id ? slugs.slug(String(id), true) : slugs.slug(toString(node));
+			data.id = id;
+			props.id = id;
+		});
+	};
 }
diff --git a/packages/markdown/remark/src/remark-unwrap.ts b/packages/markdown/remark/src/remark-unwrap.ts
index 15ddb7779..6da2a496a 100644
--- a/packages/markdown/remark/src/remark-unwrap.ts
+++ b/packages/markdown/remark/src/remark-unwrap.ts
@@ -6,33 +6,33 @@ const visit = _visit as (node: any, type: string, callback?: (node: any, index:
 
 // Remove the wrapping paragraph for <astro-root> islands
 export default function remarkUnwrap() {
-  const astroRootNodes = new Set();
-  let insideAstroRoot = false;
+	const astroRootNodes = new Set();
+	let insideAstroRoot = false;
 
-  return (tree: any) => {
-    // reset state
-    insideAstroRoot = false;
-    astroRootNodes.clear();
+	return (tree: any) => {
+		// reset state
+		insideAstroRoot = false;
+		astroRootNodes.clear();
 
-    visit(tree, 'html', (node) => {
-      if (node.value.indexOf('<astro-root') > -1 && !insideAstroRoot) {
-        insideAstroRoot = true;
-      }
-      if (node.value.indexOf('</astro-root') > -1 && insideAstroRoot) {
-        insideAstroRoot = false;
-      }
-      astroRootNodes.add(node);
-    });
+		visit(tree, 'html', (node) => {
+			if (node.value.indexOf('<astro-root') > -1 && !insideAstroRoot) {
+				insideAstroRoot = true;
+			}
+			if (node.value.indexOf('</astro-root') > -1 && insideAstroRoot) {
+				insideAstroRoot = false;
+			}
+			astroRootNodes.add(node);
+		});
 
-    visit(tree, 'paragraph', (node, index, parent) => {
-      if (parent && typeof index === 'number' && containsAstroRootNode(node)) {
-        parent.children.splice(index, 1, ...node.children);
-        return [SKIP, index];
-      }
-    });
-  };
+		visit(tree, 'paragraph', (node, index, parent) => {
+			if (parent && typeof index === 'number' && containsAstroRootNode(node)) {
+				parent.children.splice(index, 1, ...node.children);
+				return [SKIP, index];
+			}
+		});
+	};
 
-  function containsAstroRootNode(node: any) {
-    return node.children.map((child: any) => astroRootNodes.has(child)).reduce((all: boolean, v: boolean) => (all ? all : v), false);
-  }
+	function containsAstroRootNode(node: any) {
+		return node.children.map((child: any) => astroRootNodes.has(child)).reduce((all: boolean, v: boolean) => (all ? all : v), false);
+	}
 }
diff --git a/packages/markdown/remark/src/types.ts b/packages/markdown/remark/src/types.ts
index 8ae7795d0..541d3ff27 100644
--- a/packages/markdown/remark/src/types.ts
+++ b/packages/markdown/remark/src/types.ts
@@ -4,14 +4,14 @@ export type UnifiedPluginImport = Promise<{ default: unified.Plugin }>;
 export type Plugin = string | [string, any] | UnifiedPluginImport | [UnifiedPluginImport, any];
 
 export interface AstroMarkdownOptions {
-  mode?: 'md' | 'mdx';
-  remarkPlugins?: Plugin[];
-  rehypePlugins?: Plugin[];
+	mode?: 'md' | 'mdx';
+	remarkPlugins?: Plugin[];
+	rehypePlugins?: Plugin[];
 }
 
 export interface MarkdownRenderingOptions extends Partial<AstroMarkdownOptions> {
-  /** @internal */
-  $?: {
-    scopedClassName: string | null;
-  };
+	/** @internal */
+	$?: {
+		scopedClassName: string | null;
+	};
 }