typebox 1.0.31 → 1.0.33

package/build/cjs/type/extends/extends-left.d.ts

@@ -0,0 +1,55 @@
+import { type TExtendsAny } from './any';
+import { type TExtendsArray } from './array';
+import { type TExtendsAsyncIterator } from './async-iterator';
+import { type TExtendsBigInt } from './bigint';
+import { type TExtendsBoolean } from './boolean';
+import { type TExtendsConstructor } from './constructor';
+import { type TExtendsEnum } from './enum';
+import { type TExtendsFunction } from './function';
+import { type TExtendsInteger } from './integer';
+import { type TExtendsIntersect } from './intersect';
+import { type TExtendsIterator } from './iterator';
+import { type TExtendsLiteral } from './literal';
+import { type TExtendsNever } from './never';
+import { type TExtendsNull } from './null';
+import { type TExtendsNumber } from './number';
+import { type TExtendsObject } from './object';
+import { type TExtendsPromise } from './promise';
+import { type TExtendsString } from './string';
+import { type TExtendsSymbol } from './symbol';
+import { type TExtendsTemplateLiteral } from './template-literal';
+import { type TExtendsTuple } from './tuple';
+import { type TExtendsUndefined } from './undefined';
+import { type TExtendsUnion } from './union';
+import { type TExtendsUnknown } from './unknown';
+import { type TExtendsVoid } from './void';
+import { type TAny } from '../types/any';
+import { type TArray } from '../types/array';
+import { type TAsyncIterator } from '../types/async-iterator';
+import { type TBigInt } from '../types/bigint';
+import { type TBoolean } from '../types/boolean';
+import { type TConstructor } from '../types/constructor';
+import { type TEnum, type TEnumValue } from '../types/enum';
+import { type TFunction } from '../types/function';
+import { type TInteger } from '../types/integer';
+import { type TIntersect } from '../types/intersect';
+import { type TIterator } from '../types/iterator';
+import { type TLiteral } from '../types/literal';
+import { type TNever } from '../types/never';
+import { type TNull } from '../types/null';
+import { type TNumber } from '../types/number';
+import { type TObject } from '../types/object';
+import { type TPromise } from '../types/promise';
+import { type TSchema } from '../types/schema';
+import { type TString } from '../types/string';
+import { type TSymbol } from '../types/symbol';
+import { type TTemplateLiteral } from '../types/template-literal';
+import { type TTuple } from '../types/tuple';
+import { type TUndefined } from '../types/undefined';
+import { type TUnknown } from '../types/unknown';
+import { type TProperties } from '../types/properties';
+import { type TUnion } from '../types/union';
+import { type TVoid } from '../types/void';
+import * as Result from './result';
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Type extends TSchema> ? TExtendsArray<Inferred, Type, Right> : Left extends TAsyncIterator<infer Type extends TSchema> ? TExtendsAsyncIterator<Inferred, Type, Right> : Left extends TBigInt ? TExtendsBigInt<Inferred, Left, Right> : Left extends TBoolean ? TExtendsBoolean<Inferred, Left, Right> : Left extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TExtendsConstructor<Inferred, Parameters, InstanceType, Right> : Left extends TEnum<infer Values extends TEnumValue[]> ? TExtendsEnum<Inferred, TEnum<Values>, Right> : Left extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TExtendsFunction<Inferred, Parameters, ReturnType, Right> : Left extends TInteger ? TExtendsInteger<Inferred, Left, Right> : Left extends TIntersect<infer Types extends TSchema[]> ? TExtendsIntersect<Inferred, Types, Right> : Left extends TIterator<infer Type extends TSchema> ? TExtendsIterator<Inferred, Type, Right> : Left extends TLiteral ? TExtendsLiteral<Inferred, Left, Right> : Left extends TNever ? TExtendsNever<Inferred, Left, Right> : Left extends TNull ? TExtendsNull<Inferred, Left, Right> : Left extends TNumber ? TExtendsNumber<Inferred, Left, Right> : Left extends TObject<infer Properties extends TProperties> ? TExtendsObject<Inferred, Properties, Right> : Left extends TPromise<infer Type extends TSchema> ? TExtendsPromise<Inferred, Type, Right> : Left extends TString ? TExtendsString<Inferred, Left, Right> : Left extends TSymbol ? TExtendsSymbol<Inferred, Left, Right> : Left extends TTemplateLiteral<infer Pattern extends string> ? TExtendsTemplateLiteral<Inferred, Pattern, Right> : Left extends TTuple<infer Types extends TSchema[]> ? TExtendsTuple<Inferred, Types, Right> : Left extends TUndefined ? TExtendsUndefined<Inferred, Left, Right> : Left extends TUnion<infer Types extends TSchema[]> ? TExtendsUnion<Inferred, Types, Right> : Left extends TUnknown ? TExtendsUnknown<Inferred, Left, Right> : Left extends TVoid ? TExtendsVoid<Inferred, Left, Right> : Result.TExtendsFalse);
+export declare function ExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsLeft<Inferred, Left, Right>;

