elysia 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/type/typebox-system-lite.js

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_system = require("typebox/system");
+
+Object.defineProperty(exports, 'Arguments', {
+  enumerable: true,
+  get: function () {
+    return typebox_system.Arguments;
+  }
+});
+Object.defineProperty(exports, 'Environment', {
+  enumerable: true,
+  get: function () {
+    return typebox_system.Environment;
+  }
+});
+Object.defineProperty(exports, 'Hashing', {
+  enumerable: true,
+  get: function () {
+    return typebox_system.Hashing;
+  }
+});
+Object.defineProperty(exports, 'Memory', {
+  enumerable: true,
+  get: function () {
+    return typebox_system.Memory;
+  }
+});
+Object.defineProperty(exports, 'Settings', {
+  enumerable: true,
+  get: function () {
+    return typebox_system.Settings;
+  }
+});

package/dist/type/typebox-system-lite.mjs

@@ -0,0 +1,3 @@
+import { Arguments, Environment, Hashing, Memory, Settings } from "typebox/system";
+
+export { Arguments, Environment, Hashing, Memory, Settings };

package/dist/type/typebox-system-require.d.ts

@@ -0,0 +1,7 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { System } from "typebox/system";
+
+//#region src/type/typebox-system-require.d.ts
+declare const typeSystem: (system: TypeboxTypeNamespaces["system"]) => typeof System;
+//#endregion
+export { typeSystem };

package/dist/type/typebox-system-require.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_sync_require = require('./sync-require.js');
+
+//#region src/type/typebox-system-require.ts
+const requireLocale = () => {
+	try {
+		const req = require_type_sync_require.syncRequire({}, require("url").pathToFileURL(__filename).href);
+		if (req) return req("typebox/system").System.Locale;
+	} catch {}
+	throw new Error("TypeSystem.Locale isn't bundled: it carries every locale table. Register it with setupTypebox({ typebox: { type, system } }) using `import * as system from 'typebox/system'`, or build with `aot(entry)`.");
+};
+const typeSystem = (system) => system.System ?? Object.defineProperty({
+	Arguments: system.Arguments,
+	Environment: system.Environment,
+	Hashing: system.Hashing,
+	Memory: system.Memory,
+	Settings: system.Settings
+}, "Locale", {
+	get: requireLocale,
+	enumerable: true
+});
+
+//#endregion
+exports.typeSystem = typeSystem;

package/dist/type/typebox-system-require.mjs

@@ -0,0 +1,23 @@
+import { syncRequire } from "./sync-require.mjs";
+
+//#region src/type/typebox-system-require.ts
+const requireLocale = () => {
+	try {
+		const req = syncRequire(import.meta, import.meta.url);
+		if (req) return req("typebox/system").System.Locale;
+	} catch {}
+	throw new Error("TypeSystem.Locale isn't bundled: it carries every locale table. Register it with setupTypebox({ typebox: { type, system } }) using `import * as system from 'typebox/system'`, or build with `aot(entry)`.");
+};
+const typeSystem = (system) => system.System ?? Object.defineProperty({
+	Arguments: system.Arguments,
+	Environment: system.Environment,
+	Hashing: system.Hashing,
+	Memory: system.Memory,
+	Settings: system.Settings
+}, "Locale", {
+	get: requireLocale,
+	enumerable: true
+});
+
+//#endregion
+export { typeSystem };

package/dist/type/typebox-type-live.d.ts

