typebox 1.0.42 → 1.0.44

package/build/schema/engine/schema.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import * as Schema from '../types/index.mjs';
 import { BuildRefine, CheckRefine, ErrorRefine } from './_refine.mjs';
 import { BuildGuard, CheckGuard, ErrorGuard } from './_guard.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildAdditionalItems, CheckAdditionalItems, ErrorAdditionalItems } from './additionalItems.mjs';
 import { BuildAdditionalProperties, CheckAdditionalProperties, ErrorAdditionalProperties } from './additionalProperties.mjs';
 import { BuildAllOf, CheckAllOf, ErrorAllOf } from './allOf.mjs';
@@ -48,7 +48,7 @@ import { BuildUniqueItems, CheckUniqueItems, ErrorUniqueItems } from './uniqueIt
 // HasTypeName
 // ----------------------------------------------------------------
 function HasTypeName(schema, typename) {
-    return S.IsType(schema) &&
+    return Schema.IsType(schema) &&
         (G.IsArray(schema.type) && schema.type.includes(typename) ||
             G.IsEqual(schema.type, typename));
 }
@@ -59,17 +59,17 @@ function HasObjectType(schema) {
     return HasTypeName(schema, 'object');
 }
 function HasObjectKeywords(schema) {
-    return S.IsSchemaObject(schema) && (S.IsAdditionalProperties(schema) ||
-        S.IsDependencies(schema) ||
-        S.IsDependentRequired(schema) ||
-        S.IsDependentSchemas(schema) ||
-        S.IsProperties(schema) ||
-        S.IsPatternProperties(schema) ||
-        S.IsPropertyNames(schema) ||
-        S.IsMinProperties(schema) ||
-        S.IsMaxProperties(schema) ||
-        S.IsRequired(schema) ||
-        S.IsUnevaluatedProperties(schema));
+    return Schema.IsSchemaObject(schema) && (Schema.IsAdditionalProperties(schema) ||
+        Schema.IsDependencies(schema) ||
+        Schema.IsDependentRequired(schema) ||
+        Schema.IsDependentSchemas(schema) ||
+        Schema.IsProperties(schema) ||
+        Schema.IsPatternProperties(schema) ||
+        Schema.IsPropertyNames(schema) ||
+        Schema.IsMinProperties(schema) ||
+        Schema.IsMaxProperties(schema) ||
+        Schema.IsRequired(schema) ||
+        Schema.IsUnevaluatedProperties(schema));
 }
 // ----------------------------------------------------------------
 // HasArray
@@ -78,16 +78,16 @@ function HasArrayType(schema) {
     return HasTypeName(schema, 'array');
 }
 function HasArrayKeywords(schema) {
-    return S.IsSchemaObject(schema) && (S.IsAdditionalItems(schema) ||
-        S.IsItems(schema) ||
-        S.IsContains(schema) ||
-        S.IsMaxContains(schema) ||
-        S.IsMaxItems(schema) ||
-        S.IsMinContains(schema) ||
-        S.IsMinItems(schema) ||
-        S.IsPrefixItems(schema) ||
-        S.IsUnevaluatedItems(schema) ||
-        S.IsUniqueItems(schema));
+    return Schema.IsSchemaObject(schema) && (Schema.IsAdditionalItems(schema) ||
+        Schema.IsItems(schema) ||
+        Schema.IsContains(schema) ||
+        Schema.IsMaxContains(schema) ||
+        Schema.IsMaxItems(schema) ||
+        Schema.IsMinContains(schema) ||
+        Schema.IsMinItems(schema) ||
+        Schema.IsPrefixItems(schema) ||
+        Schema.IsUnevaluatedItems(schema) ||
+        Schema.IsUniqueItems(schema));
 }
 // ----------------------------------------------------------------
 // HasString
@@ -96,10 +96,10 @@ function HasStringType(schema) {
     return HasTypeName(schema, 'string');
 }
 function HasStringKeywords(schema) {
-    return S.IsSchemaObject(schema) && (S.IsMinLength(schema) ||
-        S.IsMaxLength(schema) ||
-        S.IsFormat(schema) ||
-        S.IsPattern(schema));
+    return Schema.IsSchemaObject(schema) && (Schema.IsMinLength(schema) ||
+        Schema.IsMaxLength(schema) ||
+        Schema.IsFormat(schema) ||
+        Schema.IsPattern(schema));
 }
 // ----------------------------------------------------------------
 // HasNumber
