@ox-content/vite-plugin-svelte 3.1.2 → 3.1.4

package/dist/index.d.mts

@@ -1,4 +1,6 @@
-import { HeadInput, OxContentOptions, RenderIslandFn, RenderedHead, oxContent, renderHead } from "@ox-content/vite-plugin";
+import { C as SvelteHtmlHostInitIslands, _ as SvelteHtmlHostClientRuntimeLoader, a as createSvelteHtmlHostDomRenderer, b as SvelteHtmlHostDomRuntime, c as InitSvelteHtmlHostInput, d as SvelteHtmlHostClientDiagnosticCode, f as SvelteHtmlHostClientError, g as SvelteHtmlHostClientRenderer, h as SvelteHtmlHostClientModules, i as SvelteHtmlHostDomRenderer, l as SvelteHtmlHostClientComponentValue, m as SvelteHtmlHostClientModuleValue, n as initSvelteHtmlHost, o as loadSvelteHtmlHostDomRuntime, p as SvelteHtmlHostClientModuleLoader, r as readSvelteHtmlHostSlot, s as CreateSvelteHtmlHostLazyHydrateInput, t as createSvelteHtmlHostLazyHydrate, u as SvelteHtmlHostClientContext, v as SvelteHtmlHostDomMode, w as SvelteHtmlHostModuleIdResolver, x as SvelteHtmlHostExportNameResolver, y as SvelteHtmlHostDomRendererInput } from "./html-host-client.mjs";
+import { CreateHtmlHostHydrateInput, CreateHtmlHostIslandRegistryInput, HeadInput, HtmlHostClientModule, HtmlHostCollectionDocument, HtmlHostCollectionDocumentsOptions, HtmlHostComponentRenderer, HtmlHostDiagnostic, HtmlHostDiagnosticCode, HtmlHostHydrateRenderer, HtmlHostIslandDocument, HtmlHostIslandEntry, HtmlHostIslandRegistry, HtmlHostIslandRegistryContext, HtmlHostModule, HtmlHostServerModuleLoader, MdxImport, MdxImport as MdxImport$1, MdxImportSpecifier, MdxImportSpecifierKind, OxContentOptions, RenderHtmlHostInput, RenderIslandFn, RenderedHead, ResolvedHtmlHostIslandRegistry, oxContent, renderHead, toHtmlHostClientModuleId } from "@ox-content/vite-plugin";
+import { CompileOptions, Warning } from "svelte/compiler";
 import { PluginOption } from "vite";
 //#region src/types.d.ts
 /**
@@ -31,6 +33,25 @@ type ComponentsMap = Record<string, string>;
  * `configResolved`.
  */
 type ComponentsOption = ComponentsMap | string | string[];
+type SvelteCompilerWarning = Warning;
+interface SvelteCompilerOptions extends Omit<CompileOptions, "filename" | "generate" | "runes"> {
+  filename: string;
+  generate: "client" | "server";
+  runes: boolean;
+}
+interface SvelteCompilerJsOutput {
+  code: string;
+  map?: unknown;
+}
+interface SvelteCompilerObjectResult {
+  js: SvelteCompilerJsOutput | string;
+  warnings?: readonly SvelteCompilerWarning[];
+}
+type SvelteCompilerResult = SvelteCompilerObjectResult | string;
+type SvelteCompileFunction = (source: string, options: SvelteCompilerOptions) => SvelteCompilerResult | Promise<SvelteCompilerResult>;
+type SvelteCompilerOption = SvelteCompileFunction | {
+  compile: SvelteCompileFunction;
+};
 /**
  * Opt-in build-time props for MDX documents imported as Svelte components.
  *
@@ -90,6 +111,16 @@ interface SvelteIntegrationOptions extends OxContentOptions {
    * @default true
    */
   runes?: boolean;
