typebox 1.0.31 → 1.0.33

package/build/cjs/schema/engine/required.js

@@ -0,0 +1,37 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildRequired = BuildRequired;
+exports.CheckRequired = CheckRequired;
+exports.ErrorRequired = ErrorRequired;
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildRequired(context, schema, value) {
+    return index_1.EmitGuard.ReduceAnd(schema.required.map((key) => index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key))));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckRequired(context, schema, value) {
+    return index_1.Guard.Every(schema.required, 0, (key) => index_1.Guard.HasPropertyKey(value, key));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorRequired(context, schemaPath, instancePath, schema, value) {
+    const requiredProperties = [];
+    const isRequired = index_1.Guard.EveryAll(schema.required, 0, (key) => {
+        const hasKey = index_1.Guard.HasPropertyKey(value, key);
+        if (!hasKey)
+            requiredProperties.push(key);
+        return hasKey;
+    });
+    return isRequired || context.AddError({
+        keyword: 'required',
+        schemaPath,
+        instancePath,
+        params: { requiredProperties }
+    });
+}

package/build/cjs/schema/engine/schema.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildSchema(context: BuildContext, schema: S.XSchemaLike, value: string): string;
+export declare function CheckSchema(context: CheckContext, schema: S.XSchemaLike, value: unknown): boolean;
+export declare function ErrorSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XSchemaLike, value: unknown): boolean;

package/build/cjs/schema/engine/schema.js

