@sinclair/typebox 0.31.28 → 0.32.0-dev-2

package/esm/type/extends/extends-check.mjs

@@ -0,0 +1,649 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox/type
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+---------------------------------------------------------------------------*/
+import { Any } from '../any/index.mjs';
+import { Function } from '../function/index.mjs';
+import { Number } from '../number/index.mjs';
+import { String } from '../string/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+import { PatternNumberExact, PatternStringExact } from '../patterns/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { TypeGuard, ValueGuard } from '../guard/index.mjs';
+export class ExtendsResolverError extends Error {
+}
+export var ExtendsResult;
+(function (ExtendsResult) {
+    ExtendsResult[ExtendsResult["Union"] = 0] = "Union";
+    ExtendsResult[ExtendsResult["True"] = 1] = "True";
+    ExtendsResult[ExtendsResult["False"] = 2] = "False";
+})(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 (TypeGuard.TNever(right) ||
+        TypeGuard.TIntersect(right) ||
+        TypeGuard.TUnion(right) ||
+        TypeGuard.TUnknown(right) ||
+        TypeGuard.TAny(right));
+}
+// prettier-ignore
+function StructuralRight(left, right) {
+    return (TypeGuard.TNever(right) ? TNeverRight(left, right) :
+        TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+            TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+                TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+                    TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                        Throw('StructuralRight'));
+}
+// ------------------------------------------------------------------
+// Any
+// ------------------------------------------------------------------
+// prettier-ignore
+function TAnyRight(left, right) {
+    return ExtendsResult.True;
+}
+// prettier-ignore
+function TAny(left, right) {
+    return (TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+        (TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema))) ? ExtendsResult.True :
+            TypeGuard.TUnion(right) ? ExtendsResult.Union :
+                TypeGuard.TUnknown(right) ? ExtendsResult.True :
+                    TypeGuard.TAny(right) ? ExtendsResult.True :
+                        ExtendsResult.Union);
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+// prettier-ignore
+function TArrayRight(left, right) {
+    return (TypeGuard.TUnknown(left) ? ExtendsResult.False :
+        TypeGuard.TAny(left) ? ExtendsResult.Union :
+            TypeGuard.TNever(left) ? ExtendsResult.True :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function TArray(left, right) {
+    return (TypeGuard.TObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            !TypeGuard.TArray(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// AsyncIterator
+// ------------------------------------------------------------------
+// prettier-ignore
+function TAsyncIterator(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        !TypeGuard.TAsyncIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// BigInt
+// ------------------------------------------------------------------
+// prettier-ignore
+function TBigInt(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TBigInt(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Boolean
+// ------------------------------------------------------------------
+// prettier-ignore
+function TBooleanRight(left, right) {
+    return (TypeGuard.TLiteralBoolean(left) ? ExtendsResult.True :
+        TypeGuard.TBoolean(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function TBoolean(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TBoolean(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Constructor
+// ------------------------------------------------------------------
+// prettier-ignore
+function TConstructor(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            !TypeGuard.TConstructor(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 :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Date
+// ------------------------------------------------------------------
+// prettier-ignore
+function TDate(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TDate(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Function
+// ------------------------------------------------------------------
+// prettier-ignore
+function TFunction(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            !TypeGuard.TFunction(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 :
+                        IntoBooleanResult(Visit(left.returns, right.returns)));
+}
+// ------------------------------------------------------------------
+// Integer
+// ------------------------------------------------------------------
+// prettier-ignore
+function TIntegerRight(left, right) {
+    return (TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? ExtendsResult.True :
+        TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function TInteger(left, right) {
+    return (TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                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) :
+        !TypeGuard.TIterator(right) ? ExtendsResult.False :
+            IntoBooleanResult(Visit(left.items, right.items)));
+}
+// ------------------------------------------------------------------
+// Literal
+// ------------------------------------------------------------------
+// prettier-ignore
+function TLiteral(left, right) {
+    return (TypeGuard.TLiteral(right) && right.const === left.const ? ExtendsResult.True :
+        IsStructuralRight(right) ? StructuralRight(left, right) :
+            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                    TypeGuard.TString(right) ? TStringRight(left, right) :
+                        TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+                            TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+                                TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+                                    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) {
+        if (!TypeGuard.TNot(current))
+            break;
+        current = current.not;
+        depth += 1;
+    }
+    return depth % 2 === 0 ? current : 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 (TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) :
+        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) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TNull(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Number
+// ------------------------------------------------------------------
+// prettier-ignore
+function TNumberRight(left, right) {
+    return (TypeGuard.TLiteralNumber(left) ? ExtendsResult.True :
+        TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function TNumber(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TInteger(right) || 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 && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && ((TypeGuard.TString(schema.properties.description.anyOf[0]) &&
+        TypeGuard.TUndefined(schema.properties.description.anyOf[1])) || (TypeGuard.TString(schema.properties.description.anyOf[1]) &&
+        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 = 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 = 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 = Function([Any()], 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 :
+        TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? ExtendsResult.False :
+            ExtendsResult.True);
+}
+// prettier-ignore
+function TObjectRight(left, right) {
+    return (TypeGuard.TUnknown(left) ? ExtendsResult.False :
+        TypeGuard.TAny(left) ? ExtendsResult.Union : (TypeGuard.TNever(left) ||
+            (TypeGuard.TLiteralString(left) && IsObjectStringLike(right)) ||
+            (TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right)) ||
+            (TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right)) ||
+            (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+            (TypeGuard.TBigInt(left) && IsObjectBigIntLike(right)) ||
+            (TypeGuard.TString(left) && IsObjectStringLike(right)) ||
+            (TypeGuard.TSymbol(left) && IsObjectSymbolLike(right)) ||
+            (TypeGuard.TNumber(left) && IsObjectNumberLike(right)) ||
+            (TypeGuard.TInteger(left) && IsObjectNumberLike(right)) ||
+            (TypeGuard.TBoolean(left) && IsObjectBooleanLike(right)) ||
+            (TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right)) ||
+            (TypeGuard.TDate(left) && IsObjectDateLike(right)) ||
+            (TypeGuard.TConstructor(left) && IsObjectConstructorLike(right)) ||
+            (TypeGuard.TFunction(left) && IsObjectFunctionLike(right))) ? ExtendsResult.True :
+            (TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left))) ? (() => {
+                // When expressing a Record with literal key values, the Record is converted into a Object with
+                // the Hint assigned as `Record`. This is used to invert the extends logic.
+                return right[Hint] === 'Record' ? ExtendsResult.True : ExtendsResult.False;
+            })() :
+                (TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left))) ? (() => {
+                    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+                })() :
+                    ExtendsResult.False);
+}
+// prettier-ignore
+function TObject(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+            !TypeGuard.TObject(right) ? ExtendsResult.False :
+                (() => {
+                    for (const key of Object.getOwnPropertyNames(right.properties)) {
+                        if (!(key in left.properties) && !TypeGuard.TOptional(right.properties[key])) {
+                            return ExtendsResult.False;
+                        }
+                        if (TypeGuard.TOptional(right.properties[key])) {
+                            return ExtendsResult.True;
+                        }
+                        if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+                            return ExtendsResult.False;
+                        }
+                    }
+                    return ExtendsResult.True;
+                })());
+}
+// ------------------------------------------------------------------
+// Promise
+// ------------------------------------------------------------------
+// prettier-ignore
+function TPromise(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True :
+            !TypeGuard.TPromise(right) ? ExtendsResult.False :
+                IntoBooleanResult(Visit(left.item, right.item)));
+}
+// ------------------------------------------------------------------
+// Record
+// ------------------------------------------------------------------
+// prettier-ignore
+function RecordKey(schema) {
+    return (PatternNumberExact in schema.patternProperties ? Number() :
+        PatternStringExact in schema.patternProperties ? String() :
+            Throw('Unknown record key pattern'));
+}
+// prettier-ignore
+function RecordValue(schema) {
+    return (PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] :
+        PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] :
+            Throw('Unable to get record value schema'));
+}
+// prettier-ignore
+function TRecordRight(left, right) {
+    const [Key, Value] = [RecordKey(right), RecordValue(right)];
+    return ((TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === ExtendsResult.True) ? ExtendsResult.True :
+        TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+            TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+                TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) :
+                    TypeGuard.TObject(left) ? (() => {
+                        for (const key of Object.getOwnPropertyNames(left.properties)) {
+                            if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+                                return ExtendsResult.False;
+                            }
+                        }
+                        return ExtendsResult.True;
+                    })() :
+                        ExtendsResult.False);
+}
+// prettier-ignore
+function TRecord(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            !TypeGuard.TRecord(right) ? ExtendsResult.False :
+                Visit(RecordValue(left), RecordValue(right)));
+}
+// ------------------------------------------------------------------
+// String
+// ------------------------------------------------------------------
+// prettier-ignore
+function TStringRight(left, right) {
+    return (TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? ExtendsResult.True :
+        TypeGuard.TString(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function TString(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TString(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Symbol
+// ------------------------------------------------------------------
+// prettier-ignore
+function TSymbol(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                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 (TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralToUnion(left), right) :
+        TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralToUnion(right)) :
+            Throw('Invalid fallthrough for TemplateLiteral'));
+}
+// ------------------------------------------------------------------
+// Tuple
+// ------------------------------------------------------------------
+// prettier-ignore
+function IsArrayOfTuple(left, right) {
+    return (TypeGuard.TArray(right) &&
+        left.items !== undefined &&
+        left.items.every((schema) => Visit(schema, right.items) === ExtendsResult.True));
+}
+// prettier-ignore
+function TTupleRight(left, right) {
+    return (TypeGuard.TNever(left) ? ExtendsResult.True :
+        TypeGuard.TUnknown(left) ? ExtendsResult.False :
+            TypeGuard.TAny(left) ? ExtendsResult.Union :
+                ExtendsResult.False);
+}
+// prettier-ignore
+function TTuple(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True :
+            TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True :
+                !TypeGuard.TTuple(right) ? ExtendsResult.False :
+                    (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) || (!ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items)) ? ExtendsResult.False :
+                        (ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items)) ? ExtendsResult.True :
+                            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) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TUint8Array(right) ? ExtendsResult.True :
+                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Undefined
+// ------------------------------------------------------------------
+// prettier-ignore
+function TUndefined(left, right) {
+    return (IsStructuralRight(right) ? StructuralRight(left, right) :
+        TypeGuard.TObject(right) ? TObjectRight(left, right) :
+            TypeGuard.TRecord(right) ? TRecordRight(left, right) :
+                TypeGuard.TVoid(right) ? VoidRight(left, right) :
+                    TypeGuard.TUndefined(right) ? 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 (TypeGuard.TNever(right) ? TNeverRight(left, right) :
+        TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+            TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+                TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                    TypeGuard.TString(right) ? TStringRight(left, right) :
+                        TypeGuard.TNumber(right) ? TNumberRight(left, right) :
+                            TypeGuard.TInteger(right) ? TIntegerRight(left, right) :
+                                TypeGuard.TBoolean(right) ? TBooleanRight(left, right) :
+                                    TypeGuard.TArray(right) ? TArrayRight(left, right) :
+                                        TypeGuard.TTuple(right) ? TTupleRight(left, right) :
+                                            TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                                                TypeGuard.TUnknown(right) ? ExtendsResult.True :
+                                                    ExtendsResult.False);
+}
+// ------------------------------------------------------------------
+// Void
+// ------------------------------------------------------------------
+// prettier-ignore
+function VoidRight(left, right) {
+    return (TypeGuard.TUndefined(left) ? ExtendsResult.True :
+        TypeGuard.TUndefined(left) ? ExtendsResult.True :
+            ExtendsResult.False);
+}
+// prettier-ignore
+function TVoid(left, right) {
+    return (TypeGuard.TIntersect(right) ? TIntersectRight(left, right) :
+        TypeGuard.TUnion(right) ? TUnionRight(left, right) :
+            TypeGuard.TUnknown(right) ? TUnknownRight(left, right) :
+                TypeGuard.TAny(right) ? TAnyRight(left, right) :
+                    TypeGuard.TObject(right) ? TObjectRight(left, right) :
+                        TypeGuard.TVoid(right) ? ExtendsResult.True :
+                            ExtendsResult.False);
+}
+// prettier-ignore
+function Visit(left, right) {
+    return (
+    // resolvable
+    (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right)) ? TTemplateLiteral(left, right) :
+        (TypeGuard.TNot(left) || TypeGuard.TNot(right)) ? TNot(left, right) :
+            // standard
+            TypeGuard.TAny(left) ? TAny(left, right) :
+                TypeGuard.TArray(left) ? TArray(left, right) :
+                    TypeGuard.TBigInt(left) ? TBigInt(left, right) :
+                        TypeGuard.TBoolean(left) ? TBoolean(left, right) :
+                            TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) :
+                                TypeGuard.TConstructor(left) ? TConstructor(left, right) :
+                                    TypeGuard.TDate(left) ? TDate(left, right) :
+                                        TypeGuard.TFunction(left) ? TFunction(left, right) :
+                                            TypeGuard.TInteger(left) ? TInteger(left, right) :
+                                                TypeGuard.TIntersect(left) ? TIntersect(left, right) :
+                                                    TypeGuard.TIterator(left) ? TIterator(left, right) :
+                                                        TypeGuard.TLiteral(left) ? TLiteral(left, right) :
+                                                            TypeGuard.TNever(left) ? TNever(left, right) :
+                                                                TypeGuard.TNull(left) ? TNull(left, right) :
+                                                                    TypeGuard.TNumber(left) ? TNumber(left, right) :
+                                                                        TypeGuard.TObject(left) ? TObject(left, right) :
+                                                                            TypeGuard.TRecord(left) ? TRecord(left, right) :
+                                                                                TypeGuard.TString(left) ? TString(left, right) :
+                                                                                    TypeGuard.TSymbol(left) ? TSymbol(left, right) :
+                                                                                        TypeGuard.TTuple(left) ? TTuple(left, right) :
+                                                                                            TypeGuard.TPromise(left) ? TPromise(left, right) :
+                                                                                                TypeGuard.TUint8Array(left) ? TUint8Array(left, right) :
+                                                                                                    TypeGuard.TUndefined(left) ? TUndefined(left, right) :
+                                                                                                        TypeGuard.TUnion(left) ? TUnion(left, right) :
+                                                                                                            TypeGuard.TUnknown(left) ? TUnknown(left, right) :
+                                                                                                                TypeGuard.TVoid(left) ? TVoid(left, right) :
+                                                                                                                    Throw(`Unknown left type operand '${left[Kind]}'`));
+}
+export function ExtendsCheck(left, right) {
+    return Visit(left, right);
+}

package/esm/type/extends/extends-undefined.d.mts

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