+  /**
+   * Compiler used for Markdown/MDX-generated Svelte modules.
+   *
+   * The default is `svelte/compiler`. Pass the same compiler used by an
+   * alternative Svelte Vite integration to keep ordinary `.svelte` files and
+   * Ox Content-generated document modules on the same compiler implementation.
+   *
+   * @default `svelte/compiler`
+   */
+  compiler?: SvelteCompilerOption;
   /**
    * Built-in static embeds rendered during Markdown transformation.
    *
@@ -206,6 +237,7 @@ interface ResolvedSvelteOptions {
   codeAnnotations: ResolvedCodeAnnotationsOptions;
   components: ComponentsMap;
   runes: boolean;
+  compiler?: SvelteCompilerOption;
   embeds: ResolvedBuiltinEmbedOptions;
   mdx?: boolean;
   root?: string;
@@ -215,7 +247,8 @@ interface ResolvedSvelteOptions {
 }
 interface SvelteTransformResult {
   code: string;
-  map: null;
+  map: unknown;
+  warnings: SvelteCompilerWarning[];
   usedComponents: string[];
   frontmatter: Record<string, unknown>;
 }
@@ -227,6 +260,78 @@ interface ComponentIsland {
   content?: string;
 }
 //#endregion
+//#region src/html-host.d.ts
+interface SvelteHtmlHostModule extends HtmlHostModule {}
+interface SvelteHtmlHostClientModule extends HtmlHostClientModule {}
+type SvelteHtmlHostDiagnosticCode = HtmlHostDiagnosticCode;
+interface SvelteHtmlHostDiagnostic extends HtmlHostDiagnostic {}
+type SvelteServerModuleLoader = HtmlHostServerModuleLoader;
+type SvelteHtmlComponentRenderer = HtmlHostComponentRenderer;
+type SvelteClientModuleResolver = (module: SvelteHtmlHostModule, context: {
+  documentPath: string;
+}) => string | undefined;
+interface RenderSvelteHtmlHostInput extends Omit<RenderHtmlHostInput, "components" | "frameworkName" | "adapter" | "renderComponent" | "resolveClientModule"> {
+  components?: ComponentsMap;
+  renderComponent?: SvelteHtmlComponentRenderer;
+  resolveClientModule?: SvelteClientModuleResolver;
+}
+interface RenderSvelteHtmlHostResult {
+  html: string;
+  modules: SvelteHtmlHostModule[];
+  clientModules: SvelteHtmlHostClientModule[];
+  diagnostics: SvelteHtmlHostDiagnostic[];
+}
+type SvelteHostHydrateRenderer = HtmlHostHydrateRenderer;
+type CreateSvelteHtmlHostHydrateInput = CreateHtmlHostHydrateInput;
+declare function renderSvelteHtmlHost(input: RenderSvelteHtmlHostInput): Promise<RenderSvelteHtmlHostResult>;
+declare function createSvelteHtmlHostHydrate(input: CreateSvelteHtmlHostHydrateInput): (element: HTMLElement, props: Record<string, unknown>) => void | (() => void);
+//#endregion
+//#region src/html-host-renderer.d.ts
+type SvelteHtmlHostRendererDiagnosticPolicy = "throw" | "collect";
+interface CreateSvelteHtmlHostRendererInput {
+  root?: string;
+  srcDir?: string;
+  contentRoot?: string;
+  components?: ComponentsMap;
+  loadModule: SvelteServerModuleLoader;
+  renderComponent?: SvelteHtmlComponentRenderer;
+  resolveClientModule?: SvelteClientModuleResolver;
+  diagnostics?: SvelteHtmlHostRendererDiagnosticPolicy;
+}
+interface SvelteHtmlHostRendererContext {
+  documentPath: string;
+  imports?: readonly MdxImport$1[];
+  root?: string;
+  srcDir?: string;
+  contentRoot?: string;
+  components?: ComponentsMap;
+  renderComponent?: SvelteHtmlComponentRenderer;
+  resolveClientModule?: SvelteClientModuleResolver;
+}
+type SvelteHtmlHostRenderer = (html: string, context: SvelteHtmlHostRendererContext) => Promise<RenderSvelteHtmlHostResult>;
+declare class SvelteHtmlHostRenderError extends Error {
+  readonly diagnostics: SvelteHtmlHostDiagnostic[];
+  constructor(diagnostics: readonly SvelteHtmlHostDiagnostic[]);
+}
+declare function createSvelteHtmlHostRenderer(input: CreateSvelteHtmlHostRendererInput): SvelteHtmlHostRenderer;
+//#endregion
+//#region src/html-host-registry.d.ts
+declare const SVELTE_HTML_HOST_MODULES_VIRTUAL_ID = "virtual:ox-content-svelte/html-host/modules";
+type SvelteHtmlHostIslandDocument = HtmlHostIslandDocument;
+type SvelteHtmlHostIslandEntry = HtmlHostIslandEntry;
+type SvelteHtmlHostIslandRegistryContext = HtmlHostIslandRegistryContext;
+type CreateSvelteHtmlHostIslandRegistryInput = CreateHtmlHostIslandRegistryInput;
+type ResolvedSvelteHtmlHostIslandRegistry = ResolvedHtmlHostIslandRegistry;
+type SvelteHtmlHostIslandRegistry = HtmlHostIslandRegistry;
+declare function createSvelteHtmlHostIslandRegistry(input?: CreateSvelteHtmlHostIslandRegistryInput): SvelteHtmlHostIslandRegistry;
+declare function resolveSvelteHtmlHostIslandRegistry(input: CreateSvelteHtmlHostIslandRegistryInput, context: SvelteHtmlHostIslandRegistryContext, resolvedComponents?: Record<string, string>): Promise<ResolvedSvelteHtmlHostIslandRegistry>;
+//#endregion
+//#region src/html-host-collection-documents.d.ts
+type SvelteHtmlHostCollectionDocument = HtmlHostCollectionDocument;
+type SvelteHtmlHostCollectionDocumentsOptions = HtmlHostCollectionDocumentsOptions;
+declare function createSvelteHtmlHostCollectionDocuments(input?: SvelteHtmlHostCollectionDocumentsOptions): (context: HtmlHostIslandRegistryContext) => Promise<readonly SvelteHtmlHostCollectionDocument[]>;
+declare function resolveSvelteHtmlHostCollectionDocuments(input: SvelteHtmlHostCollectionDocumentsOptions, context: HtmlHostIslandRegistryContext): Promise<readonly SvelteHtmlHostCollectionDocument[]>;
+//#endregion
 //#region src/index.d.ts
 /**
  * Creates the Ox Content Svelte integration plugin.
@@ -257,5 +362,5 @@ interface ComponentIsland {
  */
 declare function oxContentSvelte(options?: SvelteIntegrationOptions): PluginOption[];
 //#endregion
