pi-improve-interation 0.0.1

package/node_modules/typebox/build/type/engine/tuple/to_object.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+export type TTupleElementsToProperties<Types extends TSchema[], Result extends TProperties = {}> = (Types extends [...infer Left extends TSchema[], infer Right extends TSchema] ? TTupleElementsToProperties<Left, {
+    [_ in Left['length']]: Right;
+} & Result> : {
+    [Key in keyof Result]: Result[Key];
+});
+export declare function TupleElementsToProperties<Types extends TSchema[]>(types: [...Types]): TTupleElementsToProperties<Types>;
+export type TTupleToObject<Type extends TTuple, Properties extends TProperties = TTupleElementsToProperties<Type['items']>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function TupleToObject<Type extends TTuple>(type: Type): TTupleToObject<Type>;

package/node_modules/typebox/build/type/engine/tuple/to_object.mjs

@@ -0,0 +1,14 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Object } from '../../types/object.mjs';
+export function TupleElementsToProperties(types) {
+    const result = types.reduceRight((result, right, index) => {
+        return { [index]: right, ...result };
+    }, {});
+    return result;
+}
+export function TupleToObject(type) {
+    const properties = TupleElementsToProperties(type.items);
+    const result = Object(properties);
+    return result;
+}

package/node_modules/typebox/build/type/extends/any.d.mts

@@ -0,0 +1,9 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export type TExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema> = (Right extends TInfer ? TExtendsRight<Inferred, Left, Right> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsUnion<Inferred>);
+export declare function ExtendsAny<Inferred extends TProperties, Left extends TAny, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAny<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/any.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { IsInfer } from '../types/infer.mjs';
+import { IsAny } from '../types/any.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsAny(inferred, left, right) {
+    return (IsInfer(right) ? ExtendsRight(inferred, left, right) :
+        IsAny(right) ? Result.ExtendsTrue(inferred) :
+            IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                Result.ExtendsUnion(inferred));
+}

package/node_modules/typebox/build/type/extends/array.d.mts

@@ -0,0 +1,20 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TImmutable } from '../types/_immutable.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+type TExtendsImmutable<Left extends TSchema, Right extends TSchema, IsImmutableLeft extends boolean = Left extends TImmutable ? true : false, IsImmutableRight extends boolean = Right extends TImmutable ? true : false, Result extends boolean = [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [false, true] ? true : [
+    IsImmutableLeft,
+    IsImmutableRight
+] extends [true, false] ? false : true> = Result;
+export type TExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema> = (Right extends TArray<infer Type extends TSchema> ? TExtendsImmutable<ArrayLeft, Right> extends true ? TExtendsLeft<Inferred, Left, Type> : Result.TExtendsFalse : TExtendsRight<Inferred, ArrayLeft, Right>);
+export declare function ExtendsArray<Inferred extends TProperties, ArrayLeft extends TSchema, Left extends TSchema, Right extends TSchema>(inferred: Inferred, arrayLeft: ArrayLeft, left: Left, right: Right): TExtendsArray<Inferred, ArrayLeft, Left, Right>;
+export {};

package/node_modules/typebox/build/type/extends/array.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { IsArray } from '../types/array.mjs';
+import { IsImmutable } from '../types/_immutable.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+function ExtendsImmutable(left, right) {
+    const isImmutableLeft = IsImmutable(left);
+    const isImmutableRight = IsImmutable(right);
+    return (isImmutableLeft && isImmutableRight ? true :
+        !isImmutableLeft && isImmutableRight ? true :
+            isImmutableLeft && !isImmutableRight ? false :
+                true);
+}
+export function ExtendsArray(inferred, arrayLeft, left, right) {
+    return (IsArray(right)
+        ? ExtendsImmutable(arrayLeft, right)
+            ? ExtendsLeft(inferred, left, right.items)
+            : Result.ExtendsFalse()
+        : ExtendsRight(inferred, arrayLeft, right));
+}

