revojs 0.1.57 → 0.1.59

package/dist/package.js

@@ -0,0 +1,62 @@
+//#region package.json
+var name = "revojs";
+var version = "0.1.59";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/tellua/revojs.git"
+};
+var bin = { "revojs": "dist/cli/index.js" };
+var files = ["dist", "src/types"];
+var type = "module";
+var main = "./dist/index.js";
+var module = "./dist/index.js";
+var types = "./dist/index.d.ts";
+var exports = {
+	".": {
+		"types": "./dist/index.d.ts",
+		"import": "./dist/index.js"
+	},
+	"./module": {
+		"types": "./dist/module/index.d.ts",
+		"import": "./dist/module/index.js"
+	},
+	"./shared": {
+		"types": "./dist/shared/index.d.ts",
+		"import": "./dist/shared/index.js"
+	}
+};
+var scripts = {
+	"build": "vite build",
+	"typecheck": "tsc --noEmit -p tsconfig.json",
+	"watch": "vite build --watch"
+};
+var dependencies = {
+	"@standard-schema/spec": "^1.1.0",
+	"rolldown": "^1.2.8",
+	"vite": "^8.3.0"
+};
+var devDependencies = {
+	"@revojs/tsconfig": "*",
+	"@types/node": "^26.4.1"
+};
+var optionalDependencies = { "typescript": "^7.0.2" };
+var package_default = {
+	name,
+	version,
+	license: "MIT",
+	repository,
+	bin,
+	files,
+	type,
+	sideEffects: false,
+	main,
+	module,
+	types,
+	exports,
+	scripts,
+	dependencies,
+	devDependencies,
+	optionalDependencies
+};
+//#endregion
+export { bin, package_default as default, dependencies, devDependencies, exports, files, main, module, name, optionalDependencies, repository, scripts, type, types, version };

package/dist/router/index.d.ts

@@ -0,0 +1,43 @@
+import { type Scope } from "../scope";
+import { type Awaitable } from "../shared";
+export type NodeType = "PATH" | "PARAMETER" | "OPTIONAL-PARAMETER" | "WILDCARD" | "OPTIONAL-WILDCARD" | "GROUP";
+export type RouteResolver = (segments: Array<string>) => Awaitable<Array<string> | false>;
+export interface Node<T> {
+    type: NodeType;
+    name: string;
+    value?: T;
+    hooks: Array<T>;
+    parameter?: Node<T>;
+    optionalParameter?: Node<T>;
+    wildcard?: Node<T>;
+    optionalWildcard?: Node<T>;
+    groups: Map<string, Node<T>>;
+    children: Map<string, Node<T>>;
+}
+export interface RouteContext {
+    segments: Array<string>;
+    parameters: Record<string, string>;
+    groups: Array<string>;
+}
+export interface RouterContext<T> extends RouteContext {
+    match?: T;
+    hooks: Array<T>;
+}
+export declare class Router<T> {
+    readonly rootNode: Node<T>;
+    constructor(rootNode?: Node<T>);
+    use(segments: Array<string>, value: T): Node<T>;
+    match(segments: Array<string>): RouterContext<T>;
+    resolve(scope: Scope, segments: Array<string>): Promise<RouterContext<T>>;
+}
+export declare function toSegments(route: string): string[];
+export declare function fillSegments(segments: Array<string>, parameters: Record<string, string>): string[];
+export declare function useRoute(scope: Scope): RouteContext;
+export declare const ROUTE_CONTEXT: import("..").Descriptor<RouteContext>;
+export declare const ROUTE_RESOLVER_CONTEXT: import("..").Descriptor<RouteResolver>;
+export declare const WILDCARD_MATCH: RegExp;
+export declare const OPTIONAL_WILDCARD_MATCH: RegExp;
+export declare const PARAMETER_MATCH: RegExp;
+export declare const OPTIONAL_PARAMETER_MATCH: RegExp;
+export declare const GROUP_MATCH: RegExp;
+export declare const HOOK_MATCH: RegExp;

package/dist/router/index.js