-export { type BuiltinEmbedOptions, type ComponentIsland, type ComponentsMap, type ComponentsOption, type GitHubEmbedOptions, type HeadInput, type MdxDocumentPropsOption, type OpenGraphEmbedOptions, type RenderedHead, type ResolvedBuiltinEmbedOptions, type ResolvedSvelteOptions, type SvelteIntegrationOptions, type SvelteTransformResult, oxContent, oxContentSvelte, renderHead };
+export { type BuiltinEmbedOptions, type ComponentIsland, type ComponentsMap, type ComponentsOption, type CreateSvelteHtmlHostHydrateInput, type CreateSvelteHtmlHostIslandRegistryInput, type CreateSvelteHtmlHostLazyHydrateInput, type CreateSvelteHtmlHostRendererInput, type GitHubEmbedOptions, type HeadInput, type InitSvelteHtmlHostInput, type MdxDocumentPropsOption, type MdxImport, type MdxImportSpecifier, type MdxImportSpecifierKind, type OpenGraphEmbedOptions, type RenderSvelteHtmlHostInput, type RenderSvelteHtmlHostResult, type RenderedHead, type ResolvedBuiltinEmbedOptions, type ResolvedSvelteHtmlHostIslandRegistry, type ResolvedSvelteOptions, SVELTE_HTML_HOST_MODULES_VIRTUAL_ID, type SvelteClientModuleResolver, type SvelteCompileFunction, type SvelteCompilerOption, type SvelteCompilerOptions, type SvelteCompilerResult, type SvelteCompilerWarning, type SvelteHostHydrateRenderer, type SvelteHtmlComponentRenderer, type SvelteHtmlHostClientComponentValue, type SvelteHtmlHostClientContext, type SvelteHtmlHostClientDiagnosticCode, type SvelteHtmlHostClientError, type SvelteHtmlHostClientModule, type SvelteHtmlHostClientModuleLoader, type SvelteHtmlHostClientModuleValue, type SvelteHtmlHostClientModules, type SvelteHtmlHostClientRenderer, type SvelteHtmlHostClientRuntimeLoader, type SvelteHtmlHostCollectionDocument, type SvelteHtmlHostCollectionDocumentsOptions, type SvelteHtmlHostDiagnostic, type SvelteHtmlHostDiagnosticCode, type SvelteHtmlHostDomMode, type SvelteHtmlHostDomRenderer, type SvelteHtmlHostDomRendererInput, type SvelteHtmlHostDomRuntime, type SvelteHtmlHostExportNameResolver, type SvelteHtmlHostInitIslands, type SvelteHtmlHostIslandDocument, type SvelteHtmlHostIslandEntry, type SvelteHtmlHostIslandRegistry, type SvelteHtmlHostIslandRegistryContext, type SvelteHtmlHostModule, type SvelteHtmlHostModuleIdResolver, SvelteHtmlHostRenderError, type SvelteHtmlHostRenderer, type SvelteHtmlHostRendererContext, type SvelteHtmlHostRendererDiagnosticPolicy, type SvelteIntegrationOptions, type SvelteServerModuleLoader, type SvelteTransformResult, createSvelteHtmlHostCollectionDocuments, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostHydrate, createSvelteHtmlHostIslandRegistry, createSvelteHtmlHostLazyHydrate, createSvelteHtmlHostRenderer, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, oxContent, oxContentSvelte, readSvelteHtmlHostSlot, renderHead, renderSvelteHtmlHost, resolveSvelteHtmlHostCollectionDocuments, resolveSvelteHtmlHostIslandRegistry, toHtmlHostClientModuleId as toSvelteHtmlHostClientModuleId };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/index.ts"],"mappings":";;;;;;;;;UAQiB;;;;;;EAMf;;UAGe;EACf;EACA;;;;;KAMU,gBAAgB;;;;;;;;KAShB,mBAAmB;;;;;;;;KASnB;;;;;;;;UASK,iCAAiC;;;;;;;;EAQhD;;;;;;;;;;;;;;;;;;EAmBA,aAAa;;;;;;;;EASb,4BAA4B;;;;;;;;;EAU5B;;;;;;;;;EAUA,SAAS;;;;;;;EAQT,eAAe;;;;;;;;;;;;EAaf,mBAAmB;;;;;UAMJ;;;;;EAKf;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;UAMe;;;;;EAKf;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;UAMe;;;;;EAKf,mBAAmB;;;;;EAMnB,sBAAsB;;UAGP;EACf,QAAQ;EACR,WAAW;;UAGI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,iBAAiB;EACjB,YAAY;EACZ;EACA,QAAQ;EACR;EACA;EACA,eAAe;EACf;EACA;;UAGe;EACf;EACA;EACA;EACA,aAAa;;UAGE;EACf;EACA,OAAO;EACP;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBC3Jc,gBAAgB,UAAS,2BAAgC"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/html-host.ts","../src/html-host-renderer.ts","../src/html-host-registry.ts","../src/html-host-collection-documents.ts","../src/index.ts"],"mappings":";;;;;;;;;;;UASiB;;;;;;EAMf;;UAGe;EACf;EACA;;;;;KAMU,gBAAgB;;;;;;;;KAShB,mBAAmB;KAEnB,wBAAwB;UAEnB,8BAA8B,KAC7C;EAGA;EACA;EACA;;UAGe;EACf;EACA;;UAGe;EACf,IAAI;EACJ,oBAAoB;;KAGV,uBAAuB;KAEvB,yBACV,gBACA,SAAS,0BACN,uBAAuB,QAAQ;KAExB,uBACR;EAEE,SAAS;;;;;;;;;KAUH;;;;;;;;UASK,iCAAiC;;;;;;;;EAQhD;;;;;;;;;;;;;;;;;;EAmBA,aAAa;;;;;;;;EASb,4BAA4B;;;;;;;;;EAU5B;;;;;;;;;;EAWA,WAAW;;;;;;;;;EAUX,SAAS;;;;;;;EAQT,eAAe;;;;;;;;;;;;EAaf,mBAAmB;;;;;UAMJ;;;;;EAKf;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;UAMe;;;;;EAKf;;;;;EAMA;;;;;EAMA;;;;;EAMA;;;;;UAMe;;;;;EAKf,mBAAmB;;;;;EAMnB,sBAAsB;;UAGP;EACf,QAAQ;EACR,WAAW;;UAGI;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,iBAAiB;EACjB,YAAY;EACZ;EACA,WAAW;EACX,QAAQ;EACR;EACA;EACA,eAAe;EACf;EACA;;UAGe;EACf;EACA;EACA,UAAU;EACV;EACA,aAAa;;UAGE;EACf;EACA,OAAO;EACP;EACA;EACA;;;;UC3Re,6BAA6B;UAC7B,mCAAmC;KACxC,+BAA+B;UAC1B,iCAAiC;KACtC,2BAA2B;KAC3B,8BAA8B;KAC9B,8BACV,QAAQ,sBACR;EAAW;;UAGI,kCAAkC,KACjD;EAGA,aAAa;EACb,kBAAkB;EAClB,sBAAsB;;UAGP;EACf;EACA,SAAS;EACT,eAAe;EACf,aAAa;;KAGH,4BAA4B;KAC5B,mCAAmC;iBAEzB,qBACpB,OAAO,4BACN,QAAQ;iBAUK,4BACd,OAAO,oCACL,SAAS,aAAa,OAAO;;;KC/CrB;UAEK;EACf;EACA;EACA;EACA,aAAa;EACb,YAAY;EACZ,kBAAkB;EAClB,sBAAsB;EACtB,cAAc;;UAGC;EACf;EACA,mBAAmB;EACnB;EACA;EACA;EACA,aAAa;EACb,kBAAkB;EAClB,sBAAsB;;KAGZ,0BACV,cACA,SAAS,kCACN,QAAQ;cAEA,kCAAkC;WACpC,aAAa;EAEtB,YAAY,sBAAsB;;iBAOpB,6BACd,OAAO,oCACN;;;cCxCU;KAED,+BAA+B;KAC/B,4BAA4B;KAC5B,sCAAsC;KACtC,0CAA0C;KAC1C,uCAAuC;KACvC,+BAA+B;iBAE3B,mCACd,QAAO,0CACN;iBAQa,oCACd,OAAO,yCACP,SAAS,qCACT,qBAAqB,yBACpB,QAAQ;;;KC9BC,mCAAmC;KACnC,2CAA2C;iBAEvC,wCACd,QAAO,4CAEP,SAAS,kCACN,iBAAiB;iBAIN,yCACd,OAAO,0CACP,SAAS,gCACR,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCqJJ,gBAAgB,UAAS,2BAAgC"}