package/node_modules/typebox/build/type/extends/async_iterator.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAsyncIterator } from '../types/async_iterator.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+export type TExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TAsyncIterator<infer Type extends TSchema> ? TExtendsLeft<Inferred, Left, Type> : TExtendsRight<Inferred, TAsyncIterator<Left>, Right>);
+export declare function ExtendsAsyncIterator<Inferred extends TProperties, Left extends TSchema, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsAsyncIterator<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/async_iterator.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { AsyncIterator, IsAsyncIterator } from '../types/async_iterator.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+export function ExtendsAsyncIterator(inferred, left, right) {
+    return (IsAsyncIterator(right)
+        ? ExtendsLeft(inferred, left, right.iteratorItems)
+        : ExtendsRight(inferred, AsyncIterator(left), right));
+}

package/node_modules/typebox/build/type/extends/bigint.d.mts

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

package/node_modules/typebox/build/type/extends/bigint.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsBigInt } from '../types/bigint.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsBigInt(inferred, left, right) {
+    return (IsBigInt(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/boolean.d.mts

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

package/node_modules/typebox/build/type/extends/boolean.mjs

@@ -0,0 +1,9 @@
+// deno-fmt-ignore-file
+import { IsBoolean } from '../types/boolean.mjs';
+import { ExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+export function ExtendsBoolean(inferred, left, right) {
+    return (IsBoolean(right)
+        ? Result.ExtendsTrue(inferred)
+        : ExtendsRight(inferred, left, right));
+}

package/node_modules/typebox/build/type/extends/constructor.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+import { type TExtendsParameters } from './parameters.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
+export type TExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TConstructor ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, InstanceType, Right['instanceType']> : Result.TExtendsFalse : Result.TExtendsFalse);
+export declare function ExtendsConstructor<Inferred extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, Right extends TSchema>(inferred: Inferred, parameters: [...Parameters], returnType: InstanceType, right: Right): TExtendsConstructor<Inferred, Parameters, InstanceType, Right>;

package/node_modules/typebox/build/type/extends/constructor.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { IsAny } from '../types/any.mjs';
+import { IsConstructor } from '../types/constructor.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+// ------------------------------------------------------------------
+// Parameters | ReturnType
+// ------------------------------------------------------------------ 
+import { ExtendsParameters } from './parameters.mjs';
+import { ExtendsReturnType } from './return_type.mjs';
+export function ExtendsConstructor(inferred, parameters, returnType, right) {
+    return (IsAny(right) ? Result.ExtendsTrue(inferred) :
+        IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+            IsConstructor(right) ? Result.Match(ExtendsParameters(inferred, parameters, right['parameters']), inferred => ExtendsReturnType(inferred, returnType, right['instanceType']), () => Result.ExtendsFalse()) // 'not-a-parameter-match'
+                : Result.ExtendsFalse() // 'not-a-constructor'
+    );
+}

package/node_modules/typebox/build/type/extends/enum.d.mts

@@ -0,0 +1,7 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TEnum } from '../types/enum.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TEnumToUnion } from '../engine/enum/index.mjs';
+export type TExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema> = (TExtendsLeft<Inferred, TEnumToUnion<Left>, Right>);
+export declare function ExtendsEnum<Inferred extends TProperties, Left extends TEnum, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsEnum<Inferred, Left, Right>;

package/node_modules/typebox/build/type/extends/enum.mjs

@@ -0,0 +1,6 @@
+// deno-fmt-ignore-file
+import { ExtendsLeft } from './extends_left.mjs';
+import { EnumToUnion } from '../engine/enum/index.mjs';
+export function ExtendsEnum(inferred, left, right) {
+    return ExtendsLeft(inferred, EnumToUnion(left), right);
+}

package/node_modules/typebox/build/type/extends/extends.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TCyclic } from '../types/cyclic.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TUnsafe } from '../types/unsafe.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TCyclicExtends } from '../engine/cyclic/index.mjs';
+type TCanonical<Type extends TSchema> = (Type extends TCyclic ? TCyclicExtends<Type> : Type extends TUnsafe ? TUnknown : 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, CanonicalLeft extends TSchema = TCanonical<Left>, CanonicalRight extends TSchema = TCanonical<Right>> = TExtendsLeft<Inferred, CanonicalLeft, CanonicalRight>;
+/** 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/node_modules/typebox/build/type/extends/extends.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { IsCyclic } from '../types/cyclic.mjs';
+import { Unknown } from '../types/unknown.mjs';
+import { IsUnsafe } from '../types/unsafe.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import { CyclicExtends } from '../engine/cyclic/index.mjs';
+function Canonical(type) {
+    return (IsCyclic(type) ? CyclicExtends(type) :
+        IsUnsafe(type) ? Unknown() :
+            type);
+}
+/** Performs a structural extends check on left and right types and yields inferred types on right if specified. */
+export function Extends(inferred, left, right) {
+    const canonicalLeft = Canonical(left);
+    const canonicalRight = Canonical(right);
+    return ExtendsLeft(inferred, canonicalLeft, canonicalRight);
+}

package/node_modules/typebox/build/type/extends/extends_left.d.mts

@@ -0,0 +1,55 @@
+import { type TExtendsAny } from './any.mjs';
+import { type TExtendsArray } from './array.mjs';
+import { type TExtendsAsyncIterator } from './async_iterator.mjs';
+import { type TExtendsBigInt } from './bigint.mjs';
+import { type TExtendsBoolean } from './boolean.mjs';
+import { type TExtendsConstructor } from './constructor.mjs';
+import { type TExtendsEnum } from './enum.mjs';
+import { type TExtendsFunction } from './function.mjs';
+import { type TExtendsInteger } from './integer.mjs';
+import { type TExtendsIntersect } from './intersect.mjs';
+import { type TExtendsIterator } from './iterator.mjs';
+import { type TExtendsLiteral } from './literal.mjs';
+import { type TExtendsNever } from './never.mjs';
+import { type TExtendsNull } from './null.mjs';
+import { type TExtendsNumber } from './number.mjs';
+import { type TExtendsObject } from './object.mjs';
+import { type TExtendsPromise } from './promise.mjs';
+import { type TExtendsString } from './string.mjs';
+import { type TExtendsSymbol } from './symbol.mjs';
+import { type TExtendsTemplateLiteral } from './template_literal.mjs';
+import { type TExtendsTuple } from './tuple.mjs';
+import { type TExtendsUndefined } from './undefined.mjs';
+import { type TExtendsUnion } from './union.mjs';
+import { type TExtendsUnknown } from './unknown.mjs';
+import { type TExtendsVoid } from './void.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TAsyncIterator } from '../types/async_iterator.mjs';
+import { type TBigInt } from '../types/bigint.mjs';
+import { type TBoolean } from '../types/boolean.mjs';
+import { type TConstructor } from '../types/constructor.mjs';
+import { type TEnum, type TEnumValue } from '../types/enum.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TInteger } from '../types/integer.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TIterator } from '../types/iterator.mjs';
+import { type TLiteral } from '../types/literal.mjs';
+import { type TNever } from '../types/never.mjs';
+import { type TNull } from '../types/null.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TObject } from '../types/object.mjs';
+import { type TPromise } from '../types/promise.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TString } from '../types/string.mjs';
+import { type TSymbol } from '../types/symbol.mjs';
+import { type TTemplateLiteral } from '../types/template_literal.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TUndefined } from '../types/undefined.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TVoid } from '../types/void.mjs';
+import * as Result from './result.mjs';
+export type TExtendsLeft<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TAny ? TExtendsAny<Inferred, Left, Right> : Left extends TArray<infer Items extends TSchema> ? TExtendsArray<Inferred, Left, Items, 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/node_modules/typebox/build/type/extends/extends_left.mjs

