pi-proactive 0.2.0-beta.3 → 0.2.0-beta.4

package/node_modules/typebox/build/type/script/token/unsigned_integer.mjs

@@ -1,26 +0,0 @@
-// deno-coverage-ignore-start - parsebox tested
-// deno-fmt-ignore-file
-import { Match } from './internal/match.mjs';
-import { Trim } from './internal/trim.mjs';
-import { Take } from './internal/take.mjs';
-import { Many } from './internal/many.mjs';
-import { Digit } from './internal/char.mjs';
-import { Zero } from './internal/char.mjs';
-import { NonZero } from './internal/char.mjs';
-import { UnderScore } from './internal/char.mjs';
-function TakeNonZero(input) {
-    return Take(NonZero, input);
-}
-const AllowedDigits = [...Digit, UnderScore];
-function TakeDigits(input) {
-    return Many(AllowedDigits, [UnderScore], input);
-}
-function TakeUnsignedInteger(input) {
-    return Match(Take([Zero], input), (Zero, ZeroRest) => [Zero, ZeroRest], () => Match(TakeNonZero(input), (NonZero, NonZeroRest) => Match(TakeDigits(NonZeroRest), (Digits, DigitsRest) => [`${NonZero}${Digits}`, DigitsRest], () => []), // fail: did not match Digits
-    () => [])); // fail: did not match NonZero
-}
-/** Matches if next is a UnsignedInteger */
-export function UnsignedInteger(input) {
-    return TakeUnsignedInteger(Trim(input));
-}
-// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/unsigned_number.d.mts

@@ -1,17 +0,0 @@
-import { type TTrim } from './internal/trim.mjs';
-import { type TTake } from './internal/take.mjs';
-import { type TMany } from './internal/many.mjs';
-import { type TDigit, type TUnderScore } from './internal/char.mjs';
-import { type TDot } from './internal/char.mjs';
-import { type TUnsignedInteger } from './unsigned_integer.mjs';
-type TAllowedDigits = [...TDigit, TUnderScore];
-type TIsLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [string, string] ? true : false);
-type TTakeFractional<Input extends string> = (TMany<TAllowedDigits, [TUnderScore], Input> extends [infer Digits extends string, infer DigitsRest extends string] ? Digits extends '' ? [] : [Digits, DigitsRest] : []);
-type TLeadingDot<Input extends string> = (TTake<[TDot], Input> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`0${Dot}${Fractional}`, FractionalRest] : [] : []);
-type TLeadingInteger<Input extends string> = (TUnsignedInteger<Input> extends [infer Integer extends string, infer IntegerRest extends string] ? TTake<[TDot], IntegerRest> extends [infer Dot extends string, infer DotRest extends string] ? TTakeFractional<DotRest> extends [infer Fractional extends string, infer FractionalRest extends string] ? [`${Integer}${Dot}${Fractional}`, FractionalRest] : [`${Integer}`, DotRest] : [`${Integer}`, IntegerRest] : []);
-type TTakeUnsignedNumber<Input extends string> = (TIsLeadingDot<Input> extends true ? TLeadingDot<Input> : TLeadingInteger<Input>);
-/** Matches if next is a UnsignedNumber */
-export type TUnsignedNumber<Input extends string> = (TTakeUnsignedNumber<TTrim<Input>>);
-/** Matches if next is a UnsignedNumber */
-export declare function UnsignedNumber<Input extends string>(input: Input): TUnsignedNumber<Input>;
-export {};

package/node_modules/typebox/build/type/script/token/unsigned_number.mjs

