@sinclair/typebox 0.30.4 → 0.31.0-dev-2

package/typebox.js

@@ -27,10 +27,11 @@ 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.Intrinsic = 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;
+exports.Type = exports.JsonType = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.TypeBuilder = exports.TypeBuilderError = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralGeneratorError = exports.TemplateLiteralFinite = exports.TemplateLiteralFiniteError = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyArrayResolverError = exports.KeyResolver = exports.ObjectMap = exports.Intrinsic = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.TypeExtendsError = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeBoxError = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = exports.Transform = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
+exports.Transform = Symbol.for('TypeBox.Transform');
 exports.Readonly = Symbol.for('TypeBox.Readonly');
 exports.Optional = Symbol.for('TypeBox.Optional');
 exports.Hint = Symbol.for('TypeBox.Hint');
@@ -79,6 +80,15 @@ var TypeRegistry;
     }
     TypeRegistry.Get = Get;
 })(TypeRegistry || (exports.TypeRegistry = TypeRegistry = {}));
+// --------------------------------------------------------------------------
+// TypeBoxError
+// --------------------------------------------------------------------------
+class TypeBoxError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.TypeBoxError = TypeBoxError;
 /** A registry for user defined string formats */
 var FormatRegistry;
 (function (FormatRegistry) {
@@ -117,49 +127,54 @@ var FormatRegistry;
 // --------------------------------------------------------------------------
 // ValueGuard
 // --------------------------------------------------------------------------
+/** Provides functions to type guard raw JavaScript values */
 var ValueGuard;
 (function (ValueGuard) {
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null;
-    }
-    ValueGuard.IsObject = IsObject;
+    /** Returns true if this value is an array */
     function IsArray(value) {
         return Array.isArray(value);
     }
     ValueGuard.IsArray = IsArray;
+    /** Returns true if this value is bigint */
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
+    ValueGuard.IsBigInt = IsBigInt;
+    /** Returns true if this value is a boolean */
     function IsBoolean(value) {
         return typeof value === 'boolean';
     }
     ValueGuard.IsBoolean = IsBoolean;
+    /** Returns true if this value is null */
     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;
+    /** Returns true if this value is number */
     function IsNumber(value) {
         return typeof value === 'number';
     }
     ValueGuard.IsNumber = IsNumber;
+    /** Returns true if this value is an object */
+    function IsObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    ValueGuard.IsObject = IsObject;
+    /** Returns true if this value is string */
     function IsString(value) {
         return typeof value === 'string';
     }
     ValueGuard.IsString = IsString;
+    /** Returns true if this value is undefined */
+    function IsUndefined(value) {
+        return value === undefined;
+    }
+    ValueGuard.IsUndefined = IsUndefined;
 })(ValueGuard || (exports.ValueGuard = ValueGuard = {}));
 // --------------------------------------------------------------------------
 // TypeGuard
 // --------------------------------------------------------------------------
-class TypeGuardUnknownTypeError extends Error {
-    constructor(schema) {
-        super('TypeGuard: Unknown type');
-        this.schema = schema;
-    }
+class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
 /** Provides functions to test if JavaScript values are TypeBox types */
@@ -245,11 +260,11 @@ var TypeGuard;
         return (TKindOf(schema, 'BigInt') &&
             schema.type === 'bigint' &&
             IsOptionalString(schema.$id) &&
-            IsOptionalBigInt(schema.multipleOf) &&
-            IsOptionalBigInt(schema.minimum) &&
-            IsOptionalBigInt(schema.maximum) &&
+            IsOptionalBigInt(schema.exclusiveMaximum) &&
             IsOptionalBigInt(schema.exclusiveMinimum) &&
-            IsOptionalBigInt(schema.exclusiveMaximum));
+            IsOptionalBigInt(schema.maximum) &&
+            IsOptionalBigInt(schema.minimum) &&
+            IsOptionalBigInt(schema.multipleOf));
     }
     TypeGuard.TBigInt = TBigInt;
     /** Returns true if the given schema is TBoolean */
@@ -263,18 +278,12 @@ var TypeGuard;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Constructor') &&
+        return (TKindOf(schema, 'Constructor') &&
             schema.type === 'constructor' &&
             IsOptionalString(schema.$id) &&
             ValueGuard.IsArray(schema.parameters) &&
-            TSchema(schema.returns))) {
-            return false;
-        }
-        for (const parameter of schema.parameters) {
-            if (!TSchema(parameter))
-                return false;
-        }
-        return true;
+            schema.parameters.every(schema => TSchema(schema)) &&
+            TSchema(schema.returns));
     }
     TypeGuard.TConstructor = TConstructor;
     /** Returns true if the given schema is TDate */
@@ -282,27 +291,22 @@ var TypeGuard;
         return (TKindOf(schema, 'Date') &&
             schema.type === 'Date' &&
             IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.minimumTimestamp) &&
-            IsOptionalNumber(schema.maximumTimestamp) &&
+            IsOptionalNumber(schema.exclusiveMaximumTimestamp) &&
             IsOptionalNumber(schema.exclusiveMinimumTimestamp) &&
-            IsOptionalNumber(schema.exclusiveMaximumTimestamp));
+            IsOptionalNumber(schema.maximumTimestamp) &&
+            IsOptionalNumber(schema.minimumTimestamp) &&
+            IsOptionalNumber(schema.multipleOfTimestamp));
     }
     TypeGuard.TDate = TDate;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Function') &&
+        return (TKindOf(schema, 'Function') &&
             schema.type === 'function' &&
             IsOptionalString(schema.$id) &&
             ValueGuard.IsArray(schema.parameters) &&
-            TSchema(schema.returns))) {
-            return false;
-        }
-        for (const parameter of schema.parameters) {
-            if (!TSchema(parameter))
-                return false;
-        }
-        return true;
+            schema.parameters.every(schema => TSchema(schema)) &&
+            TSchema(schema.returns));
     }
     TypeGuard.TFunction = TFunction;
     /** Returns true if the given schema is TInteger */
@@ -310,31 +314,23 @@ var TypeGuard;
         return (TKindOf(schema, 'Integer') &&
             schema.type === 'integer' &&
             IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.multipleOf) &&
-            IsOptionalNumber(schema.minimum) &&
-            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMaximum) &&
             IsOptionalNumber(schema.exclusiveMinimum) &&
-            IsOptionalNumber(schema.exclusiveMaximum));
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.multipleOf));
     }
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TIntersect */
     function TIntersect(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Intersect') &&
+        return (TKindOf(schema, 'Intersect') &&
+            (ValueGuard.IsString(schema.type) && schema.type !== 'object' ? false : true) &&
             ValueGuard.IsArray(schema.allOf) &&
+            schema.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
             IsOptionalString(schema.type) &&
             (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) &&
-            IsOptionalString(schema.$id))) {
-            return false;
-        }
-        if ('type' in schema && schema.type !== 'object') {
-            return false;
-        }
-        for (const inner of schema.allOf) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
+            IsOptionalString(schema.$id));
     }
     TypeGuard.TIntersect = TIntersect;
     /** Returns true if the given schema is TIterator */
@@ -408,31 +404,24 @@ var TypeGuard;
         return (TKindOf(schema, 'Number') &&
             schema.type === 'number' &&
             IsOptionalString(schema.$id) &&
-            IsOptionalNumber(schema.multipleOf) &&
-            IsOptionalNumber(schema.minimum) &&
-            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.exclusiveMaximum) &&
             IsOptionalNumber(schema.exclusiveMinimum) &&
-            IsOptionalNumber(schema.exclusiveMaximum));
+            IsOptionalNumber(schema.maximum) &&
+            IsOptionalNumber(schema.minimum) &&
+            IsOptionalNumber(schema.multipleOf));
     }
     TypeGuard.TNumber = TNumber;
     /** Returns true if the given schema is TObject */
     function TObject(schema) {
-        if (!(TKindOf(schema, 'Object') &&
+        // prettier-ignore
+        return (TKindOf(schema, 'Object') &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
             ValueGuard.IsObject(schema.properties) &&
             IsAdditionalProperties(schema.additionalProperties) &&
             IsOptionalNumber(schema.minProperties) &&
-            IsOptionalNumber(schema.maxProperties))) {
-            return false;
-        }
-        for (const [key, value] of Object.entries(schema.properties)) {
-            if (!IsControlCharacterFree(key))
-                return false;
-            if (!TSchema(value))
-                return false;
-        }
-        return true;
+            IsOptionalNumber(schema.maxProperties) &&
+            Object.entries(schema.properties).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
     }
     TypeGuard.TObject = TObject;
     /** Returns true if the given schema is TPromise */
@@ -447,26 +436,25 @@ var TypeGuard;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Record') &&
+        return (TKindOf(schema, 'Record') &&
             schema.type === 'object' &&
             IsOptionalString(schema.$id) &&
             IsAdditionalProperties(schema.additionalProperties) &&
-            ValueGuard.IsObject(schema.patternProperties))) {
-            return false;
-        }
-        const keys = Object.getOwnPropertyNames(schema.patternProperties);
-        if (keys.length !== 1) {
-            return false;
-        }
-        if (!IsPattern(keys[0])) {
-            return false;
-        }
-        if (!TSchema(schema.patternProperties[keys[0]])) {
-            return false;
-        }
-        return true;
+            ValueGuard.IsObject(schema.patternProperties) &&
+            ((schema) => {
+                const keys = Object.getOwnPropertyNames(schema.patternProperties);
+                return (keys.length === 1 &&
+                    IsPattern(keys[0]) &&
+                    ValueGuard.IsObject(schema.patternProperties) &&
+                    TSchema(schema.patternProperties[keys[0]]));
+            })(schema));
     }
     TypeGuard.TRecord = TRecord;
+    /** Returns true if this schema is TRecursive */
+    function TRecursive(schema) {
+        return ValueGuard.IsObject(schema) && exports.Hint in schema && schema[exports.Hint] === 'Recursive';
+    }
+    TypeGuard.TRecursive = TRecursive;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
         // prettier-ignore
