@astrojs/markdown-remark 0.0.0-assets-uint8array-20231109073138

package/LICENSE

@@ -0,0 +1,61 @@
+MIT License
+
+Copyright (c) 2021 Fred K. Schott
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+"""
+This license applies to parts of the `packages/create-astro` and `packages/astro` subdirectories originating from the https://github.com/sveltejs/kit repository:
+
+Copyright (c) 2020 [these people](https://github.com/sveltejs/kit/graphs/contributors)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+
+"""
+This license applies to parts of the `packages/create-astro` and `packages/astro` subdirectories originating from the https://github.com/vitejs/vite repository:
+
+MIT License
+
+Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""

package/dist/frontmatter-injection.d.ts

@@ -0,0 +1,12 @@
+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;
+/**
+ * @deprecated Use `setVfileFrontmatter` instead
+ */
+export declare function toRemarkInitializeAstroData({ userFrontmatter, }: {
+    userFrontmatter: Record<string, any>;
+}): () => (tree: any, vfile: VFile) => void;

package/dist/frontmatter-injection.js

@@ -0,0 +1,41 @@
+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;
+}
+function toRemarkInitializeAstroData({
+  userFrontmatter
+}) {
+  return () => function(tree, vfile) {
+    if (!vfile.data.astro) {
+      vfile.data.astro = { frontmatter: userFrontmatter };
+    }
+  };
+}
+export {
+  InvalidAstroDataError,
+  safelyGetAstroData,
+  setVfileFrontmatter,
+  toRemarkInitializeAstroData
+};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import type { AstroMarkdownOptions, MarkdownProcessor, MarkdownRenderingOptions, MarkdownRenderingResult } 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 { remarkPrism } from './remark-prism.js';
+export { remarkShiki } from './remark-shiki.js';
+export * from './types.js';
+export declare const markdownConfigDefaults: Omit<Required<AstroMarkdownOptions>, 'drafts'>;
+/**
+ * Create a markdown preprocessor to render multiple markdown files
+ */
+export declare function createMarkdownProcessor(opts?: AstroMarkdownOptions): Promise<MarkdownProcessor>;
+/**
+ * Shared utility for rendering markdown
+ *
+ * @deprecated Use `createMarkdownProcessor` instead for better performance
+ */
+export declare function renderMarkdown(content: string, opts: MarkdownRenderingOptions): Promise<MarkdownRenderingResult>;

package/dist/index.js

