typebox 1.0.42 → 1.0.44

package/build/schema/engine/minContains.mjs

@@ -1,36 +1,38 @@
 // 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 BuildMinContains(context, schema, value) {
+export function BuildMinContains(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.IsGreaterEqualThan(count, E.Constant(schema.minContains));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinContains(context, schema, value) {
+export function CheckMinContains(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.IsGreaterEqualThan(count, schema.minContains);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMinContains(context, schemaPath, instancePath, schema, value) {
-    return CheckMinContains(context, schema, value) || context.AddError({
+export function ErrorMinContains(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinContains(stack, context, schema, value) || context.AddError({
         keyword: 'contains',
         schemaPath,
         instancePath,

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

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

@@ -3,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMinItems(context, schema, value) {
+export function BuildMinItems(stack, context, schema, value) {
     return E.IsGreaterEqualThan(E.Member(value, 'length'), E.Constant(schema.minItems));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinItems(context, schema, value) {
+export function CheckMinItems(stack, context, schema, value) {
     return G.IsGreaterEqualThan(value.length, schema.minItems);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMinItems(context, schemaPath, instancePath, schema, value) {
-    return CheckMinItems(context, schema, value) || context.AddError({
+export function ErrorMinItems(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinItems(stack, context, schema, value) || context.AddError({
         keyword: 'minItems',
         schemaPath,
         instancePath,

package/build/schema/engine/minLength.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 BuildMinLength(context: BuildContext, schema: S.XMinLength, value: string): string;
-export declare function CheckMinLength(context: CheckContext, schema: S.XMinLength, value: string): boolean;
-export declare function ErrorMinLength(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinLength, value: string): boolean;
+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/build/schema/engine/minLength.mjs

@@ -3,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMinLength(context, schema, value) {
+export function BuildMinLength(stack, context, schema, value) {
     return E.IsGreaterEqualThan(E.StringGraphemeCount(value), E.Constant(schema.minLength));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinLength(context, schema, value) {
+export function CheckMinLength(stack, context, schema, value) {
     return G.IsGreaterEqualThan(G.StringGraphemeCount(value), schema.minLength);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMinLength(context, schemaPath, instancePath, schema, value) {
-    return CheckMinLength(context, schema, value) || context.AddError({
+export function ErrorMinLength(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinLength(stack, context, schema, value) || context.AddError({
         keyword: 'minLength',
         schemaPath,
         instancePath,

package/build/schema/engine/minProperties.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 BuildMinProperties(context: BuildContext, schema: S.XMinProperties, value: string): string;
-export declare function CheckMinProperties(context: CheckContext, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMinProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildMinProperties(stack: Stack, context: BuildContext, schema: Schema.XMinProperties, value: string): string;
+export declare function CheckMinProperties(stack: Stack, context: CheckContext, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMinProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/minProperties.mjs

@@ -3,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMinProperties(context, schema, value) {
+export function BuildMinProperties(stack, context, schema, value) {
     return E.IsGreaterEqualThan(E.Member(E.Keys(value), 'length'), E.Constant(schema.minProperties));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMinProperties(context, schema, value) {
+export function CheckMinProperties(stack, context, schema, value) {
     return G.IsGreaterEqualThan(G.Keys(value).length, schema.minProperties);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMinProperties(context, schemaPath, instancePath, schema, value) {
-    return CheckMinProperties(context, schema, value) || context.AddError({
+export function ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMinProperties(stack, context, schema, value) || context.AddError({
         keyword: 'minProperties',
         schemaPath,
         instancePath,

package/build/schema/engine/minimum.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 BuildMinimum(context: BuildContext, schema: S.XMinimum, value: string): string;
-export declare function CheckMinimum(context: CheckContext, schema: S.XMinimum, value: number | bigint): boolean;
-export declare function ErrorMinimum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMinimum, value: number | bigint): boolean;
+export declare function BuildMinimum(stack: Stack, context: BuildContext, schema: Schema.XMinimum, value: string): string;
+export declare function CheckMinimum(stack: Stack, context: CheckContext, schema: Schema.XMinimum, value: number | bigint): boolean;
+export declare function ErrorMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMinimum, value: number | bigint): boolean;

package/build/schema/engine/minimum.mjs

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

package/build/schema/engine/multipleOf.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 BuildMultipleOf(context: BuildContext, schema: S.XMultipleOf, value: string): string;
-export declare function CheckMultipleOf(context: CheckContext, schema: S.XMultipleOf, value: number | bigint): boolean;
-export declare function ErrorMultipleOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMultipleOf, value: number | bigint): boolean;
+export declare function BuildMultipleOf(stack: Stack, context: BuildContext, schema: Schema.XMultipleOf, value: string): string;
+export declare function CheckMultipleOf(stack: Stack, context: CheckContext, schema: Schema.XMultipleOf, value: number | bigint): boolean;
+export declare function ErrorMultipleOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMultipleOf, value: number | bigint): boolean;

package/build/schema/engine/multipleOf.mjs

@@ -3,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildMultipleOf(context, schema, value) {
+export function BuildMultipleOf(stack, context, schema, value) {
     return E.MultipleOf(value, E.Constant(schema.multipleOf));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckMultipleOf(context, schema, value) {
+export function CheckMultipleOf(stack, context, schema, value) {
     return G.IsMultipleOf(value, schema.multipleOf);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorMultipleOf(context, schemaPath, instancePath, schema, value) {
-    return CheckMultipleOf(context, schema, value) || context.AddError({
+export function ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckMultipleOf(stack, context, schema, value) || context.AddError({
         keyword: 'multipleOf',
         schemaPath,
         instancePath,

package/build/schema/engine/not.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 BuildNot(context: BuildContext, schema: S.XNot, value: string): string;
-export declare function CheckNot(context: CheckContext, schema: S.XNot, value: unknown): boolean;
-export declare function ErrorNot(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XNot, value: unknown): boolean;
+export declare function BuildNot(stack: Stack, context: BuildContext, schema: Schema.XNot, value: string): string;
+export declare function CheckNot(stack: Stack, context: CheckContext, schema: Schema.XNot, value: unknown): boolean;
+export declare function ErrorNot(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XNot, value: unknown): boolean;

package/build/schema/engine/not.mjs

@@ -1,33 +1,34 @@
 // deno-fmt-ignore-file
+import { CheckContext } from './_context.mjs';
+import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
-import { Reducer } from './_reducer.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildNotUnevaluated(context, schema, value) {
-    return Reducer(context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
+function BuildNotUnevaluated(stack, context, schema, value) {
+    return Reducer(stack, context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
 }
-function BuildNotFast(context, schema, value) {
-    return E.Not(BuildSchema(context, schema.not, value));
+function BuildNotFast(stack, context, schema, value) {
+    return E.Not(BuildSchema(stack, context, schema.not, value));
 }
-export function BuildNot(context, schema, value) {
-    return context.UseUnevaluated() ? BuildNotUnevaluated(context, schema, value) : BuildNotFast(context, schema, value);
+export function BuildNot(stack, context, schema, value) {
+    return context.UseUnevaluated() ? BuildNotUnevaluated(stack, context, schema, value) : BuildNotFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckNot(context, schema, value) {
-    const condition = context.Clone();
-    const isSchema = !CheckSchema(condition, schema.not, value);
-    const isNot = isSchema && context.Merge([condition]);
+export function CheckNot(stack, context, schema, value) {
+    const nextContext = new CheckContext();
+    const isSchema = !CheckSchema(stack, nextContext, schema.not, value);
+    const isNot = isSchema && context.Merge([nextContext]);
     return isNot;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorNot(context, schemaPath, instancePath, schema, value) {
-    return CheckNot(context, schema, value) || context.AddError({
+export function ErrorNot(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckNot(stack, context, schema, value) || context.AddError({
         keyword: 'not',
         schemaPath,
         instancePath,

package/build/schema/engine/oneOf.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 BuildOneOf(context: BuildContext, schema: S.XOneOf, value: string): string;
-export declare function CheckOneOf(context: CheckContext, schema: S.XOneOf, value: unknown): boolean;
-export declare function ErrorOneOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XOneOf, value: unknown): boolean;
+export declare function BuildOneOf(stack: Stack, context: BuildContext, schema: Schema.XOneOf, value: string): string;
+export declare function CheckOneOf(stack: Stack, context: CheckContext, schema: Schema.XOneOf, value: unknown): boolean;
+export declare function ErrorOneOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XOneOf, value: unknown): boolean;

package/build/schema/engine/oneOf.mjs

@@ -1,45 +1,45 @@
 // deno-fmt-ignore-file
+import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { Reducer } from './_reducer.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-import { Reducer } from './_reducer.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildOneOfUnevaluated(context, schema, value) {
-    return Reducer(context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
+function BuildOneOfUnevaluated(stack, context, schema, value) {
+    return Reducer(stack, context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
 }
-function BuildOneOfFast(context, schema, value) {
-    const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(context, schema, value)));
+function BuildOneOfFast(stack, context, schema, value) {
+    const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(stack, context, schema, value)));
     const count = E.Call(E.Member(results, 'reduce'), [
         E.ArrowFunction(['count', 'result'], E.Ternary(E.IsEqual('result', E.Constant(true)), E.PrefixIncrement('count'), 'count')),
         E.Constant(0),
     ]);
     return E.IsEqual(count, E.Constant(1));
 }
-export function BuildOneOf(context, schema, value) {
-    return context.UseUnevaluated() ? BuildOneOfUnevaluated(context, schema, value) : BuildOneOfFast(context, schema, value);
+export function BuildOneOf(stack, context, schema, value) {
+    return context.UseUnevaluated() ? BuildOneOfUnevaluated(stack, context, schema, value) : BuildOneOfFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckOneOf(context, schema, value) {
+export function CheckOneOf(stack, context, schema, value) {
     const passedContexts = schema.oneOf.reduce((result, schema) => {
-        const nextContext = context.Clone();
-        return CheckSchema(nextContext, schema, value) ? [...result, nextContext] : result;
+        const nextContext = new CheckContext();
+        return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
     }, []);
     return G.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorOneOf(context, schemaPath, instancePath, schema, value) {
+export function ErrorOneOf(stack, context, schemaPath, instancePath, schema, value) {
     const failedContexts = [];
     const passingSchemas = [];
     const passedContexts = schema.oneOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const nextContext = new AccumulatedErrorContext();
         const nextSchemaPath = `${schemaPath}/oneOf/${index}`;
-        const isSchema = ErrorSchema(nextContext, nextSchemaPath, instancePath, schema, value);
+        const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (isSchema)
             passingSchemas.push(index);
         if (!isSchema)

package/build/schema/engine/pattern.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 BuildPattern(context: BuildContext, schema: S.XPattern, value: string): string;
-export declare function CheckPattern(context: CheckContext, schema: S.XPattern, value: string): boolean;
-export declare function ErrorPattern(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPattern, value: string): boolean;
+export declare function BuildPattern(stack: Stack, context: BuildContext, schema: Schema.XPattern, value: string): string;
+export declare function CheckPattern(stack: Stack, context: CheckContext, schema: Schema.XPattern, value: string): boolean;
+export declare function ErrorPattern(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPattern, value: string): boolean;

package/build/schema/engine/pattern.mjs

@@ -1,25 +1,25 @@
 // deno-fmt-ignore-file
-import * as V from './_externals.mjs';
+import * as Externals from './_externals.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildPattern(context, schema, value) {
-    const regexp = V.CreateExternalVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern);
+export function BuildPattern(stack, context, schema, value) {
+    const regexp = Externals.CreateVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern);
     return E.Call(E.Member(regexp, 'test'), [value]);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckPattern(context, schema, value) {
+export function CheckPattern(stack, context, schema, value) {
     const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern;
     return regexp.test(value);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorPattern(context, schemaPath, instancePath, schema, value) {
-    return CheckPattern(context, schema, value) || context.AddError({
+export function ErrorPattern(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckPattern(stack, context, schema, value) || context.AddError({
         keyword: 'pattern',
         schemaPath,
         instancePath,

package/build/schema/engine/patternProperties.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 BuildPatternProperties(context: BuildContext, schema: S.XPatternProperties, value: string): string;
-export declare function CheckPatternProperties(context: CheckContext, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPatternProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildPatternProperties(stack: Stack, context: BuildContext, schema: Schema.XPatternProperties, value: string): string;
+export declare function CheckPatternProperties(stack: Stack, context: CheckContext, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPatternProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/patternProperties.mjs

@@ -1,42 +1,44 @@
 // deno-fmt-ignore-file
-import * as V from './_externals.mjs';
+import * as Externals from './_externals.mjs';
+import { Unique } from './_unique.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildPatternProperties(context, schema, value) {
+export function BuildPatternProperties(stack, context, schema, value) {
     return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
-        const regexp = V.CreateExternalVariable(new RegExp(pattern));
-        const notKey = E.Not(E.Call(E.Member(regexp, 'test'), ['key']));
-        const isSchema = BuildSchema(context, schema, 'value');
-        const addKey = context.AddKey('key');
+        const [key, prop] = [Unique(), Unique()];
+        const regexp = Externals.CreateVariable(new RegExp(pattern));
+        const notKey = E.Not(E.Call(E.Member(regexp, 'test'), [key]));
+        const isSchema = BuildSchema(stack, context, schema, prop);
+        const addKey = context.AddKey(key);
         const guarded = context.UseUnevaluated() ? E.Or(notKey, E.And(isSchema, addKey)) : E.Or(notKey, isSchema);
-        return E.Every(E.Entries(value), E.Constant(0), ['[key, value]', '_'], guarded);
+        return E.Every(E.Entries(value), E.Constant(0), [`[${key}, ${prop}]`, '_'], guarded);
     }));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckPatternProperties(context, schema, value) {
+export function CheckPatternProperties(stack, context, schema, value) {
     return G.Every(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const regexp = new RegExp(pattern);
-        return G.Every(G.Entries(value), 0, ([key, value]) => {
-            return !regexp.test(key) || CheckSchema(context, schema, value) && context.AddKey(key);
+        return G.Every(G.Entries(value), 0, ([key, prop]) => {
+            return !regexp.test(key) || CheckSchema(stack, context, schema, prop) && context.AddKey(key);
         });
     });
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorPatternProperties(context, schemaPath, instancePath, schema, value) {
+export function ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value) {
     return G.EveryAll(G.Entries(schema.patternProperties), 0, ([pattern, schema]) => {
         const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
         const regexp = new RegExp(pattern);
         return G.EveryAll(G.Entries(value), 0, ([key, value]) => {
             const nextInstancePath = `${instancePath}/${key}`;
             const notKey = !regexp.test(key);
-            return notKey || ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
+            return notKey || ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
         });
     });
 }

package/build/schema/engine/prefixItems.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 BuildPrefixItems(context: BuildContext, schema: S.XPrefixItems, value: string): string;
-export declare function CheckPrefixItems(context: CheckContext, schema: S.XPrefixItems, value: unknown[]): boolean;
-export declare function ErrorPrefixItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPrefixItems, value: unknown[]): boolean;
+export declare function BuildPrefixItems(stack: Stack, context: BuildContext, schema: Schema.XPrefixItems, value: string): string;
+export declare function CheckPrefixItems(stack: Stack, context: CheckContext, schema: Schema.XPrefixItems, value: unknown[]): boolean;
+export declare function ErrorPrefixItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPrefixItems, value: unknown[]): boolean;

package/build/schema/engine/prefixItems.mjs

@@ -4,10 +4,10 @@ import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildPrefixItems(context, schema, value) {
+export function BuildPrefixItems(stack, context, schema, value) {
     return E.ReduceAnd(schema.prefixItems.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);
@@ -16,20 +16,20 @@ export function BuildPrefixItems(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckPrefixItems(context, schema, value) {
+export function CheckPrefixItems(stack, context, schema, value) {
     return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, 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));
     });
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorPrefixItems(context, schemaPath, instancePath, schema, value) {
+export function ErrorPrefixItems(stack, context, schemaPath, instancePath, schema, value) {
     return G.IsEqual(value.length, 0) || G.EveryAll(schema.prefixItems, 0, (schema, index) => {
         const nextSchemaPath = `${schemaPath}/prefixItems/${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));
     });
 }

package/build/schema/engine/properties.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 BuildProperties(context: BuildContext, schema: S.XProperties, value: string): string;
-export declare function CheckProperties(context: CheckContext, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildProperties(stack: Stack, context: BuildContext, schema: Schema.XProperties, value: string): string;
+export declare function CheckProperties(stack: Stack, context: CheckContext, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/properties.mjs

@@ -1,16 +1,16 @@
 // deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import * as S from '../types/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 import { InexactOptionalCheck, InexactOptionalBuild, IsExactOptional } from './_exact_optional.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildProperties(context, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
+export function BuildProperties(stack, context, schema, value) {
+    const required = Schema.IsRequired(schema) ? schema.required : [];
     const everyKey = G.Entries(schema.properties).map(([key, schema]) => {
         const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(context, schema, E.Member(value, key));
+        const isSchema = BuildSchema(stack, context, schema, E.Member(value, key));
         const addKey = context.AddKey(E.Constant(key));
         const guarded = context.UseUnevaluated() ? E.And(isSchema, addKey) : isSchema;
         // --------------------------------------------------------------
@@ -47,10 +47,10 @@ export function BuildProperties(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckProperties(context, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
+export function CheckProperties(stack, context, schema, value) {
+    const required = Schema.IsRequired(schema) ? schema.required : [];
     const isProperties = G.Every(G.Entries(schema.properties), 0, ([key, schema]) => {
-        const isProperty = !G.HasPropertyKey(value, key) || (CheckSchema(context, schema, value[key]) && context.AddKey(key));
+        const isProperty = !G.HasPropertyKey(value, key) || (CheckSchema(stack, context, schema, value[key]) && context.AddKey(key));
         return IsExactOptional(required, key)
             ? isProperty
             : InexactOptionalCheck(value, key) || isProperty;
@@ -60,13 +60,13 @@ export function CheckProperties(context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorProperties(context, schemaPath, instancePath, schema, value) {
-    const required = S.IsRequired(schema) ? schema.required : [];
+export function ErrorProperties(stack, context, schemaPath, instancePath, schema, value) {
+    const required = Schema.IsRequired(schema) ? schema.required : [];
     const isProperties = G.EveryAll(G.Entries(schema.properties), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/properties/${key}`;
         const nextInstancePath = `${instancePath}/${key}`;
         // Defer error generation for IsExactOptional
-        const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
+        const isProperty = () => (!G.HasPropertyKey(value, key) || (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key)));
         return IsExactOptional(required, key)
             ? isProperty()
             : InexactOptionalCheck(value, key) || isProperty();