typebox 0.0.1 → 1.0.0-rc

package/build/schema/engine/additionalItems.mjs

@@ -0,0 +1,48 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return S.IsItems(schema) && G.IsArray(schema.items);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildAdditionalItems(context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const isSchema = BuildSchema(context, schema.additionalItems, 'element');
+    const isLength = E.IsLessThan('index', E.Constant(schema.items.length));
+    const addIndex = context.AddIndex('index');
+    const guarded = context.UseUnevaluated() ? E.Or(isLength, E.And(isSchema, addIndex)) : E.Or(isLength, isSchema);
+    return E.Call(E.Member(value, 'every'), [E.ArrowFunction(['element', 'index'], guarded)]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAdditionalItems(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((element, index) => {
+        return G.IsLessThan(index, schema.items.length)
+            || (CheckSchema(context, schema.additionalItems, element) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAdditionalItems(context, schemaPath, instancePath, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((element, index) => {
+        const nextSchemaPath = `${schemaPath}/additionalItems`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsLessThan(index, schema.items.length) ||
+            (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema.additionalItems, element) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}

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

@@ -0,0 +1,8 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function CanAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties, value: string): schema is S.XAdditionalProperties & S.XRequired;
+export declare function BuildAdditionalPropertiesFast(context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
+export declare function BuildAdditionalPropertiesStandard(context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function BuildAdditionalProperties(context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function CheckAdditionalProperties(context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorAdditionalProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/additionalProperties.mjs

@@ -0,0 +1,103 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import * as V from './_externals.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// 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(...G.Keys(schema.patternProperties));
+    if (S.IsProperties(schema))
+        patterns.push(...G.Keys(schema.properties));
+    return G.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.
+//
+// ------------------------------------------------------------------
+export function CanAdditionalPropertiesFast(context, schema, value) {
+    return S.IsRequired(schema)
+        && S.IsProperties(schema)
+        && !S.IsPatternProperties(schema)
+        && G.IsEqual(schema.additionalProperties, false)
+        && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
+}
+export function BuildAdditionalPropertiesFast(context, schema, value) {
+    return E.IsEqual(E.Member(E.Call(E.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), E.Constant(schema.required.length));
+}
+// ------------------------------------------------------------------
+// BuildAdditionalPropertiesStandard
+// ------------------------------------------------------------------
+export function BuildAdditionalPropertiesStandard(context, schema, value) {
+    const regexp = V.CreateExternalVariable(new RegExp(GetPropertiesPattern(schema)));
+    const isSchema = BuildSchema(context, schema.additionalProperties, `${value}[key]`);
+    const isKey = E.Call(E.Member(regexp, 'test'), ['key']);
+    const addKey = context.AddKey('key');
+    const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
+    return E.Call(E.Member(E.Keys(value), 'every'), [E.ArrowFunction(['key'], guarded)]);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildAdditionalProperties(context, schema, value) {
+    return CanAdditionalPropertiesFast(context, schema, value)
+        ? BuildAdditionalPropertiesFast(context, schema, value)
+        : BuildAdditionalPropertiesStandard(context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAdditionalProperties(context, schema, value) {
+    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const isAdditionalProperties = G.Every(G.Keys(value), (key) => {
+        return regexp.test(key) ||
+            (CheckSchema(context, schema.additionalProperties, value[key]) && context.AddKey(key));
+    });
+    return isAdditionalProperties;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAdditionalProperties(context, schemaPath, instancePath, schema, value) {
+    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const additionalProperties = [];
+    const isAdditionalProperties = G.EveryAll(G.Keys(value), (key) => {
+        const nextSchemaPath = `${schemaPath}/additionalProperties`;
+        const nextInstancePath = `${instancePath}/${key}`;
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isAdditionalProperty = regexp.test(key) ||
+            (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: `${schemaPath}/additionalProperties`,
+        instancePath: instancePath,
+        params: { additionalProperties },
+    });
+}

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

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

package/build/schema/engine/allOf.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Reducer } from './_reducer.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildAllOfStandard(context, schema, value) {
+    return Reducer(context, schema.allOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(schema.allOf.length)));
+}
+function BuildAllOfFast(context, schema, value) {
+    return E.ReduceAnd(schema.allOf.map((schema) => BuildSchema(context, schema, value)));
+}
+export function BuildAllOf(context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildAllOfStandard(context, schema, value)
+        : BuildAllOfFast(context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAllOf(context, schema, value) {
+    const results = schema.allOf.reduce((result, schema) => {
+        const nextContext = context.Clone();
+        return CheckSchema(nextContext, schema, value) ? [...result, nextContext] : result;
+    }, []);
+    return G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAllOf(context, schemaPath, instancePath, schema, value) {
+    const failedContexts = [];
+    const results = schema.allOf.reduce((result, schema, index) => {
+        const nextSchemaPath = `${schemaPath}/allOf/${index}`;
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isSchema = ErrorSchema(nextContext, nextSchemaPath, instancePath, schema, value);
+        if (!isSchema)
+            failedContexts.push(nextContext);
+        return isSchema ? [...result, nextContext] : result;
+    }, []);
+    const isAllOf = G.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/schema/engine/anyOf.d.mts

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

package/build/schema/engine/anyOf.mjs

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

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

@@ -0,0 +1,4 @@
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildBooleanSchema(context: BuildContext, schema: boolean, value: string): string;
+export declare function CheckBooleanSchema(context: CheckContext, schema: boolean, value: unknown): boolean;
+export declare function ErrorBooleanSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

package/build/schema/engine/boolean.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildBooleanSchema(context, schema, value) {
+    return schema ? E.Constant(true) : E.Constant(false);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckBooleanSchema(context, schema, value) {
+    return schema;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorBooleanSchema(context, schemaPath, instancePath, schema, value) {
+    return CheckBooleanSchema(context, schema, value) || context.AddError({
+        keyword: 'boolean',
+        schemaPath: `${schemaPath}/${schema}`,
+        instancePath,
+        params: {}
+    });
+}

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

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

package/build/schema/engine/const.mjs

@@ -0,0 +1,30 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildConst(context, schema, value) {
+    return G.IsValueLike(schema.const)
+        ? E.IsEqual(value, E.Constant(schema.const))
+        : E.IsDeepEqual(value, V.CreateExternalVariable(schema.const));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckConst(context, schema, value) {
+    return G.IsValueLike(schema.const)
+        ? G.IsEqual(value, schema.const)
+        : G.IsDeepEqual(value, schema.const);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function ErrorConst(context, schemaPath, instancePath, schema, value) {
+    return CheckConst(context, schema, value) || context.AddError({
+        keyword: 'const',
+        schemaPath: `${schemaPath}/const`,
+        instancePath,
+        params: { allowedValue: schema.const },
+    });
+}

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

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

package/build/schema/engine/contains.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Invalid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return !(S.IsMinContains(schema) && G.IsEqual(schema.minContains, 0));
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildContains(context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
+    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction(['value'], BuildSchema(context, schema.contains, 'value'))]);
+    return E.And(isLength, isSome);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckContains(context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    return !G.IsEqual(value.length, 0) &&
+        value.some((value) => CheckSchema(context, schema.contains, value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorContains(context, schemaPath, instancePath, schema, value) {
+    return CheckContains(context, schema, value) || context.AddError({
+        keyword: 'contains',
+        schemaPath: `${schemaPath}/contains`,
+        instancePath,
+        params: { minContains: 1 },
+    });
+}

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

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

package/build/schema/engine/dependencies.mjs

@@ -0,0 +1,45 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildDependencies(context, schema, value) {
+    const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
+    const isEveryDependency = E.ReduceAnd(G.Entries(schema.dependencies).map(([key, schema]) => {
+        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
+        const isSchema = BuildSchema(context, schema, value);
+        const isEveryKey = (schema) => E.ReduceAnd(schema.map((key) => E.HasPropertyKey(value, E.Constant(key))));
+        return E.Or(notKey, G.IsArray(schema) ? isEveryKey(schema) : isSchema);
+    }));
+    return E.Or(isLength, isEveryDependency);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckDependencies(context, schema, value) {
+    const isLength = G.IsEqual(G.Keys(value).length, 0);
+    const isEvery = G.Every(G.Entries(schema.dependencies), ([key, schema]) => {
+        return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
+            ? schema.every((key) => G.HasPropertyKey(value, key))
+            : CheckSchema(context, schema, value));
+    });
+    return isLength || isEvery;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorDependencies(context, schemaPath, instancePath, schema, value) {
+    const isLength = G.IsEqual(G.Keys(value).length, 0);
+    const isEvery = G.EveryAll(G.Entries(schema.dependencies), ([key, schema]) => {
+        const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
+        return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
+            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
+                keyword: 'dependencies',
+                schemaPath: `${schemaPath}/dependencies`,
+                instancePath,
+                params: { property: key, dependencies: schema },
+            })) : ErrorSchema(context, nextSchemaPath, instancePath, schema, value));
+    });
+    return isLength || isEvery;
+}

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

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

package/build/schema/engine/dependentRequired.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildDependentRequired(context, schema, value) {
+    const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
+    const isEvery = E.ReduceAnd(G.Entries(schema.dependentRequired).map(([key, keys]) => {
+        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
+        const everyKey = E.ReduceAnd(keys.map((key) => E.HasPropertyKey(value, E.Constant(key))));
+        return E.Or(notKey, everyKey);
+    }));
+    return E.Or(isLength, isEvery);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckDependentRequired(context, schema, value) {
+    const isLength = G.IsEqual(G.Keys(value).length, 0);
+    const isEvery = G.Every(G.Entries(schema.dependentRequired), ([key, keys]) => {
+        return !G.HasPropertyKey(value, key) ||
+            keys.every((key) => G.HasPropertyKey(value, key));
+    });
+    return isLength || isEvery;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorDependentRequired(context, schemaPath, instancePath, schema, value) {
+    const isLength = G.IsEqual(G.Keys(value).length, 0);
+    const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), ([key, keys]) => {
+        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
+            keyword: 'dependentRequired',
+            schemaPath: `${schemaPath}/dependentRequired`,
+            instancePath,
+            params: { property: key, dependencies: keys },
+        }));
+    });
+    return isLength || isEveryEntry;
+}

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

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

package/build/schema/engine/dependentSchemas.mjs

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

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

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

package/build/schema/engine/enum.mjs

@@ -0,0 +1,33 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildEnum(context, schema, value) {
+    return E.ReduceOr(schema.enum.map(option => {
+        if (G.IsValueLike(option))
+            return E.IsEqual(value, E.Constant(option));
+        const variable = V.CreateExternalVariable(option);
+        return E.IsDeepEqual(value, variable);
+    }));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckEnum(context, schema, value) {
+    return schema.enum.some(option => G.IsValueLike(option)
+        ? G.IsEqual(value, option)
+        : G.IsDeepEqual(value, option));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorEnum(context, schemaPath, instancePath, schema, value) {
+    return CheckEnum(context, schema, value) || context.AddError({
+        keyword: 'enum',
+        schemaPath: `${schemaPath}/enum`,
+        instancePath,
+        params: { allowedValues: schema.enum }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildExclusiveMaximum(context: BuildContext, schema: S.XExclusiveMaximum, value: string): string;
+export declare function CheckExclusiveMaximum(context: CheckContext, schema: S.XExclusiveMaximum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMaximum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XExclusiveMaximum, value: number | bigint): boolean;

package/build/schema/engine/exclusiveMaximum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildExclusiveMaximum(context, schema, value) {
+    return E.IsLessThan(value, E.Constant(schema.exclusiveMaximum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckExclusiveMaximum(context, schema, value) {
+    return G.IsLessThan(value, schema.exclusiveMaximum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorExclusiveMaximum(context, schemaPath, instancePath, schema, value) {
+    return CheckExclusiveMaximum(context, schema, value) || context.AddError({
+        keyword: 'exclusiveMaximum',
+        schemaPath: `${schemaPath}/exclusiveMaximum`,
+        instancePath,
+        params: { comparison: '<', limit: schema.exclusiveMaximum }
+    });
+}

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

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildExclusiveMinimum(context: BuildContext, schema: S.XExclusiveMinimum, value: string): string;
+export declare function CheckExclusiveMinimum(context: CheckContext, schema: S.XExclusiveMinimum, value: number | bigint): boolean;
+export declare function ErrorExclusiveMinimum(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XExclusiveMinimum, value: number | bigint): boolean;