@sinclair/typebox 0.32.0-dev-27 → 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/guard/type.d.mts

@@ -26,6 +26,7 @@ import type { TOptional } from '../optional/index.mjs';
 import type { TPromise } from '../promise/index.mjs';
 import type { TReadonly } from '../readonly/index.mjs';
 import type { TRef } from '../ref/index.mjs';
+import type { TRegExp } from '../regexp/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { TSymbol } from '../symbol/index.mjs';
 import type { TTuple } from '../tuple/index.mjs';
@@ -104,6 +105,8 @@ export declare function IsRecursive(value: unknown): value is {
 };
 /** Returns true if the given value is TRef */
 export declare function IsRef(value: unknown): value is TRef;
+/** Returns true if the given value is TRegExp */
+export declare function IsRegExp(value: unknown): value is TRegExp;
 /** Returns true if the given value is TString */
 export declare function IsString(value: unknown): value is TString;
 /** Returns true if the given value is TSymbol */

package/build/import/type/guard/type.mjs

@@ -26,6 +26,7 @@ const KnownTypes = [
     'Promise',
     'Record',
     'Ref',
+    'RegExp',
     'String',
     'Symbol',
     'TemplateLiteral',
@@ -324,6 +325,14 @@ export function IsRef(value) {
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
+/** Returns true if the given value is TRegExp */
+export function IsRegExp(value) {
+    // prettier-ignore
+    return (IsKindOf(value, 'RegExp') &&
+        IsOptionalString(value.$id) &&
+        ValueGuard.IsString(value.source) &&
+        ValueGuard.IsString(value.flags));
+}
 /** Returns true if the given value is TString */
 export function IsString(value) {
     // prettier-ignore
@@ -452,6 +461,7 @@ export function IsSchema(value) {
         IsPromise(value) ||
         IsRecord(value) ||
         IsRef(value) ||
+        IsRegExp(value) ||
         IsString(value) ||
         IsSymbol(value) ||
         IsTemplateLiteral(value) ||

package/build/import/type/guard/value.d.mts

@@ -18,6 +18,8 @@ export declare function IsNull(value: unknown): value is null;
 export declare function IsNumber(value: unknown): value is number;
 /** Returns true if this value is an object */
 export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
+/** Returns true if this value is RegExp */
+export declare function IsRegExp(value: unknown): value is RegExp;
 /** Returns true if this value is string */
 export declare function IsString(value: unknown): value is string;
 /** Returns true if this value is symbol */

package/build/import/type/guard/value.mjs

@@ -38,6 +38,10 @@ export function IsNumber(value) {
 export function IsObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/** Returns true if this value is RegExp */
+export function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
 /** Returns true if this value is string */
 export function IsString(value) {
     return typeof value === 'string';

package/build/import/type/record/record.d.mts

@@ -5,6 +5,7 @@ import { type TObject, type TProperties, type TAdditionalProperties, type Object
 import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
 import { type TNever } from '../never/index.mjs';
 import { type TUnion } from '../union/index.mjs';
+import { type TRegExp } from '../regexp/index.mjs';
 import { type TString } from '../string/index.mjs';
 import { type TInteger } from '../integer/index.mjs';
 import { type TNumber } from '../number/index.mjs';
@@ -30,6 +31,7 @@ type TFromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties
 type TFromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
     [_ in Assert<K, PropertyKey>]: T;
 }>>);
+type TFromRegExpKey<_ extends TRegExp, T extends TSchema> = (Ensure<TRecord<TRegExp, T>>);
 type TFromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
 type TFromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
 type TFromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
@@ -43,7 +45,7 @@ export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchem
     };
     additionalProperties: TAdditionalProperties;
 }
-export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
+export type TRecordOrObject<K extends TSchema, T extends TSchema> = K extends TTemplateLiteral ? TFromTemplateLiteralKey<K, T> : K extends TEnum<infer S> ? TFromEnumKey<S, T> : K extends TUnion<infer S> ? TFromUnionKey<S, T> : K extends TLiteral<infer S> ? TFromLiteralKey<S, T> : K extends TInteger ? TFromIntegerKey<K, T> : K extends TNumber ? TFromNumberKey<K, T> : K extends TRegExp ? TFromRegExpKey<K, T> : K extends TString ? TFromStringKey<K, T> : TNever;
 /** `[Json]` Creates a Record type */
 export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): TRecordOrObject<K, T>;
 export {};