@@ -0,0 +1,327 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildSchema = BuildSchema;
+exports.CheckSchema = CheckSchema;
+exports.ErrorSchema = ErrorSchema;
+const S = require("../types/index");
+const index_1 = require("../../guard/index");
+const _refine_1 = require("./_refine");
+const _guard_1 = require("./_guard");
+const additionalItems_1 = require("./additionalItems");
+const additionalProperties_1 = require("./additionalProperties");
+const allOf_1 = require("./allOf");
+const anyOf_1 = require("./anyOf");
+const boolean_1 = require("./boolean");
+const const_1 = require("./const");
+const contains_1 = require("./contains");
+const dependencies_1 = require("./dependencies");
+const dependentRequired_1 = require("./dependentRequired");
+const dependentSchemas_1 = require("./dependentSchemas");
+const enum_1 = require("./enum");
+const exclusiveMaximum_1 = require("./exclusiveMaximum");
+const exclusiveMinimum_1 = require("./exclusiveMinimum");
+const format_1 = require("./format");
+const if_1 = require("./if");
+const items_1 = require("./items");
+const maxContains_1 = require("./maxContains");
+const maximum_1 = require("./maximum");
+const maxItems_1 = require("./maxItems");
+const maxLength_1 = require("./maxLength");
+const maxProperties_1 = require("./maxProperties");
+const minContains_1 = require("./minContains");
+const minimum_1 = require("./minimum");
+const minItems_1 = require("./minItems");
+const minLength_1 = require("./minLength");
+const minProperties_1 = require("./minProperties");
+const multipleOf_1 = require("./multipleOf");
+const not_1 = require("./not");
+const oneOf_1 = require("./oneOf");
+const pattern_1 = require("./pattern");
+const patternProperties_1 = require("./patternProperties");
+const prefixItems_1 = require("./prefixItems");
+const properties_1 = require("./properties");
+const propertyNames_1 = require("./propertyNames");
+const ref_1 = require("./ref");
+const required_1 = require("./required");
+const type_1 = require("./type");
+const unevaluatedItems_1 = require("./unevaluatedItems");
+const unevaluatedProperties_1 = require("./unevaluatedProperties");
+const uniqueItems_1 = require("./uniqueItems");
+// ----------------------------------------------------------------
+// HasTypeName
+// ----------------------------------------------------------------
+function HasTypeName(schema, typename) {
+    return S.IsType(schema) &&
+        (index_1.Guard.IsArray(schema.type) && schema.type.includes(typename) ||
+            index_1.Guard.IsEqual(schema.type, typename));
+}
+// ----------------------------------------------------------------
+// HasObject
+// ----------------------------------------------------------------
+function HasObjectType(schema) {
+    return HasTypeName(schema, 'object');
+}
+function HasObjectKeywords(schema) {
+    return S.IsSchema(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));
+}
+// ----------------------------------------------------------------
+// HasArray
+// ----------------------------------------------------------------
+function HasArrayType(schema) {
+    return HasTypeName(schema, 'array');
+}
+function HasArrayKeywords(schema) {
+    return S.IsSchema(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));
+}
+// ----------------------------------------------------------------
+// HasString
+// ----------------------------------------------------------------
+function HasStringType(schema) {
+    return HasTypeName(schema, 'string');
+}
+function HasStringKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsMinLength(schema) ||
+        S.IsMaxLength(schema) ||
+        S.IsFormat(schema) ||
+        S.IsPattern(schema));
+}
+// ----------------------------------------------------------------
+// HasNumber
+// ----------------------------------------------------------------
+function HasNumberType(schema) {
+    return HasTypeName(schema, 'number') || HasTypeName(schema, 'bigint');
+}
+function HasNumberKeywords(schema) {
+    return S.IsSchema(schema) && (S.IsMinimum(schema) ||
+        S.IsMaximum(schema) ||
+        S.IsExclusiveMaximum(schema) ||
+        S.IsExclusiveMinimum(schema) ||
+        S.IsMultipleOf(schema));
+}
+// ----------------------------------------------------------------
+// Build
+// ----------------------------------------------------------------
+function BuildSchema(context, schema, value) {
+    const conditions = [];
+    if (S.IsBooleanSchema(schema))
+        return (0, boolean_1.BuildBooleanSchema)(context, schema, value);
+    if (S.IsType(schema))
+        conditions.push((0, type_1.BuildType)(context, schema, value));
+    if (HasObjectKeywords(schema)) {
+        const constraints = [];
+        if (S.IsRequired(schema))
+            constraints.push((0, required_1.BuildRequired)(context, schema, value));
+        if (S.IsAdditionalProperties(schema))
+            constraints.push((0, additionalProperties_1.BuildAdditionalProperties)(context, schema, value));
+        if (S.IsDependencies(schema))
+            constraints.push((0, dependencies_1.BuildDependencies)(context, schema, value));
+        if (S.IsDependentRequired(schema))
+            constraints.push((0, dependentRequired_1.BuildDependentRequired)(context, schema, value));
+        if (S.IsDependentSchemas(schema))
+            constraints.push((0, dependentSchemas_1.BuildDependentSchemas)(context, schema, value));
+        if (S.IsPatternProperties(schema))
+            constraints.push((0, patternProperties_1.BuildPatternProperties)(context, schema, value));
+        if (S.IsProperties(schema))
+            constraints.push((0, properties_1.BuildProperties)(context, schema, value));
+        if (S.IsPropertyNames(schema))
+            constraints.push((0, propertyNames_1.BuildPropertyNames)(context, schema, value));
+        if (S.IsMinProperties(schema))
+            constraints.push((0, minProperties_1.BuildMinProperties)(context, schema, value));
+        if (S.IsMaxProperties(schema))
+            constraints.push((0, maxProperties_1.BuildMaxProperties)(context, schema, value));
+        const reduced = index_1.EmitGuard.ReduceAnd(constraints);
+        const guarded = index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.IsObjectNotArray(value)), reduced);
+        conditions.push(HasObjectType(schema) ? reduced : guarded);
+    }
+    if (HasArrayKeywords(schema)) {
+        const constraints = [];
+        if (S.IsAdditionalItems(schema))
+            constraints.push((0, additionalItems_1.BuildAdditionalItems)(context, schema, value));
+        if (S.IsContains(schema))
+            constraints.push((0, contains_1.BuildContains)(context, schema, value));
+        if (S.IsItems(schema))
+            constraints.push((0, items_1.BuildItems)(context, schema, value));
+        if (S.IsMaxContains(schema))
+            constraints.push((0, maxContains_1.BuildMaxContains)(context, schema, value));
+        if (S.IsMaxItems(schema))
+            constraints.push((0, maxItems_1.BuildMaxItems)(context, schema, value));
+        if (S.IsMinContains(schema))
+            constraints.push((0, minContains_1.BuildMinContains)(context, schema, value));
+        if (S.IsMinItems(schema))
+            constraints.push((0, minItems_1.BuildMinItems)(context, schema, value));
+        if (S.IsPrefixItems(schema))
+            constraints.push((0, prefixItems_1.BuildPrefixItems)(context, schema, value));
+        if (S.IsUniqueItems(schema))
+            constraints.push((0, uniqueItems_1.BuildUniqueItems)(context, schema, value));
+        const reduced = index_1.EmitGuard.ReduceAnd(constraints);
+        const guarded = index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.IsArray(value)), reduced);
+        conditions.push(HasArrayType(schema) ? reduced : guarded);
+    }
+    if (HasStringKeywords(schema)) {
+        const constraints = [];
+        if (S.IsFormat(schema))
+            constraints.push((0, format_1.BuildFormat)(context, schema, value));
+        if (S.IsMaxLength(schema))
+            constraints.push((0, maxLength_1.BuildMaxLength)(context, schema, value));
+        if (S.IsMinLength(schema))
+            constraints.push((0, minLength_1.BuildMinLength)(context, schema, value));
+        if (S.IsPattern(schema))
+            constraints.push((0, pattern_1.BuildPattern)(context, schema, value));
+        const reduced = index_1.EmitGuard.ReduceAnd(constraints);
+        const guarded = index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.IsString(value)), reduced);
+        conditions.push(HasStringType(schema) ? reduced : guarded);
+    }
+    if (HasNumberKeywords(schema)) {
+        const constraints = [];
+        if (S.IsExclusiveMaximum(schema))
+            constraints.push((0, exclusiveMaximum_1.BuildExclusiveMaximum)(context, schema, value));
+        if (S.IsExclusiveMinimum(schema))
+            constraints.push((0, exclusiveMinimum_1.BuildExclusiveMinimum)(context, schema, value));
+        if (S.IsMaximum(schema))
+            constraints.push((0, maximum_1.BuildMaximum)(context, schema, value));
+        if (S.IsMinimum(schema))
+            constraints.push((0, minimum_1.BuildMinimum)(context, schema, value));
+        if (S.IsMultipleOf(schema))
+            constraints.push((0, multipleOf_1.BuildMultipleOf)(context, schema, value));
+        const reduced = index_1.EmitGuard.ReduceAnd(constraints);
+        const guarded = index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.Or(index_1.EmitGuard.IsNumber(value), index_1.EmitGuard.IsBigInt(value))), reduced);
+        conditions.push(HasNumberType(schema) ? reduced : guarded);
+    }
+    if (S.IsRef(schema))
+        conditions.push((0, ref_1.BuildRef)(context, schema, value));
+    if (S.IsGuard(schema))
+        conditions.push((0, _guard_1.BuildGuard)(context, schema, value));
+    if (S.IsConst(schema))
+        conditions.push((0, const_1.BuildConst)(context, schema, value));
+    if (S.IsEnum(schema))
+        conditions.push((0, enum_1.BuildEnum)(context, schema, value));
+    if (S.IsIf(schema))
+        conditions.push((0, if_1.BuildIf)(context, schema, value));
+    if (S.IsNot(schema))
+        conditions.push((0, not_1.BuildNot)(context, schema, value));
+    if (S.IsAllOf(schema))
+        conditions.push((0, allOf_1.BuildAllOf)(context, schema, value));
+    if (S.IsAnyOf(schema))
+        conditions.push((0, anyOf_1.BuildAnyOf)(context, schema, value));
+    if (S.IsOneOf(schema))
+        conditions.push((0, oneOf_1.BuildOneOf)(context, schema, value));
+    if (S.IsUnevaluatedItems(schema))
+        conditions.push(index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.IsArray(value)), (0, unevaluatedItems_1.BuildUnevaluatedItems)(context, schema, value)));
+    if (S.IsUnevaluatedProperties(schema))
+        conditions.push(index_1.EmitGuard.Or(index_1.EmitGuard.Not(index_1.EmitGuard.IsObject(value)), (0, unevaluatedProperties_1.BuildUnevaluatedProperties)(context, schema, value)));
+    if (S.IsRefine(schema))
+        conditions.push((0, _refine_1.BuildRefine)(context, schema, value));
+    return index_1.EmitGuard.ReduceAnd(conditions);
+}
+// ----------------------------------------------------------------
+// Check
+// ----------------------------------------------------------------
+function CheckSchema(context, schema, value) {
+    return S.IsBooleanSchema(schema) ? (0, boolean_1.CheckBooleanSchema)(context, schema, value) : ((!S.IsType(schema) || (0, type_1.CheckType)(context, schema, value)) &&
+        (!(index_1.Guard.IsObject(value) && !index_1.Guard.IsArray(value)) || ((!S.IsRequired(schema) || (0, required_1.CheckRequired)(context, schema, value)) &&
+            (!S.IsAdditionalProperties(schema) || (0, additionalProperties_1.CheckAdditionalProperties)(context, schema, value)) &&
+            (!S.IsDependencies(schema) || (0, dependencies_1.CheckDependencies)(context, schema, value)) &&
+            (!S.IsDependentRequired(schema) || (0, dependentRequired_1.CheckDependentRequired)(context, schema, value)) &&
+            (!S.IsDependentSchemas(schema) || (0, dependentSchemas_1.CheckDependentSchemas)(context, schema, value)) &&
+            (!S.IsPatternProperties(schema) || (0, patternProperties_1.CheckPatternProperties)(context, schema, value)) &&
+            (!S.IsProperties(schema) || (0, properties_1.CheckProperties)(context, schema, value)) &&
+            (!S.IsPropertyNames(schema) || (0, propertyNames_1.CheckPropertyNames)(context, schema, value)) &&
+            (!S.IsMinProperties(schema) || (0, minProperties_1.CheckMinProperties)(context, schema, value)) &&
+            (!S.IsMaxProperties(schema) || (0, maxProperties_1.CheckMaxProperties)(context, schema, value)))) &&
+        (!index_1.Guard.IsArray(value) || ((!S.IsAdditionalItems(schema) || (0, additionalItems_1.CheckAdditionalItems)(context, schema, value)) &&
+            (!S.IsContains(schema) || (0, contains_1.CheckContains)(context, schema, value)) &&
+            (!S.IsItems(schema) || (0, items_1.CheckItems)(context, schema, value)) &&
+            (!S.IsMaxContains(schema) || (0, maxContains_1.CheckMaxContains)(context, schema, value)) &&
+            (!S.IsMaxItems(schema) || (0, maxItems_1.CheckMaxItems)(context, schema, value)) &&
+            (!S.IsMinContains(schema) || (0, minContains_1.CheckMinContains)(context, schema, value)) &&
+            (!S.IsMinItems(schema) || (0, minItems_1.CheckMinItems)(context, schema, value)) &&
+            (!S.IsPrefixItems(schema) || (0, prefixItems_1.CheckPrefixItems)(context, schema, value)) &&
+            (!S.IsUniqueItems(schema) || (0, uniqueItems_1.CheckUniqueItems)(context, schema, value)))) &&
+        (!index_1.Guard.IsString(value) || ((!S.IsFormat(schema) || (0, format_1.CheckFormat)(context, schema, value)) &&
+            (!S.IsMaxLength(schema) || (0, maxLength_1.CheckMaxLength)(context, schema, value)) &&
+            (!S.IsMinLength(schema) || (0, minLength_1.CheckMinLength)(context, schema, value)) &&
+            (!S.IsPattern(schema) || (0, pattern_1.CheckPattern)(context, schema, value)))) &&
+        (!(index_1.Guard.IsNumber(value) || index_1.Guard.IsBigInt(value)) || ((!S.IsExclusiveMaximum(schema) || (0, exclusiveMaximum_1.CheckExclusiveMaximum)(context, schema, value)) &&
+            (!S.IsExclusiveMinimum(schema) || (0, exclusiveMinimum_1.CheckExclusiveMinimum)(context, schema, value)) &&
+            (!S.IsMaximum(schema) || (0, maximum_1.CheckMaximum)(context, schema, value)) &&
+            (!S.IsMinimum(schema) || (0, minimum_1.CheckMinimum)(context, schema, value)) &&
+            (!S.IsMultipleOf(schema) || (0, multipleOf_1.CheckMultipleOf)(context, schema, value)))) &&
+        (!S.IsRef(schema) || (0, ref_1.CheckRef)(context, schema, value)) &&
+        (!S.IsGuard(schema) || (0, _guard_1.CheckGuard)(context, schema, value)) &&
+        (!S.IsConst(schema) || (0, const_1.CheckConst)(context, schema, value)) &&
+        (!S.IsEnum(schema) || (0, enum_1.CheckEnum)(context, schema, value)) &&
+        (!S.IsIf(schema) || (0, if_1.CheckIf)(context, schema, value)) &&
+        (!S.IsNot(schema) || (0, not_1.CheckNot)(context, schema, value)) &&
+        (!S.IsAllOf(schema) || (0, allOf_1.CheckAllOf)(context, schema, value)) &&
+        (!S.IsAnyOf(schema) || (0, anyOf_1.CheckAnyOf)(context, schema, value)) &&
+        (!S.IsOneOf(schema) || (0, oneOf_1.CheckOneOf)(context, schema, value)) &&
+        (!S.IsUnevaluatedItems(schema) || (!index_1.Guard.IsArray(value) || (0, unevaluatedItems_1.CheckUnevaluatedItems)(context, schema, value))) &&
+        (!S.IsUnevaluatedProperties(schema) || (!index_1.Guard.IsObject(value) || (0, unevaluatedProperties_1.CheckUnevaluatedProperties)(context, schema, value))) &&
+        (!S.IsRefine(schema) || (0, _refine_1.CheckRefine)(context, schema, value)));
+}
+// ----------------------------------------------------------------
+// Error
+// ----------------------------------------------------------------
+function ErrorSchema(context, schemaPath, instancePath, schema, value) {
+    return (S.IsBooleanSchema(schema)) ? (0, boolean_1.ErrorBooleanSchema)(context, schemaPath, instancePath, schema, value) : (!!(+(!S.IsType(schema) || (0, type_1.ErrorType)(context, schemaPath, instancePath, schema, value)) &
+        +(!(index_1.Guard.IsObject(value) && !index_1.Guard.IsArray(value)) || !!(+(!S.IsRequired(schema) || (0, required_1.ErrorRequired)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsAdditionalProperties(schema) || (0, additionalProperties_1.ErrorAdditionalProperties)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependencies(schema) || (0, dependencies_1.ErrorDependencies)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependentRequired(schema) || (0, dependentRequired_1.ErrorDependentRequired)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsDependentSchemas(schema) || (0, dependentSchemas_1.ErrorDependentSchemas)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPatternProperties(schema) || (0, patternProperties_1.ErrorPatternProperties)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsProperties(schema) || (0, properties_1.ErrorProperties)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPropertyNames(schema) || (0, propertyNames_1.ErrorPropertyNames)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinProperties(schema) || (0, minProperties_1.ErrorMinProperties)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxProperties(schema) || (0, maxProperties_1.ErrorMaxProperties)(context, schemaPath, instancePath, schema, value)))) &
+        +(!index_1.Guard.IsArray(value) || !!(+(!S.IsAdditionalItems(schema) || (0, additionalItems_1.ErrorAdditionalItems)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsContains(schema) || (0, contains_1.ErrorContains)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsItems(schema) || (0, items_1.ErrorItems)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxContains(schema) || (0, maxContains_1.ErrorMaxContains)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxItems(schema) || (0, maxItems_1.ErrorMaxItems)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinContains(schema) || (0, minContains_1.ErrorMinContains)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinItems(schema) || (0, minItems_1.ErrorMinItems)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPrefixItems(schema) || (0, prefixItems_1.ErrorPrefixItems)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsUniqueItems(schema) || (0, uniqueItems_1.ErrorUniqueItems)(context, schemaPath, instancePath, schema, value)))) &
+        +(!index_1.Guard.IsString(value) || !!(+(!S.IsFormat(schema) || (0, format_1.ErrorFormat)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaxLength(schema) || (0, maxLength_1.ErrorMaxLength)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinLength(schema) || (0, minLength_1.ErrorMinLength)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsPattern(schema) || (0, pattern_1.ErrorPattern)(context, schemaPath, instancePath, schema, value)))) &
+        +(!(index_1.Guard.IsNumber(value) || index_1.Guard.IsBigInt(value)) || !!(+(!S.IsExclusiveMaximum(schema) || (0, exclusiveMaximum_1.ErrorExclusiveMaximum)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsExclusiveMinimum(schema) || (0, exclusiveMinimum_1.ErrorExclusiveMinimum)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMaximum(schema) || (0, maximum_1.ErrorMaximum)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMinimum(schema) || (0, minimum_1.ErrorMinimum)(context, schemaPath, instancePath, schema, value)) &
+            +(!S.IsMultipleOf(schema) || (0, multipleOf_1.ErrorMultipleOf)(context, schemaPath, instancePath, schema, value)))) &
+        +(!S.IsRef(schema) || (0, ref_1.ErrorRef)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsGuard(schema) || (0, _guard_1.ErrorGuard)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsConst(schema) || (0, const_1.ErrorConst)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsEnum(schema) || (0, enum_1.ErrorEnum)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsIf(schema) || (0, if_1.ErrorIf)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsNot(schema) || (0, not_1.ErrorNot)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsAllOf(schema) || (0, allOf_1.ErrorAllOf)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsAnyOf(schema) || (0, anyOf_1.ErrorAnyOf)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsOneOf(schema) || (0, oneOf_1.ErrorOneOf)(context, schemaPath, instancePath, schema, value)) &
+        +(!S.IsUnevaluatedItems(schema) || (!index_1.Guard.IsArray(value) || (0, unevaluatedItems_1.ErrorUnevaluatedItems)(context, schemaPath, instancePath, schema, value))) &
+        +(!S.IsUnevaluatedProperties(schema) || (!index_1.Guard.IsObject(value) || (0, unevaluatedProperties_1.ErrorUnevaluatedProperties)(context, schemaPath, instancePath, schema, value)))) &&
+        (!S.IsRefine(schema) || (0, _refine_1.ErrorRefine)(context, schemaPath, instancePath, schema, value)));
+}