@@ -0,0 +1,83 @@
+// deno-fmt-ignore-file
+import { ExtendsAny } from './any.mjs';
+import { ExtendsArray } from './array.mjs';
+import { ExtendsAsyncIterator } from './async_iterator.mjs';
+import { ExtendsBigInt } from './bigint.mjs';
+import { ExtendsBoolean } from './boolean.mjs';
+import { ExtendsConstructor } from './constructor.mjs';
+import { ExtendsEnum } from './enum.mjs';
+import { ExtendsFunction } from './function.mjs';
+import { ExtendsInteger } from './integer.mjs';
+import { ExtendsIntersect } from './intersect.mjs';
+import { ExtendsIterator } from './iterator.mjs';
+import { ExtendsLiteral } from './literal.mjs';
+import { ExtendsNever } from './never.mjs';
+import { ExtendsNull } from './null.mjs';
+import { ExtendsNumber } from './number.mjs';
+import { ExtendsObject } from './object.mjs';
+import { ExtendsPromise } from './promise.mjs';
+import { ExtendsString } from './string.mjs';
+import { ExtendsSymbol } from './symbol.mjs';
+import { ExtendsTemplateLiteral } from './template_literal.mjs';
+import { ExtendsTuple } from './tuple.mjs';
+import { ExtendsUndefined } from './undefined.mjs';
+import { ExtendsUnion } from './union.mjs';
+import { ExtendsUnknown } from './unknown.mjs';
+import { ExtendsVoid } from './void.mjs';
+// ----------------------------------------------------------------------------
+// Types
+// ----------------------------------------------------------------------------
+import { IsAny } from '../types/any.mjs';
+import { IsArray } from '../types/array.mjs';
+import { IsAsyncIterator } from '../types/async_iterator.mjs';
+import { IsBigInt } from '../types/bigint.mjs';
+import { IsBoolean } from '../types/boolean.mjs';
+import { IsConstructor } from '../types/constructor.mjs';
+import { IsEnum } from '../types/enum.mjs';
+import { IsFunction } from '../types/function.mjs';
+import { IsInteger } from '../types/integer.mjs';
+import { IsIntersect } from '../types/intersect.mjs';
+import { IsIterator } from '../types/iterator.mjs';
+import { IsLiteral } from '../types/literal.mjs';
+import { IsNever } from '../types/never.mjs';
+import { IsNull } from '../types/null.mjs';
+import { IsNumber } from '../types/number.mjs';
+import { IsObject } from '../types/object.mjs';
+import { IsPromise } from '../types/promise.mjs';
+import { IsString } from '../types/string.mjs';
+import { IsSymbol } from '../types/symbol.mjs';
+import { IsTemplateLiteral } from '../types/template_literal.mjs';
+import { IsTuple } from '../types/tuple.mjs';
+import { IsUndefined } from '../types/undefined.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { IsUnion } from '../types/union.mjs';
+import { IsVoid } from '../types/void.mjs';
+import * as Result from './result.mjs';
+export function ExtendsLeft(inferred, left, right) {
+    return (IsAny(left) ? ExtendsAny(inferred, left, right) :
+        IsArray(left) ? ExtendsArray(inferred, left, left.items, right) :
+            IsAsyncIterator(left) ? ExtendsAsyncIterator(inferred, left.iteratorItems, right) :
+                IsBigInt(left) ? ExtendsBigInt(inferred, left, right) :
+                    IsBoolean(left) ? ExtendsBoolean(inferred, left, right) :
+                        IsConstructor(left) ? ExtendsConstructor(inferred, left.parameters, left.instanceType, right) :
+                            IsEnum(left) ? ExtendsEnum(inferred, left, right) :
+                                IsFunction(left) ? ExtendsFunction(inferred, left.parameters, left.returnType, right) :
+                                    IsInteger(left) ? ExtendsInteger(inferred, left, right) :
+                                        IsIntersect(left) ? ExtendsIntersect(inferred, left.allOf, right) :
+                                            IsIterator(left) ? ExtendsIterator(inferred, left.iteratorItems, right) :
+                                                IsLiteral(left) ? ExtendsLiteral(inferred, left, right) :
+                                                    IsNever(left) ? ExtendsNever(inferred, left, right) :
+                                                        IsNull(left) ? ExtendsNull(inferred, left, right) :
+                                                            IsNumber(left) ? ExtendsNumber(inferred, left, right) :
+                                                                IsObject(left) ? ExtendsObject(inferred, left.properties, right) :
+                                                                    IsPromise(left) ? ExtendsPromise(inferred, left.item, right) :
+                                                                        IsString(left) ? ExtendsString(inferred, left, right) :
+                                                                            IsSymbol(left) ? ExtendsSymbol(inferred, left, right) :
+                                                                                IsTemplateLiteral(left) ? ExtendsTemplateLiteral(inferred, left.pattern, right) :
+                                                                                    IsTuple(left) ? ExtendsTuple(inferred, left.items, right) :
+                                                                                        IsUndefined(left) ? ExtendsUndefined(inferred, left, right) :
+                                                                                            IsUnion(left) ? ExtendsUnion(inferred, left.anyOf, right) :
+                                                                                                IsUnknown(left) ? ExtendsUnknown(inferred, left, right) :
+                                                                                                    IsVoid(left) ? ExtendsVoid(inferred, left, right) :
+                                                                                                        Result.ExtendsFalse());
+}