@@ -513,28 +501,25 @@ var TypeGuard;
             ValueGuard.IsString(schema.$ref));
     }
     TypeGuard.TThis = TThis;
+    /** Returns true of this schema is TTransform */
+    function TTransform(schema) {
+        return ValueGuard.IsObject(schema) && exports.Transform in schema;
+    }
+    TypeGuard.TTransform = TTransform;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Tuple') &&
+        return (TKindOf(schema, 'Tuple') &&
             schema.type === 'array' &&
             IsOptionalString(schema.$id) &&
             ValueGuard.IsNumber(schema.minItems) &&
             ValueGuard.IsNumber(schema.maxItems) &&
-            schema.minItems === schema.maxItems)) {
-            return false;
-        }
-        if (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0) {
-            return true;
-        }
-        if (!ValueGuard.IsArray(schema.items)) {
-            return false;
-        }
-        for (const inner of schema.items) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
+            schema.minItems === schema.maxItems &&
+            (( // empty
+            ValueGuard.IsUndefined(schema.items) &&
+                ValueGuard.IsUndefined(schema.additionalItems) &&
+                schema.minItems === 0) || (ValueGuard.IsArray(schema.items) &&
+                schema.items.every(schema => TSchema(schema)))));
     }
     TypeGuard.TTuple = TTuple;
     /** Returns true if the given schema is TUndefined */
@@ -553,16 +538,11 @@ var TypeGuard;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
         // prettier-ignore
-        if (!(TKindOf(schema, 'Union') &&
+        return (TKindOf(schema, 'Union') &&
+            IsOptionalString(schema.$id) &&
+            ValueGuard.IsObject(schema) &&
             ValueGuard.IsArray(schema.anyOf) &&
-            IsOptionalString(schema.$id))) {
-            return false;
-        }
-        for (const inner of schema.anyOf) {
-            if (!TSchema(inner))
-                return false;
-        }
-        return true;
+            schema.anyOf.every(schema => TSchema(schema)));
     }
     TypeGuard.TUnion = TUnion;
     /** Returns true if the given schema is TUint8Array */
@@ -650,26 +630,24 @@ var TypeGuard;
 var ExtendsUndefined;
 (function (ExtendsUndefined) {
     function Check(schema) {
-        if (schema[exports.Kind] === 'Undefined')
-            return true;
-        if (schema[exports.Kind] === 'Not') {
-            return !Check(schema.not);
-        }
-        if (schema[exports.Kind] === 'Intersect') {
-            const intersect = schema;
-            return intersect.allOf.every((schema) => Check(schema));
-        }
-        if (schema[exports.Kind] === 'Union') {
-            const union = schema;
-            return union.anyOf.some((schema) => Check(schema));
-        }
-        return false;
+        return schema[exports.Kind] === 'Intersect'
+            ? schema.allOf.every((schema) => Check(schema))
+            : schema[exports.Kind] === 'Union'
+                ? schema.anyOf.some((schema) => Check(schema))
+                : schema[exports.Kind] === 'Undefined'
+                    ? true
+                    : schema[exports.Kind] === 'Not'
+                        ? !Check(schema.not)
+                        : false;
     }
     ExtendsUndefined.Check = Check;
 })(ExtendsUndefined || (exports.ExtendsUndefined = ExtendsUndefined = {}));
 // --------------------------------------------------------------------------
 // TypeExtends
 // --------------------------------------------------------------------------
+class TypeExtendsError extends TypeBoxError {
+}
+exports.TypeExtendsError = TypeExtendsError;
 var TypeExtendsResult;
 (function (TypeExtendsResult) {
     TypeExtendsResult[TypeExtendsResult["Union"] = 0] = "Union";
@@ -682,7 +660,13 @@ var TypeExtends;
     // IntoBooleanResult
     // --------------------------------------------------------------------------
     function IntoBooleanResult(result) {
-        return result === TypeExtendsResult.False ? TypeExtendsResult.False : TypeExtendsResult.True;
+        return result === TypeExtendsResult.False ? result : TypeExtendsResult.True;
+    }
+    // --------------------------------------------------------------------------
+    // Throw
+    // --------------------------------------------------------------------------
+    function Throw(message) {
+        throw new TypeExtendsError(message);
     }
     // --------------------------------------------------------------------------
     // StructuralRight
@@ -696,17 +680,13 @@ var TypeExtends;
             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');
+        // prettier-ignore
+        return (TypeGuard.TNever(right) ? TNeverRight(left, right) :
+            TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+                TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+                    TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+                        TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                            Throw('StructuralRight'));
     }
     // --------------------------------------------------------------------------
     // Any
@@ -715,179 +695,155 @@ var TypeExtends;
         return TypeExtendsResult.True;
     }
     function TAny(left, right) {
-        if (TypeGuard.TIntersect(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))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TUnknown(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TAny(right))
-            return TypeExtendsResult.True;
-        return TypeExtendsResult.Union;
+        // prettier-ignore
+        return (TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+            (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) ? TypeExtendsResult.True :
+                TypeGuard.TUnion(right) ? TypeExtendsResult.Union :
+                    TypeGuard.TUnknown(right) ? TypeExtendsResult.True :
+                        TypeGuard.TAny(right) ? TypeExtendsResult.True :
+                            TypeExtendsResult.Union);
     }
     // --------------------------------------------------------------------------
     // Array
     // --------------------------------------------------------------------------
     function TArrayRight(left, right) {
-        if (TypeGuard.TUnknown(left))
-            return TypeExtendsResult.False;
-        if (TypeGuard.TAny(left))
-            return TypeExtendsResult.Union;
-        if (TypeGuard.TNever(left))
-            return TypeExtendsResult.True;
-        return TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+            TypeGuard.TAny(left) ? TypeExtendsResult.Union :
+                TypeGuard.TNever(left) ? TypeExtendsResult.True :
+                    TypeExtendsResult.False);
     }
     function TArray(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectArrayLike(right))
-            return TypeExtendsResult.True;
-        if (!TypeGuard.TArray(right))
-            return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.items, right.items));
+        // prettier-ignore
+        return (TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
+            IsStructuralRight(right) ? StructuralRight(left, right) :
+                !TypeGuard.TArray(right) ? TypeExtendsResult.False :
+                    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));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            !TypeGuard.TAsyncIterator(right) ? TypeExtendsResult.False :
+                IntoBooleanResult(Visit(left.items, right.items)));
     }
     // --------------------------------------------------------------------------
     // BigInt
     // --------------------------------------------------------------------------
     function TBigInt(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TBigInt(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Boolean
     // --------------------------------------------------------------------------
     function TBooleanRight(left, right) {
-        if (TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const))
-            return TypeExtendsResult.True;
-        return TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        return TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const) ? TypeExtendsResult.True : TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function TBoolean(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TBoolean(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Constructor
     // --------------------------------------------------------------------------
     function TConstructor(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (!TypeGuard.TConstructor(right))
-            return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-            return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-            return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                !TypeGuard.TConstructor(right) ? TypeExtendsResult.False :
+                    left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
+                        (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
+                            IntoBooleanResult(Visit(left.returns, right.returns)));
     }
     // --------------------------------------------------------------------------
     // Date
     // --------------------------------------------------------------------------
     function TDate(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TDate(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Function
     // --------------------------------------------------------------------------
     function TFunction(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (!TypeGuard.TFunction(right))
-            return TypeExtendsResult.False;
-        if (left.parameters.length > right.parameters.length)
-            return TypeExtendsResult.False;
-        if (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) {
-            return TypeExtendsResult.False;
-        }
-        return IntoBooleanResult(Visit(left.returns, right.returns));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                !TypeGuard.TFunction(right) ? TypeExtendsResult.False :
+                    left.parameters.length > right.parameters.length ? TypeExtendsResult.False :
+                        (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True)) ? TypeExtendsResult.False :
+                            IntoBooleanResult(Visit(left.returns, right.returns)));
     }
     // --------------------------------------------------------------------------
     // Integer
     // --------------------------------------------------------------------------
     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;
+        // prettier-ignore
+        return (TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? TypeExtendsResult.True :
+            TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True :
+                TypeExtendsResult.False);
     }
     function TInteger(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True :
+            IsStructuralRight(right) ? StructuralRight(left, right) :
+                TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                    TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Intersect
     // --------------------------------------------------------------------------
     function TIntersectRight(left, right) {
-        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True)
+            ? TypeExtendsResult.True
+            : TypeExtendsResult.False;
     }
     function TIntersect(left, right) {
-        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True)
+            ? TypeExtendsResult.True
+            : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Iterator
     // --------------------------------------------------------------------------
     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));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            !TypeGuard.TIterator(right) ? TypeExtendsResult.False :