@@ -0,0 +1,183 @@
+import { defineContext, getContext, setContext } from "../scope/index.js";
+//#region src/router/index.ts
+var Router = class {
+	rootNode;
+	constructor(rootNode) {
+		this.rootNode = rootNode ?? {
+			type: "PATH",
+			name: "",
+			children: /* @__PURE__ */ new Map(),
+			groups: /* @__PURE__ */ new Map(),
+			hooks: []
+		};
+	}
+	use(segments, value) {
+		let node = this.rootNode;
+		for (const segment of segments) {
+			const optionalWildcard = OPTIONAL_WILDCARD_MATCH.exec(segment)?.[1];
+			if (typeof optionalWildcard === "string") {
+				node.optionalWildcard ??= {
+					type: "OPTIONAL-WILDCARD",
+					name: optionalWildcard,
+					children: /* @__PURE__ */ new Map(),
+					groups: /* @__PURE__ */ new Map(),
+					hooks: []
+				};
+				node = node.optionalWildcard;
+				continue;
+			}
+			const wildcard = WILDCARD_MATCH.exec(segment)?.[1];
+			if (typeof wildcard === "string") {
+				node.wildcard ??= {
+					type: "WILDCARD",
+					name: wildcard,
+					children: /* @__PURE__ */ new Map(),
+					groups: /* @__PURE__ */ new Map(),
+					hooks: []
+				};
+				node = node.wildcard;
+				continue;
+			}
+			const optionalParameter = OPTIONAL_PARAMETER_MATCH.exec(segment)?.[1];
+			if (typeof optionalParameter === "string") {
+				node.optionalParameter ??= {
+					type: "OPTIONAL-PARAMETER",
+					name: optionalParameter,
+					children: /* @__PURE__ */ new Map(),
+					groups: /* @__PURE__ */ new Map(),
+					hooks: []
+				};
+				node = node.optionalParameter;
+				continue;
+			}
+			const parameter = PARAMETER_MATCH.exec(segment)?.[1];
+			if (typeof parameter === "string") {
+				node.parameter ??= {
+					type: "PARAMETER",
+					name: parameter,
+					children: /* @__PURE__ */ new Map(),
+					groups: /* @__PURE__ */ new Map(),
+					hooks: []
+				};
+				node = node.parameter;
+				continue;
+			}
+			const group = GROUP_MATCH.exec(segment)?.[1];
+			if (typeof group === "string") {
+				let child = node.groups.get(group);
+				if (!child) {
+					child = {
+						type: "GROUP",
+						name: group,
+						children: /* @__PURE__ */ new Map(),
+						groups: /* @__PURE__ */ new Map(),
+						hooks: []
+					};
+					node.groups.set(group, child);
+				}
+				node = child;
+				continue;
+			}
+			if (typeof HOOK_MATCH.exec(segment)?.[1] === "string") {
+				node.hooks.push(value);
+				return node;
+			}
+			let child = node.children.get(segment);
+			if (!child) {
+				child = {
+					type: "PATH",
+					name: segment,
+					children: /* @__PURE__ */ new Map(),
+					groups: /* @__PURE__ */ new Map(),
+					hooks: []
+				};
+				node.children.set(segment, child);
+			}
+			node = child;
+		}
+		node.value = value;
+		return node;
+	}
+	match(segments) {
+		const context = {
+			segments,
+			parameters: {},
+			groups: [],
+			hooks: []
+		};
+		visit(this.rootNode, 0, context);
+		return context;
+	}
+	async resolve(scope, segments) {
+		const result = await getContext(scope, ROUTE_RESOLVER_CONTEXT)?.(segments);
+		return setContext(scope, ROUTE_CONTEXT, result ? this.match(result) : {
+			segments,
+			parameters: {},
+			groups: [],
+			hooks: []
+		});
+	}
+};
+function visit(node, index, context, parameter) {
+	const hookCount = context.hooks.length;
+	const groupCount = context.groups.length;
+	if (node.hooks.length > 0) context.hooks.push(...node.hooks);
+	if (node.type === "GROUP") context.groups.push(node.name);
+	if (parameter !== void 0) context.parameters[node.name] = parameter;
+	if (descend(node, index, context)) return true;
+	context.hooks.length = hookCount;
+	context.groups.length = groupCount;
+	if (parameter !== void 0) delete context.parameters[node.name];
+	return false;
+}
+function descend(node, index, context) {
+	if (index === context.segments.length) {
+		if (node.value !== void 0) {
+			context.match = node.value;
+			return true;
+		}
+		for (const group of node.groups.values()) if (visit(group, index, context)) return true;
+		if (node.optionalParameter && visit(node.optionalParameter, index, context)) return true;
+		if (node.optionalWildcard && visit(node.optionalWildcard, index, context, "")) return true;
+		return false;
+	}
+	for (const group of node.groups.values()) if (visit(group, index, context)) return true;
+	const segment = context.segments[index] ?? "";
+	const child = node.children.get(segment);
+	if (child && visit(child, index + 1, context)) return true;
+	if (node.optionalParameter && visit(node.optionalParameter, index, context)) return true;
+	if (node.parameter && visit(node.parameter, index + 1, context, segment)) return true;
+	if (node.optionalParameter && visit(node.optionalParameter, index + 1, context, segment)) return true;
+	if (node.wildcard && visit(node.wildcard, context.segments.length, context, context.segments.slice(index).join("/"))) return true;
+	if (node.optionalWildcard && visit(node.optionalWildcard, context.segments.length, context, context.segments.slice(index).join("/"))) return true;
+	return false;
+}
+function toSegments(route) {
+	return route.split("/").filter((segment) => segment !== "");
+}
+function fillSegments(segments, parameters) {
+	const resolved = new Array();
+	for (const segment of segments) {
+		const name = OPTIONAL_WILDCARD_MATCH.exec(segment)?.[1] ?? WILDCARD_MATCH.exec(segment)?.[1] ?? OPTIONAL_PARAMETER_MATCH.exec(segment)?.[1] ?? PARAMETER_MATCH.exec(segment)?.[1];
+		if (typeof name === "string") {
+			const value = parameters[name];
+			if (value) resolved.push(...value.split("/"));
+			continue;
+		}
+		resolved.push(segment);
+	}
+	return resolved;
+}
+function useRoute(scope) {
+	return getContext(scope, ROUTE_CONTEXT);
+}
+var ROUTE_CONTEXT = defineContext("ROUTE_CONTEXT");
+var ROUTE_RESOLVER_CONTEXT = defineContext("ROUTE_RESOLVER_CONTEXT");
+var WILDCARD_MATCH = /^\[\.\.\.(.*)\]$/;
+var OPTIONAL_WILDCARD_MATCH = /^\[\[\.\.\.(.*)\]\]$/;
+var PARAMETER_MATCH = /^\[(.*)\]$/;
+var OPTIONAL_PARAMETER_MATCH = /^\[\[(.*)\]\]$/;
+var GROUP_MATCH = /^\((.*)\)$/;
+var HOOK_MATCH = /^\+(.+)$/;
+//#endregion
+export { GROUP_MATCH, HOOK_MATCH, OPTIONAL_PARAMETER_MATCH, OPTIONAL_WILDCARD_MATCH, PARAMETER_MATCH, ROUTE_CONTEXT, ROUTE_RESOLVER_CONTEXT, Router, WILDCARD_MATCH, fillSegments, toSegments, useRoute };