package/node_modules/typebox/build/type/extends/extends_right.d.mts

@@ -0,0 +1,25 @@
+import { Memory } from '../../system/memory/index.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TEnum, type TEnumValue } from '../types/enum.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TIntersect } from '../types/intersect.mjs';
+import { type TTemplateLiteral } from '../types/template_literal.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+import { type TTemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+import { type TEnumValuesToUnion } from '../engine/enum/index.mjs';
+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/node_modules/typebox/build/type/extends/extends_right.mjs

@@ -0,0 +1,44 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsAny } from '../types/any.mjs';
+import { IsEnum } from '../types/enum.mjs';
+import { IsInfer } from '../types/infer.mjs';
+import { IsIntersect } from '../types/intersect.mjs';
+import { IsTemplateLiteral } from '../types/template_literal.mjs';
+import { IsUnion } from '../types/union.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import * as Result from './result.mjs';
+import { TemplateLiteralDecode } from '../engine/template_literal/decode.mjs';
+import { EnumValuesToUnion } from '../engine/enum/index.mjs';
+function ExtendsRightInfer(inferred, name, left, right) {
+    return Result.Match(ExtendsLeft(inferred, left, right), checkInferred => Result.ExtendsTrue(Memory.Assign(Memory.Assign(inferred, checkInferred), { [name]: left })), () => Result.ExtendsFalse());
+}
+function ExtendsRightAny(inferred, _left) {
+    return Result.ExtendsTrue(inferred);
+}
+function ExtendsRightEnum(inferred, left, right) {
+    const union = EnumValuesToUnion(right);
+    return ExtendsLeft(inferred, left, union);
+}
+function ExtendsRightIntersect(inferred, left, right) {
+    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => ExtendsRightIntersect(inferred, left, tail), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(inferred));
+}
+function ExtendsRightTemplateLiteral(inferred, left, right) {
+    const decoded = TemplateLiteralDecode(right);
+    return ExtendsLeft(inferred, left, decoded);
+}
+function ExtendsRightUnion(inferred, left, right) {
+    return Guard.TakeLeft(right, (head, tail) => Result.Match(ExtendsLeft(inferred, left, head), inferred => Result.ExtendsTrue(inferred), () => ExtendsRightUnion(inferred, left, tail)), () => Result.ExtendsFalse());
+}
+export function ExtendsRight(inferred, left, right) {
+    return (IsAny(right) ? ExtendsRightAny(inferred, left) :
+        IsEnum(right) ? ExtendsRightEnum(inferred, left, right.enum) :
+            IsInfer(right) ? ExtendsRightInfer(inferred, right.name, left, right.extends) :
+                IsIntersect(right) ? ExtendsRightIntersect(inferred, left, right.allOf) :
+                    IsTemplateLiteral(right) ? ExtendsRightTemplateLiteral(inferred, left, right.pattern) :
+                        IsUnion(right) ? ExtendsRightUnion(inferred, left, right.anyOf) :
+                            IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+                                Result.ExtendsFalse());
+}

