@sinclair/typebox 0.29.5 → 0.30.0-dev-1

package/typebox.js

@@ -27,11 +27,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
-exports.Modifier = Symbol.for('TypeBox.Modifier');
+exports.Readonly = Symbol.for('TypeBox.Readonly');
+exports.Optional = Symbol.for('TypeBox.Optional');
 exports.Hint = Symbol.for('TypeBox.Hint');
 exports.Kind = Symbol.for('TypeBox.Kind');
 // --------------------------------------------------------------------------
@@ -57,6 +58,11 @@ var TypeRegistry;
         return map.clear();
     }
     TypeRegistry.Clear = Clear;
+    /** Deletes a registered type */
+    function Delete(kind) {
+        return map.delete(kind);
+    }
+    TypeRegistry.Delete = Delete;
     /** Returns true if this registry contains this kind */
     function Has(kind) {
         return map.has(kind);
@@ -87,6 +93,11 @@ var FormatRegistry;
         return map.clear();
     }
     FormatRegistry.Clear = Clear;
+    /** Deletes a registered format */
+    function Delete(format) {
+        return map.delete(format);
+    }
+    FormatRegistry.Delete = Delete;
     /** Returns true if the user defined string format exists */
     function Has(format) {
         return map.has(format);
@@ -104,6 +115,44 @@ var FormatRegistry;
     FormatRegistry.Get = Get;
 })(FormatRegistry || (exports.FormatRegistry = FormatRegistry = {}));
 // --------------------------------------------------------------------------
