pi-proactive 0.2.0-beta.5 → 0.2.0-beta.7

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

@@ -1,49 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
-import { IsAny } from '../types/any.mjs';
-import { IsDependent } from '../types/dependent.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 { EvaluateEnum } from '../engine/evaluate/evaluate.mjs';
-import { EvaluateTemplateLiteral } from '../engine/evaluate/evaluate.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 ExtendsRightDependent(inferred, left, if_, then_, else_) {
-    return Result.Match(ExtendsLeft(inferred, left, if_), inferred => Result.Match(ExtendsLeft(inferred, left, then_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()), () => Result.Match(ExtendsLeft(inferred, left, else_), inferred => Result.ExtendsTrue(inferred), () => Result.ExtendsFalse()));
-}
-function ExtendsRightEnum(inferred, left, right) {
-    const evaluated = EvaluateEnum(right);
-    return ExtendsLeft(inferred, left, evaluated);
-}
-function ExtendsRightIntersect(inferred, left, right) {
-    return Guard.ShiftLeft(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 evaluated = EvaluateTemplateLiteral(right);
-    return ExtendsLeft(inferred, left, evaluated);
-}
-function ExtendsRightUnion(inferred, left, right) {
-    return Guard.ShiftLeft(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) :
-        IsDependent(right) ? ExtendsRightDependent(inferred, left, right.if, right.then, right.else) :
-            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

@@ -1,10 +0,0 @@
-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

@@ -1,17 +0,0 @@
-// 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

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

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

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

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

@@ -1,34 +0,0 @@
-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

@@ -1,62 +0,0 @@
-// 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.ShiftLeft(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

@@ -1,8 +0,0 @@
-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>;

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

@@ -1,10 +0,0 @@
-// deno-fmt-ignore-file
-import { IsInteger } from '../types/integer.mjs';
-import { IsNumber } from '../types/number.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-export function ExtendsInteger(inferred, left, right) {
-    return (IsInteger(right) ? Result.ExtendsTrue(inferred) :
-        IsNumber(right) ? Result.ExtendsTrue(inferred) :
-            ExtendsRight(inferred, left, right));
-}

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

@@ -1,6 +0,0 @@
-import { type TProperties } from '../types/properties.mjs';
-import { type TSchema } from '../types/schema.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-import { type TEvaluateIntersect } from '../engine/evaluate/index.mjs';
-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/node_modules/typebox/build/type/extends/intersect.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { ExtendsLeft } from './extends_left.mjs';
-// ----------------------------------------------------------------------------
-// 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.
-//
-// ----------------------------------------------------------------------------
-import { EvaluateIntersect } from '../engine/evaluate/index.mjs';
-export function ExtendsIntersect(inferred, left, right) {
-    const evaluated = EvaluateIntersect(left);
-    return ExtendsLeft(inferred, evaluated, right);
-}

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

@@ -1,18 +0,0 @@
-import { type TUnreachable } from '../../system/unreachable/unreachable.mjs';
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TLiteral, type TLiteralValue } from '../types/literal.mjs';
-import { type TBigInt } from '../types/bigint.mjs';
-import { type TBoolean } from '../types/boolean.mjs';
-import { type TNumber } from '../types/number.mjs';
-import { type TString } from '../types/string.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-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> : TUnreachable);
-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/node_modules/typebox/build/type/extends/literal.mjs

@@ -1,44 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Unreachable } from '../../system/unreachable/unreachable.mjs';
-import { IsLiteral, Literal } from '../types/literal.mjs';
-import { IsBigInt } from '../types/bigint.mjs';
-import { IsBoolean } from '../types/boolean.mjs';
-import { IsNumber } from '../types/number.mjs';
-import { IsString } from '../types/string.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-function ExtendsLiteralValue(inferred, left, right) {
-    return (left === right
-        ? Result.ExtendsTrue(inferred)
-        : Result.ExtendsFalse());
-}
-function ExtendsLiteralBigInt(inferred, left, right) {
-    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
-        IsBigInt(right) ? Result.ExtendsTrue(inferred) :
-            ExtendsRight(inferred, Literal(left), right));
-}
-function ExtendsLiteralBoolean(inferred, left, right) {
-    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
-        IsBoolean(right) ? Result.ExtendsTrue(inferred) :
-            ExtendsRight(inferred, Literal(left), right));
-}
-function ExtendsLiteralNumber(inferred, left, right) {
-    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
-        IsNumber(right) ? Result.ExtendsTrue(inferred) :
-            ExtendsRight(inferred, Literal(left), right));
-}
-function ExtendsLiteralString(inferred, left, right) {
-    return (IsLiteral(right) ? ExtendsLiteralValue(inferred, left, right.const) :
-        IsString(right) ? Result.ExtendsTrue(inferred) :
-            ExtendsRight(inferred, Literal(left), right));
-}
-export function ExtendsLiteral(inferred, left, right) {
-    return (Guard.IsBigInt(left.const) ? ExtendsLiteralBigInt(inferred, left.const, right) :
-        Guard.IsBoolean(left.const) ? ExtendsLiteralBoolean(inferred, left.const, right) :
-            Guard.IsNumber(left.const) ? ExtendsLiteralNumber(inferred, left.const, right) :
-                Guard.IsString(left.const) ? ExtendsLiteralString(inferred, left.const, right) :
-                    Unreachable() // ExtendsRight(inferred, left, right)
-    );
-}
-// deno-coverage-ignore-stop

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