package/node_modules/typebox/build/type/extends/function.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TAny } from '../types/any.mjs';
+import { type TFunction } from '../types/function.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+import { type TExtendsParameters } from './parameters.mjs';
+import { type TExtendsReturnType } from './return_type.mjs';
+export type TExtendsFunction<Inferred extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, Right extends TSchema> = (Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Right extends TFunction ? TExtendsParameters<Inferred, Parameters, Right['parameters']> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsReturnType<Inferred, ReturnType, Right['returnType']> : 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/node_modules/typebox/build/type/extends/function.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { IsAny } from '../types/any.mjs';
+import { IsFunction } from '../types/function.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import * as Result from './result.mjs';
+// ------------------------------------------------------------------
+// Parameters | ReturnType
+// ------------------------------------------------------------------ 
+import { ExtendsParameters } from './parameters.mjs';
+import { ExtendsReturnType } from './return_type.mjs';
+export function ExtendsFunction(inferred, parameters, returnType, right) {
+    return (IsAny(right) ? Result.ExtendsTrue(inferred) :
+        IsUnknown(right) ? Result.ExtendsTrue(inferred) :
+            IsFunction(right) ? Result.Match(ExtendsParameters(inferred, parameters, right['parameters']), inferred => ExtendsReturnType(inferred, returnType, right['returnType']), () => Result.ExtendsFalse()) // 'not-a-parameter-match'
+                : Result.ExtendsFalse() // 'not-a-function'
+    );
+}

package/node_modules/typebox/build/type/extends/index.d.mts

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

package/node_modules/typebox/build/type/extends/index.mjs

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

package/node_modules/typebox/build/type/extends/inference.d.mts

@@ -0,0 +1,34 @@
+import { type TUnreachable } from '../../system/unreachable/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { type TSchema } from '../types/schema.mjs';
+import { type TArray } from '../types/array.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TTuple } from '../types/tuple.mjs';
+import { type TExtendsLeft } from './extends_left.mjs';
+import { type TUnion } from '../types/union.mjs';
+import { type TInfer } from '../types/infer.mjs';
+import { type TRest } from '../types/rest.mjs';
+import * as Result from './result.mjs';
+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 ? 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/node_modules/typebox/build/type/extends/inference.mjs

@@ -0,0 +1,62 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Unreachable } from '../../system/unreachable/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsArray } from '../types/array.mjs';
+import { IsUnknown } from '../types/unknown.mjs';
+import { Tuple } from '../types/tuple.mjs';
+import { ExtendsLeft } from './extends_left.mjs';
+import { Union } from '../types/union.mjs';
+// ----------------------------------------------------------------------------
+// Operator
+// ----------------------------------------------------------------------------
+import { IsInfer } from '../types/infer.mjs';
+import { IsRest } from '../types/rest.mjs';
+import * as Result from './result.mjs';
+// ----------------------------------------------------------------------------
+// Factory
+// ----------------------------------------------------------------------------
+export function Inferrable(name, type) {
+    return Memory.Create({ '~kind': 'Inferrable' }, { name, type }, {});
+}
+// ----------------------------------------------------------------------------
+// Guard
+// ----------------------------------------------------------------------------
+export function IsInferable(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, '~kind')
+        && Guard.HasPropertyKey(value, 'name')
+        && Guard.HasPropertyKey(value, 'type')
+        && Guard.IsEqual(value["~kind"], 'Inferrable')
+        && Guard.IsString(value.name)
+        && Guard.IsObject(value.type);
+}
+export function TryRestInferable(type) {
+    return (IsRest(type)
+        ? IsInfer(type.items)
+            ? IsArray(type.items.extends) ? Inferrable(type.items.name, type.items.extends.items) :
+                IsUnknown(type.items.extends) ? Inferrable(type.items.name, type.items.extends) :
+                    undefined
+            : Unreachable() // undefined
+        : undefined);
+}
+export function TryInferable(type) {
+    return (IsInfer(type) ? Inferrable(type.name, type.extends) :
+        undefined);
+}
+function TryInferResults(rest, right, result = []) {
+    return Guard.TakeLeft(rest, (head, tail) => Result.Match(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => undefined), () => result);
+}
+export function InferTupleResult(inferred, name, left, right) {
+    const results = TryInferResults(left, right);
+    return (Guard.IsArray(results)
+        ? Result.ExtendsTrue(Memory.Assign(inferred, { [name]: Tuple(results) }))
+        : Result.ExtendsFalse());
+}
+export function InferUnionResult(inferred, name, left, right) {
+    const results = TryInferResults(left, right);
+    return (Guard.IsArray(results)
+        ? Result.ExtendsTrue(Memory.Assign(inferred, { [name]: Union(results) }))
+        : Result.ExtendsFalse());
+}

package/node_modules/typebox/build/type/extends/integer.d.mts

@@ -0,0 +1,8 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TInteger } from '../types/integer.mjs';
+import { type TNumber } from '../types/number.mjs';
+import { type TExtendsRight } from './extends_right.mjs';
+import * as Result from './result.mjs';
+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>;