+                IntoBooleanResult(Visit(left.items, right.items)));
     }
     // --------------------------------------------------------------------------
     // Literal
     // --------------------------------------------------------------------------
     function TLiteral(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        if (TypeGuard.TString(right))
-            return TStringRight(left, right);
-        if (TypeGuard.TNumber(right))
-            return TNumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-            return TIntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-            return TBooleanRight(left, right);
-        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True :
+            IsStructuralRight(right) ? StructuralRight(left, right) :
+                TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                    TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                        TypeGuard.TString(right) ? TStringRight(left, right) :
+                            TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+                                TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+                                    TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+                                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Never
@@ -915,40 +871,38 @@ var TypeExtends;
         // 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(UnwrapTNot(left), right);
-        if (TypeGuard.TNot(right))
-            return Visit(left, UnwrapTNot(right));
-        throw new Error(`TypeExtends: Invalid fallthrough for Not`);
+        // prettier-ignore
+        return (TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) :
+            TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) :
+                Throw('Invalid fallthrough for Not'));
     }
     // --------------------------------------------------------------------------
     // Null
     // --------------------------------------------------------------------------
     function TNull(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TNull(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Number
     // --------------------------------------------------------------------------
     function TNumberRight(left, right) {
-        if (TypeGuard.TLiteralNumber(left))
-            return TypeExtendsResult.True;
-        return TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TLiteralNumber(left) ? TypeExtendsResult.True :
+            TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True :
+                TypeExtendsResult.False);
     }
     function TNumber(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Object
@@ -999,161 +953,133 @@ var TypeExtends;
     // Property
     // --------------------------------------------------------------------------
     function Property(left, right) {
-        if (Visit(left, right) === TypeExtendsResult.False)
-            return TypeExtendsResult.False;
-        if (TypeGuard.TOptional(left) && !TypeGuard.TOptional(right))
-            return TypeExtendsResult.False;
-        return TypeExtendsResult.True;
+        // prettier-ignore
+        return (Visit(left, right) === TypeExtendsResult.False ? TypeExtendsResult.False :
+            TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? TypeExtendsResult.False :
+                TypeExtendsResult.True);
     }
     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.TLiteralString(left) && IsObjectStringLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TString(left) && IsObjectStringLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TNumber(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TInteger(left) && IsObjectNumberLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TDate(left) && IsObjectDateLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))
-            return TypeExtendsResult.True;
-        if (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) {
-            // When expressing a Record with literal key values, the Record is converted into a Object with
-            // the Hint assigned as `Record`. This is used to invert the extends logic.
-            return right[exports.Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        if (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) {
-            return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
-        }
-        return TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+            TypeGuard.TAny(left) ? TypeExtendsResult.Union : (TypeGuard.TNever(left) ||
+                (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) ||
+                (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) ||
+                (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+                (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+                (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) ||
+                (TypeGuard.TString(left) && IsObjectStringLike(right)) ||
+                (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+                (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) ||
+                (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) ||
+                (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) ||
+                (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+                (TypeGuard.TDate(left) && IsObjectDateLike(right)) ||
+                (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) ||
+                (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))) ? TypeExtendsResult.True :
+                (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) ? (() => {
+                    // When expressing a Record with literal key values, the Record is converted into a Object with
+                    // the Hint assigned as `Record`. This is used to invert the extends logic.
+                    return right[exports.Hint] === 'Record' ? TypeExtendsResult.True : TypeExtendsResult.False;
+                })() :
+                    (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) ? (() => {
+                        return IsObjectPropertyCount(right, 0)
+                            ? TypeExtendsResult.True
+                            : TypeExtendsResult.False;
+                    })() :
+                        TypeExtendsResult.False);
     }
     function TObject(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        if (!TypeGuard.TObject(right))
-            return TypeExtendsResult.False;
-        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) {
-                return TypeExtendsResult.False;
-            }
-        }
-        return TypeExtendsResult.True;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                !TypeGuard.TObject(right) ? TypeExtendsResult.False :
+                    (() => {
+                        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) {
+                                return TypeExtendsResult.False;
+                            }
+                        }
+                        return TypeExtendsResult.True;
+                    })());
     }
     // --------------------------------------------------------------------------
     // Promise
     // --------------------------------------------------------------------------
     function TPromise(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right) && IsObjectPromiseLike(right))
-            return TypeExtendsResult.True;
-        if (!TypeGuard.TPromise(right))
-            return TypeExtendsResult.False;
-        return IntoBooleanResult(Visit(left.item, right.item));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? TypeExtendsResult.True :
+                !TypeGuard.TPromise(right) ? TypeExtendsResult.False :
+                    IntoBooleanResult(Visit(left.item, right.item)));
     }
     // --------------------------------------------------------------------------
     // Record
     // --------------------------------------------------------------------------
     function RecordKey(schema) {
-        if (exports.PatternNumberExact in schema.patternProperties)
-            return exports.Type.Number();
-        if (exports.PatternStringExact in schema.patternProperties)
-            return exports.Type.String();
-        throw Error('TypeExtends: Cannot get record key');
+        // prettier-ignore
+        return (exports.PatternNumberExact in schema.patternProperties ? exports.Type.Number() :
+            exports.PatternStringExact in schema.patternProperties ? exports.Type.String() :
+                Throw('Unknown record key pattern'));
     }
     function RecordValue(schema) {
-        if (exports.PatternNumberExact in schema.patternProperties)
-            return schema.patternProperties[exports.PatternNumberExact];
-        if (exports.PatternStringExact in schema.patternProperties)
-            return schema.patternProperties[exports.PatternStringExact];
-        throw Error('TypeExtends: Cannot get record value');
+        // prettier-ignore
+        return (exports.PatternNumberExact in schema.patternProperties ? schema.patternProperties[exports.PatternNumberExact] :
+            exports.PatternStringExact in schema.patternProperties ? schema.patternProperties[exports.PatternStringExact] :
+                Throw('Unable to get record value schema'));
     }
     function TRecordRight(left, right) {
-        const Key = RecordKey(right);
-        const Value = RecordValue(right);
-        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);
-        if (TypeGuard.TString(left) && TypeGuard.TNumber(Key))
-            return Visit(left, Value);
-        if (TypeGuard.TArray(left) && TypeGuard.TNumber(Key))
-            return Visit(left, Value);
-        if (TypeGuard.TObject(left)) {
-            for (const key of Object.getOwnPropertyNames(left.properties)) {
-                if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
-                    return TypeExtendsResult.False;
-                }
-            }
-            return TypeExtendsResult.True;
-        }
-        return TypeExtendsResult.False;
+        const [Key, Value] = [RecordKey(right), RecordValue(right)];
+        // prettier-ignore
+        return ((TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True) ? TypeExtendsResult.True :
+            TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+                TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+                    TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+                        TypeGuard.TObject(left) ? (() => {
+                            for (const key of Object.getOwnPropertyNames(left.properties)) {
+                                if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+                                    return TypeExtendsResult.False;
+                                }
+                            }
+                            return TypeExtendsResult.True;
+                        })() :
+                            TypeExtendsResult.False);
     }
     function TRecord(left, right) {
-        const Value = RecordValue(left);
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (!TypeGuard.TRecord(right))
-            return TypeExtendsResult.False;
-        return Visit(Value, RecordValue(right));
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                !TypeGuard.TRecord(right) ? TypeExtendsResult.False :
+                    Visit(RecordValue(left), RecordValue(right)));
     }
     // --------------------------------------------------------------------------
     // String
     // --------------------------------------------------------------------------
     function TStringRight(left, right) {
-        if (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const))
-            return TypeExtendsResult.True;
-        return TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? TypeExtendsResult.True :
+            TypeGuard.TString(left) ? TypeExtendsResult.True :
+                TypeExtendsResult.False);
     }
     function TString(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TString(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Symbol
     // --------------------------------------------------------------------------
     function TSymbol(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TSymbol(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // TemplateLiteral
@@ -1162,11 +1088,10 @@ var TypeExtends;
         // 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.
-        if (TypeGuard.TTemplateLiteral(left))
-            return Visit(TemplateLiteralResolver.Resolve(left), right);
-        if (TypeGuard.TTemplateLiteral(right))
-            return Visit(left, TemplateLiteralResolver.Resolve(right));
-        throw new Error(`TypeExtends: Invalid fallthrough for TemplateLiteral`);
+        // prettier-ignore
+        return (TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralResolver.Resolve(left), right) :
+            TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralResolver.Resolve(right)) :
+                Throw('Invalid fallthrough for TemplateLiteral'));
     }
     // --------------------------------------------------------------------------
     // Tuple
@@ -1178,63 +1103,60 @@ var TypeExtends;
             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;
-        return TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TNever(left) ? TypeExtendsResult.True :
+            TypeGuard.TUnknown(left) ? TypeExtendsResult.False :
+                TypeGuard.TAny(left) ? TypeExtendsResult.Union :
+                    TypeExtendsResult.False);
     }
     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 ((ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)))
-            return TypeExtendsResult.False;
-        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;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True :
+                TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? TypeExtendsResult.True :
+                    !TypeGuard.TTuple(right) ? TypeExtendsResult.False :
+                        (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.False :
+                            (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) ? TypeExtendsResult.True :
+                                left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True :
+                                    TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Uint8Array
     // --------------------------------------------------------------------------
     function TUint8Array(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        return TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TUint8Array(right) ? TypeExtendsResult.True :
+                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Undefined
     // --------------------------------------------------------------------------
     function TUndefined(left, right) {
-        if (IsStructuralRight(right))
-            return StructuralRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        if (TypeGuard.TRecord(right))
-            return TRecordRight(left, right);
-        if (TypeGuard.TVoid(right))
-            return VoidRight(left, right);
-        return TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TVoid(right) ? VoidRight(left, right) :
+                        TypeGuard.TUndefined(right) ? TypeExtendsResult.True :
+                            TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Union
     // --------------------------------------------------------------------------
     function TUnionRight(left, right) {
-        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True)
+            ? TypeExtendsResult.True
+            : TypeExtendsResult.False;
     }
     function TUnion(left, right) {
-        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True)
+            ? TypeExtendsResult.True
+            : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
     // Unknown
@@ -1243,111 +1165,74 @@ var TypeExtends;
         return TypeExtendsResult.True;
     }
     function TUnknown(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.TAny(right))
-            return TAnyRight(left, right);
-        if (TypeGuard.TString(right))
-            return TStringRight(left, right);
-        if (TypeGuard.TNumber(right))
-            return TNumberRight(left, right);
-        if (TypeGuard.TInteger(right))
-            return TIntegerRight(left, right);
-        if (TypeGuard.TBoolean(right))
-            return TBooleanRight(left, right);
-        if (TypeGuard.TArray(right))
-            return TArrayRight(left, right);
-        if (TypeGuard.TTuple(right))
-            return TTupleRight(left, right);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        return TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return (TypeGuard.TNever(right) ? TNeverRight(left, right) :
+            TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+                TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+                    TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                        TypeGuard.TString(right) ? TStringRight(left, right) :
+                            TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+                                TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+                                    TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+                                        TypeGuard.TArray(right) ? TArrayRight(left, right) :
+                                            TypeGuard.TTuple(right) ? TTupleRight(left, right) :
+                                                TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                                                    TypeGuard.TUnknown(right) ? TypeExtendsResult.True :
+                                                        TypeExtendsResult.False);
     }
     // --------------------------------------------------------------------------
     // Void
     // --------------------------------------------------------------------------
     function VoidRight(left, right) {
-        if (TypeGuard.TUndefined(left))
-            return TypeExtendsResult.True;
-        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True :
+            TypeGuard.TUndefined(left) ? TypeExtendsResult.True :
+                TypeExtendsResult.False;
     }
     function TVoid(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);
