@astrojs/markdown-remark 7.1.1 → 7.2.0

package/dist/highlight.d.ts

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

package/dist/highlight.js

@@ -1,9 +1,9 @@
+import { defaultExcludeLanguages } from "@astrojs/internal-helpers/markdown";
 import { fromHtml } from "hast-util-from-html";
 import { toText } from "hast-util-to-text";
 import { removePosition } from "unist-util-remove-position";
 import { visitParents } from "unist-util-visit-parents";
 const languagePattern = /\blanguage-(\S+)\b/;
-const defaultExcludeLanguages = ["math"];
 async function highlightCodeBlocks(tree, highlighter, excludeLanguages = []) {
   const nodes = [];
   visitParents(tree, { type: "element", tagName: "code" }, (node, ancestors) => {
@@ -56,6 +56,5 @@ async function highlightCodeBlocks(tree, highlighter, excludeLanguages = []) {
   }
 }
 export {
-  defaultExcludeLanguages,
   highlightCodeBlocks
 };

package/dist/index.d.ts

@@ -1,14 +1,24 @@
-import type { AstroMarkdownOptions, AstroMarkdownProcessorOptions, MarkdownProcessor, SyntaxHighlightConfig } from './types.js';
-export { extractFrontmatter, isFrontmatterValid, type ParseFrontmatterOptions, type ParseFrontmatterResult, parseFrontmatter, } from './frontmatter.js';
+import type { AstroMarkdownOptions, MarkdownHeading, MarkdownRenderer } from '@astrojs/internal-helpers/markdown';
+declare module 'vfile' {
+    interface DataMap {
+        astro: {
+            headings?: MarkdownHeading[];
+            localImagePaths?: string[];
+            remoteImagePaths?: string[];
+            frontmatter?: Record<string, any>;
+        };
+    }
+}
+export type { Node } from 'unist';
+export type { AstroMarkdownOptions, MarkdownHeading, MarkdownProcessor, MarkdownRenderer, MarkdownRenderOptions, MarkdownRenderResult, RehypePlugin, RehypePlugins, RemarkPlugin, RemarkPlugins, RemarkRehype, ShikiConfig, Smartypants, SyntaxHighlightConfig, SyntaxHighlightConfigType, } from '@astrojs/internal-helpers/markdown';
+export { extractFrontmatter, isFrontmatterValid, type ParseFrontmatterOptions, type ParseFrontmatterResult, parseFrontmatter, } from '@astrojs/internal-helpers/frontmatter';
 export { rehypeHeadingIds } from './rehype-collect-headings.js';
 export { rehypePrism } from './rehype-prism.js';
 export { rehypeShiki } from './rehype-shiki.js';
 export { remarkCollectImages } from './remark-collect-images.js';
-export { type CreateShikiHighlighterOptions, createShikiHighlighter, type ShikiHighlighter, type ShikiHighlighterHighlightOptions, } from './shiki.js';
-export * from './types.js';
-export declare const syntaxHighlightDefaults: Required<SyntaxHighlightConfig>;
-export declare const markdownConfigDefaults: Required<AstroMarkdownOptions>;
+export { isUnifiedProcessor, type UnifiedProcessorOptions, type UnifiedResolvedOptions, unified, } from './processor.js';
+export { markdownConfigDefaults, syntaxHighlightDefaults, } from '@astrojs/internal-helpers/markdown';
 /**
  * Create a markdown preprocessor to render multiple markdown files
  */
-export declare function createMarkdownProcessor(opts?: AstroMarkdownProcessorOptions): Promise<MarkdownProcessor>;
+export declare function createMarkdownProcessor(opts?: AstroMarkdownOptions): Promise<MarkdownRenderer>;

package/dist/index.js

@@ -1,3 +1,4 @@
+import { markdownConfigDefaults } from "@astrojs/internal-helpers/markdown";
 import rehypeRaw from "rehype-raw";
 import rehypeStringify from "rehype-stringify";
 import remarkGfm from "remark-gfm";
@@ -6,7 +7,6 @@ import remarkRehype from "remark-rehype";
 import remarkSmartypants from "remark-smartypants";
 import { unified } from "unified";
 import { VFile } from "vfile";
-import { defaultExcludeLanguages } from "./highlight.js";
 import { loadPlugins } from "./load-plugins.js";
 import { rehypeHeadingIds } from "./rehype-collect-headings.js";
 import { rehypeImages } from "./rehype-images.js";
@@ -17,35 +17,19 @@ import {
   extractFrontmatter,
   isFrontmatterValid,
   parseFrontmatter
-} from "./frontmatter.js";
+} from "@astrojs/internal-helpers/frontmatter";
 import { rehypeHeadingIds as rehypeHeadingIds2 } from "./rehype-collect-headings.js";
 import { rehypePrism as rehypePrism2 } from "./rehype-prism.js";
 import { rehypeShiki as rehypeShiki2 } from "./rehype-shiki.js";
 import { remarkCollectImages as remarkCollectImages2 } from "./remark-collect-images.js";
 import {
-  createShikiHighlighter
-} from "./shiki.js";
-export * from "./types.js";
-const syntaxHighlightDefaults = {
-  type: "shiki",
-  excludeLangs: defaultExcludeLanguages
-};
-const markdownConfigDefaults = {
-  syntaxHighlight: syntaxHighlightDefaults,
-  shikiConfig: {
-    langs: [],
-    theme: "github-dark",
-    themes: {},
-    wrap: false,
-    transformers: [],
-    langAlias: {}
-  },
-  remarkPlugins: [],
-  rehypePlugins: [],
-  remarkRehype: {},
-  gfm: true,
-  smartypants: true
-};
+  isUnifiedProcessor,
+  unified as unified2
+} from "./processor.js";
+import {
+  markdownConfigDefaults as markdownConfigDefaults2,
+  syntaxHighlightDefaults
+} from "@astrojs/internal-helpers/markdown";
 const isPerformanceBenchmark = Boolean(process.env.ASTRO_PERFORMANCE_BENCHMARK);
 async function createMarkdownProcessor(opts) {
   const {
@@ -144,14 +128,15 @@ ${err.message}`;
 }
 export {
   createMarkdownProcessor,
-  createShikiHighlighter,
   extractFrontmatter,
   isFrontmatterValid,
-  markdownConfigDefaults,
+  isUnifiedProcessor,
+  markdownConfigDefaults2 as markdownConfigDefaults,
   parseFrontmatter,
   rehypeHeadingIds2 as rehypeHeadingIds,
   rehypePrism2 as rehypePrism,
   rehypeShiki2 as rehypeShiki,
   remarkCollectImages2 as remarkCollectImages,
-  syntaxHighlightDefaults
+  syntaxHighlightDefaults,
+  unified2 as unified
 };

package/dist/processor.d.ts

@@ -0,0 +1,40 @@
+import type { MarkdownProcessor, RehypePlugins, RemarkPlugins, RemarkRehype, Smartypants } from '@astrojs/internal-helpers/markdown';
+export interface UnifiedProcessorOptions {
+    remarkPlugins?: RemarkPlugins;
+    rehypePlugins?: RehypePlugins;
+    remarkRehype?: RemarkRehype;
+    /** Enable GitHub-Flavored Markdown. Defaults to `true`. */
+    gfm?: boolean;
+    /** Enable SmartyPants typography. Defaults to `true`; pass an object to configure it. */
+    smartypants?: boolean | Smartypants;
+}
+/**
+ * Resolved options on the processor returned by `unified()`. Always populated
+ * (the factory normalises absent inputs into defaults).
+ */
+export interface UnifiedResolvedOptions {
+    remarkPlugins: RemarkPlugins;
+    rehypePlugins: RehypePlugins;
+    remarkRehype: RemarkRehype;
+    gfm?: boolean;
+    smartypants?: boolean | Smartypants;
+}
+/**
+ * Use the default remark/rehype-based Markdown processor for `markdown.processor`.
+ * Extend the pipeline with remark or rehype plugins, or pass options to `remark-rehype`.
+ *
+ * ```js
+ * import { unified } from '@astrojs/markdown-remark';
+ * import remarkToc from 'remark-toc';
+ *
+ * export default defineConfig({
+ *   markdown: {
+ *     processor: unified({ remarkPlugins: [remarkToc] }),
+ *   },
+ * });
+ * ```
+ */
+export declare function unified(opts?: UnifiedProcessorOptions): MarkdownProcessor<UnifiedResolvedOptions>;
+export declare function isUnifiedProcessor(p: {
+    name: string;
+}): p is MarkdownProcessor<UnifiedResolvedOptions>;

package/dist/processor.js

@@ -0,0 +1,33 @@
+function unified(opts = {}) {
+  const processor = {
+    name: "unified",
+    options: {
+      remarkPlugins: [...opts.remarkPlugins ?? []],
+      rehypePlugins: [...opts.rehypePlugins ?? []],
+      remarkRehype: { ...opts.remarkRehype },
+      gfm: opts.gfm,
+      smartypants: opts.smartypants
+    },
+    async createRenderer(shared) {
+      const { createMarkdownProcessor } = await import("./index.js");
+      return createMarkdownProcessor({
+        ...shared,
+        remarkPlugins: processor.options.remarkPlugins,
+        rehypePlugins: processor.options.rehypePlugins,
+        remarkRehype: processor.options.remarkRehype,
+        // `unified({ gfm, smartypants })` wins; fall back to the deprecated
+        // top-level `markdown.gfm` / `markdown.smartypants` while they still exist.
+        gfm: processor.options.gfm ?? shared.gfm,
+        smartypants: processor.options.smartypants ?? shared.smartypants
+      });
+    }
+  };
+  return processor;
+}
+function isUnifiedProcessor(p) {
+  return p.name === "unified";
+}
+export {
+  isUnifiedProcessor,
+  unified
+};

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

@@ -1,4 +1,4 @@
-import type { RehypePlugin } from './types.js';
+import type { RehypePlugin } from '@astrojs/internal-helpers/markdown';
 /**
  * Rehype plugin that adds `id` attributes to headings based on their text content.
  *

package/dist/rehype-prism.js

@@ -4,11 +4,9 @@ const rehypePrism = (excludeLangs) => {
   return async (tree) => {
     await highlightCodeBlocks(
       tree,
-      (code, language) => {
-        let { html, classLanguage } = runHighlighterWithAstro(language, code);
-        return Promise.resolve(
-          `<pre class="${classLanguage}" data-language="${language}"><code class="${classLanguage}">${html}</code></pre>`
-        );
+      async (code, language) => {
+        let { html, classLanguage } = await runHighlighterWithAstro(language, code);
+        return `<pre class="${classLanguage}" data-language="${language}"><code class="${classLanguage}">${html}</code></pre>`;
       },
       excludeLangs
     );

package/dist/rehype-shiki.d.ts

@@ -1,4 +1,4 @@
 import type { Root } from 'hast';
 import type { Plugin } from 'unified';
-import type { ShikiConfig } from './types.js';
+import type { ShikiConfig } from '@astrojs/internal-helpers/markdown';
 export declare const rehypeShiki: Plugin<[ShikiConfig, string[]?], Root>;

package/dist/rehype-shiki.js

@@ -1,5 +1,5 @@
 import { highlightCodeBlocks } from "./highlight.js";
-import { createShikiHighlighter } from "./shiki.js";
+import { createShikiHighlighter } from "@astrojs/internal-helpers/shiki";
 const rehypeShiki = (config, excludeLangs) => {
   let highlighterAsync;
   return async (tree) => {

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

@@ -1,4 +1,4 @@
 import type { Root } from 'mdast';
 import type { VFile } from 'vfile';
-import type { AstroMarkdownProcessorOptions } from './types.js';
-export declare function remarkCollectImages(opts: AstroMarkdownProcessorOptions['image']): (tree: Root, vfile: VFile) => void;
+import type { AstroMarkdownOptions } from '@astrojs/internal-helpers/markdown';
+export declare function remarkCollectImages(opts: AstroMarkdownOptions['image']): (tree: Root, vfile: VFile) => void;

package/dist/shiki.d.ts

@@ -1,44 +1 @@
-import type { Root } from 'hast';
-import { type HighlighterCoreOptions, type LanguageRegistration, type ShikiTransformer, type ThemeRegistration, type ThemeRegistrationRaw } from 'shiki';
-import type { ThemePresets } from './types.js';
-export interface ShikiHighlighter {
-    codeToHast(code: string, lang?: string, options?: ShikiHighlighterHighlightOptions): Promise<Root>;
-    codeToHtml(code: string, lang?: string, options?: ShikiHighlighterHighlightOptions): Promise<string>;
-}
-export interface CreateShikiHighlighterOptions {
-    langs?: LanguageRegistration[];
-    theme?: ThemePresets | ThemeRegistration | ThemeRegistrationRaw;
-    themes?: Record<string, ThemePresets | ThemeRegistration | ThemeRegistrationRaw>;
-    langAlias?: HighlighterCoreOptions['langAlias'];
-}
-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(options?: CreateShikiHighlighterOptions): Promise<ShikiHighlighter>;
-export type { ThemePresets };
+export { type CreateShikiHighlighterOptions, createShikiHighlighter, type ShikiHighlighter, type ShikiHighlighterHighlightOptions, type ThemePresets, } from '@astrojs/internal-helpers/shiki';

package/dist/shiki.js

@@ -1,163 +1,6 @@
 import {
-  createCssVariablesTheme,
-  createHighlighter,
-  isSpecialLang
-} from "shiki";
-import { loadShikiEngine } from "#shiki-engine";
-let _cssVariablesTheme;
-const cssVariablesTheme = () => _cssVariablesTheme ?? (_cssVariablesTheme = createCssVariablesTheme({
-  variablePrefix: "--astro-code-"
-}));
-const cachedHighlighters = /* @__PURE__ */ new Map();
-function clearShikiHighlighterCache() {
-  cachedHighlighters.clear();
-}
-function createShikiHighlighter(options) {
-  const key = getCacheKey(options);
-  let highlighterPromise = cachedHighlighters.get(key);
-  if (!highlighterPromise) {
-    highlighterPromise = createShikiHighlighterInternal(options);
-    cachedHighlighters.set(key, highlighterPromise);
-  }
-  return ensureLanguagesLoaded(highlighterPromise, options?.langs);
-}
-function getCacheKey(options) {
-  const keyCache = [];
-  const { theme, themes, langAlias } = options ?? {};
-  if (theme) {
-    keyCache.push(theme);
-  }
-  if (themes) {
-    keyCache.push(Object.entries(themes).sort());
-  }
-  if (langAlias) {
-    keyCache.push(Object.entries(langAlias).sort());
-  }
-  return keyCache.length > 0 ? JSON.stringify(keyCache) : "";
-}
-async function ensureLanguagesLoaded(promise, langs) {
-  const highlighter = await promise;
-  if (!langs) {
-    return highlighter;
-  }
-  const loadedLanguages = highlighter.getLoadedLanguages();
-  for (const lang of langs) {
-    if (typeof lang === "string" && (isSpecialLang(lang) || loadedLanguages.includes(lang))) {
-      continue;
-    }
-    await highlighter.loadLanguage(lang);
-  }
-  return highlighter;
-}
-let shikiEngine = void 0;
-async function createShikiHighlighterInternal({
-  langs = [],
-  theme = "github-dark",
-  themes = {},
-  langAlias = {}
-} = {}) {
-  theme = theme === "css-variables" ? cssVariablesTheme() : theme;
-  if (shikiEngine === void 0) {
-    shikiEngine = await loadShikiEngine();
-  }
-  const highlighter = await createHighlighter({
-    langs: ["plaintext", ...langs],
-    langAlias,
-    themes: Object.values(themes).length ? Object.values(themes) : [theme],
-    engine: shikiEngine
-  });
-  async function highlight(code, lang = "plaintext", options, to) {
-    const resolvedLang = langAlias[lang] ?? lang;
-    const loadedLanguages = highlighter.getLoadedLanguages();
-    if (!isSpecialLang(lang) && !loadedLanguages.includes(resolvedLang)) {
-      try {
-        await highlighter.loadLanguage(resolvedLang);
-      } catch (_err) {
-        const langStr = lang === resolvedLang ? `"${lang}"` : `"${lang}" (aliased to "${resolvedLang}")`;
-        console.warn(`[Shiki] The language ${langStr} doesn't exist, falling back to "plaintext".`);
-        lang = "plaintext";
-      }
-    }
-    code = code.replace(/(?:\r\n|\r|\n)$/, "");
-    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 neither 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 (resolvedLang === "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];
-            }
-          }
-        },
-        ...options.transformers ?? []
-      ]
-    });
-  }
-  return {
-    codeToHast(code, lang, options = {}) {
-      return highlight(code, lang, options, "hast");
-    },
-    codeToHtml(code, lang, options = {}) {
-      return highlight(code, lang, options, "html");
-    },
-    loadLanguage(...newLangs) {
-      return highlighter.loadLanguage(...newLangs);
-    },
-    getLoadedLanguages() {
-      return highlighter.getLoadedLanguages();
-    }
-  };
-}
-function normalizePropAsString(value) {
-  return Array.isArray(value) ? value.join(" ") : value;
-}
+  createShikiHighlighter
+} from "@astrojs/internal-helpers/shiki";
 export {
-  clearShikiHighlighterCache,
   createShikiHighlighter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/markdown-remark",
-  "version": "7.1.1",
+  "version": "7.2.0",
   "type": "module",
   "author": "withastro",
   "license": "MIT",
@@ -20,10 +20,6 @@
     "#import-plugin": {
       "browser": "./dist/import-plugin-browser.js",
       "default": "./dist/import-plugin-default.js"
-    },
-    "#shiki-engine": {
-      "workerd": "./dist/shiki-engine-workerd.js",
-      "default": "./dist/shiki-engine-default.js"
     }
   },
   "files": [
@@ -33,7 +29,6 @@
     "github-slugger": "^2.0.0",
     "hast-util-from-html": "^2.0.3",
     "hast-util-to-text": "^4.0.2",
-    "js-yaml": "^4.1.1",
     "mdast-util-definitions": "^6.0.0",
     "rehype-raw": "^7.0.0",
     "rehype-stringify": "^10.0.1",
@@ -41,25 +36,22 @@
     "remark-parse": "^11.0.0",
     "remark-rehype": "^11.1.2",
     "remark-smartypants": "^3.0.2",
-    "retext-smartypants": "^6.2.0",
-    "shiki": "^4.0.0",
-    "smol-toml": "^1.6.0",
     "unified": "^11.0.5",
     "unist-util-remove-position": "^5.0.0",
     "unist-util-visit": "^5.1.0",
     "unist-util-visit-parents": "^6.0.2",
     "vfile": "^6.0.3",
-    "@astrojs/internal-helpers": "0.9.0",
-    "@astrojs/prism": "4.0.1"
+    "@astrojs/internal-helpers": "0.10.0",
+    "@astrojs/prism": "4.0.2"
   },
   "devDependencies": {
     "@types/estree": "^1.0.8",
     "@types/hast": "^3.0.4",
-    "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.4",
     "@types/unist": "^3.0.3",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.28.0",
     "mdast-util-mdx-expression": "^2.0.1",
+    "shiki": "^4.0.0",
     "astro-scripts": "0.0.14"
   },
   "publishConfig": {
@@ -67,10 +59,9 @@
   },
   "scripts": {
     "prepublish": "pnpm build",
-    "build": "astro-scripts build \"src/**/*.ts\" && tsc -p tsconfig.json",
+    "build": "astro-scripts build \"src/**/*.ts\" && tsc -b",
     "build:ci": "astro-scripts build \"src/**/*.ts\"",
     "dev": "astro-scripts dev \"src/**/*.ts\"",
-    "test": "astro-scripts test \"test/**/*.test.ts\"",
-    "typecheck:tests": "tsc --build tsconfig.test.json"
+    "test": "astro-scripts test \"test/**/*.test.ts\""
   }
 }