package/build/cjs/type/extends/extends-left.js

@@ -0,0 +1,86 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsLeft = ExtendsLeft;
+const any_1 = require("./any");
+const array_1 = require("./array");
+const async_iterator_1 = require("./async-iterator");
+const bigint_1 = require("./bigint");
+const boolean_1 = require("./boolean");
+const constructor_1 = require("./constructor");
+const enum_1 = require("./enum");
+const function_1 = require("./function");
+const integer_1 = require("./integer");
+const intersect_1 = require("./intersect");
+const iterator_1 = require("./iterator");
+const literal_1 = require("./literal");
+const never_1 = require("./never");
+const null_1 = require("./null");
+const number_1 = require("./number");
+const object_1 = require("./object");
+const promise_1 = require("./promise");
+const string_1 = require("./string");
+const symbol_1 = require("./symbol");
+const template_literal_1 = require("./template-literal");
+const tuple_1 = require("./tuple");
+const undefined_1 = require("./undefined");
+const union_1 = require("./union");
+const unknown_1 = require("./unknown");
+const void_1 = require("./void");
+// ----------------------------------------------------------------------------
+// Types
+// ----------------------------------------------------------------------------
+const any_2 = require("../types/any");
+const array_2 = require("../types/array");
+const async_iterator_2 = require("../types/async-iterator");
+const bigint_2 = require("../types/bigint");
+const boolean_2 = require("../types/boolean");
+const constructor_2 = require("../types/constructor");
+const enum_2 = require("../types/enum");
+const function_2 = require("../types/function");
+const integer_2 = require("../types/integer");
+const intersect_2 = require("../types/intersect");
+const iterator_2 = require("../types/iterator");
+const literal_2 = require("../types/literal");
+const never_2 = require("../types/never");
+const null_2 = require("../types/null");
+const number_2 = require("../types/number");
+const object_2 = require("../types/object");
+const promise_2 = require("../types/promise");
+const string_2 = require("../types/string");
+const symbol_2 = require("../types/symbol");
+const template_literal_2 = require("../types/template-literal");
+const tuple_2 = require("../types/tuple");
+const undefined_2 = require("../types/undefined");
+const unknown_2 = require("../types/unknown");
+const union_2 = require("../types/union");
+const void_2 = require("../types/void");
+const Result = require("./result");
+function ExtendsLeft(inferred, left, right) {
+    return ((0, any_2.IsAny)(left) ? (0, any_1.ExtendsAny)(inferred, left, right) :
+        (0, array_2.IsArray)(left) ? (0, array_1.ExtendsArray)(inferred, left.items, right) :
+            (0, async_iterator_2.IsAsyncIterator)(left) ? (0, async_iterator_1.ExtendsAsyncIterator)(inferred, left.iteratorItems, right) :
+                (0, bigint_2.IsBigInt)(left) ? (0, bigint_1.ExtendsBigInt)(inferred, left, right) :
+                    (0, boolean_2.IsBoolean)(left) ? (0, boolean_1.ExtendsBoolean)(inferred, left, right) :
+                        (0, constructor_2.IsConstructor)(left) ? (0, constructor_1.ExtendsConstructor)(inferred, left.parameters, left.instanceType, right) :
+                            (0, enum_2.IsEnum)(left) ? (0, enum_1.ExtendsEnum)(inferred, left, right) :
+                                (0, function_2.IsFunction)(left) ? (0, function_1.ExtendsFunction)(inferred, left.parameters, left.returnType, right) :
+                                    (0, integer_2.IsInteger)(left) ? (0, integer_1.ExtendsInteger)(inferred, left, right) :
+                                        (0, intersect_2.IsIntersect)(left) ? (0, intersect_1.ExtendsIntersect)(inferred, left.allOf, right) :
+                                            (0, iterator_2.IsIterator)(left) ? (0, iterator_1.ExtendsIterator)(inferred, left.iteratorItems, right) :
+                                                (0, literal_2.IsLiteral)(left) ? (0, literal_1.ExtendsLiteral)(inferred, left, right) :
+                                                    (0, never_2.IsNever)(left) ? (0, never_1.ExtendsNever)(inferred, left, right) :
+                                                        (0, null_2.IsNull)(left) ? (0, null_1.ExtendsNull)(inferred, left, right) :
+                                                            (0, number_2.IsNumber)(left) ? (0, number_1.ExtendsNumber)(inferred, left, right) :
+                                                                (0, object_2.IsObject)(left) ? (0, object_1.ExtendsObject)(inferred, left.properties, right) :
+                                                                    (0, promise_2.IsPromise)(left) ? (0, promise_1.ExtendsPromise)(inferred, left.item, right) :
+                                                                        (0, string_2.IsString)(left) ? (0, string_1.ExtendsString)(inferred, left, right) :
+                                                                            (0, symbol_2.IsSymbol)(left) ? (0, symbol_1.ExtendsSymbol)(inferred, left, right) :
+                                                                                (0, template_literal_2.IsTemplateLiteral)(left) ? (0, template_literal_1.ExtendsTemplateLiteral)(inferred, left.pattern, right) :
+                                                                                    (0, tuple_2.IsTuple)(left) ? (0, tuple_1.ExtendsTuple)(inferred, left.items, right) :
+                                                                                        (0, undefined_2.IsUndefined)(left) ? (0, undefined_1.ExtendsUndefined)(inferred, left, right) :
+                                                                                            (0, union_2.IsUnion)(left) ? (0, union_1.ExtendsUnion)(inferred, left.anyOf, right) :
+                                                                                                (0, unknown_2.IsUnknown)(left) ? (0, unknown_1.ExtendsUnknown)(inferred, left, right) :
+                                                                                                    (0, void_2.IsVoid)(left) ? (0, void_1.ExtendsVoid)(inferred, left, right) :
+                                                                                                        Result.ExtendsFalse());
+}