@@ -1,8 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TNever } from '../types/never.mjs';
-import { type TInfer } from '../types/infer.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-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/node_modules/typebox/build/type/extends/never.mjs

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

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

@@ -1,7 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TNull } from '../types/null.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-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/node_modules/typebox/build/type/extends/null.mjs

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

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

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

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

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

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

@@ -1,32 +0,0 @@
-import { type TUnreachable } from '../../system/unreachable/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TSchema } from '../types/schema.mjs';
-import { type TOptional } from '../types/_optional.mjs';
-import { type TInfer } from '../types/infer.mjs';
-import { type TNever } from '../types/never.mjs';
-import { type TObject } from '../types/object.mjs';
-import { type TRecord } from '../types/record.mjs';
-import { type TUnion } from '../types/union.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-import { type TExtendsRight } from './extends_right.mjs';
-import { type TUnionToTuple } from '../engine/helpers/union.mjs';
-import * as Result from './result.mjs';
-type TExtendsPropertyOptional<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse : Result.TExtendsTrue<Inferred>);
-type TExtendsProperty<Inferred extends TProperties, Left extends TSchema, Right extends TSchema> = (Right extends TInfer<string, TNever> ? Result.TExtendsFalse : TExtendsLeft<Inferred, Left, Right> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsPropertyOptional<Inferred, Left, Right> : Result.TExtendsFalse);
-type TExtractInferredProperties<Keys extends PropertyKey[], Properties extends Record<PropertyKey, Result.TResult>, Result extends TProperties = {}> = (Keys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? Left extends keyof Properties ? Properties[Left] extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtractInferredProperties<Right, Properties, Result & Inferred> : TExtractInferredProperties<Right, Properties, Result> : TUnreachable : Result);
-type TExtendsPropertiesComparer<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Properties extends Record<PropertyKey, Result.TExtendsTrue | Result.TExtendsFalse> = {
-    [RightKey in keyof Right]: (RightKey extends keyof Left ? TExtendsProperty<{}, Left[RightKey], Right[RightKey]> : Right[RightKey] extends TOptional<Right[RightKey]> ? Right[RightKey] extends TInfer ? Result.TExtendsTrue<Memory.TAssign<Inferred, {
-        [_ in Right[RightKey]['name']]: Right[RightKey]['extends'];
-    }>> : Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
-}, Checked extends boolean = Properties[keyof Right] extends Result.TExtendsTrueLike ? true : false, Extracted extends TProperties = Checked extends true ? TExtractInferredProperties<TUnionToTuple<keyof Properties>, Properties> : {}> = (Checked extends true ? Result.TExtendsTrue<Extracted> : Result.TExtendsFalse);
-type TExtendsProperties<Inferred extends TProperties, Left extends TProperties, Right extends TProperties, Compared extends Result.TResult = TExtendsPropertiesComparer<Inferred, Left, Right>> = (Compared extends Result.TExtendsTrueLike<infer ComparedInferred extends TProperties> ? Result.TExtendsTrue<Memory.TAssign<Inferred, ComparedInferred>> : Result.TExtendsFalse);
-type TExtendsObjectToObject<Inferred extends TProperties, Left extends TProperties, Right extends TProperties> = (TExtendsProperties<Inferred, Left, Right>);
-type TRecordMergeInferred<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
-    [Key in keyof Right]: Key extends keyof Left ? Left[Key] extends TUnion<infer Types extends TSchema[]> ? TUnion<[...Types, Right[Key]]> : TUnion<[Left[Key], Right[Key]]> : Right[Key];
-}> = Result;
-type TExtendsRecordComparer<Properties extends TProperties, Keys extends (keyof Properties)[], Type extends TSchema, Result extends TProperties> = (Keys extends [infer Left extends (keyof Properties), ...infer Right extends (keyof Properties)[]] ? TExtendsLeft<{}, Properties[Left], Type> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsRecordComparer<Properties, Right, Type, TRecordMergeInferred<Result, Inferred>> : Result.TExtendsFalse : Result.TExtendsTrue<Result>);
-type TExtendsObjectToRecord<Inferred extends TProperties, Properties extends TProperties, _Pattern extends string, Value extends TSchema, Keys extends (keyof Properties)[] = TUnionToTuple<keyof Properties>, Result extends Result.TResult = TExtendsRecordComparer<Properties, Keys, Value, Inferred>> = Result;
-export type TExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TExtendsObjectToRecord<Inferred, Left, Pattern, Value> : Right extends TObject<infer Properties extends TProperties> ? TExtendsObjectToObject<Inferred, Left, Properties> : TExtendsRight<Inferred, TObject<Left>, Right>);
-export declare function ExtendsObject<Inferred extends TProperties, Left extends TProperties, Right extends TSchema>(inferred: Inferred, left: Left, right: Right): TExtendsObject<Inferred, Left, Right>;
-export {};

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