@@ -0,0 +1,11 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+
+//#region src/type/typebox-type-live.d.ts
+declare function injectTypeboxType(typebox?: TypeboxTypeNamespaces): void;
+declare const loadTypeNamespace: () => TypeboxTypeNamespaces;
+declare function markTypeUsed(): void;
+declare const isTypeUsed: () => boolean;
+declare const isTypeNamespaceLoaded: () => boolean;
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, type TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type-live.js

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_type = require("typebox/type");
+typebox_type = require_runtime.__toESM(typebox_type);
+let src_type_typebox_system_lite = require("./typebox-system-lite.mjs");
+src_type_typebox_system_lite = require_runtime.__toESM(src_type_typebox_system_lite);
+
+//#region src/type/typebox-type-live.ts
+src_type_typebox_system_lite.Settings.Set({ unionPrioritySort: false });
+let namespaces = {
+	type: typebox_type,
+	system: src_type_typebox_system_lite
+};
+function injectTypeboxType(typebox) {
+	if (typebox) namespaces = typebox;
+}
+const loadTypeNamespace = () => namespaces;
+function markTypeUsed() {}
+const isTypeUsed = () => true;
+const isTypeNamespaceLoaded = () => true;
+
+//#endregion
+exports.Codec = typebox_type.Codec;
+exports.Decode = typebox_type.Decode;
+exports.Evaluate = typebox_type.Evaluate;
+exports.Intersect = typebox_type.Intersect;
+exports.Module = typebox_type.Module;
+exports.Null = typebox_type.Null;
+exports.Ref = typebox_type.Ref;
+exports.Refine = typebox_type.Refine;
+exports.Undefined = typebox_type.Undefined;
+exports.Unsafe = typebox_type.Unsafe;
+exports.injectTypeboxType = injectTypeboxType;
+exports.isTypeNamespaceLoaded = isTypeNamespaceLoaded;
+exports.isTypeUsed = isTypeUsed;
+exports.loadTypeNamespace = loadTypeNamespace;
+exports.markTypeUsed = markTypeUsed;

package/dist/type/typebox-type-live.mjs

@@ -0,0 +1,20 @@
+import * as type from "typebox/type";
+import { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe } from "typebox/type";
+import * as system from "./typebox-system-lite.mjs";
+
+//#region src/type/typebox-type-live.ts
+system.Settings.Set({ unionPrioritySort: false });
+let namespaces = {
+	type,
+	system
+};
+function injectTypeboxType(typebox) {
+	if (typebox) namespaces = typebox;
+}
+const loadTypeNamespace = () => namespaces;
+function markTypeUsed() {}
+const isTypeUsed = () => true;
+const isTypeNamespaceLoaded = () => true;
+
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type.d.ts

@@ -0,0 +1,26 @@
+import * as _$typebox_type0 from "typebox/type";
+import { Codec as Codec$1, Decode as Decode$1, Evaluate as Evaluate$1, Intersect as Intersect$1, Module as Module$1, Null as Null$1, Ref as Ref$1, Refine as Refine$1, Undefined as Undefined$1, Unsafe as Unsafe$1 } from "typebox/type";
+import * as _$typebox_system0 from "typebox/system";
+
+//#region src/type/typebox-type.d.ts
+interface TypeboxTypeNamespaces {
+  type: typeof _$typebox_type0;
+  system: Pick<typeof _$typebox_system0, 'Arguments' | 'Environment' | 'Hashing' | 'Memory' | 'Settings'> & Partial<Pick<typeof _$typebox_system0, 'System'>>;
+}
+declare const loadTypeNamespace: () => TypeboxTypeNamespaces;
+declare const markTypeUsed: () => void;
+declare const isTypeUsed: () => boolean;
+declare const isTypeNamespaceLoaded: () => boolean;
+declare let Codec: typeof Codec$1;
+declare let Decode: typeof Decode$1;
+declare let Evaluate: typeof Evaluate$1;
+declare let Intersect: typeof Intersect$1;
+declare let Module: typeof Module$1;
+declare let Null: typeof Null$1;
+declare let Ref: typeof Ref$1;
+declare let Refine: typeof Refine$1;
+declare let Undefined: typeof Undefined$1;
+declare let Unsafe: typeof Unsafe$1;
+declare function injectTypeboxType(typebox: TypeboxTypeNamespaces): void;
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type.js

