@elysiajs/jwt 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -120,7 +120,7 @@ function IsObject2(value) {
   return value !== null && typeof value === "object";
 }
 function IsArray2(value) {
-  return Array.isArray(value) && !ArrayBuffer.isView(value);
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
 }
 function IsUndefined2(value) {
   return value === void 0;
@@ -225,6 +225,9 @@ function IsOptional(value) {
 function IsAny(value) {
   return IsKindOf(value, "Any");
 }
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
+}
 function IsArray3(value) {
   return IsKindOf(value, "Array");
 }
@@ -340,13 +343,14 @@ function IsKind(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]);
 }
 function IsSchema(value) {
-  return IsAny(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 var type_exports = {};
 __export(type_exports, {
   IsAny: () => IsAny2,
+  IsArgument: () => IsArgument2,
   IsArray: () => IsArray4,
   IsAsyncIterator: () => IsAsyncIterator3,
   IsBigInt: () => IsBigInt3,
@@ -400,6 +404,7 @@ __export(type_exports, {
 var TypeGuardUnknownTypeError = class extends TypeBoxError {
 };
 var KnownTypes = [
+  "Argument",
   "Any",
   "Array",
   "AsyncIterator",
@@ -487,6 +492,9 @@ function IsOptional2(value) {
 function IsAny2(value) {
   return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
 }
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+}
 function IsArray4(value) {
   return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
 }
@@ -627,7 +635,7 @@ function IsKind2(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
 function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
@@ -675,6 +683,11 @@ function Array2(items, options) {
   return CreateType({ [Kind]: "Array", type: "array", items }, options);
 }
 
+// node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
+function Argument(index) {
+  return CreateType({ [Kind]: "Argument", index });
+}
+
 // node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
 function AsyncIterator(items, options) {
   return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
@@ -1490,7 +1503,7 @@ function Const(T, options) {
 
 // node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
 function ConstructorParameters(schema, options) {
-  return Tuple(schema.parameters, options);
+  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
@@ -1865,7 +1878,142 @@ function ExtractFromMappedResult(R, T) {
 
 // node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
 function InstanceType(schema, options) {
-  return CreateType(schema.returns, options);
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
+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 Object2(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) {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(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 Object2({ 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(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean2(key) ? FromBooleanKey(key, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
+}
+function RecordPattern(record) {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+function RecordKey2(type) {
+  const pattern = RecordPattern(type);
+  return pattern === PatternStringExact ? String() : pattern === PatternNumberExact ? Number2() : String({ pattern });
+}
+function RecordValue2(type) {
+  return type.patternProperties[RecordPattern(type)];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromFunction2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromIntersect5(args, type) {
+  type.allOf = FromTypes(args, type.allOf);
+  return type;
+}
+function FromUnion7(args, type) {
+  type.anyOf = FromTypes(args, type.anyOf);
+  return type;
+}
+function FromTuple4(args, type) {
+  if (IsUndefined(type.items))
+    return type;
+  type.items = FromTypes(args, type.items);
+  return type;
+}
+function FromArray5(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromAsyncIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromPromise3(args, type) {
+  type.item = FromType(args, type.item);
+  return type;
+}
+function FromObject2(args, type) {
+  const mappedProperties = FromProperties11(args, type.properties);
+  return { ...type, ...Object2(mappedProperties) };
+}
+function FromRecord2(args, type) {
+  const mappedKey = FromType(args, RecordKey2(type));
+  const mappedValue = FromType(args, RecordValue2(type));
+  const result = Record(mappedKey, mappedValue);
+  return { ...type, ...result };
+}
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty2(args, type) {
+  const isReadonly = IsReadonly(type);
+  const isOptional = IsOptional(type);
+  const mapped = FromType(args, type);
+  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties11(args, properties) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty2(args, properties[key]) };
+  }, {});
+}
+function FromTypes(args, types) {
+  return types.map((type) => FromType(args, type));
+}
+function FromType(args, type) {
+  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+function Instantiate(type, args) {
+  return FromType(args, CloneType(type));
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
@@ -1959,14 +2107,14 @@ function Uppercase(T, options = {}) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
-function FromProperties11(properties, propertyKeys, options) {
+function FromProperties12(properties, propertyKeys, options) {
   const result = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
     result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
   return result;
 }
 function FromMappedResult9(mappedResult, propertyKeys, options) {
-  return FromProperties11(mappedResult.properties, propertyKeys, options);
+  return FromProperties12(mappedResult.properties, propertyKeys, options);
 }
 function OmitFromMappedResult(mappedResult, propertyKeys, options) {
   const properties = FromMappedResult9(mappedResult, propertyKeys, options);
@@ -1974,22 +2122,22 @@ function OmitFromMappedResult(mappedResult, propertyKeys, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
-function FromIntersect5(types, propertyKeys) {
+function FromIntersect6(types, propertyKeys) {
   return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromUnion7(types, propertyKeys) {
+function FromUnion8(types, propertyKeys) {
   return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromProperty2(properties, key) {
+function FromProperty3(properties, key) {
   const { [key]: _, ...R } = properties;
   return R;
 }
-function FromProperties12(properties, propertyKeys) {
-  return propertyKeys.reduce((T, K2) => FromProperty2(T, K2), properties);
+function FromProperties13(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty3(T, K2), properties);
 }
-function FromObject2(properties, propertyKeys) {
+function FromObject3(properties, propertyKeys) {
   const options = Discard(properties, [TransformKind, "$id", "required", "properties"]);
-  const omittedProperties = FromProperties12(properties["properties"], propertyKeys);
+  const omittedProperties = FromProperties13(properties["properties"], propertyKeys);
   return Object2(omittedProperties, options);
 }
 function UnionFromPropertyKeys(propertyKeys) {
@@ -1997,7 +2145,7 @@ function UnionFromPropertyKeys(propertyKeys) {
   return Union(result);
 }
 function OmitResolve(properties, propertyKeys) {
-  return IsIntersect(properties) ? Intersect(FromIntersect5(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion7(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject2(properties, propertyKeys) : Object2({});
+  return IsIntersect(properties) ? Intersect(FromIntersect6(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion8(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject3(properties, propertyKeys) : Object2({});
 }
 function Omit(type, key, options) {
   const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
@@ -2025,14 +2173,14 @@ function OmitFromMappedKey(type, mappedKey, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
-function FromProperties13(properties, propertyKeys, options) {
+function FromProperties14(properties, propertyKeys, options) {
   const result = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
     result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
   return result;
 }
 function FromMappedResult10(mappedResult, propertyKeys, options) {
-  return FromProperties13(mappedResult.properties, propertyKeys, options);
+  return FromProperties14(mappedResult.properties, propertyKeys, options);
 }
 function PickFromMappedResult(mappedResult, propertyKeys, options) {
   const properties = FromMappedResult10(mappedResult, propertyKeys, options);
@@ -2040,22 +2188,22 @@ function PickFromMappedResult(mappedResult, propertyKeys, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
-function FromIntersect6(types, propertyKeys) {
+function FromIntersect7(types, propertyKeys) {
   return types.map((type) => PickResolve(type, propertyKeys));
 }
-function FromUnion8(types, propertyKeys) {
+function FromUnion9(types, propertyKeys) {
   return types.map((type) => PickResolve(type, propertyKeys));
 }
-function FromProperties14(properties, propertyKeys) {
+function FromProperties15(properties, propertyKeys) {
   const result = {};
   for (const K2 of propertyKeys)
     if (K2 in properties)
       result[K2] = properties[K2];
   return result;
 }
-function FromObject3(T, K) {
+function FromObject4(T, K) {
   const options = Discard(T, [TransformKind, "$id", "required", "properties"]);
-  const properties = FromProperties14(T["properties"], K);
+  const properties = FromProperties15(T["properties"], K);
   return Object2(properties, options);
 }
 function UnionFromPropertyKeys2(propertyKeys) {
@@ -2063,7 +2211,7 @@ function UnionFromPropertyKeys2(propertyKeys) {
   return Union(result);
 }
 function PickResolve(properties, propertyKeys) {
-  return IsIntersect(properties) ? Intersect(FromIntersect6(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion8(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject3(properties, propertyKeys) : Object2({});
+  return IsIntersect(properties) ? Intersect(FromIntersect7(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion9(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject4(properties, propertyKeys) : Object2({});
 }
 function Pick(type, key, options) {
   const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
@@ -2099,22 +2247,31 @@ function FromComputed3(target, parameters) {
 function FromRef3($ref) {
   return Computed("Partial", [Ref($ref)]);
 }
-function FromProperties15(properties) {
+function FromProperties16(properties) {
   const partialProperties = {};
   for (const K of globalThis.Object.getOwnPropertyNames(properties))
     partialProperties[K] = Optional(properties[K]);
   return partialProperties;
 }
-function FromObject4(T) {
-  const options = Discard(T, [TransformKind, "$id", "required", "properties"]);
-  const properties = FromProperties15(T["properties"]);
+function FromObject5(type) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const properties = FromProperties16(type["properties"]);
   return Object2(properties, options);
 }
 function FromRest6(types) {
   return types.map((type) => PartialResolve(type));
 }
 function PartialResolve(type) {
-  return IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject4(type) : Object2({});
+  return (
+    // Mappable
+    IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject5(type) : (
+      // Intrinsic
+      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+        // Passthrough
+        Object2({})
+      )
+    )
+  );
 }
 function Partial(type, options) {
   if (IsMappedResult(type)) {
@@ -2125,62 +2282,20 @@ function Partial(type, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
-function FromProperties16(K, options) {
+function FromProperties17(K, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(K))
     Acc[K2] = Partial(K[K2], Clone(options));
   return Acc;
 }
 function FromMappedResult11(R, options) {
-  return FromProperties16(R.properties, options);
+  return FromProperties17(R.properties, options);
 }
 function PartialFromMappedResult(R, options) {
   const P = FromMappedResult11(R, options);
   return MappedResult(P);
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
-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 Object2(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) {
-  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
-  return RecordCreateFromPattern(pattern, type, options);
-}
-function FromAnyKey(_, type, options) {
-  return RecordCreateFromPattern(PatternStringExact, type, options);
-}
-function FromNeverKey(_key, type, options) {
-  return RecordCreateFromPattern(PatternNeverExact, 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 IsComputed(type) ? Computed("Record", [key, Computed(type.target, type.parameters)], options) : IsComputed(key) ? Computed("Record", [Computed(type.target, type.parameters), type], options) : IsRef(key) ? Computed("Record", [Ref(key.$ref), type]) : IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
-}
-
 // node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
 function FromComputed4(target, parameters) {
   return Computed("Required", [Computed(target, parameters)]);
@@ -2188,22 +2303,31 @@ function FromComputed4(target, parameters) {
 function FromRef4($ref) {
   return Computed("Required", [Ref($ref)]);
 }
-function FromProperties17(properties) {
+function FromProperties18(properties) {
   const requiredProperties = {};
   for (const K of globalThis.Object.getOwnPropertyNames(properties))
     requiredProperties[K] = Discard(properties[K], [OptionalKind]);
   return requiredProperties;
 }
-function FromObject5(type) {
+function FromObject6(type) {
   const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
-  const properties = FromProperties17(type["properties"]);
+  const properties = FromProperties18(type["properties"]);
   return Object2(properties, options);
 }
 function FromRest7(types) {
   return types.map((type) => RequiredResolve(type));
 }
 function RequiredResolve(type) {
-  return IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject5(type) : Object2({});
+  return (
+    // Mappable
+    IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject6(type) : (
+      // Intrinsic
+      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+        // Passthrough
+        Object2({})
+      )
+    )
+  );
 }
 function Required(type, options) {
   if (IsMappedResult(type)) {
@@ -2214,14 +2338,14 @@ function Required(type, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
-function FromProperties18(P, options) {
+function FromProperties19(P, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
     Acc[K2] = Required(P[K2], options);
   return Acc;
 }
 function FromMappedResult12(R, options) {
-  return FromProperties18(R.properties, options);
+  return FromProperties19(R.properties, options);
 }
 function RequiredFromMappedResult(R, options) {
   const P = FromMappedResult12(R, options);
@@ -2229,13 +2353,13 @@ function RequiredFromMappedResult(R, options) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
-function DerefParameters(moduleProperties, types) {
+function DereferenceParameters(moduleProperties, types) {
   return types.map((type) => {
-    return IsRef(type) ? Deref(moduleProperties, type.$ref) : FromType(moduleProperties, type);
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
   });
 }
-function Deref(moduleProperties, ref) {
-  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Deref(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
+function Dereference(moduleProperties, ref) {
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
 }
 function FromAwaited(parameters) {
   return Awaited(parameters[0]);
@@ -2255,59 +2379,68 @@ function FromOmit(parameters) {
 function FromPick(parameters) {
   return Pick(parameters[0], parameters[1]);
 }
-function FromRecord2(parameters) {
-  return Record(parameters[0], parameters[1]);
-}
 function FromRequired(parameters) {
   return Required(parameters[0]);
 }
 function FromComputed5(moduleProperties, target, parameters) {
-  const dereferenced = DerefParameters(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 === "Record" ? FromRecord2(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
+  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 FromObject6(moduleProperties, properties) {
-  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
-    return { ...result, [key]: FromType(moduleProperties, properties[key]) };
-  }, {}));
+function FromArray6(moduleProperties, type) {
+  return Array2(FromType2(moduleProperties, type));
 }
-function FromConstructor2(moduleProperties, parameters, instanceType) {
-  return Constructor(FromRest8(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+function FromAsyncIterator3(moduleProperties, type) {
+  return AsyncIterator(FromType2(moduleProperties, type));
 }
-function FromFunction2(moduleProperties, parameters, returnType) {
-  return Function(FromRest8(moduleProperties, parameters), FromType(moduleProperties, returnType));
+function FromConstructor3(moduleProperties, parameters, instanceType) {
+  return Constructor(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, instanceType));
 }
-function FromTuple4(moduleProperties, types) {
-  return Tuple(FromRest8(moduleProperties, types));
+function FromFunction3(moduleProperties, parameters, returnType) {
+  return Function(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, returnType));
 }
-function FromIntersect7(moduleProperties, types) {
-  return Intersect(FromRest8(moduleProperties, types));
+function FromIntersect8(moduleProperties, types) {
+  return Intersect(FromTypes2(moduleProperties, types));
+}
+function FromIterator3(moduleProperties, type) {
+  return Iterator(FromType2(moduleProperties, type));
+}
+function FromObject7(moduleProperties, properties) {
+  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
+    return { ...result, [key]: FromType2(moduleProperties, properties[key]) };
+  }, {}));
 }
-function FromUnion9(moduleProperties, types) {
-  return Union(FromRest8(moduleProperties, types));
+function FromRecord3(moduleProperties, type) {
+  const [value, pattern] = [FromType2(moduleProperties, RecordValue2(type)), RecordPattern(type)];
+  const result = CloneType(type);
+  result.patternProperties[pattern] = value;
+  return result;
 }
-function FromArray5(moduleProperties, type) {
-  return Array2(FromType(moduleProperties, type));
+function FromTransform(moduleProperties, transform) {
+  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
 }
-function FromAsyncIterator2(moduleProperties, type) {
-  return AsyncIterator(FromType(moduleProperties, type));
+function FromTuple5(moduleProperties, types) {
+  return Tuple(FromTypes2(moduleProperties, types));
 }
-function FromIterator2(moduleProperties, type) {
-  return Iterator(FromType(moduleProperties, type));
+function FromUnion10(moduleProperties, types) {
+  return Union(FromTypes2(moduleProperties, types));
 }
-function FromRest8(moduleProperties, types) {
-  return types.map((type) => FromType(moduleProperties, type));
+function FromTypes2(moduleProperties, types) {
+  return types.map((type) => FromType2(moduleProperties, type));
 }
-function FromType(moduleProperties, type) {
+function FromType2(moduleProperties, type) {
   return (
-    // Modifier Unwrap - Reapplied via CreateType Options
-    IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
-      // Traveral
-      IsArray3(type) ? CreateType(FromArray5(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator2(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor2(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction2(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect7(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator2(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject6(moduleProperties, type.properties), type) : IsTuple(type) ? CreateType(FromTuple4(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion9(moduleProperties, type.anyOf), type) : type
+    // Modifiers
+    IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
+      // Transform
+      IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : (
+        // Types
+        IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type
+      )
     )
   );
 }
 function ComputeType(moduleProperties, key) {
-  return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
+  return key in moduleProperties ? FromType2(moduleProperties, moduleProperties[key]) : Never();
 }
 function ComputeModuleProperties(moduleProperties) {
   return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
@@ -2345,12 +2478,7 @@ function Not(type, options) {
 
 // node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
 function Parameters(schema, options) {
-  return Tuple(schema.parameters, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
-function ReadonlyOptional(schema) {
-  return Readonly(Optional(schema));
+  return IsFunction2(schema) ? Tuple(schema.parameters, options) : Never();
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
@@ -2379,7 +2507,7 @@ function Rest(T) {
 
 // node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
 function ReturnType(schema, options) {
-  return CreateType(schema.returns, options);
+  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
@@ -2428,6 +2556,7 @@ function Void(options) {
 var type_exports2 = {};
 __export(type_exports2, {
   Any: () => Any,
+  Argument: () => Argument,
   Array: () => Array2,
   AsyncIterator: () => AsyncIterator,
   Awaited: () => Awaited,
@@ -2446,6 +2575,7 @@ __export(type_exports2, {
   Function: () => Function,
   Index: () => Index,
   InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
   Integer: () => Integer,
   Intersect: () => Intersect,
   Iterator: () => Iterator,
@@ -2523,7 +2653,9 @@ var jwt = ({
         iat: Type.Optional(Type.String())
       })
     ]),
-    {}
+    {
+      modules: Type.Module({})
+    }
   ) : void 0;
   return new Elysia({
     name: "@elysiajs/jwt",