package/build/cjs/schema/engine/type.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+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;

package/build/cjs/schema/engine/type.js

@@ -0,0 +1,79 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildType = BuildType;
+exports.CheckType = CheckType;
+exports.ErrorType = ErrorType;
+const index_1 = require("../../guard/index");
+// ------------------------------------------------------------------
+// TypeName
+// ------------------------------------------------------------------
+function BuildTypeName(context, type, value) {
+    return (
+    // jsonschema
+    index_1.Guard.IsEqual(type, 'object') ? index_1.EmitGuard.IsObjectNotArray(value) :
+        index_1.Guard.IsEqual(type, 'array') ? index_1.EmitGuard.IsArray(value) :
+            index_1.Guard.IsEqual(type, 'boolean') ? index_1.EmitGuard.IsBoolean(value) :
+                index_1.Guard.IsEqual(type, 'integer') ? index_1.EmitGuard.IsInteger(value) :
+                    index_1.Guard.IsEqual(type, 'number') ? index_1.EmitGuard.IsNumber(value) :
+                        index_1.Guard.IsEqual(type, 'null') ? index_1.EmitGuard.IsNull(value) :
+                            index_1.Guard.IsEqual(type, 'string') ? index_1.EmitGuard.IsString(value) :
+                                // xschema
+                                index_1.Guard.IsEqual(type, 'asyncIterator') ? index_1.EmitGuard.IsAsyncIterator(value) :
+                                    index_1.Guard.IsEqual(type, 'bigint') ? index_1.EmitGuard.IsBigInt(value) :
+                                        index_1.Guard.IsEqual(type, 'constructor') ? index_1.EmitGuard.IsConstructor(value) :
+                                            index_1.Guard.IsEqual(type, 'function') ? index_1.EmitGuard.IsFunction(value) :
+                                                index_1.Guard.IsEqual(type, 'iterator') ? index_1.EmitGuard.IsIterator(value) :
+                                                    index_1.Guard.IsEqual(type, 'symbol') ? index_1.EmitGuard.IsSymbol(value) :
+                                                        index_1.Guard.IsEqual(type, 'undefined') ? index_1.EmitGuard.IsUndefined(value) :
+                                                            index_1.Guard.IsEqual(type, 'void') ? index_1.EmitGuard.IsUndefined(value) :
+                                                                index_1.EmitGuard.Constant(true));
+}
+function CheckTypeName(context, type, schema, value) {
+    return (
+    // jsonschema
+    index_1.Guard.IsEqual(type, 'object') ? index_1.Guard.IsObjectNotArray(value) :
+        index_1.Guard.IsEqual(type, 'array') ? index_1.Guard.IsArray(value) :
+            index_1.Guard.IsEqual(type, 'boolean') ? index_1.Guard.IsBoolean(value) :
+                index_1.Guard.IsEqual(type, 'integer') ? index_1.Guard.IsInteger(value) :
+                    index_1.Guard.IsEqual(type, 'number') ? index_1.Guard.IsNumber(value) :
+                        index_1.Guard.IsEqual(type, 'null') ? index_1.Guard.IsNull(value) :
+                            index_1.Guard.IsEqual(type, 'string') ? index_1.Guard.IsString(value) :
+                                // xschema
+                                index_1.Guard.IsEqual(type, 'asyncIterator') ? index_1.Guard.IsAsyncIterator(value) :
+                                    index_1.Guard.IsEqual(type, 'bigint') ? index_1.Guard.IsBigInt(value) :
+                                        index_1.Guard.IsEqual(type, 'constructor') ? index_1.Guard.IsConstructor(value) :
+                                            index_1.Guard.IsEqual(type, 'function') ? index_1.Guard.IsFunction(value) :
+                                                index_1.Guard.IsEqual(type, 'iterator') ? index_1.Guard.IsIterator(value) :
+                                                    index_1.Guard.IsEqual(type, 'symbol') ? index_1.Guard.IsSymbol(value) :
+                                                        index_1.Guard.IsEqual(type, 'undefined') ? index_1.Guard.IsUndefined(value) :
+                                                            index_1.Guard.IsEqual(type, 'void') ? index_1.Guard.IsUndefined(value) :
+                                                                true);
+}
+// ------------------------------------------------------------------
+// TypeNames
+// ------------------------------------------------------------------
+function BuildTypeNames(context, typenames, value) {
+    return index_1.EmitGuard.ReduceOr(typenames.map(type => BuildTypeName(context, type, value)));
+}
+function CheckTypeNames(context, types, schema, value) {
+    return types.some(type => CheckTypeName(context, type, schema, value));
+}
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+function BuildType(context, schema, value) {
+    return index_1.Guard.IsArray(schema.type) ? BuildTypeNames(context, schema.type, value) : BuildTypeName(context, schema.type, value);
+}
+function CheckType(context, schema, value) {
+    return index_1.Guard.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
+}
+function ErrorType(context, schemaPath, instancePath, schema, value) {
+    const isType = index_1.Guard.IsArray(schema.type) ? CheckTypeNames(context, schema.type, schema, value) : CheckTypeName(context, schema.type, schema, value);
+    return isType || context.AddError({
+        keyword: 'type',
+        schemaPath,
+        instancePath,
+        params: { type: schema.type }
+    });
+}

