typebox 1.2.18 → 1.3.0

package/build/system/locale/ur_PK.mjs

@@ -33,7 +33,6 @@ export function ur_PK(error) {
         case 'unevaluatedItems': return 'غیر تشخیص شدہ آئٹمز نہیں ہونے چاہئیں';
         case 'unevaluatedProperties': return 'غیر تشخیص شدہ خصوصیات نہیں ہونی چاہئیں';
         case 'uniqueItems': return `ڈپلیکیٹ آئٹمز نہیں ہونے چاہئیں`;
-        case '~guard': return `چیک فنکشن سے مطابقت ہونی چاہیے`;
         case '~refine': return error.params.message;
         default: return 'تصدیق میں ایک نامعلوم خرابی پیش آئی';
     }

package/build/system/locale/vi_VN.mjs

@@ -33,7 +33,6 @@ export function vi_VN(error) {
         case 'unevaluatedItems': return 'không được có các mục chưa được đánh giá';
         case 'unevaluatedProperties': return 'không được có các thuộc tính chưa được đánh giá';
         case 'uniqueItems': return `không được có các mục trùng lặp`;
-        case '~guard': return `phải khớp với hàm kiểm tra`;
         case '~refine': return error.params.message;
         default: return 'đã xảy ra lỗi xác thực không xác định';
     }

package/build/system/locale/yo_NG.mjs

@@ -33,7 +33,6 @@ export function yo_NG(error) {
         case 'unevaluatedItems': return 'ko gbọdọ ni awọn ohun ti ko ṣe iṣiro';
         case 'unevaluatedProperties': return 'ko gbọdọ ni awọn ohun-ini ti ko ṣe iṣiro';
         case 'uniqueItems': return `ko gbọdọ ni awọn ohun elo ẹda`;
-        case '~guard': return `gbogbo yẹ ki o ba iṣẹ́ ṣàyẹ̀wò mu`;
         case '~refine': return error.params.message;
         default: return 'aṣiṣe ijẹrisi aimọ waye';
     }

package/build/system/locale/zh_Hans.mjs

@@ -33,7 +33,6 @@ export function zh_Hans(error) {
         case 'unevaluatedItems': return '不得有未评估的项';
         case 'unevaluatedProperties': return '不得有未评估的属性';
         case 'uniqueItems': return `不得有重复项`;
-        case '~guard': return `必须与检查函数匹配`;
         case '~refine': return error.params.message;
         default: return '发生未知验证错误';
     }

package/build/system/locale/zh_Hant.mjs

@@ -33,7 +33,6 @@ export function zh_Hant(error) {
         case 'unevaluatedItems': return '不得有未評估的項目';
         case 'unevaluatedProperties': return '不得有未評估的屬性';
         case 'uniqueItems': return `不得有重複項目`;
-        case '~guard': return `必須與檢查函數匹配`;
         case '~refine': return error.params.message;
         default: return '發生未知驗證錯誤';
     }

package/build/system/memory/clone.d.mts

