@code-yeongyu/senpi 2026.8.18 → 2026.8.19

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/unsigned_integer.mjs

@@ -0,0 +1,26 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/unsigned_number.d.mts

@@ -0,0 +1,17 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/unsigned_number.mjs

@@ -0,0 +1,38 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/until.d.mts

@@ -0,0 +1,7 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/until.mjs

@@ -0,0 +1,21 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/until_1.d.mts

@@ -0,0 +1,5 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/script/token/until_1.mjs

@@ -0,0 +1,12 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_codec.d.mts

@@ -0,0 +1,30 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_codec.mjs

@@ -0,0 +1,60 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_immutable.d.mts

@@ -0,0 +1,9 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_immutable.mjs

@@ -0,0 +1,18 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_optional.d.mts

@@ -0,0 +1,9 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_optional.mjs

@@ -0,0 +1,18 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_readonly.d.mts

@@ -0,0 +1,9 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_readonly.mjs

@@ -0,0 +1,18 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_refine.d.mts

@@ -0,0 +1,24 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/_refine.mjs

@@ -0,0 +1,36 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/any.d.mts

@@ -0,0 +1,10 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/any.mjs

@@ -0,0 +1,18 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/array.d.mts

@@ -0,0 +1,18 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/array.mjs

@@ -0,0 +1,25 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/bigint.d.mts

@@ -0,0 +1,12 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/bigint.mjs

@@ -0,0 +1,21 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/boolean.d.mts

@@ -0,0 +1,11 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/boolean.mjs

@@ -0,0 +1,17 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/call.d.mts

@@ -0,0 +1,16 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/call.mjs

@@ -0,0 +1,23 @@
+// 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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/constructor.d.mts

@@ -0,0 +1,18 @@
+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/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/constructor.mjs

@@ -0,0 +1,24 @@
+// 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']);
+}