skilld 1.7.0 → 1.7.2

package/dist/_chunks/libs/@sinclair/typebox.mjs

@@ -1,2304 +0,0 @@
-import { t as __exportAll } from "../../rolldown-runtime.mjs";
-function IsAsyncIterator$2(value) {
-	return IsObject$3(value) && !IsArray$3(value) && !IsUint8Array$2(value) && Symbol.asyncIterator in value;
-}
-function IsArray$3(value) {
-	return Array.isArray(value);
-}
-function IsBigInt$2(value) {
-	return typeof value === "bigint";
-}
-function IsBoolean$2(value) {
-	return typeof value === "boolean";
-}
-function IsDate$2(value) {
-	return value instanceof globalThis.Date;
-}
-function IsFunction$2(value) {
-	return typeof value === "function";
-}
-function IsIterator$2(value) {
-	return IsObject$3(value) && !IsArray$3(value) && !IsUint8Array$2(value) && Symbol.iterator in value;
-}
-function IsNull$2(value) {
-	return value === null;
-}
-function IsNumber$3(value) {
-	return typeof value === "number";
-}
-function IsObject$3(value) {
-	return typeof value === "object" && value !== null;
-}
-function IsRegExp$2(value) {
-	return value instanceof globalThis.RegExp;
-}
-function IsString$2(value) {
-	return typeof value === "string";
-}
-function IsSymbol$2(value) {
-	return typeof value === "symbol";
-}
-function IsUint8Array$2(value) {
-	return value instanceof globalThis.Uint8Array;
-}
-function IsUndefined$3(value) {
-	return value === void 0;
-}
-function ArrayType(value) {
-	return value.map((value) => Visit$2(value));
-}
-function DateType(value) {
-	return new Date(value.getTime());
-}
-function Uint8ArrayType(value) {
-	return new Uint8Array(value);
-}
-function RegExpType(value) {
-	return new RegExp(value.source, value.flags);
-}
-function ObjectType(value) {
-	const result = {};
-	for (const key of Object.getOwnPropertyNames(value)) result[key] = Visit$2(value[key]);
-	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Visit$2(value[key]);
-	return result;
-}
-function Visit$2(value) {
-	return IsArray$3(value) ? ArrayType(value) : IsDate$2(value) ? DateType(value) : IsUint8Array$2(value) ? Uint8ArrayType(value) : IsRegExp$2(value) ? RegExpType(value) : IsObject$3(value) ? ObjectType(value) : value;
-}
-function Clone(value) {
-	return Visit$2(value);
-}
-function CloneType(schema, options) {
-	return options === void 0 ? Clone(schema) : Clone({
-		...options,
-		...schema
-	});
-}
-function IsObject$2(value) {
-	return value !== null && typeof value === "object";
-}
-function IsArray$2(value) {
-	return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
-}
-function IsUndefined$2(value) {
-	return value === void 0;
-}
-function IsNumber$2(value) {
-	return typeof value === "number";
-}
-var TypeSystemPolicy;
-(function(TypeSystemPolicy) {
-	TypeSystemPolicy.InstanceMode = "default";
-	TypeSystemPolicy.ExactOptionalPropertyTypes = false;
-	TypeSystemPolicy.AllowArrayObject = false;
-	TypeSystemPolicy.AllowNaN = false;
-	TypeSystemPolicy.AllowNullVoid = false;
-	function IsExactOptionalProperty(value, key) {
-		return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
-	}
-	TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
-	function IsObjectLike(value) {
-		const isObject = IsObject$2(value);
-		return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray$2(value);
-	}
-	TypeSystemPolicy.IsObjectLike = IsObjectLike;
-	function IsRecordLike(value) {
-		return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
-	}
-	TypeSystemPolicy.IsRecordLike = IsRecordLike;
-	function IsNumberLike(value) {
-		return TypeSystemPolicy.AllowNaN ? IsNumber$2(value) : Number.isFinite(value);
-	}
-	TypeSystemPolicy.IsNumberLike = IsNumberLike;
-	function IsVoidLike(value) {
-		const isUndefined = IsUndefined$2(value);
-		return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
-	}
-	TypeSystemPolicy.IsVoidLike = IsVoidLike;
-})(TypeSystemPolicy || (TypeSystemPolicy = {}));
-function ImmutableArray(value) {
-	return globalThis.Object.freeze(value).map((value) => Immutable(value));
-}
-function ImmutableDate(value) {
-	return value;
-}
-function ImmutableUint8Array(value) {
-	return value;
-}
-function ImmutableRegExp(value) {
-	return value;
-}
-function ImmutableObject(value) {
-	const result = {};
-	for (const key of Object.getOwnPropertyNames(value)) result[key] = Immutable(value[key]);
-	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Immutable(value[key]);
-	return globalThis.Object.freeze(result);
-}
-function Immutable(value) {
-	return IsArray$3(value) ? ImmutableArray(value) : IsDate$2(value) ? ImmutableDate(value) : IsUint8Array$2(value) ? ImmutableUint8Array(value) : IsRegExp$2(value) ? ImmutableRegExp(value) : IsObject$3(value) ? ImmutableObject(value) : value;
-}
-function CreateType(schema, options) {
-	const result = options !== void 0 ? {
-		...options,
-		...schema
-	} : schema;
-	switch (TypeSystemPolicy.InstanceMode) {
-		case "freeze": return Immutable(result);
-		case "clone": return Clone(result);
-		default: return result;
-	}
-}
-var TypeBoxError = class extends Error {
-	constructor(message) {
-		super(message);
-	}
-};
-const TransformKind = Symbol.for("TypeBox.Transform");
-const ReadonlyKind = Symbol.for("TypeBox.Readonly");
-const OptionalKind = Symbol.for("TypeBox.Optional");
-const Hint = Symbol.for("TypeBox.Hint");
-const Kind = Symbol.for("TypeBox.Kind");
-function IsReadonly(value) {
-	return IsObject$3(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional$1(value) {
-	return IsObject$3(value) && value[OptionalKind] === "Optional";
-}
-function IsAny$1(value) {
-	return IsKindOf$1(value, "Any");
-}
-function IsArgument$1(value) {
-	return IsKindOf$1(value, "Argument");
-}
-function IsArray$1(value) {
-	return IsKindOf$1(value, "Array");
-}
-function IsAsyncIterator$1(value) {
-	return IsKindOf$1(value, "AsyncIterator");
-}
-function IsBigInt$1(value) {
-	return IsKindOf$1(value, "BigInt");
-}
-function IsBoolean$1(value) {
-	return IsKindOf$1(value, "Boolean");
-}
-function IsComputed$1(value) {
-	return IsKindOf$1(value, "Computed");
-}
-function IsConstructor$1(value) {
-	return IsKindOf$1(value, "Constructor");
-}
-function IsDate$1(value) {
-	return IsKindOf$1(value, "Date");
-}
-function IsFunction$1(value) {
-	return IsKindOf$1(value, "Function");
-}
-function IsInteger$1(value) {
-	return IsKindOf$1(value, "Integer");
-}
-function IsIntersect$1(value) {
-	return IsKindOf$1(value, "Intersect");
-}
-function IsIterator$1(value) {
-	return IsKindOf$1(value, "Iterator");
-}
-function IsKindOf$1(value, kind) {
-	return IsObject$3(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralValue$1(value) {
-	return IsBoolean$2(value) || IsNumber$3(value) || IsString$2(value);
-}
-function IsLiteral$1(value) {
-	return IsKindOf$1(value, "Literal");
-}
-function IsMappedKey$1(value) {
-	return IsKindOf$1(value, "MappedKey");
-}
-function IsMappedResult$1(value) {
-	return IsKindOf$1(value, "MappedResult");
-}
-function IsNever$1(value) {
-	return IsKindOf$1(value, "Never");
-}
-function IsNot$1(value) {
-	return IsKindOf$1(value, "Not");
-}
-function IsNull$1(value) {
-	return IsKindOf$1(value, "Null");
-}
-function IsNumber$1(value) {
-	return IsKindOf$1(value, "Number");
-}
-function IsObject$1(value) {
-	return IsKindOf$1(value, "Object");
-}
-function IsPromise$1(value) {
-	return IsKindOf$1(value, "Promise");
-}
-function IsRecord$1(value) {
-	return IsKindOf$1(value, "Record");
-}
-function IsRef$1(value) {
-	return IsKindOf$1(value, "Ref");
-}
-function IsRegExp$1(value) {
-	return IsKindOf$1(value, "RegExp");
-}
-function IsString$1(value) {
-	return IsKindOf$1(value, "String");
-}
-function IsSymbol$1(value) {
-	return IsKindOf$1(value, "Symbol");
-}
-function IsTemplateLiteral$1(value) {
-	return IsKindOf$1(value, "TemplateLiteral");
-}
-function IsThis$1(value) {
-	return IsKindOf$1(value, "This");
-}
-function IsTransform$1(value) {
-	return IsObject$3(value) && TransformKind in value;
-}
-function IsTuple$1(value) {
-	return IsKindOf$1(value, "Tuple");
-}
-function IsUndefined$1(value) {
-	return IsKindOf$1(value, "Undefined");
-}
-function IsUnion$1(value) {
-	return IsKindOf$1(value, "Union");
-}
-function IsUint8Array$1(value) {
-	return IsKindOf$1(value, "Uint8Array");
-}
-function IsUnknown$1(value) {
-	return IsKindOf$1(value, "Unknown");
-}
-function IsUnsafe$1(value) {
-	return IsKindOf$1(value, "Unsafe");
-}
-function IsVoid$1(value) {
-	return IsKindOf$1(value, "Void");
-}
-function IsKind$1(value) {
-	return IsObject$3(value) && Kind in value && IsString$2(value[Kind]);
-}
-function IsSchema$1(value) {
-	return IsAny$1(value) || IsArgument$1(value) || IsArray$1(value) || IsBoolean$1(value) || IsBigInt$1(value) || IsAsyncIterator$1(value) || IsComputed$1(value) || IsConstructor$1(value) || IsDate$1(value) || IsFunction$1(value) || IsInteger$1(value) || IsIntersect$1(value) || IsIterator$1(value) || IsLiteral$1(value) || IsMappedKey$1(value) || IsMappedResult$1(value) || IsNever$1(value) || IsNot$1(value) || IsNull$1(value) || IsNumber$1(value) || IsObject$1(value) || IsPromise$1(value) || IsRecord$1(value) || IsRef$1(value) || IsRegExp$1(value) || IsString$1(value) || IsSymbol$1(value) || IsTemplateLiteral$1(value) || IsThis$1(value) || IsTuple$1(value) || IsUndefined$1(value) || IsUnion$1(value) || IsUint8Array$1(value) || IsUnknown$1(value) || IsUnsafe$1(value) || IsVoid$1(value) || IsKind$1(value);
-}
-const KnownTypes = [
-	"Argument",
-	"Any",
-	"Array",
-	"AsyncIterator",
-	"BigInt",
-	"Boolean",
-	"Computed",
-	"Constructor",
-	"Date",
-	"Enum",
-	"Function",
-	"Integer",
-	"Intersect",
-	"Iterator",
-	"Literal",
-	"MappedKey",
-	"MappedResult",
-	"Not",
-	"Null",
-	"Number",
-	"Object",
-	"Promise",
-	"Record",
-	"Ref",
-	"RegExp",
-	"String",
-	"Symbol",
-	"TemplateLiteral",
-	"This",
-	"Tuple",
-	"Undefined",
-	"Union",
-	"Uint8Array",
-	"Unknown",
-	"Void"
-];
-function IsPattern(value) {
-	try {
-		new RegExp(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function IsControlCharacterFree(value) {
-	if (!IsString$2(value)) return false;
-	for (let i = 0; i < value.length; i++) {
-		const code = value.charCodeAt(i);
-		if (code >= 7 && code <= 13 || code === 27 || code === 127) return false;
-	}
-	return true;
-}
-function IsAdditionalProperties(value) {
-	return IsOptionalBoolean(value) || IsSchema(value);
-}
-function IsOptionalBigInt(value) {
-	return IsUndefined$3(value) || IsBigInt$2(value);
-}
-function IsOptionalNumber(value) {
-	return IsUndefined$3(value) || IsNumber$3(value);
-}
-function IsOptionalBoolean(value) {
-	return IsUndefined$3(value) || IsBoolean$2(value);
-}
-function IsOptionalString(value) {
-	return IsUndefined$3(value) || IsString$2(value);
-}
-function IsOptionalPattern(value) {
-	return IsUndefined$3(value) || IsString$2(value) && IsControlCharacterFree(value) && IsPattern(value);
-}
-function IsOptionalFormat(value) {
-	return IsUndefined$3(value) || IsString$2(value) && IsControlCharacterFree(value);
-}
-function IsOptionalSchema(value) {
-	return IsUndefined$3(value) || IsSchema(value);
-}
-function IsOptional(value) {
-	return IsObject$3(value) && value[OptionalKind] === "Optional";
-}
-function IsAny(value) {
-	return IsKindOf(value, "Any") && IsOptionalString(value.$id);
-}
-function IsArgument(value) {
-	return IsKindOf(value, "Argument") && IsNumber$3(value.index);
-}
-function IsArray(value) {
-	return IsKindOf(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
-}
-function IsAsyncIterator(value) {
-	return IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
-}
-function IsBigInt(value) {
-	return IsKindOf(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
-}
-function IsBoolean(value) {
-	return IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
-}
-function IsComputed(value) {
-	return IsKindOf(value, "Computed") && IsString$2(value.target) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
-}
-function IsConstructor(value) {
-	return IsKindOf(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
-}
-function IsDate(value) {
-	return IsKindOf(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
-}
-function IsFunction(value) {
-	return IsKindOf(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray$3(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
-}
-function IsInteger(value) {
-	return IsKindOf(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
-}
-function IsProperties(value) {
-	return IsObject$3(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema));
-}
-function IsIntersect(value) {
-	return IsKindOf(value, "Intersect") && (IsString$2(value.type) && value.type !== "object" ? false : true) && IsArray$3(value.allOf) && value.allOf.every((schema) => IsSchema(schema) && !IsTransform(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
-}
-function IsIterator(value) {
-	return IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
-}
-function IsKindOf(value, kind) {
-	return IsObject$3(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralString(value) {
-	return IsLiteral(value) && IsString$2(value.const);
-}
-function IsLiteralNumber(value) {
-	return IsLiteral(value) && IsNumber$3(value.const);
-}
-function IsLiteralBoolean(value) {
-	return IsLiteral(value) && IsBoolean$2(value.const);
-}
-function IsLiteral(value) {
-	return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
-}
-function IsLiteralValue(value) {
-	return IsBoolean$2(value) || IsNumber$3(value) || IsString$2(value);
-}
-function IsMappedKey(value) {
-	return IsKindOf(value, "MappedKey") && IsArray$3(value.keys) && value.keys.every((key) => IsNumber$3(key) || IsString$2(key));
-}
-function IsMappedResult(value) {
-	return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
-}
-function IsNever(value) {
-	return IsKindOf(value, "Never") && IsObject$3(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
-}
-function IsNot(value) {
-	return IsKindOf(value, "Not") && IsSchema(value.not);
-}
-function IsNull(value) {
-	return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
-}
-function IsNumber(value) {
-	return IsKindOf(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
-}
-function IsObject(value) {
-	return IsKindOf(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
-}
-function IsPromise(value) {
-	return IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
-}
-function IsRecord(value) {
-	return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject$3(value.patternProperties) && ((schema) => {
-		const keys = Object.getOwnPropertyNames(schema.patternProperties);
-		return keys.length === 1 && IsPattern(keys[0]) && IsObject$3(schema.patternProperties) && IsSchema(schema.patternProperties[keys[0]]);
-	})(value);
-}
-function IsRef(value) {
-	return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString$2(value.$ref);
-}
-function IsRegExp(value) {
-	return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString$2(value.source) && IsString$2(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
-}
-function IsString(value) {
-	return IsKindOf(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
-}
-function IsSymbol(value) {
-	return IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
-}
-function IsTemplateLiteral(value) {
-	return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString$2(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
-}
-function IsThis(value) {
-	return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString$2(value.$ref);
-}
-function IsTransform(value) {
-	return IsObject$3(value) && TransformKind in value;
-}
-function IsTuple(value) {
-	return IsKindOf(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber$3(value.minItems) && IsNumber$3(value.maxItems) && value.minItems === value.maxItems && (IsUndefined$3(value.items) && IsUndefined$3(value.additionalItems) && value.minItems === 0 || IsArray$3(value.items) && value.items.every((schema) => IsSchema(schema)));
-}
-function IsUndefined(value) {
-	return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
-}
-function IsUnion(value) {
-	return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject$3(value) && IsArray$3(value.anyOf) && value.anyOf.every((schema) => IsSchema(schema));
-}
-function IsUint8Array(value) {
-	return IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
-}
-function IsUnknown(value) {
-	return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
-}
-function IsUnsafe(value) {
-	return IsKindOf(value, "Unsafe");
-}
-function IsVoid(value) {
-	return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
-}
-function IsKind(value) {
-	return IsObject$3(value) && Kind in value && IsString$2(value[Kind]) && !KnownTypes.includes(value[Kind]);
-}
-function IsSchema(value) {
-	return IsObject$3(value) && (IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value));
-}
-const PatternBoolean = "(true|false)";
-const PatternNumber = "(0|[1-9][0-9]*)";
-const PatternString = "(.*)";
-const PatternNever = "(?!.*)";
-`${PatternBoolean}`;
-const PatternNumberExact = `^${PatternNumber}$`;
-const PatternStringExact = `^${PatternString}$`;
-const PatternNeverExact = `^${PatternNever}$`;
-function SetIncludes(T, S) {
-	return T.includes(S);
-}
-function SetDistinct(T) {
-	return [...new Set(T)];
-}
-function SetIntersect(T, S) {
-	return T.filter((L) => S.includes(L));
-}
-function SetIntersectManyResolve(T, Init) {
-	return T.reduce((Acc, L) => {
-		return SetIntersect(Acc, L);
-	}, Init);
-}
-function SetIntersectMany(T) {
-	return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
-}
-function SetUnionMany(T) {
-	const Acc = [];
-	for (const L of T) Acc.push(...L);
-	return Acc;
-}
-function Any(options) {
-	return CreateType({ [Kind]: "Any" }, options);
-}
-function Array$1(items, options) {
-	return CreateType({
-		[Kind]: "Array",
-		type: "array",
-		items
-	}, options);
-}
-function Argument(index) {
-	return CreateType({
-		[Kind]: "Argument",
-		index
-	});
-}
-function AsyncIterator(items, options) {
-	return CreateType({
-		[Kind]: "AsyncIterator",
-		type: "AsyncIterator",
-		items
-	}, options);
-}
-function Computed(target, parameters, options) {
-	return CreateType({
-		[Kind]: "Computed",
-		target,
-		parameters
-	}, options);
-}
-function DiscardKey(value, key) {
-	const { [key]: _, ...rest } = value;
-	return rest;
-}
-function Discard(value, keys) {
-	return keys.reduce((acc, key) => DiscardKey(acc, key), value);
-}
-function Never(options) {
-	return CreateType({
-		[Kind]: "Never",
-		not: {}
-	}, options);
-}
-function MappedResult(properties) {
-	return CreateType({
-		[Kind]: "MappedResult",
-		properties
-	});
-}
-function Constructor(parameters, returns, options) {
-	return CreateType({
-		[Kind]: "Constructor",
-		type: "Constructor",
-		parameters,
-		returns
-	}, options);
-}
-function Function(parameters, returns, options) {
-	return CreateType({
-		[Kind]: "Function",
-		type: "Function",
-		parameters,
-		returns
-	}, options);
-}
-function UnionCreate(T, options) {
-	return CreateType({
-		[Kind]: "Union",
-		anyOf: T
-	}, options);
-}
-function IsUnionOptional(types) {
-	return types.some((type) => IsOptional$1(type));
-}
-function RemoveOptionalFromRest$1(types) {
-	return types.map((left) => IsOptional$1(left) ? RemoveOptionalFromType$1(left) : left);
-}
-function RemoveOptionalFromType$1(T) {
-	return Discard(T, [OptionalKind]);
-}
-function ResolveUnion(types, options) {
-	return IsUnionOptional(types) ? Optional(UnionCreate(RemoveOptionalFromRest$1(types), options)) : UnionCreate(RemoveOptionalFromRest$1(types), options);
-}
-function UnionEvaluated(T, options) {
-	return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
-}
-function Union(types, options) {
-	return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
-}
-var TemplateLiteralParserError = class extends TypeBoxError {};
-function Unescape(pattern) {
-	return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
-}
-function IsNonEscaped(pattern, index, char) {
-	return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
-}
-function IsOpenParen(pattern, index) {
-	return IsNonEscaped(pattern, index, "(");
-}
-function IsCloseParen(pattern, index) {
-	return IsNonEscaped(pattern, index, ")");
-}
-function IsSeparator(pattern, index) {
-	return IsNonEscaped(pattern, index, "|");
-}
-function IsGroup(pattern) {
-	if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1))) return false;
-	let count = 0;
-	for (let index = 0; index < pattern.length; index++) {
-		if (IsOpenParen(pattern, index)) count += 1;
-		if (IsCloseParen(pattern, index)) count -= 1;
-		if (count === 0 && index !== pattern.length - 1) return false;
-	}
-	return true;
-}
-function InGroup(pattern) {
-	return pattern.slice(1, pattern.length - 1);
-}
-function IsPrecedenceOr(pattern) {
-	let count = 0;
-	for (let index = 0; index < pattern.length; index++) {
-		if (IsOpenParen(pattern, index)) count += 1;
-		if (IsCloseParen(pattern, index)) count -= 1;
-		if (IsSeparator(pattern, index) && count === 0) return true;
-	}
-	return false;
-}
-function IsPrecedenceAnd(pattern) {
-	for (let index = 0; index < pattern.length; index++) if (IsOpenParen(pattern, index)) return true;
-	return false;
-}
-function Or(pattern) {
-	let [count, start] = [0, 0];
-	const expressions = [];
-	for (let index = 0; index < pattern.length; index++) {
-		if (IsOpenParen(pattern, index)) count += 1;
-		if (IsCloseParen(pattern, index)) count -= 1;
-		if (IsSeparator(pattern, index) && count === 0) {
-			const range = pattern.slice(start, index);
-			if (range.length > 0) expressions.push(TemplateLiteralParse(range));
-			start = index + 1;
-		}
-	}
-	const range = pattern.slice(start);
-	if (range.length > 0) expressions.push(TemplateLiteralParse(range));
-	if (expressions.length === 0) return {
-		type: "const",
-		const: ""
-	};
-	if (expressions.length === 1) return expressions[0];
-	return {
-		type: "or",
-		expr: expressions
-	};
-}
-function And(pattern) {
-	function Group(value, index) {
-		if (!IsOpenParen(value, index)) throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-		let count = 0;
-		for (let scan = index; scan < value.length; scan++) {
-			if (IsOpenParen(value, scan)) count += 1;
-			if (IsCloseParen(value, scan)) count -= 1;
-			if (count === 0) return [index, scan];
-		}
-		throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
-	}
-	function Range(pattern, index) {
-		for (let scan = index; scan < pattern.length; scan++) if (IsOpenParen(pattern, scan)) return [index, scan];
-		return [index, pattern.length];
-	}
-	const expressions = [];
-	for (let index = 0; index < pattern.length; index++) if (IsOpenParen(pattern, index)) {
-		const [start, end] = Group(pattern, index);
-		const range = pattern.slice(start, end + 1);
-		expressions.push(TemplateLiteralParse(range));
-		index = end;
-	} else {
-		const [start, end] = Range(pattern, index);
-		const range = pattern.slice(start, end);
-		if (range.length > 0) expressions.push(TemplateLiteralParse(range));
-		index = end - 1;
-	}
-	return expressions.length === 0 ? {
-		type: "const",
-		const: ""
-	} : expressions.length === 1 ? expressions[0] : {
-		type: "and",
-		expr: expressions
-	};
-}
-function TemplateLiteralParse(pattern) {
-	return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : {
-		type: "const",
-		const: Unescape(pattern)
-	};
-}
-function TemplateLiteralParseExact(pattern) {
-	return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
-}
-var TemplateLiteralFiniteError = class extends TypeBoxError {};
-function IsNumberExpression(expression) {
-	return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
-}
-function IsBooleanExpression(expression) {
-	return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
-}
-function IsStringExpression(expression) {
-	return expression.type === "const" && expression.const === ".*";
-}
-function IsTemplateLiteralExpressionFinite(expression) {
-	return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
-		throw new TemplateLiteralFiniteError(`Unknown expression type`);
-	})();
-}
-function IsTemplateLiteralFinite(schema) {
-	return IsTemplateLiteralExpressionFinite(TemplateLiteralParseExact(schema.pattern));
-}
-var TemplateLiteralGenerateError = class extends TypeBoxError {};
-function* GenerateReduce(buffer) {
-	if (buffer.length === 1) return yield* buffer[0];
-	for (const left of buffer[0]) for (const right of GenerateReduce(buffer.slice(1))) yield `${left}${right}`;
-}
-function* GenerateAnd(expression) {
-	return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
-}
-function* GenerateOr(expression) {
-	for (const expr of expression.expr) yield* TemplateLiteralExpressionGenerate(expr);
-}
-function* GenerateConst(expression) {
-	return yield expression.const;
-}
-function* TemplateLiteralExpressionGenerate(expression) {
-	return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
-		throw new TemplateLiteralGenerateError("Unknown expression");
-	})();
-}
-function TemplateLiteralGenerate(schema) {
-	const expression = TemplateLiteralParseExact(schema.pattern);
-	return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
-}
-function Literal(value, options) {
-	return CreateType({
-		[Kind]: "Literal",
-		const: value,
-		type: typeof value
-	}, options);
-}
-function Boolean(options) {
-	return CreateType({
-		[Kind]: "Boolean",
-		type: "boolean"
-	}, options);
-}
-function BigInt(options) {
-	return CreateType({
-		[Kind]: "BigInt",
-		type: "bigint"
-	}, options);
-}
-function Number$1(options) {
-	return CreateType({
-		[Kind]: "Number",
-		type: "number"
-	}, options);
-}
-function String(options) {
-	return CreateType({
-		[Kind]: "String",
-		type: "string"
-	}, options);
-}
-function* FromUnion$9(syntax) {
-	const trim = syntax.trim().replace(/"|'/g, "");
-	return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number$1() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String() : yield (() => {
-		const literals = trim.split("|").map((literal) => Literal(literal.trim()));
-		return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
-	})();
-}
-function* FromTerminal(syntax) {
-	if (syntax[1] !== "{") return yield* [Literal("$"), ...FromSyntax(syntax.slice(1))];
-	for (let i = 2; i < syntax.length; i++) if (syntax[i] === "}") {
-		const L = FromUnion$9(syntax.slice(2, i));
-		const R = FromSyntax(syntax.slice(i + 1));
-		return yield* [...L, ...R];
-	}
-	yield Literal(syntax);
-}
-function* FromSyntax(syntax) {
-	for (let i = 0; i < syntax.length; i++) if (syntax[i] === "$") return yield* [Literal(syntax.slice(0, i)), ...FromTerminal(syntax.slice(i))];
-	yield Literal(syntax);
-}
-function TemplateLiteralSyntax(syntax) {
-	return [...FromSyntax(syntax)];
-}
-var TemplateLiteralPatternError = class extends TypeBoxError {};
-function Escape(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function Visit$1(schema, acc) {
-	return IsTemplateLiteral$1(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion$1(schema) ? `(${schema.anyOf.map((schema) => Visit$1(schema, acc)).join("|")})` : IsNumber$1(schema) ? `${acc}${PatternNumber}` : IsInteger$1(schema) ? `${acc}${PatternNumber}` : IsBigInt$1(schema) ? `${acc}${PatternNumber}` : IsString$1(schema) ? `${acc}${PatternString}` : IsLiteral$1(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean$1(schema) ? `${acc}${PatternBoolean}` : (() => {
-		throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
-	})();
-}
-function TemplateLiteralPattern(kinds) {
-	return `^${kinds.map((schema) => Visit$1(schema, "")).join("")}\$`;
-}
-function TemplateLiteralToUnion(schema) {
-	return UnionEvaluated(TemplateLiteralGenerate(schema).map((S) => Literal(S)));
-}
-function TemplateLiteral(unresolved, options) {
-	const pattern = IsString$2(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
-	return CreateType({
-		[Kind]: "TemplateLiteral",
-		type: "string",
-		pattern
-	}, options);
-}
-function FromTemplateLiteral$2(templateLiteral) {
-	return TemplateLiteralGenerate(templateLiteral).map((key) => key.toString());
-}
-function FromUnion$8(types) {
-	const result = [];
-	for (const type of types) result.push(...IndexPropertyKeys(type));
-	return result;
-}
-function FromLiteral$1(literalValue) {
-	return [literalValue.toString()];
-}
-function IndexPropertyKeys(type) {
-	return [...new Set(IsTemplateLiteral$1(type) ? FromTemplateLiteral$2(type) : IsUnion$1(type) ? FromUnion$8(type.anyOf) : IsLiteral$1(type) ? FromLiteral$1(type.const) : IsNumber$1(type) ? ["[number]"] : IsInteger$1(type) ? ["[number]"] : [])];
-}
-function FromProperties$18(type, properties, options) {
-	const result = {};
-	for (const K2 of Object.getOwnPropertyNames(properties)) result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
-	return result;
-}
-function FromMappedResult$11(type, mappedResult, options) {
-	return FromProperties$18(type, mappedResult.properties, options);
-}
-function IndexFromMappedResult(type, mappedResult, options) {
-	return MappedResult(FromMappedResult$11(type, mappedResult, options));
-}
-function FromRest$6(types, key) {
-	return types.map((type) => IndexFromPropertyKey(type, key));
-}
-function FromIntersectRest(types) {
-	return types.filter((type) => !IsNever$1(type));
-}
-function FromIntersect$7(types, key) {
-	return IntersectEvaluated(FromIntersectRest(FromRest$6(types, key)));
-}
-function FromUnionRest(types) {
-	return types.some((L) => IsNever$1(L)) ? [] : types;
-}
-function FromUnion$7(types, key) {
-	return UnionEvaluated(FromUnionRest(FromRest$6(types, key)));
-}
-function FromTuple$4(types, key) {
-	return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
-}
-function FromArray$5(type, key) {
-	return key === "[number]" ? type : Never();
-}
-function FromProperty$2(properties, propertyKey) {
-	return propertyKey in properties ? properties[propertyKey] : Never();
-}
-function IndexFromPropertyKey(type, propertyKey) {
-	return IsIntersect$1(type) ? FromIntersect$7(type.allOf, propertyKey) : IsUnion$1(type) ? FromUnion$7(type.anyOf, propertyKey) : IsTuple$1(type) ? FromTuple$4(type.items ?? [], propertyKey) : IsArray$1(type) ? FromArray$5(type.items, propertyKey) : IsObject$1(type) ? FromProperty$2(type.properties, propertyKey) : Never();
-}
-function IndexFromPropertyKeys(type, propertyKeys) {
-	return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
-}
-function FromSchema(type, propertyKeys) {
-	return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
-}
-function Index(type, key, options) {
-	if (IsRef$1(type) || IsRef$1(key)) {
-		const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
-		if (!IsSchema$1(type) || !IsSchema$1(key)) throw new TypeBoxError(error);
-		return Computed("Index", [type, key]);
-	}
-	if (IsMappedResult$1(key)) return IndexFromMappedResult(type, key, options);
-	if (IsMappedKey$1(key)) return IndexFromMappedKey(type, key, options);
-	return CreateType(IsSchema$1(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
-}
-function MappedIndexPropertyKey(type, key, options) {
-	return { [key]: Index(type, [key], Clone(options)) };
-}
-function MappedIndexPropertyKeys(type, propertyKeys, options) {
-	return propertyKeys.reduce((result, left) => {
-		return {
-			...result,
-			...MappedIndexPropertyKey(type, left, options)
-		};
-	}, {});
-}
-function MappedIndexProperties(type, mappedKey, options) {
-	return MappedIndexPropertyKeys(type, mappedKey.keys, options);
-}
-function IndexFromMappedKey(type, mappedKey, options) {
-	return MappedResult(MappedIndexProperties(type, mappedKey, options));
-}
-function Iterator(items, options) {
-	return CreateType({
-		[Kind]: "Iterator",
-		type: "Iterator",
-		items
-	}, options);
-}
-function RequiredArray(properties) {
-	return globalThis.Object.keys(properties).filter((key) => !IsOptional$1(properties[key]));
-}
-function _Object(properties, options) {
-	const required = RequiredArray(properties);
-	return CreateType(required.length > 0 ? {
-		[Kind]: "Object",
-		type: "object",
-		required,
-		properties
-	} : {
-		[Kind]: "Object",
-		type: "object",
-		properties
-	}, options);
-}
-var Object$1 = _Object;
-function Promise$1(item, options) {
-	return CreateType({
-		[Kind]: "Promise",
-		type: "Promise",
-		item
-	}, options);
-}
-function RemoveReadonly(schema) {
-	return CreateType(Discard(schema, [ReadonlyKind]));
-}
-function AddReadonly(schema) {
-	return CreateType({
-		...schema,
-		[ReadonlyKind]: "Readonly"
-	});
-}
-function ReadonlyWithFlag(schema, F) {
-	return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
-}
-function Readonly(schema, enable) {
-	const F = enable ?? true;
-	return IsMappedResult$1(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
-}
-function FromProperties$17(K, F) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Readonly(K[K2], F);
-	return Acc;
-}
-function FromMappedResult$10(R, F) {
-	return FromProperties$17(R.properties, F);
-}
-function ReadonlyFromMappedResult(R, F) {
-	return MappedResult(FromMappedResult$10(R, F));
-}
-function Tuple(types, options) {
-	return CreateType(types.length > 0 ? {
-		[Kind]: "Tuple",
-		type: "array",
-		items: types,
-		additionalItems: false,
-		minItems: types.length,
-		maxItems: types.length
-	} : {
-		[Kind]: "Tuple",
-		type: "array",
-		minItems: types.length,
-		maxItems: types.length
-	}, options);
-}
-function FromMappedResult$9(K, P) {
-	return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
-}
-function MappedKeyToKnownMappedResultProperties(K) {
-	return { [K]: Literal(K) };
-}
-function MappedKeyToUnknownMappedResultProperties(P) {
-	const Acc = {};
-	for (const L of P) Acc[L] = Literal(L);
-	return Acc;
-}
-function MappedKeyToMappedResultProperties(K, P) {
-	return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
-}
-function FromMappedKey$3(K, P) {
-	return FromMappedResult$9(K, MappedKeyToMappedResultProperties(K, P));
-}
-function FromRest$5(K, T) {
-	return T.map((L) => FromSchemaType(K, L));
-}
-function FromProperties$16(K, T) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(T)) Acc[K2] = FromSchemaType(K, T[K2]);
-	return Acc;
-}
-function FromSchemaType(K, T) {
-	const options = { ...T };
-	return IsOptional$1(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : IsMappedResult$1(T) ? FromMappedResult$9(K, T.properties) : IsMappedKey$1(T) ? FromMappedKey$3(K, T.keys) : IsConstructor$1(T) ? Constructor(FromRest$5(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction$1(T) ? Function(FromRest$5(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator$1(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator$1(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect$1(T) ? Intersect(FromRest$5(K, T.allOf), options) : IsUnion$1(T) ? Union(FromRest$5(K, T.anyOf), options) : IsTuple$1(T) ? Tuple(FromRest$5(K, T.items ?? []), options) : IsObject$1(T) ? Object$1(FromProperties$16(K, T.properties), options) : IsArray$1(T) ? Array$1(FromSchemaType(K, T.items), options) : IsPromise$1(T) ? Promise$1(FromSchemaType(K, T.item), options) : T;
-}
-function MappedFunctionReturnType(K, T) {
-	const Acc = {};
-	for (const L of K) Acc[L] = FromSchemaType(L, T);
-	return Acc;
-}
-function Mapped(key, map, options) {
-	const K = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
-	return Object$1(MappedFunctionReturnType(K, map({
-		[Kind]: "MappedKey",
-		keys: K
-	})), options);
-}
-function RemoveOptional(schema) {
-	return CreateType(Discard(schema, [OptionalKind]));
-}
-function AddOptional(schema) {
-	return CreateType({
-		...schema,
-		[OptionalKind]: "Optional"
-	});
-}
-function OptionalWithFlag(schema, F) {
-	return F === false ? RemoveOptional(schema) : AddOptional(schema);
-}
-function Optional(schema, enable) {
-	const F = enable ?? true;
-	return IsMappedResult$1(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
-}
-function FromProperties$15(P, F) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Optional(P[K2], F);
-	return Acc;
-}
-function FromMappedResult$8(R, F) {
-	return FromProperties$15(R.properties, F);
-}
-function OptionalFromMappedResult(R, F) {
-	return MappedResult(FromMappedResult$8(R, F));
-}
-function IntersectCreate(T, options = {}) {
-	const allObjects = T.every((schema) => IsObject$1(schema));
-	const clonedUnevaluatedProperties = IsSchema$1(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
-	return CreateType(options.unevaluatedProperties === false || IsSchema$1(options.unevaluatedProperties) || allObjects ? {
-		...clonedUnevaluatedProperties,
-		[Kind]: "Intersect",
-		type: "object",
-		allOf: T
-	} : {
-		...clonedUnevaluatedProperties,
-		[Kind]: "Intersect",
-		allOf: T
-	}, options);
-}
-function IsIntersectOptional(types) {
-	return types.every((left) => IsOptional$1(left));
-}
-function RemoveOptionalFromType(type) {
-	return Discard(type, [OptionalKind]);
-}
-function RemoveOptionalFromRest(types) {
-	return types.map((left) => IsOptional$1(left) ? RemoveOptionalFromType(left) : left);
-}
-function ResolveIntersect(types, options) {
-	return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest(types), options)) : IntersectCreate(RemoveOptionalFromRest(types), options);
-}
-function IntersectEvaluated(types, options = {}) {
-	if (types.length === 1) return CreateType(types[0], options);
-	if (types.length === 0) return Never(options);
-	if (types.some((schema) => IsTransform$1(schema))) throw new Error("Cannot intersect transform types");
-	return ResolveIntersect(types, options);
-}
-function Intersect(types, options) {
-	if (types.length === 1) return CreateType(types[0], options);
-	if (types.length === 0) return Never(options);
-	if (types.some((schema) => IsTransform$1(schema))) throw new Error("Cannot intersect transform types");
-	return IntersectCreate(types, options);
-}
-function Ref(...args) {
-	const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
-	if (typeof $ref !== "string") throw new TypeBoxError("Ref: $ref must be a string");
-	return CreateType({
-		[Kind]: "Ref",
-		$ref
-	}, options);
-}
-function FromComputed$4(target, parameters) {
-	return Computed("Awaited", [Computed(target, parameters)]);
-}
-function FromRef$3($ref) {
-	return Computed("Awaited", [Ref($ref)]);
-}
-function FromIntersect$6(types) {
-	return Intersect(FromRest$4(types));
-}
-function FromUnion$6(types) {
-	return Union(FromRest$4(types));
-}
-function FromPromise$2(type) {
-	return Awaited(type);
-}
-function FromRest$4(types) {
-	return types.map((type) => Awaited(type));
-}
-function Awaited(type, options) {
-	return CreateType(IsComputed$1(type) ? FromComputed$4(type.target, type.parameters) : IsIntersect$1(type) ? FromIntersect$6(type.allOf) : IsUnion$1(type) ? FromUnion$6(type.anyOf) : IsPromise$1(type) ? FromPromise$2(type.item) : IsRef$1(type) ? FromRef$3(type.$ref) : type, options);
-}
-function FromRest$3(types) {
-	const result = [];
-	for (const L of types) result.push(KeyOfPropertyKeys(L));
-	return result;
-}
-function FromIntersect$5(types) {
-	return SetUnionMany(FromRest$3(types));
-}
-function FromUnion$5(types) {
-	return SetIntersectMany(FromRest$3(types));
-}
-function FromTuple$3(types) {
-	return types.map((_, indexer) => indexer.toString());
-}
-function FromArray$4(_) {
-	return ["[number]"];
-}
-function FromProperties$14(T) {
-	return globalThis.Object.getOwnPropertyNames(T);
-}
-function FromPatternProperties(patternProperties) {
-	if (!includePatternProperties) return [];
-	return globalThis.Object.getOwnPropertyNames(patternProperties).map((key) => {
-		return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
-	});
-}
-function KeyOfPropertyKeys(type) {
-	return IsIntersect$1(type) ? FromIntersect$5(type.allOf) : IsUnion$1(type) ? FromUnion$5(type.anyOf) : IsTuple$1(type) ? FromTuple$3(type.items ?? []) : IsArray$1(type) ? FromArray$4(type.items) : IsObject$1(type) ? FromProperties$14(type.properties) : IsRecord$1(type) ? FromPatternProperties(type.patternProperties) : [];
-}
-let includePatternProperties = false;
-function FromComputed$3(target, parameters) {
-	return Computed("KeyOf", [Computed(target, parameters)]);
-}
-function FromRef$2($ref) {
-	return Computed("KeyOf", [Ref($ref)]);
-}
-function KeyOfFromType(type, options) {
-	return CreateType(UnionEvaluated(KeyOfPropertyKeysToRest(KeyOfPropertyKeys(type))), options);
-}
-function KeyOfPropertyKeysToRest(propertyKeys) {
-	return propertyKeys.map((L) => L === "[number]" ? Number$1() : Literal(L));
-}
-function KeyOf(type, options) {
-	return IsComputed$1(type) ? FromComputed$3(type.target, type.parameters) : IsRef$1(type) ? FromRef$2(type.$ref) : IsMappedResult$1(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
-}
-function FromProperties$13(properties, options) {
-	const result = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = KeyOf(properties[K2], Clone(options));
-	return result;
-}
-function FromMappedResult$7(mappedResult, options) {
-	return FromProperties$13(mappedResult.properties, options);
-}
-function KeyOfFromMappedResult(mappedResult, options) {
-	return MappedResult(FromMappedResult$7(mappedResult, options));
-}
-function CompositeKeys(T) {
-	const Acc = [];
-	for (const L of T) Acc.push(...KeyOfPropertyKeys(L));
-	return SetDistinct(Acc);
-}
-function FilterNever(T) {
-	return T.filter((L) => !IsNever$1(L));
-}
-function CompositeProperty(T, K) {
-	const Acc = [];
-	for (const L of T) Acc.push(...IndexFromPropertyKeys(L, [K]));
-	return FilterNever(Acc);
-}
-function CompositeProperties(T, K) {
-	const Acc = {};
-	for (const L of K) Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
-	return Acc;
-}
-function Composite(T, options) {
-	return Object$1(CompositeProperties(T, CompositeKeys(T)), options);
-}
-function Date$1(options) {
-	return CreateType({
-		[Kind]: "Date",
-		type: "Date"
-	}, options);
-}
-function Null(options) {
-	return CreateType({
-		[Kind]: "Null",
-		type: "null"
-	}, options);
-}
-function Symbol$1(options) {
-	return CreateType({
-		[Kind]: "Symbol",
-		type: "symbol"
-	}, options);
-}
-function Undefined(options) {
-	return CreateType({
-		[Kind]: "Undefined",
-		type: "undefined"
-	}, options);
-}
-function Uint8Array$1(options) {
-	return CreateType({
-		[Kind]: "Uint8Array",
-		type: "Uint8Array"
-	}, options);
-}
-function Unknown(options) {
-	return CreateType({ [Kind]: "Unknown" }, options);
-}
-function FromArray$3(T) {
-	return T.map((L) => FromValue(L, false));
-}
-function FromProperties$12(value) {
-	const Acc = {};
-	for (const K of globalThis.Object.getOwnPropertyNames(value)) Acc[K] = Readonly(FromValue(value[K], false));
-	return Acc;
-}
-function ConditionalReadonly(T, root) {
-	return root === true ? T : Readonly(T);
-}
-function FromValue(value, root) {
-	return IsAsyncIterator$2(value) ? ConditionalReadonly(Any(), root) : IsIterator$2(value) ? ConditionalReadonly(Any(), root) : IsArray$3(value) ? Readonly(Tuple(FromArray$3(value))) : IsUint8Array$2(value) ? Uint8Array$1() : IsDate$2(value) ? Date$1() : IsObject$3(value) ? ConditionalReadonly(Object$1(FromProperties$12(value)), root) : IsFunction$2(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined$3(value) ? Undefined() : IsNull$2(value) ? Null() : IsSymbol$2(value) ? Symbol$1() : IsBigInt$2(value) ? BigInt() : IsNumber$3(value) ? Literal(value) : IsBoolean$2(value) ? Literal(value) : IsString$2(value) ? Literal(value) : Object$1({});
-}
-function Const(T, options) {
-	return CreateType(FromValue(T, true), options);
-}
-function ConstructorParameters(schema, options) {
-	return IsConstructor$1(schema) ? Tuple(schema.parameters, options) : Never(options);
-}
-function Enum(item, options) {
-	if (IsUndefined$3(item)) throw new Error("Enum undefined or empty");
-	const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
-	return Union([...new Set(values1)].map((value) => Literal(value)), {
-		...options,
-		[Hint]: "Enum"
-	});
-}
-var ExtendsResolverError = class extends TypeBoxError {};
-var ExtendsResult;
-(function(ExtendsResult) {
-	ExtendsResult[ExtendsResult["Union"] = 0] = "Union";
-	ExtendsResult[ExtendsResult["True"] = 1] = "True";
-	ExtendsResult[ExtendsResult["False"] = 2] = "False";
-})(ExtendsResult || (ExtendsResult = {}));
-function IntoBooleanResult(result) {
-	return result === ExtendsResult.False ? result : ExtendsResult.True;
-}
-function Throw(message) {
-	throw new ExtendsResolverError(message);
-}
-function IsStructuralRight(right) {
-	return IsNever(right) || IsIntersect(right) || IsUnion(right) || IsUnknown(right) || IsAny(right);
-}
-function StructuralRight(left, right) {
-	return IsNever(right) ? FromNeverRight(left, right) : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
-}
-function FromAnyRight(left, right) {
-	return ExtendsResult.True;
-}
-function FromAny(left, right) {
-	return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) && right.anyOf.some((schema) => IsAny(schema) || IsUnknown(schema)) ? ExtendsResult.True : IsUnion(right) ? ExtendsResult.Union : IsUnknown(right) ? ExtendsResult.True : IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
-}
-function FromArrayRight(left, right) {
-	return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromArray$2(left, right) {
-	return IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
-}
-function FromAsyncIterator$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : !IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
-}
-function FromBigInt(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromBooleanRight(left, right) {
-	return IsLiteralBoolean(left) ? ExtendsResult.True : IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromBoolean(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromConstructor$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
-}
-function FromDate(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromFunction$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
-}
-function FromIntegerRight(left, right) {
-	return IsLiteral(left) && IsNumber$3(left.const) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromInteger(left, right) {
-	return IsInteger(right) || IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
-}
-function FromIntersectRight(left, right) {
-	return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromIntersect$4(left, right) {
-	return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromIterator$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : !IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
-}
-function FromLiteral(left, right) {
-	return IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? FromStringRight(left, right) : IsNumber(right) ? FromNumberRight(left, right) : IsInteger(right) ? FromIntegerRight(left, right) : IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
-}
-function FromNeverRight(left, right) {
-	return ExtendsResult.False;
-}
-function FromNever(left, right) {
-	return ExtendsResult.True;
-}
-function UnwrapTNot(schema) {
-	let [current, depth] = [schema, 0];
-	while (true) {
-		if (!IsNot(current)) break;
-		current = current.not;
-		depth += 1;
-	}
-	return depth % 2 === 0 ? current : Unknown();
-}
-function FromNot(left, right) {
-	return IsNot(left) ? Visit(UnwrapTNot(left), right) : IsNot(right) ? Visit(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
-}
-function FromNull(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromNumberRight(left, right) {
-	return IsLiteralNumber(left) ? ExtendsResult.True : IsNumber(left) || IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromNumber(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsInteger(right) || IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function IsObjectPropertyCount(schema, count) {
-	return Object.getOwnPropertyNames(schema.properties).length === count;
-}
-function IsObjectStringLike(schema) {
-	return IsObjectArrayLike(schema);
-}
-function IsObjectSymbolLike(schema) {
-	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (IsString(schema.properties.description.anyOf[0]) && IsUndefined(schema.properties.description.anyOf[1]) || IsString(schema.properties.description.anyOf[1]) && IsUndefined(schema.properties.description.anyOf[0]));
-}
-function IsObjectNumberLike(schema) {
-	return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectBooleanLike(schema) {
-	return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectBigIntLike(schema) {
-	return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectDateLike(schema) {
-	return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectUint8ArrayLike(schema) {
-	return IsObjectArrayLike(schema);
-}
-function IsObjectFunctionLike(schema) {
-	const length = Number$1();
-	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
-}
-function IsObjectConstructorLike(schema) {
-	return IsObjectPropertyCount(schema, 0);
-}
-function IsObjectArrayLike(schema) {
-	const length = Number$1();
-	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === ExtendsResult.True;
-}
-function IsObjectPromiseLike(schema) {
-	const then = Function([Any()], Any());
-	return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === ExtendsResult.True;
-}
-function Property(left, right) {
-	return Visit(left, right) === ExtendsResult.False ? ExtendsResult.False : IsOptional(left) && !IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
-}
-function FromObjectRight(left, right) {
-	return IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : IsNever(left) || IsLiteralString(left) && IsObjectStringLike(right) || IsLiteralNumber(left) && IsObjectNumberLike(right) || IsLiteralBoolean(left) && IsObjectBooleanLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsBigInt(left) && IsObjectBigIntLike(right) || IsString(left) && IsObjectStringLike(right) || IsSymbol(left) && IsObjectSymbolLike(right) || IsNumber(left) && IsObjectNumberLike(right) || IsInteger(left) && IsObjectNumberLike(right) || IsBoolean(left) && IsObjectBooleanLike(right) || IsUint8Array(left) && IsObjectUint8ArrayLike(right) || IsDate(left) && IsObjectDateLike(right) || IsConstructor(left) && IsObjectConstructorLike(right) || IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : IsRecord(left) && IsString(RecordKey$1(left)) ? right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False : IsRecord(left) && IsNumber(RecordKey$1(left)) ? IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False : ExtendsResult.False;
-}
-function FromObject$6(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : !IsObject(right) ? ExtendsResult.False : (() => {
-		for (const key of Object.getOwnPropertyNames(right.properties)) {
-			if (!(key in left.properties) && !IsOptional(right.properties[key])) return ExtendsResult.False;
-			if (IsOptional(right.properties[key])) return ExtendsResult.True;
-			if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) return ExtendsResult.False;
-		}
-		return ExtendsResult.True;
-	})();
-}
-function FromPromise$1(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit(left.item, right.item));
-}
-function RecordKey$1(schema) {
-	return PatternNumberExact in schema.patternProperties ? Number$1() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
-}
-function RecordValue$1(schema) {
-	return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
-}
-function FromRecordRight(left, right) {
-	const [Key, Value] = [RecordKey$1(right), RecordValue$1(right)];
-	return IsLiteralString(left) && IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True ? ExtendsResult.True : IsUint8Array(left) && IsNumber(Key) ? Visit(left, Value) : IsString(left) && IsNumber(Key) ? Visit(left, Value) : IsArray(left) && IsNumber(Key) ? Visit(left, Value) : IsObject(left) ? (() => {
-		for (const key of Object.getOwnPropertyNames(left.properties)) if (Property(Value, left.properties[key]) === ExtendsResult.False) return ExtendsResult.False;
-		return ExtendsResult.True;
-	})() : ExtendsResult.False;
-}
-function FromRecord$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : !IsRecord(right) ? ExtendsResult.False : Visit(RecordValue$1(left), RecordValue$1(right));
-}
-function FromRegExp(left, right) {
-	return Visit(IsRegExp(left) ? String() : left, IsRegExp(right) ? String() : right);
-}
-function FromStringRight(left, right) {
-	return IsLiteral(left) && IsString$2(left.const) ? ExtendsResult.True : IsString(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromString(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsString(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromSymbol(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromTemplateLiteral$1(left, right) {
-	return IsTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) : IsTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
-}
-function IsArrayOfTuple(left, right) {
-	return IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True);
-}
-function FromTupleRight(left, right) {
-	return IsNever(left) ? ExtendsResult.True : IsUnknown(left) ? ExtendsResult.False : IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
-}
-function FromTuple$2(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !IsTuple(right) ? ExtendsResult.False : IsUndefined$3(left.items) && !IsUndefined$3(right.items) || !IsUndefined$3(left.items) && IsUndefined$3(right.items) ? ExtendsResult.False : IsUndefined$3(left.items) && !IsUndefined$3(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUint8Array(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUndefined(left, right) {
-	return IsStructuralRight(right) ? StructuralRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsRecord(right) ? FromRecordRight(left, right) : IsVoid(right) ? FromVoidRight(left, right) : IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnionRight(left, right) {
-	return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnion$4(left, right) {
-	return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromUnknownRight(left, right) {
-	return ExtendsResult.True;
-}
-function FromUnknown(left, right) {
-	return IsNever(right) ? FromNeverRight(left, right) : IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : IsString(right) ? FromStringRight(left, right) : IsNumber(right) ? FromNumberRight(left, right) : IsInteger(right) ? FromIntegerRight(left, right) : IsBoolean(right) ? FromBooleanRight(left, right) : IsArray(right) ? FromArrayRight(left, right) : IsTuple(right) ? FromTupleRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromVoidRight(left, right) {
-	return IsUndefined(left) ? ExtendsResult.True : IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
-}
-function FromVoid(left, right) {
-	return IsIntersect(right) ? FromIntersectRight(left, right) : IsUnion(right) ? FromUnionRight(left, right) : IsUnknown(right) ? FromUnknownRight(left, right) : IsAny(right) ? FromAnyRight(left, right) : IsObject(right) ? FromObjectRight(left, right) : IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
-}
-function Visit(left, right) {
-	return IsTemplateLiteral(left) || IsTemplateLiteral(right) ? FromTemplateLiteral$1(left, right) : IsRegExp(left) || IsRegExp(right) ? FromRegExp(left, right) : IsNot(left) || IsNot(right) ? FromNot(left, right) : IsAny(left) ? FromAny(left, right) : IsArray(left) ? FromArray$2(left, right) : IsBigInt(left) ? FromBigInt(left, right) : IsBoolean(left) ? FromBoolean(left, right) : IsAsyncIterator(left) ? FromAsyncIterator$2(left, right) : IsConstructor(left) ? FromConstructor$2(left, right) : IsDate(left) ? FromDate(left, right) : IsFunction(left) ? FromFunction$2(left, right) : IsInteger(left) ? FromInteger(left, right) : IsIntersect(left) ? FromIntersect$4(left, right) : IsIterator(left) ? FromIterator$2(left, right) : IsLiteral(left) ? FromLiteral(left, right) : IsNever(left) ? FromNever(left, right) : IsNull(left) ? FromNull(left, right) : IsNumber(left) ? FromNumber(left, right) : IsObject(left) ? FromObject$6(left, right) : IsRecord(left) ? FromRecord$2(left, right) : IsString(left) ? FromString(left, right) : IsSymbol(left) ? FromSymbol(left, right) : IsTuple(left) ? FromTuple$2(left, right) : IsPromise(left) ? FromPromise$1(left, right) : IsUint8Array(left) ? FromUint8Array(left, right) : IsUndefined(left) ? FromUndefined(left, right) : IsUnion(left) ? FromUnion$4(left, right) : IsUnknown(left) ? FromUnknown(left, right) : IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`);
-}
-function ExtendsCheck(left, right) {
-	return Visit(left, right);
-}
-function FromProperties$11(P, Right, True, False, options) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
-	return Acc;
-}
-function FromMappedResult$6(Left, Right, True, False, options) {
-	return FromProperties$11(Left.properties, Right, True, False, options);
-}
-function ExtendsFromMappedResult(Left, Right, True, False, options) {
-	return MappedResult(FromMappedResult$6(Left, Right, True, False, options));
-}
-function ExtendsResolve(left, right, trueType, falseType) {
-	const R = ExtendsCheck(left, right);
-	return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
-}
-function Extends(L, R, T, F, options) {
-	return IsMappedResult$1(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey$1(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
-}
-function FromPropertyKey$2(K, U, L, R, options) {
-	return { [K]: Extends(Literal(K), U, L, R, Clone(options)) };
-}
-function FromPropertyKeys$2(K, U, L, R, options) {
-	return K.reduce((Acc, LK) => {
-		return {
-			...Acc,
-			...FromPropertyKey$2(LK, U, L, R, options)
-		};
-	}, {});
-}
-function FromMappedKey$2(K, U, L, R, options) {
-	return FromPropertyKeys$2(K.keys, U, L, R, options);
-}
-function ExtendsFromMappedKey(T, U, L, R, options) {
-	return MappedResult(FromMappedKey$2(T, U, L, R, options));
-}
-function ExcludeFromTemplateLiteral(L, R) {
-	return Exclude(TemplateLiteralToUnion(L), R);
-}
-function ExcludeRest(L, R) {
-	const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
-	return excluded.length === 1 ? excluded[0] : Union(excluded);
-}
-function Exclude(L, R, options = {}) {
-	if (IsTemplateLiteral$1(L)) return CreateType(ExcludeFromTemplateLiteral(L, R), options);
-	if (IsMappedResult$1(L)) return CreateType(ExcludeFromMappedResult(L, R), options);
-	return CreateType(IsUnion$1(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
-}
-function FromProperties$10(P, U) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Exclude(P[K2], U);
-	return Acc;
-}
-function FromMappedResult$5(R, T) {
-	return FromProperties$10(R.properties, T);
-}
-function ExcludeFromMappedResult(R, T) {
-	return MappedResult(FromMappedResult$5(R, T));
-}
-function ExtractFromTemplateLiteral(L, R) {
-	return Extract(TemplateLiteralToUnion(L), R);
-}
-function ExtractRest(L, R) {
-	const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-	return extracted.length === 1 ? extracted[0] : Union(extracted);
-}
-function Extract(L, R, options) {
-	if (IsTemplateLiteral$1(L)) return CreateType(ExtractFromTemplateLiteral(L, R), options);
-	if (IsMappedResult$1(L)) return CreateType(ExtractFromMappedResult(L, R), options);
-	return CreateType(IsUnion$1(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
-}
-function FromProperties$9(P, T) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Extract(P[K2], T);
-	return Acc;
-}
-function FromMappedResult$4(R, T) {
-	return FromProperties$9(R.properties, T);
-}
-function ExtractFromMappedResult(R, T) {
-	return MappedResult(FromMappedResult$4(R, T));
-}
-function InstanceType(schema, options) {
-	return IsConstructor$1(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-function ReadonlyOptional(schema) {
-	return Readonly(Optional(schema));
-}
-function RecordCreateFromPattern(pattern, T, options) {
-	return CreateType({
-		[Kind]: "Record",
-		type: "object",
-		patternProperties: { [pattern]: T }
-	}, options);
-}
-function RecordCreateFromKeys(K, T, options) {
-	const result = {};
-	for (const K2 of K) result[K2] = T;
-	return Object$1(result, {
-		...options,
-		[Hint]: "Record"
-	});
-}
-function FromTemplateLiteralKey(K, T, options) {
-	return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
-}
-function FromUnionKey(key, type, options) {
-	return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
-}
-function FromLiteralKey(key, type, options) {
-	return RecordCreateFromKeys([key.toString()], type, options);
-}
-function FromRegExpKey(key, type, options) {
-	return RecordCreateFromPattern(key.source, type, options);
-}
-function FromStringKey(key, type, options) {
-	return RecordCreateFromPattern(IsUndefined$3(key.pattern) ? PatternStringExact : key.pattern, type, options);
-}
-function FromAnyKey(_, type, options) {
-	return RecordCreateFromPattern(PatternStringExact, type, options);
-}
-function FromNeverKey(_key, type, options) {
-	return RecordCreateFromPattern(PatternNeverExact, type, options);
-}
-function FromBooleanKey(_key, type, options) {
-	return Object$1({
-		true: type,
-		false: type
-	}, options);
-}
-function FromIntegerKey(_key, type, options) {
-	return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function FromNumberKey(_, type, options) {
-	return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-function Record(key, type, options = {}) {
-	return IsUnion$1(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral$1(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral$1(key) ? FromLiteralKey(key.const, type, options) : IsBoolean$1(key) ? FromBooleanKey(key, type, options) : IsInteger$1(key) ? FromIntegerKey(key, type, options) : IsNumber$1(key) ? FromNumberKey(key, type, options) : IsRegExp$1(key) ? FromRegExpKey(key, type, options) : IsString$1(key) ? FromStringKey(key, type, options) : IsAny$1(key) ? FromAnyKey(key, type, options) : IsNever$1(key) ? FromNeverKey(key, type, options) : Never(options);
-}
-function RecordPattern(record) {
-	return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
-}
-function RecordKey(type) {
-	const pattern = RecordPattern(type);
-	return pattern === PatternStringExact ? String() : pattern === PatternNumberExact ? Number$1() : String({ pattern });
-}
-function RecordValue(type) {
-	return type.patternProperties[RecordPattern(type)];
-}
-function FromConstructor$1(args, type) {
-	type.parameters = FromTypes$1(args, type.parameters);
-	type.returns = FromType$1(args, type.returns);
-	return type;
-}
-function FromFunction$1(args, type) {
-	type.parameters = FromTypes$1(args, type.parameters);
-	type.returns = FromType$1(args, type.returns);
-	return type;
-}
-function FromIntersect$3(args, type) {
-	type.allOf = FromTypes$1(args, type.allOf);
-	return type;
-}
-function FromUnion$3(args, type) {
-	type.anyOf = FromTypes$1(args, type.anyOf);
-	return type;
-}
-function FromTuple$1(args, type) {
-	if (IsUndefined$3(type.items)) return type;
-	type.items = FromTypes$1(args, type.items);
-	return type;
-}
-function FromArray$1(args, type) {
-	type.items = FromType$1(args, type.items);
-	return type;
-}
-function FromAsyncIterator$1(args, type) {
-	type.items = FromType$1(args, type.items);
-	return type;
-}
-function FromIterator$1(args, type) {
-	type.items = FromType$1(args, type.items);
-	return type;
-}
-function FromPromise(args, type) {
-	type.item = FromType$1(args, type.item);
-	return type;
-}
-function FromObject$5(args, type) {
-	const mappedProperties = FromProperties$8(args, type.properties);
-	return {
-		...type,
-		...Object$1(mappedProperties)
-	};
-}
-function FromRecord$1(args, type) {
-	const result = Record(FromType$1(args, RecordKey(type)), FromType$1(args, RecordValue(type)));
-	return {
-		...type,
-		...result
-	};
-}
-function FromArgument(args, argument) {
-	return argument.index in args ? args[argument.index] : Unknown();
-}
-function FromProperty$1(args, type) {
-	const isReadonly = IsReadonly(type);
-	const isOptional = IsOptional$1(type);
-	const mapped = FromType$1(args, type);
-	return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
-}
-function FromProperties$8(args, properties) {
-	return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
-		return {
-			...result,
-			[key]: FromProperty$1(args, properties[key])
-		};
-	}, {});
-}
-function FromTypes$1(args, types) {
-	return types.map((type) => FromType$1(args, type));
-}
-function FromType$1(args, type) {
-	return IsConstructor$1(type) ? FromConstructor$1(args, type) : IsFunction$1(type) ? FromFunction$1(args, type) : IsIntersect$1(type) ? FromIntersect$3(args, type) : IsUnion$1(type) ? FromUnion$3(args, type) : IsTuple$1(type) ? FromTuple$1(args, type) : IsArray$1(type) ? FromArray$1(args, type) : IsAsyncIterator$1(type) ? FromAsyncIterator$1(args, type) : IsIterator$1(type) ? FromIterator$1(args, type) : IsPromise$1(type) ? FromPromise(args, type) : IsObject$1(type) ? FromObject$5(args, type) : IsRecord$1(type) ? FromRecord$1(args, type) : IsArgument$1(type) ? FromArgument(args, type) : type;
-}
-function Instantiate(type, args) {
-	return FromType$1(args, CloneType(type));
-}
-function Integer(options) {
-	return CreateType({
-		[Kind]: "Integer",
-		type: "integer"
-	}, options);
-}
-function MappedIntrinsicPropertyKey(K, M, options) {
-	return { [K]: Intrinsic(Literal(K), M, Clone(options)) };
-}
-function MappedIntrinsicPropertyKeys(K, M, options) {
-	return K.reduce((Acc, L) => {
-		return {
-			...Acc,
-			...MappedIntrinsicPropertyKey(L, M, options)
-		};
-	}, {});
-}
-function MappedIntrinsicProperties(T, M, options) {
-	return MappedIntrinsicPropertyKeys(T["keys"], M, options);
-}
-function IntrinsicFromMappedKey(T, M, options) {
-	return MappedResult(MappedIntrinsicProperties(T, M, options));
-}
-function ApplyUncapitalize(value) {
-	const [first, rest] = [value.slice(0, 1), value.slice(1)];
-	return [first.toLowerCase(), rest].join("");
-}
-function ApplyCapitalize(value) {
-	const [first, rest] = [value.slice(0, 1), value.slice(1)];
-	return [first.toUpperCase(), rest].join("");
-}
-function ApplyUppercase(value) {
-	return value.toUpperCase();
-}
-function ApplyLowercase(value) {
-	return value.toLowerCase();
-}
-function FromTemplateLiteral(schema, mode, options) {
-	const expression = TemplateLiteralParseExact(schema.pattern);
-	if (!IsTemplateLiteralExpressionFinite(expression)) return {
-		...schema,
-		pattern: FromLiteralValue(schema.pattern, mode)
-	};
-	return TemplateLiteral([Union(FromRest$2([...TemplateLiteralExpressionGenerate(expression)].map((value) => Literal(value)), mode))], options);
-}
-function FromLiteralValue(value, mode) {
-	return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
-}
-function FromRest$2(T, M) {
-	return T.map((L) => Intrinsic(L, M));
-}
-function Intrinsic(schema, mode, options = {}) {
-	return IsMappedKey$1(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral$1(schema) ? FromTemplateLiteral(schema, mode, options) : IsUnion$1(schema) ? Union(FromRest$2(schema.anyOf, mode), options) : IsLiteral$1(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
-}
-function Capitalize(T, options = {}) {
-	return Intrinsic(T, "Capitalize", options);
-}
-function Lowercase(T, options = {}) {
-	return Intrinsic(T, "Lowercase", options);
-}
-function Uncapitalize(T, options = {}) {
-	return Intrinsic(T, "Uncapitalize", options);
-}
-function Uppercase(T, options = {}) {
-	return Intrinsic(T, "Uppercase", options);
-}
-function FromProperties$7(properties, propertyKeys, options) {
-	const result = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
-	return result;
-}
-function FromMappedResult$3(mappedResult, propertyKeys, options) {
-	return FromProperties$7(mappedResult.properties, propertyKeys, options);
-}
-function OmitFromMappedResult(mappedResult, propertyKeys, options) {
-	return MappedResult(FromMappedResult$3(mappedResult, propertyKeys, options));
-}
-function FromIntersect$2(types, propertyKeys) {
-	return types.map((type) => OmitResolve(type, propertyKeys));
-}
-function FromUnion$2(types, propertyKeys) {
-	return types.map((type) => OmitResolve(type, propertyKeys));
-}
-function FromProperty(properties, key) {
-	const { [key]: _, ...R } = properties;
-	return R;
-}
-function FromProperties$6(properties, propertyKeys) {
-	return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
-}
-function FromObject$4(type, propertyKeys, properties) {
-	const options = Discard(type, [
-		TransformKind,
-		"$id",
-		"required",
-		"properties"
-	]);
-	return Object$1(FromProperties$6(properties, propertyKeys), options);
-}
-function UnionFromPropertyKeys$1(propertyKeys) {
-	return Union(propertyKeys.reduce((result, key) => IsLiteralValue$1(key) ? [...result, Literal(key)] : result, []));
-}
-function OmitResolve(type, propertyKeys) {
-	return IsIntersect$1(type) ? Intersect(FromIntersect$2(type.allOf, propertyKeys)) : IsUnion$1(type) ? Union(FromUnion$2(type.anyOf, propertyKeys)) : IsObject$1(type) ? FromObject$4(type, propertyKeys, type.properties) : Object$1({});
-}
-function Omit(type, key, options) {
-	const typeKey = IsArray$3(key) ? UnionFromPropertyKeys$1(key) : key;
-	const propertyKeys = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
-	const isTypeRef = IsRef$1(type);
-	const isKeyRef = IsRef$1(key);
-	return IsMappedResult$1(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey$1(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({
-		...OmitResolve(type, propertyKeys),
-		...options
-	});
-}
-function FromPropertyKey$1(type, key, options) {
-	return { [key]: Omit(type, [key], Clone(options)) };
-}
-function FromPropertyKeys$1(type, propertyKeys, options) {
-	return propertyKeys.reduce((Acc, LK) => {
-		return {
-			...Acc,
-			...FromPropertyKey$1(type, LK, options)
-		};
-	}, {});
-}
-function FromMappedKey$1(type, mappedKey, options) {
-	return FromPropertyKeys$1(type, mappedKey.keys, options);
-}
-function OmitFromMappedKey(type, mappedKey, options) {
-	return MappedResult(FromMappedKey$1(type, mappedKey, options));
-}
-function FromProperties$5(properties, propertyKeys, options) {
-	const result = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
-	return result;
-}
-function FromMappedResult$2(mappedResult, propertyKeys, options) {
-	return FromProperties$5(mappedResult.properties, propertyKeys, options);
-}
-function PickFromMappedResult(mappedResult, propertyKeys, options) {
-	return MappedResult(FromMappedResult$2(mappedResult, propertyKeys, options));
-}
-function FromIntersect$1(types, propertyKeys) {
-	return types.map((type) => PickResolve(type, propertyKeys));
-}
-function FromUnion$1(types, propertyKeys) {
-	return types.map((type) => PickResolve(type, propertyKeys));
-}
-function FromProperties$4(properties, propertyKeys) {
-	const result = {};
-	for (const K2 of propertyKeys) if (K2 in properties) result[K2] = properties[K2];
-	return result;
-}
-function FromObject$3(Type, keys, properties) {
-	const options = Discard(Type, [
-		TransformKind,
-		"$id",
-		"required",
-		"properties"
-	]);
-	return Object$1(FromProperties$4(properties, keys), options);
-}
-function UnionFromPropertyKeys(propertyKeys) {
-	return Union(propertyKeys.reduce((result, key) => IsLiteralValue$1(key) ? [...result, Literal(key)] : result, []));
-}
-function PickResolve(type, propertyKeys) {
-	return IsIntersect$1(type) ? Intersect(FromIntersect$1(type.allOf, propertyKeys)) : IsUnion$1(type) ? Union(FromUnion$1(type.anyOf, propertyKeys)) : IsObject$1(type) ? FromObject$3(type, propertyKeys, type.properties) : Object$1({});
-}
-function Pick(type, key, options) {
-	const typeKey = IsArray$3(key) ? UnionFromPropertyKeys(key) : key;
-	const propertyKeys = IsSchema$1(key) ? IndexPropertyKeys(key) : key;
-	const isTypeRef = IsRef$1(type);
-	const isKeyRef = IsRef$1(key);
-	return IsMappedResult$1(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey$1(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({
-		...PickResolve(type, propertyKeys),
-		...options
-	});
-}
-function FromPropertyKey(type, key, options) {
-	return { [key]: Pick(type, [key], Clone(options)) };
-}
-function FromPropertyKeys(type, propertyKeys, options) {
-	return propertyKeys.reduce((result, leftKey) => {
-		return {
-			...result,
-			...FromPropertyKey(type, leftKey, options)
-		};
-	}, {});
-}
-function FromMappedKey(type, mappedKey, options) {
-	return FromPropertyKeys(type, mappedKey.keys, options);
-}
-function PickFromMappedKey(type, mappedKey, options) {
-	return MappedResult(FromMappedKey(type, mappedKey, options));
-}
-function FromComputed$2(target, parameters) {
-	return Computed("Partial", [Computed(target, parameters)]);
-}
-function FromRef$1($ref) {
-	return Computed("Partial", [Ref($ref)]);
-}
-function FromProperties$3(properties) {
-	const partialProperties = {};
-	for (const K of globalThis.Object.getOwnPropertyNames(properties)) partialProperties[K] = Optional(properties[K]);
-	return partialProperties;
-}
-function FromObject$2(type, properties) {
-	const options = Discard(type, [
-		TransformKind,
-		"$id",
-		"required",
-		"properties"
-	]);
-	return Object$1(FromProperties$3(properties), options);
-}
-function FromRest$1(types) {
-	return types.map((type) => PartialResolve(type));
-}
-function PartialResolve(type) {
-	return IsComputed$1(type) ? FromComputed$2(type.target, type.parameters) : IsRef$1(type) ? FromRef$1(type.$ref) : IsIntersect$1(type) ? Intersect(FromRest$1(type.allOf)) : IsUnion$1(type) ? Union(FromRest$1(type.anyOf)) : IsObject$1(type) ? FromObject$2(type, type.properties) : IsBigInt$1(type) ? type : IsBoolean$1(type) ? type : IsInteger$1(type) ? type : IsLiteral$1(type) ? type : IsNull$1(type) ? type : IsNumber$1(type) ? type : IsString$1(type) ? type : IsSymbol$1(type) ? type : IsUndefined$1(type) ? type : Object$1({});
-}
-function Partial(type, options) {
-	if (IsMappedResult$1(type)) return PartialFromMappedResult(type, options);
-	else return CreateType({
-		...PartialResolve(type),
-		...options
-	});
-}
-function FromProperties$2(K, options) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(K)) Acc[K2] = Partial(K[K2], Clone(options));
-	return Acc;
-}
-function FromMappedResult$1(R, options) {
-	return FromProperties$2(R.properties, options);
-}
-function PartialFromMappedResult(R, options) {
-	return MappedResult(FromMappedResult$1(R, options));
-}
-function FromComputed$1(target, parameters) {
-	return Computed("Required", [Computed(target, parameters)]);
-}
-function FromRef($ref) {
-	return Computed("Required", [Ref($ref)]);
-}
-function FromProperties$1(properties) {
-	const requiredProperties = {};
-	for (const K of globalThis.Object.getOwnPropertyNames(properties)) requiredProperties[K] = Discard(properties[K], [OptionalKind]);
-	return requiredProperties;
-}
-function FromObject$1(type, properties) {
-	const options = Discard(type, [
-		TransformKind,
-		"$id",
-		"required",
-		"properties"
-	]);
-	return Object$1(FromProperties$1(properties), options);
-}
-function FromRest(types) {
-	return types.map((type) => RequiredResolve(type));
-}
-function RequiredResolve(type) {
-	return IsComputed$1(type) ? FromComputed$1(type.target, type.parameters) : IsRef$1(type) ? FromRef(type.$ref) : IsIntersect$1(type) ? Intersect(FromRest(type.allOf)) : IsUnion$1(type) ? Union(FromRest(type.anyOf)) : IsObject$1(type) ? FromObject$1(type, type.properties) : IsBigInt$1(type) ? type : IsBoolean$1(type) ? type : IsInteger$1(type) ? type : IsLiteral$1(type) ? type : IsNull$1(type) ? type : IsNumber$1(type) ? type : IsString$1(type) ? type : IsSymbol$1(type) ? type : IsUndefined$1(type) ? type : Object$1({});
-}
-function Required(type, options) {
-	if (IsMappedResult$1(type)) return RequiredFromMappedResult(type, options);
-	else return CreateType({
-		...RequiredResolve(type),
-		...options
-	});
-}
-function FromProperties(P, options) {
-	const Acc = {};
-	for (const K2 of globalThis.Object.getOwnPropertyNames(P)) Acc[K2] = Required(P[K2], options);
-	return Acc;
-}
-function FromMappedResult(R, options) {
-	return FromProperties(R.properties, options);
-}
-function RequiredFromMappedResult(R, options) {
-	return MappedResult(FromMappedResult(R, options));
-}
-function DereferenceParameters(moduleProperties, types) {
-	return types.map((type) => {
-		return IsRef$1(type) ? Dereference(moduleProperties, type.$ref) : FromType(moduleProperties, type);
-	});
-}
-function Dereference(moduleProperties, ref) {
-	return ref in moduleProperties ? IsRef$1(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
-}
-function FromAwaited(parameters) {
-	return Awaited(parameters[0]);
-}
-function FromIndex(parameters) {
-	return Index(parameters[0], parameters[1]);
-}
-function FromKeyOf(parameters) {
-	return KeyOf(parameters[0]);
-}
-function FromPartial(parameters) {
-	return Partial(parameters[0]);
-}
-function FromOmit(parameters) {
-	return Omit(parameters[0], parameters[1]);
-}
-function FromPick(parameters) {
-	return Pick(parameters[0], parameters[1]);
-}
-function FromRequired(parameters) {
-	return Required(parameters[0]);
-}
-function FromComputed(moduleProperties, target, parameters) {
-	const dereferenced = DereferenceParameters(moduleProperties, parameters);
-	return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
-}
-function FromArray(moduleProperties, type) {
-	return Array$1(FromType(moduleProperties, type));
-}
-function FromAsyncIterator(moduleProperties, type) {
-	return AsyncIterator(FromType(moduleProperties, type));
-}
-function FromConstructor(moduleProperties, parameters, instanceType) {
-	return Constructor(FromTypes(moduleProperties, parameters), FromType(moduleProperties, instanceType));
-}
-function FromFunction(moduleProperties, parameters, returnType) {
-	return Function(FromTypes(moduleProperties, parameters), FromType(moduleProperties, returnType));
-}
-function FromIntersect(moduleProperties, types) {
-	return Intersect(FromTypes(moduleProperties, types));
-}
-function FromIterator(moduleProperties, type) {
-	return Iterator(FromType(moduleProperties, type));
-}
-function FromObject(moduleProperties, properties) {
-	return Object$1(globalThis.Object.keys(properties).reduce((result, key) => {
-		return {
-			...result,
-			[key]: FromType(moduleProperties, properties[key])
-		};
-	}, {}));
-}
-function FromRecord(moduleProperties, type) {
-	const [value, pattern] = [FromType(moduleProperties, RecordValue(type)), RecordPattern(type)];
-	const result = CloneType(type);
-	result.patternProperties[pattern] = value;
-	return result;
-}
-function FromTransform(moduleProperties, transform) {
-	return IsRef$1(transform) ? {
-		...Dereference(moduleProperties, transform.$ref),
-		[TransformKind]: transform[TransformKind]
-	} : transform;
-}
-function FromTuple(moduleProperties, types) {
-	return Tuple(FromTypes(moduleProperties, types));
-}
-function FromUnion(moduleProperties, types) {
-	return Union(FromTypes(moduleProperties, types));
-}
-function FromTypes(moduleProperties, types) {
-	return types.map((type) => FromType(moduleProperties, type));
-}
-function FromType(moduleProperties, type) {
-	return IsOptional$1(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : IsTransform$1(type) ? CreateType(FromTransform(moduleProperties, type), type) : IsArray$1(type) ? CreateType(FromArray(moduleProperties, type.items), type) : IsAsyncIterator$1(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) : IsComputed$1(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) : IsConstructor$1(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) : IsFunction$1(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) : IsIntersect$1(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) : IsIterator$1(type) ? CreateType(FromIterator(moduleProperties, type.items), type) : IsObject$1(type) ? CreateType(FromObject(moduleProperties, type.properties), type) : IsRecord$1(type) ? CreateType(FromRecord(moduleProperties, type)) : IsTuple$1(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) : IsUnion$1(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) : type;
-}
-function ComputeType(moduleProperties, key) {
-	return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
-}
-function ComputeModuleProperties(moduleProperties) {
-	return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
-		return {
-			...result,
-			[key]: ComputeType(moduleProperties, key)
-		};
-	}, {});
-}
-var TModule = class {
-	constructor($defs) {
-		const computed = ComputeModuleProperties($defs);
-		this.$defs = this.WithIdentifiers(computed);
-	}
-	Import(key, options) {
-		const $defs = {
-			...this.$defs,
-			[key]: CreateType(this.$defs[key], options)
-		};
-		return CreateType({
-			[Kind]: "Import",
-			$defs,
-			$ref: key
-		});
-	}
-	WithIdentifiers($defs) {
-		return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
-			return {
-				...result,
-				[key]: {
-					...$defs[key],
-					$id: key
-				}
-			};
-		}, {});
-	}
-};
-function Module(properties) {
-	return new TModule(properties);
-}
-function Not(type, options) {
-	return CreateType({
-		[Kind]: "Not",
-		not: type
-	}, options);
-}
-function Parameters(schema, options) {
-	return IsFunction$1(schema) ? Tuple(schema.parameters, options) : Never();
-}
-let Ordinal = 0;
-function Recursive(callback, options = {}) {
-	if (IsUndefined$3(options.$id)) options.$id = `T${Ordinal++}`;
-	const thisType = CloneType(callback({
-		[Kind]: "This",
-		$ref: `${options.$id}`
-	}));
-	thisType.$id = options.$id;
-	return CreateType({
-		[Hint]: "Recursive",
-		...thisType
-	}, options);
-}
-function RegExp$1(unresolved, options) {
-	const expr = IsString$2(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-	return CreateType({
-		[Kind]: "RegExp",
-		type: "RegExp",
-		source: expr.source,
-		flags: expr.flags
-	}, options);
-}
-function RestResolve(T) {
-	return IsIntersect$1(T) ? T.allOf : IsUnion$1(T) ? T.anyOf : IsTuple$1(T) ? T.items ?? [] : [];
-}
-function Rest(T) {
-	return RestResolve(T);
-}
-function ReturnType(schema, options) {
-	return IsFunction$1(schema) ? CreateType(schema.returns, options) : Never(options);
-}
-var TransformDecodeBuilder = class {
-	constructor(schema) {
-		this.schema = schema;
-	}
-	Decode(decode) {
-		return new TransformEncodeBuilder(this.schema, decode);
-	}
-};
-var TransformEncodeBuilder = class {
-	constructor(schema, decode) {
-		this.schema = schema;
-		this.decode = decode;
-	}
-	EncodeTransform(encode, schema) {
-		const Encode = (value) => schema[TransformKind].Encode(encode(value));
-		const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-		const Codec = {
-			Encode,
-			Decode
-		};
-		return {
-			...schema,
-			[TransformKind]: Codec
-		};
-	}
-	EncodeSchema(encode, schema) {
-		const Codec = {
-			Decode: this.decode,
-			Encode: encode
-		};
-		return {
-			...schema,
-			[TransformKind]: Codec
-		};
-	}
-	Encode(encode) {
-		return IsTransform$1(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
-	}
-};
-function Transform(schema) {
-	return new TransformDecodeBuilder(schema);
-}
-function Unsafe(options = {}) {
-	return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
-}
-function Void(options) {
-	return CreateType({
-		[Kind]: "Void",
-		type: "void"
-	}, options);
-}
-const Type = /* @__PURE__ */ __exportAll({
-	Any: () => Any,
-	Argument: () => Argument,
-	Array: () => Array$1,
-	AsyncIterator: () => AsyncIterator,
-	Awaited: () => Awaited,
-	BigInt: () => BigInt,
-	Boolean: () => Boolean,
-	Capitalize: () => Capitalize,
-	Composite: () => Composite,
-	Const: () => Const,
-	Constructor: () => Constructor,
-	ConstructorParameters: () => ConstructorParameters,
-	Date: () => Date$1,
-	Enum: () => Enum,
-	Exclude: () => Exclude,
-	Extends: () => Extends,
-	Extract: () => Extract,
-	Function: () => Function,
-	Index: () => Index,
-	InstanceType: () => InstanceType,
-	Instantiate: () => Instantiate,
-	Integer: () => Integer,
-	Intersect: () => Intersect,
-	Iterator: () => Iterator,
-	KeyOf: () => KeyOf,
-	Literal: () => Literal,
-	Lowercase: () => Lowercase,
-	Mapped: () => Mapped,
-	Module: () => Module,
-	Never: () => Never,
-	Not: () => Not,
-	Null: () => Null,
-	Number: () => Number$1,
-	Object: () => Object$1,
-	Omit: () => Omit,
-	Optional: () => Optional,
-	Parameters: () => Parameters,
-	Partial: () => Partial,
-	Pick: () => Pick,
-	Promise: () => Promise$1,
-	Readonly: () => Readonly,
-	ReadonlyOptional: () => ReadonlyOptional,
-	Record: () => Record,
-	Recursive: () => Recursive,
-	Ref: () => Ref,
-	RegExp: () => RegExp$1,
-	Required: () => Required,
-	Rest: () => Rest,
-	ReturnType: () => ReturnType,
-	String: () => String,
-	Symbol: () => Symbol$1,
-	TemplateLiteral: () => TemplateLiteral,
-	Transform: () => Transform,
-	Tuple: () => Tuple,
-	Uint8Array: () => Uint8Array$1,
-	Uncapitalize: () => Uncapitalize,
-	Undefined: () => Undefined,
-	Union: () => Union,
-	Unknown: () => Unknown,
-	Unsafe: () => Unsafe,
-	Uppercase: () => Uppercase,
-	Void: () => Void
-});
-export { Type as t };
-
-//# sourceMappingURL=typebox.mjs.map