@@ -0,0 +1,135 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_type_sync_require = require('./sync-require.js');
+
+//#region src/type/typebox-type.ts
+let namespaces;
+/**
+* Loads `typebox/type` + `typebox/system` on first use
+*
+* separate from `typebox-value` (type ⊂ value)
+* sharing one would make a single `t.Date()` drag the whole value graph in
+*/
+function load() {
+	if (namespaces) return namespaces;
+	injectTypeboxType(resolveNamespaces());
+	return namespaces;
+}
+function resolveNamespaces() {
+	if (typeof require === "function") try {
+		return {
+			type: require("typebox/type"),
+			system: require("./typebox-system-lite.mjs")
+		};
+	} catch {}
+	const req = require_type_sync_require.syncRequire({}, require("url").pathToFileURL(__filename).href);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { type, system } }).");
+	return {
+		type: req("typebox/type"),
+		system: req("typebox/system")
+	};
+}
+const loadTypeNamespace = () => namespaces ?? load();
+let typeUsed = false;
+const markTypeUsed = () => {
+	typeUsed = true;
+};
+const isTypeUsed = () => typeUsed || namespaces !== void 0;
+const isTypeNamespaceLoaded = () => namespaces !== void 0;
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Codec = stub(() => Codec);
+let Decode = stub(() => Decode);
+let Evaluate = stub(() => Evaluate);
+let Intersect = stub(() => Intersect);
+let Module = stub(() => Module);
+let Null = stub(() => Null);
+let Ref = stub(() => Ref);
+let Refine = stub(() => Refine);
+let Undefined = stub(() => Undefined);
+let Unsafe = stub(() => Unsafe);
+function injectTypeboxType(typebox) {
+	const first = namespaces === void 0;
+	namespaces = typebox;
+	Codec = typebox.type.Codec;
+	Decode = typebox.type.Decode;
+	Evaluate = typebox.type.Evaluate;
+	Intersect = typebox.type.Intersect;
+	Module = typebox.type.Module;
+	Null = typebox.type.Null;
+	Ref = typebox.type.Ref;
+	Refine = typebox.type.Refine;
+	Undefined = typebox.type.Undefined;
+	Unsafe = typebox.type.Unsafe;
+	if (first) typebox.system.Settings.Set({ unionPrioritySort: false });
+}
+
+//#endregion
+Object.defineProperty(exports, 'Codec', {
+  enumerable: true,
+  get: function () {
+    return Codec;
+  }
+});
+Object.defineProperty(exports, 'Decode', {
+  enumerable: true,
+  get: function () {
+    return Decode;
+  }
+});
+Object.defineProperty(exports, 'Evaluate', {
+  enumerable: true,
+  get: function () {
+    return Evaluate;
+  }
+});
+Object.defineProperty(exports, 'Intersect', {
+  enumerable: true,
+  get: function () {
+    return Intersect;
+  }
+});
+Object.defineProperty(exports, 'Module', {
+  enumerable: true,
+  get: function () {
+    return Module;
+  }
+});
+Object.defineProperty(exports, 'Null', {
+  enumerable: true,
+  get: function () {
+    return Null;
+  }
+});
+Object.defineProperty(exports, 'Ref', {
+  enumerable: true,
+  get: function () {
+    return Ref;
+  }
+});
+Object.defineProperty(exports, 'Refine', {
+  enumerable: true,
+  get: function () {
+    return Refine;
+  }
+});
+Object.defineProperty(exports, 'Undefined', {
+  enumerable: true,
+  get: function () {
+    return Undefined;
+  }
+});
+Object.defineProperty(exports, 'Unsafe', {
+  enumerable: true,
+  get: function () {
+    return Unsafe;
+  }
+});
+exports.injectTypeboxType = injectTypeboxType;
+exports.isTypeNamespaceLoaded = isTypeNamespaceLoaded;
+exports.isTypeUsed = isTypeUsed;
+exports.loadTypeNamespace = loadTypeNamespace;
+exports.markTypeUsed = markTypeUsed;

package/dist/type/typebox-type.mjs