package/dist/frontmatter.d.ts

@@ -1,20 +0,0 @@
-export declare function isFrontmatterValid(frontmatter: Record<string, any>): boolean;
-export declare function extractFrontmatter(code: string): string | undefined;
-export interface ParseFrontmatterOptions {
-    /**
-     * How the frontmatter should be handled in the returned `content` string.
-     * - `preserve`: Keep the frontmatter.
-     * - `remove`: Remove the frontmatter.
-     * - `empty-with-spaces`: Replace the frontmatter with empty spaces. (preserves sourcemap line/col/offset)
-     * - `empty-with-lines`: Replace the frontmatter with empty line breaks. (preserves sourcemap line/col)
-     *
-     * @default 'remove'
-     */
-    frontmatter: 'preserve' | 'remove' | 'empty-with-spaces' | 'empty-with-lines';
-}
-export interface ParseFrontmatterResult {
-    frontmatter: Record<string, any>;
-    rawFrontmatter: string;
-    content: string;
-}
-export declare function parseFrontmatter(code: string, options?: ParseFrontmatterOptions): ParseFrontmatterResult;

package/dist/frontmatter.js

@@ -1,58 +0,0 @@
-import yaml from "js-yaml";
-import * as toml from "smol-toml";
-function isFrontmatterValid(frontmatter) {
-  try {
-    JSON.stringify(frontmatter);
-  } catch {
-    return false;
-  }
-  return typeof frontmatter === "object" && frontmatter !== null;
-}
-const frontmatterRE = /(?:^\uFEFF?|^\s*\n)(?:---|\+\+\+)([\s\S]*?\n)(?:---|\+\+\+)/;
-const frontmatterTypeRE = /(?:^\uFEFF?|^\s*\n)(---|\+\+\+)/;
-function extractFrontmatter(code) {
-  return frontmatterRE.exec(code)?.[1];
-}
-function getFrontmatterParser(code) {
-  return frontmatterTypeRE.exec(code)?.[1] === "+++" ? ["+++", toml.parse] : ["---", yaml.load];
-}
-function parseFrontmatter(code, options) {
-  const rawFrontmatter = extractFrontmatter(code);
-  if (rawFrontmatter == null) {
-    return { frontmatter: {}, rawFrontmatter: "", content: code };
-  }
-  const [delims, parser] = getFrontmatterParser(code);
-  const parsed = parser(rawFrontmatter);
-  const frontmatter = parsed && typeof parsed === "object" ? parsed : {};
-  let content;
-  switch (options?.frontmatter ?? "remove") {
-    case "preserve":
-      content = code;
-      break;
-    case "remove":
-      content = code.replace(`${delims}${rawFrontmatter}${delims}`, "");
-      break;
-    case "empty-with-spaces":
-      content = code.replace(
-        `${delims}${rawFrontmatter}${delims}`,
-        `   ${rawFrontmatter.replace(/[^\r\n]/g, " ")}   `
-      );
-      break;
-    case "empty-with-lines":
-      content = code.replace(
-        `${delims}${rawFrontmatter}${delims}`,
-        rawFrontmatter.replace(/[^\r\n]/g, "")
-      );
-      break;
-  }
-  return {
-    frontmatter,
-    rawFrontmatter,
-    content
-  };
-}
-export {
-  extractFrontmatter,
-  isFrontmatterValid,
-  parseFrontmatter
-};

