@code-yeongyu/senpi 2026.8.18 → 2026.8.19

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/cyclic.d.mts

@@ -0,0 +1,16 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticCyclic<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Defs extends TProperties, Ref extends string, Result extends unknown = (Ref extends keyof Defs ? StaticType<[...Stack, Ref], Direction, Defs, This, Defs[Ref]> : never)> = Result;
+/** Represents a Cyclic type. */
+export interface TCyclic<Defs extends TProperties = TProperties, Ref extends string = string> extends TSchema {
+    '~kind': 'Cyclic';
+    $defs: Defs;
+    $ref: Ref;
+}
+/** Creates a Cyclic type. */
+export declare function Cyclic<Defs extends TProperties, Ref extends string>($defs: Defs, $ref: Ref, options?: TSchemaOptions): TCyclic<Defs, Ref>;
+/** Returns true if the given value is a TCyclic. */
+export declare function IsCyclic(value: unknown): value is TCyclic;
+/** Extracts options from a TCyclic. */
+export declare function CyclicOptions(type: TCyclic): TSchemaOptions;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/cyclic.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Cyclic type. */
+export function Cyclic($defs, $ref, options) {
+    // $defs require an $id per definition to enable Ajv to resolve correctly
+    const defs = Guard.Keys($defs).reduce((result, key) => {
+        return { ...result, [key]: Memory.Update($defs[key], {}, { $id: key }) };
+    }, {});
+    return Memory.Create({ ['~kind']: 'Cyclic' }, { $defs: defs, $ref }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TCyclic. */
+export function IsCyclic(value) {
+    return IsKind(value, 'Cyclic');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TCyclic. */
+export function CyclicOptions(type) {
+    return Memory.Discard(type, ['~kind', '$defs', '$ref']);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/deferred.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+/** Represents a deferred action. */
+export interface TDeferred<Action extends string = string, Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Deferred';
+    type: 'deferred';
+    action: Action;
+    parameters: Types;
+    options: TSchemaOptions;
+}
+/** Creates a Deferred action. */
+export declare function Deferred<Action extends string, Types extends TSchema[]>(action: Action, parameters: [...Types], options: TSchemaOptions): TDeferred<Action, Types>;
+/** Returns true if the given value is a TDeferred. */
+export declare function IsDeferred(value: unknown): value is TDeferred;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/deferred.mjs

@@ -0,0 +1,16 @@
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Deferred action. */
+export function Deferred(action, parameters, options) {
+    return Memory.Create({ '~kind': 'Deferred' }, { type: 'deferred', action, parameters, options }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TDeferred. */
+export function IsDeferred(value) {
+    return IsKind(value, 'Deferred');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/dependent.d.mts

@@ -0,0 +1,17 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticDependent<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, If extends TSchema, Then extends TSchema, Else extends TSchema, StaticIf extends unknown = StaticType<Stack, Direction, Context, This, If>, StaticThen extends unknown = StaticType<Stack, Direction, Context, This, Then>, StaticElse extends unknown = StaticType<Stack, Direction, Context, This, Else>, Result extends unknown = (StaticIf & StaticThen) | Exclude<StaticElse, StaticIf>> = Result;
+/** Represents a Dependent Type */
+export interface TDependent<If extends TSchema = TSchema, Then extends TSchema = TSchema, Else extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Dependent';
+    if: If;
+    then: Then;
+    else: Else;
+}
+/** Creates a Dependent type */
+export declare function Dependent<If extends TSchema, Then extends TSchema, Else extends TSchema>(if_: If, then_: Then, else_: Else, options?: TSchemaOptions): TDependent<If, Then, Else>;
+/** Returns true if the given value is TDependent. */
+export declare function IsDependent(value: unknown): value is TDependent;
+/** Extracts options from a IsDependent. */
+export declare function DependentOptions(type: TDependent): TSchemaOptions;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/dependent.mjs

@@ -0,0 +1,24 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Dependent type */
+export function Dependent(if_, then_, else_, options = {}) {
+    return Memory.Create({ '~kind': 'Dependent' }, { if: if_, then: then_, else: else_ }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TDependent. */
+export function IsDependent(value) {
+    return IsKind(value, 'Dependent');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a IsDependent. */
+export function DependentOptions(type) {
+    return Memory.Discard(type, ['~kind', 'if', 'then', 'else']);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/enum.d.mts

@@ -0,0 +1,18 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
+export type TEnumValue = string | number;
+/** Returns true if the given value is a EnumValue */
+export declare function IsEnumValue(value: unknown): value is TEnumValue;
+/** Represents an Enum type. */
+export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
+    '~kind': 'Enum';
+    enum: Values;
+}
+/** Creates an Enum type. */
+export declare function Enum<Values extends TEnumValue[]>(values: readonly [...Values], options?: TSchemaOptions): TEnum<Values>;
+/** Creates an Enum type from a TypeScript enum declaration. */
+export declare function Enum<Enum extends TTypeScriptEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTypeScriptEnumToEnumValues<Enum>>;
+/** Returns true if the given value is a TEnum. */
+export declare function IsEnum(value: unknown): value is TEnum;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/enum.mjs

@@ -0,0 +1,22 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+import { IsTypeScriptEnumLike } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript_enum_to_enum_values.mjs';
+/** Returns true if the given value is a EnumValue */
+export function IsEnumValue(value) {
+    return Guard.IsString(value) || Guard.IsNumber(value);
+}
+/** Creates an Enum type. */
+export function Enum(value, options) {
+    const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;
+    return Memory.Create({ '~kind': 'Enum' }, { enum: values }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TEnum. */
+export function IsEnum(value) {
+    return IsKind(value, 'Enum');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/function.d.mts

@@ -0,0 +1,21 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+import { type TTuple } from './tuple.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+export type StaticInstantiatedParameters<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], Evaluated extends TSchema = TInstantiate<Context, TTuple<Parameters>>, Static extends unknown = StaticType<Stack, Direction, Context, This, Evaluated>, Result extends unknown[] = Static extends unknown[] ? Static : []> = Result;
+export type StaticFunction<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, StaticParameters extends unknown[] = StaticInstantiatedParameters<Stack, Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Stack, Direction, Context, This, ReturnType>, Result = (...args: StaticParameters) => StaticReturnType> = Result;
+/** Represents a Function type. */
+export interface TFunction<Parameters extends TSchema[] = TSchema[], ReturnType extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Function';
+    type: 'function';
+    parameters: Parameters;
+    returnType: ReturnType;
+}
+/** Creates a Function type. */
+export declare function _Function_<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: TSchemaOptions): TFunction<Parameters, ReturnType>;
+export { _Function_ as Function };
+/** Returns true if the given value is TFunction. */
+export declare function IsFunction(value: unknown): value is TFunction;
+/** Extracts options from a TFunction. */
+export declare function FunctionOptions(type: TFunction): TSchemaOptions;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/function.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Function type. */
+export function _Function_(parameters, returnType, options = {}) {
+    return Memory.Create({ ['~kind']: 'Function' }, { type: 'function', parameters, returnType }, options);
+}
+export { _Function_ as Function }; // Prevent Collision With Global Scope
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TFunction. */
+export function IsFunction(value) {
+    return IsKind(value, 'Function');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TFunction. */
+export function FunctionOptions(type) {
+    return Memory.Discard(type, ['~kind', 'type', 'parameters', 'returnType']);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/generic.d.mts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TParameter } from './parameter.mjs';
+/** Represents a callable Generic type. */
+export interface TGeneric<Parameters extends TParameter[] = TParameter[], Expression extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Generic';
+    type: 'generic';
+    parameters: Parameters;
+    expression: Expression;
+}
+/** Creates a Generic type. */
+export declare function Generic<Parameters extends TParameter[], Expression extends TSchema>(parameters: [...Parameters], expression: Expression): TGeneric<Parameters, Expression>;
+/** Returns true if the given value is a TGeneric. */
+export declare function IsGeneric(value: unknown): value is TGeneric;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/generic.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** Creates a Generic type. */
+export function Generic(parameters, expression) {
+    return Memory.Create({ '~kind': 'Generic' }, { type: 'generic', parameters, expression });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TGeneric. */
+export function IsGeneric(value) {
+    return IsKind(value, 'Generic');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/identifier.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+/** Represents a Identifier. */
+export interface TIdentifier<Name extends string = string> extends TSchema {
+    '~kind': 'Identifier';
+    type: 'identifier';
+    name: Name;
+}
+/** Creates an Identifier. */
+export declare function Identifier<Name extends string>(name: Name): TIdentifier<Name>;
+/** Returns true if the given value is a TIdentifier. */
+export declare function IsIdentifier(value: unknown): value is TIdentifier;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/identifier.mjs

@@ -0,0 +1,17 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Identifier. */
+export function Identifier(name) {
+    return Memory.Create({ '~kind': 'Identifier' }, { name });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TIdentifier. */
+export function IsIdentifier(value) {
+    return IsKind(value, 'Identifier');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/index.d.mts

@@ -0,0 +1,45 @@
+export * from './_codec.mjs';
+export * from './_immutable.mjs';
+export * from './_optional.mjs';
+export * from './_readonly.mjs';
+export * from './_refine.mjs';
+export * from './any.mjs';
+export * from './array.mjs';
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './call.mjs';
+export * from './constructor.mjs';
+export * from './cyclic.mjs';
+export * from './deferred.mjs';
+export * from './enum.mjs';
+export * from './function.mjs';
+export * from './generic.mjs';
+export * from './identifier.mjs';
+export * from './dependent.mjs';
+export * from './infer.mjs';
+export * from './integer.mjs';
+export * from './intersect.mjs';
+export * from './literal.mjs';
+export * from './never.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './unknown.mjs';
+export * from './symbol.mjs';
+export * from './object.mjs';
+export * from './parameter.mjs';
+export * from './properties.mjs';
+export * from './record.mjs';
+export * from './ref.mjs';
+export * from './rest.mjs';
+export * from './schema.mjs';
+export * from './static.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './template_literal.mjs';
+export * from './this.mjs';
+export * from './tuple.mjs';
+export * from './undefined.mjs';
+export * from './union.mjs';
+export * from './unknown.mjs';
+export * from './unsafe.mjs';
+export * from './void.mjs';

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/index.mjs

@@ -0,0 +1,51 @@
+// ------------------------------------------------------------------
+// Extensions
+// ------------------------------------------------------------------
+export * from './_codec.mjs';
+export * from './_immutable.mjs';
+export * from './_optional.mjs';
+export * from './_readonly.mjs';
+export * from './_refine.mjs';
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+export * from './any.mjs';
+export * from './array.mjs';
+export * from './bigint.mjs';
+export * from './boolean.mjs';
+export * from './call.mjs';
+export * from './constructor.mjs';
+export * from './cyclic.mjs';
+export * from './deferred.mjs';
+export * from './enum.mjs';
+export * from './function.mjs';
+export * from './generic.mjs';
+export * from './identifier.mjs';
+export * from './dependent.mjs';
+export * from './infer.mjs';
+export * from './integer.mjs';
+export * from './intersect.mjs';
+export * from './literal.mjs';
+export * from './never.mjs';
+export * from './null.mjs';
+export * from './number.mjs';
+export * from './unknown.mjs';
+export * from './symbol.mjs';
+export * from './object.mjs';
+export * from './parameter.mjs';
+export * from './properties.mjs';
+export * from './record.mjs';
+export * from './ref.mjs';
+export * from './rest.mjs';
+export * from './schema.mjs';
+export * from './static.mjs';
+export * from './string.mjs';
+export * from './symbol.mjs';
+export * from './template_literal.mjs';
+export * from './this.mjs';
+export * from './tuple.mjs';
+export * from './undefined.mjs';
+export * from './union.mjs';
+export * from './unknown.mjs';
+export * from './unsafe.mjs';
+export * from './void.mjs';

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/infer.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TUnknown } from '../types/unknown.mjs';
+/** Represents an Infer instruction. */
+export interface TInfer<Name extends string = string, Extends extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Infer';
+    type: 'infer';
+    name: Name;
+    extends: Extends;
+}
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string, Extends extends TSchema>(name: Name, extends_: Extends): TInfer<Name, Extends>;
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string>(name: Name): TInfer<Name, TUnknown>;
+/** Returns true if the given value is TInfer. */
+export declare function IsInfer(value: unknown): value is TInfer;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/infer.mjs

@@ -0,0 +1,20 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from '../types/schema.mjs';
+import { Unknown } from '../types/unknown.mjs';
+/** Creates an Infer instruction. */
+export function Infer(...args) {
+    const [name, extends_] = Arguments.Match(args, {
+        2: (name, extends_) => [name, extends_, extends_],
+        1: (name) => [name, Unknown(), Unknown()],
+    });
+    return Memory.Create({ ['~kind']: 'Infer' }, { type: 'infer', name, extends: extends_ }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TInfer. */
+export function IsInfer(value) {
+    return IsKind(value, 'Infer');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/integer.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema.mjs';
+export declare const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+export type StaticInteger = number;
+/** Represents an integer type. */
+export interface TInteger extends TSchema {
+    '~kind': 'Integer';
+    type: 'integer';
+}
+/** Creates a Integer type. */
+export declare function Integer(options?: TNumberOptions): TInteger;
+/** Returns true if the given value is TInteger. */
+export declare function IsInteger(value: unknown): value is TInteger;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/integer.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/intersect.d.mts

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static.mjs';
+import { type TSchema, type TIntersectOptions } from './schema.mjs';
+import { type TProperties } from './properties.mjs';
+export type StaticIntersect<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Stack, Direction, Context, This, Right, Result & StaticType<Stack, Direction, Context, This, Left>> : Result);
+/** Represents a logical Intersect type. */
+export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Intersect';
+    allOf: Types;
+}
+/** Creates a Intersect type. */
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
+/** Returns true if the given value is TIntersect. */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** Extracts options from a TIntersect. */
+export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/intersect.mjs

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

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/literal.d.mts

@@ -0,0 +1,31 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare class InvalidLiteralValue extends Error {
+    readonly cause: {
+        value: unknown;
+    };
+    constructor(value: unknown);
+}
+export type StaticLiteral<Value extends TLiteralValue> = (Value);
+export type TLiteralTypeName<Value extends TLiteralValue> = (Value extends bigint ? 'bigint' : Value extends boolean ? 'boolean' : Value extends number ? 'number' : Value extends string ? 'string' : never);
+export declare function LiteralTypeName<Value extends TLiteralValue>(value: Value): TLiteralTypeName<Value>;
+export type TLiteralValue = string | number | boolean | bigint;
+/** Represents a Literal type. */
+export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
+    '~kind': 'Literal';
+    type: TLiteralTypeName<Value>;
+    const: Value;
+}
+/** Creates a Literal type. */
+export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
+/** Returns true if the given value is a TLiteralValue. */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is TLiteral<bigint>. */
+export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
+/** Returns true if the given value is TLiteral<boolean>. */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral<number>. */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<string>. */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral. */
+export declare function IsLiteral(value: unknown): value is TLiteral;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/literal.mjs

@@ -0,0 +1,62 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// InvalidLiteralValue
+// ------------------------------------------------------------------
+export class InvalidLiteralValue extends Error {
+    constructor(value) {
+        super(`Invalid Literal value`);
+        Object.defineProperty(this, 'cause', {
+            value: { value },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
+}
+export function LiteralTypeName(value) {
+    return (Guard.IsBigInt(value) ? 'bigint' :
+        Guard.IsBoolean(value) ? 'boolean' :
+            Guard.IsNumber(value) ? 'number' :
+                Guard.IsString(value) ? 'string' :
+                    (() => { throw new InvalidLiteralValue(value); })());
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Literal type. */
+export function Literal(value, options) {
+    return Memory.Create({ '~kind': 'Literal' }, { type: LiteralTypeName(value), const: value }, options);
+}
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TLiteralValue. */
+export function IsLiteralValue(value) {
+    return Guard.IsBigInt(value)
+        || Guard.IsBoolean(value)
+        || Guard.IsNumber(value)
+        || Guard.IsString(value);
+}
+/** Returns true if the given value is TLiteral<bigint>. */
+export function IsLiteralBigInt(value) {
+    return IsLiteral(value) && Guard.IsBigInt(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean>. */
+export function IsLiteralBoolean(value) {
+    return IsLiteral(value) && Guard.IsBoolean(value.const);
+}
+/** Returns true if the given value is TLiteral<number>. */
+export function IsLiteralNumber(value) {
+    return IsLiteral(value) && Guard.IsNumber(value.const);
+}
+/** Returns true if the given value is TLiteral<string>. */
+export function IsLiteralString(value) {
+    return IsLiteral(value) && Guard.IsString(value.const);
+}
+/** Returns true if the given value is TLiteral. */
+export function IsLiteral(value) {
+    return IsKind(value, 'Literal');
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/never.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from './schema.mjs';
+export declare const NeverPattern = "(?!)";
+export type StaticNever = never;
+/** Represents a Never type. */
+export interface TNever extends TSchema {
+    '~kind': 'Never';
+    not: {};
+}
+/** Creates a Never type. */
+export declare function Never(options?: TSchemaOptions): TNever;
+/** Returns true if the given value is TNever. */
+export declare function IsNever(value: unknown): value is TNever;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/type/types/never.mjs

@@ -0,0 +1,22 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { IsKind } from './schema.mjs';
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+export const NeverPattern = '(?!)';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Never type. */
+export function Never(options) {
+    return Memory.Create({ '~kind': 'Never' }, { not: {} }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TNever. */
+export function IsNever(value) {
+    return IsKind(value, 'Never');
+}