@ox-content/vite-plugin-solid 2.81.0

package/dist/index.cjs

@@ -0,0 +1,701 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _ox_content_vite_plugin = require("@ox-content/vite-plugin");
+let fs = require("fs");
+fs = __toESM(fs, 1);
+let path = require("path");
+path = __toESM(path, 1);
+//#region src/components.ts
+/**
+* Resolves the `components` option into a name → path map, expanding glob
+* patterns against the Vite project root.
+*/
+async function resolveComponentsGlob(componentsOption, root) {
+	if (typeof componentsOption === "object" && !Array.isArray(componentsOption)) return componentsOption;
+	const patterns = Array.isArray(componentsOption) ? componentsOption : [componentsOption];
+	const result = {};
+	for (const pattern of patterns) for (const file of await globFiles(pattern, root)) {
+		const baseName = path.basename(file, path.extname(file));
+		const relativePath = "./" + path.relative(root, file).replace(/\\/g, "/");
+		result[toPascalCase(baseName)] = relativePath;
+	}
+	return result;
+}
+async function globFiles(pattern, root) {
+	const files = [];
+	const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+	if (!hasWildcard(normalized)) {
+		const fullPath = path.resolve(root, normalized);
+		if (fs.existsSync(fullPath)) files.push(fullPath);
+		return files;
+	}
+	const baseDir = path.resolve(root, staticPrefix(normalized));
+	if (!fs.existsSync(baseDir)) return files;
+	const segments = normalized.split("/");
+	const crossesDirectories = normalized.includes("**") || segments.slice(0, -1).some(hasWildcard);
+	const candidates = [];
+	if (crossesDirectories) await walkDir(baseDir, candidates);
+	else {
+		const entries = await fs.promises.readdir(baseDir, { withFileTypes: true });
+		for (const entry of entries) if (entry.isFile()) candidates.push(path.join(baseDir, entry.name));
+	}
+	const matcher = globToRegExp(normalized);
+	for (const candidate of candidates) if (matcher.test(path.relative(root, candidate).replace(/\\/g, "/"))) files.push(candidate);
+	return files;
+}
+/** Whether a pattern (or one segment of it) contains a wildcard `globToRegExp` expands. */
+function hasWildcard(pattern) {
+	return pattern.includes("*") || pattern.includes("?");
+}
+/** Leading path segments of a pattern that contain no wildcard. */
+function staticPrefix(pattern) {
+	const segments = [];
+	for (const segment of pattern.split("/")) {
+		if (hasWildcard(segment)) break;
+		segments.push(segment);
+	}
+	return segments.join("/");
+}
+/**
+* Translates a glob into an anchored `RegExp`: `**` crosses directory
+* boundaries, `*` and `?` stay within one segment.
+*/
+function globToRegExp(pattern) {
+	let source = "";
+	let index = 0;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "*") {
+			if (pattern[index + 1] === "*") {
+				index += 2;
+				if (pattern[index] === "/") {
+					index += 1;
+					source += "(?:[^/]+/)*";
+				} else source += ".*";
+				continue;
+			}
+			source += "[^/]*";
+		} else if (char === "?") source += "[^/]";
+		else source += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		index += 1;
+	}
+	return new RegExp(`^${source}$`);
+}
+async function walkDir(dir, files) {
+	const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) await walkDir(fullPath, files);
+		else if (entry.isFile()) files.push(fullPath);
+	}
+}
+function toPascalCase(str) {
+	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+}
+//#endregion
+//#region src/environment.ts
+function createSolidMarkdownEnvironment(mode, options) {
+	const isSSR = mode === "ssr";
+	return {
+		build: {
+			outDir: isSSR ? `${options.outDir}/.ox-content/ssr` : `${options.outDir}/.ox-content/client`,
+			ssr: isSSR,
+			rollupOptions: { output: {
+				format: "esm",
+				entryFileNames: isSSR ? "[name].js" : "[name].[hash].js"
+			} },
+			...isSSR && {
+				target: "node18",
+				minify: false
+			}
+		},
+		resolve: { conditions: isSSR ? [
+			"solid",
+			"node",
+			"import"
+		] : [
+			"solid",
+			"browser",
+			"import"
+		] },
+		optimizeDeps: {
+			include: isSSR ? [] : ["solid-js", "solid-js/web"],
+			exclude: ["@ox-content/vite-plugin", "@ox-content/vite-plugin-solid"]
+		}
+	};
+}
+//#endregion
+//#region src/options.ts
+const DEFAULT_MARKDOWN_EXTENSIONS = [
+	".md",
+	".markdown",
+	".mdx"
+];
+function resolveSolidOptions(options) {
+	return {
+		srcDir: options.srcDir ?? "docs",
+		outDir: options.outDir ?? "dist",
+		base: options.base ?? "/",
+		extensions: normalizeMarkdownExtensions(options.extensions),
+		gfm: options.gfm ?? true,
+		autolinks: options.autolinks ?? options.gfm ?? true,
+		frontmatter: options.frontmatter ?? true,
+		toc: options.toc ?? true,
+		tocMaxDepth: options.tocMaxDepth ?? 3,
+		codeAnnotations: resolveCodeAnnotationsOptions(options.codeAnnotations),
+		verifySolidPlugin: options.verifySolidPlugin ?? true,
+		embeds: resolveBuiltinEmbedOptions(options.embeds)
+	};
+}
+function normalizeMarkdownExtensions(extensions) {
+	const values = extensions?.length ? extensions : DEFAULT_MARKDOWN_EXTENSIONS;
+	return Array.from(new Map(values.map((extension) => {
+		const value = extension.startsWith(".") ? extension : `.${extension}`;
+		return [value.toLowerCase(), value];
+	})).values());
+}
+function isMarkdownFilePath(filePath, extensions) {
+	const pathname = filePath.split("?")[0].split("#")[0].toLowerCase();
+	return extensions.some((extension) => pathname.endsWith(extension.toLowerCase()));
+}
+function resolveCodeAnnotationsOptions(options) {
+	if (!options) return {
+		enabled: false,
+		metaKey: "annotate"
+	};
+	if (options === true) return {
+		enabled: true,
+		metaKey: "annotate"
+	};
+	return {
+		enabled: true,
+		metaKey: options.metaKey ?? "annotate"
+	};
+}
+function resolveBuiltinEmbedOptions(options) {
+	if (options === false) return {
+		github: false,
+		openGraph: false
+	};
+	return {
+		github: resolveSingleEmbedOptions(options?.github),
+		openGraph: resolveSingleEmbedOptions(options?.openGraph)
+	};
+}
+function resolveSingleEmbedOptions(options) {
+	if (options === false) return false;
+	if (options === true || options === void 0) return {};
+	return options;
+}
+//#endregion
+//#region src/codegen.ts
+/**
+* Generates the Solid module a Markdown file compiles to.
+*
+* The output is JSX on purpose. Solid has no runtime element factory to target
+* — `vite-plugin-solid` compiles this into DOM or SSR instructions — so unlike
+* the React and Vue integrations there is no factory-call form to emit.
+*/
+function generateSolidModule(content, usedComponents, islands, frontmatter, options, id) {
+	const rawHtml = JSON.stringify(content);
+	const frontmatterLiteral = JSON.stringify(frontmatter);
+	if (islands.length === 0) return `
+export const frontmatter = ${frontmatterLiteral};
+
+const rawHtml = ${rawHtml};
+
+export default function MarkdownContent() {
+  return <div class="ox-content" innerHTML={rawHtml} />;
+}
+`;
+	return `
+import { onCleanup, onMount } from 'solid-js';
+import { render } from 'solid-js/web';
+import { initIslands } from '@ox-content/islands';
+${renderComponentImports(usedComponents, options, id)}
+
+export const frontmatter = ${frontmatterLiteral};
+
+const rawHtml = ${rawHtml};
+const components = {
+${usedComponents.map((name) => `  ${name},`).join("\n")}
+};
+
+function createSolidHydrate() {
+  return (element, props) => {
+    const componentName = element.dataset.oxIsland;
+    const Component = components[componentName];
+    if (!Component) return;
+
+    // Read the slot content before clearing: the island element still holds the
+    // markup the Markdown transform left behind.
+    const islandContent = element.dataset.oxContent || element.innerHTML;
+    element.innerHTML = '';
+
+    const dispose = render(
+      () =>
+        islandContent
+          ? <Component {...props}><div innerHTML={islandContent} /></Component>
+          : <Component {...props} />,
+      element,
+    );
+
+    return () => dispose();
+  };
+}
+
+export default function MarkdownContent() {
+  let container;
+
+  onMount(() => {
+    if (!container) return;
+    const controller = initIslands(createSolidHydrate(), {
+      selector: '.ox-content [data-ox-island]',
+    });
+    onCleanup(() => controller.destroy());
+  });
+
+  return <div class="ox-content" ref={container} innerHTML={rawHtml} />;
+}
+`;
+}
+/** Rewrites registered component paths as imports relative to the Markdown file. */
+function renderComponentImports(usedComponents, options, id) {
+	const mdDir = path.dirname(id);
+	const root = options.root || process.cwd();
+	return usedComponents.map((name) => {
+		const componentPath = options.components[name];
+		if (!componentPath) return "";
+		const absolutePath = path.resolve(root, componentPath.replace(/^\.\//, ""));
+		const relativePath = path.relative(mdDir, absolutePath).replace(/\\/g, "/");
+		return `import ${name} from '${relativePath.startsWith(".") ? relativePath : "./" + relativePath}';`;
+	}).filter(Boolean).join("\n");
+}
+//#endregion
+//#region src/markdown.ts
+const COMPONENT_REGEX = /<([A-Z][a-zA-Z0-9]*)\s*([^>]*?)\s*(?:\/>|>([\s\S]*?)<\/\1>)/g;
+const PROP_REGEX = /([a-zA-Z0-9-]+)(?:=(?:"([^"]*)"|'([^']*)'|{([^}]*)}|\[([^\]]*)\]))?/g;
+const ISLAND_MARKER_PREFIX = "OXCONTENT-ISLAND-";
+const ISLAND_MARKER_SUFFIX = "-PLACEHOLDER";
+/**
+* Replaces every registered component tag with a placeholder marker that
+* survives Markdown rendering, so the island can be re-attached to the produced
+* HTML afterwards. Tags inside fenced code blocks are left as literal text.
+*/
+function scanComponents(markdown, components) {
+	const usedComponents = [];
+	const islands = [];
+	const fenceRanges = collectFenceRanges(markdown);
+	let islandIndex = 0;
+	let content = "";
+	let lastIndex = 0;
+	let match;
+	COMPONENT_REGEX.lastIndex = 0;
+	while ((match = COMPONENT_REGEX.exec(markdown)) !== null) {
+		const [fullMatch, componentName, propsString, rawIslandContent] = match;
+		const matchStart = match.index;
+		const matchEnd = matchStart + fullMatch.length;
+		if (!Object.prototype.hasOwnProperty.call(components, componentName) || isInRanges(matchStart, matchEnd, fenceRanges)) {
+			content += markdown.slice(lastIndex, matchEnd);
+			lastIndex = matchEnd;
+			continue;
+		}
+		if (!usedComponents.includes(componentName)) usedComponents.push(componentName);
+		const islandId = `ox-island-${islandIndex++}`;
+		islands.push({
+			name: componentName,
+			props: parseProps(propsString),
+			position: matchStart,
+			id: islandId,
+			content: typeof rawIslandContent === "string" ? rawIslandContent.trim() : void 0
+		});
+		content += markdown.slice(lastIndex, matchStart) + createIslandMarker(islandId);
+		lastIndex = matchEnd;
+	}
+	content += markdown.slice(lastIndex);
+	return {
+		content,
+		islands,
+		usedComponents
+	};
+}
+/** Swaps the placeholder markers in rendered HTML for island mount points. */
+function injectIslandMarkers(html, islands) {
+	let output = html;
+	for (const island of islands) {
+		const marker = createIslandMarker(island.id);
+		const propsAttr = Object.keys(island.props).length > 0 ? ` data-ox-props='${JSON.stringify(island.props).replace(/'/g, "&#39;")}'` : "";
+		const contentAttr = island.content ? ` data-ox-content='${island.content.replace(/'/g, "&#39;")}'` : "";
+		const attrs = `data-ox-island="${island.name}"${propsAttr}${contentAttr}`;
+		output = output.replaceAll(`<p>${marker}</p>`, `<div ${attrs}></div>`);
+		output = output.replaceAll(marker, `<span ${attrs}></span>`);
+	}
+	return output;
+}
+function extractFrontmatter(content) {
+	const match = /^---\n([\s\S]*?)\n---\n/.exec(content);
+	if (!match) return {
+		content,
+		frontmatter: {}
+	};
+	const frontmatter = {};
+	for (const line of match[1].split("\n")) {
+		const colonIndex = line.indexOf(":");
+		if (colonIndex > 0) {
+			const key = line.slice(0, colonIndex).trim();
+			let value = line.slice(colonIndex + 1).trim();
+			try {
+				value = JSON.parse(value);
+			} catch {
+				if (typeof value === "string" && (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'"))) value = value.slice(1, -1);
+			}
+			frontmatter[key] = value;
+		}
+	}
+	return {
+		content: content.slice(match[0].length),
+		frontmatter
+	};
+}
+function createIslandMarker(islandId) {
+	return `${ISLAND_MARKER_PREFIX}${islandId}${ISLAND_MARKER_SUFFIX}`;
+}
+function collectFenceRanges(content) {
+	const ranges = [];
+	let inFence = false;
+	let fenceChar = "";
+	let fenceLength = 0;
+	let fenceStart = 0;
+	let pos = 0;
+	while (pos < content.length) {
+		const lineEnd = content.indexOf("\n", pos);
+		const next = lineEnd === -1 ? content.length : lineEnd + 1;
+		const fenceMatch = content.slice(pos, lineEnd === -1 ? content.length : lineEnd).match(/^\s{0,3}([`~]{3,})/);
+		if (fenceMatch) {
+			const marker = fenceMatch[1];
+			if (!inFence) {
+				inFence = true;
+				fenceChar = marker[0];
+				fenceLength = marker.length;
+				fenceStart = pos;
+			} else if (marker[0] === fenceChar && marker.length >= fenceLength) {
+				inFence = false;
+				ranges.push({
+					start: fenceStart,
+					end: next
+				});
+				fenceChar = "";
+				fenceLength = 0;
+			}
+		}
+		pos = next;
+	}
+	if (inFence) ranges.push({
+		start: fenceStart,
+		end: content.length
+	});
+	return ranges;
+}
+function isInRanges(start, end, ranges) {
+	for (const range of ranges) if (start < range.end && end > range.start) return true;
+	return false;
+}
+function parseProps(propsString) {
+	const props = {};
+	if (!propsString) return props;
+	PROP_REGEX.lastIndex = 0;
+	let match;
+	while ((match = PROP_REGEX.exec(propsString)) !== null) {
+		const [, name, doubleQuoted, singleQuoted, braceValue, bracketValue] = match;
+		if (!name) continue;
+		if (doubleQuoted !== void 0) props[name] = doubleQuoted;
+		else if (singleQuoted !== void 0) props[name] = singleQuoted;
+		else if (braceValue !== void 0) try {
+			props[name] = JSON.parse(braceValue);
+		} catch {
+			props[name] = braceValue;
+		}
+		else if (bracketValue !== void 0) try {
+			props[name] = JSON.parse(`[${bracketValue}]`);
+		} catch {
+			props[name] = bracketValue;
+		}
+		else props[name] = true;
+	}
+	return props;
+}
+//#endregion
+//#region src/transform.ts
+async function transformMarkdownWithSolid(code, id, options) {
+	const { content: markdownContent, frontmatter } = options.frontmatter ? extractFrontmatter(code) : {
+		content: code,
+		frontmatter: {}
+	};
+	const scanned = scanComponents(markdownContent, options.components);
+	return {
+		code: generateSolidModule(injectIslandMarkers((await (0, _ox_content_vite_plugin.transformMarkdown)(scanned.content, id, createBaseOptions(options))).html, scanned.islands), scanned.usedComponents, scanned.islands, frontmatter, options, id),
+		map: null,
+		usedComponents: scanned.usedComponents,
+		frontmatter
+	};
+}
+/**
+* Options handed to the core Markdown transform.
+*
+* The site-level features (SSG, search, OG images, highlighting) are turned off
+* here: this path only produces the HTML that gets embedded in a Solid module,
+* and the host app owns everything around it. Frontmatter is stripped before
+* this point, so the core parser sees a body-only document.
+*/
+function createBaseOptions(options) {
+	return {
+		srcDir: options.srcDir,
+		outDir: options.outDir,
+		base: options.base,
+		extensions: options.extensions,
+		ssg: {
+			enabled: false,
+			extension: ".html",
+			clean: false,
+			bare: false,
+			generateOgImage: false,
+			lastUpdated: false
+		},
+		gfm: options.gfm,
+		frontmatter: false,
+		toc: options.toc,
+		tocMaxDepth: options.tocMaxDepth,
+		codeAnnotations: options.codeAnnotations,
+		footnotes: true,
+		tables: true,
+		taskLists: true,
+		strikethrough: true,
+		autolinks: options.autolinks,
+		highlight: false,
+		highlightTheme: "github-dark",
+		highlightLangs: [],
+		mermaid: false,
+		ogImage: false,
+		ogImageOptions: {
+			vuePlugin: "vitejs",
+			width: 1200,
+			height: 630,
+			cache: true,
+			concurrency: 1
+		},
+		transformers: [],
+		docs: false,
+		ogViewer: false,
+		search: {
+			enabled: false,
+			limit: 10,
+			prefix: true,
+			placeholder: "Search...",
+			hotkey: "k"
+		},
+		embeds: options.embeds,
+		i18n: false
+	};
+}
+//#endregion
+//#region src/verify.ts
+const TRANSFORM_PLUGIN_NAME = "ox-content:solid-transform";
+const SOLID_PLUGIN_NAME = "solid";
+function formatSolidPluginError(reason) {
+	const example = [
+		"  plugins: [",
+		"    oxContentSolid({ srcDir: 'docs' }),",
+		"    solid({ extensions: ['.md', '.markdown', '.mdx'] }),",
+		"  ]"
+	].join("\n");
+	return `[ox-content:solid] ${{
+		missing: "vite-plugin-solid was not found in the Vite config. Markdown files are emitted as Solid JSX, which only runs after babel-preset-solid compiles it.",
+		ordering: "vite-plugin-solid runs before oxContentSolid(), so it sees raw Markdown instead of the generated JSX. Both plugins are `enforce: 'pre'`, so their order follows the `plugins` array.",
+		extensions: "vite-plugin-solid did not compile the generated Markdown module. Its `extensions` option must list the Markdown extensions; by default it only looks at .jsx/.tsx files."
+	}[reason]}\n\n${example}\n`;
+}
+/**
+* Throws when `vite-plugin-solid` is absent, or placed where it would see raw
+* Markdown instead of the JSX this plugin generates.
+*/
+function verifySolidPluginOrder(config) {
+	const names = config.plugins.map((plugin) => plugin.name);
+	const solidIndex = names.indexOf(SOLID_PLUGIN_NAME);
+	if (solidIndex === -1) throw new Error(formatSolidPluginError("missing"));
+	const transformIndex = names.indexOf(TRANSFORM_PLUGIN_NAME);
+	if (transformIndex !== -1 && solidIndex < transformIndex) throw new Error(formatSolidPluginError("ordering"));
+}
+//#endregion
+//#region src/index.ts
+/**
+* Creates the Ox Content Solid integration plugin.
+*
+* Unlike the React and Svelte integrations, this plugin must be listed **before**
+* `vite-plugin-solid`, and that plugin must be told about the Markdown
+* extensions. Markdown is turned into Solid JSX here, and Solid's JSX is
+* compile-time only — `vite-plugin-solid` is what turns it into DOM or SSR
+* instructions.
+*
+* @example
+* ```ts
+* // vite.config.ts
+* import { defineConfig } from 'vite';
+* import solid from 'vite-plugin-solid';
+* import { oxContentSolid } from '@ox-content/vite-plugin-solid';
+*
+* export default defineConfig({
+*   plugins: [
+*     oxContentSolid({
+*       srcDir: 'docs',
+*       components: {
+*         Counter: './src/components/Counter.tsx',
+*       },
+*     }),
+*     solid({ extensions: ['.md', '.markdown', '.mdx'] }),
+*   ],
+* });
+* ```
+*/
+function oxContentSolid(options = {}) {
+	const resolved = resolveSolidOptions(options);
+	let componentMap = /* @__PURE__ */ new Map();
+	let config;
+	if (typeof options.components === "object" && !Array.isArray(options.components)) componentMap = new Map(Object.entries(options.components));
+	const solidTransformPlugin = {
+		name: TRANSFORM_PLUGIN_NAME,
+		enforce: "pre",
+		async configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			if (resolved.verifySolidPlugin) verifySolidPluginOrder(resolvedConfig);
+			const componentsOption = options.components;
+			if (componentsOption) {
+				const resolvedComponents = await resolveComponentsGlob(componentsOption, config.root);
+				componentMap = new Map(Object.entries(resolvedComponents));
+			}
+		},
+		async transform(code, id) {
+			if (!isMarkdownFilePath(id, resolved.extensions)) return null;
+			const result = await transformMarkdownWithSolid(code, id, {
+				...resolved,
+				components: Object.fromEntries(componentMap),
+				root: config.root
+			});
+			return {
+				code: result.code,
+				map: result.map
+			};
+		}
+	};
+	const solidVerifyPlugin = {
+		name: "ox-content:solid-verify",
+		enforce: "post",
+		transform(code, id) {
+			if (!resolved.verifySolidPlugin) return null;
+			if (!isMarkdownFilePath(id, resolved.extensions)) return null;
+			if (!code.includes("innerHTML={rawHtml}")) return null;
+			this.error(formatSolidPluginError("extensions"));
+		}
+	};
+	const solidEnvironmentPlugin = {
+		name: "ox-content:solid-environment",
+		config() {
+			const envOptions = {
+				...resolved,
+				components: Object.fromEntries(componentMap)
+			};
+			return { environments: {
+				oxcontent_ssr: createSolidMarkdownEnvironment("ssr", envOptions),
+				oxcontent_client: createSolidMarkdownEnvironment("client", envOptions)
+			} };
+		},
+		resolveId(id) {
+			if (id === "virtual:ox-content-solid/components") return "\0virtual:ox-content-solid/components";
+			return null;
+		},
+		load(id) {
+			if (id === "\0virtual:ox-content-solid/components") return generateComponentsModule(componentMap);
+			return null;
+		},
+		applyToEnvironment(environment) {
+			return [
+				"oxcontent_ssr",
+				"oxcontent_client",
+				"client",
+				"ssr"
+			].includes(environment.name);
+		}
+	};
+	const solidHmrPlugin = {
+		name: "ox-content:solid-hmr",
+		apply: "serve",
+		handleHotUpdate({ file, server, modules }) {
+			if (Array.from(componentMap.values()).some((path) => file.endsWith(path.replace(/^\.\//, "")))) {
+				const mdModules = Array.from(server.moduleGraph.idToModuleMap.values()).filter((mod) => mod.file && isMarkdownFilePath(mod.file, resolved.extensions));
+				if (mdModules.length > 0) {
+					server.ws.send({
+						type: "custom",
+						event: "ox-content:solid-update",
+						data: { file }
+					});
+					return [...modules, ...mdModules];
+				}
+			}
+			return modules;
+		}
+	};
+	const environmentPlugin = (0, _ox_content_vite_plugin.oxContent)(options).flatMap((plugin) => Array.isArray(plugin) ? plugin : [plugin]).find((plugin) => plugin.name === "ox-content:environment");
+	const plugins = [
+		solidTransformPlugin,
+		solidVerifyPlugin,
+		solidEnvironmentPlugin,
+		solidHmrPlugin
+	];
+	if (environmentPlugin) plugins.push(environmentPlugin);
+	return plugins;
+}
+function generateComponentsModule(componentMap) {
+	const imports = [];
+	const exports = [];
+	componentMap.forEach((path, name) => {
+		imports.push(`import ${name} from '${path}';`);
+		exports.push(`  ${name},`);
+	});
+	return `
+${imports.join("\n")}
+
+export const components = {
+${exports.join("\n")}
+};
+
+export default components;
+`;
+}
+//#endregion
+Object.defineProperty(exports, "oxContent", {
+	enumerable: true,
+	get: function() {
+		return _ox_content_vite_plugin.oxContent;
+	}
+});
+exports.oxContentSolid = oxContentSolid;