-        if (TypeGuard.TObject(right))
-            return TObjectRight(left, right);
-        return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        // prettier-ignore
+        return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+            TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+                TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+                    TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                            TypeGuard.TVoid(right) ? TypeExtendsResult.True :
+                                TypeExtendsResult.False;
     }
     function Visit(left, right) {
-        // Resolvable Types
-        if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right))
-            return TTemplateLiteral(left, right);
-        if (TypeGuard.TNot(left) || TypeGuard.TNot(right))
-            return TNot(left, right);
-        // Standard Types
-        if (TypeGuard.TAny(left))
-            return TAny(left, right);
-        if (TypeGuard.TArray(left))
-            return TArray(left, right);
-        if (TypeGuard.TBigInt(left))
-            return TBigInt(left, right);
-        if (TypeGuard.TBoolean(left))
-            return TBoolean(left, right);
-        if (TypeGuard.TAsyncIterator(left))
-            return TAsyncIterator(left, right);
-        if (TypeGuard.TConstructor(left))
-            return TConstructor(left, right);
-        if (TypeGuard.TDate(left))
-            return TDate(left, right);
-        if (TypeGuard.TFunction(left))
-            return TFunction(left, right);
-        if (TypeGuard.TInteger(left))
-            return TInteger(left, right);
-        if (TypeGuard.TIntersect(left))
-            return TIntersect(left, right);
-        if (TypeGuard.TIterator(left))
-            return TIterator(left, right);
-        if (TypeGuard.TLiteral(left))
-            return TLiteral(left, right);
-        if (TypeGuard.TNever(left))
-            return TNever(left, right);
-        if (TypeGuard.TNull(left))
-            return TNull(left, right);
-        if (TypeGuard.TNumber(left))
-            return TNumber(left, right);
-        if (TypeGuard.TObject(left))
-            return TObject(left, right);
-        if (TypeGuard.TRecord(left))
-            return TRecord(left, right);
-        if (TypeGuard.TString(left))
-            return TString(left, right);
-        if (TypeGuard.TSymbol(left))
-            return TSymbol(left, right);
-        if (TypeGuard.TTuple(left))
-            return TTuple(left, right);
-        if (TypeGuard.TPromise(left))
-            return TPromise(left, right);
-        if (TypeGuard.TUint8Array(left))
-            return TUint8Array(left, right);
-        if (TypeGuard.TUndefined(left))
-            return TUndefined(left, right);
-        if (TypeGuard.TUnion(left))
-            return TUnion(left, right);
-        if (TypeGuard.TUnknown(left))
-            return TUnknown(left, right);
-        if (TypeGuard.TVoid(left))
-            return TVoid(left, right);
-        throw Error(`TypeExtends: Unknown left type operand '${left[exports.Kind]}'`);
+        // prettier-ignore
+        return (
+        // resolvable
+        (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
+            (TypeGuard.TNot(left) || TypeGuard.TNot(right)) ? TNot(left, right) :
+                // standard
+                TypeGuard.TAny(left) ? TAny(left, right) :
+                    TypeGuard.TArray(left) ? TArray(left, right) :
+                        TypeGuard.TBigInt(left) ? TBigInt(left, right) :
+                            TypeGuard.TBoolean(left) ? TBoolean(left, right) :
+                                TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) :
+                                    TypeGuard.TConstructor(left) ? TConstructor(left, right) :
+                                        TypeGuard.TDate(left) ? TDate(left, right) :
+                                            TypeGuard.TFunction(left) ? TFunction(left, right) :
+                                                TypeGuard.TInteger(left) ? TInteger(left, right) :
+                                                    TypeGuard.TIntersect(left) ? TIntersect(left, right) :
+                                                        TypeGuard.TIterator(left) ? TIterator(left, right) :
+                                                            TypeGuard.TLiteral(left) ? TLiteral(left, right) :
+                                                                TypeGuard.TNever(left) ? TNever(left, right) :
+                                                                    TypeGuard.TNull(left) ? TNull(left, right) :
+                                                                        TypeGuard.TNumber(left) ? TNumber(left, right) :
+                                                                            TypeGuard.TObject(left) ? TObject(left, right) :
+                                                                                TypeGuard.TRecord(left) ? TRecord(left, right) :
+                                                                                    TypeGuard.TString(left) ? TString(left, right) :
+                                                                                        TypeGuard.TSymbol(left) ? TSymbol(left, right) :
+                                                                                            TypeGuard.TTuple(left) ? TTuple(left, right) :
+                                                                                                TypeGuard.TPromise(left) ? TPromise(left, right) :
+                                                                                                    TypeGuard.TUint8Array(left) ? TUint8Array(left, right) :
+                                                                                                        TypeGuard.TUndefined(left) ? TUndefined(left, right) :
+                                                                                                            TypeGuard.TUnion(left) ? TUnion(left, right) :
+                                                                                                                TypeGuard.TUnknown(left) ? TUnknown(left, right) :
+                                                                                                                    TypeGuard.TVoid(left) ? TVoid(left, right) :
+                                                                                                                        Throw(`Unknown left type operand '${left[exports.Kind]}'`));
     }
     function Extends(left, right) {
         return Visit(left, right);
@@ -1369,17 +1254,21 @@ var TypeClone;
         return value.map((value) => Visit(value));
     }
     function Visit(value) {
-        if (ValueGuard.IsArray(value))
-            return ArrayType(value);
-        if (ValueGuard.IsObject(value))
-            return ObjectType(value);
-        return value;
-    }
-    /** Clones a type. */
-    function Clone(schema, options = {}) {
+        // prettier-ignore
+        return ValueGuard.IsArray(value) ? ArrayType(value) :
+            ValueGuard.IsObject(value) ? ObjectType(value) :
+                value;
+    }
+    /** Clones a Rest */
+    function Rest(schemas) {
+        return schemas.map((schema) => Type(schema));
+    }
+    TypeClone.Rest = Rest;
+    /** Clones a Type */
+    function Type(schema, options = {}) {
         return { ...Visit(schema), ...options };
     }
-    TypeClone.Clone = Clone;
+    TypeClone.Type = Type;
 })(TypeClone || (exports.TypeClone = TypeClone = {}));
 // --------------------------------------------------------------------------
 // IndexedAccessor
