@ox-content/vite-plugin-svelte 3.0.0-alpha.1 → 3.0.0-alpha.10

package/dist/index.mjs

@@ -1,52 +1,30 @@
 import * as fs from "fs";
 import * as path from "path";
-import { oxContent, oxContent as oxContent$1, transformMarkdown } from "@ox-content/vite-plugin";
+import { applyIslandSsrHtml, discoverDocumentMdxIslands, oxContent, oxContent as oxContent$1, renderHead, renderIslandComponentImports, resolveContentRootPath, resolveMdxForFilePath, transformMarkdown } from "@ox-content/vite-plugin";
 import { compile } from "svelte/compiler";
 //#region src/transform.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";
+const DOCUMENT_PROP_MARKER_PREFIX = "OXCONTENT-DOCUMENT-PROP-";
+const DOCUMENT_PROP_MARKER_SUFFIX = "-PLACEHOLDER";
+const PAYLOAD_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/i;
+const RUST_PAYLOAD_KEYS = /* @__PURE__ */ new Set([
+	"props",
+	"expressions",
+	"spreads"
+]);
 async function transformMarkdownWithSvelte(code, id, options) {
 	const components = options.components;
-	const usedComponents = [];
-	const islands = [];
-	let islandIndex = 0;
 	const { content: markdownContent, frontmatter } = extractFrontmatter(code);
-	const fenceRanges = collectFenceRanges(markdownContent);
-	let processedContent = "";
-	let lastIndex = 0;
-	let match;
-	COMPONENT_REGEX.lastIndex = 0;
-	while ((match = COMPONENT_REGEX.exec(markdownContent)) !== 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)) {
-			processedContent += markdownContent.slice(lastIndex, matchEnd);
-			lastIndex = matchEnd;
-			continue;
-		}
-		if (!usedComponents.includes(componentName)) usedComponents.push(componentName);
-		const props = parseProps(propsString);
-		const islandId = `ox-island-${islandIndex++}`;
-		const islandContent = typeof rawIslandContent === "string" ? rawIslandContent.trim() : void 0;
-		islands.push({
-			name: componentName,
-			props,
-			position: matchStart,
-			id: islandId,
-			content: islandContent
-		});
-		processedContent += markdownContent.slice(lastIndex, matchStart) + createIslandMarker(islandId);
-		lastIndex = matchEnd;
-	}
-	processedContent += markdownContent.slice(lastIndex);
+	const mdx = resolveMdxForFilePath(id, options.mdx);
 	const baseOptions = {
 		srcDir: options.srcDir,
 		outDir: options.outDir,
 		base: options.base,
 		extensions: options.extensions,
+		mdx,
 		ssg: {
 			enabled: false,
 			extension: ".html",
@@ -56,6 +34,7 @@ async function transformMarkdownWithSvelte(code, id, options) {
 			lastUpdated: false,
 			pagination: false,
 			breadcrumbs: false,
+			jsonLd: false,
 			readerChrome: false,
 			localeSwitcher: false,
 			a11y: false,
@@ -94,11 +73,66 @@ async function transformMarkdownWithSvelte(code, id, options) {
 		embeds: options.embeds,
 		i18n: false
 	};
-	const svelteCode = generateSvelteModule(injectIslandMarkers((await transformMarkdown(processedContent, id, baseOptions)).html, islands), usedComponents, islands, frontmatter, options, id);
+	if (mdx) {
+		const documentExpressions = options.mdxDocumentProps ? prepareMdxDocumentExpressions(markdownContent, id) : {
+			content: markdownContent,
+			expressions: []
+		};
+		const transformed = await transformMarkdown(documentExpressions.content, id, baseOptions);
+		const discovered = await discoverDocumentMdxIslands({
+			source: markdownContent,
+			html: transformed.html,
+			components,
+			imports: transformed.imports,
+			documentPath: id,
+			contentRoot: resolveContentRootPath({
+				srcDir: options.srcDir,
+				root: options.root
+			}),
+			srcDir: options.srcDir
+		});
+		if (options.mdxDocumentProps) return compileSvelteResult(generateMdxDocumentPropsSvelteModule(transformed.html, discovered.usedComponents, frontmatter, options, id, discovered.localBindings, documentExpressions.expressions), id, discovered.usedComponents, frontmatter, options.ssr);
+		return compileSvelteResult(generateSvelteModule(options.renderIsland ? await applyIslandSsrHtml(transformed.html, options.renderIsland, id, discovered.usedComponents) : transformed.html, discovered.usedComponents, discovered.usedComponents, frontmatter, options, id, discovered.localBindings), id, discovered.usedComponents, frontmatter, options.ssr);
+	}
+	const usedComponents = [];
+	const islands = [];
+	let islandIndex = 0;
+	const fenceRanges = collectFenceRanges(markdownContent);
+	let processedContent = "";
+	let lastIndex = 0;
+	let match;
+	COMPONENT_REGEX.lastIndex = 0;
+	while ((match = COMPONENT_REGEX.exec(markdownContent)) !== 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)) {
+			processedContent += markdownContent.slice(lastIndex, matchEnd);
+			lastIndex = matchEnd;
+			continue;
+		}
+		if (!usedComponents.includes(componentName)) usedComponents.push(componentName);
+		const props = parseProps(propsString);
+		const islandId = `ox-island-${islandIndex++}`;
+		const islandContent = typeof rawIslandContent === "string" ? rawIslandContent.trim() : void 0;
+		islands.push({
+			name: componentName,
+			props,
+			position: matchStart,
+			id: islandId,
+			content: islandContent
+		});
+		processedContent += markdownContent.slice(lastIndex, matchStart) + createIslandMarker(islandId);
+		lastIndex = matchEnd;
+	}
+	processedContent += markdownContent.slice(lastIndex);
+	return compileSvelteResult(generateSvelteModule(injectIslandMarkers((await transformMarkdown(processedContent, id, baseOptions)).html, islands), usedComponents, islands, frontmatter, options, id), id, usedComponents, frontmatter, options.ssr);
+}
+function compileSvelteResult(svelteCode, id, usedComponents, frontmatter, ssr = false) {
 	return {
 		code: `${compile(svelteCode, {
 			filename: id,
-			generate: "client",
+			generate: ssr ? "server" : "client",
 			runes: true
 		}).js.code}\nexport const frontmatter = ${JSON.stringify(frontmatter)};`,
 		map: null,
@@ -212,20 +246,455 @@ function parseProps(propsString) {
 	}
 	return props;
 }
-function generateSvelteModule(content, usedComponents, islands, frontmatter, options, id) {
-	const mdDir = path.dirname(id);
-	const root = options.root || process.cwd();
-	const imports = 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");
-	if (islands.length === 0) return `
+function prepareMdxDocumentExpressions(content, filePath) {
+	const skipRanges = mergeRanges([
+		...collectFenceRanges(content),
+		...collectInlineCodeRanges(content),
+		...collectMdxEsmLineRanges(content)
+	]);
+	const expressions = [];
+	let output = "";
+	let cursor = 0;
+	let rangeIndex = 0;
+	let inTag = false;
+	let quote = null;
+	while (cursor < content.length) {
+		const range = skipRanges[rangeIndex];
+		if (range && cursor >= range.end) {
+			rangeIndex += 1;
+			continue;
+		}
+		if (range && cursor === range.start) {
+			output += content.slice(range.start, range.end);
+			cursor = range.end;
+			continue;
+		}
+		const char = content[cursor];
+		if (inTag) {
+			output += char;
+			if (quote) {
+				if (char === quote && content[cursor - 1] !== "\\") quote = null;
+			} else if (char === "\"" || char === "'") quote = char;
+			else if (char === ">") inTag = false;
+			cursor += 1;
+			continue;
+		}
+		if (char === "<" && startsHtmlLikeTag(content, cursor)) {
+			inTag = true;
+			output += char;
+			cursor += 1;
+			continue;
+		}
+		if (char === "{" && content[cursor - 1] !== "\\") {
+			const end = findMdxExpressionEnd(content, cursor + 1);
+			if (end !== -1) {
+				const expression = content.slice(cursor + 1, end).trim();
+				const path = parseDocumentPropPath(expression);
+				if (!path) throw new Error(`[ox-content-svelte] Unsupported MDX document prop expression "{${expression}}" in ${filePath}. Only identifiers and dotted property paths are supported.`);
+				const marker = `${DOCUMENT_PROP_MARKER_PREFIX}${expressions.length}${DOCUMENT_PROP_MARKER_SUFFIX}`;
+				expressions.push({
+					marker,
+					expression,
+					path
+				});
+				output += marker;
+				cursor = end + 1;
+				continue;
+			}
+		}
+		output += char;
+		cursor += 1;
+	}
+	return {
+		content: output,
+		expressions
+	};
+}
+function collectInlineCodeRanges(content) {
+	const ranges = [];
+	const fenceRanges = collectFenceRanges(content);
+	let lineStart = 0;
+	while (lineStart < content.length) {
+		const lineEnd = content.indexOf("\n", lineStart);
+		const end = lineEnd === -1 ? content.length : lineEnd;
+		if (!isInRanges(lineStart, end, fenceRanges)) {
+			let cursor = lineStart;
+			while (cursor < end) {
+				const marker = matchBacktickRun(content, cursor);
+				if (!marker) {
+					cursor += 1;
+					continue;
+				}
+				const close = content.indexOf(marker, cursor + marker.length);
+				if (close === -1 || close >= end) {
+					cursor += marker.length;
+					continue;
+				}
+				ranges.push({
+					start: cursor,
+					end: close + marker.length
+				});
+				cursor = close + marker.length;
+			}
+		}
+		lineStart = lineEnd === -1 ? content.length : lineEnd + 1;
+	}
+	return ranges;
+}
+function collectMdxEsmLineRanges(content) {
+	const ranges = [];
+	const fenceRanges = collectFenceRanges(content);
+	let lineStart = 0;
+	while (lineStart < content.length) {
+		const lineEnd = content.indexOf("\n", lineStart);
+		const end = lineEnd === -1 ? content.length : lineEnd + 1;
+		const contentEnd = lineEnd === -1 ? content.length : lineEnd;
+		if (!isInRanges(lineStart, contentEnd, fenceRanges)) {
+			const line = content.slice(lineStart, contentEnd).trimStart();
+			if (line.startsWith("import ") || line.startsWith("export ")) ranges.push({
+				start: lineStart,
+				end
+			});
+		}
+		lineStart = lineEnd === -1 ? content.length : lineEnd + 1;
+	}
+	return ranges;
+}
+function mergeRanges(ranges) {
+	const sorted = ranges.filter((range) => range.end > range.start).sort((left, right) => left.start - right.start || left.end - right.end);
+	const merged = [];
+	for (const range of sorted) {
+		const previous = merged.at(-1);
+		if (previous && range.start <= previous.end) previous.end = Math.max(previous.end, range.end);
+		else merged.push({ ...range });
+	}
+	return merged;
+}
+function matchBacktickRun(content, index) {
+	if (content[index] !== "`") return null;
+	let end = index + 1;
+	while (content[end] === "`") end += 1;
+	return content.slice(index, end);
+}
+function startsHtmlLikeTag(content, index) {
+	const next = content[index + 1];
+	return next === "/" || next === "!" || next === "?" || /[A-Za-z]/.test(next ?? "");
+}
+function findMdxExpressionEnd(content, start) {
+	let depth = 1;
+	let quote = null;
+	let escaped = false;
+	for (let index = start; index < content.length; index += 1) {
+		const char = content[index];
+		if (quote) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") {
+			depth += 1;
+			continue;
+		}
+		if (char === "}") {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function parseDocumentPropPath(expression) {
+	if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*$/.test(expression) || RESERVED_DOCUMENT_PROP_WORDS.has(expression)) return null;
+	return expression.split(".");
+}
+const RESERVED_DOCUMENT_PROP_WORDS = /* @__PURE__ */ new Set([
+	"false",
+	"Infinity",
+	"NaN",
+	"null",
+	"this",
+	"true",
+	"undefined"
+]);
+function generateMdxDocumentPropsSvelteModule(html, usedComponents, frontmatter, options, id, localBindings, documentExpressions) {
+	const filePathLiteral = JSON.stringify(id);
+	const imports = renderIslandComponentImports(usedComponents, {
+		globalComponents: options.components,
+		localBindings,
+		documentPath: id,
+		root: options.root
+	});
+	const template = renderMdxDocumentTemplate(html, usedComponents, id, documentExpressions);
+	return `
+<script>
+  ${imports}
+
+  const frontmatter = ${JSON.stringify(frontmatter)};
+  export { frontmatter };
+
+  let __ox_mdx_props = $props();
+
+  function __ox_mdx_document_prop(props, path, expression) {
+    const propName = path.join(".");
+    let value = props;
+    for (const segment of path) {
+      if (
+        value == null ||
+        (typeof value !== "object" && typeof value !== "function") ||
+        !(segment in Object(value))
+      ) {
+        throw new Error('[ox-content-svelte] Missing MDX document prop "' + propName + '" in ' + ${filePathLiteral} + ' for expression {' + expression + '}.');
+      }
+      value = value[segment];
+    }
+    if (value === undefined) {
+      throw new Error('[ox-content-svelte] Missing MDX document prop "' + propName + '" in ' + ${filePathLiteral} + ' for expression {' + expression + '}.');
+    }
+    return value;
+  }
+<\/script>
+
+<div class="ox-content">${template}</div>
+
+<style>
+  .ox-content {
+    line-height: 1.6;
+  }
+</style>
+`;
+}
+function renderMdxDocumentTemplate(html, usedComponents, filePath, documentExpressions) {
+	return renderHtmlRange({
+		html,
+		filePath,
+		usedComponents: new Set(usedComponents),
+		expressionsByMarker: new Map(documentExpressions.map((expression) => [expression.marker, expression])),
+		islandRanges: findMdxIslandRanges(html)
+	}, 0, html.length);
+}
+function renderHtmlRange(context, start, end) {
+	let output = "";
+	let cursor = start;
+	while (cursor < end) {
+		const island = findNextIslandRange(context, cursor, end);
+		if (!island) {
+			output += renderRawHtmlTemplate(context.html.slice(cursor, end), context.expressionsByMarker);
+			break;
+		}
+		output += renderRawHtmlTemplate(context.html.slice(cursor, island.openStart), context.expressionsByMarker);
+		output += renderMdxIslandTemplate(context, island);
+		cursor = island.closeEnd;
+	}
+	return output;
+}
+function findNextIslandRange(context, cursor, end) {
+	for (const island of context.islandRanges) {
+		if (island.openStart < cursor || island.closeEnd > end) continue;
+		if (context.usedComponents.has(island.name)) return island;
+	}
+	return null;
+}
+function renderRawHtmlTemplate(html, expressionsByMarker) {
+	if (!html) return "";
+	let output = "";
+	let cursor = 0;
+	while (cursor < html.length) {
+		const next = findNextDocumentExpressionMarker(html, cursor, expressionsByMarker);
+		if (!next) {
+			output += renderRawHtmlBlock(html.slice(cursor));
+			break;
+		}
+		output += renderRawHtmlBlock(html.slice(cursor, next.index));
+		output += renderDocumentExpression(next.expression);
+		cursor = next.index + next.expression.marker.length;
+	}
+	return output;
+}
+function findNextDocumentExpressionMarker(html, start, expressionsByMarker) {
+	let nextIndex = -1;
+	let nextExpression;
+	for (const expression of expressionsByMarker.values()) {
+		const index = html.indexOf(expression.marker, start);
+		if (index !== -1 && (nextIndex === -1 || index < nextIndex)) {
+			nextIndex = index;
+			nextExpression = expression;
+		}
+	}
+	return nextExpression ? {
+		index: nextIndex,
+		expression: nextExpression
+	} : null;
+}
+function renderRawHtmlBlock(html) {
+	return html ? `{@html ${JSON.stringify(html).replaceAll("<\/script", "<\\/script")}}` : "";
+}
+function renderDocumentExpression(expression) {
+	return `{${documentPropResolverExpression(expression.path, expression.expression)}}`;
+}
+function renderMdxIslandTemplate(context, island) {
+	assertSvelteComponentName(island.name, context.filePath);
+	const attrs = renderMdxIslandAttributes(readMdxIslandPayload(island), context.filePath);
+	const children = renderHtmlRange(context, island.contentStart, island.closeStart);
+	return children ? `<${island.name}${attrs}>${children}</${island.name}>` : `<${island.name}${attrs} />`;
+}
+function renderMdxIslandAttributes(payload, filePath) {
+	const attrs = [];
+	for (const spread of payload.spreads) {
+		const expression = spread.trim().startsWith("...") ? spread.trim().slice(3).trim() : spread.trim();
+		const path = parseDocumentPropPath(expression);
+		if (!path) throw new Error(`[ox-content-svelte] Unsupported MDX document prop spread "{${spread}}" in ${filePath}. Only identifiers and dotted property paths are supported.`);
+		attrs.push(`{...${documentPropResolverExpression(path, expression)}}`);
+	}
+	for (const [name, value] of Object.entries(payload.props)) {
+		assertSvelteAttributeName(name, filePath);
+		attrs.push(`${name}={${renderSvelteLiteral(value)}}`);
+	}
+	for (const [name, expression] of Object.entries(payload.expressions)) {
+		assertSvelteAttributeName(name, filePath);
+		const path = parseDocumentPropPath(expression.trim());
+		if (!path) throw new Error(`[ox-content-svelte] Unsupported MDX document prop expression "{${expression}}" for prop "${name}" in ${filePath}. Only identifiers and dotted property paths are supported.`);
+		attrs.push(`${name}={${documentPropResolverExpression(path, expression.trim())}}`);
+	}
+	return attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+}
+function documentPropResolverExpression(path, expression) {
+	return `__ox_mdx_document_prop(__ox_mdx_props, ${JSON.stringify(path)}, ${JSON.stringify(expression)})`;
+}
+function renderSvelteLiteral(value) {
+	const literal = JSON.stringify(value);
+	return literal === void 0 ? "undefined" : literal.replaceAll("<\/script", "<\\/script");
+}
+function findMdxIslandRanges(html) {
+	const ranges = [];
+	const openRe = /<(div|span)\b([^>]*\bdata-ox-island="([^"]+)"[^>]*)>/gi;
+	let match;
+	while ((match = openRe.exec(html)) !== null) {
+		const tag = match[1];
+		const name = decodeHtmlAttr(match[3] ?? "");
+		if (!name) continue;
+		const openStart = match.index;
+		const openEnd = match.index + match[0].length;
+		const closeStart = findMatchingClose(html, openEnd, tag);
+		const closeEnd = closeStart < html.length ? closeStart + tag.length + 3 : html.length;
+		const script = html.slice(openEnd, closeStart).match(PAYLOAD_SCRIPT)?.[0];
+		ranges.push({
+			name,
+			tag,
+			openStart,
+			openEnd,
+			innerStart: openEnd,
+			contentStart: openEnd + (script?.length ?? 0),
+			closeStart,
+			closeEnd,
+			propsAttr: matchAttr(match[2] ?? "", "data-ox-props"),
+			script
+		});
+	}
+	return ranges.sort((left, right) => left.openStart - right.openStart);
+}
+function findMatchingClose(html, from, tag) {
+	const openNeedle = `<${tag}`;
+	const closeNeedle = `</${tag}>`;
+	let depth = 1;
+	let cursor = from;
+	while (cursor < html.length) {
+		const nextOpen = indexOfTagOpen(html, openNeedle, cursor);
+		const nextClose = html.indexOf(closeNeedle, cursor);
+		if (nextClose === -1) return html.length;
+		if (nextOpen !== -1 && nextOpen < nextClose) {
+			depth += 1;
+			cursor = nextOpen + openNeedle.length;
+		} else {
+			depth -= 1;
+			if (depth === 0) return nextClose;
+			cursor = nextClose + closeNeedle.length;
+		}
+	}
+	return html.length;
+}
+function indexOfTagOpen(html, openNeedle, from) {
+	let cursor = from;
+	while (cursor < html.length) {
+		const index = html.indexOf(openNeedle, cursor);
+		if (index === -1) return -1;
+		const next = html[index + openNeedle.length];
+		if (next === " " || next === ">" || next === "	" || next === "\n" || next === "/") return index;
+		cursor = index + openNeedle.length;
+	}
+	return -1;
+}
+function matchAttr(attrs, name) {
+	const match = new RegExp(`\\b${name}="([^"]*)"`, "i").exec(attrs);
+	return match?.[1] === void 0 ? void 0 : decodeHtmlAttr(match[1]);
+}
+function readMdxIslandPayload(island) {
+	const fromAttr = island.propsAttr ? tryParseJson(island.propsAttr) : void 0;
+	const fromScript = island.script ? tryParseJson(island.script.match(/<script type="application\/json">([\s\S]*?)<\/script>/i)?.[1] ?? "") : void 0;
+	return normalizeMdxIslandPayload(fromAttr ?? fromScript ?? {});
+}
+function normalizeMdxIslandPayload(parsed) {
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {
+		props: {},
+		expressions: {},
+		spreads: []
+	};
+	const record = parsed;
+	const keys = Object.keys(record);
+	if (keys.length > 0 && keys.every((key) => RUST_PAYLOAD_KEYS.has(key))) return {
+		props: toRecord(record.props),
+		expressions: toStringRecord(record.expressions),
+		spreads: toStringArray(record.spreads)
+	};
+	return {
+		props: record,
+		expressions: {},
+		spreads: []
+	};
+}
+function toRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function toStringRecord(value) {
+	const record = toRecord(value);
+	const output = {};
+	for (const [key, entry] of Object.entries(record)) if (typeof entry === "string") output[key] = entry;
+	return output;
+}
+function toStringArray(value) {
+	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function tryParseJson(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function decodeHtmlAttr(value) {
+	return value.replaceAll("&quot;", "\"").replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+}
+function assertSvelteComponentName(name, filePath) {
+	if (!/^[A-Z][A-Za-z0-9_$]*$/.test(name)) throw new Error(`[ox-content-svelte] Unsupported MDX component name "${name}" in ${filePath} for mdxDocumentProps. Only simple Svelte component identifiers are supported.`);
+}
+function assertSvelteAttributeName(name, filePath) {
+	if (!/^[A-Za-z_$][\w$-]*$/.test(name)) throw new Error(`[ox-content-svelte] Unsupported MDX component prop name "${name}" in ${filePath}.`);
+}
+function generateSvelteModule(content, usedComponents, _islands, frontmatter, options, id, localBindings) {
+	const rawHtmlLiteral = JSON.stringify(content).replaceAll("<\/script", "<\\/script");
+	const imports = renderIslandComponentImports(usedComponents, {
+		globalComponents: options.components,
+		localBindings,
+		documentPath: id,
+		root: options.root
+	});
+	if (usedComponents.length === 0) return `
 <script>
   const frontmatter = ${JSON.stringify(frontmatter)};
-  const rawHtml = ${JSON.stringify(content)};
+  const rawHtml = ${rawHtmlLiteral};
 
   export { frontmatter };
 <\/script>
@@ -244,11 +713,11 @@ function generateSvelteModule(content, usedComponents, islands, frontmatter, opt
 	return `
 <script>
   import { createRawSnippet, onMount, mount, unmount } from 'svelte';
-  import { initIslands } from '@ox-content/islands';
+  import { initIslands, readIslandSlotHtml } from '@ox-content/islands';
   ${imports}
 
   const frontmatter = ${JSON.stringify(frontmatter)};
-  const rawHtml = ${JSON.stringify(content)};
+  const rawHtml = ${rawHtmlLiteral};
   const components = {
 ${componentMap}
   };
@@ -265,7 +734,7 @@ ${componentMap}
       const Component = components[componentName];
       if (!Component) return;
 
-      const islandContent = element.dataset.oxContent || element.innerHTML;
+      const islandContent = readIslandSlotHtml(element);
       const componentProps = { ...props };
       if (islandContent) {
         componentProps.children = createRawSnippet(() => ({
@@ -365,6 +834,10 @@ function resolveSingleEmbedOptions(options) {
 /**
 * Creates the Ox Content Svelte integration plugin.
 *
+* Forwards core options such as `ssg`, `redirects`, `feeds`, and `siteMaps`.
+* The Svelte Markdown transform and environments replace the generic core
+* transform/`markdown` environment; other build plugins are kept.
+*
 * @example
 * ```ts
 * // vite.config.ts
@@ -401,12 +874,14 @@ function oxContentSvelte(options = {}) {
 				componentMap = new Map(Object.entries(resolvedComponents));
 			}
 		},
-		async transform(code, id) {
+		async transform(code, id, transformOptions) {
 			if (!isMarkdownFilePath(id, resolved.extensions)) return null;
 			const result = await transformMarkdownWithSvelte(code, id, {
 				...resolved,
 				components: Object.fromEntries(componentMap),
-				root: config.root
+				root: config.root,
+				renderIsland: options.renderIsland,
+				ssr: transformOptions?.ssr
 			});
 			return {
 				code: result.code,
@@ -459,14 +934,13 @@ function oxContentSvelte(options = {}) {
 			return modules;
 		}
 	};
-	const environmentPlugin = oxContent$1(options).flatMap((plugin) => Array.isArray(plugin) ? plugin : [plugin]).find((plugin) => plugin.name === "ox-content:environment");
-	const plugins = [
+	const replacedCorePluginNames = /* @__PURE__ */ new Set(["ox-content", "ox-content:environment"]);
+	return [
 		svelteTransformPlugin,
 		svelteEnvironmentPlugin,
-		svelteHmrPlugin
+		svelteHmrPlugin,
+		...oxContent$1(options).flatMap((plugin) => Array.isArray(plugin) ? plugin : [plugin]).filter((plugin) => !replacedCorePluginNames.has(plugin.name))
 	];
-	if (environmentPlugin) plugins.push(environmentPlugin);
-	return plugins;
 }
 function resolveSvelteOptions(options) {
 	return {
@@ -481,7 +955,9 @@ function resolveSvelteOptions(options) {
 		tocMaxDepth: options.tocMaxDepth ?? 3,
 		codeAnnotations: resolveCodeAnnotationsOptions(options.codeAnnotations),
 		runes: options.runes ?? true,
-		embeds: resolveBuiltinEmbedOptions(options.embeds)
+		embeds: resolveBuiltinEmbedOptions(options.embeds),
+		mdx: options.mdx,
+		mdxDocumentProps: options.mdxDocumentProps ?? false
 	};
 }
 function resolveCodeAnnotationsOptions(options) {
@@ -564,6 +1040,6 @@ function toPascalCase(str) {
 	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
 }
 //#endregion
-export { oxContent, oxContentSvelte };
+export { oxContent, oxContentSvelte, renderHead };
 
 //# sourceMappingURL=index.mjs.map