@@ -0,0 +1,157 @@
+import {
+  InvalidAstroDataError,
+  safelyGetAstroData,
+  setVfileFrontmatter
+} from "./frontmatter-injection.js";
+import { loadPlugins } from "./load-plugins.js";
+import { rehypeHeadingIds } from "./rehype-collect-headings.js";
+import { remarkCollectImages } from "./remark-collect-images.js";
+import { remarkPrism } from "./remark-prism.js";
+import { remarkShiki } from "./remark-shiki.js";
+import rehypeRaw from "rehype-raw";
+import rehypeStringify from "rehype-stringify";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+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 { remarkPrism as remarkPrism2 } from "./remark-prism.js";
+import { remarkShiki as remarkShiki2 } from "./remark-shiki.js";
+export * from "./types.js";
+const markdownConfigDefaults = {
+  syntaxHighlight: "shiki",
+  shikiConfig: {
+    langs: [],
+    theme: "github-dark",
+    experimentalThemes: {},
+    wrap: false
+  },
+  remarkPlugins: [],
+  rehypePlugins: [],
+  remarkRehype: {},
+  gfm: true,
+  smartypants: true
+};
+const isPerformanceBenchmark = Boolean(process.env.ASTRO_PERFORMANCE_BENCHMARK);
+async function createMarkdownProcessor(opts) {
+  const {
+    syntaxHighlight = markdownConfigDefaults.syntaxHighlight,
+    shikiConfig = markdownConfigDefaults.shikiConfig,
+    remarkPlugins = markdownConfigDefaults.remarkPlugins,
+    rehypePlugins = markdownConfigDefaults.rehypePlugins,
+    remarkRehype: remarkRehypeOptions = markdownConfigDefaults.remarkRehype,
+    gfm = markdownConfigDefaults.gfm,
+    smartypants = markdownConfigDefaults.smartypants
+  } = opts ?? {};
+  const loadedRemarkPlugins = await Promise.all(loadPlugins(remarkPlugins));
+  const loadedRehypePlugins = await Promise.all(loadPlugins(rehypePlugins));
+  const parser = unified().use(remarkParse);
+  if (!isPerformanceBenchmark) {
+    if (gfm) {
+      parser.use(remarkGfm);
+    }
+    if (smartypants) {
+      parser.use(remarkSmartypants);
+    }
+  }
+  for (const [plugin, pluginOpts] of loadedRemarkPlugins) {
+    parser.use(plugin, pluginOpts);
+  }
+  if (!isPerformanceBenchmark) {
+    if (syntaxHighlight === "shiki") {
+      parser.use(remarkShiki, shikiConfig);
+    } else if (syntaxHighlight === "prism") {
+      parser.use(remarkPrism);
+    }
+    parser.use(remarkCollectImages);
+  }
+  parser.use(remarkRehype, {
+    allowDangerousHtml: true,
+    passThrough: [],
+    ...remarkRehypeOptions
+  });
+  for (const [plugin, pluginOpts] of loadedRehypePlugins) {
+    parser.use(plugin, pluginOpts);
+  }
+  parser.use(rehypeImages());
+  if (!isPerformanceBenchmark) {
+    parser.use(rehypeHeadingIds);
+  }
+  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 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 ?? {}
+        },
+        // Compat for `renderMarkdown` only. Do not use!
+        __renderMarkdownCompat: {
+          result
+        }
+      };
+    }
+  };
+}
+async function renderMarkdown(content, opts) {
+  const processor = await createMarkdownProcessor(opts);
+  const result = await processor.render(content, {
+    fileURL: opts.fileURL,
+    frontmatter: opts.frontmatter
+  });
+  return {
+    code: result.code,
+    metadata: {
+      headings: result.metadata.headings,
+      source: content,
+      html: result.code
+    },
+    vfile: result.__renderMarkdownCompat.result
+  };
+}
+function prefixError(err, prefix) {
+  if (err?.message) {
+    try {
+      err.message = `${prefix}:
+${err.message}`;
+      return err;
+    } catch (error) {
+    }
+  }
+  const wrappedError = new Error(`${prefix}${err ? `: ${err}` : ""}`);
+  try {
+    wrappedError.stack = err.stack;
+    wrappedError.cause = err;
+  } catch {
+  }
+  return wrappedError;
+}
+export {
+  InvalidAstroDataError2 as InvalidAstroDataError,
+  createMarkdownProcessor,
+  markdownConfigDefaults,
+  rehypeHeadingIds2 as rehypeHeadingIds,
+  remarkCollectImages2 as remarkCollectImages,
+  remarkPrism2 as remarkPrism,
+  remarkShiki2 as remarkShiki,
+  renderMarkdown,
+  setVfileFrontmatter2 as setVfileFrontmatter
+};

package/dist/internal.d.ts

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

package/dist/internal.js

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

package/dist/load-plugins.d.ts

@@ -0,0 +1,2 @@
+import type * as unified from 'unified';
+export declare function loadPlugins(items: (string | [string, any] | unified.Plugin<any[], any> | [unified.Plugin<any[], any>, any])[]): Promise<[unified.Plugin, any?]>[];

package/dist/load-plugins.js

@@ -0,0 +1,31 @@
+import { resolve as importMetaResolve } from "import-meta-resolve";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const cwdUrlStr = pathToFileURL(path.join(process.cwd(), "package.json")).toString();
+async function importPlugin(p) {
+  if (typeof p === "string") {
+    try {
+      const importResult2 = await import(p);
+      return importResult2.default;
+    } catch {
+    }
+    const resolved = importMetaResolve(p, cwdUrlStr);
+    const importResult = await import(resolved);
+    return importResult.default;
+  }
+  return p;
+}
+function loadPlugins(items) {
+  return items.map((p) => {
+    return new Promise((resolve, reject) => {
+      if (Array.isArray(p)) {
+        const [plugin, opts] = p;
+        return importPlugin(plugin).then((m) => resolve([m, opts])).catch((e) => reject(e));
+      }
+      return importPlugin(p).then((m) => resolve([m])).catch((e) => reject(e));
+    });
+  });
+}
+export {
+  loadPlugins
+};

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

@@ -0,0 +1,2 @@
+import type { RehypePlugin } from './types.js';
+export declare function rehypeHeadingIds(): ReturnType<RehypePlugin>;

package/dist/rehype-collect-headings.js