package/build/cjs/type/extends/extends-right.d.ts

@@ -0,0 +1,25 @@
+import { Memory } from '../../system/memory/index';
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TAny } from '../types/any';
+import { type TEnum, type TEnumValue } from '../types/enum';
+import { type TInfer } from '../types/infer';
+import { type TIntersect } from '../types/intersect';
+import { type TTemplateLiteral } from '../types/template-literal';
+import { type TUnion } from '../types/union';
+import { type TUnknown } from '../types/unknown';
+import { type TExtendsLeft } from './extends-left';
+import * as Result from './result';
+import { type TTemplateLiteralDecode } from '../engine/template-literal/decode';
+import { type TEnumValuesToUnion } from '../engine/enum/index';
+type TExtendsRightInfer<Inferred extends TProperties, Name extends string, Left extends TSchema, Right extends TSchema, Result extends Result.TResult = (TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer CheckInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Memory.TAssign<Inferred, CheckInferred>, {
+    [_ in Name]: Left;
+}>> : Result.TExtendsFalse)> = Result;
+type TExtendsRightAny<Inferred extends TProperties, Left extends TSchema, Result extends Result.TResult = Result.TExtendsTrue<Inferred>> = Result;
+type TExtendsRightEnum<Inferred extends TProperties, Left extends TSchema, Right extends TEnumValue[], Union extends TSchema = TEnumValuesToUnion<Right>> = TExtendsLeft<Inferred, Left, Union>;
+type TExtendsRightIntersect<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRightIntersect<Inferred, Left, Tail> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
+type TExtendsRightTemplateLiteral<Inferred extends TProperties, Left extends TSchema, Right extends string, Decoded extends TSchema = TTemplateLiteralDecode<Right>> = TExtendsLeft<Inferred, Left, Decoded>;
+type TExtendsRightUnion<Inferred extends TProperties, Left extends TSchema, Right extends TSchema[]> = (Right extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<Inferred, Left, Head> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? Result.TExtendsTrue<Inferred> : TExtendsRightUnion<Inferred, Left, Tail> : Result.TExtendsFalse);
+export type TExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAny ? TExtendsRightAny<Inferred, Left> : Right extends TEnum<infer Values extends TEnumValue[]> ? TExtendsRightEnum<Inferred, Left, Values> : Right extends TInfer<infer Name extends string, infer Type extends TSchema> ? TExtendsRightInfer<Inferred, Name, Left, Type> : Right extends TTemplateLiteral<infer Pattern extends string> ? TExtendsRightTemplateLiteral<Inferred, Left, Pattern> : Right extends TIntersect<infer Types extends TSchema[]> ? TExtendsRightIntersect<Inferred, Left, Types> : Right extends TUnion<infer Types extends TSchema[]> ? TExtendsRightUnion<Inferred, Left, Types> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+export declare function ExtendsRight<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsRight<Inferred, Left, Right>;
+export {};

