@astrojs/markdoc 0.0.0-10745-20240410180016

package/LICENSE

@@ -0,0 +1,59 @@
+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/README.md

@@ -0,0 +1,38 @@
+# @astrojs/markdoc (experimental) 📝
+
+This **[Astro integration][astro-integration]** enables the usage of [Markdoc](https://markdoc.dev/) to create components, pages, and content collection entries.
+
+## Documentation
+
+Read the [`@astrojs/markdoc` docs][docs]
+
+## Support
+
+- Get help in the [Astro Discord][discord]. Post questions in our `#support` forum, or visit our dedicated `#dev` channel to discuss current development and more!
+
+- Check our [Astro Integration Documentation][astro-integration] for more on integrations.
+
+- Submit bug reports and feature requests as [GitHub issues][issues].
+
+## Contributing
+
+This package is maintained by Astro's Core team. You're welcome to submit an issue or PR! These links will help you get started:
+
+- [Contributor Manual][contributing]
+- [Code of Conduct][coc]
+- [Community Guide][community]
+
+## License
+
+MIT
+
+Copyright (c) 2023–present [Astro][astro]
+
+[astro]: https://astro.build/
+[docs]: https://docs.astro.build/en/guides/integrations-guide/markdoc/
+[contributing]: https://github.com/withastro/astro/blob/main/CONTRIBUTING.md
+[coc]: https://github.com/withastro/.github/blob/main/CODE_OF_CONDUCT.md
+[community]: https://github.com/withastro/.github/blob/main/COMMUNITY_GUIDE.md
+[discord]: https://astro.build/chat/
+[issues]: https://github.com/withastro/astro/issues
+[astro-integration]: https://docs.astro.build/en/guides/integrations-guide/

package/components/Renderer.astro

@@ -0,0 +1,24 @@
+---
+//! astro-head-inject
+import type { Config } from '@markdoc/markdoc';
+import Markdoc from '@markdoc/markdoc';
+import { ComponentNode, createTreeNode } from './TreeNode.js';
+
+type Props = {
+	config: Config;
+	stringifiedAst: string;
+};
+
+const { stringifiedAst, config } = Astro.props as Props;
+
+const ast = Markdoc.Ast.fromJSON(stringifiedAst);
+const content = await Markdoc.transform(ast, config);
+---
+
+{
+	Array.isArray(content) ? (
+		content.map(async (c) => <ComponentNode treeNode={await createTreeNode(c)} />)
+	) : (
+		<ComponentNode treeNode={await createTreeNode(content)} />
+	)
+}

package/components/TreeNode.ts

@@ -0,0 +1,160 @@
+import type { RenderableTreeNode } from '@markdoc/markdoc';
+import Markdoc from '@markdoc/markdoc';
+import type { AstroInstance } from 'astro';
+import type { HTMLString } from 'astro/runtime/server/index.js';
+import {
+	createComponent,
+	createHeadAndContent,
+	isHTMLString,
+	render,
+	renderComponent,
+	renderScriptElement,
+	renderTemplate,
+	renderUniqueStylesheet,
+	unescapeHTML,
+} from 'astro/runtime/server/index.js';
+
+export type TreeNode =
+	| {
+			type: 'text';
+			content: string | HTMLString;
+	  }
+	| {
+			type: 'component';
+			component: AstroInstance['default'];
+			collectedLinks?: string[];
+			collectedStyles?: string[];
+			collectedScripts?: string[];
+			props: Record<string, any>;
+			children: TreeNode[];
+	  }
+	| {
+			type: 'element';
+			tag: string;
+			attributes: Record<string, any>;
+			children: TreeNode[];
+	  };
+
+export const ComponentNode = createComponent({
+	factory(result: any, { treeNode }: { treeNode: TreeNode }) {
+		if (treeNode.type === 'text') return render`${treeNode.content}`;
+
+		const slots = {
+			default: () =>
+				render`${treeNode.children.map((child) =>
+					renderComponent(result, 'ComponentNode', ComponentNode, { treeNode: child })
+				)}`,
+		};
+		if (treeNode.type === 'component') {
+			let styles = '',
+				links = '',
+				scripts = '';
+			if (Array.isArray(treeNode.collectedStyles)) {
+				styles = treeNode.collectedStyles
+					.map((style: any) =>
+						renderUniqueStylesheet(result, {
+							type: 'inline',
+							content: style,
+						})
+					)
+					.join('');
+			}
+			if (Array.isArray(treeNode.collectedLinks)) {
+				links = treeNode.collectedLinks
+					.map((link: any) => {
+						return renderUniqueStylesheet(result, {
+							type: 'external',
+							src: link[0] === '/' ? link : '/' + link,
+						});
+					})
+					.join('');
+			}
+			if (Array.isArray(treeNode.collectedScripts)) {
+				scripts = treeNode.collectedScripts
+					.map((script: any) => renderScriptElement(script))
+					.join('');
+			}
+
+			const head = unescapeHTML(styles + links + scripts);
+
+			let headAndContent = createHeadAndContent(
+				head,
+				renderTemplate`${renderComponent(
+					result,
+					treeNode.component.name,
+					treeNode.component,
+					treeNode.props,
+					slots
+				)}`
+			);
+
+			// Let the runtime know that this component is being used.
+			result._metadata.propagators.add({
+				init() {
+					return headAndContent;
+				},
+			});
+
+			return headAndContent;
+		}
+		return renderComponent(result, treeNode.tag, treeNode.tag, treeNode.attributes, slots);
+	},
+	propagation: 'self',
+});
+
+export async function createTreeNode(node: RenderableTreeNode): Promise<TreeNode> {
+	if (isHTMLString(node)) {
+		return { type: 'text', content: node as HTMLString };
+	} else if (typeof node === 'string' || typeof node === 'number') {
+		return { type: 'text', content: String(node) };
+	} else if (node === null || typeof node !== 'object' || !Markdoc.Tag.isTag(node)) {
+		return { type: 'text', content: '' };
+	}
+
+	const children = await Promise.all(node.children.map((child) => createTreeNode(child)));
+
+	if (typeof node.name === 'function') {
+		const component = node.name;
+		const props = node.attributes;
+
+		return {
+			type: 'component',
+			component,
+			props,
+			children,
+		};
+	} else if (isPropagatedAssetsModule(node.name)) {
+		const { collectedStyles, collectedLinks, collectedScripts } = node.name;
+		const component = (await node.name.getMod()).default;
+		const props = node.attributes;
+
+		return {
+			type: 'component',
+			component,
+			collectedStyles,
+			collectedLinks,
+			collectedScripts,
+			props,
+			children,
+		};
+	} else {
+		return {
+			type: 'element',
+			tag: node.name,
+			attributes: node.attributes,
+			children,
+		};
+	}
+}
+
+type PropagatedAssetsModule = {
+	__astroPropagation: true;
+	getMod: () => Promise<AstroInstance>;
+	collectedStyles: string[];
+	collectedLinks: string[];
+	collectedScripts: string[];
+};
+
+function isPropagatedAssetsModule(module: any): module is PropagatedAssetsModule {
+	return typeof module === 'object' && module != null && '__astroPropagation' in module;
+}

package/components/index.ts

@@ -0,0 +1,2 @@
+// @ts-expect-error
+export { default as Renderer } from './Renderer.astro';

package/dist/config.d.ts

@@ -0,0 +1,57 @@
+import type { Config, ConfigType as MarkdocConfig, MaybePromise, NodeType, Schema } from '@markdoc/markdoc';
+import _Markdoc from '@markdoc/markdoc';
+import type { AstroInstance } from 'astro';
+import { componentConfigSymbol } from './utils.js';
+export type Render = ComponentConfig | AstroInstance['default'] | string;
+export type ComponentConfig = {
+    type: 'package' | 'local';
+    path: string;
+    namedExport?: string;
+    [componentConfigSymbol]: true;
+};
+export type AstroMarkdocConfig<C extends Record<string, any> = Record<string, any>> = Omit<MarkdocConfig, 'tags' | 'nodes'> & Partial<{
+    tags: Record<string, Schema<Config, Render>>;
+    nodes: Partial<Record<NodeType, Schema<Config, Render>>>;
+    ctx: C;
+    extends: MaybePromise<ResolvedAstroMarkdocConfig>[];
+}>;
+export type ResolvedAstroMarkdocConfig = Omit<AstroMarkdocConfig, 'extends'>;
+export declare const Markdoc: typeof _Markdoc;
+export declare const nodes: {
+    heading: Schema;
+    document: Schema;
+    paragraph: Schema;
+    image: Schema;
+    fence: Schema;
+    blockquote: Schema;
+    item: Schema;
+    list: Schema;
+    hr: Schema;
+    table: Schema;
+    td: Schema;
+    th: Schema;
+    tr: Schema;
+    tbody: Schema;
+    thead: Schema;
+    strong: Schema;
+    em: Schema;
+    s: Schema;
+    inline: Schema;
+    link: Schema;
+    code: Schema;
+    text: Schema;
+    hardbreak: Schema;
+    softbreak: Schema;
+    comment: {
+        attributes: {
+            content: {
+                type: StringConstructor;
+                required: boolean;
+            };
+        };
+    };
+    error: {};
+    node: {};
+};
+export declare function defineMarkdocConfig(config: AstroMarkdocConfig): AstroMarkdocConfig;
+export declare function component(pathnameOrPkgName: string, namedExport?: string): ComponentConfig;

package/dist/config.js

@@ -0,0 +1,26 @@
+import { isRelativePath } from "@astrojs/internal-helpers/path";
+import _Markdoc from "@markdoc/markdoc";
+import { heading } from "./heading-ids.js";
+import { componentConfigSymbol } from "./utils.js";
+const Markdoc = _Markdoc;
+const nodes = { ...Markdoc.nodes, heading };
+function defineMarkdocConfig(config) {
+  return config;
+}
+function component(pathnameOrPkgName, namedExport) {
+  return {
+    type: isNpmPackageName(pathnameOrPkgName) ? "package" : "local",
+    path: pathnameOrPkgName,
+    namedExport,
+    [componentConfigSymbol]: true
+  };
+}
+function isNpmPackageName(pathname) {
+  return !isRelativePath(pathname) && !pathname.startsWith("/");
+}
+export {
+  Markdoc,
+  component,
+  defineMarkdocConfig,
+  nodes
+};

package/dist/content-entry-type.d.ts

@@ -0,0 +1,8 @@
+import type { AstroConfig, ContentEntryType } from 'astro';
+import type { MarkdocConfigResult } from './load-config.js';
+import type { MarkdocIntegrationOptions } from './options.js';
+export declare function getContentEntryType({ markdocConfigResult, astroConfig, options, }: {
+    astroConfig: AstroConfig;
+    markdocConfigResult?: MarkdocConfigResult;
+    options?: MarkdocIntegrationOptions;
+}): Promise<ContentEntryType>;

package/dist/content-entry-type.js

@@ -0,0 +1,317 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import Markdoc from "@markdoc/markdoc";
+import { emitESMImage } from "astro/assets/utils";
+import matter from "gray-matter";
+import { htmlTokenTransform } from "./html/transform/html-token-transform.js";
+import { setupConfig } from "./runtime.js";
+import { getMarkdocTokenizer } from "./tokenizer.js";
+import { MarkdocError, isComponentConfig, isValidUrl, prependForwardSlash } from "./utils.js";
+async function getContentEntryType({
+  markdocConfigResult,
+  astroConfig,
+  options
+}) {
+  return {
+    extensions: [".mdoc"],
+    getEntryInfo,
+    handlePropagation: true,
+    async getRenderModule({ contents, fileUrl, viteId }) {
+      const entry = getEntryInfo({ contents, fileUrl });
+      const tokenizer = getMarkdocTokenizer(options);
+      let tokens = tokenizer.tokenize(entry.body);
+      if (options?.allowHTML) {
+        tokens = htmlTokenTransform(tokenizer, tokens);
+      }
+      const ast = Markdoc.parse(tokens);
+      const userMarkdocConfig = markdocConfigResult?.config ?? {};
+      const markdocConfigUrl = markdocConfigResult?.fileUrl;
+      const pluginContext = this;
+      const markdocConfig = await setupConfig(userMarkdocConfig, options);
+      const filePath = fileURLToPath(fileUrl);
+      raiseValidationErrors({
+        ast,
+        /* Raised generics issue with Markdoc core https://github.com/markdoc/markdoc/discussions/400 */
+        markdocConfig,
+        entry,
+        viteId,
+        astroConfig,
+        filePath
+      });
+      await resolvePartials({
+        ast,
+        markdocConfig,
+        fileUrl,
+        allowHTML: options?.allowHTML,
+        tokenizer,
+        pluginContext,
+        root: astroConfig.root,
+        raisePartialValidationErrors: (partialAst, partialPath) => {
+          raiseValidationErrors({
+            ast: partialAst,
+            markdocConfig,
+            entry,
+            viteId,
+            astroConfig,
+            filePath: partialPath
+          });
+        }
+      });
+      const usedTags = getUsedTags(ast);
+      let componentConfigByTagMap = {};
+      for (const tag of usedTags) {
+        const render = userMarkdocConfig.tags?.[tag]?.render;
+        if (isComponentConfig(render)) {
+          componentConfigByTagMap[tag] = render;
+        }
+      }
+      let componentConfigByNodeMap = {};
+      for (const [nodeType, schema] of Object.entries(userMarkdocConfig.nodes ?? {})) {
+        const render = schema?.render;
+        if (isComponentConfig(render)) {
+          componentConfigByNodeMap[nodeType] = render;
+        }
+      }
+      await emitOptimizedImages(ast.children, {
+        astroConfig,
+        pluginContext,
+        filePath
+      });
+      const res = `import { Renderer } from '@astrojs/markdoc/components';
+import { createGetHeadings, createContentComponent } from '@astrojs/markdoc/runtime';
+${markdocConfigUrl ? `import markdocConfig from ${JSON.stringify(fileURLToPath(markdocConfigUrl))};` : "const markdocConfig = {};"}
+
+import { assetsConfig } from '@astrojs/markdoc/runtime-assets-config';
+markdocConfig.nodes = { ...assetsConfig.nodes, ...markdocConfig.nodes };
+
+${getStringifiedImports(componentConfigByTagMap, "Tag", astroConfig.root)}
+${getStringifiedImports(componentConfigByNodeMap, "Node", astroConfig.root)}
+
+const tagComponentMap = ${getStringifiedMap(componentConfigByTagMap, "Tag")};
+const nodeComponentMap = ${getStringifiedMap(componentConfigByNodeMap, "Node")};
+
+const options = ${JSON.stringify(options)};
+
+const stringifiedAst = ${JSON.stringify(
+        /* Double stringify to encode *as* stringified JSON */
+        JSON.stringify(ast)
+      )};
+
+export const getHeadings = createGetHeadings(stringifiedAst, markdocConfig, options);
+export const Content = createContentComponent(
+	Renderer,
+	stringifiedAst,
+	markdocConfig,
+  options,
+	tagComponentMap,
+	nodeComponentMap,
+)`;
+      return { code: res };
+    },
+    contentModuleTypes: await fs.promises.readFile(
+      new URL("../template/content-module-types.d.ts", import.meta.url),
+      "utf-8"
+    )
+  };
+}
+async function resolvePartials({
+  ast,
+  fileUrl,
+  root,
+  tokenizer,
+  allowHTML,
+  markdocConfig,
+  pluginContext,
+  raisePartialValidationErrors
+}) {
+  const relativePartialPath = path.relative(fileURLToPath(root), fileURLToPath(fileUrl));
+  for (const node of ast.walk()) {
+    if (node.type === "tag" && node.tag === "partial") {
+      const { file } = node.attributes;
+      if (!file) {
+        throw new MarkdocError({
+          // Should be caught by Markdoc validation step.
+          message: `(Uncaught error) Partial tag requires a 'file' attribute`
+        });
+      }
+      if (markdocConfig.partials?.[file])
+        continue;
+      let partialPath;
+      let partialContents;
+      try {
+        const resolved = await pluginContext.resolve(file, fileURLToPath(fileUrl));
+        let partialId = resolved?.id;
+        if (!partialId) {
+          const attemptResolveAsRelative = await pluginContext.resolve(
+            "./" + file,
+            fileURLToPath(fileUrl)
+          );
+          if (!attemptResolveAsRelative?.id)
+            throw new Error();
+          partialId = attemptResolveAsRelative.id;
+        }
+        partialPath = fileURLToPath(new URL(prependForwardSlash(partialId), "file://"));
+        partialContents = await fs.promises.readFile(partialPath, "utf-8");
+      } catch {
+        throw new MarkdocError({
+          message: [
+            `**${String(relativePartialPath)}** contains invalid content:`,
+            `Could not read partial file \`${file}\`. Does the file exist?`
+          ].join("\n")
+        });
+      }
+      if (pluginContext.meta.watchMode)
+        pluginContext.addWatchFile(partialPath);
+      let partialTokens = tokenizer.tokenize(partialContents);
+      if (allowHTML) {
+        partialTokens = htmlTokenTransform(tokenizer, partialTokens);
+      }
+      const partialAst = Markdoc.parse(partialTokens);
+      raisePartialValidationErrors(partialAst, partialPath);
+      await resolvePartials({
+        ast: partialAst,
+        root,
+        fileUrl: pathToFileURL(partialPath),
+        tokenizer,
+        allowHTML,
+        markdocConfig,
+        pluginContext,
+        raisePartialValidationErrors
+      });
+      Object.assign(node, partialAst);
+    }
+  }
+}
+function raiseValidationErrors({
+  ast,
+  markdocConfig,
+  entry,
+  viteId,
+  astroConfig,
+  filePath
+}) {
+  const validationErrors = Markdoc.validate(ast, markdocConfig).filter((e) => {
+    return (e.error.level === "error" || e.error.level === "critical") && // Ignore `variable-undefined` errors.
+    // Variables can be configured at runtime,
+    // so we cannot validate them at build time.
+    e.error.id !== "variable-undefined" && // Ignore missing partial errors.
+    // We will resolve these in `resolvePartials`.
+    !(e.error.id === "attribute-value-invalid" && e.error.message.match(/^Partial .+ not found/));
+  });
+  if (validationErrors.length) {
+    const frontmatterBlockOffset = entry.rawData.split("\n").length + 2;
+    const rootRelativePath = path.relative(fileURLToPath(astroConfig.root), filePath);
+    throw new MarkdocError({
+      message: [
+        `**${String(rootRelativePath)}** contains invalid content:`,
+        ...validationErrors.map((e) => `- ${e.error.message}`)
+      ].join("\n"),
+      location: {
+        // Error overlay does not support multi-line or ranges.
+        // Just point to the first line.
+        line: frontmatterBlockOffset + validationErrors[0].lines[0],
+        file: viteId
+      }
+    });
+  }
+}
+function getUsedTags(markdocAst) {
+  const tags = /* @__PURE__ */ new Set();
+  const validationErrors = Markdoc.validate(markdocAst);
+  for (const { error } of validationErrors) {
+    if (error.id === "tag-undefined") {
+      const [, tagName] = error.message.match(/Undefined tag: '(.*)'/) ?? [];
+      tags.add(tagName);
+    }
+  }
+  return tags;
+}
+function getEntryInfo({ fileUrl, contents }) {
+  const parsed = parseFrontmatter(contents, fileURLToPath(fileUrl));
+  return {
+    data: parsed.data,
+    body: parsed.content,
+    slug: parsed.data.slug,
+    rawData: parsed.matter
+  };
+}
+async function emitOptimizedImages(nodeChildren, ctx) {
+  for (const node of nodeChildren) {
+    let isComponent = node.type === "tag" && node.tag === "image";
+    if ((node.type === "image" || isComponent) && typeof node.attributes.src === "string") {
+      let attributeName = isComponent ? "src" : "__optimizedSrc";
+      if (shouldOptimizeImage(node.attributes.src)) {
+        const resolved = await ctx.pluginContext.resolve(node.attributes.src, ctx.filePath);
+        if (resolved?.id && fs.existsSync(new URL(prependForwardSlash(resolved.id), "file://"))) {
+          const src = await emitESMImage(
+            resolved.id,
+            ctx.pluginContext.meta.watchMode,
+            ctx.pluginContext.emitFile
+          );
+          const fsPath = resolved.id;
+          if (src) {
+            if (ctx.astroConfig.output === "static") {
+              if (globalThis.astroAsset.referencedImages)
+                globalThis.astroAsset.referencedImages.add(fsPath);
+            }
+            node.attributes[attributeName] = { ...src, fsPath };
+          }
+        } else {
+          throw new MarkdocError({
+            message: `Could not resolve image ${JSON.stringify(
+              node.attributes.src
+            )} from ${JSON.stringify(ctx.filePath)}. Does the file exist?`
+          });
+        }
+      } else if (isComponent) {
+        node.attributes[attributeName] = node.attributes.src;
+      }
+    }
+    await emitOptimizedImages(node.children, ctx);
+  }
+}
+function shouldOptimizeImage(src) {
+  return !isValidUrl(src) && !src.startsWith("/");
+}
+function getStringifiedImports(componentConfigMap, componentNamePrefix, root) {
+  let stringifiedComponentImports = "";
+  for (const [key, config] of Object.entries(componentConfigMap)) {
+    const importName = config.namedExport ? `{ ${config.namedExport} as ${componentNamePrefix + toImportName(key)} }` : componentNamePrefix + toImportName(key);
+    const resolvedPath = config.type === "local" ? fileURLToPath(new URL(config.path, root)) : config.path;
+    stringifiedComponentImports += `import ${importName} from ${JSON.stringify(resolvedPath)};
+`;
+  }
+  return stringifiedComponentImports;
+}
+function toImportName(unsafeName) {
+  return unsafeName.replace("-", "_");
+}
+function getStringifiedMap(componentConfigMap, componentNamePrefix) {
+  let stringifiedComponentMap = "{";
+  for (const key in componentConfigMap) {
+    stringifiedComponentMap += `${JSON.stringify(key)}: ${componentNamePrefix + toImportName(key)},
+`;
+  }
+  stringifiedComponentMap += "}";
+  return stringifiedComponentMap;
+}
+function parseFrontmatter(fileContents, filePath) {
+  try {
+    matter.clearCache();
+    return matter(fileContents);
+  } catch (e) {
+    if (e.name === "YAMLException") {
+      const err = e;
+      err.id = filePath;
+      err.loc = { file: e.id, line: e.mark.line + 1, column: e.mark.column };
+      err.message = e.reason;
+      throw err;
+    } else {
+      throw e;
+    }
+  }
+}
+export {
+  getContentEntryType
+};