@@ -1388,7 +1277,7 @@ var IndexedAccessor;
 (function (IndexedAccessor) {
     function OptionalUnwrap(schema) {
         return schema.map((schema) => {
-            const { [exports.Optional]: _, ...clone } = TypeClone.Clone(schema);
+            const { [exports.Optional]: _, ...clone } = TypeClone.Type(schema);
             return clone;
         });
     }
@@ -1399,19 +1288,16 @@ var IndexedAccessor;
         return schema.some((schema) => TypeGuard.TOptional(schema));
     }
     function ResolveIntersect(schema) {
-        const optional = IsIntersectOptional(schema.allOf);
-        return optional ? exports.Type.Optional(exports.Type.Intersect(OptionalUnwrap(schema.allOf))) : schema;
+        return IsIntersectOptional(schema.allOf) ? exports.Type.Optional(exports.Type.Intersect(OptionalUnwrap(schema.allOf))) : schema;
     }
     function ResolveUnion(schema) {
-        const optional = IsUnionOptional(schema.anyOf);
-        return optional ? exports.Type.Optional(exports.Type.Union(OptionalUnwrap(schema.anyOf))) : schema;
+        return IsUnionOptional(schema.anyOf) ? exports.Type.Optional(exports.Type.Union(OptionalUnwrap(schema.anyOf))) : schema;
     }
     function ResolveOptional(schema) {
-        if (schema[exports.Kind] === 'Intersect')
-            return ResolveIntersect(schema);
-        if (schema[exports.Kind] === 'Union')
-            return ResolveUnion(schema);
-        return schema;
+        // prettier-ignore
+        return schema[exports.Kind] === 'Intersect' ? ResolveIntersect(schema) :
+            schema[exports.Kind] === 'Union' ? ResolveUnion(schema) :
+                schema;
     }
     function TIntersect(schema, key) {
         const resolved = schema.allOf.reduce((acc, schema) => {
@@ -1438,15 +1324,12 @@ var IndexedAccessor;
         return element;
     }
     function Visit(schema, key) {
-        if (schema[exports.Kind] === 'Intersect')
-            return TIntersect(schema, key);
-        if (schema[exports.Kind] === 'Union')
-            return TUnion(schema, key);
-        if (schema[exports.Kind] === 'Object')
-            return TObject(schema, key);
-        if (schema[exports.Kind] === 'Tuple')
-            return TTuple(schema, key);
-        return exports.Type.Never();
+        // prettier-ignore
+        return schema[exports.Kind] === 'Intersect' ? TIntersect(schema, key) :
+            schema[exports.Kind] === 'Union' ? TUnion(schema, key) :
+                schema[exports.Kind] === 'Object' ? TObject(schema, key) :
+                    schema[exports.Kind] === 'Tuple' ? TTuple(schema, key) :
+                        exports.Type.Never();
     }
     function Resolve(schema, keys, options = {}) {
         const resolved = keys.map((key) => Visit(schema, key.toString()));
@@ -1501,13 +1384,11 @@ var Intrinsic;
         return [Map(L, mode), ...IntrinsicRest(R, mode)];
     }
     function Visit(schema, mode) {
-        if (TypeGuard.TTemplateLiteral(schema))
-            return IntrinsicTemplateLiteral(schema, mode);
-        if (TypeGuard.TUnion(schema))
-            return exports.Type.Union(IntrinsicRest(schema.anyOf, mode));
-        if (TypeGuard.TLiteral(schema))
-            return exports.Type.Literal(IntrinsicLiteral(schema.const, mode));
-        return schema;
+        // prettier-ignore
+        return TypeGuard.TTemplateLiteral(schema) ? IntrinsicTemplateLiteral(schema, mode) :
+            TypeGuard.TUnion(schema) ? exports.Type.Union(IntrinsicRest(schema.anyOf, mode)) :
+                TypeGuard.TLiteral(schema) ? exports.Type.Literal(IntrinsicLiteral(schema.const, mode)) :
+                    schema;
     }
     /** Applies an intrinsic string manipulation to the given type. */
     function Map(schema, mode) {
@@ -1536,16 +1417,14 @@ var ObjectMap;
         // prevent sub schema mapping as unregistered kinds will not pass TSchema checks. This is notable in the
         // 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 TIntersect(schema, callback);
-        if (schema[exports.Kind] === 'Union')
-            return TUnion(schema, callback);
-        if (schema[exports.Kind] === 'Object')
-            return TObject(schema, callback);
-        return schema;
+        // prettier-ignore
+        return (schema[exports.Kind] === 'Intersect' ? TIntersect(schema, callback) :
+            schema[exports.Kind] === 'Union' ? TUnion(schema, callback) :
+                schema[exports.Kind] === 'Object' ? TObject(schema, callback) :
+                    schema);
     }
     function Map(schema, callback, options) {
-        return { ...Visit(TypeClone.Clone(schema), callback), ...options };
+        return { ...Visit(TypeClone.Type(schema), callback), ...options };
     }
     ObjectMap.Map = Map;
 })(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
@@ -1568,15 +1447,12 @@ var KeyResolver;
         return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : [];
     }
     function Visit(schema, options) {
-        if (TypeGuard.TIntersect(schema))
-            return TIntersect(schema, options);
-        if (TypeGuard.TUnion(schema))
-            return TUnion(schema, options);
-        if (TypeGuard.TObject(schema))
-            return TObject(schema, options);
-        if (TypeGuard.TRecord(schema))
-            return TRecord(schema, options);
-        return [];
+        // prettier-ignore
+        return (TypeGuard.TIntersect(schema) ? TIntersect(schema, options) :
+            TypeGuard.TUnion(schema) ? TUnion(schema, options) :
+                TypeGuard.TObject(schema) ? TObject(schema, options) :
+                    TypeGuard.TRecord(schema) ? TRecord(schema, options) :
+                        []);
     }
     /** Resolves an array of keys in this schema */
     function ResolveKeys(schema, options) {
@@ -1594,23 +1470,23 @@ var KeyResolver;
 // --------------------------------------------------------------------------
 // KeyArrayResolver
 // --------------------------------------------------------------------------
+class KeyArrayResolverError extends TypeBoxError {
+}
+exports.KeyArrayResolverError = KeyArrayResolverError;
 var KeyArrayResolver;
 (function (KeyArrayResolver) {
     /** Resolves an array of string[] keys from the given schema or array type. */
     function Resolve(schema) {
-        if (Array.isArray(schema))
-            return schema;
-        if (TypeGuard.TUnionLiteral(schema))
-            return schema.anyOf.map((schema) => schema.const.toString());
-        if (TypeGuard.TLiteral(schema))
-            return [schema.const];
-        if (TypeGuard.TTemplateLiteral(schema)) {
-            const expression = TemplateLiteralParser.ParseExact(schema.pattern);
-            if (!TemplateLiteralFinite.Check(expression))
-                throw Error('KeyArrayResolver: Cannot resolve keys from infinite template expression');
-            return [...TemplateLiteralGenerator.Generate(expression)];
-        }
-        return [];
+        // prettier-ignore
+        return Array.isArray(schema) ? schema :
+            TypeGuard.TUnionLiteral(schema) ? schema.anyOf.map((schema) => schema.const.toString()) :
+                TypeGuard.TLiteral(schema) ? [schema.const] :
+                    TypeGuard.TTemplateLiteral(schema) ? (() => {
+                        const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+                        if (!TemplateLiteralFinite.Check(expression))
+                            throw new KeyArrayResolverError('Cannot resolve keys from infinite template expression');
+                        return [...TemplateLiteralGenerator.Generate(expression)];
+                    })() : [];
     }
     KeyArrayResolver.Resolve = Resolve;
 })(KeyArrayResolver || (exports.KeyArrayResolver = KeyArrayResolver = {}));
@@ -1638,42 +1514,28 @@ var UnionResolver;
 // --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
+class TemplateLiteralPatternError extends TypeBoxError {
+}
+exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
 var TemplateLiteralPattern;
 (function (TemplateLiteralPattern) {
+    function Throw(message) {
+        throw new TemplateLiteralPatternError(message);
+    }
     function Escape(value) {
         return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
     function Visit(schema, acc) {
-        if (TypeGuard.TTemplateLiteral(schema)) {
-            return schema.pattern.slice(1, schema.pattern.length - 1);
-        }
-        else if (TypeGuard.TUnion(schema)) {
-            return `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})`;
-        }
-        else if (TypeGuard.TNumber(schema)) {
-            return `${acc}${exports.PatternNumber}`;
-        }
-        else if (TypeGuard.TInteger(schema)) {
-            return `${acc}${exports.PatternNumber}`;
-        }
-        else if (TypeGuard.TBigInt(schema)) {
-            return `${acc}${exports.PatternNumber}`;
-        }
-        else if (TypeGuard.TString(schema)) {
-            return `${acc}${exports.PatternString}`;
-        }
-        else if (TypeGuard.TLiteral(schema)) {
-            return `${acc}${Escape(schema.const.toString())}`;
-        }
-        else if (TypeGuard.TBoolean(schema)) {
-            return `${acc}${exports.PatternBoolean}`;
-        }
-        else if (TypeGuard.TNever(schema)) {
-            throw Error('TemplateLiteralPattern: TemplateLiteral cannot operate on types of TNever');
-        }
-        else {
-            throw Error(`TemplateLiteralPattern: Unexpected Kind '${schema[exports.Kind]}'`);
-        }
+        // prettier-ignore
+        return (TypeGuard.TTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
+            TypeGuard.TUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
+                TypeGuard.TNumber(schema) ? `${acc}${exports.PatternNumber}` :
+                    TypeGuard.TInteger(schema) ? `${acc}${exports.PatternNumber}` :
+                        TypeGuard.TBigInt(schema) ? `${acc}${exports.PatternNumber}` :
+                            TypeGuard.TString(schema) ? `${acc}${exports.PatternString}` :
+                                TypeGuard.TLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
+                                    TypeGuard.TBoolean(schema) ? `${acc}${exports.PatternBoolean}` :
+                                        Throw(`Unexpected Kind '${schema[exports.Kind]}'`));
     }
     function Create(kinds) {
         return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
@@ -1698,10 +1560,7 @@ var TemplateLiteralResolver;
 // --------------------------------------------------------------------------------------
 // TemplateLiteralParser
 // --------------------------------------------------------------------------------------
-class TemplateLiteralParserError extends Error {
-    constructor(message) {
-        super(message);
-    }
+class TemplateLiteralParserError extends TypeBoxError {
 }
 exports.TemplateLiteralParserError = TemplateLiteralParserError;
 var TemplateLiteralParser;
@@ -1816,21 +1675,18 @@ var TemplateLiteralParser;
                 index = end - 1;
             }
         }
-        if (expressions.length === 0)
-            return { type: 'const', const: '' };
-        if (expressions.length === 1)
-            return expressions[0];
-        return { type: 'and', expr: expressions };
+        // prettier-ignore
+        return (expressions.length === 0) ? { type: 'const', const: '' } :
+            (expressions.length === 1) ? expressions[0] :
+                { type: 'and', expr: expressions };
     }
     /** Parses a pattern and returns an expression tree */
     function Parse(pattern) {
-        if (IsGroup(pattern))
-            return Parse(InGroup(pattern));
-        if (IsPrecedenceOr(pattern))
-            return Or(pattern);
-        if (IsPrecedenceAnd(pattern))
-            return And(pattern);
-        return { type: 'const', const: pattern };
+        // prettier-ignore
+        return IsGroup(pattern) ? Parse(InGroup(pattern)) :
+            IsPrecedenceOr(pattern) ? Or(pattern) :
+                IsPrecedenceAnd(pattern) ? And(pattern) :
+                    { type: 'const', const: pattern };
     }
     TemplateLiteralParser.Parse = Parse;
     /** Parses a pattern and strips forward and trailing ^ and $ */
@@ -1842,8 +1698,14 @@ var TemplateLiteralParser;
 // --------------------------------------------------------------------------------------
 // TemplateLiteralFinite
 // --------------------------------------------------------------------------------------
+class TemplateLiteralFiniteError extends TypeBoxError {
+}
+exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
 var TemplateLiteralFinite;
 (function (TemplateLiteralFinite) {
+    function Throw(message) {
+        throw new TemplateLiteralFiniteError(message);
+    }
     function IsNumber(expression) {
         // prettier-ignore
         return (expression.type === 'or' &&
@@ -1866,23 +1728,22 @@ var TemplateLiteralFinite;
         return expression.type === 'const' && expression.const === '.*';
     }
     function Check(expression) {
-        if (IsBoolean(expression))
-            return true;
-        if (IsNumber(expression) || IsString(expression))
-            return false;
-        if (expression.type === 'and')
-            return expression.expr.every((expr) => Check(expr));
-        if (expression.type === 'or')
-            return expression.expr.every((expr) => Check(expr));
-        if (expression.type === 'const')
-            return true;
-        throw Error(`TemplateLiteralFinite: Unknown expression type`);
+        // prettier-ignore
+        return IsBoolean(expression) ? true :
+            IsNumber(expression) || IsString(expression) ? false :
+                (expression.type === 'and') ? expression.expr.every((expr) => Check(expr)) :
+                    (expression.type === 'or') ? expression.expr.every((expr) => Check(expr)) :
+                        (expression.type === 'const') ? true :
+                            Throw(`Unknown expression type`);
     }
     TemplateLiteralFinite.Check = Check;
 })(TemplateLiteralFinite || (exports.TemplateLiteralFinite = TemplateLiteralFinite = {}));
 // --------------------------------------------------------------------------------------
 // TemplateLiteralGenerator
 // --------------------------------------------------------------------------------------
+class TemplateLiteralGeneratorError extends TypeBoxError {
+}
+exports.TemplateLiteralGeneratorError = TemplateLiteralGeneratorError;
 var TemplateLiteralGenerator;
 (function (TemplateLiteralGenerator) {
     function* Reduce(buffer) {
@@ -1905,13 +1766,11 @@ var TemplateLiteralGenerator;
         return yield expression.const;
     }
     function* Generate(expression) {
-        if (expression.type === 'and')
-            return yield* And(expression);
-        if (expression.type === 'or')
-            return yield* Or(expression);
-        if (expression.type === 'const')
-            return yield* Const(expression);
-        throw Error('TemplateLiteralGenerator: Unknown expression');
+        // prettier-ignore
+        return (expression.type === 'and' ? yield* And(expression) :
+            expression.type === 'or' ? yield* Or(expression) :
+                expression.type === 'const' ? yield* Const(expression) :
+                    (() => { throw new TemplateLiteralGeneratorError('Unknown expression'); })());
     }
     TemplateLiteralGenerator.Generate = Generate;
 })(TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = TemplateLiteralGenerator = {}));
@@ -1922,16 +1781,17 @@ var TemplateLiteralDslParser;
 (function (TemplateLiteralDslParser) {
     function* ParseUnion(template) {
         const trim = template.trim().replace(/"|'/g, '');
-        if (trim === 'boolean')
-            return yield exports.Type.Boolean();
-        if (trim === 'number')
-            return yield exports.Type.Number();
-        if (trim === 'bigint')
-            return yield exports.Type.BigInt();
-        if (trim === 'string')
-            return yield exports.Type.String();
-        const literals = trim.split('|').map((literal) => exports.Type.Literal(literal.trim()));
-        return yield literals.length === 0 ? exports.Type.Never() : literals.length === 1 ? literals[0] : exports.Type.Union(literals);
+        // prettier-ignore
+        return (trim === 'boolean' ? yield exports.Type.Boolean() :
+            trim === 'number' ? yield exports.Type.Number() :
+                trim === 'bigint' ? yield exports.Type.BigInt() :
+                    trim === 'string' ? yield exports.Type.String() :
+                        yield (() => {
+                            const literals = trim.split('|').map((literal) => exports.Type.Literal(literal.trim()));
+                            return (literals.length === 0 ? exports.Type.Never() :
+                                literals.length === 1 ? literals[0] :
+                                    exports.Type.Union(literals));
+                        })());
     }
     function* ParseTerminal(template) {
         if (template[1] !== '{') {
@@ -1963,6 +1823,38 @@ var TemplateLiteralDslParser;
     }
     TemplateLiteralDslParser.Parse = Parse;
 })(TemplateLiteralDslParser || (exports.TemplateLiteralDslParser = TemplateLiteralDslParser = {}));
+// ---------------------------------------------------------------------
+// TransformBuilder
+// ---------------------------------------------------------------------
+class TransformDecodeBuilder {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+    }
+}
+exports.TransformDecodeBuilder = TransformDecodeBuilder;
+class TransformEncodeBuilder {
+    constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+    }
+    Encode(encode) {
+        const schema = TypeClone.Type(this.schema);
+        // prettier-ignore
+        return (TypeGuard.TTransform(schema) ? (() => {
+            const Encode = (value) => schema[exports.Transform].Encode(encode(value));
+            const Decode = (value) => this.decode(schema[exports.Transform].Decode(value));
+            const Codec = { Encode: Encode, Decode: Decode };
+            return { ...schema, [exports.Transform]: Codec };
+        })() : (() => {
+            const Codec = { Decode: this.decode, Encode: encode };
+            return { ...schema, [exports.Transform]: Codec };
+        })());
+    }
+}
+exports.TransformEncodeBuilder = TransformEncodeBuilder;
 // --------------------------------------------------------------------------
 // TypeOrdinal: Used for auto $id generation
 // --------------------------------------------------------------------------
@@ -1970,218 +1862,221 @@ let TypeOrdinal = 0;
 // --------------------------------------------------------------------------
 // TypeBuilder
 // --------------------------------------------------------------------------
+class TypeBuilderError extends TypeBoxError {
+}
+exports.TypeBuilderError = TypeBuilderError;
 class TypeBuilder {
-    /** `[Utility]` Creates a schema without `static` and `params` types */
+    /** `[Internal]` Creates a schema without `static` and `params` types */
     Create(schema) {
         return schema;
     }
-    /** `[Utility]` Discards a property key from the given schema */
+    /** `[Internal]` Throws a TypeBuilder error with the given message */
+    Throw(message) {
+        throw new TypeBuilderError(message);
+    }
+    /** `[Internal]` Discards a property key from the given schema */
     Discard(schema, key) {
         const { [key]: _, ...rest } = schema;
         return rest;
     }
-    /** `[Standard]` Omits compositing symbols from this schema */
+    /** `[Json]` Omits compositing symbols from this schema */
     Strict(schema) {
         return JSON.parse(JSON.stringify(schema));
     }
 }
 exports.TypeBuilder = TypeBuilder;
 // --------------------------------------------------------------------------
-// StandardTypeBuilder
+// JsonTypeBuilder
 // --------------------------------------------------------------------------
-class StandardTypeBuilder extends TypeBuilder {
+class JsonTypeBuilder extends TypeBuilder {
     // ------------------------------------------------------------------------
     // Modifiers
     // ------------------------------------------------------------------------
-    /** `[Standard]` Creates a Readonly and Optional property */
+    /** `[Json]` Creates a Readonly and Optional property */
     ReadonlyOptional(schema) {
         return this.Readonly(this.Optional(schema));
     }
-    /** `[Standard]` Creates a Readonly property */
+    /** `[Json]` Creates a Readonly property */
     Readonly(schema) {
-        return { ...TypeClone.Clone(schema), [exports.Readonly]: 'Readonly' };
+        return { ...TypeClone.Type(schema), [exports.Readonly]: 'Readonly' };
     }
-    /** `[Standard]` Creates an Optional property */
+    /** `[Json]` Creates an Optional property */
     Optional(schema) {
-        return { ...TypeClone.Clone(schema), [exports.Optional]: 'Optional' };
+        return { ...TypeClone.Type(schema), [exports.Optional]: 'Optional' };
     }
     // ------------------------------------------------------------------------
     // Types
     // ------------------------------------------------------------------------
-    /** `[Standard]` Creates an Any type */
+    /** `[Json]` Creates an Any type */
     Any(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Any' });
     }
-    /** `[Standard]` Creates an Array type */
+    /** `[Json]` Creates an Array type */
     Array(schema, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Clone(schema) });
+        return this.Create({ ...options, [exports.Kind]: 'Array', type: 'array', items: TypeClone.Type(schema) });
     }
-    /** `[Standard]` Creates a Boolean type */
+    /** `[Json]` Creates a Boolean type */
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    /** `[Standard]` Intrinsic function to Capitalize LiteralString types */
+    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
     Capitalize(schema, options = {}) {
-        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Capitalize'), ...options };
+        return { ...Intrinsic.Map(TypeClone.Type(schema), 'Capitalize'), ...options };
     }
-    /** `[Standard]` Creates a Composite object type */
+    /** `[Json]` Creates a Composite object type */
     Composite(objects, options) {
         const intersect = exports.Type.Intersect(objects, {});
         const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
         const properties = keys.reduce((acc, key) => ({ ...acc, [key]: exports.Type.Index(intersect, [key]) }), {});
         return exports.Type.Object(properties, options);
     }
-    /** `[Standard]` Creates a Enum type */
+    /** `[Json]` Creates a Enum type */
     Enum(item, options = {}) {
         // prettier-ignore
         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 }));
+        // prettier-ignore
+        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]` Creates a Conditional type */
+    /** `[Json]` Creates a Conditional type */
     Extends(left, right, trueType, falseType, options = {}) {
         switch (TypeExtends.Extends(left, right)) {
             case TypeExtendsResult.Union:
-                return this.Union([TypeClone.Clone(trueType, options), TypeClone.Clone(falseType, options)]);
+                return this.Union([TypeClone.Type(trueType, options), TypeClone.Type(falseType, options)]);
             case TypeExtendsResult.True:
-                return TypeClone.Clone(trueType, options);
+                return TypeClone.Type(trueType, options);
             case TypeExtendsResult.False:
-                return TypeClone.Clone(falseType, options);
+                return TypeClone.Type(falseType, options);
         }
     }
-    /** `[Standard]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
     Exclude(unionType, excludedMembers, options = {}) {
-        if (TypeGuard.TTemplateLiteral(unionType))
-            return this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options);
-        if (TypeGuard.TTemplateLiteral(excludedMembers))
-            return this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options);
-        if (TypeGuard.TUnion(unionType)) {
-            const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False);
-            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
-        }
-        else {
-            return (TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(unionType, options));
-        }
-    }
-    /** `[Standard]` Constructs a type by extracting from type all union members that are assignable to union */
+        // prettier-ignore
+        return (TypeGuard.TTemplateLiteral(unionType) ? this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) :
+            TypeGuard.TTemplateLiteral(excludedMembers) ? this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) :
+                TypeGuard.TUnion(unionType) ? (() => {
+                    const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False);
+                    return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options));
+                })() :
+                    TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) :
+                        TypeClone.Type(unionType, options));
+    }
+    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
     Extract(type, union, options = {}) {
-        if (TypeGuard.TTemplateLiteral(type))
-            return this.Extract(TemplateLiteralResolver.Resolve(type), union, options);
-        if (TypeGuard.TTemplateLiteral(union))
-            return this.Extract(type, TemplateLiteralResolver.Resolve(union), options);
-        if (TypeGuard.TUnion(type)) {
-            const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False);
-            return (narrowed.length === 1 ? TypeClone.Clone(narrowed[0], options) : this.Union(narrowed, options));
-        }
-        else {
-            return (TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Clone(type, options) : this.Never(options));
-        }
-    }
-    /** `[Standard]` Returns an Indexed property type for the given keys */
+        // prettier-ignore
+        return (TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) :
+            TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) :
+                TypeGuard.TUnion(type) ? (() => {
+                    const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False);
+                    return (narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options));
+                })() :
+                    TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Type(type, options) :
+                        this.Never(options));
+    }
+    /** `[Json]` Returns an Indexed property type for the given keys */
     Index(schema, unresolved, options = {}) {
-        if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
-            return TypeClone.Clone(schema.items, options);
-        }
-        else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
-            const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
-            const cloned = items.map((schema) => TypeClone.Clone(schema));
-            return this.Union(cloned, options);
-        }
-        else {
-            const keys = KeyArrayResolver.Resolve(unresolved);
-            const clone = TypeClone.Clone(schema);
-            return IndexedAccessor.Resolve(clone, keys, options);
-        }
-    }
-    /** `[Standard]` Creates an Integer type */
+        // prettier-ignore
+        return (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+            return TypeClone.Type(schema.items, options);
+        })() :
+            TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+                const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+                const cloned = items.map((schema) => TypeClone.Type(schema));
+                return this.Union(cloned, options);
+            })() : (() => {
+                const keys = KeyArrayResolver.Resolve(unresolved);
+                const clone = TypeClone.Type(schema);
+                return IndexedAccessor.Resolve(clone, keys, options);
+            })());
+    }
+    /** `[Json]` Creates an Integer type */
     Integer(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Integer', type: 'integer' });
     }