@@ -0,0 +1,70 @@
+import { syncRequire } from "./sync-require.mjs";
+
+//#region src/type/typebox-type.ts
+let namespaces;
+/**
+* Loads `typebox/type` + `typebox/system` on first use
+*
+* separate from `typebox-value` (type ⊂ value)
+* sharing one would make a single `t.Date()` drag the whole value graph in
+*/
+function load() {
+	if (namespaces) return namespaces;
+	injectTypeboxType(resolveNamespaces());
+	return namespaces;
+}
+function resolveNamespaces() {
+	if (typeof require === "function") try {
+		return {
+			type: require("typebox/type"),
+			system: require("./typebox-system-lite.mjs")
+		};
+	} catch {}
+	const req = syncRequire(import.meta, import.meta.url);
+	if (!req) throw new Error("TypeBox couldn't be loaded: this runtime has no synchronous module loader. Build with the AOT plugin ('elysia/plugin/aot') so TypeBox is wired statically, or register it manually with setupTypebox({ typebox: { type, system } }).");
+	return {
+		type: req("typebox/type"),
+		system: req("typebox/system")
+	};
+}
+const loadTypeNamespace = () => namespaces ?? load();
+let typeUsed = false;
+const markTypeUsed = () => {
+	typeUsed = true;
+};
+const isTypeUsed = () => typeUsed || namespaces !== void 0;
+const isTypeNamespaceLoaded = () => namespaces !== void 0;
+function stub(get) {
+	return function(...args) {
+		load();
+		return get()(...args);
+	};
+}
+let Codec = stub(() => Codec);
+let Decode = stub(() => Decode);
+let Evaluate = stub(() => Evaluate);
+let Intersect = stub(() => Intersect);
+let Module = stub(() => Module);
+let Null = stub(() => Null);
+let Ref = stub(() => Ref);
+let Refine = stub(() => Refine);
+let Undefined = stub(() => Undefined);
+let Unsafe = stub(() => Unsafe);
+function injectTypeboxType(typebox) {
+	const first = namespaces === void 0;
+	namespaces = typebox;
+	Codec = typebox.type.Codec;
+	Decode = typebox.type.Decode;
+	Evaluate = typebox.type.Evaluate;
+	Intersect = typebox.type.Intersect;
+	Module = typebox.type.Module;
+	Null = typebox.type.Null;
+	Ref = typebox.type.Ref;
+	Refine = typebox.type.Refine;
+	Undefined = typebox.type.Undefined;
+	Unsafe = typebox.type.Unsafe;
+	if (first) typebox.system.Settings.Set({ unionPrioritySort: false });
+}
+
+//#endregion
+export { Codec, Decode, Evaluate, Intersect, Module, Null, Ref, Refine, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-value-live.d.ts

@@ -0,0 +1,11 @@
+import { TypeboxNamespaces } from "./typebox-value.js";
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+
+//#region src/type/typebox-value-live.d.ts
+declare function injectTypebox(_typebox?: TypeboxNamespaces): void;
+declare function warmTypebox(): void;
+declare function preloadTypebox(): Promise<void> | undefined;
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, type TypeboxNamespaces, injectTypebox, preloadTypebox, warmTypebox };

package/dist/type/typebox-value-live.js

@@ -0,0 +1,31 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
+let typebox_compile = require("typebox/compile");
+let typebox_system = require("typebox/system");
+
+//#region src/type/typebox-value-live.ts
+typebox_system.Settings.Set({ unionPrioritySort: false });
+function injectTypebox(_typebox) {}
+function warmTypebox() {}
+function preloadTypebox() {}
+
+//#endregion
+exports.Build = typebox_schema.Build;
+exports.Check = typebox_value.Check;
+exports.Clean = typebox_value.Clean;
+exports.Clone = typebox_value.Clone;
+exports.Compile = typebox_compile.Compile;
+exports.Create = typebox_value.Create;
+exports.Decode = typebox_value.Decode;
+exports.DecodeUnsafe = typebox_value.DecodeUnsafe;
+exports.Default = typebox_value.Default;
+exports.Encode = typebox_value.Encode;
+exports.EncodeUnsafe = typebox_value.EncodeUnsafe;
+exports.Errors = typebox_value.Errors;
+exports.HasCodec = typebox_value.HasCodec;
+exports.SchemaCompile = typebox_schema.Compile;
+exports.injectTypebox = injectTypebox;
+exports.preloadTypebox = preloadTypebox;
+exports.warmTypebox = warmTypebox;