@@ -0,0 +1,97 @@
+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 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])/) ?? [];
+      if (!level)
+        return;
+      const depth = Number.parseInt(level);
+      let text = "";
+      visit(node, (child, __, parent) => {
+        if (child.type === "element" || parent == null) {
+          return;
+        }
+        if (child.type === "raw") {
+          if (child.value.match(/^\n?<.*>\n?$/)) {
+            return;
+          }
+        }
+        if (rawNodeTypes.has(child.type)) {
+          if (isMDX || codeTagNames.has(parent.tagName)) {
+            let value = child.value;
+            if (isMdxTextExpression(child) && !(astroData instanceof InvalidAstroDataError)) {
+              const frontmatterPath = getMdxFrontmatterVariablePath(child);
+              if (Array.isArray(frontmatterPath) && frontmatterPath.length > 0) {
+                const frontmatterValue = getMdxFrontmatterVariableValue(astroData, frontmatterPath);
+                if (typeof frontmatterValue === "string") {
+                  value = frontmatterValue;
+                }
+              }
+            }
+            text += value;
+          } else {
+            text += child.value.replace(/\{/g, "${");
+          }
+        }
+      });
+      node.properties = node.properties || {};
+      if (typeof node.properties.id !== "string") {
+        let slug = slugger.slug(text);
+        if (slug.endsWith("-"))
+          slug = slug.slice(0, -1);
+        node.properties.id = slug;
+      }
+      headings.push({ depth, slug: node.properties.id, text });
+    });
+    file.data.__astroHeadings = headings;
+  };
+}
+function isMDXFile(file) {
+  return Boolean(file.history[0]?.endsWith(".mdx"));
+}
+function getMdxFrontmatterVariablePath(node) {
+  if (!node.data?.estree || node.data.estree.body.length !== 1)
+    return new Error();
+  const statement = node.data.estree.body[0];
+  if (statement?.type !== "ExpressionStatement" || statement.expression.type !== "MemberExpression")
+    return new Error();
+  let expression = statement.expression;
+  const expressionPath = [];
+  while (expression.type === "MemberExpression" && expression.property.type === (expression.computed ? "Literal" : "Identifier")) {
+    expressionPath.push(
+      expression.property.type === "Literal" ? String(expression.property.value) : expression.property.name
+    );
+    expression = expression.object;
+  }
+  if (expression.type !== "Identifier" || expression.name !== "frontmatter")
+    return new Error();
+  return expressionPath.reverse();
+}
+function getMdxFrontmatterVariableValue(astroData, path) {
+  let value = astroData.frontmatter;
+  for (const key of path) {
+    if (!value[key])
+      return void 0;
+    value = value[key];
+  }
+  return value;
+}
+function isMdxTextExpression(node) {
+  return node.type === "mdxTextExpression";
+}
+export {
+  rehypeHeadingIds
+};

package/dist/rehype-images.d.ts

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

package/dist/rehype-images.js

@@ -0,0 +1,20 @@
+import { visit } from "unist-util-visit";
+function rehypeImages() {
+  return () => function(tree, file) {
+    visit(tree, (node) => {
+      if (node.type !== "element")
+        return;
+      if (node.tagName !== "img")
+        return;
+      if (node.properties?.src) {
+        if (file.data.imagePaths?.has(node.properties.src)) {
+          node.properties["__ASTRO_IMAGE_"] = node.properties.src;
+          delete node.properties.src;
+        }
+      }
+    });
+  };
+}
+export {
+  rehypeImages
+};

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

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

package/dist/remark-collect-images.js

@@ -0,0 +1,38 @@
+import { definitions } from "mdast-util-definitions";
+import { visit } from "unist-util-visit";
+function remarkCollectImages() {
+  return function(tree, vfile) {
+    if (typeof vfile?.path !== "string")
+      return;
+    const definition = definitions(tree);
+    const imagePaths = /* @__PURE__ */ new Set();
+    visit(tree, ["image", "imageReference"], (node) => {
+      if (node.type === "image") {
+        if (shouldOptimizeImage(node.url))
+          imagePaths.add(node.url);
+      }
+      if (node.type === "imageReference") {
+        const imageDefinition = definition(node.identifier);
+        if (imageDefinition) {
+          if (shouldOptimizeImage(imageDefinition.url))
+            imagePaths.add(imageDefinition.url);
+        }
+      }
+    });
+    vfile.data.imagePaths = imagePaths;
+  };
+}
+function shouldOptimizeImage(src) {
+  return !isValidUrl(src) && !src.startsWith("/");
+}
+function isValidUrl(str) {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  remarkCollectImages
+};

package/dist/remark-prism.d.ts