@@ -1,38 +0,0 @@
-// deno-coverage-ignore-start - parsebox tested
-// deno-fmt-ignore-file
-import { IsEqual } from './internal/guard.mjs';
-import { IsMatch, Match } from './internal/match.mjs';
-import { Trim } from './internal/trim.mjs';
-import { Take } from './internal/take.mjs';
-import { Many } from './internal/many.mjs';
-import { Digit, UnderScore } from './internal/char.mjs';
-import { Dot } from './internal/char.mjs';
-import { UnsignedInteger } from './unsigned_integer.mjs';
-const AllowedDigits = [...Digit, UnderScore];
-function IsLeadingDot(input) {
-    return IsMatch(Take([Dot], input));
-}
-function TakeFractional(input) {
-    return Match(Many(AllowedDigits, [UnderScore], input), (Digits, DigitsRest) => IsEqual(Digits, '')
-        ? [] // fail: no Digits
-        : [Digits, DigitsRest], () => []); // fail: did not match Digits
-}
-function LeadingDot(input) {
-    return Match(Take([Dot], input), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`0${Dot}${Fractional}`, FractionalRest], () => []), // fail: did not match Fractional
-    () => []); // fail: did not match Dot
-}
-function LeadingInteger(input) {
-    return Match(UnsignedInteger(input), (Integer, IntegerRest) => Match(Take([Dot], IntegerRest), (Dot, DotRest) => Match(TakeFractional(DotRest), (Fractional, FractionalRest) => [`${Integer}${Dot}${Fractional}`, FractionalRest], () => [`${Integer}`, DotRest]), // fail: did not match Fractional, use Integer
-    () => [`${Integer}`, IntegerRest]), // fail: did not match Dot, use Integer
-    () => []); // fail: did not match Integer
-}
-function TakeUnsignedNumber(input) {
-    return (IsLeadingDot(input)
-        ? LeadingDot(input)
-        : LeadingInteger(input));
-}
-/** Matches if next is a UnsignedNumber */
-export function UnsignedNumber(input) {
-    return TakeUnsignedNumber(Trim(input));
-}
-// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/until.d.mts

@@ -1,7 +0,0 @@
-type TTakeOne<Input extends string> = (Input extends `${infer Left extends string}${infer Right extends string}` ? [Left, Right] : []);
-type TIsInputMatchSentinal<End extends string[], Input extends string> = (End extends [infer Left extends string, ...infer Right extends string[]] ? Input extends `${Left}${string}` ? true : TIsInputMatchSentinal<Right, Input> : false);
-/** Match Input until but not including End. No match if End not found. */
-export type TUntil<End extends string[], Input extends string, Result extends string = ''> = (TTakeOne<Input> extends [infer One extends string, infer Rest extends string] ? TIsInputMatchSentinal<End, Input> extends true ? [Result, Input] : TUntil<End, Rest, `${Result}${One}`> : []);
-/** Match Input until but not including End. No match if End not found. */
-export declare function Until<End extends string[], Input extends string>(end: [...End], input: Input, result?: string): TUntil<End, Input>;
-export {};

package/node_modules/typebox/build/type/script/token/until.mjs

@@ -1,21 +0,0 @@
-// deno-coverage-ignore-start - parsebox tested
-// deno-fmt-ignore-file
-import { Match } from './internal/match.mjs';
-import { IsEqual, ShiftLeft } from './internal/guard.mjs';
-function TakeOne(input) {
-    const result = IsEqual(input, '') ? [] : [input.slice(0, 1), input.slice(1)];
-    return result;
-}
-function IsInputMatchSentinal(end, input) {
-    return ShiftLeft(end, (left, right) => input.startsWith(left)
-        ? true
-        : IsInputMatchSentinal(right, input), () => false);
-}
-/** Match Input until but not including End. No match if End not found. */
-export function Until(end, input, result = '') {
-    return Match(TakeOne(input), (One, Rest) => IsInputMatchSentinal(end, input)
-        ? [result, input] // ok: at sentinal 
-        : Until(end, Rest, `${result}${One}`) // fail: advance + 1
-    , () => []);
-}
-// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/script/token/until_1.d.mts

@@ -1,5 +0,0 @@
-import { type TUntil } from './until.mjs';
-/** Match Input until but not including End. No match if End not found or match is zero-length. */
-export type TUntil_1<End extends string[], Input extends string> = (TUntil<End, Input> extends [infer Until extends string, infer UntilRest extends string] ? Until extends '' ? [] : [Until, UntilRest] : []);
-/** Match Input until but not including End. No match if End not found or match is zero-length. */
-export declare function Until_1<End extends string[], Input extends string>(end: [...End], input: Input): TUntil_1<End, Input>;

package/node_modules/typebox/build/type/script/token/until_1.mjs

