typebox 1.0.43 → 1.0.45

package/build/schema/engine/additionalProperties.mjs

@@ -1,8 +1,9 @@
 // deno-fmt-ignore-file
 import * as S from '../types/index.mjs';
 import * as V from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Common: GetPropertiesPattern
@@ -51,45 +52,47 @@ export function BuildAdditionalPropertiesFast(context, schema, value) {
 // ------------------------------------------------------------------
 // BuildAdditionalPropertiesStandard
 // ------------------------------------------------------------------
-export function BuildAdditionalPropertiesStandard(context, schema, value) {
-    const regexp = V.CreateExternalVariable(new RegExp(GetPropertiesPattern(schema)));
-    const isSchema = BuildSchema(context, schema.additionalProperties, `${value}[key]`);
-    const isKey = E.Call(E.Member(regexp, 'test'), ['key']);
-    const addKey = context.AddKey('key');
+export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
+    const [key, _index] = [Unique(), Unique()];
+    const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
+    const isSchema = BuildSchema(stack, context, schema.additionalProperties, `${value}[${key}]`);
+    const isKey = E.Call(E.Member(regexp, 'test'), [key]);
+    const addKey = context.AddKey(key);
     const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
-    return E.Every(E.Keys(value), E.Constant(0), ['key', '_'], guarded);
+    const result = E.Every(E.Keys(value), E.Constant(0), [key, _index], guarded);
+    return result;
 }
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildAdditionalProperties(context, schema, value) {
+export function BuildAdditionalProperties(stack, context, schema, value) {
     return CanAdditionalPropertiesFast(context, schema, value)
         ? BuildAdditionalPropertiesFast(context, schema, value)
-        : BuildAdditionalPropertiesStandard(context, schema, value);
+        : BuildAdditionalPropertiesStandard(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckAdditionalProperties(context, schema, value) {
+export function CheckAdditionalProperties(stack, context, schema, value) {
     const regexp = new RegExp(GetPropertiesPattern(schema));
-    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key) => {
+    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
         return regexp.test(key) ||
-            (CheckSchema(context, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (CheckSchema(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
     });
     return isAdditionalProperties;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value) {
+export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
     const regexp = new RegExp(GetPropertiesPattern(schema));
     const additionalProperties = [];
-    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key) => {
+    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextSchemaPath = `${schemaPath}/additionalProperties`;
         const nextInstancePath = `${instancePath}/${key}`;
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const nextContext = new AccumulatedErrorContext();
         const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchema(nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
+            (ErrorSchema(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
         if (!isAdditionalProperty)
             additionalProperties.push(key);
         return isAdditionalProperty;

package/build/schema/engine/allOf.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 BuildAllOf(context: BuildContext, schema: S.XAllOf, value: string): string;
-export declare function CheckAllOf(context: CheckContext, schema: S.XAllOf, value: unknown): boolean;
-export declare function ErrorAllOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAllOf, value: unknown): boolean;
+export declare function BuildAllOf(stack: Stack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
+export declare function CheckAllOf(stack: Stack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
+export declare function ErrorAllOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;

package/build/schema/engine/allOf.mjs

@@ -1,41 +1,41 @@
 // 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 BuildAllOfStandard(context, schema, value) {
-    return Reducer(context, schema.allOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(schema.allOf.length)));
+function BuildAllOfStandard(stack, context, schema, value) {
+    return Reducer(stack, context, schema.allOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(schema.allOf.length)));
 }
-function BuildAllOfFast(context, schema, value) {
-    return E.ReduceAnd(schema.allOf.map((schema) => BuildSchema(context, schema, value)));
+function BuildAllOfFast(stack, context, schema, value) {
+    return E.ReduceAnd(schema.allOf.map((schema) => BuildSchema(stack, context, schema, value)));
 }
-export function BuildAllOf(context, schema, value) {
+export function BuildAllOf(stack, context, schema, value) {
     return context.UseUnevaluated()
-        ? BuildAllOfStandard(context, schema, value)
-        : BuildAllOfFast(context, schema, value);
+        ? BuildAllOfStandard(stack, context, schema, value)
+        : BuildAllOfFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckAllOf(context, schema, value) {
+export function CheckAllOf(stack, context, schema, value) {
     const results = schema.allOf.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(results.length, schema.allOf.length) && context.Merge(results);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorAllOf(context, schemaPath, instancePath, schema, value) {
+export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, value) {
     const failedContexts = [];
     const results = schema.allOf.reduce((result, schema, index) => {
         const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isSchema = ErrorSchema(nextContext, nextSchemaPath, instancePath, schema, value);
+        const nextContext = new AccumulatedErrorContext();
+        const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)
             failedContexts.push(nextContext);
         return isSchema ? [...result, nextContext] : result;

package/build/schema/engine/anyOf.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 BuildAnyOf(context: BuildContext, schema: S.XAnyOf, value: string): string;
-export declare function CheckAnyOf(context: CheckContext, schema: S.XAnyOf, value: unknown): boolean;
-export declare function ErrorAnyOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAnyOf, value: unknown): boolean;
+export declare function BuildAnyOf(stack: Stack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
+export declare function CheckAnyOf(stack: Stack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function ErrorAnyOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

package/build/schema/engine/anyOf.mjs

@@ -1,41 +1,41 @@
 // deno-fmt-ignore-file
+import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { Reducer } from './_reducer.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-import { Reducer } from './_reducer.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-function BuildAnyOfStandard(context, schema, value) {
-    return Reducer(context, schema.anyOf, value, E.IsGreaterThan(E.Member('results', 'length'), E.Constant(0)));
+function BuildAnyOfStandard(stack, context, schema, value) {
+    return Reducer(stack, context, schema.anyOf, value, E.IsGreaterThan(E.Member('results', 'length'), E.Constant(0)));
 }
-function BuildAnyOfFast(context, schema, value) {
-    return E.ReduceOr(schema.anyOf.map((schema) => BuildSchema(context, schema, value)));
+function BuildAnyOfFast(stack, context, schema, value) {
+    return E.ReduceOr(schema.anyOf.map((schema) => BuildSchema(stack, context, schema, value)));
 }
-export function BuildAnyOf(context, schema, value) {
+export function BuildAnyOf(stack, context, schema, value) {
     return context.UseUnevaluated()
-        ? BuildAnyOfStandard(context, schema, value)
-        : BuildAnyOfFast(context, schema, value);
+        ? BuildAnyOfStandard(stack, context, schema, value)
+        : BuildAnyOfFast(stack, context, schema, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckAnyOf(context, schema, value) {
+export function CheckAnyOf(stack, context, schema, value) {
     const results = schema.anyOf.reduce((result, schema, index) => {
-        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.IsGreaterThan(results.length, 0) && context.Merge(results);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorAnyOf(context, schemaPath, instancePath, schema, value) {
+export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
     const failedContexts = [];
     const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const nextContext = new AccumulatedErrorContext();
         const nextSchemaPath = `${schemaPath}/anyOf/${index}`;
-        const isSchema = ErrorSchema(nextContext, nextSchemaPath, instancePath, schema, value);
+        const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
         if (!isSchema)
             failedContexts.push(nextContext);
         return isSchema ? [...result, nextContext] : result;

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

@@ -1,4 +1,5 @@
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildBooleanSchema(context: BuildContext, schema: boolean, value: string): string;
-export declare function CheckBooleanSchema(context: CheckContext, schema: boolean, value: unknown): boolean;
-export declare function ErrorBooleanSchema(context: ErrorContext, schemaPath: string, instancePath: string, 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,20 +3,20 @@ import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildBooleanSchema(context, schema, value) {
+export function BuildBooleanSchema(stack, context, schema, value) {
     return schema ? E.Constant(true) : E.Constant(false);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckBooleanSchema(context, schema, value) {
+export function CheckBooleanSchema(stack, context, schema, value) {
     return schema;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) {
-    return CheckBooleanSchema(context, schema, value) || context.AddError({
+export function ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckBooleanSchema(stack, context, schema, value) || context.AddError({
         keyword: 'boolean',
         schemaPath,
         instancePath,

package/build/schema/engine/const.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 BuildConst(context: BuildContext, schema: S.XConst, value: string): string;
-export declare function CheckConst(context: CheckContext, schema: S.XConst, value: unknown): boolean;
-export declare function ErrorConst(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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

@@ -1,18 +1,18 @@
 // deno-fmt-ignore-file
-import * as V from './_externals.mjs';
+import * as Externals from './_externals.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildConst(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, V.CreateExternalVariable(schema.const));
+        : E.IsDeepEqual(value, Externals.CreateVariable(schema.const));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckConst(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);
@@ -20,8 +20,8 @@ export function CheckConst(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function ErrorConst(context, schemaPath, instancePath, schema, value) {
-    return CheckConst(context, schema, value) || context.AddError({
+export function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckConst(stack, context, schema, value) || context.AddError({
         keyword: 'const',
         schemaPath,
         instancePath,

package/build/schema/engine/contains.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 BuildContains(context: BuildContext, schema: S.XContains, value: string): string;
-export declare function CheckContains(context: CheckContext, schema: S.XContains, value: unknown[]): boolean;
-export declare function ErrorContains(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XContains, value: unknown[]): boolean;
+export declare function BuildContains(stack: Stack, context: BuildContext, schema: Schema.XContains, value: string): string;
+export declare function CheckContains(stack: Stack, context: CheckContext, schema: Schema.XContains, value: unknown[]): boolean;
+export declare function ErrorContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XContains, value: unknown[]): boolean;

package/build/schema/engine/contains.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 { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Invalid
 // ------------------------------------------------------------------
 function IsValid(schema) {
-    return !(S.IsMinContains(schema) && G.IsEqual(schema.minContains, 0));
+    return !(Schema.IsMinContains(schema) && G.IsEqual(schema.minContains, 0));
 }
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildContains(context, schema, value) {
+export function BuildContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
+    const item = Unique();
     const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction(['value'], BuildSchema(context, schema.contains, 'value'))]);
+    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction([item], BuildSchema(stack, context, schema.contains, item))]);
     return E.And(isLength, isSome);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckContains(context, schema, value) {
+export function CheckContains(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
     return !G.IsEqual(value.length, 0) &&
-        value.some((value) => CheckSchema(context, schema.contains, value));
+        value.some((item) => CheckSchema(stack, context, schema.contains, item));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorContains(context, schemaPath, instancePath, schema, value) {
-    return CheckContains(context, schema, value) || context.AddError({
+export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckContains(stack, context, schema, value) || context.AddError({
         keyword: 'contains',
         schemaPath,
         instancePath,

package/build/schema/engine/dependencies.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 BuildDependencies(context: BuildContext, schema: S.XDependencies, value: string): string;
-export declare function CheckDependencies(context: CheckContext, schema: S.XDependencies, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependencies(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependencies(stack: Stack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
+export declare function CheckDependencies(stack: Stack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependencies(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/dependencies.mjs

@@ -4,11 +4,11 @@ import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildDependencies(context, schema, value) {
+export function BuildDependencies(stack, context, schema, value) {
     const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
     const isEveryDependency = E.ReduceAnd(G.Entries(schema.dependencies).map(([key, schema]) => {
         const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(context, schema, value);
+        const isSchema = BuildSchema(stack, context, schema, value);
         const isEveryKey = (schema) => E.ReduceAnd(schema.map((key) => E.HasPropertyKey(value, E.Constant(key))));
         return E.Or(notKey, G.IsArray(schema) ? isEveryKey(schema) : isSchema);
     }));
@@ -17,19 +17,19 @@ export function BuildDependencies(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckDependencies(context, schema, value) {
+export function CheckDependencies(stack, context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.Every(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
             ? schema.every((key) => G.HasPropertyKey(value, key))
-            : CheckSchema(context, schema, value));
+            : CheckSchema(stack, context, schema, value));
     });
     return isLength || isEvery;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDependencies(context, schemaPath, instancePath, schema, value) {
+export function ErrorDependencies(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
@@ -39,7 +39,7 @@ export function ErrorDependencies(context, schemaPath, instancePath, schema, val
                 schemaPath,
                 instancePath,
                 params: { property: key, dependencies: schema },
-            })) : ErrorSchema(context, nextSchemaPath, instancePath, schema, value));
+            })) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
     });
     return isLength || isEvery;
 }

package/build/schema/engine/dependentRequired.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 BuildDependentRequired(context: BuildContext, schema: S.XDependentRequired, value: string): string;
-export declare function CheckDependentRequired(context: CheckContext, schema: S.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentRequired(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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(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(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckDependentRequired(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(context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDependentRequired(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/dependentSchemas.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 BuildDependentSchemas(context: BuildContext, schema: S.XDependentSchemas, value: string): string;
-export declare function CheckDependentSchemas(context: CheckContext, schema: S.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentSchemas(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildDependentSchemas(stack: Stack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
+export declare function CheckDependentSchemas(stack: Stack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorDependentSchemas(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/dependentSchemas.mjs

@@ -4,11 +4,11 @@ import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildDependentSchemas(context, schema, value) {
+export function BuildDependentSchemas(stack, context, schema, value) {
     const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
     const isEvery = E.ReduceAnd(G.Entries(schema.dependentSchemas).map(([key, schema]) => {
         const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(context, schema, value);
+        const isSchema = BuildSchema(stack, context, schema, value);
         return E.Or(notKey, isSchema);
     }));
     return E.Or(isLength, isEvery);
@@ -16,23 +16,23 @@ export function BuildDependentSchemas(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckDependentSchemas(context, schema, value) {
+export function CheckDependentSchemas(stack, context, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.Every(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
         return !G.HasPropertyKey(value, key) ||
-            CheckSchema(context, schema, value);
+            CheckSchema(stack, context, schema, value);
     });
     return isLength || isEvery;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorDependentSchemas(context, schemaPath, instancePath, schema, value) {
+export function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
         const nextSchemaPath = `${schemaPath}/dependentSchemas/${key}`;
         return !G.HasPropertyKey(value, key) ||
-            ErrorSchema(context, nextSchemaPath, instancePath, schema, value);
+            ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
     });
     return isLength || isEvery;
 }

package/build/schema/engine/enum.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 BuildEnum(context: BuildContext, schema: S.XEnum, value: string): string;
-export declare function CheckEnum(context: CheckContext, schema: S.XEnum, value: unknown): boolean;
-export declare function ErrorEnum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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

@@ -1,21 +1,21 @@
 // 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 BuildEnum(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));
-        const variable = V.CreateExternalVariable(option);
+        const variable = Externals.CreateVariable(option);
         return E.IsDeepEqual(value, variable);
     }));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckEnum(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));
@@ -23,8 +23,8 @@ export function CheckEnum(context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorEnum(context, schemaPath, instancePath, schema, value) {
-    return CheckEnum(context, schema, value) || context.AddError({
+export function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckEnum(stack, context, schema, value) || context.AddError({
         keyword: 'enum',
         schemaPath,
         instancePath,

package/build/schema/engine/exclusiveMaximum.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 BuildExclusiveMaximum(context: BuildContext, schema: S.XExclusiveMaximum, value: string): string;
-export declare function CheckExclusiveMaximum(context: CheckContext, schema: S.XExclusiveMaximum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMaximum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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,20 +3,20 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildExclusiveMaximum(context, schema, value) {
+export function BuildExclusiveMaximum(stack, context, schema, value) {
     return E.IsLessThan(value, E.Constant(schema.exclusiveMaximum));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckExclusiveMaximum(context, schema, value) {
+export function CheckExclusiveMaximum(stack, context, schema, value) {
     return G.IsLessThan(value, schema.exclusiveMaximum);
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMaximum(context, schema, value) || context.AddError({
+export function ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError({
         keyword: 'exclusiveMaximum',
         schemaPath,
         instancePath,

package/build/schema/engine/exclusiveMinimum.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 BuildExclusiveMinimum(context: BuildContext, schema: S.XExclusiveMinimum, value: string): string;
-export declare function CheckExclusiveMinimum(context: CheckContext, schema: S.XExclusiveMinimum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMinimum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.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;