package/dist/type/typebox-value-live.mjs

@@ -0,0 +1,13 @@
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+import { Settings } from "typebox/system";
+
+//#region src/type/typebox-value-live.ts
+Settings.Set({ unionPrioritySort: false });
+function injectTypebox(_typebox) {}
+function warmTypebox() {}
+function preloadTypebox() {}
+
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, injectTypebox, preloadTypebox, warmTypebox };

package/dist/type/typebox-value-ops.d.ts

@@ -0,0 +1,4 @@
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile };

package/dist/type/typebox-value-ops.js

@@ -0,0 +1,90 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+let typebox_schema = require("typebox/schema");
+let typebox_value = require("typebox/value");
+let typebox_compile = require("typebox/compile");
+
+Object.defineProperty(exports, 'Build', {
+  enumerable: true,
+  get: function () {
+    return typebox_schema.Build;
+  }
+});
+Object.defineProperty(exports, 'Check', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Check;
+  }
+});
+Object.defineProperty(exports, 'Clean', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Clean;
+  }
+});
+Object.defineProperty(exports, 'Clone', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Clone;
+  }
+});
+Object.defineProperty(exports, 'Compile', {
+  enumerable: true,
+  get: function () {
+    return typebox_compile.Compile;
+  }
+});
+Object.defineProperty(exports, 'Create', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Create;
+  }
+});
+Object.defineProperty(exports, 'Decode', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Decode;
+  }
+});
+Object.defineProperty(exports, 'DecodeUnsafe', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.DecodeUnsafe;
+  }
+});
+Object.defineProperty(exports, 'Default', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Default;
+  }
+});
+Object.defineProperty(exports, 'Encode', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Encode;
+  }
+});
+Object.defineProperty(exports, 'EncodeUnsafe', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.EncodeUnsafe;
+  }
+});
+Object.defineProperty(exports, 'Errors', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.Errors;
+  }
+});
+Object.defineProperty(exports, 'HasCodec', {
+  enumerable: true,
+  get: function () {
+    return typebox_value.HasCodec;
+  }
+});
+Object.defineProperty(exports, 'SchemaCompile', {
+  enumerable: true,
+  get: function () {
+    return typebox_schema.Compile;
+  }
+});

package/dist/type/typebox-value-ops.mjs

@@ -0,0 +1,5 @@
+import { Build, Compile as SchemaCompile } from "typebox/schema";
+import { Check, Clean, Clone, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec } from "typebox/value";
+import { Compile } from "typebox/compile";
+
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile };

package/dist/type/typebox-value-require.d.ts

@@ -0,0 +1,8 @@
+import { TypeboxTypeNamespaces } from "./typebox-type.js";
+import { TypeboxNamespaces } from "./typebox-value.js";
+
+//#region src/type/typebox-value-require.d.ts
+declare const requireTypebox: () => TypeboxNamespaces | undefined;
+declare const importTypebox: () => Promise<[TypeboxTypeNamespaces, TypeboxNamespaces]> | undefined;
+//#endregion
+export { importTypebox, requireTypebox };