package/dist/index.mjs

@@ -1,7 +1,8 @@
+import { a as loadSvelteHtmlHostDomRuntime, i as createSvelteHtmlHostDomRenderer, n as initSvelteHtmlHost, r as readSvelteHtmlHostSlot, t as createSvelteHtmlHostLazyHydrate } from "./html-host-client2.mjs";
+import { applyIslandSsrHtml, createHtmlHostHydrate, createHtmlHostIslandRegistry, discoverDocumentMdxIslands, formatHtmlHostDiagnostics, oxContent, oxContent as oxContent$1, renderHead, renderHtmlHost, renderIslandComponentImports, resolveContentRootPath, resolveHtmlHostCollectionDocuments, resolveHtmlHostIslandRegistry, resolveMdxForFilePath, toHtmlHostClientModuleId, toHtmlHostClientModuleId as toHtmlHostClientModuleId$1, transformMarkdown } from "@ox-content/vite-plugin";
+import { compile } from "svelte/compiler";
 import * as fs from "fs";
 import * as path from "path";
-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;
@@ -91,8 +92,8 @@ async function transformMarkdownWithSvelte(code, id, options) {
 			}),
 			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);
+		if (options.mdxDocumentProps) return compileSvelteResult(generateMdxDocumentPropsSvelteModule(transformed.html, discovered.usedComponents, frontmatter, options, id, discovered.localBindings, documentExpressions.expressions), id, discovered.usedComponents, frontmatter, options);
+		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);
 	}
 	const usedComponents = [];
 	const islands = [];