@@ -1,109 +0,0 @@
-// 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 { IsOptional } from '../types/_optional.mjs';
-import { IsInfer } from '../types/infer.mjs';
-import { IsNever } from '../types/never.mjs';
-import { IsObject, Object } from '../types/object.mjs';
-import { IsRecord, RecordPattern, RecordValue } from '../types/record.mjs';
-import { Union, IsUnion } from '../types/union.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-import { ExtendsRight } from './extends_right.mjs';
-import * as Result from './result.mjs';
-function ExtendsPropertyOptional(inferred, left, right) {
-    return (IsOptional(left)
-        ? IsOptional(right)
-            ? Result.ExtendsTrue(inferred)
-            : Result.ExtendsFalse()
-        : Result.ExtendsTrue(inferred));
-}
-function ExtendsProperty(inferred, left, right) {
-    return (
-    // Right TInfer<TNever> is TExtendsFalse
-    (IsInfer(right) && IsNever(right.extends))
-        ? Result.ExtendsFalse()
-        : Result.Match(ExtendsLeft(inferred, left, right), inferred => ExtendsPropertyOptional(inferred, left, right), () => Result.ExtendsFalse()));
-}
-function ExtractInferredProperties(keys, properties) {
-    return keys.reduce((result, key) => {
-        return key in properties
-            ? Result.IsExtendsTrueLike(properties[key])
-                // @ts-ignore 5.0.4 cannot see `.inferred`
-                ? { ...result, ...properties[key].inferred }
-                : Unreachable() // result
-            : Unreachable(); // result
-    }, {});
-}
-function ExtendsPropertiesComparer(inferred, left, right) {
-    const properties = {};
-    for (const rightKey of Guard.Keys(right)) {
-        properties[rightKey] = (rightKey in left
-            // We don't consider the exterior Inferred as part of the property check as
-            // we don't want the exterior Context to override the Inferred Context for
-            // the Property Key. This override behavior is observed in the following
-            // case we want the inferred A to shadow the exterior A.
-            //
-            // const A = Type.Script(`{ x: 1, y: 1 }`)
-            // const S = Type.Script({ A }, `{
-            //   [K in keyof A]: A extends { 
-            //     x: infer A, 
-            //     y: infer B 
-            //   } ? [A, B]   <-- inferred 'A' shadows the exterior 'A'
-            //     : never
-            // }`)
-            ? ExtendsProperty({}, left[rightKey], right[rightKey])
-            // If the right key K is not in left, but the right property is optional
-            // then we say this property is permissable. This is because an optional
-            // property on right is the same as property missing in left. If the
-            // right is infer, then we just assign the extend type to inferred.
-            : IsOptional(right[rightKey])
-                ? IsInfer(right[rightKey])
-                    // @ts-ignore 5.0.1 - cannot observe extend in right[rightKey].extends
-                    ? Result.ExtendsTrue(Memory.Assign(inferred, { [right[rightKey].name]: right[rightKey].extends }))
-                    : Result.ExtendsTrue(inferred)
-                : Result.ExtendsFalse());
-    }
-    // Check if all properties are ExtendsTrueLike
-    const checked = Guard.Values(properties).every(result => Result.IsExtendsTrueLike(result));
-    // Extract inferred results from properties, but only if the check is true.
-    const extracted = checked ? ExtractInferredProperties(Guard.Keys(properties), properties) : {};
-    return (checked
-        ? Result.ExtendsTrue(extracted)
-        : Result.ExtendsFalse());
-}
-function ExtendsProperties(inferred, left, right) {
-    const compared = ExtendsPropertiesComparer(inferred, left, right);
-    return (Result.IsExtendsTrueLike(compared)
-        ? Result.ExtendsTrue(Memory.Assign(inferred, compared.inferred))
-        : Result.ExtendsFalse());
-}
-function ExtendsObjectToObject(inferred, left, right) {
-    return ExtendsProperties(inferred, left, right);
-}
-function RecordMergeInferred(left, right) {
-    return Guard.Keys(right).reduce((result, key) => {
-        return {
-            ...result, [key]: Guard.HasPropertyKey(left, key)
-                ? IsUnion(result[key])
-                    // @ts-ignore 5.0.4 cannot see `.anyOf`
-                    ? Union([...result[key].anyOf, right[key]])
-                    : Union([left[key], right[key]])
-                : right[key]
-        };
-    }, left);
-}
-function ExtendsRecordComparer(properties, keys, type, result) {
-    return Guard.ShiftLeft(keys, (left, right) => Result.Match(ExtendsLeft({}, properties[left], type), inferred => ExtendsRecordComparer(properties, right, type, RecordMergeInferred(result, inferred)), () => Result.ExtendsFalse()), () => Result.ExtendsTrue(result));
-}
-function ExtendsObjectToRecord(inferred, properties, _pattern, value) {
-    const keys = Guard.Keys(properties);
-    const result = ExtendsRecordComparer(properties, keys, value, inferred);
-    return result;
-}
-export function ExtendsObject(inferred, left, right) {
-    return (IsRecord(right) ? ExtendsObjectToRecord(inferred, left, RecordPattern(right), RecordValue(right)) :
-        IsObject(right) ? ExtendsObjectToObject(inferred, left, right.properties) :
-            ExtendsRight(inferred, Object(left), right));
-}

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