package/dist/scope/index.d.ts

@@ -0,0 +1,43 @@
+import { type Awaitable, type Mergeable } from "../shared";
+export type Descriptor<T> = string & {
+    [descriptor]: T;
+};
+export type InferDescriptor<T> = T extends Descriptor<infer U> ? U : never;
+export type Hook = (...inputs: Array<any>) => any;
+export type Hooks<T extends Record<string, Descriptor<Hook>>> = {
+    [Key in keyof T]: InferDescriptor<T[Key]>;
+};
+export type Intersection<T> = (T extends any ? (arg: T) => void : never) extends (arg: infer I) => void ? I : never;
+export type Source<T = unknown> = Record<string, Record<string, () => Promise<T>>>;
+export type SourceScope<TSource extends Source> = Extract<keyof TSource, string>;
+export type SourceValue<TSource extends Source, TScope extends SourceScope<TSource>> = Extract<keyof TSource[TScope], string>;
+export type SourceType<TSource extends Source, TScope extends SourceScope<TSource>> = Intersection<Awaited<ReturnType<TSource[TScope][SourceValue<TSource, TScope>]>>>;
+export type SourceTypeProperty<TSource extends Source, TScope extends SourceScope<TSource>, TProperty extends PropertyKey> = SourceType<TSource, TScope> extends Partial<Record<TProperty, infer TValue>> ? TValue : never;
+export interface Plugin {
+    setup: (scope: Scope) => Awaitable<void>;
+}
+export interface Scope {
+    hooks: Record<string, Array<Hook>>;
+    context: Record<string, unknown>;
+}
+export declare function registerHook<T extends Hook>(scope: Scope, name: Descriptor<T>, invoke: T): () => void;
+export declare function createRegisterHooks<T extends Record<string, Descriptor<Hook>>>(descriptors: T): (scope: Scope, hooks: Hooks<T>) => void;
+export declare function dispatchHook<T extends Hook>(scope: Scope, name: Descriptor<T>, ...inputs: Parameters<T>): Promise<Awaited<ReturnType<T>>[]>;
+export declare function dispatchHookSingle<T extends Hook>(scope: Scope, name: Descriptor<T>, ...inputs: Parameters<T>): Promise<ReturnType<T> | undefined>;
+export declare function getContext<T>(scope: Scope, input: Descriptor<T>): T;
+export declare function setContext<T>(scope: Scope, input: Descriptor<T>, value: T): T;
+export declare function createScope(inputScope?: Mergeable<Scope>): Promise<{
+    hooks?: {
+        [x: string]: ArrayLike<Hook> | undefined;
+    } | undefined;
+    context?: {
+        [x: string]: {} | undefined;
+    } | undefined;
+} & Scope>;
+export declare function useVariables<T = typeof import("#variables")>(scope: Scope): T;
+export declare function definePlugin<T extends Plugin>(plugin: T): T;
+export declare function defineHook<T extends Hook>(name: string): Descriptor<T>;
+export declare function defineContext<T>(name: string): Descriptor<T>;
+export declare const VARIABLE_CONTEXT: Descriptor<unknown>;
+declare const descriptor: unique symbol;
+export {};

