typebox 1.0.33 → 1.0.34

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

@@ -1,111 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CanAdditionalPropertiesFast = CanAdditionalPropertiesFast;
-exports.BuildAdditionalPropertiesFast = BuildAdditionalPropertiesFast;
-exports.BuildAdditionalPropertiesStandard = BuildAdditionalPropertiesStandard;
-exports.BuildAdditionalProperties = BuildAdditionalProperties;
-exports.CheckAdditionalProperties = CheckAdditionalProperties;
-exports.ErrorAdditionalProperties = ErrorAdditionalProperties;
-const S = require("../types/index");
-const V = require("./_externals");
-const index_1 = require("../../guard/index");
-const _context_1 = require("./_context");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Common: GetPropertiesPattern
-//
-// Constructs a regular expression that matches all property keys
-// and pattern properties defined in a schema. This approach unifies
-// handling of both property types, avoiding separate logic paths.
-//
-// If no keys or patterns are present, it returns a pattern that
-// matches nothing: '(?!)'.
-//
-// ------------------------------------------------------------------
-function GetPropertiesPattern(schema) {
-    const patterns = [];
-    if (S.IsPatternProperties(schema))
-        patterns.push(...index_1.Guard.Keys(schema.patternProperties));
-    if (S.IsProperties(schema))
-        patterns.push(...index_1.Guard.Keys(schema.properties));
-    return index_1.Guard.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesFast
-//
-// Optimized logic for schemas with `additionalProperties: false`.
-//
-// This fast-path applies only when:
-// - `additionalProperties` is explicitly set to false,
-// - the schema uses only `properties` (no `patternProperties`),
-// - and all defined properties are required (i.e., no optional keys).
-//
-// This constraint is common when enforcing strict object shapes
-// with only known, fixed keys. When all these conditions are met,
-// we can generate a simplified and efficient runtime check.
-//
-// ------------------------------------------------------------------
-function CanAdditionalPropertiesFast(context, schema, value) {
-    return S.IsRequired(schema)
-        && S.IsProperties(schema)
-        && !S.IsPatternProperties(schema)
-        && index_1.Guard.IsEqual(schema.additionalProperties, false)
-        && index_1.Guard.IsEqual(index_1.Guard.Keys(schema.properties).length, schema.required.length);
-}
-function BuildAdditionalPropertiesFast(context, schema, value) {
-    return index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member(index_1.EmitGuard.Call(index_1.EmitGuard.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), index_1.EmitGuard.Constant(schema.required.length));
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesStandard
-// ------------------------------------------------------------------
-function BuildAdditionalPropertiesStandard(context, schema, value) {
-    const regexp = V.CreateExternalVariable(new RegExp(GetPropertiesPattern(schema)));
-    const isSchema = (0, schema_1.BuildSchema)(context, schema.additionalProperties, `${value}[key]`);
-    const isKey = index_1.EmitGuard.Call(index_1.EmitGuard.Member(regexp, 'test'), ['key']);
-    const addKey = context.AddKey('key');
-    const guarded = context.UseUnevaluated() ? index_1.EmitGuard.Or(isKey, index_1.EmitGuard.And(isSchema, addKey)) : index_1.EmitGuard.Or(isKey, isSchema);
-    return index_1.EmitGuard.Every(index_1.EmitGuard.Keys(value), index_1.EmitGuard.Constant(0), ['key', '_'], guarded);
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAdditionalProperties(context, schema, value) {
-    return CanAdditionalPropertiesFast(context, schema, value)
-        ? BuildAdditionalPropertiesFast(context, schema, value)
-        : BuildAdditionalPropertiesStandard(context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckAdditionalProperties(context, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
-    const isAdditionalProperties = index_1.Guard.Every(index_1.Guard.Keys(value), 0, (key) => {
-        return regexp.test(key) ||
-            ((0, schema_1.CheckSchema)(context, schema.additionalProperties, value[key]) && context.AddKey(key));
-    });
-    return isAdditionalProperties;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value) {
-    const regexp = new RegExp(GetPropertiesPattern(schema));
-    const additionalProperties = [];
-    const isAdditionalProperties = index_1.Guard.EveryAll(index_1.Guard.Keys(value), 0, (key) => {
-        const nextSchemaPath = `${schemaPath}/additionalProperties`;
-        const nextInstancePath = `${instancePath}/${key}`;
-        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isAdditionalProperty = regexp.test(key) ||
-            ((0, schema_1.ErrorSchema)(nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
-        if (!isAdditionalProperty)
-            additionalProperties.push(key);
-        return isAdditionalProperty;
-    });
-    return isAdditionalProperties || context.AddError({
-        keyword: 'additionalProperties',
-        schemaPath,
-        instancePath: instancePath,
-        params: { additionalProperties },
-    });
-}

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

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

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

@@ -1,52 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildAllOf = BuildAllOf;
-exports.CheckAllOf = CheckAllOf;
-exports.ErrorAllOf = ErrorAllOf;
-const index_1 = require("../../guard/index");
-const _context_1 = require("./_context");
-const schema_1 = require("./schema");
-const _reducer_1 = require("./_reducer");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAllOfStandard(context, schema, value) {
-    return (0, _reducer_1.Reducer)(context, schema.allOf, value, index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member('results', 'length'), index_1.EmitGuard.Constant(schema.allOf.length)));
-}
-function BuildAllOfFast(context, schema, value) {
-    return index_1.EmitGuard.ReduceAnd(schema.allOf.map((schema) => (0, schema_1.BuildSchema)(context, schema, value)));
-}
-function BuildAllOf(context, schema, value) {
-    return context.UseUnevaluated()
-        ? BuildAllOfStandard(context, schema, value)
-        : BuildAllOfFast(context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckAllOf(context, schema, value) {
-    const results = schema.allOf.reduce((result, schema) => {
-        const nextContext = context.Clone();
-        return (0, schema_1.CheckSchema)(nextContext, schema, value) ? [...result, nextContext] : result;
-    }, []);
-    return index_1.Guard.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorAllOf(context, schemaPath, instancePath, schema, value) {
-    const failedContexts = [];
-    const results = schema.allOf.reduce((result, schema, index) => {
-        const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isSchema = (0, schema_1.ErrorSchema)(nextContext, nextSchemaPath, instancePath, schema, value);
-        if (!isSchema)
-            failedContexts.push(nextContext);
-        return isSchema ? [...result, nextContext] : result;
-    }, []);
-    const isAllOf = index_1.Guard.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
-    if (!isAllOf)
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isAllOf;
-}

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

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

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

@@ -1,57 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildAnyOf = BuildAnyOf;
-exports.CheckAnyOf = CheckAnyOf;
-exports.ErrorAnyOf = ErrorAnyOf;
-const index_1 = require("../../guard/index");
-const _context_1 = require("./_context");
-const schema_1 = require("./schema");
-const _reducer_1 = require("./_reducer");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAnyOfStandard(context, schema, value) {
-    return (0, _reducer_1.Reducer)(context, schema.anyOf, value, index_1.EmitGuard.IsGreaterThan(index_1.EmitGuard.Member('results', 'length'), index_1.EmitGuard.Constant(0)));
-}
-function BuildAnyOfFast(context, schema, value) {
-    return index_1.EmitGuard.ReduceOr(schema.anyOf.map((schema) => (0, schema_1.BuildSchema)(context, schema, value)));
-}
-function BuildAnyOf(context, schema, value) {
-    return context.UseUnevaluated()
-        ? BuildAnyOfStandard(context, schema, value)
-        : BuildAnyOfFast(context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckAnyOf(context, schema, value) {
-    const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = context.Clone();
-        return (0, schema_1.CheckSchema)(nextContext, schema, value) ? [...result, nextContext] : result;
-    }, []);
-    return index_1.Guard.IsGreaterThan(results.length, 0) && context.Merge(results);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorAnyOf(context, schemaPath, instancePath, schema, value) {
-    const failedContexts = [];
-    const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = new _context_1.AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const nextSchemaPath = `${schemaPath}/anyOf/${index}`;
-        const isSchema = (0, schema_1.ErrorSchema)(nextContext, nextSchemaPath, instancePath, schema, value);
-        if (!isSchema)
-            failedContexts.push(nextContext);
-        return isSchema ? [...result, nextContext] : result;
-    }, []);
-    const isAnyOf = index_1.Guard.IsGreaterThan(results.length, 0) && context.Merge(results);
-    if (!isAnyOf)
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isAnyOf || context.AddError({
-        keyword: 'anyOf',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
-}

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

@@ -1,4 +0,0 @@
-import { BuildContext, CheckContext, ErrorContext } from './_context';
-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;

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

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildBooleanSchema = BuildBooleanSchema;
-exports.CheckBooleanSchema = CheckBooleanSchema;
-exports.ErrorBooleanSchema = ErrorBooleanSchema;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildBooleanSchema(context, schema, value) {
-    return schema ? index_1.EmitGuard.Constant(true) : index_1.EmitGuard.Constant(false);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckBooleanSchema(context, schema, value) {
-    return schema;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) {
-    return CheckBooleanSchema(context, schema, value) || context.AddError({
-        keyword: 'boolean',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
-}

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

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

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

@@ -1,35 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildConst = BuildConst;
-exports.CheckConst = CheckConst;
-exports.ErrorConst = ErrorConst;
-const V = require("./_externals");
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildConst(context, schema, value) {
-    return index_1.Guard.IsValueLike(schema.const)
-        ? index_1.EmitGuard.IsEqual(value, index_1.EmitGuard.Constant(schema.const))
-        : index_1.EmitGuard.IsDeepEqual(value, V.CreateExternalVariable(schema.const));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckConst(context, schema, value) {
-    return index_1.Guard.IsValueLike(schema.const)
-        ? index_1.Guard.IsEqual(value, schema.const)
-        : index_1.Guard.IsDeepEqual(value, schema.const);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function ErrorConst(context, schemaPath, instancePath, schema, value) {
-    return CheckConst(context, schema, value) || context.AddError({
-        keyword: 'const',
-        schemaPath,
-        instancePath,
-        params: { allowedValue: schema.const },
-    });
-}

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

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

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

@@ -1,45 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildContains = BuildContains;
-exports.CheckContains = CheckContains;
-exports.ErrorContains = ErrorContains;
-const S = require("../types/index");
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Invalid
-// ------------------------------------------------------------------
-function IsValid(schema) {
-    return !(S.IsMinContains(schema) && index_1.Guard.IsEqual(schema.minContains, 0));
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildContains(context, schema, value) {
-    if (!IsValid(schema))
-        return index_1.EmitGuard.Constant(true);
-    const isLength = index_1.EmitGuard.Not(index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member(value, 'length'), index_1.EmitGuard.Constant(0)));
-    const isSome = index_1.EmitGuard.Call(index_1.EmitGuard.Member(value, 'some'), [index_1.EmitGuard.ArrowFunction(['value'], (0, schema_1.BuildSchema)(context, schema.contains, 'value'))]);
-    return index_1.EmitGuard.And(isLength, isSome);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckContains(context, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    return !index_1.Guard.IsEqual(value.length, 0) &&
-        value.some((value) => (0, schema_1.CheckSchema)(context, schema.contains, value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorContains(context, schemaPath, instancePath, schema, value) {
-    return CheckContains(context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains: 1 },
-    });
-}

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

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

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

@@ -1,50 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildDependencies = BuildDependencies;
-exports.CheckDependencies = CheckDependencies;
-exports.ErrorDependencies = ErrorDependencies;
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildDependencies(context, schema, value) {
-    const isLength = index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member(index_1.EmitGuard.Keys(value), 'length'), index_1.EmitGuard.Constant(0));
-    const isEveryDependency = index_1.EmitGuard.ReduceAnd(index_1.Guard.Entries(schema.dependencies).map(([key, schema]) => {
-        const notKey = index_1.EmitGuard.Not(index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key)));
-        const isSchema = (0, schema_1.BuildSchema)(context, schema, value);
-        const isEveryKey = (schema) => index_1.EmitGuard.ReduceAnd(schema.map((key) => index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key))));
-        return index_1.EmitGuard.Or(notKey, index_1.Guard.IsArray(schema) ? isEveryKey(schema) : isSchema);
-    }));
-    return index_1.EmitGuard.Or(isLength, isEveryDependency);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckDependencies(context, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEvery = index_1.Guard.Every(index_1.Guard.Entries(schema.dependencies), 0, ([key, schema]) => {
-        return !index_1.Guard.HasPropertyKey(value, key) || (index_1.Guard.IsArray(schema)
-            ? schema.every((key) => index_1.Guard.HasPropertyKey(value, key))
-            : (0, schema_1.CheckSchema)(context, schema, value));
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorDependencies(context, schemaPath, instancePath, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEvery = index_1.Guard.EveryAll(index_1.Guard.Entries(schema.dependencies), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
-        return !index_1.Guard.HasPropertyKey(value, key) || (index_1.Guard.IsArray(schema)
-            ? schema.every((dependency) => index_1.Guard.HasPropertyKey(value, dependency) || context.AddError({
-                keyword: 'dependencies',
-                schemaPath,
-                instancePath,
-                params: { property: key, dependencies: schema },
-            })) : (0, schema_1.ErrorSchema)(context, nextSchemaPath, instancePath, schema, value));
-    });
-    return isLength || isEvery;
-}

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

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

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

@@ -1,45 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildDependentRequired = BuildDependentRequired;
-exports.CheckDependentRequired = CheckDependentRequired;
-exports.ErrorDependentRequired = ErrorDependentRequired;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildDependentRequired(context, schema, value) {
-    const isLength = index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member(index_1.EmitGuard.Keys(value), 'length'), index_1.EmitGuard.Constant(0));
-    const isEvery = index_1.EmitGuard.ReduceAnd(index_1.Guard.Entries(schema.dependentRequired).map(([key, keys]) => {
-        const notKey = index_1.EmitGuard.Not(index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key)));
-        const everyKey = index_1.EmitGuard.ReduceAnd(keys.map((key) => index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key))));
-        return index_1.EmitGuard.Or(notKey, everyKey);
-    }));
-    return index_1.EmitGuard.Or(isLength, isEvery);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckDependentRequired(context, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEvery = index_1.Guard.Every(index_1.Guard.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !index_1.Guard.HasPropertyKey(value, key) ||
-            keys.every((key) => index_1.Guard.HasPropertyKey(value, key));
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorDependentRequired(context, schemaPath, instancePath, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEveryEntry = index_1.Guard.EveryAll(index_1.Guard.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !index_1.Guard.HasPropertyKey(value, key) || index_1.Guard.EveryAll(keys, 0, (dependency) => index_1.Guard.HasPropertyKey(value, dependency) || context.AddError({
-            keyword: 'dependentRequired',
-            schemaPath,
-            instancePath,
-            params: { property: key, dependencies: keys },
-        }));
-    });
-    return isLength || isEveryEntry;
-}

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

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

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

@@ -1,43 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildDependentSchemas = BuildDependentSchemas;
-exports.CheckDependentSchemas = CheckDependentSchemas;
-exports.ErrorDependentSchemas = ErrorDependentSchemas;
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildDependentSchemas(context, schema, value) {
-    const isLength = index_1.EmitGuard.IsEqual(index_1.EmitGuard.Member(index_1.EmitGuard.Keys(value), 'length'), index_1.EmitGuard.Constant(0));
-    const isEvery = index_1.EmitGuard.ReduceAnd(index_1.Guard.Entries(schema.dependentSchemas).map(([key, schema]) => {
-        const notKey = index_1.EmitGuard.Not(index_1.EmitGuard.HasPropertyKey(value, index_1.EmitGuard.Constant(key)));
-        const isSchema = (0, schema_1.BuildSchema)(context, schema, value);
-        return index_1.EmitGuard.Or(notKey, isSchema);
-    }));
-    return index_1.EmitGuard.Or(isLength, isEvery);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckDependentSchemas(context, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEvery = index_1.Guard.Every(index_1.Guard.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        return !index_1.Guard.HasPropertyKey(value, key) ||
-            (0, schema_1.CheckSchema)(context, schema, value);
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorDependentSchemas(context, schemaPath, instancePath, schema, value) {
-    const isLength = index_1.Guard.IsEqual(index_1.Guard.Keys(value).length, 0);
-    const isEvery = index_1.Guard.EveryAll(index_1.Guard.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependentSchemas/${key}`;
-        return !index_1.Guard.HasPropertyKey(value, key) ||
-            (0, schema_1.ErrorSchema)(context, nextSchemaPath, instancePath, schema, value);
-    });
-    return isLength || isEvery;
-}

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

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

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

@@ -1,38 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildEnum = BuildEnum;
-exports.CheckEnum = CheckEnum;
-exports.ErrorEnum = ErrorEnum;
-const V = require("./_externals");
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildEnum(context, schema, value) {
-    return index_1.EmitGuard.ReduceOr(schema.enum.map(option => {
-        if (index_1.Guard.IsValueLike(option))
-            return index_1.EmitGuard.IsEqual(value, index_1.EmitGuard.Constant(option));
-        const variable = V.CreateExternalVariable(option);
-        return index_1.EmitGuard.IsDeepEqual(value, variable);
-    }));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckEnum(context, schema, value) {
-    return schema.enum.some(option => index_1.Guard.IsValueLike(option)
-        ? index_1.Guard.IsEqual(value, option)
-        : index_1.Guard.IsDeepEqual(value, option));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorEnum(context, schemaPath, instancePath, schema, value) {
-    return CheckEnum(context, schema, value) || context.AddError({
-        keyword: 'enum',
-        schemaPath,
-        instancePath,
-        params: { allowedValues: schema.enum }
-    });
-}

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

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

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

@@ -1,30 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BuildExclusiveMaximum = BuildExclusiveMaximum;
-exports.CheckExclusiveMaximum = CheckExclusiveMaximum;
-exports.ErrorExclusiveMaximum = ErrorExclusiveMaximum;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildExclusiveMaximum(context, schema, value) {
-    return index_1.EmitGuard.IsLessThan(value, index_1.EmitGuard.Constant(schema.exclusiveMaximum));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-function CheckExclusiveMaximum(context, schema, value) {
-    return index_1.Guard.IsLessThan(value, schema.exclusiveMaximum);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-function ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMaximum(context, schema, value) || context.AddError({
-        keyword: 'exclusiveMaximum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '<', limit: schema.exclusiveMaximum }
-    });
-}

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

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