-    /** `[Standard]` Creates an Intersect type */
+    /** `[Json]` Creates an Intersect type */
     Intersect(allOf, options = {}) {
         if (allOf.length === 0)
             return exports.Type.Never();
         if (allOf.length === 1)
-            return TypeClone.Clone(allOf[0], options);
+            return TypeClone.Type(allOf[0], options);
+        if (allOf.some((schema) => TypeGuard.TTransform(schema)))
+            this.Throw('Cannot intersect transform types');
         const objects = allOf.every((schema) => TypeGuard.TObject(schema));
-        const cloned = allOf.map((schema) => TypeClone.Clone(schema));
-        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Clone(options.unevaluatedProperties) } : {};
-        if (options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects) {
-            return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned });
-        }
-        else {
-            return this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', allOf: cloned });
-        }
-    }
-    /** `[Standard]` Creates a KeyOf type */
+        const cloned = TypeClone.Rest(allOf);
+        // prettier-ignore
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties)
+            ? { unevaluatedProperties: TypeClone.Type(options.unevaluatedProperties) }
+            : {};
+        return options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects
+            ? this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', type: 'object', allOf: cloned })
+            : this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: 'Intersect', allOf: cloned });
+    }
+    /** `[Json]` Creates a KeyOf type */
     KeyOf(schema, options = {}) {
-        if (TypeGuard.TRecord(schema)) {
+        // prettier-ignore
+        return (TypeGuard.TRecord(schema) ? (() => {
             const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-            if (pattern === exports.PatternNumberExact)
-                return this.Number(options);
-            if (pattern === exports.PatternStringExact)
-                return this.String(options);
-            throw Error('StandardTypeBuilder: Unable to resolve key type from Record key pattern');
-        }
-        else if (TypeGuard.TTuple(schema)) {
-            const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
-            const literals = items.map((_, index) => exports.Type.Literal(index));
-            return this.Union(literals, options);
-        }
-        else if (TypeGuard.TArray(schema)) {
-            return this.Number(options);
-        }
-        else {
-            const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false });
-            if (keys.length === 0)
-                return this.Never(options);
-            const literals = keys.map((key) => this.Literal(key));
-            return this.Union(literals, options);
-        }
-    }
-    /** `[Standard]` Creates a Literal type */
+            return (pattern === exports.PatternNumberExact ? this.Number(options) :
+                pattern === exports.PatternStringExact ? this.String(options) :
+                    this.Throw('Unable to resolve key type from Record key pattern'));
+        })() :
+            TypeGuard.TTuple(schema) ? (() => {
+                const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+                const literals = items.map((_, index) => exports.Type.Literal(index.toString()));
+                return this.Union(literals, options);
+            })() :
+                TypeGuard.TArray(schema) ? (() => {
+                    return this.Number(options);
+                })() : (() => {
+                    const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false });
+                    if (keys.length === 0)
+                        return this.Never(options);
+                    const literals = keys.map((key) => this.Literal(key));
+                    return this.Union(literals, options);
+                })());
+    }
+    /** `[Json]` Creates a Literal type */
     Literal(value, options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Literal', const: value, type: typeof value });
     }