package/dist/type/typebox-value-require.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/type/typebox-value-require.ts
+const fromOps = (ops) => ({
+	value: ops,
+	schema: {
+		Compile: ops.SchemaCompile,
+		Build: ops.Build
+	},
+	compile: { Compile: ops.Compile }
+});
+const requireTypebox = () => {
+	if (typeof require === "function") try {
+		return fromOps(require("./typebox-value-ops.mjs"));
+	} catch {}
+};
+const importTypebox = () => Promise.all([
+	import("typebox/type"),
+	import("./typebox-system-lite.mjs"),
+	import("./typebox-value-ops.mjs")
+]).then(([type, system, ops]) => [{
+	type,
+	system
+}, fromOps(ops)]);
+
+//#endregion
+exports.importTypebox = importTypebox;
+exports.requireTypebox = requireTypebox;

package/dist/type/typebox-value-require.mjs

@@ -0,0 +1,25 @@
+//#region src/type/typebox-value-require.ts
+const fromOps = (ops) => ({
+	value: ops,
+	schema: {
+		Compile: ops.SchemaCompile,
+		Build: ops.Build
+	},
+	compile: { Compile: ops.Compile }
+});
+const requireTypebox = () => {
+	if (typeof require === "function") try {
+		return fromOps(require("./typebox-value-ops.mjs"));
+	} catch {}
+};
+const importTypebox = () => Promise.all([
+	import("typebox/type"),
+	import("./typebox-system-lite.mjs"),
+	import("./typebox-value-ops.mjs")
+]).then(([type, system, ops]) => [{
+	type,
+	system
+}, fromOps(ops)]);
+
+//#endregion
+export { importTypebox, requireTypebox };

package/dist/type/typebox-value.d.ts

@@ -0,0 +1,35 @@
+import * as _$typebox_schema0 from "typebox/schema";
+import { Build as Build$1, Compile as Compile$1 } from "typebox/schema";
+import * as _$typebox_value0 from "typebox/value";
+import { Check as Check$1, Clean as Clean$1, Clone as Clone$1, Create as Create$1, Decode as Decode$1, DecodeUnsafe as DecodeUnsafe$1, Default as Default$1, Encode as Encode$1, EncodeUnsafe as EncodeUnsafe$1, Errors as Errors$1, HasCodec as HasCodec$1 } from "typebox/value";
+import * as _$typebox_compile0 from "typebox/compile";
+import { Compile as Compile$2 } from "typebox/compile";
+
+//#region src/type/typebox-value.d.ts
+interface TypeboxNamespaces {
+  value: Pick<typeof _$typebox_value0, 'Check' | 'Clean' | 'Clone' | 'Create' | 'Decode' | 'DecodeUnsafe' | 'Default' | 'Encode' | 'EncodeUnsafe' | 'Errors' | 'HasCodec'>;
+  schema: Pick<typeof _$typebox_schema0, 'Compile' | 'Build'>;
+  compile: Pick<typeof _$typebox_compile0, 'Compile'>;
+}
+/**
+ * Loads `typebox/value` + `typebox/schema` + `typebox/compile` on first use
+ */
+declare function load(): void;
+declare function preloadTypebox(): Promise<void> | undefined;
+declare let Check: typeof Check$1;
+declare let Clean: typeof Clean$1;
+declare let Clone: typeof Clone$1;
+declare let Create: typeof Create$1;
+declare let Decode: typeof Decode$1;
+declare let DecodeUnsafe: typeof DecodeUnsafe$1;
+declare let Default: typeof Default$1;
+declare let Encode: typeof Encode$1;
+declare let EncodeUnsafe: typeof EncodeUnsafe$1;
+declare let Errors: typeof Errors$1;
+declare let HasCodec: typeof HasCodec$1;
+declare let SchemaCompile: typeof Compile$1;
+declare let Build: typeof Build$1;
+declare let Compile: typeof Compile$2;
+declare function injectTypebox(typebox: TypeboxNamespaces): void;
+//#endregion
+export { Build, Check, Clean, Clone, Compile, Create, Decode, DecodeUnsafe, Default, Encode, EncodeUnsafe, Errors, HasCodec, SchemaCompile, TypeboxNamespaces, injectTypebox, preloadTypebox, load as warmTypebox };