package/build/cjs/schema/engine/unevaluatedItems.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+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;

package/build/cjs/schema/engine/unevaluatedItems.js

@@ -0,0 +1,54 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildUnevaluatedItems = BuildUnevaluatedItems;
+exports.CheckUnevaluatedItems = CheckUnevaluatedItems;
+exports.ErrorUnevaluatedItems = ErrorUnevaluatedItems;
+const index_1 = require("../../guard/index");
+const _context_1 = require("./_context");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildUnevaluatedItems(context, schema, value) {
+    const indices = index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'GetIndices'), []);
+    const hasIndex = index_1.EmitGuard.Call(index_1.EmitGuard.Member('indices', 'has'), ['index']);
+    const isSchema = (0, schema_1.BuildSchema)(context, schema.unevaluatedItems, 'value');
+    const addIndex = index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'AddIndex'), ['index']);
+    const isEvery = index_1.EmitGuard.Every(value, index_1.EmitGuard.Constant(0), ['value', 'index'], index_1.EmitGuard.And(index_1.EmitGuard.Or(hasIndex, isSchema), addIndex));
+    return index_1.EmitGuard.Call(index_1.EmitGuard.ArrowFunction(['context'], index_1.EmitGuard.Statements([
+        index_1.EmitGuard.ConstDeclaration('indices', indices),
+        index_1.EmitGuard.Return(isEvery)
+    ])), ['context']);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckUnevaluatedItems(context, schema, value) {
+    const indices = context.GetIndices();
+    return index_1.Guard.Every(value, 0, (value, index) => {
+        return (indices.has(index) || (0, schema_1.CheckSchema)(context, schema.unevaluatedItems, value))
+            && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value) {
+    const indices = context.GetIndices();
+    const unevaluatedItems = [];
+    const isUnevaluatedItems = index_1.Guard.EveryAll(value, 0, (value, index) => {
+        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isEvaluatedItem = (indices.has(index) || (0, schema_1.ErrorSchema)(nextContext, schemaPath, instancePath, schema.unevaluatedItems, value))
+            && context.AddIndex(index);
+        if (!isEvaluatedItem)
+            unevaluatedItems.push(index);
+        return isEvaluatedItem;
+    });
+    return isUnevaluatedItems || context.AddError({
+        keyword: 'unevaluatedItems',
+        schemaPath,
+        instancePath,
+        params: { unevaluatedItems }
+    });
+}

package/build/cjs/schema/engine/unevaluatedProperties.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildUnevaluatedProperties(context: BuildContext, schema: S.XUnevaluatedProperties, value: string): string;
+export declare function CheckUnevaluatedProperties(context: CheckContext, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorUnevaluatedProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/cjs/schema/engine/unevaluatedProperties.js

@@ -0,0 +1,54 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildUnevaluatedProperties = BuildUnevaluatedProperties;
+exports.CheckUnevaluatedProperties = CheckUnevaluatedProperties;
+exports.ErrorUnevaluatedProperties = ErrorUnevaluatedProperties;
+const index_1 = require("../../guard/index");
+const _context_1 = require("./_context");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildUnevaluatedProperties(context, schema, value) {
+    const keys = index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'GetKeys'), []);
+    const hasKey = index_1.EmitGuard.Call(index_1.EmitGuard.Member('keys', 'has'), ['key']);
+    const addKey = index_1.EmitGuard.Call(index_1.EmitGuard.Member('context', 'AddKey'), ['key']);
+    const isSchema = (0, schema_1.BuildSchema)(context, schema.unevaluatedProperties, `value`);
+    const isEvery = index_1.EmitGuard.Every(index_1.EmitGuard.Entries(value), index_1.EmitGuard.Constant(0), ['[key, value]', '_'], index_1.EmitGuard.Or(hasKey, index_1.EmitGuard.And(isSchema, addKey)));
+    return index_1.EmitGuard.Call(index_1.EmitGuard.ArrowFunction(['context'], index_1.EmitGuard.Statements([
+        index_1.EmitGuard.ConstDeclaration('keys', keys),
+        index_1.EmitGuard.Return(isEvery)
+    ])), ['context']);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+function CheckUnevaluatedProperties(context, schema, value) {
+    const keys = context.GetKeys();
+    return index_1.Guard.Every(index_1.Guard.Entries(value), 0, ([key, value]) => {
+        return keys.has(key)
+            || ((0, schema_1.CheckSchema)(context, schema.unevaluatedProperties, value) && context.AddKey(key));
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+function ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value) {
+    const keys = context.GetKeys();
+    const unevaluatedProperties = [];
+    const isUnevaluatedProperties = index_1.Guard.EveryAll(index_1.Guard.Entries(value), 0, ([key, value]) => {
+        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isEvaluatedProperty = keys.has(key)
+            || ((0, schema_1.ErrorSchema)(nextContext, schemaPath, instancePath, schema.unevaluatedProperties, value) && context.AddKey(key));
+        if (!isEvaluatedProperty)
+            unevaluatedProperties.push(key);
+        return isEvaluatedProperty;
+    });
+    return isUnevaluatedProperties || context.AddError({
+        keyword: 'unevaluatedProperties',
+        schemaPath,
+        instancePath,
+        params: { unevaluatedProperties }
+    });
+}

package/build/cjs/schema/engine/uniqueItems.d.ts

@@ -0,0 +1,5 @@
+import * as S from '../types/index';
+import { BuildContext, CheckContext, ErrorContext } from './_context';
+export declare function BuildUniqueItems(context: BuildContext, schema: S.XUniqueItems, value: string): string;
+export declare function CheckUniqueItems(context: CheckContext, schema: S.XUniqueItems, value: unknown[]): boolean;
+export declare function ErrorUniqueItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUniqueItems, value: unknown[]): boolean;