@sinclair/typebox 0.32.0-dev-26 → 0.32.0-dev-28

package/build/import/type/extends/extends-check.mjs

@@ -43,23 +43,23 @@ function IsStructuralRight(right) {
 }
 // prettier-ignore
 function StructuralRight(left, right) {
-    return (TypeGuard.IsNever(right) ? TNeverRight(left, right) :
-        TypeGuard.IsIntersect(right) ? TIntersectRight(left, right) :
-            TypeGuard.IsUnion(right) ? TUnionRight(left, right) :
-                TypeGuard.IsUnknown(right) ? TUnknownRight(left, right) :
-                    TypeGuard.IsAny(right) ? TAnyRight(left, right) :
+    return (TypeGuard.IsNever(right) ? FromNeverRight(left, right) :
+        TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+            TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+                TypeGuard.IsUnknown(right) ? FromUnknownRight(left, right) :
+                    TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
                         Throw('StructuralRight'));
 }
 // ------------------------------------------------------------------
 // Any
 // ------------------------------------------------------------------
 // prettier-ignore
-function TAnyRight(left, right) {
+function FromAnyRight(left, right) {
     return ExtendsResult.True;
 }
 // prettier-ignore
-function TAny(left, right) {
-    return (TypeGuard.IsIntersect(right) ? TIntersectRight(left, right) :
+function FromAny(left, right) {
+    return (TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
         (TypeGuard.IsUnion(right) && right.anyOf.some((schema) => TypeGuard.IsAny(schema) || TypeGuard.IsUnknown(schema))) ? ExtendsResult.True :
             TypeGuard.IsUnion(right) ? ExtendsResult.Union :
                 TypeGuard.IsUnknown(right) ? ExtendsResult.True :
@@ -70,14 +70,14 @@ function TAny(left, right) {
 // Array
 // ------------------------------------------------------------------
 // prettier-ignore
-function TArrayRight(left, right) {
+function FromArrayRight(left, right) {
     return (TypeGuard.IsUnknown(left) ? ExtendsResult.False :
         TypeGuard.IsAny(left) ? ExtendsResult.Union :
             TypeGuard.IsNever(left) ? ExtendsResult.True :
                 ExtendsResult.False);
 }
 // prettier-ignore
-function TArray(left, right) {
+function FromArray(left, right) {
     return (TypeGuard.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
             !TypeGuard.IsArray(right) ? ExtendsResult.False :
@@ -87,7 +87,7 @@ function TArray(left, right) {
 // AsyncIterator
 // ------------------------------------------------------------------
 // prettier-ignore
-function TAsyncIterator(left, right) {
+function FromAsyncIterator(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         !TypeGuard.IsAsyncIterator(right) ? ExtendsResult.False :
             IntoBooleanResult(Visit(left.items, right.items)));
@@ -96,10 +96,10 @@ function TAsyncIterator(left, right) {
 // BigInt
 // ------------------------------------------------------------------
 // prettier-ignore
-function TBigInt(left, right) {
+function FromBigInt(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsBigInt(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -107,16 +107,16 @@ function TBigInt(left, right) {
 // Boolean
 // ------------------------------------------------------------------
 // prettier-ignore
-function TBooleanRight(left, right) {
+function FromBooleanRight(left, right) {
     return (TypeGuard.IsLiteralBoolean(left) ? ExtendsResult.True :
         TypeGuard.IsBoolean(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
 // prettier-ignore
-function TBoolean(left, right) {
+function FromBoolean(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsBoolean(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -124,9 +124,9 @@ function TBoolean(left, right) {
 // Constructor
 // ------------------------------------------------------------------
 // prettier-ignore
-function TConstructor(left, right) {
+function FromConstructor(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
             !TypeGuard.IsConstructor(right) ? ExtendsResult.False :
                 left.parameters.length > right.parameters.length ? ExtendsResult.False :
                     (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
@@ -136,10 +136,10 @@ function TConstructor(left, right) {
 // Date
 // ------------------------------------------------------------------
 // prettier-ignore
-function TDate(left, right) {
+function FromDate(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsDate(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -147,9 +147,9 @@ function TDate(left, right) {
 // Function
 // ------------------------------------------------------------------
 // prettier-ignore
-function TFunction(left, right) {
+function FromFunction(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
             !TypeGuard.IsFunction(right) ? ExtendsResult.False :
                 left.parameters.length > right.parameters.length ? ExtendsResult.False :
                     (!left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === ExtendsResult.True)) ? ExtendsResult.False :
@@ -159,30 +159,30 @@ function TFunction(left, right) {
 // Integer
 // ------------------------------------------------------------------
 // prettier-ignore
-function TIntegerRight(left, right) {
+function FromIntegerRight(left, right) {
     return (TypeGuard.IsLiteral(left) && ValueGuard.IsNumber(left.const) ? ExtendsResult.True :
         TypeGuard.IsNumber(left) || TypeGuard.IsInteger(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
 // prettier-ignore
-function TInteger(left, right) {
+function FromInteger(left, right) {
     return (TypeGuard.IsInteger(right) || TypeGuard.IsNumber(right) ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
-            TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-                TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+            TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+                TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                     ExtendsResult.False);
 }
 // ------------------------------------------------------------------
 // Intersect
 // ------------------------------------------------------------------
 // prettier-ignore
-function TIntersectRight(left, right) {
+function FromIntersectRight(left, right) {
     return right.allOf.every((schema) => Visit(left, schema) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
 // prettier-ignore
-function TIntersect(left, right) {
+function FromIntersect(left, right) {
     return left.allOf.some((schema) => Visit(schema, right) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
@@ -191,7 +191,7 @@ function TIntersect(left, right) {
 // Iterator
 // ------------------------------------------------------------------
 // prettier-ignore
-function TIterator(left, right) {
+function FromIterator(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         !TypeGuard.IsIterator(right) ? ExtendsResult.False :
             IntoBooleanResult(Visit(left.items, right.items)));
@@ -200,26 +200,26 @@ function TIterator(left, right) {
 // Literal
 // ------------------------------------------------------------------
 // prettier-ignore
-function TLiteral(left, right) {
+function FromLiteral(left, right) {
     return (TypeGuard.IsLiteral(right) && right.const === left.const ? ExtendsResult.True :
         IsStructuralRight(right) ? StructuralRight(left, right) :
-            TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-                TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
-                    TypeGuard.IsString(right) ? TStringRight(left, right) :
-                        TypeGuard.IsNumber(right) ? TNumberRight(left, right) :
-                            TypeGuard.IsInteger(right) ? TIntegerRight(left, right) :
-                                TypeGuard.IsBoolean(right) ? TBooleanRight(left, right) :
+            TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+                TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+                    TypeGuard.IsString(right) ? FromStringRight(left, right) :
+                        TypeGuard.IsNumber(right) ? FromNumberRight(left, right) :
+                            TypeGuard.IsInteger(right) ? FromIntegerRight(left, right) :
+                                TypeGuard.IsBoolean(right) ? FromBooleanRight(left, right) :
                                     ExtendsResult.False);
 }
 // ------------------------------------------------------------------
 // Never
 // ------------------------------------------------------------------
 // prettier-ignore
-function TNeverRight(left, right) {
+function FromNeverRight(left, right) {
     return ExtendsResult.False;
 }
 // prettier-ignore
-function TNever(left, right) {
+function FromNever(left, right) {
     return ExtendsResult.True;
 }
 // ------------------------------------------------------------------
@@ -237,7 +237,7 @@ function UnwrapTNot(schema) {
     return depth % 2 === 0 ? current : Unknown();
 }
 // prettier-ignore
-function TNot(left, right) {
+function FromNot(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.
@@ -250,10 +250,10 @@ function TNot(left, right) {
 // Null
 // ------------------------------------------------------------------
 // prettier-ignore
-function TNull(left, right) {
+function FromNull(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsNull(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -261,16 +261,16 @@ function TNull(left, right) {
 // Number
 // ------------------------------------------------------------------
 // prettier-ignore
-function TNumberRight(left, right) {
+function FromNumberRight(left, right) {
     return (TypeGuard.IsLiteralNumber(left) ? ExtendsResult.True :
         TypeGuard.IsNumber(left) || TypeGuard.IsInteger(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
 // prettier-ignore
-function TNumber(left, right) {
+function FromNumber(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsInteger(right) || TypeGuard.IsNumber(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -340,7 +340,7 @@ function Property(left, right) {
             ExtendsResult.True);
 }
 // prettier-ignore
-function TObjectRight(left, right) {
+function FromObjectRight(left, right) {
     return (TypeGuard.IsUnknown(left) ? ExtendsResult.False :
         TypeGuard.IsAny(left) ? ExtendsResult.Union : (TypeGuard.IsNever(left) ||
             (TypeGuard.IsLiteralString(left) && IsObjectStringLike(right)) ||
@@ -368,9 +368,9 @@ function TObjectRight(left, right) {
                     ExtendsResult.False);
 }
 // prettier-ignore
-function TObject(left, right) {
+function FromObject(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
             !TypeGuard.IsObject(right) ? ExtendsResult.False :
                 (() => {
                     for (const key of Object.getOwnPropertyNames(right.properties)) {
@@ -391,7 +391,7 @@ function TObject(left, right) {
 // Promise
 // ------------------------------------------------------------------
 // prettier-ignore
-function TPromise(left, right) {
+function FromPromise(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         TypeGuard.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
             !TypeGuard.IsPromise(right) ? ExtendsResult.False :
@@ -413,7 +413,7 @@ function RecordValue(schema) {
             Throw('Unable to get record value schema'));
 }
 // prettier-ignore
-function TRecordRight(left, right) {
+function FromRecordRight(left, right) {
     const [Key, Value] = [RecordKey(right), RecordValue(right)];
     return ((TypeGuard.IsLiteralString(left) && TypeGuard.IsNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
         TypeGuard.IsUint8Array(left) && TypeGuard.IsNumber(Key) ? Visit(left, Value) :
@@ -430,26 +430,37 @@ function TRecordRight(left, right) {
                         ExtendsResult.False);
 }
 // prettier-ignore
-function TRecord(left, right) {
+function FromRecord(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
             !TypeGuard.IsRecord(right) ? ExtendsResult.False :
                 Visit(RecordValue(left), RecordValue(right)));
 }
 // ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromRegExp(left, right) {
+    // Note: RegExp types evaluate as strings, not RegExp objects.
+    // Here we remap either into string and continue evaluating.
+    const L = TypeGuard.IsRegExp(left) ? String() : left;
+    const R = TypeGuard.IsRegExp(right) ? String() : right;
+    return Visit(L, R);
+}
+// ------------------------------------------------------------------
 // String
 // ------------------------------------------------------------------
 // prettier-ignore
-function TStringRight(left, right) {
+function FromStringRight(left, right) {
     return (TypeGuard.IsLiteral(left) && ValueGuard.IsString(left.const) ? ExtendsResult.True :
         TypeGuard.IsString(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
 // prettier-ignore
-function TString(left, right) {
+function FromString(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsString(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -457,10 +468,10 @@ function TString(left, right) {
 // Symbol
 // ------------------------------------------------------------------
 // prettier-ignore
-function TSymbol(left, right) {
+function FromSymbol(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsSymbol(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -468,7 +479,7 @@ function TSymbol(left, right) {
 // TemplateLiteral
 // ------------------------------------------------------------------
 // prettier-ignore
-function TTemplateLiteral(left, right) {
+function FromTemplateLiteral(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.
@@ -486,14 +497,14 @@ function IsArrayOfTuple(left, right) {
         left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True));
 }
 // prettier-ignore
-function TTupleRight(left, right) {
+function FromTupleRight(left, right) {
     return (TypeGuard.IsNever(left) ? ExtendsResult.True :
         TypeGuard.IsUnknown(left) ? ExtendsResult.False :
             TypeGuard.IsAny(left) ? ExtendsResult.Union :
                 ExtendsResult.False);
 }
 // prettier-ignore
-function TTuple(left, right) {
+function FromTuple(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
         TypeGuard.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
             TypeGuard.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True :
@@ -507,10 +518,10 @@ function TTuple(left, right) {
 // Uint8Array
 // ------------------------------------------------------------------
 // prettier-ignore
-function TUint8Array(left, right) {
+function FromUint8Array(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
                 TypeGuard.IsUint8Array(right) ? ExtendsResult.True :
                     ExtendsResult.False);
 }
@@ -518,11 +529,11 @@ function TUint8Array(left, right) {
 // Undefined
 // ------------------------------------------------------------------
 // prettier-ignore
-function TUndefined(left, right) {
+function FromUndefined(left, right) {
     return (IsStructuralRight(right) ? StructuralRight(left, right) :
-        TypeGuard.IsObject(right) ? TObjectRight(left, right) :
-            TypeGuard.IsRecord(right) ? TRecordRight(left, right) :
-                TypeGuard.IsVoid(right) ? VoidRight(left, right) :
+        TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
+            TypeGuard.IsRecord(right) ? FromRecordRight(left, right) :
+                TypeGuard.IsVoid(right) ? FromVoidRight(left, right) :
                     TypeGuard.IsUndefined(right) ? ExtendsResult.True :
                         ExtendsResult.False);
 }
@@ -530,13 +541,13 @@ function TUndefined(left, right) {
 // Union
 // ------------------------------------------------------------------
 // prettier-ignore
-function TUnionRight(left, right) {
+function FromUnionRight(left, right) {
     return right.anyOf.some((schema) => Visit(left, schema) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
 }
 // prettier-ignore
-function TUnion(left, right) {
+function FromUnion(left, right) {
     return left.anyOf.every((schema) => Visit(schema, right) === ExtendsResult.True)
         ? ExtendsResult.True
         : ExtendsResult.False;
@@ -545,22 +556,22 @@ function TUnion(left, right) {
 // Unknown
 // ------------------------------------------------------------------
 // prettier-ignore
-function TUnknownRight(left, right) {
+function FromUnknownRight(left, right) {
     return ExtendsResult.True;
 }
 // prettier-ignore
-function TUnknown(left, right) {
-    return (TypeGuard.IsNever(right) ? TNeverRight(left, right) :
-        TypeGuard.IsIntersect(right) ? TIntersectRight(left, right) :
-            TypeGuard.IsUnion(right) ? TUnionRight(left, right) :
-                TypeGuard.IsAny(right) ? TAnyRight(left, right) :
-                    TypeGuard.IsString(right) ? TStringRight(left, right) :
-                        TypeGuard.IsNumber(right) ? TNumberRight(left, right) :
-                            TypeGuard.IsInteger(right) ? TIntegerRight(left, right) :
-                                TypeGuard.IsBoolean(right) ? TBooleanRight(left, right) :
-                                    TypeGuard.IsArray(right) ? TArrayRight(left, right) :
-                                        TypeGuard.IsTuple(right) ? TTupleRight(left, right) :
-                                            TypeGuard.IsObject(right) ? TObjectRight(left, right) :
+function FromUnknown(left, right) {
+    return (TypeGuard.IsNever(right) ? FromNeverRight(left, right) :
+        TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+            TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+                TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
+                    TypeGuard.IsString(right) ? FromStringRight(left, right) :
+                        TypeGuard.IsNumber(right) ? FromNumberRight(left, right) :
+                            TypeGuard.IsInteger(right) ? FromIntegerRight(left, right) :
+                                TypeGuard.IsBoolean(right) ? FromBooleanRight(left, right) :
+                                    TypeGuard.IsArray(right) ? FromArrayRight(left, right) :
+                                        TypeGuard.IsTuple(right) ? FromTupleRight(left, right) :
+                                            TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
                                                 TypeGuard.IsUnknown(right) ? ExtendsResult.True :
                                                     ExtendsResult.False);
 }
@@ -568,18 +579,18 @@ function TUnknown(left, right) {
 // Void
 // ------------------------------------------------------------------
 // prettier-ignore
-function VoidRight(left, right) {
+function FromVoidRight(left, right) {
     return (TypeGuard.IsUndefined(left) ? ExtendsResult.True :
         TypeGuard.IsUndefined(left) ? ExtendsResult.True :
             ExtendsResult.False);
 }
 // prettier-ignore
-function TVoid(left, right) {
-    return (TypeGuard.IsIntersect(right) ? TIntersectRight(left, right) :
-        TypeGuard.IsUnion(right) ? TUnionRight(left, right) :
-            TypeGuard.IsUnknown(right) ? TUnknownRight(left, right) :
-                TypeGuard.IsAny(right) ? TAnyRight(left, right) :
-                    TypeGuard.IsObject(right) ? TObjectRight(left, right) :
+function FromVoid(left, right) {
+    return (TypeGuard.IsIntersect(right) ? FromIntersectRight(left, right) :
+        TypeGuard.IsUnion(right) ? FromUnionRight(left, right) :
+            TypeGuard.IsUnknown(right) ? FromUnknownRight(left, right) :
+                TypeGuard.IsAny(right) ? FromAnyRight(left, right) :
+                    TypeGuard.IsObject(right) ? FromObjectRight(left, right) :
                         TypeGuard.IsVoid(right) ? ExtendsResult.True :
                             ExtendsResult.False);
 }
@@ -587,36 +598,37 @@ function TVoid(left, right) {
 function Visit(left, right) {
     return (
     // resolvable
-    (TypeGuard.IsTemplateLiteral(left) || TypeGuard.IsTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
-        (TypeGuard.IsNot(left) || TypeGuard.IsNot(right)) ? TNot(left, right) :
-            // standard
-            TypeGuard.IsAny(left) ? TAny(left, right) :
-                TypeGuard.IsArray(left) ? TArray(left, right) :
-                    TypeGuard.IsBigInt(left) ? TBigInt(left, right) :
-                        TypeGuard.IsBoolean(left) ? TBoolean(left, right) :
-                            TypeGuard.IsAsyncIterator(left) ? TAsyncIterator(left, right) :
-                                TypeGuard.IsConstructor(left) ? TConstructor(left, right) :
-                                    TypeGuard.IsDate(left) ? TDate(left, right) :
-                                        TypeGuard.IsFunction(left) ? TFunction(left, right) :
-                                            TypeGuard.IsInteger(left) ? TInteger(left, right) :
-                                                TypeGuard.IsIntersect(left) ? TIntersect(left, right) :
-                                                    TypeGuard.IsIterator(left) ? TIterator(left, right) :
-                                                        TypeGuard.IsLiteral(left) ? TLiteral(left, right) :
-                                                            TypeGuard.IsNever(left) ? TNever(left, right) :
-                                                                TypeGuard.IsNull(left) ? TNull(left, right) :
-                                                                    TypeGuard.IsNumber(left) ? TNumber(left, right) :
-                                                                        TypeGuard.IsObject(left) ? TObject(left, right) :
-                                                                            TypeGuard.IsRecord(left) ? TRecord(left, right) :
-                                                                                TypeGuard.IsString(left) ? TString(left, right) :
-                                                                                    TypeGuard.IsSymbol(left) ? TSymbol(left, right) :
-                                                                                        TypeGuard.IsTuple(left) ? TTuple(left, right) :
-                                                                                            TypeGuard.IsPromise(left) ? TPromise(left, right) :
-                                                                                                TypeGuard.IsUint8Array(left) ? TUint8Array(left, right) :
-                                                                                                    TypeGuard.IsUndefined(left) ? TUndefined(left, right) :
-                                                                                                        TypeGuard.IsUnion(left) ? TUnion(left, right) :
-                                                                                                            TypeGuard.IsUnknown(left) ? TUnknown(left, right) :
-                                                                                                                TypeGuard.IsVoid(left) ? TVoid(left, right) :
-                                                                                                                    Throw(`Unknown left type operand '${left[Kind]}'`));
+    (TypeGuard.IsTemplateLiteral(left) || TypeGuard.IsTemplateLiteral(right)) ? FromTemplateLiteral(left, right) :
+        (TypeGuard.IsRegExp(left) || TypeGuard.IsRegExp(right)) ? FromRegExp(left, right) :
+            (TypeGuard.IsNot(left) || TypeGuard.IsNot(right)) ? FromNot(left, right) :
+                // standard
+                TypeGuard.IsAny(left) ? FromAny(left, right) :
+                    TypeGuard.IsArray(left) ? FromArray(left, right) :
+                        TypeGuard.IsBigInt(left) ? FromBigInt(left, right) :
+                            TypeGuard.IsBoolean(left) ? FromBoolean(left, right) :
+                                TypeGuard.IsAsyncIterator(left) ? FromAsyncIterator(left, right) :
+                                    TypeGuard.IsConstructor(left) ? FromConstructor(left, right) :
+                                        TypeGuard.IsDate(left) ? FromDate(left, right) :
+                                            TypeGuard.IsFunction(left) ? FromFunction(left, right) :
+                                                TypeGuard.IsInteger(left) ? FromInteger(left, right) :
+                                                    TypeGuard.IsIntersect(left) ? FromIntersect(left, right) :
+                                                        TypeGuard.IsIterator(left) ? FromIterator(left, right) :
+                                                            TypeGuard.IsLiteral(left) ? FromLiteral(left, right) :
+                                                                TypeGuard.IsNever(left) ? FromNever(left, right) :
+                                                                    TypeGuard.IsNull(left) ? FromNull(left, right) :
+                                                                        TypeGuard.IsNumber(left) ? FromNumber(left, right) :
+                                                                            TypeGuard.IsObject(left) ? FromObject(left, right) :
+                                                                                TypeGuard.IsRecord(left) ? FromRecord(left, right) :
+                                                                                    TypeGuard.IsString(left) ? FromString(left, right) :
+                                                                                        TypeGuard.IsSymbol(left) ? FromSymbol(left, right) :
+                                                                                            TypeGuard.IsTuple(left) ? FromTuple(left, right) :
+                                                                                                TypeGuard.IsPromise(left) ? FromPromise(left, right) :
+                                                                                                    TypeGuard.IsUint8Array(left) ? FromUint8Array(left, right) :
+                                                                                                        TypeGuard.IsUndefined(left) ? FromUndefined(left, right) :
+                                                                                                            TypeGuard.IsUnion(left) ? FromUnion(left, right) :
+                                                                                                                TypeGuard.IsUnknown(left) ? FromUnknown(left, right) :
+                                                                                                                    TypeGuard.IsVoid(left) ? FromVoid(left, right) :
+                                                                                                                        Throw(`Unknown left type operand '${left[Kind]}'`));
 }
 export function ExtendsCheck(left, right) {
     return Visit(left, right);

package/build/import/type/extends/extends-from-mapped-key.d.mts

@@ -2,7 +2,7 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import type { Assert } from '../helpers/index.mjs';
 import { type TMappedResult, type TMappedKey } from '../mapped/index.mjs';
-import { TLiteral, TLiteralValue } from '../literal/index.mjs';
+import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TExtends } from './extends.mjs';
 type TFromPropertyKey<K extends PropertyKey, U extends TSchema, L extends TSchema, R extends TSchema> = {
     [_ in K]: TExtends<TLiteral<Assert<K, TLiteralValue>>, U, L, R>;

package/build/import/type/extends/extends-from-mapped-key.mjs

@@ -8,11 +8,10 @@ function FromPropertyKey(K, U, L, R, options) {
     };
 }
 // prettier-ignore
-function FromPropertyKeys(K, U, L, R, options, Acc = {}) {
-    const [LK, ...RK] = K;
-    return (K.length > 0
-        ? FromPropertyKeys(RK, U, L, R, options, { ...Acc, ...FromPropertyKey(LK, U, L, R, options) })
-        : Acc);
+function FromPropertyKeys(K, U, L, R, options) {
+    return K.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+    }, {});
 }
 // prettier-ignore
 function FromMappedKey(K, U, L, R, options) {

package/build/import/type/extends/extends-from-mapped-result.d.mts

@@ -2,10 +2,10 @@ import type { TSchema, SchemaOptions } from '../schema/index.mjs';
 import type { TProperties } from '../object/index.mjs';
 import { type TMappedResult } from '../mapped/index.mjs';
 import { type TExtends } from './extends.mjs';
-type TFromProperties<K extends TProperties, U extends TSchema, L extends TSchema, R extends TSchema> = ({
-    [K2 in keyof K]: TExtends<K[K2], U, L, R>;
+type TFromProperties<P extends TProperties, Right extends TSchema, False extends TSchema, True extends TSchema> = ({
+    [K2 in keyof P]: TExtends<P[K2], Right, False, True>;
 });
-type TFromMappedResult<K extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema> = (TFromProperties<K['properties'], U, L, R>);
-export type TExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>> = (TMappedResult<P>);
-export declare function ExtendsFromMappedResult<T extends TMappedResult, U extends TSchema, L extends TSchema, R extends TSchema, P extends TProperties = TFromMappedResult<T, U, L, R>>(T: T, U: U, L: L, R: R, options: SchemaOptions): TMappedResult<P>;
+type TFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema> = (TFromProperties<Left['properties'], Right, True, False>);
+export type TExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>> = (TMappedResult<P>);
+export declare function ExtendsFromMappedResult<Left extends TMappedResult, Right extends TSchema, True extends TSchema, False extends TSchema, P extends TProperties = TFromMappedResult<Left, Right, True, False>>(Left: Left, Right: Right, True: True, False: False, options: SchemaOptions): TMappedResult<P>;
 export {};

package/build/import/type/extends/extends-from-mapped-result.mjs

@@ -1,17 +1,17 @@
 import { MappedResult } from '../mapped/index.mjs';
 import { Extends } from './extends.mjs';
 // prettier-ignore
-function FromProperties(K, U, L, R, options) {
-    return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
-        return { ...Acc, [K2]: Extends(K[K2], U, L, R, options) };
+function FromProperties(P, Right, True, False, options) {
+    return globalThis.Object.getOwnPropertyNames(P).reduce((Acc, K2) => {
+        return { ...Acc, [K2]: Extends(P[K2], Right, True, False, options) };
     }, {});
 }
 // prettier-ignore
-function FromMappedResult(K, U, L, R, options) {
-    return FromProperties(K.properties, U, L, R, options);
+function FromMappedResult(Left, Right, True, False, options) {
+    return FromProperties(Left.properties, Right, True, False, options);
 }
 // prettier-ignore
-export function ExtendsFromMappedResult(T, U, L, R, options) {
-    const P = FromMappedResult(T, U, L, R, options);
+export function ExtendsFromMappedResult(Left, Right, True, False, options) {
+    const P = FromMappedResult(Left, Right, True, False, options);
     return MappedResult(P);
 }

package/build/import/type/extends/extends.mjs

@@ -6,7 +6,6 @@ import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
 // ------------------------------------------------------------------
 // TypeGuard
 // ------------------------------------------------------------------
-// prettier-ignore
 import { IsMappedKey, IsMappedResult } from '../guard/type.mjs';
 // prettier-ignore
 function ExtendsResolve(left, right, trueType, falseType) {