@@ -1,12 +0,0 @@
-// deno-coverage-ignore-start - parsebox tested
-// deno-fmt-ignore-file
-import { IsEqual } from './internal/guard.mjs';
-import { Match } from './internal/match.mjs';
-import { Until } from './until.mjs';
-/** Match Input until but not including End. No match if End not found or match is zero-length. */
-export function Until_1(end, input) {
-    return Match(Until(end, input), (Until, UntilRest) => IsEqual(Until, '')
-        ? [] // fail: match has no characters
-        : [Until, UntilRest], () => []); // fail: did not match Until
-}
-// deno-coverage-ignore-stop

package/node_modules/typebox/build/type/types/_codec.d.mts

@@ -1,30 +0,0 @@
-import { type StaticDirection, type StaticDecode, type StaticType } from './static.mjs';
-import { type TSchema } from './schema.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticCodec<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Decoded extends unknown> = (Direction extends 'Decode' ? Decoded : StaticType<Stack, Direction, Context, This, Omit<Type, '~codec'>>);
-export type TDecodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Encoded) => Decoded;
-export type TEncodeCallback<Encoded extends unknown, Decoded = unknown> = (input: Decoded) => Encoded;
-export type TCodec<Type extends TSchema = TSchema, Decoded extends unknown = unknown> = Type & {
-    '~codec': {
-        encode: TDecodeCallback<unknown, Decoded>;
-        decode: TEncodeCallback<unknown, Decoded>;
-    };
-};
-export declare class EncodeBuilder<Type extends TSchema, Encoded extends unknown, Decoded extends unknown> {
-    private readonly type;
-    private readonly decode;
-    constructor(type: Type, decode: globalThis.Function);
-    Encode(callback: TEncodeCallback<Encoded, Decoded>): TCodec<Type, Decoded>;
-}
-export declare class DecodeBuilder<Type extends TSchema, Encoded extends unknown> {
-    private readonly type;
-    constructor(type: Type);
-    Decode<Callback extends TDecodeCallback<Encoded, unknown>>(callback: Callback): EncodeBuilder<Type, Encoded, ReturnType<Callback>>;
-}
-/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
-export declare function Codec<Type extends TSchema>(type: Type): DecodeBuilder<Type, StaticDecode<Type>>;
-/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
-export declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<StaticDecode<Type>, unknown>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
-/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
-export declare function Encode<Type extends TSchema>(type: Type, callback: TEncodeCallback<StaticDecode<Type>, unknown>): TCodec<Type, unknown>;
-export declare function IsCodec(value: unknown): value is TCodec;

package/node_modules/typebox/build/type/types/_codec.mjs

@@ -1,60 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-export class EncodeBuilder {
-    constructor(type, decode) {
-        this.type = type;
-        this.decode = decode;
-    }
-    Encode(callback) {
-        const type = this.type;
-        const decode = IsCodec(type) ? (value) => this.decode(type['~codec'].decode(value)) : this.decode;
-        const encode = IsCodec(type) ? (value) => type['~codec'].encode(callback(value)) : callback;
-        const codec = { decode, encode };
-        return Memory.Update(this.type, { '~codec': codec }, {});
-    }
-}
-export class DecodeBuilder {
-    constructor(type) {
-        this.type = type;
-    }
-    Decode(callback) {
-        return new EncodeBuilder(this.type, callback);
-    }
-}
-// ------------------------------------------------------------------
-// Bidirectional
-// ------------------------------------------------------------------
-/** Creates a bi-directional Codec. Codec functions are called on Value.Decode and Value.Encode. */
-export function Codec(type) {
-    return new DecodeBuilder(type);
-}
-// ------------------------------------------------------------------
-// Unidirectional
-// ------------------------------------------------------------------
-/** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
-export function Decode(type, callback) {
-    return Codec(type).Decode(callback).Encode(() => {
-        throw Error('Encode not implemented');
-    });
-}
-/** Creates a uni-directional Codec with Encode only. The Encode function is called on Value.Encode */
-export function Encode(type, callback) {
-    return Codec(type).Decode(() => {
-        throw Error('Decode not implemented');
-    }).Encode(callback);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-export function IsCodec(value) {
-    return IsSchema(value) &&
-        Guard.HasPropertyKey(value, '~codec') &&
-        Guard.IsObject(value['~codec']) &&
-        Guard.HasPropertyKey(value['~codec'], 'encode') &&
-        Guard.HasPropertyKey(value['~codec'], 'decode');
-}

package/node_modules/typebox/build/type/types/_immutable.d.mts

@@ -1,9 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type TAddImmutable } from '../action/_add_immutable.mjs';
-export type TImmutable<Type extends TSchema = TSchema> = (Type & {
-    '~immutable': true;
-});
-/** Applies an Immutable modifier to the given type. */
-export declare function Immutable<Type extends TSchema>(type: Type): TAddImmutable<Type>;
-/** Returns true if the given value is a TImmutable */
-export declare function IsImmutable(value: unknown): value is TImmutable<TSchema>;