package/dist/scope/index.js

@@ -0,0 +1,73 @@
+import { mergeObjects } from "../shared/index.js";
+import plugins from "#plugins";
+import variables from "#variables";
+//#region src/scope/index.ts
+function registerHook(scope, name, invoke) {
+	const targets = scope.hooks[name] ?? [];
+	targets.push(invoke);
+	scope.hooks[name] = targets;
+	return () => {
+		const index = scope.hooks[name]?.indexOf(invoke);
+		if (typeof index === "number" && index >= 0) scope.hooks[name]?.splice(index, 1);
+		if (scope.hooks[name]?.length === 0) delete scope.hooks[name];
+	};
+}
+function createRegisterHooks(descriptors) {
+	return (scope, hooks) => {
+		for (const name in descriptors) registerHook(scope, descriptors[name], hooks[name]);
+	};
+}
+async function dispatchHook(scope, name, ...inputs) {
+	const results = new Array();
+	for (const invoke of scope.hooks[name] ?? []) results.push(await invoke(...inputs));
+	return results;
+}
+async function dispatchHookSingle(scope, name, ...inputs) {
+	return await dispatchHook(scope, name, ...inputs).then((results) => results.at(0));
+}
+function getContext(scope, input) {
+	if (Object.hasOwn(scope.context, input)) return scope.context[input];
+	return {};
+}
+function setContext(scope, input, value) {
+	scope.context[input] = value;
+	return value;
+}
+async function createScope(inputScope) {
+	const scope = mergeObjects(inputScope, {
+		hooks: {},
+		context: {}
+	});
+	for (const source of Object.values(plugins)) for (const resolve of Object.values(source)) {
+		const plugin = await resolve();
+		if (plugin) await plugin.setup(scope);
+	}
+	return scope;
+}
+function useVariables(scope) {
+	const normalize = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+	const entries = new Map(Object.entries(getContext(scope, VARIABLE_CONTEXT)).map(([name, value]) => [normalize(name), [name, value]]));
+	for (const [name, variable] of Object.entries(variables)) {
+		const key = normalize(name);
+		let value = entries.get(key)?.[1] ?? variable.default;
+		if (value === void 0 && variable.optional !== true) throw new Error(`Missing required variable "${name}"`);
+		if (typeof value === "string") {
+			if (variable.type === "boolean") value = value.toLowerCase() === "true";
+			if (variable.type === "number") value = Number(value);
+		}
+		entries.set(key, [name, value]);
+	}
+	return Object.fromEntries(entries.values());
+}
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineHook(name) {
+	return name;
+}
+function defineContext(name) {
+	return name;
+}
+var VARIABLE_CONTEXT = defineContext("VARIABLE_CONTEXT");
+//#endregion
+export { VARIABLE_CONTEXT, createRegisterHooks, createScope, defineContext, defineHook, definePlugin, dispatchHook, dispatchHookSingle, getContext, registerHook, setContext, useVariables };

