typebox 1.0.43 → 1.0.45

package/build/schema/engine/exclusiveMinimum.mjs

@@ -3,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildExclusiveMinimum(context, schema, value) {
+export function BuildExclusiveMinimum(stack, context, schema, value) {
     return E.IsGreaterThan(value, E.Constant(schema.exclusiveMinimum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckExclusiveMinimum(context, schema, value) {
+export function CheckExclusiveMinimum(stack, context, schema, value) {
     return G.IsGreaterThan(value, schema.exclusiveMinimum);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorExclusiveMinimum(context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMinimum(context, schema, value) || context.AddError({
+export function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError({
         keyword: 'exclusiveMinimum',
         schemaPath,
         instancePath,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildFormat(context: BuildContext, schema: S.XFormat, value: string): string;
-export declare function CheckFormat(context: CheckContext, schema: S.XFormat, value: string): boolean;
-export declare function ErrorFormat(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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

@@ -1,23 +1,23 @@
 // deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
 import { Format } from '../../format/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildFormat(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(context, schema, value) {
+export function CheckFormat(stack, context, schema, value) {
     return Format.Test(schema.format, value);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorFormat(context, schemaPath, instancePath, schema, value) {
-    return CheckFormat(context, schema, value) || context.AddError({
+export function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckFormat(stack, context, schema, value) || context.AddError({
         keyword: 'format',
         schemaPath,
         instancePath,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildIf(context: BuildContext, schema: S.XIf, value: string): string;
-export declare function CheckIf(context: CheckContext, schema: S.XIf, value: unknown): boolean;
-export declare function ErrorIf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XIf, value: unknown): boolean;
+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/build/schema/engine/if.mjs

@@ -1,41 +1,41 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
+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(context, schema, value) {
-    const thenSchema = S.IsThen(schema) ? schema.then : true;
-    const elseSchema = S.IsElse(schema) ? schema.else : true;
-    return E.Ternary(BuildSchema(context, schema.if, value), BuildSchema(context, thenSchema, value), BuildSchema(context, elseSchema, value));
+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(context, schema, value) {
-    const thenSchema = S.IsThen(schema) ? schema.then : true;
-    const elseSchema = S.IsElse(schema) ? schema.else : true;
-    return CheckSchema(context, schema.if, value)
-        ? CheckSchema(context, thenSchema, value)
-        : CheckSchema(context, elseSchema, value);
+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(context, schemaPath, instancePath, schema, value) {
-    const thenSchema = S.IsThen(schema) ? schema.then : true;
-    const elseSchema = S.IsElse(schema) ? schema.else : true;
-    const trueContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-    const isIf = ErrorSchema(trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
-        ? ErrorSchema(trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
+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(context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
+        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
             keyword: 'if',
             schemaPath,
             instancePath,

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

@@ -1,31 +1,36 @@
 export * from './_context.mjs';
-export * from './_functions.mjs';
-export * from './_reducer.mjs';
 export * from './_externals.mjs';
 export * from './_guard.mjs';
+export * from './_functions.mjs';
+export * from './_reducer.mjs';
 export * from './_refine.mjs';
-export * from './additionalProperties.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 './maximum.mjs';
+export * from './maxContains.mjs';
 export * from './maxItems.mjs';
 export * from './maxLength.mjs';
 export * from './maxProperties.mjs';
-export * from './minimum.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';
@@ -37,12 +42,8 @@ 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 './uniqueItems.mjs';
-export * from './dependentRequired.mjs';
-export * from './dependentSchemas.mjs';
-export * from './minContains.mjs';
-export * from './maxContains.mjs';
 export * from './unevaluatedItems.mjs';
 export * from './unevaluatedProperties.mjs';
-export * from './schema.mjs';
+export * from './uniqueItems.mjs';

package/build/schema/engine/index.mjs

@@ -2,36 +2,41 @@
 // Infrastructure
 // ------------------------------------------------------------------
 export * from './_context.mjs';
+export * from './_externals.mjs';
+export * from './_guard.mjs';
 export * from './_functions.mjs';
 export * from './_reducer.mjs';
-export * from './_externals.mjs';
+export * from './_refine.mjs';
+export * from './_stack.mjs';
 // ------------------------------------------------------------------
 // Schematics
 // ------------------------------------------------------------------
-export * from './_guard.mjs';
-export * from './_refine.mjs';
-export * from './additionalProperties.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 './maximum.mjs';
+export * from './maxContains.mjs';
 export * from './maxItems.mjs';
 export * from './maxLength.mjs';
 export * from './maxProperties.mjs';
-export * from './minimum.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';
@@ -43,12 +48,8 @@ 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 './uniqueItems.mjs';
-export * from './dependentRequired.mjs';
-export * from './dependentSchemas.mjs';
-export * from './minContains.mjs';
-export * from './maxContains.mjs';
 export * from './unevaluatedItems.mjs';
 export * from './unevaluatedProperties.mjs';
-export * from './schema.mjs';
+export * from './uniqueItems.mjs';

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildItems(context: BuildContext, schema: S.XItems, value: string): string;
-export declare function CheckItems(context: CheckContext, schema: S.XItems, value: unknown[]): boolean;
-export declare function ErrorItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XItems, value: unknown[]): boolean;
+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/build/schema/engine/items.mjs

@@ -1,68 +1,68 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------
-function BuildItemsSized(context, schema, value) {
+function BuildItemsSized(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 = BuildSchema(context, schema, `${value}[${index}]`);
+        const isSchema = BuildSchema(stack, context, schema, `${value}[${index}]`);
         const addIndex = context.AddIndex(E.Constant(index));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
         return E.Or(isLength, guarded);
     }));
 }
-function CheckItemsSized(context, schema, value) {
+function CheckItemsSized(stack, context, schema, value) {
     return G.Every(schema.items, 0, (schema, index) => {
         return G.IsLessEqualThan(value.length, index)
-            || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
+            || (CheckSchema(stack, context, schema, value[index]) && context.AddIndex(index));
     });
 }
-function ErrorItemsSized(context, schemaPath, instancePath, schema, value) {
+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)
-            || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+            || (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
     });
 }
 // ------------------------------------------------------------------
 // ItemsUnsized
 // ------------------------------------------------------------------
-function BuildItemsUnsized(context, schema, value) {
-    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
-    const isSchema = BuildSchema(context, schema.items, 'element');
+function BuildItemsUnsized(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+    const isSchema = BuildSchema(stack, context, schema.items, 'element');
     const addIndex = context.AddIndex('index');
     const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
     return E.Every(value, E.Constant(offset), ['element', 'index'], guarded);
 }
-function CheckItemsUnsized(context, schema, value) {
-    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+function CheckItemsUnsized(stack, context, schema, value) {
+    const offset = Schema.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
     return G.Every(value, offset, (element, index) => {
-        return CheckSchema(context, schema.items, element)
+        return CheckSchema(stack, context, schema.items, element)
             && context.AddIndex(index);
     });
 }
-function ErrorItemsUnsized(context, schemaPath, instancePath, schema, value) {
-    const offset = S.IsPrefixItems(schema) ? schema.prefixItems.length : 0;
+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 ErrorSchema(context, nextSchemaPath, nextInstancePath, schema.items, element)
+        return ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.items, element)
             && context.AddIndex(index);
     });
 }
 // ------------------------------------------------------------------
 // Items
 // ------------------------------------------------------------------
-export function BuildItems(context, schema, value) {
-    return S.IsItemsSized(schema) ? BuildItemsSized(context, schema, value) : BuildItemsUnsized(context, schema, value);
+export function BuildItems(stack, context, schema, value) {
+    return Schema.IsItemsSized(schema) ? BuildItemsSized(stack, context, schema, value) : BuildItemsUnsized(stack, context, schema, value);
 }
-export function CheckItems(context, schema, value) {
-    return S.IsItemsSized(schema) ? CheckItemsSized(context, schema, value) : CheckItemsUnsized(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(context, schemaPath, instancePath, schema, value) {
-    return S.IsItemsSized(schema) ? ErrorItemsSized(context, schemaPath, instancePath, schema, value) : ErrorItemsUnsized(context, schemaPath, instancePath, 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/build/schema/engine/maxContains.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxContains(context: BuildContext, schema: S.XMaxContains, value: string): string;
-export declare function CheckMaxContains(context: CheckContext, schema: S.XMaxContains, value: unknown[]): boolean;
-export declare function ErrorMaxContains(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMaxContains, value: unknown[]): boolean;
+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/build/schema/engine/maxContains.mjs

@@ -1,37 +1,39 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
+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 S.IsContains(schema);
+    return Schema.IsContains(schema);
 }
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxContains(context, schema, value) {
+export function BuildMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
-    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction(['result', 'value'], E.Ternary(BuildSchema(context, schema.contains, 'value'), E.PrefixIncrement('result'), 'result')), E.Constant(0)]);
+    const [result, item] = [Unique(), Unique()];
+    const count = E.Call(E.Member(value, 'reduce'), [E.ArrowFunction([result, item], E.Ternary(BuildSchema(stack, context, schema.contains, item), E.PrefixIncrement(result), result)), E.Constant(0)]);
     return E.IsLessEqualThan(count, E.Constant(schema.maxContains));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMaxContains(context, schema, value) {
+export function CheckMaxContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
-    const count = value.reduce((result, value) => CheckSchema(context, schema.contains, value) ? ++result : result, 0);
+    const count = value.reduce((result, item) => CheckSchema(stack, context, schema.contains, item) ? ++result : result, 0);
     return G.IsLessEqualThan(count, schema.maxContains);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMaxContains(context, schemaPath, instancePath, schema, value) {
-    const minContains = S.IsMinContains(schema) ? schema.minContains : 1;
-    return CheckMaxContains(context, schema, value) || context.AddError({
+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,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxItems(context: BuildContext, schema: S.XMaxItems, value: string): string;
-export declare function CheckMaxItems(context: CheckContext, schema: S.XMaxItems, value: unknown[]): boolean;
-export declare function ErrorMaxItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxItems(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(context, schema, value) {
+export function CheckMaxItems(stack, context, schema, value) {
     return G.IsLessEqualThan(value.length, schema.maxItems);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMaxItems(context, schemaPath, instancePath, schema, value) {
-    return CheckMaxItems(context, schema, value) || context.AddError({
+export function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxItems(stack, context, schema, value) || context.AddError({
         keyword: 'maxItems',
         schemaPath,
         instancePath,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxLength(context: BuildContext, schema: S.XMaxLength, value: string): string;
-export declare function CheckMaxLength(context: CheckContext, schema: S.XMaxLength, value: string): boolean;
-export declare function ErrorMaxLength(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxLength(context, schema, value) {
+export function BuildMaxLength(stack, context, schema, value) {
     return E.IsLessEqualThan(E.StringGraphemeCount(value), E.Constant(schema.maxLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMaxLength(context, schema, value) {
+export function CheckMaxLength(stack, context, schema, value) {
     return G.IsLessEqualThan(G.StringGraphemeCount(value), schema.maxLength);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMaxLength(context, schemaPath, instancePath, schema, value) {
-    return CheckMaxLength(context, schema, value) || context.AddError({
+export function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxLength(stack, context, schema, value) || context.AddError({
         keyword: 'maxLength',
         schemaPath,
         instancePath,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxProperties(context: BuildContext, schema: S.XMaxProperties, value: string): string;
-export declare function CheckMaxProperties(context: CheckContext, schema: S.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMaxProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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,20 +3,20 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaxProperties(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(context, schema, value) {
+export function CheckMaxProperties(stack, context, schema, value) {
     return G.IsLessEqualThan(G.Keys(value).length, schema.maxProperties);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function ErrorMaxProperties(context, schemaPath, instancePath, schema, value) {
-    return CheckMaxProperties(context, schema, value) || context.AddError({
+export function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
         keyword: 'maxProperties',
         schemaPath,
         instancePath,

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaximum(context: BuildContext, schema: S.XMaximum, value: string): string;
-export declare function CheckMaximum(context: CheckContext, schema: S.XMaximum, value: number | bigint): boolean;
-export declare function ErrorMaximum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMaximum(context, schema, value) {
+export function BuildMaximum(stack, context, schema, value) {
     return E.IsLessEqualThan(value, E.Constant(schema.maximum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMaximum(context, schema, value) {
+export function CheckMaximum(stack, context, schema, value) {
     return G.IsLessEqualThan(value, schema.maximum);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMaximum(context, schemaPath, instancePath, schema, value) {
-    return CheckMaximum(context, schema, value) || context.AddError({
+export function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMaximum(stack, context, schema, value) || context.AddError({
         keyword: 'maximum',
         schemaPath,
         instancePath,

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

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