-    /** `[Standard]` Intrinsic function to Lowercase LiteralString types */
+    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
     Lowercase(schema, options = {}) {
-        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Lowercase'), ...options };
+        return { ...Intrinsic.Map(TypeClone.Type(schema), 'Lowercase'), ...options };
     }
-    /** `[Standard]` Creates a Never type */
+    /** `[Json]` Creates a Never type */
     Never(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Never', not: {} });
     }
-    /** `[Standard]` Creates a Not type */
+    /** `[Json]` Creates a Not type */
     Not(schema, options) {
-        return this.Create({ ...options, [exports.Kind]: 'Not', not: TypeClone.Clone(schema) });
+        return this.Create({ ...options, [exports.Kind]: 'Not', not: TypeClone.Type(schema) });
     }
-    /** `[Standard]` Creates a Null type */
+    /** `[Json]` Creates a Null type */
     Null(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Null', type: 'null' });
     }
-    /** `[Standard]` Creates a Number type */
+    /** `[Json]` Creates a Number type */
     Number(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Number', type: 'number' });
     }
-    /** `[Standard]` Creates an Object type */
+    /** `[Json]` Creates an Object type */
     Object(properties, options = {}) {
         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]) }), {});
-        if (requiredKeys.length > 0) {
-            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys });
-        }
-        else {
-            return this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
-        }
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Type(options.additionalProperties) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }), {});
+        return requiredKeys.length > 0
+            ? this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys })
+            : this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: 'Object', type: 'object', properties: clonedProperties });
     }
-    /** `[Standard]` Constructs a type whose keys are omitted from the given type */
+    /** `[Json]` Constructs a type whose keys are omitted from the given type */
     Omit(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
             if (ValueGuard.IsArray(object.required)) {
                 object.required = object.required.filter((key) => !keys.includes(key));
                 if (object.required.length === 0)
@@ -2194,21 +2089,21 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create(object);
         }, options);
     }