@@ -108,220 +108,229 @@ function HasNumberType(schema) {
     return HasTypeName(schema, 'number') || HasTypeName(schema, 'bigint');
 }
 function HasNumberKeywords(schema) {
-    return S.IsSchemaObject(schema) && (S.IsMinimum(schema) ||
-        S.IsMaximum(schema) ||
-        S.IsExclusiveMaximum(schema) ||
-        S.IsExclusiveMinimum(schema) ||
-        S.IsMultipleOf(schema));
+    return Schema.IsSchemaObject(schema) && (Schema.IsMinimum(schema) ||
+        Schema.IsMaximum(schema) ||
+        Schema.IsExclusiveMaximum(schema) ||
+        Schema.IsExclusiveMinimum(schema) ||
+        Schema.IsMultipleOf(schema));
 }
 // ----------------------------------------------------------------
 // Build
 // ----------------------------------------------------------------
-export function BuildSchema(context, schema, value) {
+export function BuildSchema(stack, context, schema, value) {
+    stack.Push(schema);
     const conditions = [];
-    if (S.IsBooleanSchema(schema))
-        return BuildBooleanSchema(context, schema, value);
-    if (S.IsType(schema))
-        conditions.push(BuildType(context, schema, value));
+    if (Schema.IsBooleanSchema(schema))
+        return BuildBooleanSchema(stack, context, schema, value);
+    if (Schema.IsType(schema))
+        conditions.push(BuildType(stack, context, schema, value));
     if (HasObjectKeywords(schema)) {
         const constraints = [];
-        if (S.IsRequired(schema))
-            constraints.push(BuildRequired(context, schema, value));
-        if (S.IsAdditionalProperties(schema))
-            constraints.push(BuildAdditionalProperties(context, schema, value));
-        if (S.IsDependencies(schema))
-            constraints.push(BuildDependencies(context, schema, value));
-        if (S.IsDependentRequired(schema))
-            constraints.push(BuildDependentRequired(context, schema, value));
-        if (S.IsDependentSchemas(schema))
-            constraints.push(BuildDependentSchemas(context, schema, value));
-        if (S.IsPatternProperties(schema))
-            constraints.push(BuildPatternProperties(context, schema, value));
-        if (S.IsProperties(schema))
-            constraints.push(BuildProperties(context, schema, value));
-        if (S.IsPropertyNames(schema))
-            constraints.push(BuildPropertyNames(context, schema, value));
-        if (S.IsMinProperties(schema))
-            constraints.push(BuildMinProperties(context, schema, value));
-        if (S.IsMaxProperties(schema))
-            constraints.push(BuildMaxProperties(context, schema, value));
+        if (Schema.IsRequired(schema))
+            constraints.push(BuildRequired(stack, context, schema, value));
+        if (Schema.IsAdditionalProperties(schema))
+            constraints.push(BuildAdditionalProperties(stack, context, schema, value));
+        if (Schema.IsDependencies(schema))
+            constraints.push(BuildDependencies(stack, context, schema, value));
+        if (Schema.IsDependentRequired(schema))
+            constraints.push(BuildDependentRequired(stack, context, schema, value));
+        if (Schema.IsDependentSchemas(schema))
+            constraints.push(BuildDependentSchemas(stack, context, schema, value));
+        if (Schema.IsPatternProperties(schema))
+            constraints.push(BuildPatternProperties(stack, context, schema, value));
+        if (Schema.IsProperties(schema))
+            constraints.push(BuildProperties(stack, context, schema, value));
+        if (Schema.IsPropertyNames(schema))
+            constraints.push(BuildPropertyNames(stack, context, schema, value));
+        if (Schema.IsMinProperties(schema))
+            constraints.push(BuildMinProperties(stack, context, schema, value));
+        if (Schema.IsMaxProperties(schema))
+            constraints.push(BuildMaxProperties(stack, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
         const guarded = E.Or(E.Not(E.IsObjectNotArray(value)), reduced);
         conditions.push(HasObjectType(schema) ? reduced : guarded);
     }
     if (HasArrayKeywords(schema)) {
         const constraints = [];
-        if (S.IsAdditionalItems(schema))
-            constraints.push(BuildAdditionalItems(context, schema, value));
-        if (S.IsContains(schema))
-            constraints.push(BuildContains(context, schema, value));
-        if (S.IsItems(schema))
-            constraints.push(BuildItems(context, schema, value));
-        if (S.IsMaxContains(schema))
-            constraints.push(BuildMaxContains(context, schema, value));
-        if (S.IsMaxItems(schema))
-            constraints.push(BuildMaxItems(context, schema, value));
-        if (S.IsMinContains(schema))
-            constraints.push(BuildMinContains(context, schema, value));
-        if (S.IsMinItems(schema))
-            constraints.push(BuildMinItems(context, schema, value));
-        if (S.IsPrefixItems(schema))
-            constraints.push(BuildPrefixItems(context, schema, value));
-        if (S.IsUniqueItems(schema))
-            constraints.push(BuildUniqueItems(context, schema, value));
+        if (Schema.IsAdditionalItems(schema))
+            constraints.push(BuildAdditionalItems(stack, context, schema, value));
+        if (Schema.IsContains(schema))
+            constraints.push(BuildContains(stack, context, schema, value));
+        if (Schema.IsItems(schema))
+            constraints.push(BuildItems(stack, context, schema, value));
+        if (Schema.IsMaxContains(schema))
+            constraints.push(BuildMaxContains(stack, context, schema, value));
+        if (Schema.IsMaxItems(schema))
+            constraints.push(BuildMaxItems(stack, context, schema, value));
+        if (Schema.IsMinContains(schema))
+            constraints.push(BuildMinContains(stack, context, schema, value));
+        if (Schema.IsMinItems(schema))
+            constraints.push(BuildMinItems(stack, context, schema, value));
+        if (Schema.IsPrefixItems(schema))
+            constraints.push(BuildPrefixItems(stack, context, schema, value));
+        if (Schema.IsUniqueItems(schema))
+            constraints.push(BuildUniqueItems(stack, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
         const guarded = E.Or(E.Not(E.IsArray(value)), reduced);
         conditions.push(HasArrayType(schema) ? reduced : guarded);
     }
     if (HasStringKeywords(schema)) {
         const constraints = [];
-        if (S.IsFormat(schema))
-            constraints.push(BuildFormat(context, schema, value));
-        if (S.IsMaxLength(schema))
-            constraints.push(BuildMaxLength(context, schema, value));
-        if (S.IsMinLength(schema))
-            constraints.push(BuildMinLength(context, schema, value));
-        if (S.IsPattern(schema))
-            constraints.push(BuildPattern(context, schema, value));
+        if (Schema.IsFormat(schema))
+            constraints.push(BuildFormat(stack, context, schema, value));
+        if (Schema.IsMaxLength(schema))
+            constraints.push(BuildMaxLength(stack, context, schema, value));
+        if (Schema.IsMinLength(schema))
+            constraints.push(BuildMinLength(stack, context, schema, value));
+        if (Schema.IsPattern(schema))
+            constraints.push(BuildPattern(stack, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
         const guarded = E.Or(E.Not(E.IsString(value)), reduced);
         conditions.push(HasStringType(schema) ? reduced : guarded);
     }
     if (HasNumberKeywords(schema)) {
         const constraints = [];
-        if (S.IsExclusiveMaximum(schema))
-            constraints.push(BuildExclusiveMaximum(context, schema, value));
-        if (S.IsExclusiveMinimum(schema))
-            constraints.push(BuildExclusiveMinimum(context, schema, value));
-        if (S.IsMaximum(schema))
-            constraints.push(BuildMaximum(context, schema, value));
-        if (S.IsMinimum(schema))
-            constraints.push(BuildMinimum(context, schema, value));
-        if (S.IsMultipleOf(schema))
-            constraints.push(BuildMultipleOf(context, schema, value));
+        if (Schema.IsExclusiveMaximum(schema))
+            constraints.push(BuildExclusiveMaximum(stack, context, schema, value));
+        if (Schema.IsExclusiveMinimum(schema))
+            constraints.push(BuildExclusiveMinimum(stack, context, schema, value));
+        if (Schema.IsMaximum(schema))
+            constraints.push(BuildMaximum(stack, context, schema, value));
+        if (Schema.IsMinimum(schema))
+            constraints.push(BuildMinimum(stack, context, schema, value));
+        if (Schema.IsMultipleOf(schema))
+            constraints.push(BuildMultipleOf(stack, context, schema, value));
         const reduced = E.ReduceAnd(constraints);
         const guarded = E.Or(E.Not(E.Or(E.IsNumber(value), E.IsBigInt(value))), reduced);
         conditions.push(HasNumberType(schema) ? reduced : guarded);
     }
-    if (S.IsRecursiveRef(schema))
-        conditions.push(BuildRecursiveRef(context, schema, value));
-    if (S.IsRef(schema))
-        conditions.push(BuildRef(context, schema, value));
-    if (S.IsGuard(schema))
-        conditions.push(BuildGuard(context, schema, value));
-    if (S.IsConst(schema))
-        conditions.push(BuildConst(context, schema, value));
-    if (S.IsEnum(schema))
-        conditions.push(BuildEnum(context, schema, value));
-    if (S.IsIf(schema))
-        conditions.push(BuildIf(context, schema, value));
-    if (S.IsNot(schema))
-        conditions.push(BuildNot(context, schema, value));
-    if (S.IsAllOf(schema))
-        conditions.push(BuildAllOf(context, schema, value));
-    if (S.IsAnyOf(schema))
-        conditions.push(BuildAnyOf(context, schema, value));
-    if (S.IsOneOf(schema))
-        conditions.push(BuildOneOf(context, schema, value));
-    if (S.IsUnevaluatedItems(schema))
-        conditions.push(E.Or(E.Not(E.IsArray(value)), BuildUnevaluatedItems(context, schema, value)));
-    if (S.IsUnevaluatedProperties(schema))
-        conditions.push(E.Or(E.Not(E.IsObject(value)), BuildUnevaluatedProperties(context, schema, value)));
-    if (S.IsRefine(schema))
-        conditions.push(BuildRefine(context, schema, value));
-    return E.ReduceAnd(conditions);
+    if (Schema.IsRecursiveRef(schema))
+        conditions.push(BuildRecursiveRef(stack, context, schema, value));
+    if (Schema.IsRef(schema))
+        conditions.push(BuildRef(stack, context, schema, value));
+    if (Schema.IsGuard(schema))
+        conditions.push(BuildGuard(stack, context, schema, value));
+    if (Schema.IsConst(schema))
+        conditions.push(BuildConst(stack, context, schema, value));
+    if (Schema.IsEnum(schema))
+        conditions.push(BuildEnum(stack, context, schema, value));
+    if (Schema.IsIf(schema))
+        conditions.push(BuildIf(stack, context, schema, value));
+    if (Schema.IsNot(schema))
+        conditions.push(BuildNot(stack, context, schema, value));
+    if (Schema.IsAllOf(schema))
+        conditions.push(BuildAllOf(stack, context, schema, value));
+    if (Schema.IsAnyOf(schema))
+        conditions.push(BuildAnyOf(stack, context, schema, value));
+    if (Schema.IsOneOf(schema))
+        conditions.push(BuildOneOf(stack, context, schema, value));
+    if (Schema.IsUnevaluatedItems(schema))
+        conditions.push(E.Or(E.Not(E.IsArray(value)), BuildUnevaluatedItems(stack, context, schema, value)));
+    if (Schema.IsUnevaluatedProperties(schema))
+        conditions.push(E.Or(E.Not(E.IsObject(value)), BuildUnevaluatedProperties(stack, context, schema, value)));
+    if (Schema.IsRefine(schema))
+        conditions.push(BuildRefine(stack, context, schema, value));
+    const result = E.ReduceAnd(conditions);
+    stack.Pop(schema);
+    return result;
 }
 // ----------------------------------------------------------------
 // Check
 // ----------------------------------------------------------------
-export function CheckSchema(context, schema, value) {
-    return S.IsBooleanSchema(schema) ? CheckBooleanSchema(context, schema, value) : ((!S.IsType(schema) || CheckType(context, schema, value)) &&
-        (!(G.IsObject(value) && !G.IsArray(value)) || ((!S.IsRequired(schema) || CheckRequired(context, schema, value)) &&
-            (!S.IsAdditionalProperties(schema) || CheckAdditionalProperties(context, schema, value)) &&
-            (!S.IsDependencies(schema) || CheckDependencies(context, schema, value)) &&
-            (!S.IsDependentRequired(schema) || CheckDependentRequired(context, schema, value)) &&
-            (!S.IsDependentSchemas(schema) || CheckDependentSchemas(context, schema, value)) &&
-            (!S.IsPatternProperties(schema) || CheckPatternProperties(context, schema, value)) &&
-            (!S.IsProperties(schema) || CheckProperties(context, schema, value)) &&
-            (!S.IsPropertyNames(schema) || CheckPropertyNames(context, schema, value)) &&
-            (!S.IsMinProperties(schema) || CheckMinProperties(context, schema, value)) &&
-            (!S.IsMaxProperties(schema) || CheckMaxProperties(context, schema, value)))) &&
-        (!G.IsArray(value) || ((!S.IsAdditionalItems(schema) || CheckAdditionalItems(context, schema, value)) &&
-            (!S.IsContains(schema) || CheckContains(context, schema, value)) &&
-            (!S.IsItems(schema) || CheckItems(context, schema, value)) &&
-            (!S.IsMaxContains(schema) || CheckMaxContains(context, schema, value)) &&
-            (!S.IsMaxItems(schema) || CheckMaxItems(context, schema, value)) &&
-            (!S.IsMinContains(schema) || CheckMinContains(context, schema, value)) &&
-            (!S.IsMinItems(schema) || CheckMinItems(context, schema, value)) &&
-            (!S.IsPrefixItems(schema) || CheckPrefixItems(context, schema, value)) &&
-            (!S.IsUniqueItems(schema) || CheckUniqueItems(context, schema, value)))) &&
-        (!G.IsString(value) || ((!S.IsFormat(schema) || CheckFormat(context, schema, value)) &&
-            (!S.IsMaxLength(schema) || CheckMaxLength(context, schema, value)) &&
-            (!S.IsMinLength(schema) || CheckMinLength(context, schema, value)) &&
-            (!S.IsPattern(schema) || CheckPattern(context, schema, value)))) &&
-        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!S.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(context, schema, value)) &&
-            (!S.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(context, schema, value)) &&
-            (!S.IsMaximum(schema) || CheckMaximum(context, schema, value)) &&
-            (!S.IsMinimum(schema) || CheckMinimum(context, schema, value)) &&
-            (!S.IsMultipleOf(schema) || CheckMultipleOf(context, schema, value)))) &&
-        (!S.IsRecursiveRef(schema) || CheckRecursiveRef(context, schema, value)) &&
-        (!S.IsRef(schema) || CheckRef(context, schema, value)) &&
-        (!S.IsGuard(schema) || CheckGuard(context, schema, value)) &&
-        (!S.IsConst(schema) || CheckConst(context, schema, value)) &&
-        (!S.IsEnum(schema) || CheckEnum(context, schema, value)) &&
-        (!S.IsIf(schema) || CheckIf(context, schema, value)) &&
-        (!S.IsNot(schema) || CheckNot(context, schema, value)) &&
-        (!S.IsAllOf(schema) || CheckAllOf(context, schema, value)) &&
-        (!S.IsAnyOf(schema) || CheckAnyOf(context, schema, value)) &&
-        (!S.IsOneOf(schema) || CheckOneOf(context, schema, value)) &&
-        (!S.IsUnevaluatedItems(schema) || (!G.IsArray(value) || CheckUnevaluatedItems(context, schema, value))) &&
-        (!S.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || CheckUnevaluatedProperties(context, schema, value))) &&
-        (!S.IsRefine(schema) || CheckRefine(context, schema, value)));
+export function CheckSchema(stack, context, schema, value) {
+    stack.Push(schema);
+    const result = Schema.IsBooleanSchema(schema) ? CheckBooleanSchema(stack, context, schema, value) : ((!Schema.IsType(schema) || CheckType(stack, context, schema, value)) &&
+        (!(G.IsObject(value) && !G.IsArray(value)) || ((!Schema.IsRequired(schema) || CheckRequired(stack, context, schema, value)) &&
+            (!Schema.IsAdditionalProperties(schema) || CheckAdditionalProperties(stack, context, schema, value)) &&
+            (!Schema.IsDependencies(schema) || CheckDependencies(stack, context, schema, value)) &&
+            (!Schema.IsDependentRequired(schema) || CheckDependentRequired(stack, context, schema, value)) &&
+            (!Schema.IsDependentSchemas(schema) || CheckDependentSchemas(stack, context, schema, value)) &&
+            (!Schema.IsPatternProperties(schema) || CheckPatternProperties(stack, context, schema, value)) &&
+            (!Schema.IsProperties(schema) || CheckProperties(stack, context, schema, value)) &&
+            (!Schema.IsPropertyNames(schema) || CheckPropertyNames(stack, context, schema, value)) &&
+            (!Schema.IsMinProperties(schema) || CheckMinProperties(stack, context, schema, value)) &&
+            (!Schema.IsMaxProperties(schema) || CheckMaxProperties(stack, context, schema, value)))) &&
+        (!G.IsArray(value) || ((!Schema.IsAdditionalItems(schema) || CheckAdditionalItems(stack, context, schema, value)) &&
+            (!Schema.IsContains(schema) || CheckContains(stack, context, schema, value)) &&
+            (!Schema.IsItems(schema) || CheckItems(stack, context, schema, value)) &&
+            (!Schema.IsMaxContains(schema) || CheckMaxContains(stack, context, schema, value)) &&
+            (!Schema.IsMaxItems(schema) || CheckMaxItems(stack, context, schema, value)) &&
+            (!Schema.IsMinContains(schema) || CheckMinContains(stack, context, schema, value)) &&
+            (!Schema.IsMinItems(schema) || CheckMinItems(stack, context, schema, value)) &&
+            (!Schema.IsPrefixItems(schema) || CheckPrefixItems(stack, context, schema, value)) &&
+            (!Schema.IsUniqueItems(schema) || CheckUniqueItems(stack, context, schema, value)))) &&
+        (!G.IsString(value) || ((!Schema.IsFormat(schema) || CheckFormat(stack, context, schema, value)) &&
+            (!Schema.IsMaxLength(schema) || CheckMaxLength(stack, context, schema, value)) &&
+            (!Schema.IsMinLength(schema) || CheckMinLength(stack, context, schema, value)) &&
+            (!Schema.IsPattern(schema) || CheckPattern(stack, context, schema, value)))) &&
+        (!(G.IsNumber(value) || G.IsBigInt(value)) || ((!Schema.IsExclusiveMaximum(schema) || CheckExclusiveMaximum(stack, context, schema, value)) &&
+            (!Schema.IsExclusiveMinimum(schema) || CheckExclusiveMinimum(stack, context, schema, value)) &&
+            (!Schema.IsMaximum(schema) || CheckMaximum(stack, context, schema, value)) &&
+            (!Schema.IsMinimum(schema) || CheckMinimum(stack, context, schema, value)) &&
+            (!Schema.IsMultipleOf(schema) || CheckMultipleOf(stack, context, schema, value)))) &&
+        (!Schema.IsRecursiveRef(schema) || CheckRecursiveRef(stack, context, schema, value)) &&
+        (!Schema.IsRef(schema) || CheckRef(stack, context, schema, value)) &&
+        (!Schema.IsGuard(schema) || CheckGuard(stack, context, schema, value)) &&
+        (!Schema.IsConst(schema) || CheckConst(stack, context, schema, value)) &&
+        (!Schema.IsEnum(schema) || CheckEnum(stack, context, schema, value)) &&
+        (!Schema.IsIf(schema) || CheckIf(stack, context, schema, value)) &&
+        (!Schema.IsNot(schema) || CheckNot(stack, context, schema, value)) &&
+        (!Schema.IsAllOf(schema) || CheckAllOf(stack, context, schema, value)) &&
+        (!Schema.IsAnyOf(schema) || CheckAnyOf(stack, context, schema, value)) &&
+        (!Schema.IsOneOf(schema) || CheckOneOf(stack, context, schema, value)) &&
+        (!Schema.IsUnevaluatedItems(schema) || (!G.IsArray(value) || CheckUnevaluatedItems(stack, context, schema, value))) &&
+        (!Schema.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || CheckUnevaluatedProperties(stack, context, schema, value))) &&
+        (!Schema.IsRefine(schema) || CheckRefine(stack, context, schema, value)));
+    stack.Pop(schema);
+    return result;
 }
 // ----------------------------------------------------------------
 // Error
 // ----------------------------------------------------------------
-export function ErrorSchema(context, schemaPath, instancePath, schema, value) {
-    return (S.IsBooleanSchema(schema)) ? ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) : (!!(+(!S.IsType(schema) || ErrorType(context, schemaPath, instancePath, schema, value)) &
-        +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!S.IsRequired(schema) || ErrorRequired(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsAdditionalProperties(schema) || ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsDependencies(schema) || ErrorDependencies(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsDependentRequired(schema) || ErrorDependentRequired(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsDependentSchemas(schema) || ErrorDependentSchemas(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsPatternProperties(schema) || ErrorPatternProperties(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsProperties(schema) || ErrorProperties(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsPropertyNames(schema) || ErrorPropertyNames(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMinProperties(schema) || ErrorMinProperties(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMaxProperties(schema) || ErrorMaxProperties(context, schemaPath, instancePath, schema, value)))) &
-        +(!G.IsArray(value) || !!(+(!S.IsAdditionalItems(schema) || ErrorAdditionalItems(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsContains(schema) || ErrorContains(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsItems(schema) || ErrorItems(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMaxContains(schema) || ErrorMaxContains(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMaxItems(schema) || ErrorMaxItems(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMinContains(schema) || ErrorMinContains(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMinItems(schema) || ErrorMinItems(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsPrefixItems(schema) || ErrorPrefixItems(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsUniqueItems(schema) || ErrorUniqueItems(context, schemaPath, instancePath, schema, value)))) &
-        +(!G.IsString(value) || !!(+(!S.IsFormat(schema) || ErrorFormat(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMaxLength(schema) || ErrorMaxLength(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMinLength(schema) || ErrorMinLength(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsPattern(schema) || ErrorPattern(context, schemaPath, instancePath, schema, value)))) &
-        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!S.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMaximum(schema) || ErrorMaximum(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMinimum(schema) || ErrorMinimum(context, schemaPath, instancePath, schema, value)) &
-            +(!S.IsMultipleOf(schema) || ErrorMultipleOf(context, schemaPath, instancePath, schema, value)))) &
-        +(!S.IsRecursiveRef(schema) || ErrorRecursiveRef(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsRef(schema) || ErrorRef(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsGuard(schema) || ErrorGuard(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsConst(schema) || ErrorConst(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsEnum(schema) || ErrorEnum(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsIf(schema) || ErrorIf(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsNot(schema) || ErrorNot(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsAllOf(schema) || ErrorAllOf(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsAnyOf(schema) || ErrorAnyOf(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsOneOf(schema) || ErrorOneOf(context, schemaPath, instancePath, schema, value)) &
-        +(!S.IsUnevaluatedItems(schema) || (!G.IsArray(value) || ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value))) &
-        +(!S.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value)))) &&
-        (!S.IsRefine(schema) || ErrorRefine(context, schemaPath, instancePath, schema, value)));
+export function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
+    stack.Push(schema);
+    const result = (Schema.IsBooleanSchema(schema)) ? ErrorBooleanSchema(stack, context, schemaPath, instancePath, schema, value) : (!!(+(!Schema.IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!(G.IsObject(value) && !G.IsArray(value)) || !!(+(!Schema.IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsAdditionalProperties(schema) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsDependencies(schema) || ErrorDependencies(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsDependentRequired(schema) || ErrorDependentRequired(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsDependentSchemas(schema) || ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsPatternProperties(schema) || ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsProperties(schema) || ErrorProperties(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsPropertyNames(schema) || ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMinProperties(schema) || ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxProperties(schema) || ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value)))) &
+        +(!G.IsArray(value) || !!(+(!Schema.IsAdditionalItems(schema) || ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsContains(schema) || ErrorContains(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsItems(schema) || ErrorItems(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxContains(schema) || ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxItems(schema) || ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMinContains(schema) || ErrorMinContains(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMinItems(schema) || ErrorMinItems(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsPrefixItems(schema) || ErrorPrefixItems(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsUniqueItems(schema) || ErrorUniqueItems(stack, context, schemaPath, instancePath, schema, value)))) &
+        +(!G.IsString(value) || !!(+(!Schema.IsFormat(schema) || ErrorFormat(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaxLength(schema) || ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMinLength(schema) || ErrorMinLength(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsPattern(schema) || ErrorPattern(stack, context, schemaPath, instancePath, schema, value)))) &
+        +(!(G.IsNumber(value) || G.IsBigInt(value)) || !!(+(!Schema.IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMaximum(schema) || ErrorMaximum(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMinimum(schema) || ErrorMinimum(stack, context, schemaPath, instancePath, schema, value)) &
+            +(!Schema.IsMultipleOf(schema) || ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value)))) &
+        +(!Schema.IsRecursiveRef(schema) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsRef(schema) || ErrorRef(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsGuard(schema) || ErrorGuard(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsConst(schema) || ErrorConst(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsEnum(schema) || ErrorEnum(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsIf(schema) || ErrorIf(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsNot(schema) || ErrorNot(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsAllOf(schema) || ErrorAllOf(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsAnyOf(schema) || ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsOneOf(schema) || ErrorOneOf(stack, context, schemaPath, instancePath, schema, value)) &
+        +(!Schema.IsUnevaluatedItems(schema) || (!G.IsArray(value) || ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema, value))) &
+        +(!Schema.IsUnevaluatedProperties(schema) || (!G.IsObject(value) || ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema, value)))) &&
+        (!Schema.IsRefine(schema) || ErrorRefine(stack, context, schemaPath, instancePath, schema, value)));
+    stack.Pop(schema);
+    return result;
 }

package/build/schema/engine/type.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 BuildType(context: BuildContext, schema: S.XType, value: string): string;
-export declare function CheckType(context: CheckContext, schema: S.XType, value: unknown): boolean;
-export declare function ErrorType(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XType, value: unknown): boolean;
+export declare function BuildType(stack: Stack, context: BuildContext, schema: Schema.XType, value: string): string;
+export declare function CheckType(stack: Stack, context: CheckContext, schema: Schema.XType, value: unknown): boolean;
+export declare function ErrorType(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XType, value: unknown): boolean;

package/build/schema/engine/type.mjs

@@ -3,7 +3,7 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // TypeName
 // ------------------------------------------------------------------
-function BuildTypeName(context, type, value) {
+function BuildTypeName(stack, context, type, value) {
     return (
     // jsonschema
     G.IsEqual(type, 'object') ? E.IsObjectNotArray(value) :
@@ -24,7 +24,7 @@ function BuildTypeName(context, type, value) {
                                                             G.IsEqual(type, 'void') ? E.IsUndefined(value) :
                                                                 E.Constant(true));
 }
-function CheckTypeName(context, type, schema, value) {
+function CheckTypeName(stack, context, type, schema, value) {
     return (
     // jsonschema
     G.IsEqual(type, 'object') ? G.IsObjectNotArray(value) :
@@ -48,23 +48,23 @@ function CheckTypeName(context, type, schema, value) {
 // ------------------------------------------------------------------
 // TypeNames
 // ------------------------------------------------------------------
-function BuildTypeNames(context, typenames, value) {
-    return E.ReduceOr(typenames.map(type => BuildTypeName(context, type, value)));
+function BuildTypeNames(stack, context, typenames, value) {
+    return E.ReduceOr(typenames.map(type => BuildTypeName(stack, context, type, value)));
 }
-function CheckTypeNames(context, types, schema, value) {
-    return types.some(type => CheckTypeName(context, type, schema, value));
+function CheckTypeNames(stack, context, types, schema, value) {
+    return types.some(type => CheckTypeName(stack, context, type, schema, value));
 }
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------
-export function BuildType(context, schema, value) {
-    return G.IsArray(schema.type) ? BuildTypeNames(context, schema.type, value) : BuildTypeName(context, schema.type, value);
+export function BuildType(stack, context, schema, value) {
+    return G.IsArray(schema.type) ? BuildTypeNames(stack, context, schema.type, value) : BuildTypeName(stack, context, schema.type, value);
 }
-export function CheckType(context, schema, value) {
-    return G.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
+export function CheckType(stack, context, schema, value) {
+    return G.IsArray(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value);
 }
-export function ErrorType(context, schemaPath, instancePath, schema, value) {
-    const isType = G.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
+export function ErrorType(stack, context, schemaPath, instancePath, schema, value) {
+    const isType = G.IsArray(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value);
     return isType || context.AddError({
         keyword: 'type',
         schemaPath,

package/build/schema/engine/unevaluatedItems.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 BuildUnevaluatedItems(context: BuildContext, schema: S.XUnevaluatedItems, value: string): string;
-export declare function CheckUnevaluatedItems(context: CheckContext, schema: S.XUnevaluatedItems, value: unknown[]): boolean;
-export declare function ErrorUnevaluatedItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUnevaluatedItems, value: unknown[]): boolean;
+export declare function BuildUnevaluatedItems(stack: Stack, context: BuildContext, schema: Schema.XUnevaluatedItems, value: string): string;
+export declare function CheckUnevaluatedItems(stack: Stack, context: CheckContext, schema: Schema.XUnevaluatedItems, value: unknown[]): boolean;
+export declare function ErrorUnevaluatedItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUnevaluatedItems, value: unknown[]): boolean;