@@ -0,0 +1,2 @@
+import type { RemarkPlugin } from './types.js';
+export declare function remarkPrism(): ReturnType<RemarkPlugin>;

package/dist/remark-prism.js

@@ -0,0 +1,19 @@
+import { runHighlighterWithAstro } from "@astrojs/prism/dist/highlighter";
+import { visit } from "unist-util-visit";
+function remarkPrism() {
+  return function(tree) {
+    visit(tree, "code", (node) => {
+      let { lang, value } = node;
+      node.type = "html";
+      let { html, classLanguage } = runHighlighterWithAstro(lang, value);
+      let classes = [classLanguage];
+      node.value = `<pre class="${classes.join(
+        " "
+      )}"><code is:raw class="${classLanguage}">${html}</code></pre>`;
+      return node;
+    });
+  };
+}
+export {
+  remarkPrism
+};

package/dist/remark-shiki.d.ts

@@ -0,0 +1,2 @@
+import type { RemarkPlugin, ShikiConfig } from './types.js';
+export declare function remarkShiki({ langs, theme, experimentalThemes, wrap, }?: ShikiConfig): ReturnType<RemarkPlugin>;

package/dist/remark-shiki.js

@@ -0,0 +1,84 @@
+import { bundledLanguages, getHighlighter } from "shikiji";
+import { visit } from "unist-util-visit";
+const ASTRO_COLOR_REPLACEMENTS = {
+  "#000001": "var(--astro-code-color-text)",
+  "#000002": "var(--astro-code-color-background)",
+  "#000004": "var(--astro-code-token-constant)",
+  "#000005": "var(--astro-code-token-string)",
+  "#000006": "var(--astro-code-token-comment)",
+  "#000007": "var(--astro-code-token-keyword)",
+  "#000008": "var(--astro-code-token-parameter)",
+  "#000009": "var(--astro-code-token-function)",
+  "#000010": "var(--astro-code-token-string-expression)",
+  "#000011": "var(--astro-code-token-punctuation)",
+  "#000012": "var(--astro-code-token-link)"
+};
+const COLOR_REPLACEMENT_REGEX = new RegExp(
+  `(${Object.keys(ASTRO_COLOR_REPLACEMENTS).join("|")})`,
+  "g"
+);
+const highlighterCacheAsync = /* @__PURE__ */ new Map();
+function remarkShiki({
+  langs = [],
+  theme = "github-dark",
+  experimentalThemes = {},
+  wrap = false
+} = {}) {
+  const themes = experimentalThemes;
+  const cacheId = Object.values(themes).map((t) => typeof t === "string" ? t : t.name ?? "").join(",") + (typeof theme === "string" ? theme : theme.name ?? "") + langs.map((l) => l.name ?? l.id).join(",");
+  let highlighterAsync = highlighterCacheAsync.get(cacheId);
+  if (!highlighterAsync) {
+    highlighterAsync = getHighlighter({
+      langs: langs.length ? langs : Object.keys(bundledLanguages),
+      themes: Object.values(themes).length ? Object.values(themes) : [theme]
+    });
+    highlighterCacheAsync.set(cacheId, highlighterAsync);
+  }
+  return async (tree) => {
+    const highlighter = await highlighterAsync;
+    visit(tree, "code", (node) => {
+      let lang;
+      if (typeof node.lang === "string") {
+        const langExists = highlighter.getLoadedLanguages().includes(node.lang);
+        if (langExists) {
+          lang = node.lang;
+        } else {
+          console.warn(`The language "${node.lang}" doesn't exist, falling back to plaintext.`);
+          lang = "plaintext";
+        }
+      } else {
+        lang = "plaintext";
+      }
+      let themeOptions = Object.values(themes).length ? { themes } : { theme };
+      let html = highlighter.codeToHtml(node.value, { ...themeOptions, lang });
+      html = html.replace(/<pre class="(.*?)shiki(.*?)"/, `<pre class="$1astro-code$2"`);
+      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>'
+        );
+      }
+      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;"'
+        );
+      }
+      const themeName = typeof theme === "string" ? theme : theme.name;
+      if (themeName === "css-variables") {
+        html = html.replace(/style="(.*?)"/g, (m) => replaceCssVariables(m));
+      }
+      node.type = "html";
+      node.value = html;
+      node.children = [];
+    });
+  };
+}
+function replaceCssVariables(str) {
+  return str.replace(COLOR_REPLACEMENT_REGEX, (match) => ASTRO_COLOR_REPLACEMENTS[match] || match);
+}
+export {
+  remarkShiki
+};