package/build/cjs/type/extends/extends-right.js

@@ -0,0 +1,62 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsRight = ExtendsRight;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("../types/schema");
+const any_1 = require("../types/any");
+const enum_1 = require("../types/enum");
+const infer_1 = require("../types/infer");
+const intersect_1 = require("../types/intersect");
+const template_literal_1 = require("../types/template-literal");
+const union_1 = require("../types/union");
+const unknown_1 = require("../types/unknown");
+const extends_left_1 = require("./extends-left");
+const Result = require("./result");
+const decode_1 = require("../engine/template-literal/decode");
+const index_2 = require("../engine/enum/index");
+function ExtendsRightInfer(inferred, name, left, right) {
+    const check = (0, extends_left_1.ExtendsLeft)(inferred, left, right);
+    return (Result.IsExtendsTrueLike(check)
+        ? Result.ExtendsTrue(index_1.Memory.Assign(index_1.Memory.Assign(inferred, check.inferred), { [name]: left }))
+        : Result.ExtendsFalse());
+}
+function ExtendsRightAny(inferred, left) {
+    return Result.ExtendsTrue(inferred);
+}
+function ExtendsRightEnum(inferred, left, right) {
+    const union = (0, index_2.EnumValuesToUnion)(right);
+    return (0, extends_left_1.ExtendsLeft)(inferred, left, union);
+}
+function ExtendsRightIntersect(inferred, left, right) {
+    const [head, ...tail] = right;
+    return ((0, schema_1.IsSchema)(head) ? (() => {
+        const check = (0, extends_left_1.ExtendsLeft)(inferred, left, head);
+        return Result.IsExtendsTrueLike(check)
+            ? ExtendsRightIntersect(check.inferred, left, tail)
+            : Result.ExtendsFalse();
+    })() : Result.ExtendsTrue(inferred));
+}
+function ExtendsRightTemplateLiteral(inferred, left, right) {
+    const decoded = (0, decode_1.TemplateLiteralDecode)(right);
+    return (0, extends_left_1.ExtendsLeft)(inferred, left, decoded);
+}
+function ExtendsRightUnion(inferred, left, right) {
+    const [head, ...tail] = right;
+    return ((0, schema_1.IsSchema)(head) ? (() => {
+        const check = (0, extends_left_1.ExtendsLeft)(inferred, left, head);
+        return Result.IsExtendsTrueLike(check)
+            ? Result.ExtendsTrue(check.inferred)
+            : ExtendsRightUnion(inferred, left, tail);
+    })() : Result.ExtendsFalse());
+}
+function ExtendsRight(inferred, left, right) {
+    return ((0, any_1.IsAny)(right) ? ExtendsRightAny(inferred, left) :
+        (0, enum_1.IsEnum)(right) ? ExtendsRightEnum(inferred, left, right.enum) :
+            (0, infer_1.IsInfer)(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
+                (0, intersect_1.IsIntersect)(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
+                    (0, template_literal_1.IsTemplateLiteral)(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
+                        (0, union_1.IsUnion)(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
+                            (0, unknown_1.IsUnknown)(right) ? Result.ExtendsTrue(inferred) :
+                                Result.ExtendsFalse());
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TCyclic } from '../types/cyclic';
+import { type TExtendsLeft } from './extends-left';
+import { type TCyclicExtends } from '../engine/cyclic/index';
+type TNormal<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type);
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+export type TExtends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TNormal<Left>, NormalRight extends TSchema = TNormal<Right>> = TExtendsLeft<Inferred, NormalLeft, NormalRight>;
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+export declare function Extends<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtends<Inferred, Left, Right>;
+export {};

package/build/cjs/type/extends/extends.js

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extends = Extends;
+const cyclic_1 = require("../types/cyclic");
+const extends_left_1 = require("./extends-left");
+const index_1 = require("../engine/cyclic/index");
+function Normal(type) {
+    return ((0, cyclic_1.IsCyclic)(type)
+        ? (0, index_1.CyclicExtends)(type)
+        : type);
+}
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+function Extends(inferred, left, right) {
+    const normalLeft = Normal(left);
+    const normalRight = Normal(right);
+    return (0, extends_left_1.ExtendsLeft)(inferred, normalLeft, normalRight);
+}

package/build/cjs/type/extends/function.d.ts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TFunction } from '../types/function';
+import * as Result from './result';
+import { type TExtendsParameters } from './parameters';
+import { type TExtendsReturnType } from './return-type';
+export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TFunction<infer RightParamters extends TSchema[], infer RightReturnType extends TSchema> ? TExtendsParameters<Inferred, Parameters, RightParamters> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, RightReturnType> : Result.TExtendsFalse : Result.TExtendsFalse);
+export declare function ExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: ReturnType, right: Right): TExtendsFunction<Inferred, Parameters, ReturnType, Right>;

