elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/type/shared.mjs

@@ -13,12 +13,6 @@ function clearSharedReferenceCaches() {
 	for (const cache of sharedReferenceCaches) cache.clear();
 }
 const pureRefinements = /* @__PURE__ */ new WeakSet();
-/**
-* @internal Tag every `~refine` entry of a framework-built node as pure.
-* Only ever call this on nodes whose predicates are self-contained: a predicate
-* that can transitively reach a USER refinement (e.g. ObjectString, which runs
-* `Check` over the inner schema) is NOT pure and must keep the pool.
-*/
 function pureRefine(node) {
 	const refinements = node?.["~refine"];
 	if (Array.isArray(refinements)) {
@@ -31,20 +25,13 @@ const isPureRefinement = (refinement) => pureRefinements.has(refinement);
 /** @internal */
 const coerceLeafCache = /* @__PURE__ */ new Map();
 /** @internal test isolation */
-const coerceLeafCacheSize = () => coerceLeafCache.size;
-/** @internal test isolation */
 function clearCoerceLeafCache() {
 	coerceLeafCache.clear();
 }
-function cloneNode(node, out) {
-	if (out !== node) return out;
-	const target = {
-		...node,
-		"~kind": node["~kind"]
-	};
-	for (const key of Object.getOwnPropertyNames(node)) {
-		const desc = Object.getOwnPropertyDescriptor(node, key);
-		if (!desc || desc.enumerable || key === "~kind") continue;
+function copyNonEnumerable(src, target, skipKey) {
+	for (const key of Object.getOwnPropertyNames(src)) {
+		const desc = Object.getOwnPropertyDescriptor(src, key);
+		if (!desc || desc.enumerable || key === skipKey) continue;
 		Object.defineProperty(target, key, {
 			value: desc.value,
 			enumerable: false,
@@ -52,104 +39,63 @@ function cloneNode(node, out) {
 			configurable: true
 		});
 	}
+}
+function cloneNode(node, out) {
+	if (out !== node) return out;
+	const target = {
+		...node,
+		"~kind": node["~kind"]
+	};
+	copyNonEnumerable(node, target, "~kind");
 	return Object.defineProperty(target, "~kind", noEnumerable);
 }
+function dropCompiledSource(tb) {
+	if (tb.evaluateResult) tb.evaluateResult.code = void 0;
+	if (tb.buildResult) tb.buildResult.functions = void 0;
+}
 function nonAdditionalProperties(node, seen = /* @__PURE__ */ new WeakSet()) {
 	if (!node || typeof node !== "object" || seen.has(node)) return node;
 	seen.add(node);
 	let out = node;
-	if (node.properties) {
-		let newProps;
-		for (const k in node.properties) {
-			const v = node.properties[k];
+	const set = (key, value) => {
+		out = cloneNode(node, out);
+		out[key] = value;
+	};
+	const single = (key) => {
+		const v = node[key];
+		const r = nonAdditionalProperties(v, seen);
+		if (r !== v) set(key, r);
+	};
+	const record = (key) => {
+		const children = node[key];
+		let copy;
+		for (const k in children) {
+			const v = children[k];
 			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newProps ??= { ...node.properties };
-				newProps[k] = r;
-			}
+			if (r !== v) (copy ??= { ...children })[k] = r;
 		}
-		if (newProps) {
-			out = cloneNode(node, out);
-			out.properties = newProps;
-		}
-	}
-	if (node.items) if (Array.isArray(node.items)) {
-		let newItems;
-		for (let i = 0; i < node.items.length; i++) {
-			const r = nonAdditionalProperties(node.items[i], seen);
-			if (r !== node.items[i]) {
-				newItems ??= [...node.items];
-				newItems[i] = r;
-			}
-		}
-		if (newItems) {
-			out = cloneNode(node, out);
-			out.items = newItems;
-		}
-	} else {
-		const r = nonAdditionalProperties(node.items, seen);
-		if (r !== node.items) {
-			out = cloneNode(node, out);
-			out.items = r;
-		}
-	}
+		if (copy) set(key, copy);
+	};
+	if (node.properties) record("properties");
+	if (node.items && !Array.isArray(node.items)) single("items");
 	for (const key of [
+		"items",
 		"anyOf",
 		"allOf",
 		"oneOf"
 	]) {
 		const arr = node[key];
 		if (!Array.isArray(arr)) continue;
-		let newArr;
+		let copy;
 		for (let i = 0; i < arr.length; i++) {
 			const r = nonAdditionalProperties(arr[i], seen);
-			if (r !== arr[i]) {
-				newArr ??= [...arr];
-				newArr[i] = r;
-			}
-		}
-		if (newArr) {
-			out = cloneNode(node, out);
-			out[key] = newArr;
-		}
-	}
-	if (node.additionalProperties && typeof node.additionalProperties === "object") {
-		const r = nonAdditionalProperties(node.additionalProperties, seen);
-		if (r !== node.additionalProperties) {
-			out = cloneNode(node, out);
-			out.additionalProperties = r;
-		}
-	}
-	if (node.patternProperties) {
-		let newPP;
-		for (const k in node.patternProperties) {
-			const v = node.patternProperties[k];
-			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newPP ??= { ...node.patternProperties };
-				newPP[k] = r;
-			}
-		}
-		if (newPP) {
-			out = cloneNode(node, out);
-			out.patternProperties = newPP;
-		}
-	}
-	if (node.$defs) {
-		let newDefs;
-		for (const k in node.$defs) {
-			const v = node.$defs[k];
-			const r = nonAdditionalProperties(v, seen);
-			if (r !== v) {
-				newDefs ??= { ...node.$defs };
-				newDefs[k] = r;
-			}
-		}
-		if (newDefs) {
-			out = cloneNode(node, out);
-			out.$defs = newDefs;
+			if (r !== arr[i]) (copy ??= [...arr])[i] = r;
 		}
+		if (copy) set(key, copy);
 	}
+	if (node.additionalProperties && typeof node.additionalProperties === "object") single("additionalProperties");
+	if (node.patternProperties) record("patternProperties");
+	if (node.$defs) record("$defs");
 	if ((node.type === "object" || node["~kind"] === "Object") && !("additionalProperties" in node)) {
 		out = cloneNode(node, out);
 		out.additionalProperties = false;
@@ -158,4 +104,4 @@ function nonAdditionalProperties(node, seen = /* @__PURE__ */ new WeakSet()) {
 }
 
 //#endregion
-export { SHARED_REFERENCE_CACHE_LIMIT, clearCoerceLeafCache, clearSharedReferenceCaches, cloneNode, coerceLeafCache, coerceLeafCacheSize, isPureRefinement, nonAdditionalProperties, pureRefine, referenceCache };
+export { SHARED_REFERENCE_CACHE_LIMIT, clearCoerceLeafCache, clearSharedReferenceCaches, cloneNode, coerceLeafCache, copyNonEnumerable, dropCompiledSource, isPureRefinement, nonAdditionalProperties, pureRefine, referenceCache };

package/dist/type/sync-require.d.ts

@@ -0,0 +1,11 @@
+//#region src/type/sync-require.d.ts
+/**
+ * Synchronous `require` resolving from the CALLER's module: pass its own
+ * `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+ * still rewrites `import.meta.url`)
+ *
+ * Never swapped by the AOT build plugin
+ */
+declare const syncRequire: (meta: ImportMeta, url: string) => ((specifier: string) => any) | undefined;
+//#endregion
+export { syncRequire };

package/dist/type/sync-require.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/type/sync-require.ts
+/**
+* Synchronous `require` resolving from the CALLER's module: pass its own
+* `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+* still rewrites `import.meta.url`)
+*
+* Never swapped by the AOT build plugin
+*/
+const syncRequire = (meta, url) => meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(url);
+
+//#endregion
+exports.syncRequire = syncRequire;

package/dist/type/sync-require.mjs

@@ -0,0 +1,12 @@
+//#region src/type/sync-require.ts
+/**
+* Synchronous `require` resolving from the CALLER's module: pass its own
+* `import.meta` and `import.meta.url` (a CJS build empties `import.meta` but
+* still rewrites `import.meta.url`)
+*
+* Never swapped by the AOT build plugin
+*/
+const syncRequire = (meta, url) => meta.require ?? globalThis.process?.getBuiltinModule?.("module")?.createRequire(url);
+
+//#endregion
+export { syncRequire };

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

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

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, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, 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, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, type TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

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

@@ -0,0 +1,45 @@
+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.Composite = typebox_type.Composite;
+exports.Decode = typebox_type.Decode;
+exports.Evaluate = typebox_type.Evaluate;
+exports.Interface = typebox_type.Interface;
+exports.Intersect = typebox_type.Intersect;
+exports.Mapped = typebox_type.Mapped;
+exports.Module = typebox_type.Module;
+exports.Null = typebox_type.Null;
+exports.Omit = typebox_type.Omit;
+exports.Partial = typebox_type.Partial;
+exports.Pick = typebox_type.Pick;
+exports.ReadonlyObject = typebox_type.ReadonlyObject;
+exports.Ref = typebox_type.Ref;
+exports.Refine = typebox_type.Refine;
+exports.Required = typebox_type.Required;
+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, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, 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, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

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

@@ -0,0 +1,34 @@
+import * as _$typebox_type0 from "typebox/type";
+import { Codec as Codec$1, Composite as Composite$1, Decode as Decode$1, Evaluate as Evaluate$1, Interface as Interface$1, Intersect as Intersect$1, Mapped as Mapped$1, Module as Module$1, Null as Null$1, Omit as Omit$1, Partial as Partial$1, Pick as Pick$1, ReadonlyObject as ReadonlyObject$1, Ref as Ref$1, Refine as Refine$1, Required as Required$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 Composite: typeof Composite$1;
+declare let Decode: typeof Decode$1;
+declare let Evaluate: typeof Evaluate$1;
+declare let Interface: typeof Interface$1;
+declare let Intersect: typeof Intersect$1;
+declare let Mapped: typeof Mapped$1;
+declare let Module: typeof Module$1;
+declare let Null: typeof Null$1;
+declare let Omit: typeof Omit$1;
+declare let Partial: typeof Partial$1;
+declare let Pick: typeof Pick$1;
+declare let ReadonlyObject: typeof ReadonlyObject$1;
+declare let Ref: typeof Ref$1;
+declare let Refine: typeof Refine$1;
+declare let Required: typeof Required$1;
+declare let Undefined: typeof Undefined$1;
+declare let Unsafe: typeof Unsafe$1;
+declare function injectTypeboxType(typebox: TypeboxTypeNamespaces): void;
+//#endregion
+export { Codec, Composite, Decode, Evaluate, Interface, Intersect, Mapped, Module, Null, Omit, Partial, Pick, ReadonlyObject, Ref, Refine, Required, TypeboxTypeNamespaces, Undefined, Unsafe, injectTypeboxType, isTypeNamespaceLoaded, isTypeUsed, loadTypeNamespace, markTypeUsed };

package/dist/type/typebox-type.js

@@ -0,0 +1,199 @@
+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 Composite = stub(() => Composite);
+let Decode = stub(() => Decode);
+let Evaluate = stub(() => Evaluate);
+let Interface = stub(() => Interface);
+let Intersect = stub(() => Intersect);
+let Mapped = stub(() => Mapped);
+let Module = stub(() => Module);
+let Null = stub(() => Null);
+let Omit = stub(() => Omit);
+let Partial = stub(() => Partial);
+let Pick = stub(() => Pick);
+let ReadonlyObject = stub(() => ReadonlyObject);
+let Ref = stub(() => Ref);
+let Refine = stub(() => Refine);
+let Required = stub(() => Required);
+let Undefined = stub(() => Undefined);
+let Unsafe = stub(() => Unsafe);
+function injectTypeboxType(typebox) {
+	const first = namespaces === void 0;
+	namespaces = typebox;
+	Codec = typebox.type.Codec;
+	Composite = typebox.type.Composite;
+	Decode = typebox.type.Decode;
+	Evaluate = typebox.type.Evaluate;
+	Interface = typebox.type.Interface;
+	Intersect = typebox.type.Intersect;
+	Mapped = typebox.type.Mapped;
+	Module = typebox.type.Module;
+	Null = typebox.type.Null;
+	Omit = typebox.type.Omit;
+	Partial = typebox.type.Partial;
+	Pick = typebox.type.Pick;
+	ReadonlyObject = typebox.type.ReadonlyObject;
+	Ref = typebox.type.Ref;
+	Refine = typebox.type.Refine;
+	Required = typebox.type.Required;
+	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, 'Composite', {
+  enumerable: true,
+  get: function () {
+    return Composite;
+  }
+});
+Object.defineProperty(exports, 'Decode', {
+  enumerable: true,
+  get: function () {
+    return Decode;
+  }
+});
+Object.defineProperty(exports, 'Evaluate', {
+  enumerable: true,
+  get: function () {
+    return Evaluate;
+  }
+});
+Object.defineProperty(exports, 'Interface', {
+  enumerable: true,
+  get: function () {
+    return Interface;
+  }
+});
+Object.defineProperty(exports, 'Intersect', {
+  enumerable: true,
+  get: function () {
+    return Intersect;
+  }
+});
+Object.defineProperty(exports, 'Mapped', {
+  enumerable: true,
+  get: function () {
+    return Mapped;
+  }
+});
+Object.defineProperty(exports, 'Module', {
+  enumerable: true,
+  get: function () {
+    return Module;
+  }
+});
+Object.defineProperty(exports, 'Null', {
+  enumerable: true,
+  get: function () {
+    return Null;
+  }
+});
+Object.defineProperty(exports, 'Omit', {
+  enumerable: true,
+  get: function () {
+    return Omit;
+  }
+});
+Object.defineProperty(exports, 'Partial', {
+  enumerable: true,
+  get: function () {
+    return Partial;
+  }
+});
+Object.defineProperty(exports, 'Pick', {
+  enumerable: true,
+  get: function () {
+    return Pick;
+  }
+});
+Object.defineProperty(exports, 'ReadonlyObject', {
+  enumerable: true,
+  get: function () {
+    return ReadonlyObject;
+  }
+});
+Object.defineProperty(exports, 'Ref', {
+  enumerable: true,
+  get: function () {
+    return Ref;
+  }
+});
+Object.defineProperty(exports, 'Refine', {
+  enumerable: true,
+  get: function () {
+    return Refine;
+  }
+});
+Object.defineProperty(exports, 'Required', {
+  enumerable: true,
+  get: function () {
+    return Required;
+  }
+});
+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;