@@ -126,20 +127,63 @@ async function transformMarkdownWithSvelte(code, id, options) {
 		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);
+	return compileSvelteResult(generateSvelteModule(injectIslandMarkers((await transformMarkdown(processedContent, id, baseOptions)).html, islands), usedComponents, islands, frontmatter, options, id), id, usedComponents, frontmatter, options);
 }
-function compileSvelteResult(svelteCode, id, usedComponents, frontmatter, ssr = false) {
+async function compileSvelteResult(svelteCode, id, usedComponents, frontmatter, options) {
+	const compiled = normalizeSvelteCompilerResult(await resolveSvelteCompiler(options.compiler)(svelteCode, {
+		filename: id,
+		generate: options.ssr ? "server" : "client",
+		runes: options.runes
+	}), id);
 	return {
-		code: `${compile(svelteCode, {
-			filename: id,
-			generate: ssr ? "server" : "client",
-			runes: true
-		}).js.code}\nexport const frontmatter = ${JSON.stringify(frontmatter)};`,
-		map: null,
+		code: `${compiled.code}\nexport const frontmatter = ${JSON.stringify(frontmatter)};`,
+		map: compiled.map,
+		warnings: compiled.warnings,
 		usedComponents,
 		frontmatter
 	};
 }
+function resolveSvelteCompiler(compiler) {
+	if (!compiler) return compile;
+	if (typeof compiler === "function") return compiler;
+	return compiler.compile;
+}
+function normalizeSvelteCompilerResult(result, id) {
+	let value = result;
+	if (typeof value === "string") {
+		const source = value;
+		try {
+			value = JSON.parse(source);
+		} catch {
+			return {
+				code: source,
+				map: null,
+				warnings: []
+			};
+		}
+	}
+	if (!value || typeof value !== "object") throwUnsupportedCompilerResult(id);
+	const output = value;
+	const js = output.js;
+	const warnings = Array.isArray(output.warnings) ? output.warnings : [];
+	if (typeof js === "string") return {
+		code: js,
+		map: null,
+		warnings
+	};
+	if (js && typeof js === "object") {
+		const jsOutput = js;
+		if (typeof jsOutput.code === "string") return {
+			code: jsOutput.code,
+			map: jsOutput.map ?? null,
+			warnings
+		};
+	}
+	throwUnsupportedCompilerResult(id);
+}
+function throwUnsupportedCompilerResult(id) {
+	throw new Error(`[ox-content-svelte] Compiler for ${id} returned an unsupported result. Expected { js: { code } } or a compatible JSON string.`);
+}
 function createIslandMarker(islandId) {
 	return `${ISLAND_MARKER_PREFIX}${islandId}${ISLAND_MARKER_SUFFIX}`;
 }
@@ -940,12 +984,200 @@ function createSvelteMarkdownEnvironment(mode, options) {
 	};
 }
 //#endregion