package/node_modules/typebox/build/type/types/_immutable.mjs

@@ -1,18 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-import { AddImmutable } from '../action/_add_immutable.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Applies an Immutable modifier to the given type. */
-export function Immutable(type) {
-    return AddImmutable(type);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TImmutable */
-export function IsImmutable(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, '~immutable');
-}

package/node_modules/typebox/build/type/types/_optional.d.mts

@@ -1,9 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type TAddOptional } from '../action/_add_optional.mjs';
-export type TOptional<Type extends TSchema = TSchema> = (Type & {
-    '~optional': true;
-});
-/** Applies an Optional modifier to the given type. */
-export declare function Optional<Type extends TSchema>(type: Type): TAddOptional<Type>;
-/** Returns true if the given value is TOptional */
-export declare function IsOptional(value: unknown): value is TOptional<TSchema>;

package/node_modules/typebox/build/type/types/_optional.mjs

@@ -1,18 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-import { AddOptional } from '../action/_add_optional.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Applies an Optional modifier to the given type. */
-export function Optional(type) {
-    return AddOptional(type);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TOptional */
-export function IsOptional(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, '~optional');
-}

package/node_modules/typebox/build/type/types/_readonly.d.mts

@@ -1,9 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type TAddReadonly } from '../action/_add_readonly.mjs';
-export type TReadonly<Type extends TSchema = TSchema> = (Type & {
-    '~readonly': true;
-});
-/** Applies an Readonly property modifier to the given type. */
-export declare function Readonly<Type extends TSchema>(type: Type): TAddReadonly<Type>;
-/** Returns true if the given value is a TReadonly */
-export declare function IsReadonly(value: unknown): value is TReadonly<TSchema>;

package/node_modules/typebox/build/type/types/_readonly.mjs

@@ -1,18 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-import { AddReadonly } from '../action/_add_readonly.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Applies an Readonly property modifier to the given type. */
-export function Readonly(type) {
-    return AddReadonly(type);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TReadonly */
-export function IsReadonly(value) {
-    return IsSchema(value) && Guard.HasPropertyKey(value, '~readonly');
-}

package/node_modules/typebox/build/type/types/_refine.d.mts

@@ -1,24 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type Static } from './static.mjs';
-/** Applies a Refine check to the given type. */
-export type TRefineAdd<Type extends TSchema = TSchema> = ('~refine' extends keyof Type ? Type : TRefine<Type>);
-/** Applies a Refine check to the given type. */
-export declare function RefineAdd<Type extends TSchema>(type: Type, refinement: TRefinement<Type>): TRefineAdd<Type>;
-/** Represents a type with embedded Refine check. */
-export type TRefine<Type extends TSchema = TSchema> = (Type & {
-    '~refine': TRefinement<unknown>[];
-});
-export type TRefineCheckCallback<Value extends unknown = unknown> = (value: Value) => boolean;
-export type TRefineErrorCallback<Value extends unknown = unknown> = (value: Value) => string;
-export interface TRefinement<Value extends unknown = unknown> {
-    check: TRefineCheckCallback<Value>;
-    error: TRefineErrorCallback<Value>;
-}
-/** Refines a type with an explicit check */
-export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>, error: TRefineErrorCallback<Value>): TRefineAdd<Type>;
-/** Refines a type with an explicit check */
-export declare function Refine<Type extends TSchema, Value = Static<Type>>(type: Type, check: TRefineCheckCallback<Value>): TRefineAdd<Type>;
-/** Returns true if the given value is a TRefinement. */
-export declare function IsRefinement(value: unknown): value is TRefinement;
-/** Returns true if the given value is a TRefine. */
-export declare function IsRefine(value: unknown): value is TRefine;

package/node_modules/typebox/build/type/types/_refine.mjs

