@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/require/type/extends/extends-check.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendsCheck = exports.ExtendsResult = exports.ExtendsResolverError = void 0;
 const index_1 = require("../any/index");
@@ -19,12 +20,24 @@ var ExtendsResult;
     ExtendsResult[ExtendsResult["True"] = 1] = "True";
     ExtendsResult[ExtendsResult["False"] = 2] = "False";
 })(ExtendsResult || (exports.ExtendsResult = ExtendsResult = {}));
+// ------------------------------------------------------------------
+// IntoBooleanResult
+// ------------------------------------------------------------------
+// prettier-ignore
 function IntoBooleanResult(result) {
     return result === ExtendsResult.False ? result : ExtendsResult.True;
 }
+// ------------------------------------------------------------------
+// Throw
+// ------------------------------------------------------------------
+// prettier-ignore
 function Throw(message) {
     throw new ExtendsResolverError(message);
 }
+// ------------------------------------------------------------------
+// StructuralRight
+// ------------------------------------------------------------------
+// prettier-ignore
 function IsStructuralRight(right) {
     return (index_9.TypeGuard.TNever(right) ||
         index_9.TypeGuard.TIntersect(right) ||
@@ -32,6 +45,7 @@ function IsStructuralRight(right) {
         index_9.TypeGuard.TUnknown(right) ||
         index_9.TypeGuard.TAny(right));
 }
+// prettier-ignore
 function StructuralRight(left, right) {
     return (index_9.TypeGuard.TNever(right) ? TNeverRight(left, right) :
         index_9.TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
@@ -40,9 +54,14 @@ function StructuralRight(left, right) {
                     index_9.TypeGuard.TAny(right) ? TAnyRight(left, right) :
                         Throw('StructuralRight'));
 }
+// ------------------------------------------------------------------
+// Any
+// ------------------------------------------------------------------
+// prettier-ignore
 function TAnyRight(left, right) {
     return ExtendsResult.True;
 }
+// prettier-ignore
 function TAny(left, right) {
     return (index_9.TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
         (index_9.TypeGuard.TUnion(right) && right.anyOf.some((schema) => index_9.TypeGuard.TAny(schema) || index_9.TypeGuard.TUnknown(schema))) ? ExtendsResult.True :
@@ -51,23 +70,36 @@ function TAny(left, right) {
                     index_9.TypeGuard.TAny(right) ? ExtendsResult.True :
                         ExtendsResult.Union);
 }
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
 function TArrayRight(left, right) {
     return (index_9.TypeGuard.TUnknown(left) ? ExtendsResult.False :
         index_9.TypeGuard.TAny(left) ? ExtendsResult.Union :
             index_9.TypeGuard.TNever(left) ? ExtendsResult.True :
                 ExtendsResult.False);
 }
+// prettier-ignore
 function TArray(left, right) {
     return (index_9.TypeGuard.TObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
             !index_9.TypeGuard.TArray(right) ? ExtendsResult.False :
                 IntoBooleanResult(Visit(left.items, right.items)));
 }
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
 function TAsyncIterator(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         !index_9.TypeGuard.TAsyncIterator(right) ? ExtendsResult.False :
             IntoBooleanResult(Visit(left.items, right.items)));
 }
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+// prettier-ignore
 function TBigInt(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -75,11 +107,16 @@ function TBigInt(left, right) {
                 index_9.TypeGuard.TBigInt(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// prettier-ignore
 function TBooleanRight(left, right) {
     return (index_9.TypeGuard.TLiteralBoolean(left) ? ExtendsResult.True :
         index_9.TypeGuard.TBoolean(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
+// prettier-ignore
 function TBoolean(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -87,6 +124,10 @@ function TBoolean(left, right) {
                 index_9.TypeGuard.TBoolean(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
 function TConstructor(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -95,6 +136,10 @@ function TConstructor(left, right) {
                     (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
                         IntoBooleanResult(Visit(left.returns, right.returns)));
 }
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+// prettier-ignore
 function TDate(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -102,6 +147,10 @@ function TDate(left, right) {
                 index_9.TypeGuard.TDate(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
 function TFunction(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -110,11 +159,16 @@ function TFunction(left, right) {
                     (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
                         IntoBooleanResult(Visit(left.returns, right.returns)));
 }
+// ------------------------------------------------------------------
+// Integer
+// ------------------------------------------------------------------
+// prettier-ignore
 function TIntegerRight(left, right) {
     return (index_9.TypeGuard.TLiteral(left) && index_9.ValueGuard.IsNumber(left.const) ? ExtendsResult.True :
         index_9.TypeGuard.TNumber(left) || index_9.TypeGuard.TInteger(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
+// prettier-ignore
 function TInteger(left, right) {
     return (index_9.TypeGuard.TInteger(right) || index_9.TypeGuard.TNumber(right) ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
@@ -122,21 +176,34 @@ function TInteger(left, right) {
                 index_9.TypeGuard.TRecord(right) ? TRecordRight(left, right) :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Intersect
+// ------------------------------------------------------------------
+// prettier-ignore
 function TIntersectRight(left, right) {
     return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
+// prettier-ignore
 function TIntersect(left, right) {
     return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
+// ------------------------------------------------------------------
+// Iterator
+// ------------------------------------------------------------------
+// prettier-ignore
 function TIterator(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         !index_9.TypeGuard.TIterator(right) ? ExtendsResult.False :
             IntoBooleanResult(Visit(left.items, right.items)));
 }
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
 function TLiteral(left, right) {
     return (index_9.TypeGuard.TLiteral(right) && right.const === left.const ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
@@ -148,12 +215,21 @@ function TLiteral(left, right) {
                                 index_9.TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
                                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Never
+// ------------------------------------------------------------------
+// prettier-ignore
 function TNeverRight(left, right) {
     return ExtendsResult.False;
 }
+// prettier-ignore
 function TNever(left, right) {
     return ExtendsResult.True;
 }
+// ------------------------------------------------------------------
+// Not
+// ------------------------------------------------------------------
+// prettier-ignore
 function UnwrapTNot(schema) {
     let [current, depth] = [schema, 0];
     while (true) {
@@ -164,11 +240,20 @@ function UnwrapTNot(schema) {
     }
     return depth % 2 === 0 ? current : (0, index_5.Unknown)();
 }
+// prettier-ignore
 function TNot(left, right) {
+    // TypeScript has no concept of negated types, and attempts to correctly check the negated
+    // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+    // the type. Instead we unwrap to either unknown or T and continue evaluating.
+    // prettier-ignore
     return (index_9.TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) :
         index_9.TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) :
             Throw('Invalid fallthrough for Not'));
 }
+// ------------------------------------------------------------------
+// Null
+// ------------------------------------------------------------------
+// prettier-ignore
 function TNull(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -176,11 +261,16 @@ function TNull(left, right) {
                 index_9.TypeGuard.TNull(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
 function TNumberRight(left, right) {
     return (index_9.TypeGuard.TLiteralNumber(left) ? ExtendsResult.True :
         index_9.TypeGuard.TNumber(left) || index_9.TypeGuard.TInteger(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
+// prettier-ignore
 function TNumber(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -188,52 +278,72 @@ function TNumber(left, right) {
                 index_9.TypeGuard.TInteger(right) || index_9.TypeGuard.TNumber(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+// prettier-ignore
 function IsObjectPropertyCount(schema, count) {
     return Object.getOwnPropertyNames(schema.properties).length === count;
 }
+// prettier-ignore
 function IsObjectStringLike(schema) {
     return IsObjectArrayLike(schema);
 }
+// prettier-ignore
 function IsObjectSymbolLike(schema) {
     return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'description' in schema.properties && index_9.TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((index_9.TypeGuard.TString(schema.properties.description.anyOf[0]) &&
         index_9.TypeGuard.TUndefined(schema.properties.description.anyOf[1])) || (index_9.TypeGuard.TString(schema.properties.description.anyOf[1]) &&
         index_9.TypeGuard.TUndefined(schema.properties.description.anyOf[0]))));
 }
+// prettier-ignore
 function IsObjectNumberLike(schema) {
     return IsObjectPropertyCount(schema, 0);
 }
+// prettier-ignore
 function IsObjectBooleanLike(schema) {
     return IsObjectPropertyCount(schema, 0);
 }
+// prettier-ignore
 function IsObjectBigIntLike(schema) {
     return IsObjectPropertyCount(schema, 0);
 }
+// prettier-ignore
 function IsObjectDateLike(schema) {
     return IsObjectPropertyCount(schema, 0);
 }
+// prettier-ignore
 function IsObjectUint8ArrayLike(schema) {
     return IsObjectArrayLike(schema);
 }
+// prettier-ignore
 function IsObjectFunctionLike(schema) {
     const length = (0, index_3.Number)();
     return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
 }
+// prettier-ignore
 function IsObjectConstructorLike(schema) {
     return IsObjectPropertyCount(schema, 0);
 }
+// prettier-ignore
 function IsObjectArrayLike(schema) {
     const length = (0, index_3.Number)();
     return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'length' in schema.properties && IntoBooleanResult(Visit(schema.properties['length'], length)) === ExtendsResult.True);
 }
+// prettier-ignore
 function IsObjectPromiseLike(schema) {
     const then = (0, index_2.Function)([(0, index_1.Any)()], (0, index_1.Any)());
     return IsObjectPropertyCount(schema, 0) || (IsObjectPropertyCount(schema, 1) && 'then' in schema.properties && IntoBooleanResult(Visit(schema.properties['then'], then)) === ExtendsResult.True);
 }
+// ------------------------------------------------------------------
+// Property
+// ------------------------------------------------------------------
+// prettier-ignore
 function Property(left, right) {
     return (Visit(left, right) === ExtendsResult.False ? ExtendsResult.False :
         index_9.TypeGuard.TOptional(left) && !index_9.TypeGuard.TOptional(right) ? ExtendsResult.False :
             ExtendsResult.True);
 }
+// prettier-ignore
 function TObjectRight(left, right) {
     return (index_9.TypeGuard.TUnknown(left) ? ExtendsResult.False :
         index_9.TypeGuard.TAny(left) ? ExtendsResult.Union : (index_9.TypeGuard.TNever(left) ||
@@ -252,6 +362,8 @@ function TObjectRight(left, right) {
             (index_9.TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) ||
             (index_9.TypeGuard.TFunction(left) && IsObjectFunctionLike(right))) ? ExtendsResult.True :
             (index_9.TypeGuard.TRecord(left) && index_9.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[index_8.Hint] === 'Record' ? ExtendsResult.True : ExtendsResult.False;
             })() :
                 (index_9.TypeGuard.TRecord(left) && index_9.TypeGuard.TNumber(RecordKey(left))) ? (() => {
@@ -259,6 +371,7 @@ function TObjectRight(left, right) {
                 })() :
                     ExtendsResult.False);
 }
+// prettier-ignore
 function TObject(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TRecord(right) ? TRecordRight(left, right) :
@@ -278,22 +391,32 @@ function TObject(left, right) {
                     return ExtendsResult.True;
                 })());
 }
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
 function TPromise(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
             !index_9.TypeGuard.TPromise(right) ? ExtendsResult.False :
                 IntoBooleanResult(Visit(left.item, right.item)));
 }
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
 function RecordKey(schema) {
     return (index_7.PatternNumberExact in schema.patternProperties ? (0, index_3.Number)() :
         index_7.PatternStringExact in schema.patternProperties ? (0, index_4.String)() :
             Throw('Unknown record key pattern'));
 }
+// prettier-ignore
 function RecordValue(schema) {
     return (index_7.PatternNumberExact in schema.patternProperties ? schema.patternProperties[index_7.PatternNumberExact] :
         index_7.PatternStringExact in schema.patternProperties ? schema.patternProperties[index_7.PatternStringExact] :
             Throw('Unable to get record value schema'));
 }
+// prettier-ignore
 function TRecordRight(left, right) {
     const [Key, Value] = [RecordKey(right), RecordValue(right)];
     return ((index_9.TypeGuard.TLiteralString(left) && index_9.TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
@@ -310,17 +433,23 @@ function TRecordRight(left, right) {
                     })() :
                         ExtendsResult.False);
 }
+// prettier-ignore
 function TRecord(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
             !index_9.TypeGuard.TRecord(right) ? ExtendsResult.False :
                 Visit(RecordValue(left), RecordValue(right)));
 }
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
 function TStringRight(left, right) {
     return (index_9.TypeGuard.TLiteral(left) && index_9.ValueGuard.IsString(left.const) ? ExtendsResult.True :
         index_9.TypeGuard.TString(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
+// prettier-ignore
 function TString(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -328,6 +457,10 @@ function TString(left, right) {
                 index_9.TypeGuard.TString(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+// prettier-ignore
 function TSymbol(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -335,22 +468,35 @@ function TSymbol(left, right) {
                 index_9.TypeGuard.TSymbol(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// TemplateLiteral
+// ------------------------------------------------------------------
+// prettier-ignore
 function TTemplateLiteral(left, right) {
+    // TemplateLiteral types are resolved to either unions for finite expressions or string
+    // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+    // either type and continue evaluating.
     return (index_9.TypeGuard.TTemplateLiteral(left) ? Visit((0, index_6.TemplateLiteralToUnion)(left), right) :
         index_9.TypeGuard.TTemplateLiteral(right) ? Visit(left, (0, index_6.TemplateLiteralToUnion)(right)) :
             Throw('Invalid fallthrough for TemplateLiteral'));
 }
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
 function IsArrayOfTuple(left, right) {
     return (index_9.TypeGuard.TArray(right) &&
         left.items !== undefined &&
         left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True));
 }
+// prettier-ignore
 function TTupleRight(left, right) {
     return (index_9.TypeGuard.TNever(left) ? ExtendsResult.True :
         index_9.TypeGuard.TUnknown(left) ? ExtendsResult.False :
             index_9.TypeGuard.TAny(left) ? ExtendsResult.Union :
                 ExtendsResult.False);
 }
+// prettier-ignore
 function TTuple(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
@@ -361,6 +507,10 @@ function TTuple(left, right) {
                             left.items.every((schema, index) => Visit(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True :
                                 ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Uint8Array
+// ------------------------------------------------------------------
+// prettier-ignore
 function TUint8Array(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -368,6 +518,10 @@ function TUint8Array(left, right) {
                 index_9.TypeGuard.TUint8Array(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// prettier-ignore
 function TUndefined(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         index_9.TypeGuard.TObject(right) ? TObjectRight(left, right) :
@@ -376,19 +530,29 @@ function TUndefined(left, right) {
                     index_9.TypeGuard.TUndefined(right) ? ExtendsResult.True :
                         ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Union
+// ------------------------------------------------------------------
+// prettier-ignore
 function TUnionRight(left, right) {
     return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
+// prettier-ignore
 function TUnion(left, right) {
     return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
+// ------------------------------------------------------------------
+// Unknown
+// ------------------------------------------------------------------
+// prettier-ignore
 function TUnknownRight(left, right) {
     return ExtendsResult.True;
 }
+// prettier-ignore
 function TUnknown(left, right) {
     return (index_9.TypeGuard.TNever(right) ? TNeverRight(left, right) :
         index_9.TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
@@ -404,11 +568,16 @@ function TUnknown(left, right) {
                                                 index_9.TypeGuard.TUnknown(right) ? ExtendsResult.True :
                                                     ExtendsResult.False);
 }
+// ------------------------------------------------------------------
+// Void
+// ------------------------------------------------------------------
+// prettier-ignore
 function VoidRight(left, right) {
     return (index_9.TypeGuard.TUndefined(left) ? ExtendsResult.True :
         index_9.TypeGuard.TUndefined(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
+// prettier-ignore
 function TVoid(left, right) {
     return (index_9.TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
         index_9.TypeGuard.TUnion(right) ? TUnionRight(left, right) :
@@ -418,9 +587,13 @@ function TVoid(left, right) {
                         index_9.TypeGuard.TVoid(right) ? ExtendsResult.True :
                             ExtendsResult.False);
 }
+// prettier-ignore
 function Visit(left, right) {
-    return ((index_9.TypeGuard.TTemplateLiteral(left) || index_9.TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
+    return (
+    // resolvable
+    (index_9.TypeGuard.TTemplateLiteral(left) || index_9.TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
         (index_9.TypeGuard.TNot(left) || index_9.TypeGuard.TNot(right)) ? TNot(left, right) :
+            // standard
             index_9.TypeGuard.TAny(left) ? TAny(left, right) :
                 index_9.TypeGuard.TArray(left) ? TArray(left, right) :
                     index_9.TypeGuard.TBigInt(left) ? TBigInt(left, right) :

package/build/require/type/extends/extends-from-mapped-key.js

@@ -1,23 +1,28 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendsFromMappedKey = void 0;
 const index_1 = require("../mapped/index");
 const index_2 = require("../literal/index");
 const extends_1 = require("./extends");
+// prettier-ignore
 function FromPropertyKey(K, U, L, R, options) {
     return {
         [K]: (0, extends_1.Extends)((0, index_2.Literal)(K), U, L, R, options)
     };
 }
+// prettier-ignore
 function FromPropertyKeys(K, U, L, R, options) {
     const [LK, ...RK] = K;
     return (K.length > 0
         ? { ...FromPropertyKey(LK, U, L, R, options), ...FromPropertyKeys(RK, U, L, R, options) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(K, U, L, R, options) {
     return FromPropertyKeys(K.keys, U, L, R, options);
 }
+// prettier-ignore
 function ExtendsFromMappedKey(T, U, L, R, options) {
     const P = FromMappedKey(T, U, L, R, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/extends/extends-from-mapped-result.js

@@ -1,16 +1,20 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendsFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const extends_1 = require("./extends");
+// prettier-ignore
 function FromProperties(K, U, L, R, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: (0, extends_1.Extends)(K[K2], U, L, R, options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, U, L, R, options) {
     return FromProperties(K.properties, U, L, R, options);
 }
+// prettier-ignore
 function ExtendsFromMappedResult(T, U, L, R, options) {
     const P = FromMappedResult(T, U, L, R, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/extends/extends-undefined.d.ts

@@ -1,2 +1,3 @@
 import type { TSchema } from '../schema/index';
+/** Fast undefined check used for properties of type undefined */
 export declare function ExtendsUndefinedCheck(schema: TSchema): boolean;

package/build/require/type/extends/extends-undefined.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtendsUndefinedCheck = void 0;
 const index_1 = require("../symbols/index");
+/** Fast undefined check used for properties of type undefined */
 function Intersect(schema) {
     return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema));
 }
@@ -11,6 +13,8 @@ function Union(schema) {
 function Not(schema) {
     return !ExtendsUndefinedCheck(schema.not);
 }
+/** Fast undefined check used for properties of type undefined */
+// prettier-ignore
 function ExtendsUndefinedCheck(schema) {
     return (schema[index_1.Kind] === 'Intersect' ? Intersect(schema) :
         schema[index_1.Kind] === 'Union' ? Union(schema) :

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

@@ -8,7 +8,10 @@ import { type TExtendsFromMappedResult } from './extends-from-mapped-result';
 type ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = ((Static<L> extends Static<R> ? T : U) extends infer O extends TSchema ? UnionToTuple<O> extends [infer X extends TSchema, infer Y extends TSchema] ? TUnion<[X, Y]> : O : never);
 declare function ExtendsResolve<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U): ExtendsResolve<L, R, T, U>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema> = ExtendsResolve<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedResult, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedResult<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TMappedKey, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtendsFromMappedKey<L, R, T, F>;
+/** `[Json]` Creates a Conditional type */
 export declare function Extends<L extends TSchema, R extends TSchema, T extends TSchema, F extends TSchema>(L: L, R: R, T: T, F: F, options?: SchemaOptions): TExtends<L, R, T, F>;
 export {};

package/build/require/type/extends/extends.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extends = void 0;
 const index_1 = require("../union/index");
@@ -6,14 +7,21 @@ const extends_check_1 = require("./extends-check");
 const type_1 = require("../clone/type");
 const extends_from_mapped_key_1 = require("./extends-from-mapped-key");
 const extends_from_mapped_result_1 = require("./extends-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {
     const R = (0, extends_check_1.ExtendsCheck)(left, right);
     return (R === extends_check_1.ExtendsResult.Union ? (0, index_1.Union)([trueType, falseType]) :
         R === extends_check_1.ExtendsResult.True ? trueType :
             falseType);
 }
+/** `[Json]` Creates a Conditional type */
 function Extends(L, R, T, F, options = {}) {
+    // prettier-ignore
     return ((0, type_2.TMappedResult)(L) ? (0, extends_from_mapped_result_1.ExtendsFromMappedResult)(L, R, T, F, options) :
         (0, type_2.TMappedKey)(L) ? (0, type_1.CloneType)((0, extends_from_mapped_key_1.ExtendsFromMappedKey)(L, R, T, F, options)) :
             (0, type_1.CloneType)(ExtendsResolve(L, R, T, F), options));

package/build/require/type/extends/index.js

@@ -1,4 +1,5 @@
 "use strict";
+
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/build/require/type/extract/extract-from-mapped-result.js

@@ -1,16 +1,20 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExtractFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const extract_1 = require("./extract");
+// prettier-ignore
 function FromProperties(K, U, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: (0, extract_1.Extract)(K[K2], U, options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, U, options) {
     return FromProperties(K.properties, U, options);
 }
+// prettier-ignore
 function ExtractFromMappedResult(T, U, options) {
     const P = FromMappedResult(T, U, options);
     return (0, index_1.MappedResult)(P);