-    /** `[Standard]` Constructs a type where all properties are optional */
+    /** `[Json]` Constructs a type where all properties are optional */
     Partial(schema, options = {}) {
         // prettier-ignore
-        return ObjectMap.Map(schema, (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (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);
     }
-    /** `[Standard]` Constructs a type whose keys are picked from the given type */
+    /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(TypeClone.Clone(schema), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
             if (ValueGuard.IsArray(object.required)) {
                 object.required = object.required.filter((key) => keys.includes(key));
                 if (object.required.length === 0)
@@ -2221,43 +2116,41 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create(object);
         }, options);
     }
-    /** `[Standard]` Creates a Record type */
+    /** `[Json]` Creates a Record type */
     Record(key, schema, options = {}) {
-        if (TypeGuard.TTemplateLiteral(key)) {
+        // prettier-ignore
+        return (TypeGuard.TTemplateLiteral(key) ? (() => {
             const expression = TemplateLiteralParser.ParseExact(key.pattern);
             // prettier-ignore
             return TemplateLiteralFinite.Check(expression)
-                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema) }), {}), options))
-                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema) } });
-        }
-        else if (TypeGuard.TUnion(key)) {
-            const union = UnionResolver.Resolve(key);
-            if (TypeGuard.TUnionLiteral(union)) {
-                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema) }), {});
-                return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
-            }
-            else
-                throw Error('StandardTypeBuilder: Record key of type union contains non-literal types');
-        }
-        else if (TypeGuard.TLiteral(key)) {
-            if (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const)) {
-                return this.Object({ [key.const]: TypeClone.Clone(schema) }, options);
-            }
-            else
-                throw Error('StandardTypeBuilder: Record key of type literal is not of type string or number');
-        }
-        else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
-            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Clone(schema) } });
-        }
-        else if (TypeGuard.TString(key)) {
-            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 {
-            throw Error(`StandardTypeBuilder: Record key is an invalid type`);
-        }
-    }
-    /** `[Standard]` Creates a Recursive type */
+                ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(schema) }), {}), options))
+                : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Type(schema) } });
+        })() :
+            TypeGuard.TUnion(key) ? (() => {
+                const union = UnionResolver.Resolve(key);
+                if (TypeGuard.TUnionLiteral(union)) {
+                    const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Type(schema) }), {});
+                    return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
+                }
+                else
+                    this.Throw('Record key of type union contains non-literal types');
+            })() :
+                TypeGuard.TLiteral(key) ? (() => {
+                    // prettier-ignore
+                    return (ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const))
+                        ? this.Object({ [key.const]: TypeClone.Type(schema) }, options)
+                        : this.Throw('Record key of type literal is not of type string or number');
+                })() :
+                    TypeGuard.TInteger(key) || TypeGuard.TNumber(key) ? (() => {
+                        return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [exports.PatternNumberExact]: TypeClone.Type(schema) } });
+                    })() :
+                        TypeGuard.TString(key) ? (() => {
+                            const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
+                            return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Type(schema) } });
+                        })() :
+                            this.Throw(`Record key is an invalid type`));
+    }
+    /** `[Json]` Creates a Recursive type */
     Recursive(callback, options = {}) {
         if (ValueGuard.IsUndefined(options.$id))
             options.$id = `T${TypeOrdinal++}`;
@@ -2265,151 +2158,145 @@ class StandardTypeBuilder extends TypeBuilder {
         thisType.$id = options.$id;
         return this.Create({ ...options, [exports.Hint]: 'Recursive', ...thisType });
     }
-    /** `[Standard]` Creates a Ref type. */
+    /** `[Json]` 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');
+            this.Throw('Reference target type must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: unresolved.$id });
     }
-    /** `[Standard]` Constructs a type where all properties are required */
+    /** `[Json]` Constructs a type where all properties are required */
     Required(schema, options = {}) {
         // prettier-ignore
-        return ObjectMap.Map(schema, (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (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]` Extracts the rest array from a Tuple */
+    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
     Rest(schema) {
-        if (TypeGuard.TTuple(schema)) {
-            if (ValueGuard.IsUndefined(schema.items))
-                return [];
-            return schema.items.map((schema) => TypeClone.Clone(schema));
-        }
-        else {
-            return [TypeClone.Clone(schema)];
-        }
+        return (TypeGuard.TTuple(schema) && !ValueGuard.IsUndefined(schema.items) ? TypeClone.Rest(schema.items) : TypeGuard.TIntersect(schema) ? TypeClone.Rest(schema.allOf) : TypeGuard.TUnion(schema) ? TypeClone.Rest(schema.anyOf) : []);
     }
-    /** `[Standard]` Creates a String type */
+    /** `[Json]` Creates a String type */
     String(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
     }
-    /** `[Standard]` Creates a TemplateLiteral type */
+    /** `[Json]` Creates a TemplateLiteral type */
     TemplateLiteral(unresolved, options = {}) {
         // prettier-ignore
-        const pattern = (ValueGuard.IsString(unresolved))
+        const pattern = ValueGuard.IsString(unresolved)
             ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved))
             : TemplateLiteralPattern.Create(unresolved);
         return this.Create({ ...options, [exports.Kind]: 'TemplateLiteral', type: 'string', pattern });
     }
-    /** `[Standard]` Creates a Tuple type */
+    /** `[Json]` Creates a Transform type */
+    Transform(schema) {
+        return new TransformDecodeBuilder(schema);
+    }
+    /** `[Json]` Creates a Tuple type */
     Tuple(items, options = {}) {
         const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-        const clonedItems = items.map((item) => TypeClone.Clone(item));
+        const clonedItems = TypeClone.Rest(items);
         // prettier-ignore
         const schema = (items.length > 0 ?
             { ...options, [exports.Kind]: 'Tuple', type: 'array', items: clonedItems, additionalItems, minItems, maxItems } :
             { ...options, [exports.Kind]: 'Tuple', type: 'array', minItems, maxItems });
         return this.Create(schema);
     }
-    /** `[Standard]` Intrinsic function to Uncapitalize LiteralString types */
+    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
     Uncapitalize(schema, options = {}) {
-        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uncapitalize'), ...options };
+        return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uncapitalize'), ...options };
     }
-    /** `[Standard]` Creates a Union type */
+    /** `[Json]` Creates a Union type */
     Union(union, options = {}) {
-        if (TypeGuard.TTemplateLiteral(union)) {
-            return TemplateLiteralResolver.Resolve(union);
-        }
-        else {
-            const anyOf = union;
-            if (anyOf.length === 0)
-                return this.Never(options);
-            if (anyOf.length === 1)
-                return this.Create(TypeClone.Clone(anyOf[0], options));
-            const clonedAnyOf = anyOf.map((schema) => TypeClone.Clone(schema));
-            return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
-        }
-    }
-    /** `[Standard]` Creates an Unknown type */
+        // prettier-ignore
+        return TypeGuard.TTemplateLiteral(union)
+            ? TemplateLiteralResolver.Resolve(union)
+            : (() => {
+                const anyOf = union;
+                if (anyOf.length === 0)
+                    return this.Never(options);
+                if (anyOf.length === 1)
+                    return this.Create(TypeClone.Type(anyOf[0], options));
+                const clonedAnyOf = TypeClone.Rest(anyOf);
+                return this.Create({ ...options, [exports.Kind]: 'Union', anyOf: clonedAnyOf });
+            })();
+    }
+    /** `[Json]` Creates an Unknown type */
     Unknown(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Unknown' });
     }
-    /** `[Standard]` Creates a Unsafe type that will infers as the generic argument T */
+    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
     Unsafe(options = {}) {
         return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || 'Unsafe' });
     }
-    /** `[Standard]` Intrinsic function to Uppercase LiteralString types */
+    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
     Uppercase(schema, options = {}) {
-        return { ...Intrinsic.Map(TypeClone.Clone(schema), 'Uppercase'), ...options };
+        return { ...Intrinsic.Map(TypeClone.Type(schema), 'Uppercase'), ...options };
     }
 }
-exports.StandardTypeBuilder = StandardTypeBuilder;
+exports.JsonTypeBuilder = JsonTypeBuilder;
 // --------------------------------------------------------------------------
-// ExtendedTypeBuilder
+// JavaScriptTypeBuilder
 // --------------------------------------------------------------------------
-class ExtendedTypeBuilder extends StandardTypeBuilder {
-    /** `[Extended]` Creates a AsyncIterator type */
+class JavaScriptTypeBuilder extends JsonTypeBuilder {
+    /** `[JavaScript]` Creates a AsyncIterator type */
     AsyncIterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Clone(items) });
+        return this.Create({ ...options, [exports.Kind]: 'AsyncIterator', type: 'AsyncIterator', items: TypeClone.Type(items) });
     }
-    /** `[Extended]` Constructs a type by recursively unwrapping Promise types */
+    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
     Awaited(schema, options = {}) {
-        const AwaitedRest = (rest) => {
-            if (rest.length === 0)
-                return rest;
+        // prettier-ignore
+        const Unwrap = (rest) => rest.length > 0 ? (() => {
             const [L, ...R] = rest;
-            return [this.Awaited(L), ...AwaitedRest(R)];
-        };
+            return [this.Awaited(L), ...Unwrap(R)];
+        })() : rest;
         // prettier-ignore
-        return (TypeGuard.TIntersect(schema) ? exports.Type.Intersect(AwaitedRest(schema.allOf)) :
-            TypeGuard.TUnion(schema) ? exports.Type.Union(AwaitedRest(schema.anyOf)) :
+        return (TypeGuard.TIntersect(schema) ? exports.Type.Intersect(Unwrap(schema.allOf)) :
+            TypeGuard.TUnion(schema) ? exports.Type.Union(Unwrap(schema.anyOf)) :
                 TypeGuard.TPromise(schema) ? this.Awaited(schema.item) :
-                    TypeClone.Clone(schema, options));
+                    TypeClone.Type(schema, options));
     }
-    /** `[Extended]` Creates a BigInt type */
+    /** `[JavaScript]` Creates a BigInt type */
     BigInt(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'BigInt', type: 'bigint' });
     }
-    /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
+    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters(schema, options = {}) {
         return this.Tuple([...schema.parameters], { ...options });
     }
-    /** `[Extended]` Creates a Constructor type */
+    /** `[JavaScript]` Creates a Constructor type */
     Constructor(parameters, returns, options) {
-        const clonedReturns = TypeClone.Clone(returns);
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
         return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'constructor', parameters: clonedParameters, returns: clonedReturns });
     }
-    /** `[Extended]` Creates a Date type */
+    /** `[JavaScript]` Creates a Date type */
     Date(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Date', type: 'Date' });
     }
-    /** `[Extended]` Creates a Function type */
+    /** `[JavaScript]` Creates a Function type */
     Function(parameters, returns, options) {
-        const clonedReturns = TypeClone.Clone(returns, {});
-        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter));
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
         return this.Create({ ...options, [exports.Kind]: 'Function', type: 'function', parameters: clonedParameters, returns: clonedReturns });
     }
-    /** `[Extended]` Extracts the InstanceType from the given Constructor type */
+    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
     InstanceType(schema, options = {}) {
-        return TypeClone.Clone(schema.returns, options);
+        return TypeClone.Type(schema.returns, options);
     }
-    /** `[Extended]` Creates an Iterator type */
+    /** `[JavaScript]` Creates an Iterator type */
     Iterator(items, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Clone(items) });
+        return this.Create({ ...options, [exports.Kind]: 'Iterator', type: 'Iterator', items: TypeClone.Type(items) });
     }
-    /** `[Extended]` Extracts the Parameters from the given Function type */
+    /** `[JavaScript]` Extracts the Parameters from the given Function type */
     Parameters(schema, options = {}) {
         return this.Tuple(schema.parameters, { ...options });
     }
-    /** `[Extended]` Creates a Promise type */
+    /** `[JavaScript]` Creates a Promise type */
     Promise(item, options = {}) {
-        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Clone(item) });
+        return this.Create({ ...options, [exports.Kind]: 'Promise', type: 'Promise', item: TypeClone.Type(item) });
     }
     /** `[Extended]` Creates a String type */
     RegExp(unresolved, options = {}) {
@@ -2422,29 +2309,29 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     RegEx(regex, options = {}) {
         return this.RegExp(regex, options);
     }
-    /** `[Extended]` Extracts the ReturnType from the given Function type */
+    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
     ReturnType(schema, options = {}) {
-        return TypeClone.Clone(schema.returns, options);
+        return TypeClone.Type(schema.returns, options);
     }
-    /** `[Extended]` Creates a Symbol type */
+    /** `[JavaScript]` Creates a Symbol type */
     Symbol(options) {
         return this.Create({ ...options, [exports.Kind]: 'Symbol', type: 'symbol' });
     }
-    /** `[Extended]` Creates a Undefined type */
+    /** `[JavaScript]` Creates a Undefined type */
     Undefined(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Undefined', type: 'undefined' });
     }
-    /** `[Extended]` Creates a Uint8Array type */
+    /** `[JavaScript]` Creates a Uint8Array type */
     Uint8Array(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Uint8Array', type: 'Uint8Array' });
     }
-    /** `[Extended]` Creates a Void type */
+    /** `[JavaScript]` Creates a Void type */
     Void(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Void', type: 'void' });
     }
 }
-exports.ExtendedTypeBuilder = ExtendedTypeBuilder;
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-exports.StandardType = new StandardTypeBuilder();
-/** JSON Schema Type Builder with Static Resolution for TypeScript */
-exports.Type = new ExtendedTypeBuilder();
+exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;
+/** Json Type Builder with Static Resolution for TypeScript */
+exports.JsonType = new JsonTypeBuilder();
+/** JavaScript Type Builder with Static Resolution for TypeScript */
+exports.Type = new JavaScriptTypeBuilder();