@@ -1,36 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../../system/arguments/index.mjs';
-import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-/** Applies a Refine check to the given type. */
-export function RefineAdd(type, refinement) {
-    const refinements = IsRefine(type) ? [...type['~refine'], refinement] : [refinement];
-    return Memory.Update(type, { '~refine': refinements }, {});
-}
-/** Refines a type with an explicit check */
-export function Refine(...args) {
-    const [type, check, error] = Arguments.Match(args, {
-        3: (type, check, error) => [type, check, error],
-        2: (type, check) => [type, check, () => 'Refine Error'],
-    });
-    return RefineAdd(type, { check, error });
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TRefinement. */
-export function IsRefinement(value) {
-    return Guard.IsObjectNotArray(value)
-        && Guard.HasPropertyKey(value, 'check')
-        && Guard.HasPropertyKey(value, 'error')
-        && Guard.IsFunction(value.check)
-        && Guard.IsFunction(value.error);
-}
-/** Returns true if the given value is a TRefine. */
-export function IsRefine(value) {
-    return IsSchema(value)
-        && Guard.HasPropertyKey(value, '~refine')
-        && Guard.IsArray(value['~refine'])
-        && Guard.Every(value['~refine'], 0, value => IsRefinement(value));
-}

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

@@ -1,10 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-export type StaticAny = any;
-/** Represents a Any type. */
-export interface TAny extends TSchema {
-    '~kind': 'Any';
-}
-/** Creates a Any type. */
-export declare function Any(options?: TSchemaOptions): TAny;
-/** Returns true if the given value is a TAny. */
-export declare function IsAny(value: unknown): value is TAny;

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

@@ -1,18 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file 
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Any type. */
-export function Any(options) {
-    return Memory.Create({ ['~kind']: 'Any' }, {}, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TAny. */
-export function IsAny(value) {
-    return IsKind(value, 'Any');
-}

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

@@ -1,18 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TArrayOptions } from './schema.mjs';
-import { type TImmutable } from './_immutable.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticArray<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Array extends TSchema, Item extends TSchema, Result extends readonly unknown[] = Array extends TImmutable ? readonly StaticType<Stack, Direction, Context, This, Item>[] : StaticType<Stack, Direction, Context, This, Item>[]> = Result;
-/** Represents an Array type. */
-export interface TArray<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Array';
-    type: 'array';
-    items: Type;
-}
-/** Creates an Array type. */
-export declare function _Array_<Type extends TSchema>(items: Type, options?: TArrayOptions): TArray<Type>;
-export { _Array_ as Array };
-/** Returns true if the given value is a TArray. */
-export declare function IsArray(value: unknown): value is TArray;
-/** Extracts options from a TArray. */
-export declare function ArrayOptions(type: TArray): TArrayOptions;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates an Array type. */
-export function _Array_(items, options) {
-    return Memory.Create({ '~kind': 'Array' }, { type: 'array', items }, options);
-}
-export { _Array_ as Array }; // Prevent Collision With Global Scope
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TArray. */
-export function IsArray(value) {
-    return IsKind(value, 'Array');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TArray. */
-export function ArrayOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'items']);
-}

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

@@ -1,12 +0,0 @@
-import { type TSchema, type TNumberOptions } from './schema.mjs';
-export declare const BigIntPattern = "-?(?:0|[1-9][0-9]*)n";
-export type StaticBigInt = bigint;
-/** Represents a BigInt type. */
-export interface TBigInt extends TSchema {
-    '~kind': 'BigInt';
-    type: 'bigint';
-}
-/** Creates a BigInt type. */
-export declare function BigInt(options?: TNumberOptions): TBigInt;
-/** Returns true if the given value is a TBigInt. */
-export declare function IsBigInt(value: unknown): value is TBigInt;

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

