@vixt/core 0.13.3 → 0.13.5

package/dist/client/index.js

@@ -28,60 +28,224 @@ function useVixtApp() {
 	return globalThis.useVixtApp?.();
 }
 //#endregion
-//#region ../../node_modules/.pnpm/ofetch@2.0.0-alpha.3/node_modules/ofetch/dist/index.mjs
-/**
-* Joins the given base URL and path, ensuring that there is only one slash between them.
-*/
-function joinURL(base, path) {
-	if (!base || base === "/") return path || "/";
-	if (!path || path === "/") return base || "/";
-	const baseHasTrailing = base[base.length - 1] === "/";
-	const pathHasLeading = path[0] === "/";
-	if (baseHasTrailing && pathHasLeading) return base + path.slice(1);
-	if (!baseHasTrailing && !pathHasLeading) return `${base}/${path}`;
-	return base + path;
+//#region ../../node_modules/.pnpm/destr@2.0.5/node_modules/destr/dist/index.mjs
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+	if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+		warnKeyDropped(key);
+		return;
+	}
+	return value;
 }
-/**
-* Adds the base path to the input path, if it is not already present.
-*/
-function withBase(input = "", base = "") {
-	if (!base || base === "/") return input;
+function warnKeyDropped(key) {
+	console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+	if (typeof value !== "string") return value;
+	if (value[0] === "\"" && value[value.length - 1] === "\"" && value.indexOf("\\") === -1) return value.slice(1, -1);
+	const _value = value.trim();
+	if (_value.length <= 9) switch (_value.toLowerCase()) {
+		case "true": return true;
+		case "false": return false;
+		case "undefined": return;
+		case "null": return null;
+		case "nan": return NaN;
+		case "infinity": return Number.POSITIVE_INFINITY;
+		case "-infinity": return Number.NEGATIVE_INFINITY;
+	}
+	if (!JsonSigRx.test(value)) {
+		if (options.strict) throw new SyntaxError("[destr] Invalid JSON");
+		return value;
+	}
+	try {
+		if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+			if (options.strict) throw new Error("[destr] Possible prototype pollution");
+			return JSON.parse(value, jsonParseTransform);
+		}
+		return JSON.parse(value);
+	} catch (error) {
+		if (options.strict) throw error;
+		return value;
+	}
+}
+String.fromCharCode;
+const HASH_RE = /#/g;
+const AMPERSAND_RE = /&/g;
+const SLASH_RE = /\//g;
+const EQUAL_RE = /=/g;
+const PLUS_RE = /\+/g;
+const ENC_CARET_RE = /%5e/gi;
+const ENC_BACKTICK_RE = /%60/gi;
+const ENC_PIPE_RE = /%7c/gi;
+const ENC_SPACE_RE = /%20/gi;
+function encode(text) {
+	return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
+}
+function encodeQueryValue(input) {
+	return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
+}
+function encodeQueryKey(text) {
+	return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
+}
+function decode(text = "") {
+	try {
+		return decodeURIComponent("" + text);
+	} catch {
+		return "" + text;
+	}
+}
+function decodeQueryKey(text) {
+	return decode(text.replace(PLUS_RE, " "));
+}
+function decodeQueryValue(text) {
+	return decode(text.replace(PLUS_RE, " "));
+}
+function parseQuery(parametersString = "") {
+	const object = /* @__PURE__ */ Object.create(null);
+	if (parametersString[0] === "?") parametersString = parametersString.slice(1);
+	for (const parameter of parametersString.split("&")) {
+		const s = parameter.match(/([^=]+)=?(.*)/) || [];
+		if (s.length < 2) continue;
+		const key = decodeQueryKey(s[1]);
+		if (key === "__proto__" || key === "constructor") continue;
+		const value = decodeQueryValue(s[2] || "");
+		if (object[key] === void 0) object[key] = value;
+		else if (Array.isArray(object[key])) object[key].push(value);
+		else object[key] = [object[key], value];
+	}
+	return object;
+}
+function encodeQueryItem(key, value) {
+	if (typeof value === "number" || typeof value === "boolean") value = String(value);
+	if (!value) return encodeQueryKey(key);
+	if (Array.isArray(value)) return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
+	return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
+}
+function stringifyQuery(query) {
+	return Object.keys(query).filter((k) => query[k] !== void 0).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
+}
+const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
+const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
+const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
+const TRAILING_SLASH_RE = /\/$|\/\?|\/#/;
+const JOIN_LEADING_SLASH_RE = /^\.?\//;
+function hasProtocol(inputString, opts = {}) {
+	if (typeof opts === "boolean") opts = { acceptRelative: opts };
+	if (opts.strict) return PROTOCOL_STRICT_REGEX.test(inputString);
+	return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
+}
+function hasTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/");
+	return TRAILING_SLASH_RE.test(input);
+}
+function withoutTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
+	if (!hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+	}
+	const [s0, ...s] = path.split("?");
+	return ((s0.endsWith("/") ? s0.slice(0, -1) : s0) || "/") + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withTrailingSlash(input = "", respectQueryAndFragment) {
+	if (!respectQueryAndFragment) return input.endsWith("/") ? input : input + "/";
+	if (hasTrailingSlash(input, true)) return input || "/";
+	let path = input;
+	let fragment = "";
+	const fragmentIndex = input.indexOf("#");
+	if (fragmentIndex !== -1) {
+		path = input.slice(0, fragmentIndex);
+		fragment = input.slice(fragmentIndex);
+		if (!path) return fragment;
+	}
+	const [s0, ...s] = path.split("?");
+	return s0 + "/" + (s.length > 0 ? `?${s.join("?")}` : "") + fragment;
+}
+function withBase(input, base) {
+	if (isEmptyURL(base) || hasProtocol(input)) return input;
 	const _base = withoutTrailingSlash(base);
-	if (input.startsWith(_base)) return input;
+	if (input.startsWith(_base)) {
+		const nextChar = input[_base.length];
+		if (!nextChar || nextChar === "/" || nextChar === "?") return input;
+	}
 	return joinURL(_base, input);
 }