package/build/cjs/type/extends/function.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsFunction = ExtendsFunction;
+const function_1 = require("../types/function");
+const Result = require("./result");
+// ------------------------------------------------------------------
+// Parameters | ReturnType
+// ------------------------------------------------------------------ 
+const parameters_1 = require("./parameters");
+const return_type_1 = require("./return-type");
+function ExtendsFunction(inferred, parameters, returnType, right) {
+    return ((0, function_1.IsFunction)(right) ? (() => {
+        const check = (0, parameters_1.ExtendsParameters)(inferred, parameters, right.parameters);
+        return Result.IsExtendsTrueLike(check)
+            ? (0, return_type_1.ExtendsReturnType)(check.inferred, returnType, right.returnType)
+            : Result.ExtendsFalse();
+    })() : Result.ExtendsFalse());
+}

package/build/cjs/type/extends/index.d.ts

@@ -0,0 +1,2 @@
+export { Extends, type TExtends } from './extends';
+export * as ExtendsResult from './result';

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsResult = exports.Extends = void 0;
+var extends_1 = require("./extends");
+Object.defineProperty(exports, "Extends", { enumerable: true, get: function () { return extends_1.Extends; } });
+exports.ExtendsResult = require("./result");

package/build/cjs/type/extends/inference.d.ts

@@ -0,0 +1,34 @@
+import { type TUnreachable } from '../../system/unreachable/index';
+import { Memory } from '../../system/memory/index';
+import { type TSchema } from '../types/schema';
+import { type TArray } from '../types/array';
+import { type TUnknown } from '../types/unknown';
+import { type TProperties } from '../types/properties';
+import { type TTuple } from '../types/tuple';
+import { type TExtendsLeft } from './extends-left';
+import { type TUnion } from '../types/union';
+import { type TInfer } from '../types/infer';
+import { type TRest } from '../types/rest';
+import * as Result from './result';
+export interface TInferable<Name extends string = string, Type extends TSchema = TSchema> {
+    '~kind': 'Inferrable';
+    name: Name;
+    type: Type;
+}
+export declare function Inferrable<Name extends string, Type extends TSchema = TSchema>(name: Name, type: Type): never;
+export declare function IsInferable(value: unknown): value is TInferable;
+export type TTryRestInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TRest<infer RestType extends TSchema> ? RestType extends TInfer<infer Name extends string, infer Type extends TSchema> ? Type extends TArray<infer Type extends TSchema> ? TInferable<Name, Type> : Type extends TUnknown ? TInferable<Name, Type> : undefined : TUnreachable : undefined)> = Result;
+export declare function TryRestInferable<Type extends TSchema>(type: Type): TTryRestInferable<Type>;
+export type TTryInferable<Type extends TSchema, Result extends TInferable | undefined = (Type extends TInfer<infer Name extends string, infer Type extends TSchema> ? TInferable<Name, Type> : undefined)> = Result;
+export declare function TryInferable<Type extends TSchema>(type: Type): TTryInferable<Type>;
+type TryInferResults<Rest extends TSchema[], Right extends TSchema, Result extends TSchema[] = []> = (Rest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TExtendsLeft<{}, Head, Right> extends Result.TExtendsTrueLike<TProperties> ? TryInferResults<Tail, Right, [...Result, Head]> : undefined : Result);
+declare function TryInferResults<Rest extends TSchema[], Right extends TSchema>(rest: [...Rest], right: Right, result?: TSchema[]): TryInferResults<Rest, Right>;
+export type TInferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
+    [_ in Name]: TTuple<Results>;
+}>> : Result.TExtendsFalse);
+export declare function InferTupleResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, name: Name, left: Left, right: Right): TInferTupleResult<Inferred, Name, Left, Right>;
+export type TInferUnionResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema, Results extends TSchema[] | undefined = TryInferResults<Left, Right>> = (Results extends [...infer Results extends TSchema[]] ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
+    [_ in Name]: TUnion<Results>;
+}>> : Result.TExtendsFalse);
+export declare function InferUnionResult<Inferred extends TProperties, Name extends string, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, name: Name, left: Left, right: Right): TInferUnionResult<Inferred, Name, Left, Right>;
+export {};

