revojs 0.1.57 → 0.1.58

package/dist/assets/index.d.ts

@@ -0,0 +1,11 @@
+export type MimeType = (typeof mimeTypes)[keyof typeof mimeTypes];
+export interface Asset {
+    name: string;
+    type: string;
+    relative: string;
+    entityTag: string;
+    lastModified: string;
+    size: number;
+}
+export declare function mimeType(file: string): MimeType;
+export declare const mimeTypes: Record<string, string>;

package/dist/assets/index.js

@@ -0,0 +1,51 @@
+//#region src/assets/index.ts
+function mimeType(file) {
+	return mimeTypes[/\.([a-zA-Z0-9]+?)$/.exec(file)?.at(1) ?? ""] ?? "text/plain";
+}
+var mimeTypes = {
+	"txt": "text/plain",
+	"css": "text/css",
+	"html": "text/html",
+	"htm": "text/html",
+	"js": "text/javascript",
+	"json": "application/json",
+	"xml": "application/xml",
+	"csv": "text/csv",
+	"jpg": "image/jpeg",
+	"jpeg": "image/jpeg",
+	"png": "image/png",
+	"gif": "image/gif",
+	"webp": "image/webp",
+	"svg": "image/svg+xml",
+	"bmp": "image/bmp",
+	"ico": "image/x-icon",
+	"ttf": "font/ttf",
+	"otf": "font/otf",
+	"woff": "font/woff",
+	"woff2": "font/woff2",
+	"mp3": "audio/mpeg",
+	"wav": "audio/wav",
+	"ogg": "audio/ogg",
+	"m4a": "audio/mp4",
+	"mp4": "video/mp4",
+	"webm": "video/webm",
+	"ogv": "video/ogg",
+	"mov": "video/quicktime",
+	"avi": "video/x-msvideo",
+	"zip": "application/zip",
+	"rar": "application/vnd.rar",
+	"tar": "application/x-tar",
+	"gz": "application/gzip",
+	"7z": "application/x-7z-compressed",
+	"pdf": "application/pdf",
+	"doc": "application/msword",
+	"docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	"xls": "application/vnd.ms-excel",
+	"xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+	"ppt": "application/vnd.ms-powerpoint",
+	"pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+	"exe": "application/vnd.microsoft.portable-executable",
+	"apk": "application/vnd.android.package-archive"
+};
+//#endregion
+export { mimeType, mimeTypes };

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { createRunnableDevEnvironment, createServer, isRunnableDevEnvironment } from "vite";
+import { parseArgs } from "util";
+//#region src/cli/index.ts
+function help() {
+	const environmentMeta = new Array();
+	for (const [name, environment] of Object.entries(server.environments)) if (isRunnableDevEnvironment(environment)) environmentMeta.push({
+		name,
+		description: [environment.config.consumer, name === "ssr" ? "default" : void 0].filter(Boolean).join(", ")
+	});
+	const flagMeta = new Array();
+	for (const [name, descriptor] of Object.entries(command?.arguments ?? {})) flagMeta.push({
+		name,
+		description: descriptor.description,
+		multiple: descriptor.multiple,
+		short: descriptor.short,
+		type: descriptor.type
+	});
+	flagMeta.push({
+		name: "help",
+		description: "Show help",
+		short: "h",
+		type: "boolean"
+	}, {
+		name: "environment",
+		description: "Vite dev environment used for command execution",
+		short: "e",
+		type: "string"
+	});
+	const commandMeta = new Array();
+	for (const [name, child] of Object.entries(node.children)) {
+		let target = child;
+		while (target && !target.value) target = Object.values(target.children)[0];
+		commandMeta.push({
+			name,
+			description: target?.value?.description
+		});
+	}
+	environmentMeta.sort((a, b) => a.name.localeCompare(b.name));
+	commandMeta.sort((a, b) => a.name.localeCompare(b.name));
+	const lines = new Array();
+	lines.push(`Usage: ${["revojs", ...path].join(" ")} [flags]${commandMeta.length > 0 ? " [command]" : ""}`);
+	const description = command?.description ?? (path.length === 0 ? "Commands are discovered from ./commands (via the revojs \"commands\" source) and run inside the project's Vite dev server, sharing the same module graph and virtuals." : void 0);
+	if (description) lines.push("", description);
+	lines.push(...section("Environments", environmentMeta), ...section("Flags", flagMeta.map((flag) => ({
+		name: [flag.short ? `-${flag.short}` : void 0, flag.type === "string" ? `--${flag.name}=<value>${flag.multiple ? "..." : ""}` : `--${flag.name}`].filter(Boolean).join(", "),
+		description: flag.description
+	}))), ...section("Commands", commandMeta));
+	console.log(lines.join("\n"));
+}
+function section(title, entries) {
+	if (entries.length === 0) return [];
+	const width = Math.max(...entries.map((entry) => entry.name.length));
+	return [
+		"",
+		`${title}:`,
+		...entries.map((entry) => `  ${entry.name.padEnd(width)}  ${entry.description ?? ""}`.trimEnd())
+	];
+}
+var args = process.argv.slice(2);
+var parsed = parseArgs({
+	args,
+	strict: false,
+	allowPositionals: true,
+	options: {
+		help: {
+			type: "boolean",
+			short: "h",
+			default: false
+		},
+		environment: {
+			type: "string",
+			short: "e"
+		}
+	}
+});
+var server = await createServer({
+	appType: "custom",
+	environments: { command: {
+		consumer: "server",
+		dev: { createEnvironment(name, config) {
+			return createRunnableDevEnvironment(name, config);
+		} }
+	} },
+	server: {
+		middlewareMode: true,
+		hmr: false
+	}
+});
+var environment = typeof parsed.values.environment === "string" ? server.environments[parsed.values.environment] : server.environments.command ?? Object.values(server.environments).find((environment) => isRunnableDevEnvironment(environment) && environment.config.consumer === "server") ?? Object.values(server.environments).find(isRunnableDevEnvironment);
+if (!environment || !isRunnableDevEnvironment(environment)) {
+	await server.close();
+	throw new Error(typeof parsed.values.environment === "string" ? `No runnable environment named "${parsed.values.environment}" found.` : "No runnable Vite environment found.");
+}
+var commands = await environment.runner.import("#commands").then((module) => module.default);
+var radix = { children: {} };
+for (const source of Object.values(commands)) for (const [path, value] of Object.entries(source)) {
+	let node = radix;
+	for (const segment of path.replace(/\\/g, "/").split("/")) node = node.children[segment] ??= { children: {} };
+	node.value = await value();
+}
+var helpRequested = parsed.values.help === true || parsed.positionals[0] === "help";
+var path = new Array();
+var node = radix;
+if (parsed.positionals[0] !== "help") for (const positional of parsed.positionals) {
+	const child = node.children[positional];
+	if (!child) break;
+	node = child;
+	path.push(positional);
+}
+var command = node.value;
+try {
+	if (command && !helpRequested) {
+		const consumable = [...path];
+		const context = parseArgs({
+			args: args.filter((argument) => {
+				const index = consumable.indexOf(argument);
+				if (index === -1) return true;
+				consumable.splice(index, 1);
+				return false;
+			}),
+			strict: false,
+			allowPositionals: true,
+			options: {
+				...command.arguments,
+				help: {
+					type: "boolean",
+					short: "h",
+					description: "Show this help"
+				}
+			}
+		});
+		if (context.values.help) help();
+		else await command.run({
+			args: context.positionals,
+			arguments: context.values,
+			environment
+		});
+	} else {
+		help();
+		process.exitCode = helpRequested || command ? 0 : 1;
+	}
+} catch (error) {
+	console.error(error);
+	process.exitCode = 1;
+} finally {
+	await server.close();
+}
+//#endregion
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./assets";
+export * from "./router";
+export * from "./scope";

