@astrojs/markdown-remark 5.2.0 → 6.0.0-alpha.1

package/dist/frontmatter.d.ts

@@ -0,0 +1 @@
+export declare function isFrontmatterValid(frontmatter: Record<string, any>): boolean;

package/dist/frontmatter.js

@@ -0,0 +1,11 @@
+function isFrontmatterValid(frontmatter) {
+  try {
+    JSON.stringify(frontmatter);
+  } catch {
+    return false;
+  }
+  return typeof frontmatter === "object" && frontmatter !== null;
+}
+export {
+  isFrontmatterValid
+};

package/dist/highlight.d.ts

@@ -1,7 +1,7 @@
 import type { Root } from 'hast';
 type Highlighter = (code: string, language: string, options?: {
     meta?: string;
-}) => Promise<string>;
+}) => Promise<Root | string>;
 /**
  * A hast utility to syntax highlight code blocks with a given syntax highlighter.
  *

package/dist/highlight.js

@@ -16,13 +16,13 @@ async function highlightCodeBlocks(tree, highlighter) {
     let languageMatch;
     let { className } = node.properties;
     if (typeof className === "string") {
-      languageMatch = className.match(languagePattern);
+      languageMatch = languagePattern.exec(className);
     } else if (Array.isArray(className)) {
       for (const cls of className) {
         if (typeof cls !== "string") {
           continue;
         }
-        languageMatch = cls.match(languagePattern);
+        languageMatch = languagePattern.exec(cls);
         if (languageMatch) {
           break;
         }
@@ -41,9 +41,14 @@ async function highlightCodeBlocks(tree, highlighter) {
   for (const { node, language, grandParent, parent } of nodes) {
     const meta = node.data?.meta ?? node.properties.metastring ?? void 0;
     const code = toText(node, { whitespace: "pre" });
-    const html = await highlighter(code, language, { meta });
-    const replacement = fromHtml(html, { fragment: true }).children[0];
-    removePosition(replacement);
+    const result = await highlighter(code, language, { meta });
+    let replacement;
+    if (typeof result === "string") {
+      replacement = fromHtml(result, { fragment: true }).children[0];
+      removePosition(replacement);
+    } else {
+      replacement = result.children[0];
+    }
     const index = grandParent.children.indexOf(parent);
     grandParent.children[index] = replacement;
   }

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import type { AstroMarkdownOptions, MarkdownProcessor } from './types.js';
-export { InvalidAstroDataError, setVfileFrontmatter } from './frontmatter-injection.js';
 export { rehypeHeadingIds } from './rehype-collect-headings.js';
 export { remarkCollectImages } from './remark-collect-images.js';
 export { rehypePrism } from './rehype-prism.js';
 export { rehypeShiki } from './rehype-shiki.js';
-export { createShikiHighlighter, type ShikiHighlighter } from './shiki.js';
+export { isFrontmatterValid } from './frontmatter.js';
+export { createShikiHighlighter, type ShikiHighlighter, type CreateShikiHighlighterOptions, type ShikiHighlighterHighlightOptions, } from './shiki.js';
 export * from './types.js';
 export declare const markdownConfigDefaults: Required<AstroMarkdownOptions>;
 /**

package/dist/index.js

@@ -1,8 +1,3 @@
-import {
-  InvalidAstroDataError,
-  safelyGetAstroData,
-  setVfileFrontmatter
-} from "./frontmatter-injection.js";
 import { loadPlugins } from "./load-plugins.js";
 import { rehypeHeadingIds } from "./rehype-collect-headings.js";
 import { rehypePrism } from "./rehype-prism.js";
@@ -17,12 +12,14 @@ import remarkSmartypants from "remark-smartypants";
 import { unified } from "unified";
 import { VFile } from "vfile";
 import { rehypeImages } from "./rehype-images.js";
-import { InvalidAstroDataError as InvalidAstroDataError2, setVfileFrontmatter as setVfileFrontmatter2 } from "./frontmatter-injection.js";
 import { rehypeHeadingIds as rehypeHeadingIds2 } from "./rehype-collect-headings.js";
 import { remarkCollectImages as remarkCollectImages2 } from "./remark-collect-images.js";
 import { rehypePrism as rehypePrism2 } from "./rehype-prism.js";
 import { rehypeShiki as rehypeShiki2 } from "./rehype-shiki.js";
-import { createShikiHighlighter } from "./shiki.js";
+import { isFrontmatterValid } from "./frontmatter.js";
+import {
+  createShikiHighlighter
+} from "./shiki.js";
 export * from "./types.js";
 const markdownConfigDefaults = {
   syntaxHighlight: "shiki",
@@ -89,23 +86,26 @@ async function createMarkdownProcessor(opts) {
   parser.use(rehypeRaw).use(rehypeStringify, { allowDangerousHtml: true });
   return {
     async render(content, renderOpts) {
-      const vfile = new VFile({ value: content, path: renderOpts?.fileURL });
-      setVfileFrontmatter(vfile, renderOpts?.frontmatter ?? {});
+      const vfile = new VFile({
+        value: content,
+        path: renderOpts?.fileURL,
+        data: {
+          astro: {
+            frontmatter: renderOpts?.frontmatter ?? {}
+          }
+        }
+      });
       const result = await parser.process(vfile).catch((err) => {
         err = prefixError(err, `Failed to parse Markdown file "${vfile.path}"`);
         console.error(err);
         throw err;
       });
-      const astroData = safelyGetAstroData(result.data);
-      if (astroData instanceof InvalidAstroDataError) {
-        throw astroData;
-      }
       return {
         code: String(result.value),
         metadata: {
-          headings: result.data.__astroHeadings ?? [],
-          imagePaths: result.data.imagePaths ?? /* @__PURE__ */ new Set(),
-          frontmatter: astroData.frontmatter ?? {}
+          headings: result.data.astro?.headings ?? [],
+          imagePaths: result.data.astro?.imagePaths ?? [],
+          frontmatter: result.data.astro?.frontmatter ?? {}
         }
       };
     }