package/build/cjs/type/extends/inference.js

@@ -0,0 +1,80 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inferrable = Inferrable;
+exports.IsInferable = IsInferable;
+exports.TryRestInferable = TryRestInferable;
+exports.TryInferable = TryInferable;
+exports.InferTupleResult = InferTupleResult;
+exports.InferUnionResult = InferUnionResult;
+const index_1 = require("../../system/unreachable/index");
+const index_2 = require("../../system/memory/index");
+const index_3 = require("../../guard/index");
+// ----------------------------------------------------------------------------
+// Schematics
+// ----------------------------------------------------------------------------
+const schema_1 = require("../types/schema");
+const array_1 = require("../types/array");
+const unknown_1 = require("../types/unknown");
+const tuple_1 = require("../types/tuple");
+const extends_left_1 = require("./extends-left");
+const union_1 = require("../types/union");
+// ----------------------------------------------------------------------------
+// Operator
+// ----------------------------------------------------------------------------
+const infer_1 = require("../types/infer");
+const rest_1 = require("../types/rest");
+const Result = require("./result");
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+function Inferrable(name, type) {
+    return index_2.Memory.Create({ '~kind': 'Inferrable' }, { name, type }, {});
+}
+// ----------------------------------------------------------------------------
+// Guard
+// ----------------------------------------------------------------------------
+function IsInferable(value) {
+    return index_3.Guard.IsObject(value)
+        && index_3.Guard.HasPropertyKey(value, '~kind')
+        && index_3.Guard.HasPropertyKey(value, 'name')
+        && index_3.Guard.HasPropertyKey(value, 'type')
+        && index_3.Guard.IsEqual(value["~kind"], 'Inferrable')
+        && index_3.Guard.IsString(value.name)
+        && index_3.Guard.IsObject(value.type);
+}
+function TryRestInferable(type) {
+    return ((0, rest_1.IsRest)(type)
+        ? (0, infer_1.IsInfer)(type.items)
+            ? (0, array_1.IsArray)(type.items.extends) ? Inferrable(type.items.name, type.items.extends.items) :
+                (0, unknown_1.IsUnknown)(type.items.extends) ? Inferrable(type.items.name, type.items.extends) :
+                    undefined
+            : (0, index_1.Unreachable)() // undefined
+        : undefined);
+}
+function TryInferable(type) {
+    return ((0, infer_1.IsInfer)(type) ? Inferrable(type.name, type.extends) :
+        undefined);
+}
+function TryInferResults(rest, right, result = []) {
+    const [head, ...tail] = rest;
+    return ((0, schema_1.IsSchema)(head)
+        ? (() => {
+            const check = (0, extends_left_1.ExtendsLeft)({}, head, right);
+            return Result.IsExtendsTrueLike(check)
+                ? TryInferResults(tail, right, [...result, head])
+                : undefined;
+        })() : result);
+}
+function InferTupleResult(inferred, name, left, right) {
+    const results = TryInferResults(left, right);
+    return (index_3.Guard.IsArray(results)
+        ? Result.ExtendsTrue(index_2.Memory.Assign(inferred, { [name]: (0, tuple_1.Tuple)(results) }))
+        : Result.ExtendsFalse());
+}
+function InferUnionResult(inferred, name, left, right) {
+    const results = TryInferResults(left, right);
+    return (index_3.Guard.IsArray(results)
+        ? Result.ExtendsTrue(index_2.Memory.Assign(inferred, { [name]: (0, union_1.Union)(results) }))
+        : Result.ExtendsFalse());
+}

