@depup/typebox 1.1.20-depup.0 → 1.1.23-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/typebox
 
 | Field | Value |
 |-------|-------|
-| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.1.20 |
-| Processed | 2026-04-08 |
+| Original | [typebox](https://www.npmjs.com/package/typebox) @ 1.1.23 |
+| Processed | 2026-04-09 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/build/compile/compile.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 // deno-fmt-ignore-file
 import { Arguments } from '../system/arguments/index.mjs';
 import { Validator } from './validator.mjs';

package/build/compile/validator.mjs

@@ -70,7 +70,7 @@ export class Validator extends Base {
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        if (Environment.CanAccelerate() && this.check(value))
+        if (Environment.CanEvaluate() && this.check(value))
             return [];
         return Errors(this.context, this.type, value);
     }

package/build/error/errors.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file ban-types
 import { Guard } from '../guard/index.mjs';
 export function IsValidationError(value) {
     return Guard.IsObject(value) &&

package/build/format/email.d.mts

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an Email
- * @specification Json Schema 2020-12
+ * @specification ajv-formats
  */
 export declare function IsEmail(value: string): boolean;

package/build/format/email.mjs

@@ -1,29 +1,8 @@
-import { IsIPv4Internal } from './ipv4.mjs';
+const Email = /^(?!.*\.\.)[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;
 /**
  * Returns true if the value is an Email
- * @specification Json Schema 2020-12
+ * @specification ajv-formats
  */
 export function IsEmail(value) {
-    const dot = value.indexOf('.');
-    const at = value.indexOf('@');
-    const quoted = value[0] === '"' && value[at - 1] === '"';
-    const ipLiteral = value[at + 1] === '[' && value[value.length - 1] === ']';
-    const ipv6 = ipLiteral && value.indexOf(':', at) !== -1;
-    const ipv4 = ipLiteral && !ipv6 && IsIPv4Internal(value, at + 2, value.length - 1);
-    return (at > 0 && at < value.length - 1) &&
-        !(
-        // .test@example.com
-        (!quoted && dot === 0) ||
-            // te..st@example.com
-            (!quoted && dot !== -1 && value.indexOf('.', dot + 1) === dot + 1) ||
-            // test.@example.com
-            (dot !== -1 && value.indexOf('@', dot) === dot + 1) ||
-            // joe bloggs@example.com
-            (!quoted && value.indexOf(' ') !== -1) ||
-            // user1@oceania.org, user2@oceania.org
-            (value.indexOf(',') !== -1) ||
-            // joe.bloggs@[127.0.0.300]
-            (ipLiteral && !ipv4 && !ipv6) ||
-            // joe.bloggs@invalid=domain.com
-            (value.indexOf('=', at) !== -1));
+    return Email.test(value);
 }

package/build/format/idn-email.d.mts

@@ -1,5 +1,5 @@
 /**
  * Returns true if the value is an IdnEmail
- * @specification Json Schema 2020-12
+ * @specification ajv-formats (unicode-extension)
  */
 export declare function IsIdnEmail(value: string): boolean;

package/build/format/idn-email.mjs

@@ -1,8 +1,8 @@
-import { IsEmail } from './email.mjs';
+const IdnEmail = /^(?!.*\.\.)[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+(?:\.[\p{L}\p{N}!#$%&'*+/=?^_`{|}~-]+)*@[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?(?:\.[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?)*$/iu;
 /**
  * Returns true if the value is an IdnEmail
- * @specification Json Schema 2020-12
+ * @specification ajv-formats (unicode-extension)
  */
 export function IsIdnEmail(value) {
-    return IsEmail(value);
+    return IdnEmail.test(value);
 }

package/build/format/iri-reference.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-control-regex
 // deno-coverage-ignore-start
 function TryUrl(value) {
     try {

package/build/format/uri-reference.mjs

@@ -1,3 +1,4 @@
+// deno-lint-ignore-file no-control-regex
 const UriReference = /^(?!.*[^\x00-\x7F])(?!.*\\)(?:(?:[a-z][a-z0-9+\-.]*:)?(?:\/\/[^\s[\]{}<>^`|]*)?|[^\s[\]{}<>^`|]*)(?:\?[^\s[\]{}<>^`|]*)?(?:#[^\s[\]{}<>^`|]*)?$/i;
 /**
  * Returns true if the value is a valid URI Reference.

package/build/guard/globals.d.mts

@@ -1,6 +1,6 @@
-export declare function IsBoolean(value: unknown): value is Boolean;
-export declare function IsNumber(value: unknown): value is Number;
-export declare function IsString(value: unknown): value is String;
+export declare function IsBoolean(value: unknown): value is globalThis.Boolean;
+export declare function IsNumber(value: unknown): value is globalThis.Number;
+export declare function IsString(value: unknown): value is globalThis.String;
 export type TTypeArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
 export declare function IsTypeArray(value: unknown): value is TTypeArray;
 /** Returns true if the value is a Int8Array */

package/build/guard/guard.d.mts

@@ -9,7 +9,7 @@ export declare function IsBoolean(value: unknown): value is boolean;
 /** Returns true if this value is a constructor */
 export declare function IsConstructor(value: unknown): value is new (...args: never[]) => unknown;
 /** Returns true if this value is a function */
-export declare function IsFunction(value: unknown): value is Function;
+export declare function IsFunction(value: unknown): value is globalThis.Function;
 /** Returns true if this value is integer */
 export declare function IsInteger(value: unknown): value is number;
 /** Returns true if this value is an iterator */

package/build/schema/build.mjs

@@ -20,7 +20,7 @@ function CreateCode(build) {
 // CreateEvaluatedCheck
 // ------------------------------------------------------------------
 function CreateEvaluatedCheck(build, code) {
-    const factory = new globalThis.Function('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
+    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
     return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
 }
 // ------------------------------------------------------------------
@@ -35,7 +35,7 @@ function CreateDynamicCheck(build) {
 // CreateCheck
 // ------------------------------------------------------------------
 function CreateCheck(build, code) {
-    return Environment.CanAccelerate()
+    return Environment.CanEvaluate()
         ? CreateEvaluatedCheck(build, code)
         : CreateDynamicCheck(build);
 }
@@ -79,7 +79,7 @@ export class BuildResult {
     Evaluate() {
         const Code = CreateCode(this);
         const Check = CreateCheck(this, Code);
-        return { IsAccelerated: Environment.CanAccelerate(), Code, Check };
+        return { IsAccelerated: Environment.CanEvaluate(), Code, Check };
     }
 }
 /** Builds a schema into a optimized runtime validator */

package/build/schema/engine/_functions.mjs

@@ -7,7 +7,7 @@ const functions = new Map();
 // ------------------------------------------------------------------
 // CreateCallExpression
 // ------------------------------------------------------------------
-function CreateCallExpression(context, schema, hash, value) {
+function CreateCallExpression(context, _schema, hash, value) {
     return context.UseUnevaluated()
         ? E.Call(`check_${hash}`, ['context', value])
         : E.Call(`check_${hash}`, [value]);

package/build/schema/engine/_guard.d.mts

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

package/build/schema/engine/_guard.mjs

@@ -4,19 +4,19 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildGuard(stack, context, schema, value) {
+export function BuildGuard(_stack, _context, schema, value) {
     return E.Call(E.Member(E.Member(Externals.CreateVariable(schema), '~guard'), 'check'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckGuard(stack, context, schema, value) {
+export function CheckGuard(_stack, _context, schema, value) {
     return schema['~guard'].check(value);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorGuard(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorGuard(_stack, context, schemaPath, instancePath, schema, value) {
     return schema['~guard'].check(value) || context.AddError({
         keyword: '~guard',
         schemaPath,

package/build/schema/engine/_refine.d.mts

@@ -1,6 +1,6 @@
 import * as S from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRefine(stack: Stack, context: BuildContext, schema: S.XRefine, value: string): string;
-export declare function CheckRefine(stack: Stack, context: CheckContext, schema: S.XRefine, value: unknown): boolean;
-export declare function ErrorRefine(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;
+export declare function BuildRefine(_stack: Stack, _context: BuildContext, schema: S.XRefine, value: string): string;
+export declare function CheckRefine(_stack: Stack, _context: CheckContext, schema: S.XRefine, value: unknown): boolean;
+export declare function ErrorRefine(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;

package/build/schema/engine/_refine.mjs

@@ -4,20 +4,20 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildRefine(stack, context, schema, value) {
+export function BuildRefine(_stack, _context, schema, value) {
     const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
     return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'refine'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckRefine(stack, context, schema, value) {
+export function CheckRefine(_stack, _context, schema, value) {
     return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRefine(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
         return refinement.refine(value) || context.AddError({
             keyword: '~refine',

package/build/schema/engine/additionalProperties.d.mts

@@ -1,8 +1,8 @@
 import * as S from '../types/index.mjs';
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function CanAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties, value: string): schema is S.XAdditionalProperties & S.XRequired;
-export declare function BuildAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
+export declare function CanAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties, _value: string): schema is S.XAdditionalProperties & S.XRequired;
+export declare function BuildAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
 export declare function BuildAdditionalPropertiesStandard(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
 export declare function BuildAdditionalProperties(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
 export declare function CheckAdditionalProperties(stack: Stack, context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/additionalProperties.mjs

@@ -43,14 +43,14 @@ function GetPropertiesPattern(schema) {
 // we can generate a simplified and efficient runtime check.
 //
 // ------------------------------------------------------------------
-export function CanAdditionalPropertiesFast(context, schema, value) {
+export function CanAdditionalPropertiesFast(_context, schema, _value) {
     return S.IsRequired(schema)
         && S.IsProperties(schema)
         && !S.IsPatternProperties(schema)
         && G.IsEqual(schema.additionalProperties, false)
         && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
 }
-export function BuildAdditionalPropertiesFast(context, schema, value) {
+export function BuildAdditionalPropertiesFast(_context, schema, value) {
     return E.IsEqual(E.Member(E.Call(E.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), E.Constant(schema.required.length));
 }
 // ------------------------------------------------------------------

package/build/schema/engine/anyOf.mjs

@@ -21,7 +21,7 @@ export function BuildAnyOf(stack, context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function CheckAnyOf(stack, context, schema, value) {
-    const results = schema.anyOf.reduce((result, schema, index) => {
+    const results = schema.anyOf.reduce((result, schema) => {
         const nextContext = new CheckContext();
         return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
     }, []);

package/build/schema/engine/boolean.d.mts

@@ -1,5 +1,5 @@
 import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildBooleanSchema(stack: Stack, context: BuildContext, schema: boolean, value: string): string;
-export declare function CheckBooleanSchema(stack: Stack, context: CheckContext, schema: boolean, value: unknown): boolean;
+export declare function BuildBooleanSchema(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckBooleanSchema(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
 export declare function ErrorBooleanSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

package/build/schema/engine/boolean.mjs

@@ -3,13 +3,13 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildBooleanSchema(stack, context, schema, value) {
+export function BuildBooleanSchema(_stack, _context, schema, _value) {
     return schema ? E.Constant(true) : E.Constant(false);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckBooleanSchema(stack, context, schema, value) {
+export function CheckBooleanSchema(_stack, _context, schema, _value) {
     return schema;
 }
 // ------------------------------------------------------------------

package/build/schema/engine/const.d.mts

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

package/build/schema/engine/const.mjs

@@ -4,7 +4,7 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildConst(stack, context, schema, value) {
+export function BuildConst(_stack, _context, schema, value) {
     return G.IsValueLike(schema.const)
         ? E.IsEqual(value, E.Constant(schema.const))
         : E.IsDeepEqual(value, Externals.CreateVariable(schema.const));
@@ -12,7 +12,7 @@ export function BuildConst(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckConst(stack, context, schema, value) {
+export function CheckConst(_stack, _context, schema, value) {
     return G.IsValueLike(schema.const)
         ? G.IsEqual(value, schema.const)
         : G.IsDeepEqual(value, schema.const);

package/build/schema/engine/dependentRequired.d.mts

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

package/build/schema/engine/dependentRequired.mjs

@@ -3,7 +3,7 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildDependentRequired(stack, context, schema, value) {
+export function BuildDependentRequired(_stack, _context, schema, value) {
     const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
     const isEvery = E.ReduceAnd(G.Entries(schema.dependentRequired).map(([key, keys]) => {
         const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
@@ -15,7 +15,7 @@ export function BuildDependentRequired(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckDependentRequired(stack, context, schema, value) {
+export function CheckDependentRequired(_stack, _context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.Every(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
         return !G.HasPropertyKey(value, key) ||
@@ -26,7 +26,7 @@ export function CheckDependentRequired(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDependentRequired(stack, context, schemaPath, instancePath, schema, value) {
+export function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
         return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({

package/build/schema/engine/enum.d.mts

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

package/build/schema/engine/enum.mjs

@@ -4,7 +4,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildEnum(stack, context, schema, value) {
+export function BuildEnum(_stack, _context, schema, value) {
     return E.ReduceOr(schema.enum.map(option => {
         if (G.IsValueLike(option))
             return E.IsEqual(value, E.Constant(option));
@@ -15,7 +15,7 @@ export function BuildEnum(stack, context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckEnum(stack, context, schema, value) {
+export function CheckEnum(_stack, _context, schema, value) {
     return schema.enum.some(option => G.IsValueLike(option)
         ? G.IsEqual(value, option)
         : G.IsDeepEqual(value, option));

package/build/schema/engine/exclusiveMaximum.d.mts

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

package/build/schema/engine/exclusiveMaximum.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildExclusiveMaximum(stack, context, schema, value) {
+export function BuildExclusiveMaximum(_stack, _context, schema, value) {
     return E.IsLessThan(value, E.Constant(schema.exclusiveMaximum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckExclusiveMaximum(stack, context, schema, value) {
+export function CheckExclusiveMaximum(_stack, _context, schema, value) {
     return G.IsLessThan(value, schema.exclusiveMaximum);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/exclusiveMinimum.d.mts

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

package/build/schema/engine/exclusiveMinimum.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildExclusiveMinimum(stack, context, schema, value) {
+export function BuildExclusiveMinimum(_stack, _context, schema, value) {
     return E.IsGreaterThan(value, E.Constant(schema.exclusiveMinimum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckExclusiveMinimum(stack, context, schema, value) {
+export function CheckExclusiveMinimum(_stack, _context, schema, value) {
     return G.IsGreaterThan(value, schema.exclusiveMinimum);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/format.d.mts

@@ -1,6 +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 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/build/schema/engine/format.mjs

@@ -4,13 +4,13 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildFormat(stack, context, schema, value) {
+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) {
+export function CheckFormat(_stack, _context, schema, value) {
     return Format.Test(schema.format, value);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/maxItems.d.mts

@@ -1,6 +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 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/build/schema/engine/maxItems.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxItems(stack, context, schema, value) {
+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) {
+export function CheckMaxItems(_stack, _context, schema, value) {
     return G.IsLessEqualThan(value.length, schema.maxItems);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/maxLength.d.mts

@@ -1,6 +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 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/build/schema/engine/maxLength.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxLength(stack, context, schema, value) {
+export function BuildMaxLength(_stack, _context, schema, value) {
     return E.IsMaxLength(value, E.Constant(schema.maxLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMaxLength(stack, context, schema, value) {
+export function CheckMaxLength(_stack, _context, schema, value) {
     return G.IsMaxLength(value, schema.maxLength);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/maxProperties.d.mts

@@ -1,6 +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 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/build/schema/engine/maxProperties.mjs

@@ -3,13 +3,13 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxProperties(stack, context, schema, value) {
+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) {
+export function CheckMaxProperties(_stack, _context, schema, value) {
     return G.IsLessEqualThan(G.Keys(value).length, schema.maxProperties);
 }
 // ------------------------------------------------------------------

package/build/schema/engine/maximum.d.mts

@@ -1,6 +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 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/build/schema/engine/maximum.mjs

@@ -3,13 +3,13 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaximum(stack, context, schema, value) {
+export function BuildMaximum(_stack, _context, schema, value) {
     return E.IsLessEqualThan(value, E.Constant(schema.maximum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMaximum(stack, context, schema, value) {
+export function CheckMaximum(_stack, _context, schema, value) {
     return G.IsLessEqualThan(value, schema.maximum);
 }
 // ------------------------------------------------------------------