@@ -117,7 +117,7 @@ function prefixError(err, prefix) {
       err.message = `${prefix}:
 ${err.message}`;
       return err;
-    } catch (error) {
+    } catch {
     }
   }
   const wrappedError = new Error(`${prefix}${err ? `: ${err}` : ""}`);
@@ -129,13 +129,12 @@ ${err.message}`;
   return wrappedError;
 }
 export {
-  InvalidAstroDataError2 as InvalidAstroDataError,
   createMarkdownProcessor,
   createShikiHighlighter,
+  isFrontmatterValid,
   markdownConfigDefaults,
   rehypeHeadingIds2 as rehypeHeadingIds,
   rehypePrism2 as rehypePrism,
   rehypeShiki2 as rehypeShiki,
-  remarkCollectImages2 as remarkCollectImages,
-  setVfileFrontmatter2 as setVfileFrontmatter
+  remarkCollectImages2 as remarkCollectImages
 };

package/dist/rehype-collect-headings.js

@@ -1,19 +1,18 @@
 import Slugger from "github-slugger";
 import { visit } from "unist-util-visit";
-import { InvalidAstroDataError, safelyGetAstroData } from "./frontmatter-injection.js";
 const rawNodeTypes = /* @__PURE__ */ new Set(["text", "raw", "mdxTextExpression"]);
 const codeTagNames = /* @__PURE__ */ new Set(["code", "pre"]);
 function rehypeHeadingIds() {
   return function(tree, file) {
     const headings = [];
+    const frontmatter = file.data.astro?.frontmatter;
     const slugger = new Slugger();
     const isMDX = isMDXFile(file);
-    const astroData = safelyGetAstroData(file.data);
     visit(tree, (node) => {
       if (node.type !== "element") return;
       const { tagName } = node;
       if (tagName[0] !== "h") return;
-      const [, level] = tagName.match(/h([0-6])/) ?? [];
+      const [, level] = /h([0-6])/.exec(tagName) ?? [];
       if (!level) return;
       const depth = Number.parseInt(level);
       let text = "";
@@ -22,17 +21,20 @@ function rehypeHeadingIds() {
           return;
         }
         if (child.type === "raw") {
-          if (child.value.match(/^\n?<.*>\n?$/)) {
+          if (/^\n?<.*>\n?$/.test(child.value)) {
             return;
           }
         }
         if (rawNodeTypes.has(child.type)) {
           if (isMDX || codeTagNames.has(parent.tagName)) {
             let value = child.value;
-            if (isMdxTextExpression(child) && !(astroData instanceof InvalidAstroDataError)) {
+            if (isMdxTextExpression(child) && frontmatter) {
               const frontmatterPath = getMdxFrontmatterVariablePath(child);
               if (Array.isArray(frontmatterPath) && frontmatterPath.length > 0) {
-                const frontmatterValue = getMdxFrontmatterVariableValue(astroData, frontmatterPath);
+                const frontmatterValue = getMdxFrontmatterVariableValue(
+                  frontmatter,
+                  frontmatterPath
+                );
                 if (typeof frontmatterValue === "string") {
                   value = frontmatterValue;
                 }
@@ -52,7 +54,8 @@ function rehypeHeadingIds() {
       }
       headings.push({ depth, slug: node.properties.id, text });
     });
-    file.data.__astroHeadings = headings;
+    file.data.astro ??= {};
+    file.data.astro.headings = headings;
   };
 }
 function isMDXFile(file) {
@@ -74,8 +77,8 @@ function getMdxFrontmatterVariablePath(node) {
   if (expression.type !== "Identifier" || expression.name !== "frontmatter") return new Error();
   return expressionPath.reverse();
 }
-function getMdxFrontmatterVariableValue(astroData, path) {
-  let value = astroData.frontmatter;
+function getMdxFrontmatterVariableValue(frontmatter, path) {
+  let value = frontmatter;
   for (const key of path) {
     if (!value[key]) return void 0;
     value = value[key];

package/dist/rehype-images.d.ts

@@ -1,2 +1,2 @@
-import type { MarkdownVFile } from './types.js';
-export declare function rehypeImages(): () => (tree: any, file: MarkdownVFile) => void;
+import type { VFile } from 'vfile';
+export declare function rehypeImages(): () => (tree: any, file: VFile) => void;

package/dist/rehype-images.js

@@ -7,7 +7,7 @@ function rehypeImages() {
       if (node.tagName !== "img") return;
       if (node.properties?.src) {
         node.properties.src = decodeURI(node.properties.src);
-        if (file.data.imagePaths?.has(node.properties.src)) {
+        if (file.data.astro?.imagePaths?.includes(node.properties.src)) {
           const { ...props } = node.properties;
           const index = imageOccurrenceMap.get(node.properties.src) || 0;
           imageOccurrenceMap.set(node.properties.src, index + 1);

package/dist/rehype-shiki.js

@@ -3,9 +3,20 @@ import { createShikiHighlighter } from "./shiki.js";
 const rehypeShiki = (config) => {
   let highlighterAsync;
   return async (tree) => {
-    highlighterAsync ??= createShikiHighlighter(config);
+    highlighterAsync ??= createShikiHighlighter({
+      langs: config?.langs,
+      theme: config?.theme,
+      themes: config?.themes
+    });
     const highlighter = await highlighterAsync;
-    await highlightCodeBlocks(tree, highlighter.highlight);
+    await highlightCodeBlocks(tree, (code, language, options) => {
+      return highlighter.codeToHast(code, language, {
+        meta: options?.meta,
+        wrap: config?.wrap,
+        defaultColor: config?.defaultColor,
+        transformers: config?.transformers
+      });
+    });
   };
 };
 export {

package/dist/remark-collect-images.d.ts

@@ -1,2 +1,2 @@
-import type { MarkdownVFile } from './types.js';
-export declare function remarkCollectImages(): (tree: any, vfile: MarkdownVFile) => void;
+import type { VFile } from 'vfile';
+export declare function remarkCollectImages(): (tree: any, vfile: VFile) => void;

package/dist/remark-collect-images.js

@@ -17,7 +17,8 @@ function remarkCollectImages() {
         }
       }
     });
-    vfile.data.imagePaths = imagePaths;
+    vfile.data.astro ??= {};
+    vfile.data.astro.imagePaths = Array.from(imagePaths);
   };
 }
 function shouldOptimizeImage(src) {

package/dist/shiki.d.ts

@@ -1,12 +1,42 @@
-import type { ShikiConfig } from './types.js';
+import type { Root } from 'hast';
+import { type LanguageRegistration, type ShikiTransformer, type ThemeRegistration, type ThemeRegistrationRaw } from 'shiki';
+import type { ThemePresets } from './types.js';
 export interface ShikiHighlighter {
-    highlight(code: string, lang?: string, options?: {
-        inline?: boolean;
-        attributes?: Record<string, string>;
-        /**
-         * Raw `meta` information to be used by Shiki transformers
-         */
-        meta?: string;
-    }): Promise<string>;
+    codeToHast(code: string, lang?: string, options?: ShikiHighlighterHighlightOptions): Promise<Root>;
+    codeToHtml(code: string, lang?: string, options?: ShikiHighlighterHighlightOptions): Promise<string>;
 }
-export declare function createShikiHighlighter({ langs, theme, themes, defaultColor, wrap, transformers, }?: ShikiConfig): Promise<ShikiHighlighter>;
+export interface CreateShikiHighlighterOptions {
+    langs?: LanguageRegistration[];
+    theme?: ThemePresets | ThemeRegistration | ThemeRegistrationRaw;
+    themes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
+}
+export interface ShikiHighlighterHighlightOptions {
+    /**
+     * Generate inline code element only, without the pre element wrapper.
+     */
+    inline?: boolean;
+    /**
+     * Enable word wrapping.
+     * - true: enabled.
+     * - false: disabled.
+     * - null: All overflow styling removed. Code will overflow the element by default.
+     */
+    wrap?: boolean | null;
+    /**
+     * Chooses a theme from the "themes" option that you've defined as the default styling theme.
+     */
+    defaultColor?: 'light' | 'dark' | string | false;
+    /**
+     * Shiki transformers to customize the generated HTML by manipulating the hast tree.
+     */
+    transformers?: ShikiTransformer[];
+    /**
+     * Additional attributes to be added to the root code block element.
+     */
+    attributes?: Record<string, string>;
+    /**
+     * Raw `meta` information to be used by Shiki transformers.
+     */
+    meta?: string;
+}
+export declare function createShikiHighlighter({ langs, theme, themes, }?: CreateShikiHighlighterOptions): Promise<ShikiHighlighter>;

package/dist/shiki.js

@@ -1,126 +1,102 @@
 import {
   createCssVariablesTheme,
-  getHighlighter,
+  createHighlighter,
   isSpecialLang
 } from "shiki";
-import { visit } from "unist-util-visit";
-const ASTRO_COLOR_REPLACEMENTS = {
-  "--astro-code-foreground": "--astro-code-color-text",
-  "--astro-code-background": "--astro-code-color-background"
-};
-const COLOR_REPLACEMENT_REGEX = new RegExp(
-  `${Object.keys(ASTRO_COLOR_REPLACEMENTS).join("|")}`,
-  "g"
-);
 let _cssVariablesTheme;
 const cssVariablesTheme = () => _cssVariablesTheme ?? (_cssVariablesTheme = createCssVariablesTheme({ variablePrefix: "--astro-code-" }));
 async function createShikiHighlighter({
   langs = [],
   theme = "github-dark",
-  themes = {},
-  defaultColor,
-  wrap = false,
-  transformers = []
+  themes = {}
 } = {}) {
   theme = theme === "css-variables" ? cssVariablesTheme() : theme;
-  const highlighter = await getHighlighter({
+  const highlighter = await createHighlighter({
     langs: ["plaintext", ...langs],
     themes: Object.values(themes).length ? Object.values(themes) : [theme]
   });
-  return {
-    async highlight(code, lang = "plaintext", options) {
-      const loadedLanguages = highlighter.getLoadedLanguages();
-      if (!isSpecialLang(lang) && !loadedLanguages.includes(lang)) {
-        try {
-          await highlighter.loadLanguage(lang);
-        } catch (_err) {
-          console.warn(
-            `[Shiki] The language "${lang}" doesn't exist, falling back to "plaintext".`
-          );
-          lang = "plaintext";
-        }
+  async function highlight(code, lang = "plaintext", options, to) {
+    const loadedLanguages = highlighter.getLoadedLanguages();
+    if (!isSpecialLang(lang) && !loadedLanguages.includes(lang)) {
+      try {
+        await highlighter.loadLanguage(lang);
+      } catch (_err) {
+        console.warn(`[Shiki] The language "${lang}" doesn't exist, falling back to "plaintext".`);
+        lang = "plaintext";
       }
-      const themeOptions = Object.values(themes).length ? { themes } : { theme };
-      const inline = options?.inline ?? false;
-      return highlighter.codeToHtml(code, {
-        ...themeOptions,
-        defaultColor,
-        lang,
-        // NOTE: while we can spread `options.attributes` here so that Shiki can auto-serialize this as rendered
-        // attributes on the top-level tag, it's not clear whether it is fine to pass all attributes as meta, as
-        // they're technically not meta, nor parsed from Shiki's `parseMetaString` API.
-        meta: options?.meta ? { __raw: options?.meta } : void 0,
-        transformers: [
-          {
-            pre(node) {
-              if (inline) {
-                node.tagName = "code";
-              }
-              const {
-                class: attributesClass,
-                style: attributesStyle,
-                ...rest
-              } = options?.attributes ?? {};
-              Object.assign(node.properties, rest);
-              const classValue = (normalizePropAsString(node.properties.class) ?? "") + (attributesClass ? ` ${attributesClass}` : "");
-              const styleValue = (normalizePropAsString(node.properties.style) ?? "") + (attributesStyle ? `; ${attributesStyle}` : "");
-              node.properties.class = classValue.replace(/shiki/g, "astro-code");
-              node.properties.dataLanguage = lang;
-              if (wrap === false) {
-                node.properties.style = styleValue + "; overflow-x: auto;";
-              } else if (wrap === true) {
-                node.properties.style = styleValue + "; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;";
-              }
-            },
-            line(node) {
-              if (lang === "diff") {
-                const innerSpanNode = node.children[0];
-                const innerSpanTextNode = innerSpanNode?.type === "element" && innerSpanNode.children?.[0];
-                if (innerSpanTextNode && innerSpanTextNode.type === "text") {
-                  const start = innerSpanTextNode.value[0];
-                  if (start === "+" || start === "-") {
-                    innerSpanTextNode.value = innerSpanTextNode.value.slice(1);
-                    innerSpanNode.children.unshift({
-                      type: "element",
-                      tagName: "span",
-                      properties: { style: "user-select: none;" },
-                      children: [{ type: "text", value: start }]
-                    });
-                  }
+    }
+    const themeOptions = Object.values(themes).length ? { themes } : { theme };
+    const inline = options?.inline ?? false;
+    return highlighter[to === "html" ? "codeToHtml" : "codeToHast"](code, {
+      ...themeOptions,
+      defaultColor: options.defaultColor,
+      lang,
+      // NOTE: while we can spread `options.attributes` here so that Shiki can auto-serialize this as rendered
+      // attributes on the top-level tag, it's not clear whether it is fine to pass all attributes as meta, as
+      // they're technically not meta, nor parsed from Shiki's `parseMetaString` API.
+      meta: options?.meta ? { __raw: options?.meta } : void 0,
+      transformers: [
+        {
+          pre(node) {
+            if (inline) {
+              node.tagName = "code";
+            }
+            const {
+              class: attributesClass,
+              style: attributesStyle,
+              ...rest
+            } = options?.attributes ?? {};
+            Object.assign(node.properties, rest);
+            const classValue = (normalizePropAsString(node.properties.class) ?? "") + (attributesClass ? ` ${attributesClass}` : "");
+            const styleValue = (normalizePropAsString(node.properties.style) ?? "") + (attributesStyle ? `; ${attributesStyle}` : "");
+            node.properties.class = classValue.replace(/shiki/g, "astro-code");
+            node.properties.dataLanguage = lang;
+            if (options.wrap === false || options.wrap === void 0) {
+              node.properties.style = styleValue + "; overflow-x: auto;";
+            } else if (options.wrap === true) {
+              node.properties.style = styleValue + "; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word;";
+            }
+          },
+          line(node) {
+            if (lang === "diff") {
+              const innerSpanNode = node.children[0];
+              const innerSpanTextNode = innerSpanNode?.type === "element" && innerSpanNode.children?.[0];
+              if (innerSpanTextNode && innerSpanTextNode.type === "text") {
+                const start = innerSpanTextNode.value[0];
+                if (start === "+" || start === "-") {
+                  innerSpanTextNode.value = innerSpanTextNode.value.slice(1);
+                  innerSpanNode.children.unshift({
+                    type: "element",
+                    tagName: "span",
+                    properties: { style: "user-select: none;" },
+                    children: [{ type: "text", value: start }]
+                  });
                 }
               }
-            },
-            code(node) {
-              if (inline) {
-                return node.children[0];
-              }
-            },
-            root(node) {
-              if (Object.values(themes).length) {
-                return;
-              }
-              const themeName = typeof theme === "string" ? theme : theme.name;
-              if (themeName === "css-variables") {
-                visit(node, "element", (child) => {
-                  if (child.properties?.style) {
-                    child.properties.style = replaceCssVariables(child.properties.style);
-                  }
-                });
-              }
             }
           },
-          ...transformers
-        ]
-      });
+          code(node) {
+            if (inline) {
+              return node.children[0];
+            }
+          }
+        },
+        ...options.transformers ?? []
+      ]
+    });
+  }
+  return {
+    codeToHast(code, lang, options = {}) {
+      return highlight(code, lang, options, "hast");
+    },
+    codeToHtml(code, lang, options = {}) {
+      return highlight(code, lang, options, "html");
     }
   };
 }
 function normalizePropAsString(value) {
   return Array.isArray(value) ? value.join(" ") : value;
 }
-function replaceCssVariables(str) {
-  return str.replace(COLOR_REPLACEMENT_REGEX, (match) => ASTRO_COLOR_REPLACEMENTS[match] || match);
-}
 export {
   createShikiHighlighter
 };

package/dist/types.d.ts

@@ -1,26 +1,26 @@
 import type * as hast from 'hast';
 import type * as mdast from 'mdast';
 import type { Options as RemarkRehypeOptions } from 'remark-rehype';
-import type { BuiltinTheme, LanguageRegistration, ShikiTransformer, ThemeRegistration, ThemeRegistrationRaw } from 'shiki';
+import type { BuiltinTheme } from 'shiki';
 import type * as unified from 'unified';
-import type { DataMap, VFile } from 'vfile';
+import type { CreateShikiHighlighterOptions, ShikiHighlighterHighlightOptions } from './shiki.js';
 export type { Node } from 'unist';
-export type MarkdownAstroData = {
-    frontmatter: Record<string, any>;
-};
+declare module 'vfile' {
+    interface DataMap {
+        astro: {
+            headings?: MarkdownHeading[];
+            imagePaths?: string[];
+            frontmatter?: Record<string, any>;
+        };
+    }
+}
 export type RemarkPlugin<PluginParameters extends any[] = any[]> = unified.Plugin<PluginParameters, mdast.Root>;
 export type RemarkPlugins = (string | [string, any] | RemarkPlugin | [RemarkPlugin, any])[];
 export type RehypePlugin<PluginParameters extends any[] = any[]> = unified.Plugin<PluginParameters, hast.Root>;
 export type RehypePlugins = (string | [string, any] | RehypePlugin | [RehypePlugin, any])[];
 export type RemarkRehype = RemarkRehypeOptions;
 export type ThemePresets = BuiltinTheme | 'css-variables';
-export interface ShikiConfig {
-    langs?: LanguageRegistration[];
-    theme?: ThemePresets | ThemeRegistration | ThemeRegistrationRaw;
-    themes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
-    defaultColor?: 'light' | 'dark' | string | false;
-    wrap?: boolean | null;
-    transformers?: ShikiTransformer[];
+export interface ShikiConfig extends Pick<CreateShikiHighlighterOptions, 'langs' | 'theme' | 'themes'>, Pick<ShikiHighlighterHighlightOptions, 'defaultColor' | 'wrap' | 'transformers'> {
 }
 export interface AstroMarkdownOptions {
     syntaxHighlight?: 'shiki' | 'prism' | false;
@@ -42,7 +42,7 @@ export interface MarkdownProcessorRenderResult {
     code: string;
     metadata: {
         headings: MarkdownHeading[];
-        imagePaths: Set<string>;
+        imagePaths: string[];
         frontmatter: Record<string, any>;
     };
 }
@@ -51,9 +51,3 @@ export interface MarkdownHeading {
     slug: string;
     text: string;
 }
-export interface MarkdownVFile extends VFile {
-    data: Record<string, unknown> & Partial<DataMap> & {
-        __astroHeadings?: MarkdownHeading[];
-        imagePaths?: Set<string>;
-    };
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/markdown-remark",
-  "version": "5.2.0",
+  "version": "6.0.0-alpha.1",
   "type": "module",
   "author": "withastro",
   "license": "MIT",
@@ -13,8 +13,7 @@
   "homepage": "https://astro.build",
   "main": "./dist/index.js",
   "exports": {
-    ".": "./dist/index.js",
-    "./dist/internal.js": "./dist/internal.js"
+    ".": "./dist/index.js"
   },
   "imports": {
     "#import-plugin": {
@@ -27,7 +26,7 @@
   ],
   "dependencies": {
     "github-slugger": "^2.0.0",
-    "hast-util-from-html": "^2.0.1",
+    "hast-util-from-html": "^2.0.2",
     "hast-util-to-text": "^4.0.2",
     "import-meta-resolve": "^4.1.0",
     "mdast-util-definitions": "^6.0.0",
@@ -37,19 +36,19 @@
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.0",
     "remark-smartypants": "^3.0.2",
-    "shiki": "^1.10.3",
+    "shiki": "^1.16.1",
     "unified": "^11.0.5",
     "unist-util-remove-position": "^5.0.0",
     "unist-util-visit": "^5.0.0",
     "unist-util-visit-parents": "^6.0.1",
-    "vfile": "^6.0.2",
+    "vfile": "^6.0.3",
     "@astrojs/prism": "3.1.0"
   },
   "devDependencies": {
     "@types/estree": "^1.0.5",
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
-    "@types/unist": "^3.0.2",
+    "@types/unist": "^3.0.3",
     "esbuild": "^0.21.5",
     "mdast-util-mdx-expression": "^2.0.0",
     "astro-scripts": "0.0.14"
@@ -61,7 +60,6 @@
     "prepublish": "pnpm build",
     "build": "astro-scripts build \"src/**/*.ts\" && tsc -p tsconfig.json",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
-    "postbuild": "astro-scripts copy \"src/**/*.js\"",
     "dev": "astro-scripts dev \"src/**/*.ts\"",
     "test": "astro-scripts test \"test/**/*.test.js\""
   }

package/dist/frontmatter-injection.d.ts

@@ -1,6 +0,0 @@
-import type { VFileData as Data, VFile } from 'vfile';
-import type { MarkdownAstroData } from './types.js';
-export declare class InvalidAstroDataError extends TypeError {
-}
-export declare function safelyGetAstroData(vfileData: Data): MarkdownAstroData | InvalidAstroDataError;
-export declare function setVfileFrontmatter(vfile: VFile, frontmatter: Record<string, any>): void;

package/dist/frontmatter-injection.js

@@ -1,31 +0,0 @@
-function isValidAstroData(obj) {
-  if (typeof obj === "object" && obj !== null && obj.hasOwnProperty("frontmatter")) {
-    const { frontmatter } = obj;
-    try {
-      JSON.stringify(frontmatter);
-    } catch {
-      return false;
-    }
-    return typeof frontmatter === "object" && frontmatter !== null;
-  }
-  return false;
-}
-class InvalidAstroDataError extends TypeError {
-}
-function safelyGetAstroData(vfileData) {
-  const { astro } = vfileData;
-  if (!astro || !isValidAstroData(astro)) {
-    return new InvalidAstroDataError();
-  }
-  return astro;
-}
-function setVfileFrontmatter(vfile, frontmatter) {
-  vfile.data ??= {};
-  vfile.data.astro ??= {};
-  vfile.data.astro.frontmatter = frontmatter;
-}
-export {
-  InvalidAstroDataError,
-  safelyGetAstroData,
-  setVfileFrontmatter
-};

package/dist/internal.d.ts

@@ -1 +0,0 @@
-export { InvalidAstroDataError, safelyGetAstroData } from './frontmatter-injection.js';

package/dist/internal.js

@@ -1,5 +0,0 @@
-import { InvalidAstroDataError, safelyGetAstroData } from "./frontmatter-injection.js";
-export {
-  InvalidAstroDataError,
-  safelyGetAstroData
-};