package/build/cjs/type/extends/integer.d.ts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TInteger } from '../types/integer';
+import { type TNumber } from '../types/number';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema> = (Right extends TInteger ? Result.TExtendsTrue<Inferred> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsInteger<Inferred extends TProperties, Left extends TInteger, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsInteger<Inferred, Left, Right>;

package/build/cjs/type/extends/integer.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsInteger = ExtendsInteger;
+const integer_1 = require("../types/integer");
+const number_1 = require("../types/number");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsInteger(inferred, left, right) {
+    return ((0, integer_1.IsInteger)(right) ? Result.ExtendsTrue(inferred) :
+        (0, number_1.IsNumber)(right) ? Result.ExtendsTrue(inferred) :
+            (0, extends_right_1.ExtendsRight)(inferred, left, right));
+}

package/build/cjs/type/extends/intersect.d.ts

@@ -0,0 +1,6 @@
+import { type TProperties } from '../types/properties';
+import { type TSchema } from '../types/schema';
+import { type TExtendsLeft } from './extends-left';
+import { type TEvaluateIntersect } from '../engine/evaluate/index';
+export type TExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema, Evaluated extends TSchema = TEvaluateIntersect<Left>> = TExtendsLeft<Inferred, Evaluated, Right>;
+export declare function ExtendsIntersect<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIntersect<Inferred, Left, Right>;

package/build/cjs/type/extends/intersect.js

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsIntersect = ExtendsIntersect;
+const extends_left_1 = require("./extends-left");
+// ----------------------------------------------------------------------------
+// ExtendsIntersect
+//
+// This function evaluates the intersection and continues. This is different
+// to IntersectRight which MUST enumerate each type to derive Inferred. Left 
+// side types do not infer so it should be ok to do this.
+//
+// ----------------------------------------------------------------------------
+const index_1 = require("../engine/evaluate/index");
+function ExtendsIntersect(inferred, left, right) {
+    const evaluated = (0, index_1.EvaluateIntersect)(left);
+    return (0, extends_left_1.ExtendsLeft)(inferred, evaluated, right);
+}

package/build/cjs/type/extends/iterator.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TIterator } from '../types/iterator';
+import { type TExtendsRight } from './extends-right';
+import { type TExtendsLeft } from './extends-left';
+export type TExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TIterator<Left>, Right>);
+export declare function ExtendsIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsIterator<Inferred, Left, Right>;

package/build/cjs/type/extends/iterator.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsIterator = ExtendsIterator;
+const iterator_1 = require("../types/iterator");
+const extends_right_1 = require("./extends-right");
+const extends_left_1 = require("./extends-left");
+function ExtendsIterator(inferred, left, right) {
+    return ((0, iterator_1.IsIterator)(right)
+        ? (0, extends_left_1.ExtendsLeft)(inferred, left, right.iteratorItems)
+        : (0, extends_right_1.ExtendsRight)(inferred, (0, iterator_1.Iterator)(left), right));
+}

package/build/cjs/type/extends/literal.d.ts

