@sinclair/typebox 0.32.0-dev-20 → 0.32.0-dev-22

package/build/require/errors/errors.js

@@ -133,8 +133,8 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 // Types
 // --------------------------------------------------------------------------
-function* TAny(schema, references, path, value) { }
-function* TArray(schema, references, path, value) {
+function* FromAny(schema, references, path, value) { }
+function* FromArray(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
@@ -175,11 +175,11 @@ function* TArray(schema, references, path, value) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
-function* TAsyncIterator(schema, references, path, value) {
+function* FromAsyncIterator(schema, references, path, value) {
     if (!(0, index_8.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
-function* TBigInt(schema, references, path, value) {
+function* FromBigInt(schema, references, path, value) {
     if (!(0, index_8.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -198,14 +198,14 @@ function* TBigInt(schema, references, path, value) {
         yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
     }
 }
-function* TBoolean(schema, references, path, value) {
+function* FromBoolean(schema, references, path, value) {
     if (!(0, index_8.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
-function* TConstructor(schema, references, path, value) {
+function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
-function* TDate(schema, references, path, value) {
+function* FromDate(schema, references, path, value) {
     if (!(0, index_8.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -224,11 +224,11 @@ function* TDate(schema, references, path, value) {
         yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
     }
 }
-function* TFunction(schema, references, path, value) {
+function* FromFunction(schema, references, path, value) {
     if (!(0, index_8.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
-function* TInteger(schema, references, path, value) {
+function* FromInteger(schema, references, path, value) {
     if (!(0, index_8.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -247,7 +247,7 @@ function* TInteger(schema, references, path, value) {
         yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
     }
 }
-function* TIntersect(schema, references, path, value) {
+function* FromIntersect(schema, references, path, value) {
     for (const inner of schema.allOf) {
         const next = Visit(inner, references, path, value).next();
         if (!next.done) {
@@ -274,26 +274,26 @@ function* TIntersect(schema, references, path, value) {
         }
     }
 }
-function* TIterator(schema, references, path, value) {
+function* FromIterator(schema, references, path, value) {
     if (!(0, index_8.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
-function* TLiteral(schema, references, path, value) {
+function* FromLiteral(schema, references, path, value) {
     if (!(value === schema.const))
         yield Create(ValueErrorType.Literal, schema, path, value);
 }
-function* TNever(schema, references, path, value) {
+function* FromNever(schema, references, path, value) {
     yield Create(ValueErrorType.Never, schema, path, value);
 }
-function* TNot(schema, references, path, value) {
+function* FromNot(schema, references, path, value) {
     if (Visit(schema.not, references, path, value).next().done === true)
         yield Create(ValueErrorType.Not, schema, path, value);
 }
-function* TNull(schema, references, path, value) {
+function* FromNull(schema, references, path, value) {
     if (!(0, index_8.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
-function* TNumber(schema, references, path, value) {
+function* FromNumber(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -312,7 +312,7 @@ function* TNumber(schema, references, path, value) {
         yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
     }
 }
-function* TObject(schema, references, path, value) {
+function* FromObject(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -358,11 +358,11 @@ function* TObject(schema, references, path, value) {
         }
     }
 }
-function* TPromise(schema, references, path, value) {
+function* FromPromise(schema, references, path, value) {
     if (!(0, index_8.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
-function* TRecord(schema, references, path, value) {
+function* FromRecord(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -391,10 +391,10 @@ function* TRecord(schema, references, path, value) {
         }
     }
 }
-function* TRef(schema, references, path, value) {
+function* FromRef(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TString(schema, references, path, value) {
+function* FromString(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
@@ -421,11 +421,11 @@ function* TString(schema, references, path, value) {
         }
     }
 }
-function* TSymbol(schema, references, path, value) {
+function* FromSymbol(schema, references, path, value) {
     if (!(0, index_8.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
-function* TTemplateLiteral(schema, references, path, value) {
+function* FromTemplateLiteral(schema, references, path, value) {
     if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
@@ -433,10 +433,10 @@ function* TTemplateLiteral(schema, references, path, value) {
         yield Create(ValueErrorType.StringPattern, schema, path, value);
     }
 }
-function* TThis(schema, references, path, value) {
+function* FromThis(schema, references, path, value) {
     yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
-function* TTuple(schema, references, path, value) {
+function* FromTuple(schema, references, path, value) {
     if (!(0, index_8.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
@@ -452,11 +452,11 @@ function* TTuple(schema, references, path, value) {
         yield* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
     }
 }
-function* TUndefined(schema, references, path, value) {
+function* FromUndefined(schema, references, path, value) {
     if (!(0, index_8.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
-function* TUnion(schema, references, path, value) {
+function* FromUnion(schema, references, path, value) {
     let count = 0;
     for (const subschema of schema.anyOf) {
         const errors = [...Visit(subschema, references, path, value)];
@@ -468,7 +468,7 @@ function* TUnion(schema, references, path, value) {
         yield Create(ValueErrorType.Union, schema, path, value);
     }
 }
-function* TUint8Array(schema, references, path, value) {
+function* FromUint8Array(schema, references, path, value) {
     if (!(0, index_8.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
@@ -478,12 +478,12 @@ function* TUint8Array(schema, references, path, value) {
         yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
     }
 }
-function* TUnknown(schema, references, path, value) { }
-function* TVoid(schema, references, path, value) {
+function* FromUnknown(schema, references, path, value) { }
+function* FromVoid(schema, references, path, value) {
     if (!index_1.TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
-function* TKind(schema, references, path, value) {
+function* FromKind(schema, references, path, value) {
     const check = index_3.TypeRegistry.Get(schema[index_6.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
@@ -493,69 +493,69 @@ function* Visit(schema, references, path, value) {
     const schema_ = schema;
     switch (schema_[index_6.Kind]) {
         case 'Any':
-            return yield* TAny(schema_, references_, path, value);
+            return yield* FromAny(schema_, references_, path, value);
         case 'Array':
-            return yield* TArray(schema_, references_, path, value);
+            return yield* FromArray(schema_, references_, path, value);
         case 'AsyncIterator':
-            return yield* TAsyncIterator(schema_, references_, path, value);
+            return yield* FromAsyncIterator(schema_, references_, path, value);
         case 'BigInt':
-            return yield* TBigInt(schema_, references_, path, value);
+            return yield* FromBigInt(schema_, references_, path, value);
         case 'Boolean':
-            return yield* TBoolean(schema_, references_, path, value);
+            return yield* FromBoolean(schema_, references_, path, value);
         case 'Constructor':
-            return yield* TConstructor(schema_, references_, path, value);
+            return yield* FromConstructor(schema_, references_, path, value);
         case 'Date':
-            return yield* TDate(schema_, references_, path, value);
+            return yield* FromDate(schema_, references_, path, value);
         case 'Function':
-            return yield* TFunction(schema_, references_, path, value);
+            return yield* FromFunction(schema_, references_, path, value);
         case 'Integer':
-            return yield* TInteger(schema_, references_, path, value);
+            return yield* FromInteger(schema_, references_, path, value);
         case 'Intersect':
-            return yield* TIntersect(schema_, references_, path, value);
+            return yield* FromIntersect(schema_, references_, path, value);
         case 'Iterator':
-            return yield* TIterator(schema_, references_, path, value);
+            return yield* FromIterator(schema_, references_, path, value);
         case 'Literal':
-            return yield* TLiteral(schema_, references_, path, value);
+            return yield* FromLiteral(schema_, references_, path, value);
         case 'Never':
-            return yield* TNever(schema_, references_, path, value);
+            return yield* FromNever(schema_, references_, path, value);
         case 'Not':
-            return yield* TNot(schema_, references_, path, value);
+            return yield* FromNot(schema_, references_, path, value);
         case 'Null':
-            return yield* TNull(schema_, references_, path, value);
+            return yield* FromNull(schema_, references_, path, value);
         case 'Number':
-            return yield* TNumber(schema_, references_, path, value);
+            return yield* FromNumber(schema_, references_, path, value);
         case 'Object':
-            return yield* TObject(schema_, references_, path, value);
+            return yield* FromObject(schema_, references_, path, value);
         case 'Promise':
-            return yield* TPromise(schema_, references_, path, value);
+            return yield* FromPromise(schema_, references_, path, value);
         case 'Record':
-            return yield* TRecord(schema_, references_, path, value);
+            return yield* FromRecord(schema_, references_, path, value);
         case 'Ref':
-            return yield* TRef(schema_, references_, path, value);
+            return yield* FromRef(schema_, references_, path, value);
         case 'String':
-            return yield* TString(schema_, references_, path, value);
+            return yield* FromString(schema_, references_, path, value);
         case 'Symbol':
-            return yield* TSymbol(schema_, references_, path, value);
+            return yield* FromSymbol(schema_, references_, path, value);
         case 'TemplateLiteral':
-            return yield* TTemplateLiteral(schema_, references_, path, value);
+            return yield* FromTemplateLiteral(schema_, references_, path, value);
         case 'This':
-            return yield* TThis(schema_, references_, path, value);
+            return yield* FromThis(schema_, references_, path, value);
         case 'Tuple':
-            return yield* TTuple(schema_, references_, path, value);
+            return yield* FromTuple(schema_, references_, path, value);
         case 'Undefined':
-            return yield* TUndefined(schema_, references_, path, value);
+            return yield* FromUndefined(schema_, references_, path, value);
         case 'Union':
-            return yield* TUnion(schema_, references_, path, value);
+            return yield* FromUnion(schema_, references_, path, value);
         case 'Uint8Array':
-            return yield* TUint8Array(schema_, references_, path, value);
+            return yield* FromUint8Array(schema_, references_, path, value);
         case 'Unknown':
-            return yield* TUnknown(schema_, references_, path, value);
+            return yield* FromUnknown(schema_, references_, path, value);
         case 'Void':
-            return yield* TVoid(schema_, references_, path, value);
+            return yield* FromVoid(schema_, references_, path, value);
         default:
             if (!index_3.TypeRegistry.Has(schema_[index_6.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
-            return yield* TKind(schema_, references_, path, value);
+            return yield* FromKind(schema_, references_, path, value);
     }
 }
 /** Returns an iterator for each error in this value. */

package/build/require/index.d.ts

@@ -7,7 +7,7 @@ export { Any, type TAny } from './type/any/index';
 export { Array, type TArray, type ArrayOptions } from './type/array/index';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
 export { Awaited, type TAwaited } from './type/awaited/index';
-export { BigInt, type TBigInt, BigIntOptions } from './type/bigint/index';
+export { BigInt, type TBigInt, type BigIntOptions } from './type/bigint/index';
 export { Boolean, type TBoolean } from './type/boolean/index';
 export { Composite, type TComposite } from './type/composite/index';
 export { Const, type TConst } from './type/const/index';
@@ -24,7 +24,7 @@ export { Increment, type Assert, type AssertType, type AssertRest, type AssertPr
 export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
-export { Intersect, IntersectEvaluated, type TIntersect, type IntersectOptions } from './type/intersect/index';
+export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index';
 export { Iterator, type TIterator } from './type/iterator/index';
 export { Intrinsic, IntrinsicFromMappedKey, type TIntrinsic, Capitalize, type TCapitalize, Lowercase, type TLowercase, Uncapitalize, type TUncapitalize, Uppercase, type TUppercase } from './type/intrinsic/index';
 export { KeyOf, type TKeyOf, type KeyOfFromMappedResult, KeyOfPropertyKeys, KeyOfPattern } from './type/keyof/index';
@@ -54,13 +54,13 @@ export { type TSchema, type TKind, type SchemaOptions, type TAnySchema } from '.
 export { type Static, type StaticDecode, type StaticEncode } from './type/static/index';
 export { Strict } from './type/strict/index';
 export { String, type TString, type StringOptions, type StringFormatOption, type StringContentEncodingOption } from './type/string/index';
-export { Symbol, type TSymbol, type SymbolValue } from './type/symbol/index';
-export { TemplateLiteral, IsTemplateLiteralFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, type TTemplateLiteral, type TTemplateLiteralKind } from './type/template-literal/index';
-export { Transform, type TTransform, type TransformOptions, type TransformFunction, TransformDecodeBuilder, TransformEncodeBuilder } from './type/transform/index';
+export { Symbol, type TSymbol, type TSymbolValue as SymbolValue } from './type/symbol/index';
+export { TemplateLiteral, IsTemplateLiteralFinite, IsTemplateLiteralExpressionFinite, TemplateLiteralParse, TemplateLiteralParseExact, TemplateLiteralGenerate, TemplateLiteralExpressionGenerate, type TTemplateLiteral, type TIsTemplateLiteralFinite, type TTemplateLiteralGenerate, type TTemplateLiteralKind, } from './type/template-literal/index';
+export { Transform, TransformDecodeBuilder, TransformEncodeBuilder, type TTransform, type TransformOptions, type TransformFunction } from './type/transform/index';
 export { Tuple, type TTuple } from './type/tuple/index';
 export { Uint8Array, type TUint8Array, type Uint8ArrayOptions } from './type/uint8array/index';
 export { Undefined, type TUndefined } from './type/undefined/index';
-export { Union, UnionEvaluated, type TUnion } from './type/union/index';
+export { Union, UnionEvaluated, type TUnion, type TUnionEvaluated } from './type/union/index';
 export { Unknown, type TUnknown } from './type/unknown/index';
 export { Unsafe, type TUnsafe } from './type/unsafe/index';
 export { Void, type TVoid } from './type/void/index';

package/build/require/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lowercase = exports.Capitalize = exports.IntrinsicFromMappedKey = exports.Intrinsic = exports.Iterator = exports.IntersectEvaluated = exports.Intersect = exports.Integer = exports.InstanceType = exports.IndexFromMappedKey = exports.IndexPropertyKeys = exports.Index = exports.Increment = exports.Function = exports.Extract = exports.ExtendsUndefinedCheck = exports.ExtendsResult = exports.ExtendsCheck = exports.Extends = exports.Exclude = exports.Enum = exports.Deref = exports.Date = exports.ConstructorParameters = exports.Constructor = exports.Const = exports.Composite = exports.Boolean = exports.BigInt = exports.Awaited = exports.AsyncIterator = exports.Array = exports.Any = exports.CloneRest = exports.CloneType = exports.ValueGuard = exports.TypeGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternString = exports.PatternNumberExact = exports.PatternNumber = exports.PatternBooleanExact = exports.PatternBoolean = exports.TransformKind = exports.OptionalKind = exports.ReadonlyKind = exports.Hint = exports.Kind = void 0;
-exports.Unsafe = exports.Unknown = exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
-exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = void 0;
+exports.UnionEvaluated = exports.Union = exports.Undefined = exports.Uint8Array = exports.Tuple = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.Transform = exports.TemplateLiteralExpressionGenerate = exports.TemplateLiteralGenerate = exports.TemplateLiteralParseExact = exports.TemplateLiteralParse = exports.IsTemplateLiteralExpressionFinite = exports.IsTemplateLiteralFinite = exports.TemplateLiteral = exports.Symbol = exports.String = exports.Strict = exports.ReturnType = exports.Rest = exports.Required = exports.RegExp = exports.Ref = exports.Recursive = exports.Record = exports.ReadonlyOptional = exports.ReadonlyFromMappedResult = exports.Readonly = exports.Promise = exports.Pick = exports.PartialFromMappedResult = exports.Partial = exports.Parameters = exports.OptionalFromMappedResult = exports.Optional = exports.Omit = exports.Object = exports.Number = exports.Null = exports.Not = exports.Never = exports.MappedResult = exports.MappedKey = exports.Mapped = exports.Literal = exports.KeyOfPattern = exports.KeyOfPropertyKeys = exports.KeyOf = exports.Uppercase = exports.Uncapitalize = void 0;
+exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.Type = exports.Void = exports.Unsafe = exports.Unknown = void 0;
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
@@ -153,9 +153,11 @@ Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () {
 var index_55 = require("./type/template-literal/index");
 Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return index_55.TemplateLiteral; } });
 Object.defineProperty(exports, "IsTemplateLiteralFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralFinite; } });
+Object.defineProperty(exports, "IsTemplateLiteralExpressionFinite", { enumerable: true, get: function () { return index_55.IsTemplateLiteralExpressionFinite; } });
 Object.defineProperty(exports, "TemplateLiteralParse", { enumerable: true, get: function () { return index_55.TemplateLiteralParse; } });
 Object.defineProperty(exports, "TemplateLiteralParseExact", { enumerable: true, get: function () { return index_55.TemplateLiteralParseExact; } });
 Object.defineProperty(exports, "TemplateLiteralGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralGenerate; } });
+Object.defineProperty(exports, "TemplateLiteralExpressionGenerate", { enumerable: true, get: function () { return index_55.TemplateLiteralExpressionGenerate; } });
 var index_56 = require("./type/transform/index");
 Object.defineProperty(exports, "Transform", { enumerable: true, get: function () { return index_56.Transform; } });
 Object.defineProperty(exports, "TransformDecodeBuilder", { enumerable: true, get: function () { return index_56.TransformDecodeBuilder; } });

package/build/require/type/awaited/awaited.d.ts

@@ -2,11 +2,9 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import { type TIntersect } from '../intersect/index';
 import { type TUnion } from '../union/index';
 import { type TPromise } from '../promise/index';
-type FromRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [FromSchema<L>, ...FromRest<R>] : [];
-declare function FromRest<T extends TSchema[]>(T: [...T]): FromRest<T>;
-type FromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<FromRest<S>> : T extends TUnion<infer S> ? TUnion<FromRest<S>> : T extends TPromise<infer S> ? FromSchema<S> : T;
-declare function FromSchema<T extends TSchema>(T: T): FromSchema<T>;
-export type TAwaited<T extends TSchema> = (FromSchema<T>);
+type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, TFromSchema<L>]> : Acc;
+type TFromSchema<T extends TSchema> = T extends TIntersect<infer S> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S> ? TUnion<TFromRest<S>> : T extends TPromise<infer S> ? TFromSchema<S> : T;
+export type TAwaited<T extends TSchema> = (TFromSchema<T>);
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): FromSchema<T>;
+export declare function Awaited<T extends TSchema>(T: T, options?: SchemaOptions): TFromSchema<T>;
 export {};

package/build/require/type/awaited/awaited.js

@@ -11,11 +11,11 @@ const type_1 = require("../clone/type");
 // prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
-function FromRest(T) {
+function FromRest(T, Acc = []) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? [FromSchema(L), ...FromRest(R)]
-        : []);
+        ? FromRest(R, [...Acc, FromSchema(L)])
+        : Acc);
 }
 // prettier-ignore
 function FromIntersect(T) {

package/build/require/type/composite/composite.d.ts

@@ -1,15 +1,15 @@
 import type { UnionToTuple, Assert, Evaluate } from '../helpers/index';
-import { type TObject, type ObjectOptions } from '../object/index';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index';
 import { type TIntersect } from '../intersect/index';
 import { type TIndex } from '../indexed/index';
-type CompositeKeys<T extends TObject[]> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? keyof L['properties'] | CompositeKeys<R> : never;
-type CompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L extends string, ...infer R extends string[]] ? {
+type TCompositeKeys<T extends TObject[], Acc extends PropertyKey = never> = T extends [infer L extends TObject, ...infer R extends TObject[]] ? TCompositeKeys<R, Acc | keyof L['properties']> : Acc;
+type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[], Acc extends TProperties = {}> = K extends [infer L extends string, ...infer R extends string[]] ? TCompositeIndex<T, R, Acc & {
     [_ in L]: TIndex<T, [L]>;
-} & CompositeIndex<T, R> : {};
-type CompositeReduce<T extends TObject[]> = UnionToTuple<CompositeKeys<T>> extends infer K ? Evaluate<CompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
-export type CompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<CompositeReduce<T>> : TObject<{}>;
-export declare function CompositeResolve<T extends TObject[]>(T: [...T]): CompositeResolve<T>;
-export type TComposite<T extends TObject[]> = CompositeResolve<T>;
+}> : Acc;
+type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
+export type TCompositeResolve<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
+export declare function CompositeResolve<T extends TObject[]>(T: [...T]): TCompositeResolve<T>;
+export type TComposite<T extends TObject[]> = TCompositeResolve<T>;
 /** `[Json]` Creates a Composite object type */
 export declare function Composite<T extends TObject[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
 export {};

package/build/require/type/const/const.d.ts

@@ -14,15 +14,12 @@ import { type TReadonly } from '../readonly/index';
 import { type TUndefined } from '../undefined/index';
 import { type TUint8Array } from '../uint8array/index';
 import { type TUnknown } from '../unknown/index';
-type FromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...FromArray<R>] : T;
-declare function FromArray<T extends readonly unknown[]>(T: [...T]): FromArray<T>;
-type FromProperties<T extends Record<PropertyKey, unknown>> = {
+type TFromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...TFromArray<R>] : T;
+type TFromProperties<T extends Record<PropertyKey, unknown>> = {
     -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
 };
-declare function FromProperties<T extends Record<PropertyKey, unknown>>(value: T): FromProperties<T>;
-type ConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
-declare function ConditionalReadonly<T extends TSchema, Root extends boolean>(T: T, root: Root): ConditionalReadonly<T, Root>;
-type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? ConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<FromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? ConditionalReadonly<TObject<Evaluate<FromProperties<T>>>, Root> : T extends Function ? ConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
+type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<TFromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? TConditionalReadonly<TObject<Evaluate<TFromProperties<T>>>, Root> : T extends Function ? TConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
 declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
 export type TConst<T> = FromValue<T, true>;
 /** `[JavaScript]` Creates a readonly const type from the given value. */

package/build/require/type/constructor/constructor.d.ts

@@ -2,12 +2,12 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { Static } from '../static/index';
 import type { Ensure } from '../helpers/index';
 import { Kind } from '../symbols/index';
-type TConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
-type TConstructorStaticParameters<T extends TSchema[], P extends unknown[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [Static<L, P>, ...TConstructorStaticParameters<R, P>] : [];
-export type TConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: TConstructorStaticParameters<T, P>) => TConstructorStaticReturnType<U, P>>);
+type ConstructorStaticReturnType<T extends TSchema, P extends unknown[]> = Static<T, P>;
+type ConstructorStaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? ConstructorStaticParameters<R, P, [...Acc, Static<L, P>]> : Acc;
+export type ConstructorStatic<T extends TSchema[], U extends TSchema, P extends unknown[]> = (Ensure<new (...param: ConstructorStaticParameters<T, P>) => ConstructorStaticReturnType<U, P>>);
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
-    static: TConstructorStatic<T, U, this['params']>;
+    static: ConstructorStatic<T, U, this['params']>;
     type: 'Constructor';
     parameters: T;
     returns: U;

package/build/require/type/deref/deref.d.ts

@@ -11,12 +11,12 @@ import type { TConstructor } from '../constructor/index';
 import type { TFunction } from '../function/index';
 import type { TRef } from '../ref/index';
 import type { TObject, TProperties } from '../object/index';
-export type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DerefResolve<L>, ...FromRest<R>] : []);
+export type TFromRest<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Acc, DerefResolve<L>]> : Acc);
 type FromProperties<T extends TProperties> = Evaluate<{
     [K in keyof T]: DerefResolve<T[K]>;
 }>;
 declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
-export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
+export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<TFromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<TFromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<TFromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<TFromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<TFromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
 export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
 export type TDeref<T extends TSchema> = DerefResolve<T>;
 /** `[Json]` Creates a dereferenced type */

package/build/require/type/deref/deref.js

@@ -21,67 +21,57 @@ function FromProperties(properties, references) {
 }
 // prettier-ignore
 function FromConstructor(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
+    schema.parameters = FromRest(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
 }
 // prettier-ignore
 function FromFunction(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
+    schema.parameters = FromRest(schema.parameters, references);
+    schema.returns = Deref(schema.returns, references);
+    return schema;
 }
 // prettier-ignore
 function FromIntersect(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.allOf = FromRest(clone.allOf, references);
-    return clone;
+    schema.allOf = FromRest(schema.allOf, references);
+    return schema;
 }
 // prettier-ignore
 function FromUnion(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.anyOf = FromRest(clone.anyOf, references);
-    return clone;
+    schema.anyOf = FromRest(schema.anyOf, references);
+    return schema;
 }
 // prettier-ignore
 function FromTuple(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    if ((0, value_1.IsUndefined)(clone.items))
-        return clone;
-    clone.items = FromRest(clone.items, references);
-    return clone;
+    if ((0, value_1.IsUndefined)(schema.items))
+        return schema;
+    schema.items = FromRest(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromArray(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromObject(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.properties = FromProperties(clone.properties, references);
-    return clone;
+    schema.properties = FromProperties(schema.properties, references);
+    return schema;
 }
 // prettier-ignore
 function FromPromise(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.item = Deref(clone.item, references);
-    return clone;
+    schema.item = Deref(schema.item, references);
+    return schema;
 }
 // prettier-ignore
 function FromAsyncIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
+    schema.items = Deref(schema.items, references);
+    return schema;
 }
 // prettier-ignore
 function FromRef(schema, references) {
@@ -109,6 +99,6 @@ function DerefResolve(schema, references) {
 exports.DerefResolve = DerefResolve;
 /** `[Json]` Creates a dereferenced type */
 function Deref(schema, references) {
-    return DerefResolve(schema, references);
+    return DerefResolve((0, type_1.CloneType)(schema), (0, type_1.CloneRest)(references));
 }
 exports.Deref = Deref;

package/build/require/type/exclude/exclude-from-mapped-result.d.ts

@@ -2,12 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index';
 import type { TProperties } from '../object/index';
 import { type TMappedResult } from '../mapped/index';
 import { type TExclude } from './exclude';
-type FromProperties<K extends TProperties, U extends TSchema> = ({
+type TFromProperties<K extends TProperties, U extends TSchema> = ({
     [K2 in keyof K]: TExclude<K[K2], U>;
 });
-declare function FromProperties<K extends TProperties, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromProperties<K, U>;
-type FromMappedResult<K extends TMappedResult, U extends TSchema> = (FromProperties<K['properties'], U>);
-declare function FromMappedResult<K extends TMappedResult, U extends TSchema>(K: K, U: U, options: SchemaOptions): FromMappedResult<K, U>;
-export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>> = (TMappedResult<P>);
-export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = FromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<K extends TMappedResult, U extends TSchema> = (TFromProperties<K['properties'], U>);
+export type TExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<T extends TMappedResult, U extends TSchema, P extends TProperties = TFromMappedResult<T, U>>(T: T, U: U, options: SchemaOptions): TMappedResult<P>;
 export {};