@@ -1,6 +1,5 @@
 /**
- * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
- * properties from the source value. This is to ensure cloned types retain discriminable
- * hidden properties.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export declare function Clone<Value extends unknown = unknown>(value: Value): Value;

package/build/system/memory/clone.mjs

@@ -1,28 +1,32 @@
 // deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
+import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 import { Metrics } from './metrics.mjs';
 // ------------------------------------------------------------------
-// Guard
+// ClassInstance
+//
+// TypeBox does not clone arbitrary class instances. Class instances
+// cannot be safely cloned without potentially breaking private
+// members of the instance.
+//
 // ------------------------------------------------------------------
-function IsGuard(value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, '~guard');
-}
-function FromGuard(value) {
-    return value; // non-clonable
+function FromClassInstance(value) {
+    return value; // atomic
 }
 // ------------------------------------------------------------------
-// Array
+// KindedObject
+//
+// Types have non-enumerable properties that MUST be preserved on Clone. 
+// The following is the optimal path for TypeBox types.
 // ------------------------------------------------------------------
-function FromArray(value) {
-    return value.map((value) => FromValue(value));
+function IsKindedObject(value) {
+    return Guard.HasPropertyKey(value, '~kind');
 }
-// ------------------------------------------------------------------
-// Object
-// ------------------------------------------------------------------
-function FromObject(value) {
+function FromKindedObject(value) {
     const result = {};
     const descriptors = Object.getOwnPropertyDescriptors(value);
     for (const key of Object.keys(descriptors)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
         const descriptor = descriptors[key];
         if (Guard.HasPropertyKey(descriptor, 'value')) {
             Object.defineProperty(result, key, { ...descriptor, value: FromValue(descriptor.value) });
@@ -31,31 +35,73 @@ function FromObject(value) {
     return result;
 }
 // ------------------------------------------------------------------
+// PlainObject
+// ------------------------------------------------------------------
+function FromPlainObject(value) {
+    const result = {};
+    for (const key of Guard.Keys(value)) {
+        if (Guard.IsUnsafePropertyKey(key))
+            continue; // (ignore: prototype-pollution)
+        result[key] = FromValue(value[key]);
+    }
+    for (const key of Guard.Symbols(value)) {
+        result[key] = FromValue(value[key]);
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value) ? FromClassInstance(value) :
+        IsKindedObject(value) ? FromKindedObject(value) :
+            FromPlainObject(value));
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((element) => FromValue(element));
+}
+// ------------------------------------------------------------------
+// TypeArray
+// ------------------------------------------------------------------
+function FromTypedArray(value) {
+    return value.slice();
+}
+// ------------------------------------------------------------------
 // RegExp
 // ------------------------------------------------------------------
 function FromRegExp(value) {
     return new RegExp(value.source, value.flags);
 }
 // ------------------------------------------------------------------
-// RegExp
+// Map
 // ------------------------------------------------------------------
-function FromUnknown(value) {
-    return value;
+function FromMap(value) {
+    return new Map(FromValue([...value.entries()]));
 }
 // ------------------------------------------------------------------
-// Value
+// Set
 // ------------------------------------------------------------------
+function FromSet(value) {
+    return new Set(FromValue([...value.values()]));
+}
 function FromValue(value) {
-    return (value instanceof RegExp ? FromRegExp(value) :
-        IsGuard(value) ? FromGuard(value) :
-            Guard.IsArray(value) ? FromArray(value) :
-                Guard.IsObject(value) ? FromObject(value) :
-                    FromUnknown(value));
+    return (GlobalsGuard.IsTypeArray(value) ? FromTypedArray(value) :
+        GlobalsGuard.IsRegExp(value) ? FromRegExp(value) :
+            GlobalsGuard.IsMap(value) ? FromMap(value) :
+                GlobalsGuard.IsSet(value) ? FromSet(value) :
+                    Guard.IsArray(value) ? FromArray(value) :
+                        Guard.IsObject(value) ? FromObject(value) :
+                            value);
 }
+// ------------------------------------------------------------------
+// Clone
+// ------------------------------------------------------------------
 /**
- * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
- * properties from the source value. This is to ensure cloned types retain discriminable
- * hidden properties.
+ * Returns a Clone of the given value. This function is similar to structuredClone()
+ * but also supports deep cloning instances of Map, Set and TypeArray.
  */
 export function Clone(value) {
     Metrics.clone += 1;

package/build/type/action/index.d.mts

@@ -4,7 +4,6 @@ export * from './_add_optional.mjs';
 export * from './_remove_immutable.mjs';
 export * from './_remove_readonly.mjs';
 export * from './_remove_optional.mjs';
-export * from './awaited.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';
 export * from './constructor_parameters.mjs';

package/build/type/action/index.mjs

@@ -4,7 +4,6 @@ export * from './_add_optional.mjs';
 export * from './_remove_immutable.mjs';
 export * from './_remove_readonly.mjs';
 export * from './_remove_optional.mjs';
-export * from './awaited.mjs';
 export * from './capitalize.mjs';
 export * from './conditional.mjs';
 export * from './constructor_parameters.mjs';

package/build/type/action/readonly_object.d.mts

@@ -9,8 +9,3 @@ export declare function ReadonlyObjectDeferred<Type extends TSchema>(type: Type,
 export type TReadonlyObject<Type extends TSchema> = (TReadonlyObjectAction<Type>);
 /** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
 export declare function ReadonlyObject<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyObject<Type>;
-/**
- * This type has been renamed to ReadonlyObject.
- * @deprecated
-*/
-export declare const ReadonlyType: typeof ReadonlyObject;

package/build/type/action/readonly_object.mjs

@@ -9,8 +9,3 @@ export function ReadonlyObjectDeferred(type, options = {}) {
 export function ReadonlyObject(type, options = {}) {
     return ReadonlyObjectAction(type, options);
 }
-/**
- * This type has been renamed to ReadonlyObject.
- * @deprecated
-*/
-export const ReadonlyType = ReadonlyObject;

package/build/type/action/with.d.mts

@@ -9,13 +9,3 @@ export declare function WithDeferred<Type extends TSchema, Options extends TSche
 export type TWith<Type extends TSchema, Options extends TSchema> = (Type & Options);
 /** Applies annotation options to the given type. */
 export declare function With<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;
-/**
- * @deprecated Type.TOptions\<T\> has been renamed to Type.TWith\<T\>. This type will be removed in the
- * next version of TypeBox.
- */
-export type TOptions<Type extends TSchema, Options extends TSchema> = TWith<Type, Options>;
-/**
- * @deprecated Type.Options\<T\> has been renamed to Type.With\<T\>. This type will be removed in the
- * next version of TypeBox.
- */
-export declare function Options<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TOptions<Type, Options>;

package/build/type/action/with.mjs

@@ -9,11 +9,3 @@ export function WithDeferred(type, options) {
 export function With(type, options) {
     return WithAction(type, options);
 }
-/**
- * @deprecated Type.Options\<T\> has been renamed to Type.With\<T\>. This type will be removed in the
- * next version of TypeBox.
- */
-export function Options(type, options) {
-    return With(type, options);
-}
-// deno-coverage-ignore-stop

package/build/type/engine/cyclic/check.d.mts

@@ -1,12 +1,9 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
@@ -16,7 +13,7 @@ import { type TInterfaceDeferred } from '../../action/interface.mjs';
 type TFromRef<Stack extends (keyof Context)[], Context extends TProperties, Ref extends (keyof Context)> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
 type TFromProperties<Stack extends (keyof Context)[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
 type TFromTypes<Stack extends (keyof Context)[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
-type TFromType<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+type TFromType<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
 export type TCyclicCheck<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */

package/build/type/engine/cyclic/check.mjs

@@ -1,13 +1,10 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
 import { IsArray } from '../../types/array.mjs';
-import { IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { IsFunction } from '../../types/function.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsIterator } from '../../types/iterator.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { IsPromise } from '../../types/promise.mjs';
 import { PropertyValues } from '../../types/properties.mjs';
 import { IsRecord, RecordValue } from '../../types/record.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
@@ -31,18 +28,15 @@ function FromTypes(stack, context, types) {
 function FromType(stack, context, type) {
     return (IsRef(type) ? FromRef(stack, context, type.$ref) :
         IsArray(type) ? FromType(stack, context, type.items) :
-            IsAsyncIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
-                    IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
-                        IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
-                            IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
-                                IsIterator(type) ? FromType(stack, context, type.iteratorItems) :
-                                    IsObject(type) ? FromProperties(stack, context, type.properties) :
-                                        IsPromise(type) ? FromType(stack, context, type.item) :
-                                            IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
-                                                IsTuple(type) ? FromTypes(stack, context, type.items) :
-                                                    IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
-                                                        false);
+            IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                    IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                        IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                            IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                    IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                        IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                            false);
 }
 /** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
 export function CyclicCheck(stack, context, type) {

package/build/type/engine/cyclic/dependencies.d.mts

@@ -1,13 +1,10 @@
 import { type TUnreachable } from '../../../system/unreachable/index.mjs';
 import { type TSchema } from '../../types/schema.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TTuple } from '../../types/tuple.mjs';
@@ -17,7 +14,7 @@ import { type TInterfaceDeferred } from '../../action/interface.mjs';
 type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
 type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
 type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
-type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
 export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */

package/build/type/engine/cyclic/dependencies.mjs

@@ -1,13 +1,10 @@
 // deno-fmt-ignore-file
 import { Unreachable } from '../../../system/unreachable/index.mjs';
 import { IsArray } from '../../types/array.mjs';
-import { IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { IsConstructor } from '../../types/constructor.mjs';
 import { IsFunction } from '../../types/function.mjs';
 import { IsIntersect } from '../../types/intersect.mjs';
-import { IsIterator } from '../../types/iterator.mjs';
 import { IsObject } from '../../types/object.mjs';
-import { IsPromise } from '../../types/promise.mjs';
 import { PropertyValues } from '../../types/properties.mjs';
 import { IsRecord, RecordValue } from '../../types/record.mjs';
 import { IsTuple } from '../../types/tuple.mjs';
@@ -33,18 +30,15 @@ function FromTypes(context, types, result) {
 function FromType(context, type, result) {
     return (IsRef(type) ? FromRef(context, type.$ref, result) :
         IsArray(type) ? FromType(context, type.items, result) :
-            IsAsyncIterator(type) ? FromType(context, type.iteratorItems, result) :
-                IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
-                    IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
-                        IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
-                            IsIntersect(type) ? FromTypes(context, type.allOf, result) :
-                                IsIterator(type) ? FromType(context, type.iteratorItems, result) :
-                                    IsObject(type) ? FromProperties(context, type.properties, result) :
-                                        IsPromise(type) ? FromType(context, type.item, result) :
-                                            IsUnion(type) ? FromTypes(context, type.anyOf, result) :
-                                                IsTuple(type) ? FromTypes(context, type.items, result) :
-                                                    IsRecord(type) ? FromType(context, RecordValue(type), result) :
-                                                        result);
+            IsConstructor(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                IsFunction(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                    IsInterfaceDeferred(type) ? FromProperties(context, type.parameters[1], result) :
+                        IsIntersect(type) ? FromTypes(context, type.allOf, result) :
+                            IsObject(type) ? FromProperties(context, type.properties, result) :
+                                IsUnion(type) ? FromTypes(context, type.anyOf, result) :
+                                    IsTuple(type) ? FromTypes(context, type.items, result) :
+                                        IsRecord(type) ? FromType(context, RecordValue(type), result) :
+                                            result);
 }
 /** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
 export function CyclicDependencies(context, key, type) {

package/build/type/engine/cyclic/extends.d.mts

@@ -1,14 +1,11 @@
 import { type TSchema } from '../../types/schema.mjs';
 import { type TAny } from '../../types/any.mjs';
 import { type TArray } from '../../types/array.mjs';
-import { type TAsyncIterator } from '../../types/async_iterator.mjs';
 import { type TConstructor } from '../../types/constructor.mjs';
 import { type TCyclic } from '../../types/cyclic.mjs';
 import { type TFunction } from '../../types/function.mjs';
 import { type TIntersect } from '../../types/intersect.mjs';
-import { type TIterator } from '../../types/iterator.mjs';
 import { type TObject } from '../../types/object.mjs';
-import { type TPromise } from '../../types/promise.mjs';
 import { type TProperties } from '../../types/properties.mjs';
 import { type TRecord } from '../../types/record.mjs';
 import { type TRef } from '../../types/ref.mjs';
@@ -22,7 +19,7 @@ type TFromProperties<Properties extends TProperties, Result extends TProperties
     [Key in keyof Result]: Result[Key];
 };
 type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
-type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
 type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
 /** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
 export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;

package/build/type/engine/cyclic/extends.mjs

@@ -2,13 +2,10 @@
 import { Guard } from '../../../guard/index.mjs';
 import { Any } from '../../types/any.mjs';
 import { Array as _Array_, IsArray, ArrayOptions } from '../../types/array.mjs';
-import { AsyncIterator, IsAsyncIterator } from '../../types/async_iterator.mjs';
 import { Constructor, IsConstructor } from '../../types/constructor.mjs';
 import { Function as _Function_, IsFunction } from '../../types/function.mjs';
 import { Intersect, IsIntersect } from '../../types/intersect.mjs';
-import { Iterator, IsIterator } from '../../types/iterator.mjs';
 import { Object, IsObject } from '../../types/object.mjs';
-import { Promise, IsPromise } from '../../types/promise.mjs';
 import { IsRecord, Record, RecordKey, RecordValue } from '../../types/record.mjs';
 import { IsRef } from '../../types/ref.mjs';
 import { Tuple, IsTuple } from '../../types/tuple.mjs';
@@ -30,17 +27,14 @@ function FromTypes(types) {
 function FromType(type) {
     return (IsRef(type) ? FromRef(type.$ref) :
         IsArray(type) ? _Array_(FromType(type.items), ArrayOptions(type)) :
-            IsAsyncIterator(type) ? AsyncIterator(FromType(type.iteratorItems)) :
-                IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
-                    IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
-                        IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
-                            IsIterator(type) ? Iterator(FromType(type.iteratorItems)) :
-                                IsObject(type) ? Object(FromProperties(type.properties)) :
-                                    IsPromise(type) ? Promise(FromType(type.item)) :
-                                        IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
-                                            IsUnion(type) ? Union(FromTypes(type.anyOf)) :
-                                                IsTuple(type) ? Tuple(FromTypes(type.items)) :
-                                                    type);
+            IsConstructor(type) ? Constructor(FromTypes(type.parameters), FromType(type.instanceType)) :
+                IsFunction(type) ? _Function_(FromTypes(type.parameters), FromType(type.returnType)) :
+                    IsIntersect(type) ? Intersect(FromTypes(type.allOf)) :
+                        IsObject(type) ? Object(FromProperties(type.properties)) :
+                            IsRecord(type) ? Record(RecordKey(type), FromType(RecordValue(type))) :
+                                IsUnion(type) ? Union(FromTypes(type.anyOf)) :
+                                    IsTuple(type) ? Tuple(FromTypes(type.items)) :
+                                        type);
 }
 function CyclicAnyFromParameters(defs, ref) {
     return (ref in defs

package/build/type/engine/index.d.mts

@@ -1,5 +1,4 @@
 export { Instantiate, type TInstantiate } from './instantiate.mjs';
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
 export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';

package/build/type/engine/index.mjs

@@ -5,7 +5,6 @@ export { Instantiate } from './instantiate.mjs';
 // ------------------------------------------------------------------
 // Engine: Internals
 // ------------------------------------------------------------------
-export * from './awaited/index.mjs';
 export * from './conditional/index.mjs';
 export * from './constructor_parameters/index.mjs';
 export * from './cyclic/index.mjs';

package/build/type/engine/indexed/instantiate.d.mts

@@ -8,7 +8,7 @@ import { type TState, type TInstantiateType, type TCanInstantiate } from '../ins
 import { type TIndexDeferred } from '../../action/indexed.mjs';
 import { type TCollapseToObject } from '../object/index.mjs';
 import { type TFromType } from './from_type.mjs';
-type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic | TDependent | TIntersect | TUnion ? TCollapseToObject<Type> : Type)> = Result;
+type TNormalizeType<Type extends TSchema, Result extends TSchema = (Type extends TCyclic ? TCollapseToObject<Type> : Type extends TDependent ? TCollapseToObject<Type> : Type extends TIntersect ? TCollapseToObject<Type> : Type extends TUnion ? TCollapseToObject<Type> : Type)> = Result;
 export type TIndexAction<Type extends TSchema, Indexer extends TSchema, Result extends TSchema = TCanInstantiate<[Type, Indexer]> extends true ? TFromType<TNormalizeType<Type>, Indexer> : TIndexDeferred<Type, Indexer>> = Result;
 export declare function IndexAction<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options: TSchemaOptions): TIndexAction<Type, Indexer>;
 export type TIndexInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, Indexer extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>, InstantiatedIndexer extends TSchema = TInstantiateType<Context, State, Indexer>> = TIndexAction<InstantiatedType, InstantiatedIndexer>;

package/build/type/engine/indexed/instantiate.mjs

@@ -9,8 +9,10 @@ import { IndexDeferred } from '../../action/indexed.mjs';
 import { CollapseToObject } from '../object/index.mjs';
 import { FromType } from './from_type.mjs';
 function NormalizeType(type) {
-    const result = (IsCyclic(type) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) :
-        type);
+    const result = (IsCyclic(type) ||
+        IsDependent(type) ||
+        IsIntersect(type) ||
+        IsUnion(type)) ? CollapseToObject(type) : type;
     return result;
 }
 export function IndexAction(type, indexer, options) {

package/build/type/engine/instantiate.d.mts

@@ -1,6 +1,8 @@
+import { type TAddImmutableAction } from './immutable/instantiate_add.mjs';
+import { type TAddReadonlyAction } from './readonly/instantiate_add.mjs';
+import { type TAddOptionalAction } from './optional/instantiate_add.mjs';
 import { type TSchema } from '../types/schema.mjs';
 import { type TArray } from '../types/array.mjs';
-import { type TAsyncIterator } from '../types/async_iterator.mjs';
 import { type TConstructor } from '../types/constructor.mjs';
 import { type TDeferred } from '../types/deferred.mjs';
 import { type TFunction } from '../types/function.mjs';
@@ -8,9 +10,7 @@ import { type TCall } from '../types/call.mjs';
 import { type TIdentifier } from '../types/identifier.mjs';
 import { type TDependent } from '../types/dependent.mjs';
 import { type TIntersect } from '../types/intersect.mjs';
-import { type TIterator } from '../types/iterator.mjs';
 import { type TObject } from '../types/object.mjs';
-import { type TPromise } from '../types/promise.mjs';
 import { type TProperties } from '../types/properties.mjs';
 import { type TRecord } from '../types/record.mjs';
 import { type TTuple } from '../types/tuple.mjs';
@@ -26,7 +26,6 @@ import { type TRemoveOptionalInstantiate } from './optional/instantiate_remove.m
 import { type TOptional } from '../types/_optional.mjs';
 import { type TImmutable } from '../types/_immutable.mjs';
 import { type TReadonly } from '../types/_readonly.mjs';
-import { type TAwaitedInstantiate } from './awaited/instantiate.mjs';
 import { type TCallInstantiate } from './call/instantiate.mjs';
 import { type TCapitalizeInstantiate } from './intrinsics/instantiate.mjs';
 import { type TConditionalInstantiate } from './conditional/index.mjs';
@@ -71,6 +70,7 @@ export type TInstantiateElements<Context extends TProperties, State extends TSta
 export declare function InstantiateElements<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateElements<Context, State, Types>;
 export type TInstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TInstantiateTypes<Context, State, Right, [...Result, TInstantiateType<Context, State, Left>]> : Result);
 export declare function InstantiateTypes<Context extends TProperties, State extends TState, Types extends TSchema[]>(context: Context, state: State, types: [...Types]): TInstantiateTypes<Context, State, Types>;
+type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithOptional extends TSchema = Type extends TOptional ? TAddOptionalAction<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TAddReadonlyAction<WithOptional> : WithOptional, WithImmutable extends TSchema = Type extends TImmutable ? TAddImmutableAction<WithReadonly> : WithReadonly> = WithImmutable;
 type TInstantiateDeferred<Context extends TProperties, State extends TState, Action extends string, Parameters extends TSchema[]> = ([
     Action,
     Parameters
@@ -92,9 +92,6 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
 ] extends ['RemoveOptional', [infer Type extends TSchema]] ? TRemoveOptionalInstantiate<Context, State, Type> : [
     Action,
     Parameters
-] extends ['Awaited', [infer Type extends TSchema]] ? TAwaitedInstantiate<Context, State, Type> : [
-    Action,
-    Parameters
 ] extends ['Capitalize', [infer Type extends TSchema]] ? TCapitalizeInstantiate<Context, State, Type> : [
     Action,
     Parameters
@@ -171,11 +168,9 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
     Action,
     Parameters
 ] extends ['With', [infer Type extends TSchema, infer Options extends TSchema]] ? TWithInstantiate<Context, State, Type, Options> : TDeferred<Action, Parameters>);
-export type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type)> = Result;
-export declare function InstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
-type TWithModifiers<Type extends TSchema, InstantiatedType extends TSchema, WithImmutable extends TSchema = Type extends TImmutable ? TImmutable<InstantiatedType> : InstantiatedType, WithReadonly extends TSchema = Type extends TReadonly ? TReadonly<WithImmutable> : WithImmutable, WithOptional extends TSchema = Type extends TOptional ? TOptional<WithReadonly> : WithReadonly> = WithOptional;
-export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateImmediate<Context, State, Type>, WithModifiers extends TSchema = Type extends TDeferred ? InstantiatedType : TWithModifiers<Type, InstantiatedType>> = WithModifiers;
-export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: TProperties, state: TState, type: Type): TInstantiateType<Context, State, Type>;
+type TInstantiateImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Type, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TDependent<infer If extends TSchema, infer Then extends TSchema, infer Else extends TSchema> ? TDependent<TInstantiateType<Context, State, If>, TInstantiateType<Context, State, Then>, TInstantiateType<Context, State, Else>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithModifiers extends TSchema = TWithModifiers<Type, InstantiatedType>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Type extends TSchema, Result extends TSchema = Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : TInstantiateImmediate<Context, State, Type>> = Result;
+export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type): TInstantiateImmediate<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
 export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, TState<[], []>, Type>);
 /** Instantiates computed schematics using the given context and type. */