package/dist/index.js

@@ -0,0 +1,4 @@
+import { mimeType, mimeTypes } from "./assets/index.js";
+import { VARIABLE_CONTEXT, createRegisterHooks, createScope, defineContext, defineHook, definePlugin, dispatchHook, dispatchHookSingle, getContext, registerHook, setContext, useVariables } from "./scope/index.js";
+import { GROUP_MATCH, HOOK_MATCH, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD_MATCH, PARAMETER_MATCH, ROUTE_CONTEXT, ROUTE_RESOLVER_CONTEXT, Router, WILDCARD_MATCH, fillSegments, toSegments, useRoute } from "./router/index.js";
+export { GROUP_MATCH, HOOK_MATCH, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD_MATCH, PARAMETER_MATCH, ROUTE_CONTEXT, ROUTE_RESOLVER_CONTEXT, Router, VARIABLE_CONTEXT, WILDCARD_MATCH, createRegisterHooks, createScope, defineContext, defineHook, definePlugin, dispatchHook, dispatchHookSingle, fillSegments, getContext, mimeType, mimeTypes, registerHook, setContext, toSegments, useRoute, useVariables };

package/dist/module/index.d.ts

@@ -0,0 +1,108 @@
+import type { parseArgs } from "node:util";
+import { type ParseArgsOptionDescriptor, type ParseArgsOptionsConfig } from "node:util";
+import type { RunnableDevEnvironment } from "vite";
+import { type PluginOption, type UserConfig } from "vite";
+import { type Awaitable, type Mergeable } from "../shared/index.ts";
+export type CommandValues<T extends ParseArgsOptionsConfig> = ReturnType<typeof parseArgs<{
+    options: T;
+    allowPositionals: true;
+    strict: true;
+}>>["values"];
+export type Consumer = "client" | "server";
+export type Template = (consumer: Consumer) => Awaitable<undefined | string>;
+export type Variable = StringVariable | NumberVariable | BooleanVariable | EnumVariable;
+export type InferVariableValue<T extends Variable> = T extends {
+    type: "enum";
+    options: infer Options;
+} ? Extract<Options, ReadonlyArray<unknown>>[number] : T["type"] extends "string" ? string : T["type"] extends "number" ? number : boolean;
+export type OptionalVariable<T extends Variable> = T extends {
+    optional: true;
+} ? T extends {
+    default: infer Default;
+} ? [Default] extends [undefined] ? undefined : never : undefined : never;
+export type InferVariables<T extends Record<string, Variable>> = {
+    [Key in keyof T]: T[Key] extends Record<string, Variable> ? InferVariables<T[Key]> : InferVariableValue<T[Key]> | OptionalVariable<T[Key]>;
+};
+export type UnionToIntersection<TUnion> = (TUnion extends unknown ? (arg: TUnion) => void : never) extends (arg: infer TIntersection) => void ? TIntersection : never;
+export type InferModuleConfig<TModule> = TModule extends Module<infer TName extends string, infer TConfig, infer TDependencies extends ReadonlyArray<Module>> ? Record<TName, TConfig> & InferModuleConfigs<TDependencies> : never;
+export type InferModuleConfigs<TModules extends ReadonlyArray<Module>> = Partial<UnionToIntersection<InferModuleConfig<TModules[number]>>>;
+export type ModuleInput<TModules extends ReadonlyArray<Module>> = Mergeable<Config> & InferModuleConfigs<TModules> & {
+    modules?: TModules;
+};
+export type ModuleSetupResult<TName extends string, TConfig, TDependencies extends ReadonlyArray<Module> = []> = void | (Mergeable<Config> & Mergeable<Record<TName, TConfig>> & Mergeable<InferModuleConfigs<TDependencies>>);
+export interface CommandArgument extends ParseArgsOptionDescriptor {
+    description?: string;
+}
+export type CommandArguments = ParseArgsOptionsConfig & Record<string, CommandArgument>;
+export interface CommandContext<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
+    args: Array<string>;
+    arguments: CommandValues<T>;
+    environment: RunnableDevEnvironment;
+}
+export interface Command<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
+    description?: string;
+    arguments?: T;
+    run: (context: CommandContext<T>) => Awaitable<void>;
+}
+export interface Source {
+    match: Array<string>;
+    from: Array<string>;
+}
+export interface StringVariable {
+    type: "string";
+    default?: string;
+    optional?: boolean;
+}
+export interface NumberVariable {
+    type: "number";
+    default?: number;
+    optional?: boolean;
+}
+export interface BooleanVariable {
+    type: "boolean";
+    default?: boolean;
+    optional?: boolean;
+}
+export interface EnumVariable {
+    type: "enum";
+    options: Array<string>;
+    default?: string;
+    optional?: boolean;
+}
+export interface Config {
+    copy: Array<string>;
+    modules: Array<Module>;
+    variables: Record<Consumer, Record<string, Variable>>;
+    sources: Record<string, Source>;
+    virtuals: Record<string, Template>;
+    templates: Record<string, Template>;
+    vite: UserConfig;
+}
+export interface Module<TName extends string = string, TConfig = unknown, TDependencies extends ReadonlyArray<unknown> = ReadonlyArray<unknown>> {
+    name: TName;
+    config?: () => TConfig;
+    modules?: TDependencies & ReadonlyArray<Module>;
+    setup: (config: Config) => Awaitable<void | Mergeable<Config>>;
+}
+export interface ModuleDefinition<TName extends string, TConfig = Record<string, never>, TDependencies extends ReadonlyArray<Module> = []> {
+    name: TName;
+    config?: () => TConfig;
+    modules?: TDependencies;
+    setup: (config: Config & Record<TName, TConfig> & InferModuleConfigs<TDependencies>) => Awaitable<ModuleSetupResult<TName, TConfig, TDependencies>>;
+}
+export declare function defineCommand<const T extends ParseArgsOptionsConfig>(command: Command<T>): Command<T>;
+export declare function defineModule<const TName extends string, TConfig = Record<string, never>, const TDependencies extends ReadonlyArray<Module> = []>(definition: ModuleDefinition<TName, TConfig, TDependencies>): Module<TName, TConfig, TDependencies>;
+export declare function addVirtual(config: Config, name: string, virtual: Template): void;
+export declare function addTemplate(config: Config, name: string, template: Template): void;
+export declare function addTypes(config: Config, name: string, types: Template): void;
+export declare function posixPath(path: string): string;
+export declare function resolvePattern(pattern: string, cwd?: string): string[];
+export declare function resolvePaths(patterns: string | ArrayLike<string>, cwd?: string): string[];
+export declare function resolveSource(source: Source): Map<string, Map<string, string>>;
+export declare function useModule(source: string | URL): {
+    fromModule: (...paths: Array<string>) => string;
+};
+export declare function createConfig<const TModules extends ReadonlyArray<Module>>(inputConfig?: ModuleInput<TModules>): Promise<Config>;
+export declare function core(config: Config): Promise<Array<PluginOption>>;
+export declare function module<const TModules extends ReadonlyArray<Module>>(inputConfig?: ModuleInput<TModules>): Promise<Array<PluginOption>>;
+export declare function revojs<const TModules extends ReadonlyArray<Module>>(inputConfig?: ModuleInput<TModules>): Promise<Array<PluginOption>>;