package/dist/shiki-engine-default.d.ts

@@ -1,2 +0,0 @@
-import type { RegexEngine } from 'shiki';
-export declare function loadShikiEngine(): Promise<RegexEngine>;

package/dist/shiki-engine-default.js

@@ -1,7 +0,0 @@
-import { createOnigurumaEngine } from "shiki/engine/oniguruma";
-function loadShikiEngine() {
-  return createOnigurumaEngine(import("shiki/wasm"));
-}
-export {
-  loadShikiEngine
-};

package/dist/shiki-engine-workerd.d.ts

@@ -1,2 +0,0 @@
-import type { RegexEngine } from 'shiki';
-export declare function loadShikiEngine(): Promise<RegexEngine>;

package/dist/shiki-engine-workerd.js

@@ -1,7 +0,0 @@
-import { createOnigurumaEngine } from "shiki/engine/oniguruma";
-function loadShikiEngine() {
-  return createOnigurumaEngine(import("shiki/onig.wasm"));
-}
-export {
-  loadShikiEngine
-};

package/dist/types.d.ts

@@ -1,77 +0,0 @@
-import type { RemotePattern } from '@astrojs/internal-helpers/remote';
-import type * as hast from 'hast';
-import type * as mdast from 'mdast';
-import type { Options as RemarkRehypeOptions } from 'remark-rehype';
-import type { Options as SmartypantsOptions } from 'retext-smartypants';
-import type { BuiltinTheme } from 'shiki';
-import type * as unified from 'unified';
-import type { CreateShikiHighlighterOptions, ShikiHighlighterHighlightOptions } from './shiki.js';
-export type { Node } from 'unist';
-declare module 'vfile' {
-    interface DataMap {
-        astro: {
-            headings?: MarkdownHeading[];
-            localImagePaths?: string[];
-            remoteImagePaths?: 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 Smartypants = SmartypantsOptions;
-export type ThemePresets = BuiltinTheme | 'css-variables';
-export type SyntaxHighlightConfigType = 'shiki' | 'prism';
-export interface SyntaxHighlightConfig {
-    type: SyntaxHighlightConfigType;
-    excludeLangs?: string[];
-}
-export interface ShikiConfig extends Pick<CreateShikiHighlighterOptions, 'langs' | 'theme' | 'themes' | 'langAlias'>, Pick<ShikiHighlighterHighlightOptions, 'defaultColor' | 'wrap' | 'transformers'> {
-}
-/**
- * Configuration options that end up in the markdown section of AstroConfig
- */
-export interface AstroMarkdownOptions {
-    syntaxHighlight?: SyntaxHighlightConfig | SyntaxHighlightConfigType | false;
-    shikiConfig?: ShikiConfig;
-    remarkPlugins?: RemarkPlugins;
-    rehypePlugins?: RehypePlugins;
-    remarkRehype?: RemarkRehype;
-    gfm?: boolean;
-    smartypants?: boolean | SmartypantsOptions;
-}
-/**
- * Extra configuration options from other parts of AstroConfig that get injected into this plugin
- */
-export interface AstroMarkdownProcessorOptions extends AstroMarkdownOptions {
-    image?: {
-        domains?: string[];
-        remotePatterns?: RemotePattern[];
-    };
-}
-export interface MarkdownProcessor {
-    render: (content: string, opts?: MarkdownProcessorRenderOptions) => Promise<MarkdownProcessorRenderResult>;
-}
-export interface MarkdownProcessorRenderOptions {
-    /** The URL of the file being rendered, used for resolving relative image paths */
-    fileURL?: URL;
-    /** Used for frontmatter injection plugins */
-    frontmatter?: Record<string, any>;
-}
-export interface MarkdownProcessorRenderResult {
-    code: string;
-    metadata: {
-        headings: MarkdownHeading[];
-        localImagePaths: string[];
-        remoteImagePaths: string[];
-        frontmatter: Record<string, any>;
-    };
-}
-export interface MarkdownHeading {
-    depth: number;
-    slug: string;
-    text: string;
-}