@code-yeongyu/senpi 2026.8.18 → 2026.8.19

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/exclusiveMinimum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildExclusiveMinimum(_stack, _context, schema, value) {
+    return E.IsGreaterThan(value, E.Constant(schema.exclusiveMinimum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckExclusiveMinimum(_stack, _context, schema, value) {
+    return G.IsGreaterThan(value, schema.exclusiveMinimum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError({
+        keyword: 'exclusiveMinimum',
+        schemaPath,
+        instancePath,
+        params: { comparison: '>', limit: schema.exclusiveMinimum }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/format.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildFormat(_stack: Stack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
+export declare function CheckFormat(_stack: Stack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
+export declare function ErrorFormat(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/format.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import { Format } from '../../format/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildFormat(_stack, _context, schema, value) {
+    return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckFormat(_stack, _context, schema, value) {
+    return Format.Test(schema.format, value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckFormat(stack, context, schema, value) || context.AddError({
+        keyword: 'format',
+        schemaPath,
+        instancePath,
+        params: { format: schema.format },
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/if.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildIf(stack: Stack, context: BuildContext, schema: Schema.XIf, value: string): string;
+export declare function CheckIf(stack: Stack, context: CheckContext, schema: Schema.XIf, value: unknown): boolean;
+export declare function ErrorIf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XIf, value: unknown): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/if.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildIf(stack, context, schema, value) {
+    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
+    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
+    return E.Ternary(BuildSchema(stack, context, schema.if, value), BuildSchema(stack, context, thenSchema, value), BuildSchema(stack, context, elseSchema, value));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckIf(stack, context, schema, value) {
+    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
+    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
+    return CheckSchema(stack, context, schema.if, value)
+        ? CheckSchema(stack, context, thenSchema, value)
+        : CheckSchema(stack, context, elseSchema, value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
+    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
+    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
+    const trueContext = new AccumulatedErrorContext();
+    const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
+        ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
+            keyword: 'if',
+            schemaPath,
+            instancePath,
+            params: { failingKeyword: 'then' },
+        })
+        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
+            keyword: 'if',
+            schemaPath,
+            instancePath,
+            params: { failingKeyword: 'else' },
+        });
+    if (isIf)
+        context.Merge([trueContext]);
+    return isIf;
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/index.d.mts

@@ -0,0 +1,48 @@
+export * from './_context.mjs';
+export * from './_externals.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_refine.mjs';
+export * from './_stack.mjs';
+export * from './additionalItems.mjs';
+export * from './additionalProperties.mjs';
+export * from './allOf.mjs';
+export * from './anyOf.mjs';
+export * from './boolean.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './dependencies.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './maximum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './minimum.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './type.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';
+export * from './uniqueItems.mjs';

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/index.mjs

@@ -0,0 +1,54 @@
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+export * from './_context.mjs';
+export * from './_externals.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
+export * from './_refine.mjs';
+export * from './_stack.mjs';
+// ------------------------------------------------------------------
+// Schematics
+// ------------------------------------------------------------------
+export * from './additionalItems.mjs';
+export * from './additionalProperties.mjs';
+export * from './allOf.mjs';
+export * from './anyOf.mjs';
+export * from './boolean.mjs';
+export * from './const.mjs';
+export * from './contains.mjs';
+export * from './dependencies.mjs';
+export * from './dependentRequired.mjs';
+export * from './dependentSchemas.mjs';
+export * from './enum.mjs';
+export * from './exclusiveMaximum.mjs';
+export * from './exclusiveMinimum.mjs';
+export * from './format.mjs';
+export * from './if.mjs';
+export * from './items.mjs';
+export * from './maxContains.mjs';
+export * from './maxItems.mjs';
+export * from './maxLength.mjs';
+export * from './maxProperties.mjs';
+export * from './maximum.mjs';
+export * from './minContains.mjs';
+export * from './minItems.mjs';
+export * from './minLength.mjs';
+export * from './minProperties.mjs';
+export * from './minimum.mjs';
+export * from './multipleOf.mjs';
+export * from './not.mjs';
+export * from './oneOf.mjs';
+export * from './pattern.mjs';
+export * from './patternProperties.mjs';
+export * from './prefixItems.mjs';
+export * from './properties.mjs';
+export * from './propertyNames.mjs';
+export * from './recursiveRef.mjs';
+export * from './ref.mjs';
+export * from './required.mjs';
+export * from './schema.mjs';
+export * from './type.mjs';
+export * from './unevaluatedItems.mjs';
+export * from './unevaluatedProperties.mjs';
+export * from './uniqueItems.mjs';

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/items.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildItems(stack: Stack, context: BuildContext, schema: Schema.XItems, value: string): string;
+export declare function CheckItems(stack: Stack, context: CheckContext, schema: Schema.XItems, value: unknown[]): boolean;
+export declare function ErrorItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XItems, value: unknown[]): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/items.mjs

@@ -0,0 +1,88 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
+// ------------------------------------------------------------------
+// ItemsSized
+// ------------------------------------------------------------------
+function BuildItemsSizedStandard(stack, context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
+        const addIndex = context.AddIndex(E.Constant(index));
+        return E.Or(isLength, E.And(isSchema, addIndex));
+    }));
+}
+function BuildItemsSizedFast(stack, context, schema, value) {
+    return E.ReduceAnd(schema.items.map((schema, index) => {
+        const isLength = E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(index));
+        const isSchema = BuildSchemaPushStack(stack, context, schema, `${value}[${index}]`);
+        return E.Or(isLength, isSchema);
+    }));
+}
+function BuildItemsSized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsSizedStandard(stack, context, schema, value)
+        : BuildItemsSizedFast(stack, context, schema, value);
+}
+function CheckItemsSized(stack, context, schema, value) {
+    return G.Every(schema.items, 0, (schema, index) => {
+        return G.IsLessEqualThan(value.length, index)
+            || (CheckSchemaPushStack(stack, context, schema, value[index]) && context.AddIndex(index));
+    });
+}
+function ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(schema.items, 0, (schema, index) => {
+        const nextSchemaPath = `${schemaPath}/items/${index}`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsLessEqualThan(value.length, index)
+            || (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+    });
+}
+// ------------------------------------------------------------------
+// ItemsUnsized
+// ------------------------------------------------------------------
+function BuildItemsUnsizedStandard(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    const addIndex = context.AddIndex('index');
+    return E.Every(value, E.Constant(offset), ['element', 'index'], E.And(isSchema, addIndex));
+}
+function BuildItemsUnsizedFast(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchemaPushStack(stack, context, schema.items, 'element');
+    return E.Every(value, E.Constant(offset), ['element', 'index'], isSchema);
+}
+function BuildItemsUnsized(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildItemsUnsizedStandard(stack, context, schema, value)
+        : BuildItemsUnsizedFast(stack, context, schema, value);
+}
+function CheckItemsUnsized(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.Every(value, offset, (element, index) => {
+        return CheckSchemaPushStack(stack, context, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+function ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    return G.EveryAll(value, offset, (element, index) => {
+        const nextSchemaPath = `${schemaPath}/items`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.items, element)
+            && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Items
+// ------------------------------------------------------------------
+export function BuildItems(stack, context, schema, value) {
+    return Schema.IsItemsSized(schema) ? BuildItemsSized(stack, context, schema, value) : BuildItemsUnsized(stack, context, schema, value);
+}
+export function CheckItems(stack, context, schema, value) {
+    return Schema.IsItemsSized(schema) ? CheckItemsSized(stack, context, schema, value) : CheckItemsUnsized(stack, context, schema, value);
+}
+export function ErrorItems(stack, context, schemaPath, instancePath, schema, value) {
+    return Schema.IsItemsSized(schema) ? ErrorItemsSized(stack, context, schemaPath, instancePath, schema, value) : ErrorItemsUnsized(stack, context, schemaPath, instancePath, schema, value);
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxContains.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxContains(stack: Stack, context: BuildContext, schema: Schema.XMaxContains, value: string): string;
+export declare function CheckMaxContains(stack: Stack, context: CheckContext, schema: Schema.XMaxContains, value: unknown[]): boolean;
+export declare function ErrorMaxContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxContains, value: unknown[]): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxContains.mjs

@@ -0,0 +1,42 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Unique } from './_unique.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return Schema.IsContains(schema);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const count = G.Counted(value, (item) => CheckSchema(stack, context, schema.contains, item));
+    return G.IsLessEqualThan(count, schema.maxContains);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value) {
+    const minContains = Schema.IsMinContains(schema) ? schema.minContains : 1;
+    return CheckMaxContains(stack, context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath,
+        instancePath,
+        params: { minContains, maxContains: schema.maxContains },
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxItems.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxItems(_stack: Stack, _context: BuildContext, schema: Schema.XMaxItems, value: string): string;
+export declare function CheckMaxItems(_stack: Stack, _context: CheckContext, schema: Schema.XMaxItems, value: unknown[]): boolean;
+export declare function ErrorMaxItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxItems, value: unknown[]): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxItems.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxItems(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(E.Member(value, 'length'), E.Constant(schema.maxItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxItems(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(value.length, schema.maxItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxItems(stack, context, schema, value) || context.AddError({
+        keyword: 'maxItems',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxItems }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxLength.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxLength(_stack: Stack, _context: BuildContext, schema: Schema.XMaxLength, value: string): string;
+export declare function CheckMaxLength(_stack: Stack, _context: CheckContext, schema: Schema.XMaxLength, value: string): boolean;
+export declare function ErrorMaxLength(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxLength, value: string): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxLength.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxLength(_stack, _context, schema, value) {
+    return E.IsMaxLength(value, E.Constant(schema.maxLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxLength(_stack, _context, schema, value) {
+    return G.IsMaxLength(value, schema.maxLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxLength(stack, context, schema, value) || context.AddError({
+        keyword: 'maxLength',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxLength }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxProperties.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaxProperties(_stack: Stack, _context: BuildContext, schema: Schema.XMaxProperties, value: string): string;
+export declare function CheckMaxProperties(_stack: Stack, _context: CheckContext, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMaxProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maxProperties.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaxProperties(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.maxProperties));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaxProperties(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(G.Keys(value).length, schema.maxProperties);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
+        keyword: 'maxProperties',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.maxProperties },
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maximum.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMaximum(_stack: Stack, _context: BuildContext, schema: Schema.XMaximum, value: string): string;
+export declare function CheckMaximum(_stack: Stack, _context: CheckContext, schema: Schema.XMaximum, value: number | bigint): boolean;
+export declare function ErrorMaximum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaximum, value: number | bigint): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/maximum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMaximum(_stack, _context, schema, value) {
+    return E.IsLessEqualThan(value, E.Constant(schema.maximum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMaximum(_stack, _context, schema, value) {
+    return G.IsLessEqualThan(value, schema.maximum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaximum(stack, context, schema, value) || context.AddError({
+        keyword: 'maximum',
+        schemaPath,
+        instancePath,
+        params: { comparison: '<=', limit: schema.maximum }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minContains.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMinContains(stack: Stack, context: BuildContext, schema: Schema.XMinContains, value: string): string;
+export declare function CheckMinContains(stack: Stack, context: CheckContext, schema: Schema.XMinContains, value: unknown[]): boolean;
+export declare function ErrorMinContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinContains, value: unknown[]): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minContains.mjs

@@ -0,0 +1,51 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Unique } from './_unique.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return Schema.IsContains(schema);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildMinContainsStandard(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const count = E.Counted(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
+function BuildMinContainsFast(stack, context, schema, value) {
+    const [item] = [Unique()];
+    const count = E.Counted(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.IsGreaterEqualThan(count, E.Constant(schema.minContains));
+}
+export function BuildMinContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    return context.UseUnevaluated()
+        ? BuildMinContainsStandard(stack, context, schema, value)
+        : BuildMinContainsFast(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const count = G.Counted(value, (item, index) => CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index));
+    return G.IsGreaterEqualThan(count, schema.minContains);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinContains(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinContains(stack, context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath,
+        instancePath,
+        params: { minContains: schema.minContains }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minItems.d.mts

@@ -0,0 +1,6 @@
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+import * as Schema from '../types/index.mjs';
+export declare function BuildMinItems(_stack: Stack, _context: BuildContext, schema: Schema.XMinItems, value: string): string;
+export declare function CheckMinItems(_stack: Stack, _context: CheckContext, schema: Schema.XMinItems, value: unknown[]): boolean;
+export declare function ErrorMinItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinItems, value: unknown[]): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minItems.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinItems(_stack, _context, schema, value) {
+    return E.IsGreaterEqualThan(E.Member(value, 'length'), E.Constant(schema.minItems));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinItems(_stack, _context, schema, value) {
+    return G.IsGreaterEqualThan(value.length, schema.minItems);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinItems(stack, context, schema, value) || context.AddError({
+        keyword: 'minItems',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.minItems }
+    });
+}

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minLength.d.mts

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMinLength(_stack: Stack, _context: BuildContext, schema: Schema.XMinLength, value: string): string;
+export declare function CheckMinLength(_stack: Stack, _context: CheckContext, schema: Schema.XMinLength, value: string): boolean;
+export declare function ErrorMinLength(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinLength, value: string): boolean;

package/node_modules/@code-yeongyu/senpi-codemode/node_modules/typebox/build/schema/engine/minLength.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinLength(_stack, _context, schema, value) {
+    return E.IsMinLength(value, E.Constant(schema.minLength));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinLength(_stack, _context, schema, value) {
+    return G.IsMinLength(value, schema.minLength);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinLength(stack, context, schema, value) || context.AddError({
+        keyword: 'minLength',
+        schemaPath,
+        instancePath,
+        params: { limit: schema.minLength }
+    });
+}