+// ValueGuard
+// --------------------------------------------------------------------------
+var ValueGuard;
+(function (ValueGuard) {
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    ValueGuard.IsObject = IsObject;
+    function IsArray(value) {
+        return Array.isArray(value);
+    }
+    ValueGuard.IsArray = IsArray;
+    function IsBoolean(value) {
+        return typeof value === 'boolean';
+    }
+    ValueGuard.IsBoolean = IsBoolean;
+    function IsNull(value) {
+        return value === null;
+    }
+    ValueGuard.IsNull = IsNull;
+    function IsUndefined(value) {
+        return value === undefined;
+    }
+    ValueGuard.IsUndefined = IsUndefined;
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    ValueGuard.IsBigInt = IsBigInt;
+    function IsNumber(value) {
+        return typeof value === 'number';
+    }
+    ValueGuard.IsNumber = IsNumber;
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    ValueGuard.IsString = IsString;
+})(ValueGuard || (exports.ValueGuard = ValueGuard = {}));
+// --------------------------------------------------------------------------
 // TypeGuard
 // --------------------------------------------------------------------------
 class TypeGuardUnknownTypeError extends Error {
@@ -116,12 +165,6 @@ exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 /** Provides functions to test if JavaScript values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    }
-    function IsArray(value) {
-        return typeof value === 'object' && value !== null && Array.isArray(value);
-    }
     function IsPattern(value) {
         try {
             new RegExp(value);
@@ -132,7 +175,7 @@ var TypeGuard;
         }
     }
     function IsControlCharacterFree(value) {
-        if (typeof value !== 'string')
+        if (!ValueGuard.IsString(value))
             return false;
         for (let i = 0; i < value.length; i++) {
             const code = value.charCodeAt(i);
@@ -145,63 +188,62 @@ var TypeGuard;
     function IsAdditionalProperties(value) {
         return IsOptionalBoolean(value) || TSchema(value);
     }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    function IsNumber(value) {
-        return typeof value === 'number' && globalThis.Number.isFinite(value);
-    }
-    function IsBoolean(value) {
-        return typeof value === 'boolean';
-    }
     function IsOptionalBigInt(value) {
-        return value === undefined || (value !== undefined && IsBigInt(value));
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
     }
     function IsOptionalNumber(value) {
-        return value === undefined || (value !== undefined && IsNumber(value));
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
     }
     function IsOptionalBoolean(value) {
-        return value === undefined || (value !== undefined && IsBoolean(value));
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
     }
     function IsOptionalString(value) {
-        return value === undefined || (value !== undefined && IsString(value));
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+        return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
     }
     function IsOptionalFormat(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
+        return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
     }
     function IsOptionalSchema(value) {
-        return value === undefined || TSchema(value);
+        return ValueGuard.IsUndefined(value) || TSchema(value);
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Any' && IsOptionalString(schema.$id);
+        // prettier-ignore
+        return (TKindOf(schema, 'Any') &&
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TAny = TAny;
     /** Returns true if the given schema is TArray */
     function TArray(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Array' &&
+        return (TKindOf(schema, 'Array') &&
             schema.type === 'array' &&
             IsOptionalString(schema.$id) &&
             TSchema(schema.items) &&
+            IsOptionalSchema(schema.contains) &&
+            IsOptionalNumber(schema.minContains) &&
+            IsOptionalNumber(schema.maxContains) &&
             IsOptionalNumber(schema.minItems) &&
             IsOptionalNumber(schema.maxItems) &&
             IsOptionalBoolean(schema.uniqueItems));
     }
     TypeGuard.TArray = TArray;
+    /** Returns true if the given schema is TAsyncIterator */
+    function TAsyncIterator(schema) {
+        // prettier-ignore
+        return (TKindOf(schema, 'AsyncIterator') &&
+            schema.type === 'AsyncIterator' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items));
+    }
+    TypeGuard.TAsyncIterator = TAsyncIterator;
     /** Returns true if the given schema is TBigInt */
     function TBigInt(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'BigInt' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'BigInt' &&
+        return (TKindOf(schema, 'BigInt') &&
+            schema.type === 'bigint' &&
             IsOptionalString(schema.$id) &&
             IsOptionalBigInt(schema.multipleOf) &&
             IsOptionalBigInt(schema.minimum) &&
@@ -213,8 +255,7 @@ var TypeGuard;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Boolean' &&
+        return (TKindOf(schema, 'Boolean') &&
             schema.type === 'boolean' &&
             IsOptionalString(schema.$id));
     }
@@ -222,12 +263,10 @@ var TypeGuard;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Constructor' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Constructor' &&
+        if (!(TKindOf(schema, 'Constructor') &&
+            schema.type === 'constructor' &&
             IsOptionalString(schema.$id) &&
-            IsArray(schema.parameters) &&
+            ValueGuard.IsArray(schema.parameters) &&
             TSchema(schema.returns))) {
             return false;
         }
@@ -240,10 +279,8 @@ var TypeGuard;
     TypeGuard.TConstructor = TConstructor;
     /** Returns true if the given schema is TDate */
     function TDate(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Date' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Date' &&
+        return (TKindOf(schema, 'Date') &&
+            schema.type === 'Date' &&
             IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.minimumTimestamp) &&
             IsOptionalNumber(schema.maximumTimestamp) &&
@@ -254,12 +291,10 @@ var TypeGuard;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Function' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Function' &&
+        if (!(TKindOf(schema, 'Function') &&
+            schema.type === 'function' &&
             IsOptionalString(schema.$id) &&
-            IsArray(schema.parameters) &&
+            ValueGuard.IsArray(schema.parameters) &&
             TSchema(schema.returns))) {
             return false;
         }
@@ -272,8 +307,7 @@ var TypeGuard;
     TypeGuard.TFunction = TFunction;
     /** Returns true if the given schema is TInteger */
     function TInteger(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Integer' &&
+        return (TKindOf(schema, 'Integer') &&
             schema.type === 'integer' &&
             IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
@@ -286,9 +320,8 @@ var TypeGuard;
     /** Returns true if the given schema is TIntersect */
     function TIntersect(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Intersect' &&
-            IsArray(schema.allOf) &&
+        if (!(TKindOf(schema, 'Intersect') &&
+            ValueGuard.IsArray(schema.allOf) &&
             IsOptionalString(schema.type) &&
             (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
             IsOptionalString(schema.$id))) {
@@ -304,57 +337,75 @@ var TypeGuard;
         return true;
     }
     TypeGuard.TIntersect = TIntersect;
+    /** Returns true if the given schema is TIterator */
+    function TIterator(schema) {
+        // prettier-ignore
+        return (TKindOf(schema, 'Iterator') &&
+            schema.type === 'Iterator' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items));
+    }
+    TypeGuard.TIterator = TIterator;
+    /** Returns true if the given schema is a TKind with the given name. */
+    function TKindOf(schema, kind) {
+        return TKind(schema) && schema[exports.Kind] === kind;
+    }
+    TypeGuard.TKindOf = TKindOf;
     /** Returns true if the given schema is TKind */
     function TKind(schema) {
-        return IsObject(schema) && exports.Kind in schema && typeof schema[exports.Kind] === 'string'; // TS 4.1.5: any required for symbol indexer
+        return ValueGuard.IsObject(schema) && exports.Kind in schema && ValueGuard.IsString(schema[exports.Kind]);
     }
     TypeGuard.TKind = TKind;
     /** Returns true if the given schema is TLiteral<string> */
     function TLiteralString(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'string';
+        return TLiteral(schema) && ValueGuard.IsString(schema.const);
     }
     TypeGuard.TLiteralString = TLiteralString;
     /** Returns true if the given schema is TLiteral<number> */
     function TLiteralNumber(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'number';
+        return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
     }
     TypeGuard.TLiteralNumber = TLiteralNumber;
     /** Returns true if the given schema is TLiteral<boolean> */
     function TLiteralBoolean(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean';
+        return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
     }
     TypeGuard.TLiteralBoolean = TLiteralBoolean;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return TLiteralString(schema) || TLiteralNumber(schema) || TLiteralBoolean(schema);
+        // prettier-ignore
+        return (TKindOf(schema, 'Literal') &&
+            IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) ||
+            ValueGuard.IsNumber(schema.const) ||
+            ValueGuard.IsString(schema.const)));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNever */
     function TNever(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Never' && IsObject(schema.not) && globalThis.Object.getOwnPropertyNames(schema.not).length === 0;
+        // prettier-ignore
+        return (TKindOf(schema, 'Never') &&
+            ValueGuard.IsObject(schema.not) &&
+            Object.getOwnPropertyNames(schema.not).length === 0);
     }
     TypeGuard.TNever = TNever;
     /** Returns true if the given schema is TNot */
     function TNot(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Not' &&
+        return (TKindOf(schema, 'Not') &&
             TSchema(schema.not));
     }
     TypeGuard.TNot = TNot;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Null' &&
+        return (TKindOf(schema, 'Null') &&
             schema.type === 'null' &&
             IsOptionalString(schema.$id));
     }
     TypeGuard.TNull = TNull;
     /** Returns true if the given schema is TNumber */
     function TNumber(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Number' &&
+        return (TKindOf(schema, 'Number') &&
             schema.type === 'number' &&
             IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
@@ -366,11 +417,10 @@ var TypeGuard;
     TypeGuard.TNumber = TNumber;
     /** Returns true if the given schema is TObject */
     function TObject(schema) {
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Object' &&
+        if (!(TKindOf(schema, 'Object') &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
-            IsObject(schema.properties) &&
+            ValueGuard.IsObject(schema.properties) &&
             IsAdditionalProperties(schema.additionalProperties) &&
             IsOptionalNumber(schema.minProperties) &&
             IsOptionalNumber(schema.maxProperties))) {
@@ -388,10 +438,8 @@ var TypeGuard;
     /** Returns true if the given schema is TPromise */
     function TPromise(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Promise' &&
-            schema.type === 'object' &&
-            schema.instanceOf === 'Promise' &&
+        return (TKindOf(schema, 'Promise') &&
+            schema.type === 'Promise' &&
             IsOptionalString(schema.$id) &&
             TSchema(schema.item));
     }
@@ -399,15 +447,14 @@ var TypeGuard;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Record' &&
+        if (!(TKindOf(schema, 'Record') &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
             IsAdditionalProperties(schema.additionalProperties) &&
-            IsObject(schema.patternProperties))) {
+            ValueGuard.IsObject(schema.patternProperties))) {
             return false;
         }
-        const keys = Object.keys(schema.patternProperties);
+        const keys = Object.getOwnPropertyNames(schema.patternProperties);
         if (keys.length !== 1) {
             return false;
         }
@@ -423,41 +470,30 @@ var TypeGuard;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Ref' &&
+        return (TKindOf(schema, 'Ref') &&
             IsOptionalString(schema.$id) &&
-            IsString(schema.$ref));
+            ValueGuard.IsString(schema.$ref));
     }
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
     function TString(schema) {
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'String' &&
-            schema.type === 'string' &&
-            IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.minLength) &&
-            IsOptionalNumber(schema.maxLength) &&
-            IsOptionalPattern(schema.pattern) &&
-            IsOptionalFormat(schema.format));
+        return (TKindOf(schema, 'String') && schema.type === 'string' && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TSymbol */
     function TSymbol(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Symbol' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Symbol' &&
+        return (TKindOf(schema, 'Symbol') &&
+            schema.type === 'symbol' &&
             IsOptionalString(schema.$id));
     }
     TypeGuard.TSymbol = TSymbol;
     /** Returns true if the given schema is TTemplateLiteral */
     function TTemplateLiteral(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'TemplateLiteral' &&
+        return (TKindOf(schema, 'TemplateLiteral') &&
             schema.type === 'string' &&
-            IsString(schema.pattern) &&
+            ValueGuard.IsString(schema.pattern) &&
             schema.pattern[0] === '^' &&
             schema.pattern[schema.pattern.length - 1] === '$');
     }
@@ -465,28 +501,26 @@ var TypeGuard;
     /** Returns true if the given schema is TThis */
     function TThis(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'This' &&
+        return (TKindOf(schema, 'This') &&
             IsOptionalString(schema.$id) &&
-            IsString(schema.$ref));
+            ValueGuard.IsString(schema.$ref));
     }
     TypeGuard.TThis = TThis;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Tuple' &&
+        if (!(TKindOf(schema, 'Tuple') &&
             schema.type === 'array' &&
             IsOptionalString(schema.$id) &&
-            IsNumber(schema.minItems) &&
-            IsNumber(schema.maxItems) &&
+            ValueGuard.IsNumber(schema.minItems) &&
+            ValueGuard.IsNumber(schema.maxItems) &&
             schema.minItems === schema.maxItems)) {
             return false;
         }
-        if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
+        if (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0) {
             return true;
         }
-        if (!IsArray(schema.items)) {
+        if (!ValueGuard.IsArray(schema.items)) {
             return false;
         }
         for (const inner of schema.items) {
@@ -499,10 +533,8 @@ var TypeGuard;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Undefined' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Undefined' &&
+        return (TKindOf(schema, 'Undefined') &&
+            schema.type === 'undefined' &&
             IsOptionalString(schema.$id));
     }
     TypeGuard.TUndefined = TUndefined;
@@ -514,9 +546,8 @@ var TypeGuard;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
         // prettier-ignore
-        if (!(TKind(schema) &&
-            schema[exports.Kind] === 'Union' &&
-            IsArray(schema.anyOf) &&
+        if (!(TKindOf(schema, 'Union') &&
+            ValueGuard.IsArray(schema.anyOf) &&
             IsOptionalString(schema.$id))) {
             return false;
         }
@@ -529,61 +560,58 @@ var TypeGuard;
     TypeGuard.TUnion = TUnion;
     /** Returns true if the given schema is TUint8Array */
     function TUint8Array(schema) {
-        return TKind(schema) && schema[exports.Kind] === 'Uint8Array' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.instanceOf === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+        // prettier-ignore
+        return (TKindOf(schema, 'Uint8Array') &&
+            schema.type === 'Uint8Array' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minByteLength) &&
+            IsOptionalNumber(schema.maxByteLength));
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Unknown' &&
+        return (TKindOf(schema, 'Unknown') &&
             IsOptionalString(schema.$id));
     }
     TypeGuard.TUnknown = TUnknown;
     /** Returns true if the given schema is a raw TUnsafe */
     function TUnsafe(schema) {
-        // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Unsafe');
+        return TKindOf(schema, 'Unsafe');
     }
     TypeGuard.TUnsafe = TUnsafe;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
         // prettier-ignore
-        return (TKind(schema) &&
-            schema[exports.Kind] === 'Void' &&
-            schema.type === 'null' &&
-            schema.typeOf === 'Void' &&
+        return (TKindOf(schema, 'Void') &&
+            schema.type === 'void' &&
             IsOptionalString(schema.$id));
     }
     TypeGuard.TVoid = TVoid;
-    /** Returns true if this schema has the ReadonlyOptional modifier */
-    function TReadonlyOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'ReadonlyOptional';
-    }
-    TypeGuard.TReadonlyOptional = TReadonlyOptional;
     /** Returns true if this schema has the Readonly modifier */
     function TReadonly(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'Readonly';
+        return ValueGuard.IsObject(schema) && schema[exports.Readonly] === 'Readonly';
     }
     TypeGuard.TReadonly = TReadonly;
     /** Returns true if this schema has the Optional modifier */
     function TOptional(schema) {
-        return IsObject(schema) && schema[exports.Modifier] === 'Optional';
+        return ValueGuard.IsObject(schema) && schema[exports.Optional] === 'Optional';
     }
     TypeGuard.TOptional = TOptional;
     /** Returns true if the given schema is TSchema */
     function TSchema(schema) {
-        return (typeof schema === 'object' &&
+        return (ValueGuard.IsObject(schema) &&
             (TAny(schema) ||
                 TArray(schema) ||
                 TBoolean(schema) ||
                 TBigInt(schema) ||
+                TAsyncIterator(schema) ||
                 TConstructor(schema) ||
                 TDate(schema) ||
                 TFunction(schema) ||
                 TInteger(schema) ||
                 TIntersect(schema) ||
+                TIterator(schema) ||
                 TLiteral(schema) ||
                 TNever(schema) ||
                 TNot(schema) ||
@@ -650,14 +678,38 @@ var TypeExtends;
         return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
     }
     // --------------------------------------------------------------------------
+    // StructuralRight
+    // --------------------------------------------------------------------------
+    function IsStructuralRight(right) {
+        // prettier-ignore
+        return (TypeGuard.TNever(right) ||
+            TypeGuard.TIntersect(right) ||
+            TypeGuard.TUnion(right) ||
+            TypeGuard.TUnknown(right) ||
+            TypeGuard.TAny(right));
+    }
+    function StructuralRight(left, right) {
+        if (TypeGuard.TNever(right))
+            return TNeverRight(left, right);
+        if (TypeGuard.TIntersect(right))
+            return TIntersectRight(left, right);
+        if (TypeGuard.TUnion(right))
+            return TUnionRight(left, right);
+        if (TypeGuard.TUnknown(right))
+            return TUnknownRight(left, right);
+        if (TypeGuard.TAny(right))
+            return TAnyRight(left, right);
+        throw Error('TypeExtends: StructuralRight');
+    }
+    // --------------------------------------------------------------------------
     // Any
     // --------------------------------------------------------------------------
-    function AnyRight(left, right) {
+    function TAnyRight(left, right) {
         return TypeExtendsResult.True;
     }
-    function Any(left, right) {
+    function TAny(left, right) {
         if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
+            return TIntersectRight(left, right);
         if (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)))
             return TypeExtendsResult.True;
         if (TypeGuard.TUnion(right))
@@ -671,7 +723,7 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Array
     // --------------------------------------------------------------------------
-    function ArrayRight(left, right) {
+    function TArrayRight(left, right) {
         if (TypeGuard.TUnknown(left))
             return TypeExtendsResult.False;
         if (TypeGuard.TAny(left))
@@ -680,15 +732,9 @@ var TypeExtends;
             return TypeExtendsResult.True;
         return TypeExtendsResult.False;
     }
-    function Array(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TArray(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
             return TypeExtendsResult.True;
         if (!TypeGuard.TArray(right))
@@ -696,64 +742,52 @@ var TypeExtends;
         return IntoBooleanResult(Visit(left.items, right.items));
     }
     // --------------------------------------------------------------------------
+    // AsyncIterator
+    // --------------------------------------------------------------------------
+    function TAsyncIterator(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
+        if (!TypeGuard.TAsyncIterator(right))
+            return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.items, right.items));
+    }
+    // --------------------------------------------------------------------------
     // BigInt
     // --------------------------------------------------------------------------
-    function BigInt(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TBigInt(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Boolean
     // --------------------------------------------------------------------------
-    function BooleanRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'boolean')
+    function TBooleanRight(left, right) {
+        if (TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const))
             return TypeExtendsResult.True;
         return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Boolean(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TBoolean(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Constructor
     // --------------------------------------------------------------------------
-    function Constructor(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TConstructor(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (!TypeGuard.TConstructor(right))
             return TypeExtendsResult.False;
         if (left.parameters.length > right.parameters.length)
@@ -766,35 +800,23 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Date
     // --------------------------------------------------------------------------
-    function Date(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TDate(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Function
     // --------------------------------------------------------------------------
-    function Function(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TFunction(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (!TypeGuard.TFunction(right))
             return TypeExtendsResult.False;
         if (left.parameters.length > right.parameters.length)
@@ -807,87 +829,72 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Integer
     // --------------------------------------------------------------------------
-    function IntegerRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'number')
+    function TIntegerRight(left, right) {
+        if (TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const))
             return TypeExtendsResult.True;
         return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Integer(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TInteger(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Intersect
     // --------------------------------------------------------------------------
-    function IntersectRight(left, right) {
+    function TIntersectRight(left, right) {
         return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Intersect(left, right) {
+    function TIntersect(left, right) {
         return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
-    // Literal
+    // Iterator
     // --------------------------------------------------------------------------
-    function IsLiteralString(schema) {
-        return typeof schema.const === 'string';
-    }
-    function IsLiteralNumber(schema) {
-        return typeof schema.const === 'number';
-    }
-    function IsLiteralBoolean(schema) {
-        return typeof schema.const === 'boolean';
+    function TIterator(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
+        if (!TypeGuard.TIterator(right))
+            return TypeExtendsResult.False;
+        return IntoBooleanResult(Visit(left.items, right.items));
     }
-    function Literal(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    // --------------------------------------------------------------------------
+    // Literal
+    // --------------------------------------------------------------------------
+    function TLiteral(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         if (TypeGuard.TString(right))
-            return StringRight(left, right);
+            return TStringRight(left, right);
         if (TypeGuard.TNumber(right))
-            return NumberRight(left, right);
+            return TNumberRight(left, right);
         if (TypeGuard.TInteger(right))
-            return IntegerRight(left, right);
+            return TIntegerRight(left, right);
         if (TypeGuard.TBoolean(right))
-            return BooleanRight(left, right);
+            return TBooleanRight(left, right);
         return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Never
     // --------------------------------------------------------------------------
-    function NeverRight(left, right) {
+    function TNeverRight(left, right) {
         return TypeExtendsResult.False;
     }
-    function Never(left, right) {
+    function TNever(left, right) {
         return TypeExtendsResult.True;
     }
     // --------------------------------------------------------------------------
     // Not
     // --------------------------------------------------------------------------
-    function UnwrapNot(schema) {
+    function UnwrapTNot(schema) {
         let [current, depth] = [schema, 0];
         while (true) {
             if (!TypeGuard.TNot(current))
@@ -897,66 +904,50 @@ var TypeExtends;
         }
         return depth % 2 === 0 ? current : exports.Type.Unknown();
     }
-    function Not(left, right) {
+    function TNot(left, right) {
         // TypeScript has no concept of negated types, and attempts to correctly check the negated
         // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
         // the type. Instead we unwrap to either unknown or T and continue evaluating.
         if (TypeGuard.TNot(left))
-            return Visit(UnwrapNot(left), right);
+            return Visit(UnwrapTNot(left), right);
         if (TypeGuard.TNot(right))
-            return Visit(left, UnwrapNot(right));
+            return Visit(left, UnwrapTNot(right));
         throw new Error(`TypeExtends: Invalid fallthrough for Not`);
     }
     // --------------------------------------------------------------------------
     // Null
     // --------------------------------------------------------------------------
-    function Null(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TNull(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Number
     // --------------------------------------------------------------------------
-    function NumberRight(left, right) {
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left))
+    function TNumberRight(left, right) {
+        if (TypeGuard.TLiteralNumber(left))
             return TypeExtendsResult.True;
         return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Number(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TNumber(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Object
     // --------------------------------------------------------------------------
     function IsObjectPropertyCount(schema, count) {
-        return globalThis.Object.keys(schema.properties).length === count;
+        return Object.getOwnPropertyNames(schema.properties).length === count;
     }
     function IsObjectStringLike(schema) {
         return IsObjectArrayLike(schema);
@@ -1007,18 +998,18 @@ var TypeExtends;
             return TypeExtendsResult.False;
         return TypeExtendsResult.True;
     }
-    function ObjectRight(left, right) {
+    function TObjectRight(left, right) {
         if (TypeGuard.TUnknown(left))
             return TypeExtendsResult.False;
         if (TypeGuard.TAny(left))
             return TypeExtendsResult.Union;
         if (TypeGuard.TNever(left))
             return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && IsObjectStringLike(right))
+        if (TypeGuard.TLiteralString(left) && IsObjectStringLike(right))
             return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralNumber(left) && IsObjectNumberLike(right))
+        if (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right))
             return TypeExtendsResult.True;
-        if (TypeGuard.TLiteral(left) && IsLiteralBoolean(left) && IsObjectBooleanLike(right))
+        if (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right))
             return TypeExtendsResult.True;
         if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
             return TypeExtendsResult.True;
@@ -1052,20 +1043,14 @@ var TypeExtends;
         }
         return TypeExtendsResult.False;
     }
-    function Object(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TObject(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         if (!TypeGuard.TObject(right))
             return TypeExtendsResult.False;
-        for (const key of globalThis.Object.keys(right.properties)) {
+        for (const key of Object.getOwnPropertyNames(right.properties)) {
             if (!(key in left.properties))
                 return TypeExtendsResult.False;
             if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
@@ -1077,15 +1062,9 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Promise
     // --------------------------------------------------------------------------
-    function Promise(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TPromise(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
             return TypeExtendsResult.True;
         if (!TypeGuard.TPromise(right))
@@ -1109,10 +1088,10 @@ var TypeExtends;
             return schema.patternProperties[exports.PatternStringExact];
         throw Error('TypeExtends: Cannot get record value');
     }
-    function RecordRight(left, right) {
+    function TRecordRight(left, right) {
         const Key = RecordKey(right);
         const Value = RecordValue(right);
-        if (TypeGuard.TLiteral(left) && IsLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
+        if (TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True)
             return TypeExtendsResult.True;
         if (TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key))
             return Visit(left, Value);
@@ -1121,7 +1100,7 @@ var TypeExtends;
         if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
             return Visit(left, Value);
         if (TypeGuard.TObject(left)) {
-            for (const key of globalThis.Object.keys(left.properties)) {
+            for (const key of Object.getOwnPropertyNames(left.properties)) {
                 if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
                     return TypeExtendsResult.False;
                 }
@@ -1130,18 +1109,12 @@ var TypeExtends;
         }
         return TypeExtendsResult.False;
     }
-    function Record(left, right) {
+    function TRecord(left, right) {
         const Value = RecordValue(left);
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (!TypeGuard.TRecord(right))
             return TypeExtendsResult.False;
         return Visit(Value, RecordValue(right));
@@ -1149,52 +1122,36 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // String
     // --------------------------------------------------------------------------
-    function StringRight(left, right) {
-        if (TypeGuard.TLiteral(left) && typeof left.const === 'string')
+    function TStringRight(left, right) {
+        if (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const))
             return TypeExtendsResult.True;
         return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function String(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TString(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Symbol
     // --------------------------------------------------------------------------
-    function Symbol(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TSymbol(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // TemplateLiteral
     // --------------------------------------------------------------------------
-    function TemplateLiteral(left, right) {
+    function TTemplateLiteral(left, right) {
         // TemplateLiteral types are resolved to either unions for finite expressions or string
         // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
         // either type and continue evaluating.
@@ -1207,75 +1164,58 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Tuple
     // --------------------------------------------------------------------------
-    function TupleRight(left, right) {
+    function IsArrayOfTuple(left, right) {
+        // prettier-ignore
+        return (TypeGuard.TArray(right) &&
+            left.items !== undefined &&
+            left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True));
+    }
+    function TTupleRight(left, right) {
+        if (TypeGuard.TNever(left))
+            return TypeExtendsResult.True;
         if (TypeGuard.TUnknown(left))
             return TypeExtendsResult.False;
         if (TypeGuard.TAny(left))
             return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-            return TypeExtendsResult.True;
         return TypeExtendsResult.False;
     }
-    function IsArrayOfTuple(left, right) {
-        return TypeGuard.TArray(right) && left.items !== undefined && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
-    }
-    function Tuple(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TTuple(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
             return TypeExtendsResult.True;
         if (TypeGuard.TArray(right) && IsArrayOfTuple(left, right))
             return TypeExtendsResult.True;
         if (!TypeGuard.TTuple(right))
             return TypeExtendsResult.False;
-        if ((left.items === undefined && right.items !== undefined) || (left.items !== undefined && right.items === undefined))
+        if ((ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)))
             return TypeExtendsResult.False;
-        if (left.items === undefined && right.items === undefined)
+        if (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items))
             return TypeExtendsResult.True;
         return left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Uint8Array
     // --------------------------------------------------------------------------
-    function Uint8Array(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TUint8Array(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Undefined
     // --------------------------------------------------------------------------
-    function Undefined(left, right) {
-        if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
-        if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
-        if (TypeGuard.TNever(right))
-            return NeverRight(left, right);
-        if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
-        if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+    function TUndefined(left, right) {
+        if (IsStructuralRight(right))
+            return StructuralRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         if (TypeGuard.TRecord(right))
-            return RecordRight(left, right);
+            return TRecordRight(left, right);
         if (TypeGuard.TVoid(right))
             return VoidRight(left, right);
         return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
@@ -1283,39 +1223,41 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Union
     // --------------------------------------------------------------------------
-    function UnionRight(left, right) {
+    function TUnionRight(left, right) {
         return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Union(left, right) {
+    function TUnion(left, right) {
         return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Unknown
     // --------------------------------------------------------------------------
-    function UnknownRight(left, right) {
+    function TUnknownRight(left, right) {
         return TypeExtendsResult.True;
     }
-    function Unknown(left, right) {
+    function TUnknown(left, right) {
+        if (TypeGuard.TNever(right))
+            return TNeverRight(left, right);
         if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
+            return TIntersectRight(left, right);
         if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
+            return TUnionRight(left, right);
         if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+            return TAnyRight(left, right);
         if (TypeGuard.TString(right))
-            return StringRight(left, right);
+            return TStringRight(left, right);
         if (TypeGuard.TNumber(right))
-            return NumberRight(left, right);
+            return TNumberRight(left, right);
         if (TypeGuard.TInteger(right))
-            return IntegerRight(left, right);
+            return TIntegerRight(left, right);
         if (TypeGuard.TBoolean(right))
-            return BooleanRight(left, right);
+            return TBooleanRight(left, right);
         if (TypeGuard.TArray(right))
-            return ArrayRight(left, right);
+            return TArrayRight(left, right);
         if (TypeGuard.TTuple(right))
-            return TupleRight(left, right);
+            return TTupleRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
@@ -1326,74 +1268,78 @@ var TypeExtends;
             return TypeExtendsResult.True;
         return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
-    function Void(left, right) {
+    function TVoid(left, right) {
         if (TypeGuard.TIntersect(right))
-            return IntersectRight(left, right);
+            return TIntersectRight(left, right);
         if (TypeGuard.TUnion(right))
-            return UnionRight(left, right);
+            return TUnionRight(left, right);
         if (TypeGuard.TUnknown(right))
-            return UnknownRight(left, right);
+            return TUnknownRight(left, right);
         if (TypeGuard.TAny(right))
-            return AnyRight(left, right);
+            return TAnyRight(left, right);
         if (TypeGuard.TObject(right))
-            return ObjectRight(left, right);
+            return TObjectRight(left, right);
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, right) {
         // Resolvable Types
         if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right))
-            return TemplateLiteral(left, right);
+            return TTemplateLiteral(left, right);
         if (TypeGuard.TNot(left) || TypeGuard.TNot(right))
-            return Not(left, right);
+            return TNot(left, right);
         // Standard Types
         if (TypeGuard.TAny(left))
-            return Any(left, right);
+            return TAny(left, right);
         if (TypeGuard.TArray(left))
-            return Array(left, right);
+            return TArray(left, right);
         if (TypeGuard.TBigInt(left))
-            return BigInt(left, right);
+            return TBigInt(left, right);
         if (TypeGuard.TBoolean(left))
-            return Boolean(left, right);
+            return TBoolean(left, right);
+        if (TypeGuard.TAsyncIterator(left))
+            return TAsyncIterator(left, right);
         if (TypeGuard.TConstructor(left))
-            return Constructor(left, right);
+            return TConstructor(left, right);
         if (TypeGuard.TDate(left))
-            return Date(left, right);
+            return TDate(left, right);
         if (TypeGuard.TFunction(left))
-            return Function(left, right);
+            return TFunction(left, right);
         if (TypeGuard.TInteger(left))
-            return Integer(left, right);
+            return TInteger(left, right);
         if (TypeGuard.TIntersect(left))
-            return Intersect(left, right);
+            return TIntersect(left, right);
+        if (TypeGuard.TIterator(left))
+            return TIterator(left, right);
         if (TypeGuard.TLiteral(left))
-            return Literal(left, right);
+            return TLiteral(left, right);
         if (TypeGuard.TNever(left))
-            return Never(left, right);
+            return TNever(left, right);
         if (TypeGuard.TNull(left))
-            return Null(left, right);
+            return TNull(left, right);
         if (TypeGuard.TNumber(left))
-            return Number(left, right);
+            return TNumber(left, right);
         if (TypeGuard.TObject(left))
-            return Object(left, right);
+            return TObject(left, right);
         if (TypeGuard.TRecord(left))
-            return Record(left, right);
+            return TRecord(left, right);
         if (TypeGuard.TString(left))
-            return String(left, right);
+            return TString(left, right);
         if (TypeGuard.TSymbol(left))
-            return Symbol(left, right);
+            return TSymbol(left, right);
         if (TypeGuard.TTuple(left))
-            return Tuple(left, right);
+            return TTuple(left, right);
         if (TypeGuard.TPromise(left))
-            return Promise(left, right);
+            return TPromise(left, right);
         if (TypeGuard.TUint8Array(left))
-            return Uint8Array(left, right);
+            return TUint8Array(left, right);
         if (TypeGuard.TUndefined(left))
-            return Undefined(left, right);
+            return TUndefined(left, right);
         if (TypeGuard.TUnion(left))
-            return Union(left, right);
+            return TUnion(left, right);
         if (TypeGuard.TUnknown(left))
-            return Unknown(left, right);
+            return TUnknown(left, right);
         if (TypeGuard.TVoid(left))
-            return Void(left, right);
+            return TVoid(left, right);
         throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
     }
     function Extends(left, right) {
@@ -1407,29 +1353,19 @@ var TypeExtends;
 /** Specialized Clone for Types */
 var TypeClone;
 (function (TypeClone) {
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null;
-    }
-    function IsArray(value) {
-        return globalThis.Array.isArray(value);
+    function ObjectType(value) {
+        const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        return { ...clonedProperties, ...clonedSymbols };
     }
-    function Array(value) {
+    function ArrayType(value) {
         return value.map((value) => Visit(value));
     }
-    function Object(value) {
-        const clonedProperties = globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
-            return { ...acc, [key]: Visit(value[key]) };
-        }, {});
-        const clonedSymbols = globalThis.Object.getOwnPropertySymbols(value).reduce((acc, key) => {
-            return { ...acc, [key]: Visit(value[key]) };
-        }, {});
-        return { ...clonedProperties, ...clonedSymbols };
-    }
     function Visit(value) {
-        if (IsArray(value))
-            return Array(value);
-        if (IsObject(value))
-            return Object(value);
+        if (ValueGuard.IsArray(value))
+            return ArrayType(value);
+        if (ValueGuard.IsObject(value))
+            return ObjectType(value);
         return value;
     }
     /** Clones a type. */
@@ -1445,7 +1381,7 @@ var IndexedAccessor;
 (function (IndexedAccessor) {
     function OptionalUnwrap(schema) {
         return schema.map((schema) => {
-            const { [exports.Modifier]: _, ...clone } = TypeClone.Clone(schema, {});
+            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema, {});
             return clone;
         });
     }
@@ -1470,39 +1406,39 @@ var IndexedAccessor;
             return ResolveUnion(schema);
         return schema;
     }
-    function Intersect(schema, key) {
+    function TIntersect(schema, key) {
         const resolved = schema.allOf.reduce((acc, schema) => {
             const indexed = Visit(schema, key);
             return indexed[exports.Kind] === 'Never' ? acc : [...acc, indexed];
         }, []);
         return ResolveOptional(exports.Type.Intersect(resolved));
     }
-    function Union(schema, key) {
+    function TUnion(schema, key) {
         const resolved = schema.anyOf.map((schema) => Visit(schema, key));
         return ResolveOptional(exports.Type.Union(resolved));
     }
-    function Object(schema, key) {
+    function TObject(schema, key) {
         const property = schema.properties[key];
-        return property === undefined ? exports.Type.Never() : exports.Type.Union([property]);
+        return ValueGuard.IsUndefined(property) ? exports.Type.Never() : exports.Type.Union([property]);
     }
-    function Tuple(schema, key) {
+    function TTuple(schema, key) {
         const items = schema.items;
-        if (items === undefined)
+        if (ValueGuard.IsUndefined(items))
             return exports.Type.Never();
         const element = items[key]; //
-        if (element === undefined)
+        if (ValueGuard.IsUndefined(element))
             return exports.Type.Never();
         return element;
     }
     function Visit(schema, key) {
         if (schema[exports.Kind] === 'Intersect')
-            return Intersect(schema, key);
+            return TIntersect(schema, key);
         if (schema[exports.Kind] === 'Union')
-            return Union(schema, key);
+            return TUnion(schema, key);
         if (schema[exports.Kind] === 'Object')
-            return Object(schema, key);
+            return TObject(schema, key);
         if (schema[exports.Kind] === 'Tuple')
-            return Tuple(schema, key);
+            return TTuple(schema, key);
         return exports.Type.Never();
     }
     function Resolve(schema, keys, options = {}) {
@@ -1516,15 +1452,15 @@ var IndexedAccessor;
 // --------------------------------------------------------------------------
 var ObjectMap;
 (function (ObjectMap) {
-    function Intersect(schema, callback) {
+    function TIntersect(schema, callback) {
         // prettier-ignore
         return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
-    function Union(schema, callback) {
+    function TUnion(schema, callback) {
         // prettier-ignore
         return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
     }
-    function Object(schema, callback) {
+    function TObject(schema, callback) {
         return callback(schema);
     }
     function Visit(schema, callback) {
@@ -1533,11 +1469,11 @@ var ObjectMap;
         // case of TObject where unregistered property kinds cause the TObject check to fail. As mapping is only
         // used for composition, we use explicit checks instead.
         if (schema[exports.Kind] === 'Intersect')
-            return Intersect(schema, callback);
+            return TIntersect(schema, callback);
         if (schema[exports.Kind] === 'Union')
-            return Union(schema, callback);
+            return TUnion(schema, callback);
         if (schema[exports.Kind] === 'Object')
-            return Object(schema, callback);
+            return TObject(schema, callback);
         return schema;
     }
     function Map(schema, callback, options) {
@@ -1550,28 +1486,28 @@ var KeyResolver;
     function UnwrapPattern(key) {
         return key[0] === '^' && key[key.length - 1] === '$' ? key.slice(1, key.length - 1) : key;
     }
-    function Intersect(schema, options) {
+    function TIntersect(schema, options) {
         return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, options)], []);
     }
-    function Union(schema, options) {
+    function TUnion(schema, options) {
         const sets = schema.anyOf.map((inner) => Visit(inner, options));
         return [...sets.reduce((set, outer) => outer.map((key) => (sets.every((inner) => inner.includes(key)) ? set.add(key) : set))[0], new Set())];
     }
-    function Object(schema, options) {
-        return globalThis.Object.keys(schema.properties);
+    function TObject(schema, options) {
+        return Object.getOwnPropertyNames(schema.properties);
     }
-    function Record(schema, options) {
-        return options.includePatterns ? globalThis.Object.keys(schema.patternProperties) : [];
+    function TRecord(schema, options) {
+        return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : [];
     }
     function Visit(schema, options) {
         if (TypeGuard.TIntersect(schema))
-            return Intersect(schema, options);
+            return TIntersect(schema, options);
         if (TypeGuard.TUnion(schema))
-            return Union(schema, options);
+            return TUnion(schema, options);
         if (TypeGuard.TObject(schema))
-            return Object(schema, options);
+            return TObject(schema, options);
         if (TypeGuard.TRecord(schema))
-            return Record(schema, options);
+            return TRecord(schema, options);
         return [];
     }
     /** Resolves an array of keys in this schema */
@@ -1594,7 +1530,7 @@ var KeyArrayResolver;
 (function (KeyArrayResolver) {
     /** Resolves an array of string[] keys from the given schema or array type. */
     function Resolve(schema) {
-        if (globalThis.Array.isArray(schema))
+        if (Array.isArray(schema))
             return schema;
         if (TypeGuard.TUnionLiteral(schema))
             return schema.anyOf.map((schema) => schema.const.toString());
@@ -1615,10 +1551,10 @@ var KeyArrayResolver;
 // --------------------------------------------------------------------------
 var UnionResolver;
 (function (UnionResolver) {
-    function* Union(union) {
+    function* TUnion(union) {
         for (const schema of union.anyOf) {
             if (schema[exports.Kind] === 'Union') {
-                yield* Union(schema);
+                yield* TUnion(schema);
             }
             else {
                 yield schema;
@@ -1627,7 +1563,7 @@ var UnionResolver;
     }
     /** Returns a resolved union with interior unions flattened */
     function Resolve(union) {
-        return exports.Type.Union([...Union(union)], { ...union });
+        return exports.Type.Union([...TUnion(union)], { ...union });
     }
     UnionResolver.Resolve = Resolve;
 })(UnionResolver || (exports.UnionResolver = UnionResolver = {}));
@@ -1641,12 +1577,10 @@ var TemplateLiteralPattern;
     }
     function Visit(schema, acc) {
         if (TypeGuard.TTemplateLiteral(schema)) {
-            const pattern = schema.pattern.slice(1, schema.pattern.length - 1);
-            return pattern;
+            return schema.pattern.slice(1, schema.pattern.length - 1);
         }
         else if (TypeGuard.TUnion(schema)) {
-            const tokens = schema.anyOf.map((schema) => Visit(schema, acc)).join('|');
-            return `(${tokens})`;
+            return `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})`;
         }
         else if (TypeGuard.TNumber(schema)) {
             return `${acc}${exports.PatternNumber}`;
@@ -1973,6 +1907,11 @@ class TypeBuilder {
     Create(schema) {
         return schema;
     }
+    /** `[Utility]` Discards a property key from the given schema */
+    Discard(schema, key) {
+        const { [key]: _, ...rest } = schema;
+        return rest;
+    }
     /** `[Standard]` Omits compositing symbols from this schema */
     Strict(schema) {
         return JSON.parse(JSON.stringify(schema));
@@ -1986,17 +1925,17 @@ class StandardTypeBuilder extends TypeBuilder {
     // ------------------------------------------------------------------------
     // Modifiers
     // ------------------------------------------------------------------------
-    /** `[Modifier]` Creates a Optional property */
-    Optional(schema) {
-        return { [exports.Modifier]: 'Optional', ...TypeClone.Clone(schema, {}) };
-    }
-    /** `[Modifier]` Creates a ReadonlyOptional property */
+    /** `[Standard]` Creates a Readonly and Optional property */
     ReadonlyOptional(schema) {
-        return { [exports.Modifier]: 'ReadonlyOptional', ...TypeClone.Clone(schema, {}) };
+        return this.Readonly(this.Optional(schema));
     }
-    /** `[Modifier]` Creates a Readonly object or property */
+    /** `[Standard]` Creates a Readonly property */
     Readonly(schema) {
-        return { [exports.Modifier]: 'Readonly', ...schema };
+        return { ...TypeClone.Clone(schema, {}), [exports.Readonly]: 'Readonly' };
+    }
+    /** `[Standard]` Creates an Optional property */
+    Optional(schema) {
+        return { ...TypeClone.Clone(schema, {}), [exports.Optional]: 'Optional' };
     }
     // ------------------------------------------------------------------------
     // Types
@@ -2023,8 +1962,8 @@ class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a Enum type */
     Enum(item, options = {}) {
         // prettier-ignore
-        const values = globalThis.Object.keys(item).filter((key) => isNaN(key)).map((key) => item[key]);
-        const anyOf = values.map((value) => (typeof value === 'string' ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
+        const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const anyOf = values.map((value) => (ValueGuard.IsString(value) ? { [exports.Kind]: 'Literal', type: 'string', const: value } : { [exports.Kind]: 'Literal', type: 'number', const: value }));
         return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
     }
     /** `[Standard]` A conditional type expression that will return the true type if the left type extends the right */
@@ -2072,7 +2011,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return TypeClone.Clone(schema.items, options);
         }
         else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
-            const items = schema.items === undefined ? [] : schema.items;
+            const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
             const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
             return this.Union(cloned, options);
         }
@@ -2112,7 +2051,7 @@ class StandardTypeBuilder extends TypeBuilder {
             throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern');
         }
         else if (TypeGuard.TTuple(schema)) {
-            const items = schema.items === undefined ? [] : schema.items;
+            const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
             const literals = items.map((_, index) => exports.Type.Literal(index));
             return this.Union(literals, options);
         }
@@ -2149,8 +2088,8 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates an Object type */
     Object(properties, options = {}) {
-        const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]) || TypeGuard.TReadonlyOptional(properties[key]));
+        const propertyKeys = Object.getOwnPropertyNames(properties);
+        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]));
         const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
         const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Clone(options.additionalProperties, {}) } : {};
         const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(properties[key], {}) }), {});
@@ -2170,7 +2109,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 if (schema.required.length === 0)
                     delete schema.required;
             }
-            for (const key of globalThis.Object.keys(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(schema.properties)) {
                 if (keys.includes(key))
                     delete schema.properties[key];
             }
@@ -2179,28 +2118,12 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a mapped type where all properties are Optional */
     Partial(schema, options = {}) {
-        function Apply(schema) {
-            // prettier-ignore
-            switch (schema[exports.Modifier]) {
-                case 'ReadonlyOptional':
-                    schema[exports.Modifier] = 'ReadonlyOptional';
-                    break;
-                case 'Readonly':
-                    schema[exports.Modifier] = 'ReadonlyOptional';
-                    break;
-                case 'Optional':
-                    schema[exports.Modifier] = 'Optional';
-                    break;
-                default:
-                    schema[exports.Modifier] = 'Optional';
-                    break;
-            }
-        }
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            delete schema.required;
-            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
-            return schema;
+        return ObjectMap.Map(schema, (object) => {
+            const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+                return { ...acc, [key]: this.Optional(object.properties[key]) };
+            }, {});
+            return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */);
         }, options);
     }
     Pick(schema, unresolved, options = {}) {
@@ -2212,7 +2135,7 @@ class StandardTypeBuilder extends TypeBuilder {
                 if (schema.required.length === 0)
                     delete schema.required;
             }
-            for (const key of globalThis.Object.keys(schema.properties)) {
+            for (const key of Object.getOwnPropertyNames(schema.properties)) {
                 if (!keys.includes(key))
                     delete schema.properties[key];
             }
@@ -2235,21 +2158,20 @@ class StandardTypeBuilder extends TypeBuilder {
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
-                throw Error('TypeBuilder: Record key of type union contains non-literal types');
+                throw Error('StandardTypeBuilder: Record key of type union contains non-literal types');
         }
         else if (TypeGuard.TLiteral(key)) {
-            if (typeof key.const === 'string' || typeof key.const === 'number') {
+            if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
                 return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
             }
             else
-                throw Error('TypeBuilder: Record key of type literal is not of type string or number');
+                throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number');
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-            const pattern = exports.PatternNumberExact;
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
+            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema, {}) } });
         }
         else if (TypeGuard.TString(key)) {
-            const pattern = key.pattern === undefined ? exports.PatternStringExact : key.pattern;
+            const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
             return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
         }
         else {
@@ -2258,48 +2180,34 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Creates a Recursive type */
     Recursive(callback, options = {}) {
-        if (options.$id === undefined)
+        if (ValueGuard.IsUndefined(options.$id))
             options.$id = `T${TypeOrdinal++}`;
         const thisType = callback({ [exports.Kind]: 'This', $ref: `${options.$id}` });
         thisType.$id = options.$id;
         return this.Create({ ...options, [exports.Hint]: 'Recursive', ...thisType });
     }
-    /** `[Standard]` Creates a Ref type. The referenced type must contain a $id */
-    Ref(schema, options = {}) {
-        if (schema.$id === undefined)
+    /** `[Standard]` Creates a Ref type. */
+    Ref(unresolved, options = {}) {
+        if (ValueGuard.IsString(unresolved))
+            return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: unresolved });
+        if (ValueGuard.IsUndefined(unresolved.$id))
             throw Error('StandardTypeBuilder.Ref: Target type must specify an $id');
-        return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
+        return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: unresolved.$id });
     }
     /** `[Standard]` Creates a mapped type where all properties are Required */
     Required(schema, options = {}) {
-        function Apply(schema) {
-            // prettier-ignore
-            switch (schema[exports.Modifier]) {
-                case 'ReadonlyOptional':
-                    schema[exports.Modifier] = 'Readonly';
-                    break;
-                case 'Readonly':
-                    schema[exports.Modifier] = 'Readonly';
-                    break;
-                case 'Optional':
-                    delete schema[exports.Modifier];
-                    break;
-                default:
-                    delete schema[exports.Modifier];
-                    break;
-            }
-        }
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema, {}), (schema) => {
-            schema.required = globalThis.Object.keys(schema.properties);
-            globalThis.Object.keys(schema.properties).forEach(key => Apply(schema.properties[key]));
-            return schema;
+        return ObjectMap.Map(schema, (object) => {
+            const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+                return { ...acc, [key]: this.Discard(object.properties[key], exports.Optional) };
+            }, {});
+            return this.Object(properties, object /* object used as options to retain other constraints  */);
         }, options);
     }
     /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
     Rest(schema) {
         if (TypeGuard.TTuple(schema)) {
-            if (schema.items === undefined)
+            if (ValueGuard.IsUndefined(schema.items))
                 return [];
             return schema.items.map((schema) => TypeClone.Clone(schema, {}));
         }
@@ -2314,7 +2222,7 @@ class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a template literal type */
     TemplateLiteral(unresolved, options = {}) {
         // prettier-ignore
-        const pattern = (typeof unresolved === 'string')
+        const pattern = (ValueGuard.IsString(unresolved))
             ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
             : TemplateLiteralPattern.Create(unresolved);
         return this.Create({ ...options, [exports.Kind]: 'TemplateLiteral', type: 'string', pattern });
@@ -2357,9 +2265,13 @@ exports.StandardTypeBuilder = StandardTypeBuilder;
 // ExtendedTypeBuilder
 // --------------------------------------------------------------------------
 class ExtendedTypeBuilder extends StandardTypeBuilder {
+    /** `[Extended]` Creates a AsyncIterator type */
+    AsyncIterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items, {}) });
+    }
     /** `[Extended]` Creates a BigInt type */
     BigInt(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'null', typeOf: 'BigInt' });
+        return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'bigint' });
     }
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters(schema, options = {}) {
@@ -2369,33 +2281,44 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     Constructor(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
         const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
+        return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Creates a Date type */
     Date(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
+        return this.Create({ ...options, [exports.Kind]: 'Date', type: 'Date' });
     }
     /** `[Extended]` Creates a Function type */
     Function(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
         const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-        return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
+        return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Extracts the InstanceType from the given Constructor */
     InstanceType(schema, options = {}) {
         return TypeClone.Clone(schema.returns, options);
     }
+    /** `[Extended]` Creates an Iterator type */
+    Iterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items, {}) });
+    }
     /** `[Extended]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
         return this.Tuple(schema.parameters, { ...options });
     }
     /** `[Extended]` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'object', instanceOf: 'Promise', item: TypeClone.Clone(item, {}) });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item, {}) });
+    }
+    /** `[Extended]` Creates a String pattern type from Regular Expression */
+    RegExp(unresolved, options = {}) {
+        const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source;
+        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern });
     }
-    /** `[Extended]` Creates a regular expression type */
+    /**
+     * @deprecated Use `Type.RegExp`
+     */
     RegEx(regex, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'String', type: 'string', pattern: regex.source });
+        return this.RegExp(regex, options);
     }
     /** `[Extended]` Extracts the ReturnType from the given Function */
     ReturnType(schema, options = {}) {
@@ -2403,23 +2326,23 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     }
     /** `[Extended]` Creates a Symbol type */
     Symbol(options) {
-        return this.Create({ ...options, [exports.Kind]: 'Symbol', type: 'null', typeOf: 'Symbol' });
+        return this.Create({ ...options, [exports.Kind]: 'Symbol', type: 'symbol' });
     }
     /** `[Extended]` Creates a Undefined type */
     Undefined(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'null', typeOf: 'Undefined' });
+        return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'undefined' });
     }
     /** `[Extended]` Creates a Uint8Array type */
     Uint8Array(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'object', instanceOf: 'Uint8Array' });
+        return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'Uint8Array' });
     }
     /** `[Extended]` Creates a Void type */
     Void(options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'null', typeOf: 'Void' });
+        return this.Create({ ...options, [exports.Kind]: 'Void', type: 'void' });
     }
 }
 exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 exports.StandardType = new StandardTypeBuilder();
-/** JSON Schema TypeBuilder with Static Resolution for TypeScript */
+/** JSON Schema Type Builder with Static Resolution for TypeScript */
 exports.Type = new ExtendedTypeBuilder();