@@ -1,15 +0,0 @@
-import { type TInfer } from '../types/infer.mjs';
-import { type TSchema } from '../types/schema.mjs';
-import { type TOptional } from '../types/_optional.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-import * as Result from './result.mjs';
-type TParameterCompare<Inferred extends TProperties, Left extends TSchema, LeftRest extends TSchema[], Right extends TSchema, RightRest extends TSchema[], CheckLeft extends TSchema = Right extends TInfer ? Left : Right, CheckRight extends TSchema = Right extends TInfer ? Right : Left, IsLeftOptional extends boolean = Left extends TOptional ? true : false, IsRightOptional extends boolean = Right extends TOptional ? true : false> = ([
-    IsLeftOptional,
-    IsRightOptional
-] extends [false, true] ? Result.TExtendsFalse : TExtendsLeft<Inferred, CheckLeft, CheckRight> extends Result.TExtendsTrueLike<infer Inferred extends TProperties> ? TExtendsParameters<Inferred, LeftRest, RightRest> : Result.TExtendsFalse);
-type TParameterRight<Inferred extends TProperties, Left extends TSchema, LeftRest extends TSchema[], RightRest extends TSchema[]> = (RightRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TParameterCompare<Inferred, Left, LeftRest, Head, Tail> : Left extends TOptional ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
-type TParameterLeft<Inferred extends TProperties, LeftRest extends TSchema[], RightRest extends TSchema[]> = (LeftRest extends [infer Head extends TSchema, ...infer Tail extends TSchema[]] ? TParameterRight<Inferred, Head, Tail, RightRest> : Result.TExtendsTrue<Inferred>);
-export type TExtendsParameters<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[]> = TParameterLeft<Inferred, Left, Right>;
-export declare function ExtendsParameters<Inferred extends TProperties, Left extends TSchema[], Right extends TSchema[]>(inferred: Inferred, left: Left, right: Right): TExtendsParameters<Inferred, Left, Right>;
-export {};

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

@@ -1,28 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsInfer } from '../types/infer.mjs';
-import { IsOptional } from '../types/_optional.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-import * as Result from './result.mjs';
-function ParameterCompare(inferred, left, leftRest, right, rightRest) {
-    // Parameter extends Right on Left, except when infer Right  
-    const checkLeft = IsInfer(right) ? left : right;
-    const checkRight = IsInfer(right) ? right : left;
-    const isLeftOptional = IsOptional(left);
-    const isRightOptional = IsOptional(right);
-    return ((!isLeftOptional && isRightOptional)
-        ? Result.ExtendsFalse() // 'fail: left-required-but-right-is-optional'
-        : Result.Match(ExtendsLeft(inferred, checkLeft, checkRight), inferred => ExtendsParameters(inferred, leftRest, rightRest), () => Result.ExtendsFalse()) // 'fail: left-and-right-did-not-match'
-    );
-}
-function ParameterRight(inferred, left, leftRest, rightRest) {
-    return Guard.ShiftLeft(rightRest, (head, tail) => ParameterCompare(inferred, left, leftRest, head, tail), () => IsOptional(left) // 'right-did-not-have-enough-elements'
-        ? Result.ExtendsTrue(inferred) // 'ok: left was optional'
-        : Result.ExtendsFalse()); // 'fail: left was required'
-}
-function ParametersLeft(inferred, left, rightRest) {
-    return Guard.ShiftLeft(left, (head, tail) => ParameterRight(inferred, head, tail, rightRest), () => Result.ExtendsTrue(inferred)); // 'ok: no-more-elements-in-left'
-}
-export function ExtendsParameters(inferred, left, right) {
-    return ParametersLeft(inferred, left, right);
-}

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