package/dist/module/index.js

@@ -0,0 +1,306 @@
+import { mimeType } from "../assets/index.js";
+import { mergeObjects } from "../shared/index.js";
+import package_default from "../package.js";
+import { findPackageJSON } from "node:module";
+import { spawnSync } from "child_process";
+import { copyFileSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import { globSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { dirname, extname, isAbsolute, join, posix, relative, resolve, win32 } from "path";
+import { fileURLToPath } from "url";
+import "vite";
+//#region src/module/index.ts
+function defineCommand(command) {
+	return command;
+}
+function defineModule(definition) {
+	return definition;
+}
+function addVirtual(config, name, virtual) {
+	config.virtuals[name] = virtual;
+}
+function addTemplate(config, name, template) {
+	config.templates[name] = template;
+}
+function addTypes(config, name, types) {
+	addTemplate(config, `types/${name}.d.ts`, types);
+}
+function posixPath(path) {
+	return path.split(win32.sep).join(posix.sep);
+}
+function resolvePattern(pattern, cwd) {
+	const from = resolve(cwd ?? ".");
+	const files = new Array();
+	for (const match of globSync(pattern, { cwd: from })) {
+		const file = join(from, match);
+		if (statSync(file).isFile()) files.push(posixPath(file));
+	}
+	return files;
+}
+function resolvePaths(patterns, cwd) {
+	const from = resolve(cwd ?? ".");
+	const input = Array.isArray(patterns) ? patterns : [patterns];
+	const entries = /* @__PURE__ */ new Set();
+	const includes = new Array();
+	const excludes = new Array();
+	for (const pattern of input) if (pattern.startsWith("!")) excludes.push(pattern.slice(1));
+	else includes.push(pattern);
+	try {
+		for (const include of includes) for (const file of resolvePattern(include, from)) entries.add(file);
+		for (const exclude of excludes) for (const file of resolvePattern(exclude, from)) entries.delete(file);
+	} catch {
+		return [];
+	}
+	return [...entries];
+}
+function resolveSource(source) {
+	const scopes = /* @__PURE__ */ new Map();
+	for (const directory of source.from) {
+		const from = resolve(directory);
+		const paths = resolvePaths(source.match, from);
+		if (paths.length === 0) continue;
+		let scope = PACKAGE_CACHE.get(from);
+		if (scope === void 0) {
+			const path = findPackageJSON(pathToFileURL(from).href);
+			if (path === void 0) throw new Error(`Unable to resolve package.json for ${from}`);
+			const manifest = JSON.parse(readFileSync(path, "utf8"));
+			if (typeof manifest.name !== "string" || manifest.name.length === 0) throw new Error(`Missing "name" field in ${path}`);
+			scope = manifest.name;
+			PACKAGE_CACHE.set(from, scope);
+		}
+		let files = scopes.get(scope);
+		if (files === void 0) {
+			files = /* @__PURE__ */ new Map();
+			scopes.set(scope, files);
+		}
+		for (const file of paths) files.set(posixPath(relative(from, file)).replace(/\.[^/]+$/, ""), file);
+	}
+	return scopes;
+}
+function useModule(source) {
+	source = source.toString();
+	if (source.startsWith("file://")) source = dirname(fileURLToPath(source));
+	return { fromModule: (...paths) => {
+		return posixPath(join(source, ...paths));
+	} };
+}
+async function createConfig(inputConfig) {
+	const { fromModule } = useModule(import.meta.url);
+	const defaultConfig = {
+		copy: [],
+		modules: [],
+		variables: {
+			client: {
+				isServer: {
+					type: "boolean",
+					default: false
+				},
+				isClient: {
+					type: "boolean",
+					default: true
+				}
+			},
+			server: {
+				isServer: {
+					type: "boolean",
+					default: true
+				},
+				isClient: {
+					type: "boolean",
+					default: false
+				}
+			}
+		},
+		sources: {
+			plugins: {
+				match: ["**/*.{js,ts}", "!**/*.d.ts"],
+				from: ["./plugins"]
+			},
+			commands: {
+				match: ["**/*.{js,ts}", "!**/*.d.ts"],
+				from: ["./commands", fromModule("../../cli/commands")]
+			}
+		},
+		templates: {},
+		virtuals: {},
+		vite: {}
+	};
+	let config = mergeObjects(inputConfig, defaultConfig);
+	let index = 0;
+	while (index < config.modules.length) {
+		const module = config.modules[index];
+		config = mergeObjects(config, { [module.name]: module.config?.() ?? {} });
+		const result = await module.setup(config);
+		if (result) config = mergeObjects(config, result);
+		if (module.modules) config.modules.push(...module.modules);
+		index++;
+	}
+	for (const module of config.modules) {
+		const value = JSON.stringify(config[module.name] ?? {});
+		addVirtual(config, `config/${module.name}`, () => `export default ${value}`);
+		addTypes(config, `config/${module.name}`, () => `declare module "#config/${module.name}" { const config: ${value}; export default config; }`);
+	}
+	addTypes(config, "vite", () => "import 'vite/client'");
+	addTypes(config, "revojs", () => `import '${fromModule("../types/index.d.ts")}'`);
+	return config;
+}
+async function core(config) {
+	return [{
+		name: package_default.name + "-core",
+		async config() {
+			for (const [name, source] of Object.entries(config.sources)) {
+				const resolved = resolveSource(source);
+				addVirtual(config, name, () => {
+					const cwd = posixPath(resolve("."));
+					return `export default { ${[...resolved].map(([scope, files]) => {
+						return `"${scope}": { ${[...files].map(([key, path]) => {
+							const entry = posixPath(relative(cwd, path));
+							return `"${key}": () => import("${entry.startsWith(".") ? entry : "./" + entry}").then((module) => module.default)`;
+						}).join(",")} }`;
+					}).join(",")} }`;
+				});
+				addTypes(config, name, () => {
+					const scopes = [...resolved].map(([scope, files]) => {
+						return `"${scope}":{ ${[...files].map(([key, path]) => `"${key}": () => Promise<typeof import("${posixPath(path)}").default>`).join(";")} }`;
+					});
+					return `declare module "#${name}" { type Entries = { ${scopes.join(";")} }; const entries: Entries; export default entries; }`;
+				});
+			}
+			addVirtual(config, "variables", (consumer) => {
+				const variables = config.variables[consumer];
+				return `${Object.entries(variables).map(([name, variable]) => `export const ${name} = ${variable.default};`).join(" ")} export default ${JSON.stringify(variables)}`;
+			});
+			addTypes(config, "variables", () => {
+				const exports = /* @__PURE__ */ new Map();
+				for (const variables of Object.values(config.variables)) for (const [name, variable] of Object.entries(variables)) exports.set(name, `export const ${name}: InferVariableValue<${JSON.stringify(variable)}> | OptionalVariable<${JSON.stringify(variable)}>;`);
+				return `declare module "#variables" { import type { InferVariableValue, OptionalVariable } from "revojs/module"; ${[...exports.values()].join(" ")}; const entries: Record<string, Variable>; export default entries; }`;
+			});
+			addTemplate(config, "index.d.ts", () => {
+				return Object.keys(config.templates).reduce((content, name) => {
+					if (name.startsWith("types/")) content += `import "./${name}" \n`;
+					return content;
+				}, "");
+			});
+			return mergeObjects({ server: { watch: { ignored: [`**/.${package_default.name}/**`] } } }, config.vite);
+		},
+		async buildStart() {
+			const meta = resolve("." + package_default.name);
+			rmSync(meta, {
+				recursive: true,
+				force: true
+			});
+			for (const template in config.templates) {
+				const content = await config.templates[template](this.environment.config.consumer);
+				if (content) {
+					const path = join(meta, template);
+					mkdirSync(dirname(path), { recursive: true });
+					writeFileSync(path, content);
+				}
+			}
+		},
+		resolveId(key) {
+			if (key.startsWith("#") && key.slice(1) in config.virtuals) return `\0${key.slice(1)}`;
+		},
+		async load(key) {
+			if (key.startsWith("\0")) {
+				const virtual = config.virtuals[key.slice(1)];
+				return await virtual?.(this.environment.config.consumer);
+			}
+		}
+	}, config.vite.plugins];
+}
+async function module(inputConfig) {
+	const config = await createConfig(inputConfig);
+	const copiedFiles = new Set(resolvePaths(config.copy, "./src"));
+	const copiedExtensions = new Set([...copiedFiles].map((file) => extname(file)));
+	return [await core(config), {
+		name: package_default.name + "-module",
+		config() {
+			return {
+				builder: {
+					sharedConfigBuild: true,
+					async buildApp(builder) {
+						await builder.build(builder.environments.module);
+					}
+				},
+				environments: { module: { build: { rolldownOptions: {
+					input: resolvePaths(["./src/**/*.*", "!./src/**/*.d.ts"]).filter((file) => !copiedFiles.has(file)),
+					external: (key) => !key.startsWith(".") && !isAbsolute(key) || key.startsWith("#") || copiedExtensions.has(extname(key)),
+					output: {
+						preserveModules: true,
+						preserveModulesRoot: resolve("src"),
+						sanitizeFileName: (name) => name.replace(/\0/g, "").replace(/\?.*$/, "")
+					}
+				} } } }
+			};
+		},
+		closeBundle() {
+			let path;
+			try {
+				path = join(dirname(createRequire(import.meta.url).resolve("typescript/package.json")), "lib", "tsc.js");
+			} catch {
+				return;
+			}
+			spawnSync(process.execPath, [
+				path,
+				"--noEmit",
+				"false",
+				"--declaration",
+				"--emitDeclarationOnly"
+			], { stdio: "inherit" });
+			for (const file of resolvePaths(config.copy, "./src")) {
+				const output = join(resolve("dist"), relative(resolve("src"), file));
+				mkdirSync(dirname(output), { recursive: true });
+				copyFileSync(file, output);
+			}
+			for (const file of resolvePaths("./src/**/*.d.ts")) {
+				const output = join(resolve("dist"), relative(resolve("src"), file));
+				mkdirSync(dirname(output), { recursive: true });
+				copyFileSync(file, output);
+			}
+		}
+	}];
+}
+async function revojs(inputConfig) {
+	const config = await createConfig(inputConfig);
+	return [await core(config), {
+		name: package_default.name,
+		config() {
+			return mergeObjects({
+				appType: config.modules.length === 0 ? "spa" : "custom",
+				builder: {
+					sharedConfigBuild: true,
+					async buildApp(builder) {
+						for (const environment of Object.values(builder.environments)) if (environment.config.consumer === "client") await builder.build(environment);
+						for (const environment of Object.values(builder.environments)) if (environment.config.consumer === "server") await builder.build(environment);
+					}
+				}
+			}, config.vite);
+		},
+		configResolved(viteConfig) {
+			addVirtual(config, "assets", () => {
+				const assets = new Array();
+				for (const key in viteConfig.environments) {
+					const environment = viteConfig.environments[key];
+					if (environment.consumer === "client") for (const path of resolvePaths("**/*", environment.build.outDir)) {
+						const meta = statSync(path);
+						const name = posixPath(relative(environment.build.outDir, path));
+						assets.push({
+							name,
+							type: mimeType(path),
+							relative: `./client/${name}`,
+							entityTag: `W/"${meta.size.toString(16)}-${Math.floor(meta.mtimeMs).toString(16)}"`,
+							lastModified: meta.mtime.toJSON(),
+							size: meta.size
+						});
+					}
+				}
+				return `export default { ${assets.map((asset) => `"/${asset.name}": ${JSON.stringify(asset)}`).join(",")} }`;
+			});
+		}
+	}];
+}
+var PACKAGE_CACHE = /* @__PURE__ */ new Map();
+//#endregion
+export { addTemplate, addTypes, addVirtual, core, createConfig, defineCommand, defineModule, module, posixPath, resolvePaths, resolvePattern, resolveSource, revojs, useModule };