package/dist/shared/index.d.ts

@@ -0,0 +1,14 @@
+import type { StandardJSONSchemaV1 } from "@standard-schema/spec";
+export type Awaitable<T> = T | PromiseLike<T>;
+export type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type Mergeable<T> = T extends Primitive | ((...args: Array<never>) => unknown) ? T : T extends ArrayLike<infer U> ? ArrayLike<Mergeable<U>> : {
+    [K in keyof T]?: Mergeable<T[K]>;
+};
+export type JSONValue = null | string | number | boolean | JSONObject | Array<JSONValue>;
+export interface JSONObject {
+    [key: string]: JSONValue | undefined;
+}
+export type JsonSchema = StandardJSONSchemaV1 | JSONObject;
+export declare function mergeObjects<TBase, TInput>(base: TBase, input: TInput): TBase & TInput;
+export declare function toJsonSchema(schema: JsonSchema): JSONObject;
+export declare const scheduleAliases: Record<string, string>;

package/dist/shared/index.js

@@ -0,0 +1,39 @@
+//#region src/shared/index.ts
+function mergeObjects(base, input) {
+	if (input === null || input === void 0) return mergeObjects(base, {});
+	const object = {};
+	for (const key of Object.keys(input)) {
+		if (DANGEROUS_KEYS.has(key)) continue;
+		object[key] = input[key];
+	}
+	for (const key in base) {
+		if (DANGEROUS_KEYS.has(key)) continue;
+		const value = base[key];
+		if (value === null || value === void 0) continue;
+		if (Array.isArray(value) && Array.isArray(object[key])) object[key] = [...value, ...object[key]];
+		else if (typeof value === "object" && typeof object[key] === "object") object[key] = mergeObjects(value, object[key]);
+		else object[key] = value;
+	}
+	return object;
+}
+function toJsonSchema(schema) {
+	const standard = schema["~standard"];
+	if (standard?.jsonSchema !== void 0) return standard.jsonSchema.input({ target: "draft-07" });
+	return schema;
+}
+var scheduleAliases = {
+	"@yearly": "0 0 1 1 *",
+	"@annually": "0 0 1 1 *",
+	"@monthly": "0 0 1 * *",
+	"@weekly": "0 0 * * 0",
+	"@daily": "0 0 * * *",
+	"@midnight": "0 0 * * *",
+	"@hourly": "0 * * * *"
+};
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+//#endregion
+export { mergeObjects, scheduleAliases, toJsonSchema };

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+declare module "#assets" {
+    import type { Asset } from "revojs";
+
+    const entries: Record<string, Asset>;
+    export default entries;
+}
+
+declare module "#plugins" {
+    import type { Plugin, Source } from "revojs";
+
+    const entries: Source<Plugin>;
+    export default entries;
+}
+
+declare module "#commands" {
+    import type { Source } from "revojs";
+    import type { Command } from "revojs/module";
+
+    const entries: Source<Command>;
+    export default entries;
+}

package/package.json

@@ -1,49 +1,52 @@
 {
     "name": "revojs",
-    "version": "0.1.57",
+    "version": "0.1.59",
     "license": "MIT",
-    "repository": "tellua/revojs",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tellua/revojs.git"
+    },
     "bin": {
-        "revojs": "./dist/commands/index.mjs"
+        "revojs": "dist/cli/index.js"
     },
     "files": [
         "dist",
         "src/types"
     ],
     "type": "module",
