@ox-content/vite-plugin-svelte 3.1.2-beta.0 → 3.1.3

package/dist/html-host-client.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_html_host_client = require("./html-host-client2.cjs");
+exports.createSvelteHtmlHostDomRenderer = require_html_host_client.createSvelteHtmlHostDomRenderer;
+exports.createSvelteHtmlHostLazyHydrate = require_html_host_client.createSvelteHtmlHostLazyHydrate;
+exports.initSvelteHtmlHost = require_html_host_client.initSvelteHtmlHost;
+exports.loadSvelteHtmlHostDomRuntime = require_html_host_client.loadSvelteHtmlHostDomRuntime;
+exports.readSvelteHtmlHostSlot = require_html_host_client.readSvelteHtmlHostSlot;

package/dist/html-host-client.d.cts

@@ -0,0 +1,92 @@
+import { InitIslandsOptions } from "@ox-content/islands";
+//#region src/html-host-client-types.d.ts
+type SvelteHtmlHostClientDiagnosticCode = "missing-island-name" | "missing-module-id" | "unknown-module" | "module-load-failed" | "runtime-load-failed" | "missing-export" | "render-failed";
+interface SvelteHtmlHostClientError {
+  code: SvelteHtmlHostClientDiagnosticCode;
+  message: string;
+  element: HTMLElement;
+  props: Record<string, unknown>;
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+}
+type SvelteHtmlHostClientComponentValue = unknown;
+type SvelteHtmlHostClientModuleValue = SvelteHtmlHostClientComponentValue;
+type SvelteHtmlHostClientModuleLoader<TModule = SvelteHtmlHostClientModuleValue> = () => TModule | PromiseLike<TModule>;
+type SvelteHtmlHostClientModules = Readonly<Record<string, SvelteHtmlHostClientModuleLoader>> | ReadonlyMap<string, SvelteHtmlHostClientModuleLoader>;
+interface SvelteHtmlHostClientContext<TRuntime = undefined> {
+  component: unknown;
+  componentName: string;
+  element: HTMLElement;
+  exportName: string;
+  moduleExports: unknown;
+  moduleId: string;
+  props: Record<string, unknown>;
+  runtime: TRuntime | undefined;
+  slotHtml: string | undefined;
+}
+type SvelteHtmlHostClientRenderer<TRuntime = undefined> = (context: SvelteHtmlHostClientContext<TRuntime>) => void | (() => void) | PromiseLike<void | (() => void)>;
+type SvelteHtmlHostClientRuntimeLoader<TRuntime = undefined> = () => TRuntime | Promise<TRuntime>;
+type SvelteHtmlHostModuleIdResolver = (element: HTMLElement, context: {
+  componentName: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+type SvelteHtmlHostExportNameResolver = (element: HTMLElement, context: {
+  componentName: string;
+  moduleId: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+interface SvelteHtmlHostClientBaseInput<TRuntime = undefined> {
+  modules: SvelteHtmlHostClientModules;
+  loadRuntime?: SvelteHtmlHostClientRuntimeLoader<TRuntime>;
+  resolveModuleId?: SvelteHtmlHostModuleIdResolver;
+  resolveExportName?: SvelteHtmlHostExportNameResolver;
+  onError?: (error: SvelteHtmlHostClientError) => void;
+}
+interface CreateSvelteHtmlHostLazyHydrateRenderInput<TRuntime = undefined> extends SvelteHtmlHostClientBaseInput<TRuntime> {
+  render: SvelteHtmlHostClientRenderer<TRuntime>;
+  mount?: never;
+}
+interface CreateSvelteHtmlHostLazyHydrateMountInput extends SvelteHtmlHostClientBaseInput<SvelteHtmlHostDomRuntime> {
+  mount: SvelteHtmlHostDomRendererInput;
+  render?: never;
+}
+type CreateSvelteHtmlHostLazyHydrateInput<TRuntime = undefined> = CreateSvelteHtmlHostLazyHydrateRenderInput<TRuntime> | CreateSvelteHtmlHostLazyHydrateMountInput;
+type SvelteHtmlHostDomMode = "render" | "hydrate";
+interface SvelteHtmlHostDomRendererInput {
+  mode: SvelteHtmlHostDomMode;
+}
+interface SvelteHtmlHostDomRuntime {
+  mount: (component: SvelteHtmlHostClientComponentValue, options: {
+    target: HTMLElement;
+    props?: Record<string, unknown>;
+  }) => unknown;
+  hydrate: (component: SvelteHtmlHostClientComponentValue, options: {
+    target: HTMLElement;
+    props?: Record<string, unknown>;
+  }) => unknown;
+  unmount: (instance: unknown) => void | Promise<void>;
+  createRawSnippet: (factory: () => {
+    render: () => string;
+    setup?: (element: Element) => void;
+  }) => unknown;
+}
+type SvelteHtmlHostInitIslands<TController = unknown> = (hydrate: (element: HTMLElement, props: Record<string, unknown>) => void | (() => void), options?: InitIslandsOptions) => TController;
+type InitSvelteHtmlHostInput<TRuntime = undefined> = CreateSvelteHtmlHostLazyHydrateInput<TRuntime> & {
+  initIslands: SvelteHtmlHostInitIslands;
+  options?: InitIslandsOptions;
+};
+//#endregion
+//#region src/html-host-dom-renderer.d.ts
+type SvelteHtmlHostDomRenderer = SvelteHtmlHostClientRenderer<SvelteHtmlHostDomRuntime>;
+declare function loadSvelteHtmlHostDomRuntime(): Promise<SvelteHtmlHostDomRuntime>;
+declare function createSvelteHtmlHostDomRenderer(input: SvelteHtmlHostDomRendererInput): SvelteHtmlHostDomRenderer;
+//#endregion
+//#region src/html-host-client.d.ts
+declare function initSvelteHtmlHost<TRuntime = undefined>(input: InitSvelteHtmlHostInput<TRuntime>): ReturnType<InitSvelteHtmlHostInput<TRuntime>["initIslands"]>;
+declare function createSvelteHtmlHostLazyHydrate<TRuntime = undefined>(input: CreateSvelteHtmlHostLazyHydrateInput<TRuntime>): (element: HTMLElement, props: Record<string, unknown>) => () => void;
+declare function readSvelteHtmlHostSlot(element: Pick<HTMLElement, "dataset" | "innerHTML">): string | undefined;
+//#endregion
+export { initSvelteHtmlHost, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostLazyHydrate, loadSvelteHtmlHostDomRuntime, readSvelteHtmlHostSlot };
+export type { CreateSvelteHtmlHostLazyHydrateInput, InitSvelteHtmlHostInput, SvelteHtmlHostClientContext, SvelteHtmlHostClientDiagnosticCode, SvelteHtmlHostClientError, SvelteHtmlHostClientComponentValue, SvelteHtmlHostClientModuleLoader, SvelteHtmlHostClientModules, SvelteHtmlHostClientModuleValue, SvelteHtmlHostClientRenderer, SvelteHtmlHostClientRuntimeLoader, SvelteHtmlHostDomMode, SvelteHtmlHostDomRenderer, SvelteHtmlHostDomRendererInput, SvelteHtmlHostDomRuntime, SvelteHtmlHostExportNameResolver, SvelteHtmlHostInitIslands, SvelteHtmlHostModuleIdResolver };

package/dist/html-host-client.d.mts

@@ -0,0 +1,92 @@
+import { InitIslandsOptions } from "@ox-content/islands";
+//#region src/html-host-client-types.d.ts
+type SvelteHtmlHostClientDiagnosticCode = "missing-island-name" | "missing-module-id" | "unknown-module" | "module-load-failed" | "runtime-load-failed" | "missing-export" | "render-failed";
+interface SvelteHtmlHostClientError {
+  code: SvelteHtmlHostClientDiagnosticCode;
+  message: string;
+  element: HTMLElement;
+  props: Record<string, unknown>;
+  componentName?: string;
+  moduleId?: string;
+  exportName?: string;
+  cause?: unknown;
+}
+type SvelteHtmlHostClientComponentValue = unknown;
+type SvelteHtmlHostClientModuleValue = SvelteHtmlHostClientComponentValue;
+type SvelteHtmlHostClientModuleLoader<TModule = SvelteHtmlHostClientModuleValue> = () => TModule | PromiseLike<TModule>;
+type SvelteHtmlHostClientModules = Readonly<Record<string, SvelteHtmlHostClientModuleLoader>> | ReadonlyMap<string, SvelteHtmlHostClientModuleLoader>;
+interface SvelteHtmlHostClientContext<TRuntime = undefined> {
+  component: unknown;
+  componentName: string;
+  element: HTMLElement;
+  exportName: string;
+  moduleExports: unknown;
+  moduleId: string;
+  props: Record<string, unknown>;
+  runtime: TRuntime | undefined;
+  slotHtml: string | undefined;
+}
+type SvelteHtmlHostClientRenderer<TRuntime = undefined> = (context: SvelteHtmlHostClientContext<TRuntime>) => void | (() => void) | PromiseLike<void | (() => void)>;
+type SvelteHtmlHostClientRuntimeLoader<TRuntime = undefined> = () => TRuntime | Promise<TRuntime>;
+type SvelteHtmlHostModuleIdResolver = (element: HTMLElement, context: {
+  componentName: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+type SvelteHtmlHostExportNameResolver = (element: HTMLElement, context: {
+  componentName: string;
+  moduleId: string;
+  props: Record<string, unknown>;
+}) => string | undefined;
+interface SvelteHtmlHostClientBaseInput<TRuntime = undefined> {
+  modules: SvelteHtmlHostClientModules;
+  loadRuntime?: SvelteHtmlHostClientRuntimeLoader<TRuntime>;
+  resolveModuleId?: SvelteHtmlHostModuleIdResolver;
+  resolveExportName?: SvelteHtmlHostExportNameResolver;
+  onError?: (error: SvelteHtmlHostClientError) => void;
+}
+interface CreateSvelteHtmlHostLazyHydrateRenderInput<TRuntime = undefined> extends SvelteHtmlHostClientBaseInput<TRuntime> {
+  render: SvelteHtmlHostClientRenderer<TRuntime>;
+  mount?: never;
+}
+interface CreateSvelteHtmlHostLazyHydrateMountInput extends SvelteHtmlHostClientBaseInput<SvelteHtmlHostDomRuntime> {
+  mount: SvelteHtmlHostDomRendererInput;
+  render?: never;
+}
+type CreateSvelteHtmlHostLazyHydrateInput<TRuntime = undefined> = CreateSvelteHtmlHostLazyHydrateRenderInput<TRuntime> | CreateSvelteHtmlHostLazyHydrateMountInput;
+type SvelteHtmlHostDomMode = "render" | "hydrate";
+interface SvelteHtmlHostDomRendererInput {
+  mode: SvelteHtmlHostDomMode;
+}
+interface SvelteHtmlHostDomRuntime {
+  mount: (component: SvelteHtmlHostClientComponentValue, options: {
+    target: HTMLElement;
+    props?: Record<string, unknown>;
+  }) => unknown;
+  hydrate: (component: SvelteHtmlHostClientComponentValue, options: {
+    target: HTMLElement;
+    props?: Record<string, unknown>;
+  }) => unknown;
+  unmount: (instance: unknown) => void | Promise<void>;
+  createRawSnippet: (factory: () => {
+    render: () => string;
+    setup?: (element: Element) => void;
+  }) => unknown;
+}
+type SvelteHtmlHostInitIslands<TController = unknown> = (hydrate: (element: HTMLElement, props: Record<string, unknown>) => void | (() => void), options?: InitIslandsOptions) => TController;
+type InitSvelteHtmlHostInput<TRuntime = undefined> = CreateSvelteHtmlHostLazyHydrateInput<TRuntime> & {
+  initIslands: SvelteHtmlHostInitIslands;
+  options?: InitIslandsOptions;
+};
+//#endregion
+//#region src/html-host-dom-renderer.d.ts
+type SvelteHtmlHostDomRenderer = SvelteHtmlHostClientRenderer<SvelteHtmlHostDomRuntime>;
+declare function loadSvelteHtmlHostDomRuntime(): Promise<SvelteHtmlHostDomRuntime>;
+declare function createSvelteHtmlHostDomRenderer(input: SvelteHtmlHostDomRendererInput): SvelteHtmlHostDomRenderer;
+//#endregion
+//#region src/html-host-client.d.ts
+declare function initSvelteHtmlHost<TRuntime = undefined>(input: InitSvelteHtmlHostInput<TRuntime>): ReturnType<InitSvelteHtmlHostInput<TRuntime>["initIslands"]>;
+declare function createSvelteHtmlHostLazyHydrate<TRuntime = undefined>(input: CreateSvelteHtmlHostLazyHydrateInput<TRuntime>): (element: HTMLElement, props: Record<string, unknown>) => () => void;
+declare function readSvelteHtmlHostSlot(element: Pick<HTMLElement, "dataset" | "innerHTML">): string | undefined;
+//#endregion
+export { initSvelteHtmlHost, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostLazyHydrate, loadSvelteHtmlHostDomRuntime, readSvelteHtmlHostSlot };
+export type { CreateSvelteHtmlHostLazyHydrateInput, InitSvelteHtmlHostInput, SvelteHtmlHostClientContext, SvelteHtmlHostClientDiagnosticCode, SvelteHtmlHostClientError, SvelteHtmlHostClientComponentValue, SvelteHtmlHostClientModuleLoader, SvelteHtmlHostClientModules, SvelteHtmlHostClientModuleValue, SvelteHtmlHostClientRenderer, SvelteHtmlHostClientRuntimeLoader, SvelteHtmlHostDomMode, SvelteHtmlHostDomRenderer, SvelteHtmlHostDomRendererInput, SvelteHtmlHostDomRuntime, SvelteHtmlHostExportNameResolver, SvelteHtmlHostInitIslands, SvelteHtmlHostModuleIdResolver };

package/dist/html-host-client.mjs

@@ -0,0 +1,2 @@
+import { a as loadSvelteHtmlHostDomRuntime, i as createSvelteHtmlHostDomRenderer, n as initSvelteHtmlHost, r as readSvelteHtmlHostSlot, t as createSvelteHtmlHostLazyHydrate } from "./html-host-client2.mjs";
+export { createSvelteHtmlHostDomRenderer, createSvelteHtmlHostLazyHydrate, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, readSvelteHtmlHostSlot };

package/dist/html-host-client2.cjs

@@ -0,0 +1,293 @@
+//#region src/html-host-dom-renderer.ts
+const DOM_RENDERER_MODE = Symbol("svelte-html-host-dom-renderer-mode");
+async function loadSvelteHtmlHostDomRuntime() {
+	const { createRawSnippet, hydrate, mount, unmount } = await import("svelte");
+	return {
+		createRawSnippet,
+		hydrate,
+		mount,
+		unmount
+	};
+}
+function createSvelteHtmlHostDomRenderer(input) {
+	const renderer = ((context) => {
+		const runtime = context.runtime;
+		if (!runtime) throw new Error("Svelte HTML host DOM renderer requires a Svelte runtime.");
+		const componentProps = componentPropsWithSlot(runtime, context.props, context.slotHtml);
+		const instance = input.mode === "hydrate" ? runtime.hydrate(context.component, {
+			target: context.element,
+			props: componentProps
+		}) : runtime.mount(context.component, {
+			target: context.element,
+			props: componentProps
+		});
+		return () => {
+			runtime.unmount(instance);
+		};
+	});
+	Object.defineProperty(renderer, DOM_RENDERER_MODE, { value: input.mode });
+	return renderer;
+}
+function svelteHtmlHostDomRendererMode(renderer) {
+	return renderer[DOM_RENDERER_MODE];
+}
+function componentPropsWithSlot(runtime, props, slotHtml) {
+	if (!slotHtml) return props;
+	return {
+		...props,
+		children: runtime.createRawSnippet(() => ({
+			render: () => slotHtml,
+			setup: (element) => {
+				element.innerHTML = slotHtml;
+			}
+		}))
+	};
+}
+//#endregion
+//#region src/html-host-client-errors.ts
+function reportError(input, error) {
+	error.element.classList?.add("ox-island-error");
+	error.element.dataset.oxError = error.message;
+	input.onError?.(error);
+	if (typeof CustomEvent === "function" && typeof error.element.dispatchEvent === "function") error.element.dispatchEvent(new CustomEvent("ox-content-svelte-html-host:error", { detail: error }));
+}
+function clientError(code, element, props, context = {}) {
+	return {
+		code,
+		element,
+		props,
+		...context,
+		message: clientErrorMessage(code, context)
+	};
+}
+function clientErrorMessage(code, context) {
+	const component = context.componentName ? `Svelte island "${context.componentName}"` : "Svelte island";
+	const reason = causeMessage(context.cause);
+	switch (code) {
+		case "missing-island-name": return "Svelte island element is missing data-ox-island.";
+		case "missing-module-id": return `${component} is missing data-ox-module.`;
+		case "unknown-module": return `${component} references unknown module "${context.moduleId ?? ""}".`;
+		case "module-load-failed": return `${component} module "${context.moduleId ?? ""}" failed to load: ${reason}`;
+		case "runtime-load-failed": return `Svelte runtime failed to load: ${reason}`;
+		case "missing-export": return `${component} module "${context.moduleId ?? ""}" is missing export "${context.exportName ?? "default"}".`;
+		case "render-failed": return `${component} failed to render: ${reason}`;
+	}
+}
+function causeMessage(cause) {
+	if (cause == null) return "";
+	if (cause instanceof Error) return cause.message;
+	if (typeof cause === "string") return cause;
+	if (typeof cause === "number" || typeof cause === "boolean") return cause.toString();
+	try {
+		return JSON.stringify(cause);
+	} catch {
+		return Object.prototype.toString.call(cause);
+	}
+}
+//#endregion
+//#region src/html-host-client.ts
+const ISLAND_JSON_SCRIPT = /^\s*<script type="application\/json">[\s\S]*?<\/script>/;
+function initSvelteHtmlHost(input) {
+	return input.initIslands(createSvelteHtmlHostLazyHydrate(input), input.options);
+}
+function createSvelteHtmlHostLazyHydrate(input) {
+	const render = resolveRenderer(input);
+	const load = resolveRuntimeLoader(input, render);
+	const moduleCache = /* @__PURE__ */ new Map();
+	let runtimeCache;
+	return (element, props) => {
+		const componentName = element.dataset.oxIsland;
+		if (!componentName) {
+			reportError(input, clientError("missing-island-name", element, props));
+			return noop;
+		}
+		const moduleId = input.resolveModuleId?.(element, {
+			componentName,
+			props
+		}) ?? element.dataset.oxModule;
+		if (!moduleId) {
+			reportError(input, clientError("missing-module-id", element, props, { componentName }));
+			return noop;
+		}
+		if (!moduleLoader(input.modules, moduleId)) {
+			reportError(input, clientError("unknown-module", element, props, {
+				componentName,
+				moduleId
+			}));
+			return noop;
+		}
+		const exportName = input.resolveExportName?.(element, {
+			componentName,
+			moduleId,
+			props
+		}) ?? element.dataset.oxExport ?? "default";
+		const slotHtml = readSvelteHtmlHostSlot(element);
+		let disposed = false;
+		let disposeMounted;
+		const dispose = () => {
+			if (disposed) return;
+			disposed = true;
+			disposeMounted?.();
+			disposeMounted = void 0;
+		};
+		(async () => {
+			let moduleExports;
+			let runtime;
+			try {
+				moduleExports = await loadClientModule(input.modules, moduleId, moduleCache);
+			} catch (cause) {
+				if (!disposed) reportError(input, clientError("module-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				}));
+				return;
+			}
+			if (disposed) return;
+			try {
+				runtime = await loadRuntime(load, () => runtimeCache, (pending) => {
+					runtimeCache = pending;
+				});
+			} catch (cause) {
+				if (!disposed) reportError(input, clientError("runtime-load-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				}));
+				return;
+			}
+			if (disposed) return;
+			const component = exportedValue(moduleExports, exportName);
+			if (component == null) {
+				reportError(input, clientError("missing-export", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause: /* @__PURE__ */ new Error(`Export "${exportName}" was not found.`)
+				}));
+				return;
+			}
+			if (!preservesElementContents(input, render)) element.innerHTML = "";
+			try {
+				const cleanup = await render({
+					component,
+					componentName,
+					element,
+					exportName,
+					moduleExports,
+					moduleId,
+					props,
+					runtime,
+					slotHtml
+				});
+				disposeMounted = cleanup ? once(cleanup) : void 0;
+				if (disposed) {
+					disposeMounted?.();
+					disposeMounted = void 0;
+				}
+			} catch (cause) {
+				if (!disposed) reportError(input, clientError("render-failed", element, props, {
+					componentName,
+					moduleId,
+					exportName,
+					cause
+				}));
+			}
+		})();
+		return dispose;
+	};
+}
+function readSvelteHtmlHostSlot(element) {
+	const fromAttr = element.dataset.oxContent;
+	if (fromAttr) return fromAttr;
+	if (element.dataset.oxSsr === "true") return void 0;
+	return element.innerHTML.replace(ISLAND_JSON_SCRIPT, "") || void 0;
+}
+async function loadClientModule(modules, moduleId, cache) {
+	const cached = cache.get(moduleId);
+	if (cached) return cached;
+	const loader = moduleLoader(modules, moduleId);
+	if (!loader) throw new Error(`Unknown module "${moduleId}".`);
+	const pending = Promise.resolve().then(loader).catch((cause) => {
+		cache.delete(moduleId);
+		throw cause;
+	});
+	cache.set(moduleId, pending);
+	return pending;
+}
+async function loadRuntime(load, getCached, setCached) {
+	if (!load) return void 0;
+	const cached = getCached();
+	if (cached) return cached;
+	const pending = Promise.resolve().then(load).catch((cause) => {
+		setCached(void 0);
+		throw cause;
+	});
+	setCached(pending);
+	return pending;
+}
+function resolveRenderer(input) {
+	if (input.render) return input.render;
+	if (input.mount) return createSvelteHtmlHostDomRenderer(input.mount);
+	throw new Error("initSvelteHtmlHost requires either render or mount.");
+}
+function resolveRuntimeLoader(input, render) {
+	if (input.loadRuntime) return input.loadRuntime;
+	if (input.mount || svelteHtmlHostDomRendererMode(render)) return loadSvelteHtmlHostDomRuntime;
+}
+function preservesElementContents(input, render) {
+	return (input.mount?.mode ?? svelteHtmlHostDomRendererMode(render)) === "hydrate";
+}
+function moduleLoader(modules, moduleId) {
+	return isReadonlyMap(modules) ? modules.get(moduleId) : modules[moduleId];
+}
+function isReadonlyMap(value) {
+	return typeof value.get === "function";
+}
+function exportedValue(moduleExports, exportName) {
+	if (exportName === "default" && typeof moduleExports === "function") return moduleExports;
+	if (!moduleExports || typeof moduleExports !== "object") return;
+	return moduleExports[exportName];
+}
+function once(cleanup) {
+	let called = false;
+	return () => {
+		if (called) return;
+		called = true;
+		cleanup();
+	};
+}
+function noop() {}
+//#endregion
+Object.defineProperty(exports, "createSvelteHtmlHostDomRenderer", {
+	enumerable: true,
+	get: function() {
+		return createSvelteHtmlHostDomRenderer;
+	}
+});
+Object.defineProperty(exports, "createSvelteHtmlHostLazyHydrate", {
+	enumerable: true,
+	get: function() {
+		return createSvelteHtmlHostLazyHydrate;
+	}
+});
+Object.defineProperty(exports, "initSvelteHtmlHost", {
+	enumerable: true,
+	get: function() {
+		return initSvelteHtmlHost;
+	}
+});
+Object.defineProperty(exports, "loadSvelteHtmlHostDomRuntime", {
+	enumerable: true,
+	get: function() {
+		return loadSvelteHtmlHostDomRuntime;
+	}
+});
+Object.defineProperty(exports, "readSvelteHtmlHostSlot", {
+	enumerable: true,
+	get: function() {
+		return readSvelteHtmlHostSlot;
+	}
+});

package/dist/html-host-client2.d.cts

@@ -0,0 +1,2 @@
+import { C as SvelteHtmlHostModuleIdResolver, S 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, x as SvelteHtmlHostExportNameResolver, y as SvelteHtmlHostDomRendererInput } from "./html-host-client.cjs";
+export { type CreateSvelteHtmlHostLazyHydrateInput, type InitSvelteHtmlHostInput, type SvelteHtmlHostClientComponentValue, type SvelteHtmlHostClientContext, type SvelteHtmlHostClientDiagnosticCode, type SvelteHtmlHostClientError, type SvelteHtmlHostClientModuleLoader, type SvelteHtmlHostClientModuleValue, type SvelteHtmlHostClientModules, type SvelteHtmlHostClientRenderer, type SvelteHtmlHostClientRuntimeLoader, type SvelteHtmlHostDomMode, type SvelteHtmlHostDomRenderer, type SvelteHtmlHostDomRendererInput, type SvelteHtmlHostDomRuntime, type SvelteHtmlHostExportNameResolver, type SvelteHtmlHostInitIslands, type SvelteHtmlHostModuleIdResolver, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostLazyHydrate, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, readSvelteHtmlHostSlot };

package/dist/html-host-client2.d.mts

@@ -0,0 +1,2 @@
+import { C as SvelteHtmlHostModuleIdResolver, S 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, x as SvelteHtmlHostExportNameResolver, y as SvelteHtmlHostDomRendererInput } from "./html-host-client.mjs";
+export { type CreateSvelteHtmlHostLazyHydrateInput, type InitSvelteHtmlHostInput, type SvelteHtmlHostClientComponentValue, type SvelteHtmlHostClientContext, type SvelteHtmlHostClientDiagnosticCode, type SvelteHtmlHostClientError, type SvelteHtmlHostClientModuleLoader, type SvelteHtmlHostClientModuleValue, type SvelteHtmlHostClientModules, type SvelteHtmlHostClientRenderer, type SvelteHtmlHostClientRuntimeLoader, type SvelteHtmlHostDomMode, type SvelteHtmlHostDomRenderer, type SvelteHtmlHostDomRendererInput, type SvelteHtmlHostDomRuntime, type SvelteHtmlHostExportNameResolver, type SvelteHtmlHostInitIslands, type SvelteHtmlHostModuleIdResolver, createSvelteHtmlHostDomRenderer, createSvelteHtmlHostLazyHydrate, initSvelteHtmlHost, loadSvelteHtmlHostDomRuntime, readSvelteHtmlHostSlot };