@@ -1,13 +0,0 @@
-import { type TSchema } from '../types/schema.mjs';
-import { type TProperties } from '../types/properties.mjs';
-import { type TAny } from '../types/any.mjs';
-import { type TUnknown } from '../types/unknown.mjs';
-import { type TObject } from '../types/object.mjs';
-import { type TRecordPatternToType, type TRecord } from '../types/record.mjs';
-import { type TExtendsLeft } from './extends_left.mjs';
-import * as Result from './result.mjs';
-export type TFromObject<Inferred extends TProperties, Properties extends TProperties> = keyof Properties extends never ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse;
-type TFromRecord<Inferred extends TProperties, _LeftKey extends TSchema, LeftValue extends TSchema, _RightKey extends TSchema, RightValue extends TSchema> = (TExtendsLeft<Inferred, LeftValue, RightValue>);
-export type TExtendsRecord<Inferred extends TProperties, LeftPattern extends string, LeftValue extends TSchema, Right extends TSchema> = (Right extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TFromRecord<Inferred, TRecordPatternToType<LeftPattern>, LeftValue, TRecordPatternToType<Pattern>, Value> : Right extends TObject<infer Properties extends TProperties> ? TFromObject<Inferred, Properties> : Right extends TAny ? Result.TExtendsTrue<Inferred> : Right extends TUnknown ? Result.TExtendsTrue<Inferred> : Result.TExtendsFalse);
-export declare function ExtendsRecord<Inferred extends TProperties, Pattern extends string, Value extends TSchema, Right extends TSchema>(inferred: Inferred, leftPattern: Pattern, leftValue: Value, right: Right): TExtendsRecord<Inferred, Pattern, Value, Right>;
-export {};

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

@@ -1,23 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsAny } from '../types/any.mjs';
-import { IsUnknown } from '../types/unknown.mjs';
-import { IsObject } from '../types/object.mjs';
-import { IsRecord, RecordPatternToType, RecordPattern, RecordValue } from '../types/record.mjs';
-import { ExtendsLeft } from './extends_left.mjs';
-import * as Result from './result.mjs';
-function FromObject(inferred, properties) {
-    return (Guard.IsEqual(Guard.Keys(properties).length, 0)
-        ? Result.ExtendsTrue(inferred)
-        : Result.ExtendsFalse());
-}
-function FromRecord(inferred, _leftKey, leftValue, _rightKey, rightValue) {
-    return ExtendsLeft(inferred, leftValue, rightValue);
-}
-export function ExtendsRecord(inferred, leftPattern, leftValue, right) {
-    return (IsRecord(right) ? FromRecord(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) :
-        IsObject(right) ? FromObject(inferred, right.properties) :
-            IsAny(right) ? Result.ExtendsTrue(inferred) :
-                IsUnknown(right) ? Result.ExtendsTrue(inferred) :
-                    Result.ExtendsFalse());
-}