package/dist/types.d.ts

@@ -0,0 +1,78 @@
+import type * as hast from 'hast';
+import type * as mdast from 'mdast';
+import type { one as Handler, all as Handlers, Options as RemarkRehypeOptions } from 'remark-rehype';
+import type { BuiltinTheme, LanguageRegistration, ThemeRegistration, ThemeRegistrationRaw } from 'shikiji';
+import type * as unified from 'unified';
+import type { VFile } from 'vfile';
+export type { Node } from 'unist';
+export type MarkdownAstroData = {
+    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 = Omit<RemarkRehypeOptions, 'handlers' | 'unknownHandler'> & {
+    handlers?: typeof Handlers;
+    handler?: typeof Handler;
+};
+export interface ShikiConfig {
+    langs?: LanguageRegistration[];
+    theme?: BuiltinTheme | ThemeRegistration | ThemeRegistrationRaw;
+    experimentalThemes?: Record<string, BuiltinTheme | ThemeRegistration | ThemeRegistrationRaw>;
+    wrap?: boolean | null;
+}
+export interface AstroMarkdownOptions {
+    drafts?: boolean;
+    syntaxHighlight?: 'shiki' | 'prism' | false;
+    shikiConfig?: ShikiConfig;
+    remarkPlugins?: RemarkPlugins;
+    rehypePlugins?: RehypePlugins;
+    remarkRehype?: RemarkRehype;
+    gfm?: boolean;
+    smartypants?: boolean;
+}
+export interface ImageMetadata {
+    src: string;
+    width: number;
+    height: number;
+    type: string;
+}
+export interface MarkdownProcessor {
+    render: (content: string, opts?: MarkdownProcessorRenderOptions) => Promise<MarkdownProcessorRenderResult>;
+}
+export interface MarkdownProcessorRenderOptions {
+    /** Used for frontmatter injection plugins */
+    frontmatter?: Record<string, any>;
+}
+export interface MarkdownProcessorRenderResult {
+    code: string;
+    metadata: {
+        headings: MarkdownHeading[];
+        imagePaths: Set<string>;
+        frontmatter: Record<string, any>;
+    };
+}
+export interface MarkdownRenderingOptions extends AstroMarkdownOptions, MarkdownProcessorRenderOptions {
+}
+export interface MarkdownHeading {
+    depth: number;
+    slug: string;
+    text: string;
+}
+export interface MarkdownMetadata {
+    headings: MarkdownHeading[];
+    source: string;
+    html: string;
+}
+export interface MarkdownVFile extends VFile {
+    data: {
+        __astroHeadings?: MarkdownHeading[];
+        imagePaths?: Set<string>;
+    };
+}
+export interface MarkdownRenderingResult {
+    metadata: MarkdownMetadata;
+    vfile: MarkdownVFile;
+    code: string;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@astrojs/markdown-remark",
+  "version": "0.0.0-assets-uint8array-20231109073138",
+  "type": "module",
+  "author": "withastro",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/withastro/astro.git",
+    "directory": "packages/markdown/remark"
+  },
+  "bugs": "https://github.com/withastro/astro/issues",
+  "homepage": "https://astro.build",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./dist/internal.js": "./dist/internal.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "astro": "0.0.0-assets-uint8array-20231109073138"
+  },
+  "dependencies": {
+    "@astrojs/prism": "^3.0.0",
+    "github-slugger": "^2.0.0",
+    "import-meta-resolve": "^3.0.0",
+    "mdast-util-definitions": "^6.0.0",
+    "rehype-raw": "^6.1.1",
+    "rehype-stringify": "^9.0.4",
+    "remark-gfm": "^3.0.1",
+    "remark-parse": "^10.0.2",
+    "remark-rehype": "^10.1.0",
+    "remark-smartypants": "^2.0.0",
+    "shikiji": "^0.6.8",
+    "unified": "^10.1.2",
+    "unist-util-visit": "^4.1.2",
+    "vfile": "^5.3.7"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.5",
+    "@types/estree": "^1.0.1",
+    "@types/hast": "^2.3.5",
+    "@types/mdast": "^3.0.12",
+    "@types/mocha": "^10.0.1",
+    "@types/unist": "^2.0.7",
+    "chai": "^4.3.7",
+    "mdast-util-mdx-expression": "^1.3.2",
+    "mocha": "^10.2.0",
+    "astro-scripts": "0.0.14"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "scripts": {
+    "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": "mocha --exit --timeout 20000"
+  }
+}