-function withoutTrailingSlash(path) {
-	if (!path || path === "/") return "/";
-	return path[path.length - 1] === "/" ? path.slice(0, -1) : path;
-}
-/**
-* Returns the URL with the given query parameters. If a query parameter is undefined, it is omitted.
-*/
 function withQuery(input, query) {
-	if (!query || Object.keys(query).length === 0) return input;
-	const searchIndex = input.indexOf("?");
-	if (searchIndex === -1) {
-		const normalizedQuery = Object.entries(query).filter(([, value]) => value !== void 0).flatMap(([key, value]) => {
-			if (Array.isArray(value)) return value.map((item) => [key, normalizeQueryValue(item)]);
-			return [[key, normalizeQueryValue(value)]];
-		});
-		const queryString$1 = new URLSearchParams(normalizedQuery).toString();
-		return queryString$1 ? `${input}?${queryString$1}` : input;
+	const parsed = parseURL(input);
+	parsed.search = stringifyQuery({
+		...parseQuery(parsed.search),
+		...query
+	});
+	return stringifyParsedURL(parsed);
+}
+function isEmptyURL(url) {
+	return !url || url === "/";
+}
+function isNonEmptyURL(url) {
+	return url && url !== "/";
+}
+function joinURL(base, ...input) {
+	let url = base || "";
+	for (const segment of input.filter((url2) => isNonEmptyURL(url2))) if (url) {
+		const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
+		url = withTrailingSlash(url) + _segment;
+	} else url = segment;
+	return url;
+}
+const protocolRelative = Symbol.for("ufo:protocolRelative");
+function parseURL(input = "", defaultProto) {
+	const _specialProtoMatch = input.match(/^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i);
+	if (_specialProtoMatch) {
+		const [, _proto, _pathname = ""] = _specialProtoMatch;
+		return {
+			protocol: _proto.toLowerCase(),
+			pathname: _pathname,
+			href: _proto + _pathname,
+			auth: "",
+			host: "",
+			search: "",
+			hash: ""
+		};
 	}
-	const searchParams = new URLSearchParams(input.slice(searchIndex + 1));
-	const base = input.slice(0, searchIndex);
-	for (const [key, value] of Object.entries(query)) if (value === void 0) searchParams.delete(key);
-	else if (Array.isArray(value)) for (const item of value) searchParams.append(key, normalizeQueryValue(item));
-	else searchParams.set(key, normalizeQueryValue(value));
-	const queryString = searchParams.toString();
-	return queryString ? `${base}?${queryString}` : base;
-}
-function normalizeQueryValue(value) {
-	if (value === null) return "";
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (typeof value === "object") return JSON.stringify(value);
-	return String(value);
+	if (!hasProtocol(input, { acceptRelative: true })) return defaultProto ? parseURL(defaultProto + input) : parsePath(input);
+	const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
+	let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
+	if (protocol === "file:") path = path.replace(/\/(?=[A-Za-z]:)/, "");
+	const { pathname, search, hash } = parsePath(path);
+	return {
+		protocol: protocol.toLowerCase(),
+		auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
+		host,
+		pathname,
+		search,
+		hash,
+		[protocolRelative]: !protocol
+	};
+}
+function parsePath(input = "") {
+	const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
+	return {
+		pathname,
+		search,
+		hash
+	};
+}
+function stringifyParsedURL(parsed) {
+	const pathname = parsed.pathname || "";
+	const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
+	const hash = parsed.hash || "";
+	const auth = parsed.auth ? parsed.auth + "@" : "";
+	const host = parsed.host || "";
+	return (parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "") + auth + host + pathname + search + hash;
 }
+//#endregion
+//#region ../../node_modules/.pnpm/ofetch@1.5.1/node_modules/ofetch/dist/shared/ofetch.CWycOUEr.mjs
 var FetchError = class extends Error {
 	constructor(message, opts) {
 		super(message, opts);
@@ -146,8 +310,8 @@ function detectResponseType(_contentType = "") {
 	if (textTypes.has(contentType) || contentType.startsWith("text/")) return "text";
 	return "blob";
 }
-function resolveFetchOptions(request, input, defaults, Headers$1) {
-	const headers = mergeHeaders(input?.headers ?? request?.headers, defaults?.headers, Headers$1);
+function resolveFetchOptions(request, input, defaults, Headers) {
+	const headers = mergeHeaders(input?.headers ?? request?.headers, defaults?.headers, Headers);
 	let query;
 	if (defaults?.query || defaults?.params || input?.params || input?.query) query = {
 		...defaults?.params,
@@ -163,15 +327,17 @@ function resolveFetchOptions(request, input, defaults, Headers$1) {
 		headers
 	};
 }
-function mergeHeaders(input, defaults, Headers$1) {
-	if (!defaults) return new Headers$1(input);
-	const headers = new Headers$1(defaults);
-	if (input) for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers$1(input)) headers.set(key, value);
+function mergeHeaders(input, defaults, Headers) {
+	if (!defaults) return new Headers(input);
+	const headers = new Headers(defaults);
+	if (input) for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) headers.set(key, value);
 	return headers;
 }
 async function callHooks(context, hooks) {
-	if (hooks) if (Array.isArray(hooks)) for (const hook of hooks) await hook(context);
-	else await hooks(context);
+	if (hooks) {
+		if (Array.isArray(hooks)) for (const hook of hooks) await hook(context);
+		else await hooks(context);
+	}
 }
 const retryStatusCodes = /* @__PURE__ */ new Set([
 	408,
@@ -190,7 +356,7 @@ const nullBodyResponses = /* @__PURE__ */ new Set([
 	304
 ]);
 function createFetch(globalOptions = {}) {
-	const { fetch: fetch$1 = globalThis.fetch } = globalOptions;
+	const { fetch = globalThis.fetch, Headers = globalThis.Headers, AbortController = globalThis.AbortController } = globalOptions;
 	async function onError(context) {
 		const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
 		if (context.options.retry !== false && !isAbort) {
@@ -211,7 +377,7 @@ function createFetch(globalOptions = {}) {
 		if (Error.captureStackTrace) Error.captureStackTrace(error, $fetchRaw);
 		throw error;
 	}
-	const $fetchRaw = async function $fetchRaw$1(_request, _options = {}) {
+	const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
 		const context = {
 			request: _request,
 			options: resolveFetchOptions(_request, _options, globalOptions.defaults, Headers),
@@ -219,7 +385,10 @@ function createFetch(globalOptions = {}) {
 			error: void 0
 		};
 		if (context.options.method) context.options.method = context.options.method.toUpperCase();
-		if (context.options.onRequest) await callHooks(context, context.options.onRequest);
+		if (context.options.onRequest) {
+			await callHooks(context, context.options.onRequest);
+			if (!(context.options.headers instanceof Headers)) context.options.headers = new Headers(context.options.headers || {});
+		}
 		if (typeof context.request === "string") {
 			if (context.options.baseURL) context.request = withBase(context.request, context.options.baseURL);
 			if (context.options.query) {
@@ -233,30 +402,39 @@ function createFetch(globalOptions = {}) {
 			if (isJSONSerializable(context.options.body)) {
 				const contentType = context.options.headers.get("content-type");
 				if (typeof context.options.body !== "string") context.options.body = contentType === "application/x-www-form-urlencoded" ? new URLSearchParams(context.options.body).toString() : JSON.stringify(context.options.body);
-				context.options.headers = new Headers(context.options.headers || {});
 				if (!contentType) context.options.headers.set("content-type", "application/json");
 				if (!context.options.headers.has("accept")) context.options.headers.set("accept", "application/json");
 			} else if ("pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || typeof context.options.body.pipe === "function") {
 				if (!("duplex" in context.options)) context.options.duplex = "half";
 			}
 		}
-		if (context.options.timeout) context.options.signal = context.options.signal ? AbortSignal.any([AbortSignal.timeout(context.options.timeout), context.options.signal]) : AbortSignal.timeout(context.options.timeout);
+		let abortTimeout;
+		if (!context.options.signal && context.options.timeout) {
+			const controller = new AbortController();
+			abortTimeout = setTimeout(() => {
+				const error = /* @__PURE__ */ new Error("[TimeoutError]: The operation was aborted due to timeout");
+				error.name = "TimeoutError";
+				error.code = 23;
+				controller.abort(error);
+			}, context.options.timeout);
+			context.options.signal = controller.signal;
+		}
 		try {
-			context.response = await fetch$1(context.request, context.options);
+			context.response = await fetch(context.request, context.options);
 		} catch (error) {
 			context.error = error;
 			if (context.options.onRequestError) await callHooks(context, context.options.onRequestError);
 			return await onError(context);
+		} finally {
+			if (abortTimeout) clearTimeout(abortTimeout);
 		}
 		if ((context.response.body || context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD") {
 			const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
 			switch (responseType) {
 				case "json": {
 					const data = await context.response.text();
-					if (data) {
-						const parseFunction = context.options.parseResponse || JSON.parse;
-						context.response._data = parseFunction(data);
-					}
+					const parseFunction = context.options.parseResponse || destr;
+					context.response._data = parseFunction(data);
 					break;
 				}
 				case "stream":
@@ -272,12 +450,12 @@ function createFetch(globalOptions = {}) {
 		}
 		return context.response;
 	};
-	const $fetch$1 = async function $fetch$2(request, options) {
+	const $fetch = async function $fetch2(request, options) {
 		return (await $fetchRaw(request, options))._data;
 	};
-	$fetch$1.raw = $fetchRaw;
-	$fetch$1.native = (...args) => fetch$1(...args);
-	$fetch$1.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+	$fetch.raw = $fetchRaw;
+	$fetch.native = (...args) => fetch(...args);
+	$fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
 		...globalOptions,
 		...customGlobalOptions,
 		defaults: {
@@ -286,11 +464,25 @@ function createFetch(globalOptions = {}) {
 			...defaultOptions
 		}
 	});
-	return $fetch$1;
+	return $fetch;
 }
 //#endregion
-//#region src/client/fetch.ts
-const $fetch = createFetch({ fetch: globalThis.fetch ? (...args) => globalThis.fetch(...args) : () => Promise.reject(/* @__PURE__ */ new Error("[ofetch] global.fetch is not supported!")) });
+//#region ../../node_modules/.pnpm/ofetch@1.5.1/node_modules/ofetch/dist/index.mjs
+const _globalThis = (function() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+	throw new Error("unable to locate global object");
+})();
+const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(/* @__PURE__ */ new Error("[ofetch] global.fetch is not supported!"));
+const Headers = _globalThis.Headers;
+const AbortController = _globalThis.AbortController;
+const $fetch = createFetch({
+	fetch,
+	Headers,
+	AbortController
+});
 //#endregion
 //#region src/client/plugin.ts
 /**

package/dist/node/index.d.mts

@@ -8,54 +8,54 @@ import { NitroPluginConfig } from "nitro/vite";
 import Checker from "vite-plugin-checker";
 import { TSConfig } from "pkg-types";
 //#region src/node/types/layer.d.ts
-interface VixtConfigLayerMeta extends ConfigLayerMeta {
+export interface VixtConfigLayerMeta extends ConfigLayerMeta {
   /** layer name */
   name?: string;
   /** layer alias */
   alias?: string;
 }
-interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
+export interface VixtConfigLayer extends ConfigLayer<VixtOptions, VixtConfigLayerMeta> {
   /** when layer is in node_modules, layer will copy to `<buildLayersDir>/<layerName>`, and change cwd */
   cwd?: string;
 }
-interface LoadVixtConfigOptions extends LoadConfigOptions<VixtOptions, VixtConfigLayerMeta> {}
-interface ResolvedVixtConfig extends ResolvedConfig<VixtOptions, VixtConfigLayerMeta> {}
+export interface LoadVixtConfigOptions extends LoadConfigOptions<VixtOptions, VixtConfigLayerMeta> {}
+export interface ResolvedVixtConfig extends ResolvedConfig<VixtOptions, VixtConfigLayerMeta> {}
 //#endregion
 //#region src/node/types/vixt.d.ts
-interface Vixt {
+export interface Vixt {
   options: VixtOptions;
   _layers: VixtConfigLayer[];
   _modules: VixtModule[];
 }
-type ExtractPluginOptions<Options = any> = Options extends ((...args: any[]) => any) ? Parameters<Options>[0] : Options;
+export type ExtractPluginOptions<Options = any> = Options extends ((...args: any[]) => any) ? Parameters<Options>[0] : Options;
 //#endregion
 //#region src/node/types/module.d.ts
-type ModuleOptions = Record<string, any>;
-interface ModuleMeta extends Record<string, any> {
+export type ModuleOptions = Record<string, any>;
+export interface ModuleMeta extends Record<string, any> {
   name?: string;
   configKey?: string;
 }
-interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
+export interface ModuleDefinition<T extends ModuleOptions = ModuleOptions> {
   meta?: ModuleMeta;
   defaults?: Partial<T> | ((vixt: Vixt) => Partial<T>);
   setup?: (this: void, resolvedOptions: T, vixt: Vixt) => PluginOption | void;
 }
-interface VixtModule<T extends ModuleOptions = ModuleOptions> {
+export interface VixtModule<T extends ModuleOptions = ModuleOptions> {
   (this: void, resolvedOptions: T, vixt: Vixt): PluginOption;
   getOptions?: (inlineOptions: Partial<T>, Vixt: Vixt) => T;
   getMeta?: () => ModuleMeta;
 }
 //#endregion
 //#region src/node/types/options.d.ts
-interface AliasOptions {
+export interface AliasOptions {
   [find: string]: string;
 }
-interface AppHeadAttrs {
+export interface AppHeadAttrs {
   children?: string;
   injectTo?: HtmlTagDescriptor['injectTo'];
   [key: string]: string | boolean | undefined;
 }
-interface AppHead {
+export interface AppHead {
   title?: AppHeadAttrs[];
   link?: AppHeadAttrs[];
   meta?: AppHeadAttrs[];
@@ -63,7 +63,7 @@ interface AppHead {
   script?: AppHeadAttrs[];
   noscript?: AppHeadAttrs[];
 }
-interface AppOptions {
+export interface AppOptions {
   /**
    * The base path of your Vixt application.
    * @default '/'
@@ -175,7 +175,7 @@ interface AppOptions {
    */
   transformIndexHtml?: boolean;
 }
-interface BuildOptions {
+export interface BuildOptions {
   /**
    * Set to true to enable bundle analysis, or pass an object with `enabled: true` and options: [vite-bundle-analyzer](https://github.com/nonzzz/vite-bundle-analyzer)
    */
@@ -189,7 +189,7 @@ interface BuildOptions {
     enabled?: boolean;
   });
 }
-interface DevServerOptions extends Pick<ServerOptions, 'port' | 'host' | 'cors'> {
+export interface DevServerOptions extends Pick<ServerOptions, 'port' | 'host' | 'cors'> {
   /**
    * Whether to enable HTTPS by using [@vitejs/plugin-basic-ssl](https://github.com/vitejs/vite-plugin-basic-ssl).
    * @default false
@@ -202,12 +202,12 @@ interface DevServerOptions extends Pick<ServerOptions, 'port' | 'host' | 'cors'>
    */
   watch?: string[];
 }
-interface ImportsOptions extends ExtractPluginOptions<typeof AutoImport> {}
-interface NitroOptions extends Omit<NitroPluginConfig, 'serverDir'> {
+export interface ImportsOptions extends ExtractPluginOptions<typeof AutoImport> {}
+export interface NitroOptions extends Omit<NitroPluginConfig, 'serverDir'> {
   enabled?: boolean;
   serverDir?: Exclude<NitroPluginConfig['serverDir'], boolean>;
 }
-interface TypescriptOptions {
+export interface TypescriptOptions {
   references?: (string | {
     path?: string;
     content?: string;
@@ -246,7 +246,7 @@ interface TypescriptOptions {
 }
 //#endregion
 //#region src/node/types/config.d.ts
-interface VixtConfig {
+export interface VixtConfig {
   /**
    * You can improve your DX by defining additional aliases to access custom directories within your JavaScript and CSS.
    * @default
@@ -386,7 +386,7 @@ interface VixtConfig {
  * it includes some properties that declared in `VueVixtOptions`, `ReactVixtOptions`, etc.,
  * see {@link VixtConfig} to view the common options.
  */
-interface VixtOptions extends VixtConfig {
+export interface VixtOptions extends VixtConfig {
   /** custom options */
   [key: string]: any;
 }
@@ -404,27 +404,27 @@ interface VixtOptions extends VixtConfig {
  * })
  * ```
  */
-declare function defineVixtConfig(input: VixtOptions): VixtOptions;
-declare function loadVixtConfig(opts?: LoadVixtConfigOptions): Promise<ResolvedVixtConfig>;
-declare function applyLayers({ config, layers }: ResolvedVixtConfig): VixtConfigLayer[];
-declare function isSamePath(a: string, b: string): boolean;
-declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
+export declare function defineVixtConfig(input: VixtOptions): VixtOptions;
+export declare function loadVixtConfig(opts?: LoadVixtConfigOptions): Promise<ResolvedVixtConfig>;
+export declare function applyLayers({ config, layers }: ResolvedVixtConfig): VixtConfigLayer[];
+export declare function isSamePath(a: string, b: string): boolean;
+export declare function resolveLayersDirs(layers?: VixtConfigLayer[]): Record<string, string[] | undefined>;
 //#endregion
 //#region src/node/env.d.ts
-declare function loadCLIOptions(): Partial<import("@vixt/cli").VixtArgs>;
-declare function loadMode(): string | undefined;
+export declare function loadCLIOptions(): Partial<import("@vixt/cli").VixtArgs>;
+export declare function loadMode(): string | undefined;
 /**
  * Load workspace and cwd env variables by default
  */
-declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
+export declare function loadEnv(mode?: string, envDir?: string | false, prefixes?: string | string[]): ImportMeta["env"];
 /**
  * find the workspace dir
  */
-declare function findUpWorkspaceDir(): string | undefined;
+export declare function findUpWorkspaceDir(): string | undefined;
 /**
  * Load workspace env variables
  */
-declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
+export declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]): Record<string, string>;
 //#endregion
 //#region src/node/module.d.ts
 /**
@@ -448,7 +448,7 @@ declare function loadWorkspaceEnv(mode?: string, prefixes?: string | string[]):
  * })
  * ```
  */
-declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
+export declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) => PluginOption): (options?: Options) => PluginOption;
 /**
  * Define a Vixt module.
  * @example
@@ -482,20 +482,19 @@ declare function defineVitePlugin<Options = any>(pluginFn: (options?: Options) =
  * })
  * ```
  */
-declare function defineVixtModule<T extends ModuleOptions = ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
-declare function installModule<T extends ModuleOptions = ModuleOptions>(module: VixtModule<T>, inlineOptions: any, vixt: Vixt): PluginOption;
-declare function applyLayerModules({ config, layers }: ResolvedVixtConfig): Promise<VixtModule[]>;
+export declare function defineVixtModule<T extends ModuleOptions = ModuleOptions>(definition: ModuleDefinition<T> | VixtModule<T>): VixtModule<T>;
+export declare function installModule<T extends ModuleOptions = ModuleOptions>(module: VixtModule<T>, inlineOptions: any, vixt: Vixt): PluginOption;
+export declare function applyLayerModules({ config, layers }: ResolvedVixtConfig): Promise<VixtModule[]>;
 //#endregion
 //#region src/node/modules/index.d.ts
-declare const virtualModuleIds: {
+export declare const virtualModuleIds: {
   appConfig: string | undefined;
   css: string | undefined;
   plugins: string | undefined;
 };
-declare const builtinModules: (VixtModule<ModuleOptions> | VixtModule<AliasOptions> | VixtModule<AppOptions> | VixtModule<BuildOptions> | VixtModule<DevServerOptions> | VixtModule<ImportsOptions> | VixtModule<NitroOptions> | VixtModule<TypescriptOptions>)[];
+export declare const builtinModules: (VixtModule<ModuleOptions> | VixtModule<AliasOptions> | VixtModule<AppOptions> | VixtModule<BuildOptions> | VixtModule<DevServerOptions> | VixtModule<ImportsOptions> | VixtModule<NitroOptions> | VixtModule<TypescriptOptions>)[];
 //#endregion
 //#region src/node/vixt.d.ts
-declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
-declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => import("vite").PluginOption;
-//#endregion
-export { AliasOptions, AppHead, AppHeadAttrs, AppOptions, BuildOptions, DevServerOptions, ExtractPluginOptions, ImportsOptions, LoadVixtConfigOptions, ModuleDefinition, ModuleMeta, ModuleOptions, NitroOptions, ResolvedVixtConfig, TypescriptOptions, Vixt, VixtConfig, VixtConfigLayer, VixtConfigLayerMeta, VixtModule, VixtOptions, applyLayerModules, applyLayers, builtinModules, createVixtPlugin, defineVitePlugin, defineVixtConfig, defineVixtModule, findUpWorkspaceDir, installModule, isSamePath, loadCLIOptions, loadEnv, loadMode, loadVixt, loadVixtConfig, loadWorkspaceEnv, resolveLayersDirs, virtualModuleIds };
+export declare function loadVixt(opts?: LoadConfigOptions<VixtOptions>): Promise<Vixt>;
+export declare function createVixtPlugin(loadOptions: LoadConfigOptions<VixtOptions>): (options?: VixtOptions | undefined) => import("vite").PluginOption;
+//#endregion