@@ -0,0 +1,17 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TLiteral, type TLiteralValue } from '../types/literal';
+import { type TBigInt } from '../types/bigint';
+import { type TBoolean } from '../types/boolean';
+import { type TNumber } from '../types/number';
+import { type TString } from '../types/string';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+type TExtendsLiteralValue<Inferred extends TProperties, Left extends TLiteralValue, Right extends TLiteralValue> = (Left extends Right ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
+type TExtendsLiteralBigInt<Inferred extends TProperties, Left extends bigint, Right extends TSchema> = (Right extends TLiteral<infer Value extends bigint> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBigInt ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralBoolean<Inferred extends TProperties, Left extends boolean, Right extends TSchema> = (Right extends TLiteral<infer Value extends boolean> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TBoolean ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralNumber<Inferred extends TProperties, Left extends number, Right extends TSchema> = (Right extends TLiteral<infer Value extends number> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TNumber ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+type TExtendsLiteralString<Inferred extends TProperties, Left extends string, Right extends TSchema> = (Right extends TLiteral<infer Value extends string> ? TExtendsLiteralValue<Inferred, Left, Value> : Right extends TString ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, TLiteral<Left>, Right>);
+export type TExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema> = (Left extends TLiteral<infer Value extends bigint> ? TExtendsLiteralBigInt<Inferred, Value, Right> : Left extends TLiteral<infer Value extends boolean> ? TExtendsLiteralBoolean<Inferred, Value, Right> : Left extends TLiteral<infer Value extends number> ? TExtendsLiteralNumber<Inferred, Value, Right> : Left extends TLiteral<infer Value extends string> ? TExtendsLiteralString<Inferred, Value, Right> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsLiteral<Inferred extends TProperties, Left extends TLiteral, Right extends TSchema>(inferred: TProperties, left: Left, right: Right): TExtendsLiteral<Inferred, Left, Right>;
+export {};

package/build/cjs/type/extends/literal.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsLiteral = ExtendsLiteral;
+const index_1 = require("../../guard/index");
+const literal_1 = require("../types/literal");
+const bigint_1 = require("../types/bigint");
+const boolean_1 = require("../types/boolean");
+const number_1 = require("../types/number");
+const string_1 = require("../types/string");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsLiteralValue(inferred, left, right) {
+    return (left === right
+        ? Result.ExtendsTrue(inferred)
+        : Result.ExtendsFalse());
+}
+function ExtendsLiteralBigInt(inferred, left, right) {
+    return ((0, literal_1.IsLiteral)(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        (0, bigint_1.IsBigInt)(right) ? Result.ExtendsTrue(inferred) :
+            (0, extends_right_1.ExtendsRight)(inferred, (0, literal_1.Literal)(left), right));
+}
+function ExtendsLiteralBoolean(inferred, left, right) {
+    return ((0, literal_1.IsLiteral)(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        (0, boolean_1.IsBoolean)(right) ? Result.ExtendsTrue(inferred) :
+            (0, extends_right_1.ExtendsRight)(inferred, (0, literal_1.Literal)(left), right));
+}
+function ExtendsLiteralNumber(inferred, left, right) {
+    return ((0, literal_1.IsLiteral)(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        (0, number_1.IsNumber)(right) ? Result.ExtendsTrue(inferred) :
+            (0, extends_right_1.ExtendsRight)(inferred, (0, literal_1.Literal)(left), right));
+}
+function ExtendsLiteralString(inferred, left, right) {
+    return ((0, literal_1.IsLiteral)(right) ? ExtendsLiteralValue(inferred, left, right.const) :
+        (0, string_1.IsString)(right) ? Result.ExtendsTrue(inferred) :
+            (0, extends_right_1.ExtendsRight)(inferred, (0, literal_1.Literal)(left), right));
+}
+function ExtendsLiteral(inferred, left, right) {
+    return (index_1.Guard.IsBigInt(left.const) ? ExtendsLiteralBigInt(inferred, left.const, right) :
+        index_1.Guard.IsBoolean(left.const) ? ExtendsLiteralBoolean(inferred, left.const, right) :
+            index_1.Guard.IsNumber(left.const) ? ExtendsLiteralNumber(inferred, left.const, right) :
+                index_1.Guard.IsString(left.const) ? ExtendsLiteralString(inferred, left.const, right) :
+                    (0, extends_right_1.ExtendsRight)(inferred, left, right));
+}

package/build/cjs/type/extends/never.d.ts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TNever } from '../types/never';
+import { type TInfer } from '../types/infer';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Result.TExtendsTrue<Inferred>);
+export declare function ExtendsNever<Inferred extends TProperties, Left extends TNever, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNever<Inferred, Left, Right>;

package/build/cjs/type/extends/never.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsNever = ExtendsNever;
+const infer_1 = require("../types/infer");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsNever(inferred, left, right) {
+    return ((0, infer_1.IsInfer)(right)
+        ? (0, extends_right_1.ExtendsRight)(inferred, left, right)
+        : Result.ExtendsTrue(inferred));
+}

package/build/cjs/type/extends/null.d.ts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TNull } from '../types/null';
+import { type TExtendsRight } from './extends-right';
+import * as Result from './result';
+export type TExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema> = (Right extends TNull ? Result.TExtendsTrue<Inferred> : TExtendsRight<Inferred, Left, Right>);
+export declare function ExtendsNull<Inferred extends TProperties, Left extends TNull, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsNull<Inferred, Left, Right>;

package/build/cjs/type/extends/null.js

@@ -0,0 +1,12 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsNull = ExtendsNull;
+const null_1 = require("../types/null");
+const extends_right_1 = require("./extends-right");
+const Result = require("./result");
+function ExtendsNull(inferred, left, right) {
+    return ((0, null_1.IsNull)(right)
+        ? Result.ExtendsTrue(inferred)
+        : (0, extends_right_1.ExtendsRight)(inferred, left, right));
+}