@@ -1,21 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Pattern
-// ------------------------------------------------------------------
-export const BigIntPattern = '-?(?:0|[1-9][0-9]*)n';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a BigInt type. */
-export function BigInt(options) {
-    return Memory.Create({ '~kind': 'BigInt' }, { type: 'bigint' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TBigInt. */
-export function IsBigInt(value) {
-    return IsKind(value, 'BigInt');
-}

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

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-export type StaticBoolean = boolean;
-/** Represents a Boolean type. */
-export interface TBoolean extends TSchema {
-    '~kind': 'Boolean';
-    type: 'boolean';
-}
-/** Creates a Boolean type. */
-export declare function Boolean(options?: TSchemaOptions): TBoolean;
-/** Returns true if the given value is a TBoolean. */
-export declare function IsBoolean(value: unknown): value is TBoolean;

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

@@ -1,17 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Boolean type. */
-export function Boolean(options) {
-    return Memory.Create({ '~kind': 'Boolean' }, { type: 'boolean' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TBoolean. */
-export function IsBoolean(value) {
-    return IsKind(value, 'Boolean');
-}

package/node_modules/typebox/build/type/types/call.d.mts

@@ -1,16 +0,0 @@
-import { type TSchema } from './schema.mjs';
-import { type TCallInstantiate } from '../engine/call/instantiate.mjs';
-import { type TState } from '../engine/instantiate.mjs';
-/** Represents a deferred generic Call */
-export interface TCall<Target extends TSchema = TSchema, Arguments extends TSchema[] = TSchema[]> extends TSchema {
-    '~kind': 'Call';
-    type: 'call';
-    target: Target;
-    arguments: Arguments;
-}
-export type TCallConstruct<Target extends TSchema, Arguments extends TSchema[], Result extends TSchema = TCall<Target, Arguments>> = Result;
-export declare function CallConstruct<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallConstruct<Target, Arguments>;
-/** Creates a Call type. */
-export declare function Call<Target extends TSchema, Arguments extends TSchema[]>(target: Target, arguments_: [...Arguments]): TCallInstantiate<{}, TState<[], []>, Target, Arguments>;
-/** Returns true if the given type is a TCall. */
-export declare function IsCall(value: unknown): value is TCall;

package/node_modules/typebox/build/type/types/call.mjs

@@ -1,23 +0,0 @@
-// deno-lint-ignore-file ban-types
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-import { CallInstantiate } from '../engine/call/instantiate.mjs';
-import { State } from '../engine/instantiate.mjs';
-export function CallConstruct(target, arguments_) {
-    return Memory.Create({ ['~kind']: 'Call' }, { type: 'call', target, arguments: arguments_ }, {});
-}
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Call type. */
-export function Call(target, arguments_) {
-    return CallInstantiate({}, State([], []), target, arguments_);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given type is a TCall. */
-export function IsCall(value) {
-    return IsKind(value, 'Call');
-}

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

@@ -1,18 +0,0 @@
-import { type StaticType, type StaticDirection } from './static.mjs';
-import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type StaticInstantiatedParameters } from './function.mjs';
-import { type TProperties } from './properties.mjs';
-export type StaticConstructor<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], InstanceType extends TSchema, StaticParameters extends unknown[] = StaticInstantiatedParameters<Stack, Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Stack, Direction, Context, This, InstanceType>, Result = new (...args: StaticParameters) => StaticReturnType> = Result;
-/** Represents a Constructor type. */
-export interface TConstructor<Parameters extends TSchema[] = TSchema[], InstanceType extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Constructor';
-    type: 'constructor';
-    parameters: Parameters;
-    instanceType: InstanceType;
-}
-/** Creates a Constructor type. */
-export declare function Constructor<Parameters extends TSchema[], InstanceType extends TSchema>(parameters: [...Parameters], instanceType: InstanceType, options?: TSchemaOptions): TConstructor<Parameters, InstanceType>;
-/** Returns true if the given value is a TConstructor. */
-export declare function IsConstructor(value: unknown): value is TConstructor;
-/** Extracts options from a TConstructor. */
-export declare function ConstructorOptions(type: TConstructor): TSchemaOptions;

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

@@ -1,24 +0,0 @@
-// deno-fmt-ignore-file
-import { Memory } from '../../system/memory/index.mjs';
-import { IsKind } from './schema.mjs';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Constructor type. */
-export function Constructor(parameters, instanceType, options = {}) {
-    return Memory.Create({ '~kind': 'Constructor' }, { type: 'constructor', parameters, instanceType }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TConstructor. */
-export function IsConstructor(value) {
-    return IsKind(value, 'Constructor');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TConstructor. */
-export function ConstructorOptions(type) {
-    return Memory.Discard(type, ['~kind', 'type', 'parameters', 'instanceType']);
-}