-    "main": "./dist/index.mjs",
-    "module": "./dist/index.mjs",
-    "types": "./dist/index.d.mts",
+    "sideEffects": false,
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "exports": {
         ".": {
-            "types": "./dist/index.d.mts",
-            "import": "./dist/index.mjs"
-        },
-        "./kit": {
-            "types": "./dist/kit/index.d.mts",
-            "import": "./dist/kit/index.mjs"
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
         },
-        "./vite": {
-            "types": "./dist/vite/index.d.mts",
-            "import": "./dist/vite/index.mjs"
+        "./module": {
+            "types": "./dist/module/index.d.ts",
+            "import": "./dist/module/index.js"
         },
-        "./types": {
-            "types": "./src/types/index.d.ts"
+        "./shared": {
+            "types": "./dist/shared/index.d.ts",
+            "import": "./dist/shared/index.js"
         }
     },
     "scripts": {
-        "build": "tsdown",
-        "watch": "tsdown -w"
+        "build": "vite build",
+        "typecheck": "tsc --noEmit -p tsconfig.json",
+        "watch": "vite build --watch"
     },
     "dependencies": {
-        "citty": "^0.2.2",
-        "rolldown": "^1.0.0-rc.15",
-        "rolldown-plugin-dts": "^0.23.2",
-        "vite": "^8.0.8"
+        "@standard-schema/spec": "^1.1.0",
+        "rolldown": "^1.2.8",
+        "vite": "^8.3.0"
     },
     "devDependencies": {
         "@revojs/tsconfig": "*",
-        "@types/node": "^25.6.0",
-        "tsdown": "^0.21.8"
+        "@types/node": "^26.4.1"
+    },
+    "optionalDependencies": {
+        "typescript": "^7.0.2"
     }
 }

package/src/types/index.d.ts

@@ -1,18 +1,21 @@
-declare module "#client" {
-    const client: string;
+declare module "#assets" {
+    import type { Asset } from "revojs";
 
-    export default client;
+    const entries: Record<string, Asset>;
+    export default entries;
 }
 
-declare module "#server" {
-    import type { Server } from "revojs";
+declare module "#plugins" {
+    import type { Plugin, Source } from "revojs";
 
-    const server: Server;
-
-    export default server;
+    const entries: Source<Plugin>;
+    export default entries;
 }
 
-interface ImportMeta {
-    readonly SERVER: boolean;
-    readonly CLIENT: boolean;
+declare module "#commands" {
+    import type { Source } from "revojs";
+    import type { Command } from "revojs/module";
+
+    const entries: Source<Command>;
+    export default entries;
 }

package/dist/commands/index.d.mts

@@ -1 +0,0 @@
-export { };

package/dist/commands/index.mjs

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import { n as version, t as name } from "../package-DllXqorv.mjs";
-import { resolvePaths } from "../kit/index.mjs";
-import { defineCommand, runMain } from "citty";
-import { copyFileSync, mkdirSync } from "fs";
-import { dirname, join, relative } from "path";
-import { rolldown } from "rolldown";
-import { dts } from "rolldown-plugin-dts";
-//#endregion
-//#region src/commands/module/index.ts
-var module_default = defineCommand({ subCommands: { build: defineCommand({ async setup() {
-	await (await rolldown({
-		input: resolvePaths([
-			"./src/**/*.js",
-			"./src/**/*.ts",
-			"!./src/**/*.d.ts"
-		]),
-		plugins: [dts()],
-		external: () => true
-	})).write({
-		cleanDir: true,
-		preserveModules: true,
-		sanitizeFileName: false
-	});
-	for (const path of resolvePaths([
-		"./src/**/*.*",
-		"!./src/**/*.js",
-		"!./src/**/*.ts"
-	])) {
-		const target = join("./dist", relative("./src", path));
-		mkdirSync(dirname(target), { recursive: true });
-		copyFileSync(path, target);
-	}
-	for (const path of resolvePaths(["./src/**/*.d.ts"])) {
-		const target = join("./dist", relative("./src", path));
-		mkdirSync(dirname(target), { recursive: true });
-		copyFileSync(path, target);
-	}
-} }) } });
-//#endregion
-//#region src/commands/index.ts
-runMain(defineCommand({
-	meta: {
-		name,
-		version
-	},
-	subCommands: { module: module_default }
-}));
-//#endregion
-export {};