-//#region src/index.ts
+//#region src/components.ts
 /**
-* Vite Plugin for Ox Content Svelte Integration
-*
-* Uses Vite's Environment API to enable embedding Svelte components in Markdown.
+* 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/html-host-default-renderer.ts
+const defaultRenderSvelteHtmlComponent = async (component, props, slotHtml) => {
+	return renderWithSvelteRuntime(await loadDefaultSvelteRuntime(), component, props, slotHtml);
+};
+function createSvelteHtmlHostComponentRenderer(loadModule) {
+	let pending;
+	return async (component, props, slotHtml) => {
+		pending ??= loadSvelteRuntimeFromHost(loadModule);
+		return renderWithSvelteRuntime(await pending, component, props, slotHtml);
+	};
+}
+async function loadDefaultSvelteRuntime() {
+	const [server, shared] = await Promise.all([import("svelte/server"), import("svelte")]);
+	return resolveSvelteRuntime(server, shared);
+}
+async function loadSvelteRuntimeFromHost(loadModule) {
+	const [server, shared] = await Promise.all([loadModule("svelte/server"), loadModule("svelte")]);
+	return resolveSvelteRuntime(server, shared);
+}
+function renderWithSvelteRuntime(runtime, component, props, slotHtml) {
+	const componentProps = slotHtml ? {
+		...props,
+		children: runtime.createRawSnippet(() => ({ render: () => slotHtml }))
+	} : props;
+	const rendered = runtime.render(component, { props: componentProps });
+	return rendered.html ?? rendered.body ?? "";
+}
+function resolveSvelteRuntime(server, shared) {
+	return {
+		render: runtimeFunction(server, "render", "svelte/server"),
+		createRawSnippet: runtimeFunction(shared, "createRawSnippet", "svelte")
+	};
+}
+function runtimeFunction(module, name, moduleId) {
+	const value = module && typeof module === "object" ? module[name] : void 0;
+	if (typeof value !== "function") throw new Error(`Svelte HTML host renderer could not load ${moduleId}.${name}.`);
+	return value;
+}
+//#endregion
+//#region src/html-host.ts
+async function renderSvelteHtmlHost(input) {
+	const resolveClientModule = input.resolveClientModule;
+	return await renderHtmlHost({
+		...input,
+		frameworkName: "Svelte",
+		renderComponent: input.renderComponent ?? defaultRenderSvelteHtmlComponent,
+		resolveClientModule
+	});
+}
+function createSvelteHtmlHostHydrate(input) {
+	return createHtmlHostHydrate(input);
+}
+//#endregion
+//#region src/html-host-renderer.ts
+var SvelteHtmlHostRenderError = class extends Error {
+	diagnostics;
+	constructor(diagnostics) {
+		super(formatHtmlHostDiagnostics(diagnostics));
+		this.name = "SvelteHtmlHostRenderError";
+		this.diagnostics = [...diagnostics];
+	}
+};
+function createSvelteHtmlHostRenderer(input) {
+	const policy = input.diagnostics ?? "throw";
+	const defaultRenderComponent = createSvelteHtmlHostComponentRenderer(input.loadModule);
+	return async (html, context) => {
+		const root = context.root ?? input.root;
+		const result = await renderSvelteHtmlHost({
+			html,
+			documentPath: context.documentPath,
+			root,
+			srcDir: context.srcDir ?? input.srcDir,
+			contentRoot: context.contentRoot ?? input.contentRoot,
+			imports: context.imports,
+			components: context.components ?? input.components,
+			loadModule: input.loadModule,
+			renderComponent: context.renderComponent ?? input.renderComponent ?? defaultRenderComponent,
+			resolveClientModule: context.resolveClientModule ?? input.resolveClientModule ?? ((module) => toHtmlHostClientModuleId$1(module.serverModuleId, root))
+		});
+		if (policy === "throw" && result.diagnostics.length > 0) throw new SvelteHtmlHostRenderError(result.diagnostics);
+		return result;
+	};
+}
+//#endregion
+//#region src/html-host-registry.ts
+const SVELTE_HTML_HOST_MODULES_VIRTUAL_ID = "virtual:ox-content-svelte/html-host/modules";
+function createSvelteHtmlHostIslandRegistry(input = {}) {
+	return createHtmlHostIslandRegistry({
+		...input,
+		virtualModuleId: input.virtualModuleId ?? "virtual:ox-content-svelte/html-host/modules",
+		pluginName: input.pluginName ?? "ox-content:svelte-html-host-island-registry"
+	});
+}
+function resolveSvelteHtmlHostIslandRegistry(input, context, resolvedComponents) {
+	return resolveHtmlHostIslandRegistry(input, context, resolvedComponents);
+}
+//#endregion
+//#region src/html-host-collection-documents.ts
+function createSvelteHtmlHostCollectionDocuments(input = {}) {
+	return (context) => resolveSvelteHtmlHostCollectionDocuments(input, context);
+}
+function resolveSvelteHtmlHostCollectionDocuments(input, context) {
+	return resolveHtmlHostCollectionDocuments(input, context);
+}
+//#endregion
+//#region src/index.ts
 const DEFAULT_MARKDOWN_EXTENSIONS = [
 	".md",
 	".markdown",
@@ -1029,6 +1261,7 @@ function oxContentSvelte(options = {}) {
 				renderIsland: options.renderIsland,
 				ssr: transformOptions?.ssr
 			});
+			for (const warning of result.warnings) this.warn(formatSvelteCompilerWarning(warning));
 			return {
 				code: result.code,
 				map: result.map
@@ -1101,11 +1334,16 @@ function resolveSvelteOptions(options) {
 		tocMaxDepth: options.tocMaxDepth ?? 3,
 		codeAnnotations: resolveCodeAnnotationsOptions(options.codeAnnotations),
 		runes: options.runes ?? true,
+		compiler: options.compiler,
 		embeds: resolveBuiltinEmbedOptions(options.embeds),
 		mdx: options.mdx,
 		mdxDocumentProps: options.mdxDocumentProps ?? false
 	};
 }
+function formatSvelteCompilerWarning(warning) {
+	const message = `${warning.code ? `[${warning.code}] ` : ""}${warning.message}`;
+	return warning.frame ? `${message}\n${warning.frame}` : message;
+}
 function resolveCodeAnnotationsOptions(options) {
 	if (!options) return {
 		enabled: false,
@@ -1143,49 +1381,7 @@ ${exports.join("\n")}
 export default components;
 `;
 }
-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) {
-		const files = await globFiles(pattern, root);
-		for (const file of files) {
-			const componentName = toPascalCase(path.basename(file, path.extname(file)));
-			result[componentName] = "./" + path.relative(root, file).replace(/\\/g, "/");
-		}
-	}
-	return result;
-}
-async function globFiles(pattern, root) {
-	const files = [];
-	if (!pattern.includes("*")) {
-		const fullPath = path.resolve(root, pattern);
-		if (fs.existsSync(fullPath)) files.push(fullPath);
-		return files;
-	}
-	const parts = pattern.split("*");
-	const baseDir = path.resolve(root, parts[0]);
-	const ext = parts[1] || "";
-	if (!fs.existsSync(baseDir)) return files;
-	if (pattern.includes("**")) await walkDir(baseDir, files, ext);
-	else {
-		const entries = await fs.promises.readdir(baseDir, { withFileTypes: true });
-		for (const entry of entries) if (entry.isFile() && entry.name.endsWith(ext)) files.push(path.join(baseDir, entry.name));
-	}
-	return files;
-}
-async function walkDir(dir, files, ext) {
-	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, ext);
-		else if (entry.isFile() && entry.name.endsWith(ext)) files.push(fullPath);
-	}
-}
-function toPascalCase(str) {
-	return str.replace(/[-_](\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
-}
 //#endregion
-export { oxContent, oxContentSvelte, renderHead };
+export { SVELTE_HTML_HOST_MODULES_VIRTUAL_ID, SvelteHtmlHostRenderError, createSvelteHtmlHostCollectionDocuments, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostHydrate, createSvelteHtmlHostIslandRegistry, createSvelteHtmlHostLazyHydrate, createSvelteHtmlHostRenderer, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, oxContent, oxContentSvelte, readSvelteHtmlHostSlot, renderHead, renderSvelteHtmlHost, resolveSvelteHtmlHostCollectionDocuments, resolveSvelteHtmlHostIslandRegistry, toHtmlHostClientModuleId as toSvelteHtmlHostClientModuleId };
 
 //# sourceMappingURL=index.mjs.map