@depup/typebox 1.1.6-depup.0

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

@@ -0,0 +1,9 @@
+export interface TExternal {
+    /** The name of the variable that holds external variables in generated code */
+    identifier: string;
+    /** An array of external variables */
+    variables: unknown[];
+}
+export declare function ResetExternal(): void;
+export declare function CreateVariable(value: unknown): string;
+export declare function GetExternal(): TExternal;

package/build/schema/engine/_externals.mjs

@@ -0,0 +1,34 @@
+// deno-fmt-ignore-file
+const identifier = 'external_';
+let resetCount = 0;
+const state = {
+    identifier: `${identifier}${resetCount}`,
+    variables: []
+};
+// ------------------------------------------------------------------
+// ResetExternals
+//
+// Each reset results in a new external group identifier. This is done 
+// to prevent variable name overlap when generating and evaluating
+// multiple types in the same scope.
+//
+// ------------------------------------------------------------------
+export function ResetExternal() {
+    state.identifier = `${identifier}${resetCount}`;
+    state.variables = [];
+    resetCount += 1;
+}
+// ------------------------------------------------------------------
+// CreateVariable
+// ------------------------------------------------------------------
+export function CreateVariable(value) {
+    const call = `${state.identifier}[${state.variables.length}]`;
+    state.variables.push(value);
+    return call;
+}
+// ------------------------------------------------------------------
+// GetExternals
+// ------------------------------------------------------------------
+export function GetExternal() {
+    return state;
+}

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

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext } from './_context.mjs';
+export declare function ResetFunctions(): void;
+export declare function GetFunctions(): string[];
+export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;

package/build/schema/engine/_functions.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Hashing } from '../../system/hashing/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema } from './schema.mjs';
+const functions = new Map();
+// ------------------------------------------------------------------
+// CreateCallExpression
+// ------------------------------------------------------------------
+function CreateCallExpression(context, schema, hash, value) {
+    return context.UseUnevaluated()
+        ? E.Call(`check_${hash}`, ['context', value])
+        : E.Call(`check_${hash}`, [value]);
+}
+// ------------------------------------------------------------------
+// CreateFunctionExpression
+// ------------------------------------------------------------------
+function CreateFunctionExpression(stack, context, schema, hash) {
+    const expression = BuildSchema(stack, context, schema, 'value');
+    return context.UseUnevaluated()
+        ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
+        : E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['value'], expression));
+}
+// ------------------------------------------------------------------
+// ResetFunctions
+// ------------------------------------------------------------------
+export function ResetFunctions() {
+    functions.clear();
+}
+// ------------------------------------------------------------------
+// GetFunctions
+// ------------------------------------------------------------------
+export function GetFunctions() {
+    return [...functions.values()];
+}
+// ------------------------------------------------------------------
+// CreateFunction
+// ------------------------------------------------------------------
+export function CreateFunction(stack, context, schema, value) {
+    const hash = Schema.IsSchemaObject(schema) ? Hashing.Hash({ __baseURL: stack.BaseURL().href, ...schema }) : Hashing.Hash(schema);
+    const call = CreateCallExpression(context, schema, hash, value);
+    if (functions.has(hash))
+        return call;
+    functions.set(hash, '');
+    functions.set(hash, CreateFunctionExpression(stack, context, schema, hash));
+    return call;
+}

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

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildGuard(stack: Stack, context: BuildContext, schema: Schema.XGuard, value: string): string;
+export declare function CheckGuard(stack: Stack, context: CheckContext, schema: Schema.XGuard, value: unknown): boolean;
+export declare function ErrorGuard(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XGuard, value: unknown): boolean;

package/build/schema/engine/_guard.mjs

@@ -0,0 +1,26 @@
+// deno-fmt-ignore-file
+import * as Externals from './_externals.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildGuard(stack, context, schema, value) {
+    return E.Call(E.Member(E.Member(Externals.CreateVariable(schema), '~guard'), 'check'), [value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckGuard(stack, context, schema, value) {
+    return schema['~guard'].check(value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorGuard(stack, context, schemaPath, instancePath, schema, value) {
+    return schema['~guard'].check(value) || context.AddError({
+        keyword: '~guard',
+        schemaPath,
+        instancePath,
+        params: { errors: schema['~guard'].errors(value) },
+    });
+}

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

@@ -0,0 +1,4 @@
+import * as S from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext } from './_context.mjs';
+export declare function Reducer(stack: Stack, context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;

package/build/schema/engine/_reducer.mjs

@@ -0,0 +1,45 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Reducer
+//
+// This function is used to generate an reducer evaluation context 
+// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
+// is required from 2019-09 onwards to gather evaluated keys and indices
+// for the unevaluatedItems and unevaluatedProperties keywords.
+//
+// ------------------------------------------------------------------
+//
+// const context = new Context() // exterior
+//
+// (() => {
+//   const results = []
+//
+//   const context_0 = context.Clone()
+//   const context_1 = context.Clone()
+//   const context_2 = context.Clone()
+//   const context_3 = context.Clone()
+//   
+//   const condition_0 = ((context) => <subschema>)(context_0)
+//   const condition_1 = ((context) => <subschema>)(context_1)
+//   const condition_2 = ((context) => <subschema>)(context_2)
+//   const condition_3 = ((context) => <subschema>)(context_3)
+// 
+//   if(condition_0) results.push(context_0)
+//   if(condition_1) results.push(context_1)
+//   if(condition_2) results.push(context_2)
+//   if(condition_3) results.push(context_3)
+//
+//   return <check> && context.Merge(results)
+// })()
+//
+// ------------------------------------------------------------------
+export function Reducer(stack, context, schemas, value, check) {
+    const results = E.ConstDeclaration('results', '[]');
+    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, E.New('CheckContext', [])));
+    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(stack, context, schema, value)), [`context_${index}`])));
+    const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])));
+    const returns = E.Return(E.And(check, context.Merge('results')));
+    return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
+}

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

@@ -0,0 +1,6 @@
+import * as S from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildRefine(stack: Stack, context: BuildContext, schema: S.XRefine, value: string): string;
+export declare function CheckRefine(stack: Stack, context: CheckContext, schema: S.XRefine, value: unknown): boolean;
+export declare function ErrorRefine(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;

package/build/schema/engine/_refine.mjs

@@ -0,0 +1,29 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildRefine(stack, context, schema, value) {
+    const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'refine'), [value]));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckRefine(stack, context, schema, value) {
+    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorRefine(stack, context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
+        return refinement.refine(value) || context.AddError({
+            keyword: '~refine',
+            schemaPath,
+            instancePath,
+            params: { index, message: refinement.message },
+        });
+    });
+}

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

@@ -0,0 +1,18 @@
+import * as Schema from '../types/index.mjs';
+export declare class Stack {
+    private readonly context;
+    private readonly schema;
+    private readonly ids;
+    private readonly anchors;
+    private readonly recursiveAnchors;
+    private readonly dynamicAnchors;
+    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
+    BaseURL(): URL;
+    Base(): Schema.XSchemaObject;
+    Push(schema: Schema.XSchema): void;
+    Pop(schema: Schema.XSchema): void;
+    private FromContext;
+    private FromRef;
+    Ref(ref: string): Schema.XSchema | undefined;
+    RecursiveRef(recursiveRef: string): Schema.XSchema | undefined;
+}

package/build/schema/engine/_stack.mjs

@@ -0,0 +1,73 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Guard as G } from '../../guard/index.mjs';
+import { Resolve } from '../resolve/index.mjs';
+export class Stack {
+    constructor(context, schema) {
+        this.context = context;
+        this.schema = schema;
+        this.ids = [];
+        this.anchors = [];
+        this.recursiveAnchors = [];
+        this.dynamicAnchors = [];
+    }
+    // ----------------------------------------------------------------
+    // Base
+    // ----------------------------------------------------------------
+    BaseURL() {
+        return this.ids.reduce((result, schema) => new URL(schema.$id, result), new URL('http://unknown'));
+    }
+    Base() {
+        return this.ids[this.ids.length - 1] ?? this.schema;
+    }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push(schema) {
+        if (!Schema.IsSchemaObject(schema))
+            return;
+        if (Schema.IsId(schema))
+            this.ids.push(schema);
+        if (Schema.IsAnchor(schema))
+            this.anchors.push(schema);
+        if (Schema.IsRecursiveAnchorTrue(schema))
+            this.recursiveAnchors.push(schema);
+        if (Schema.IsDynamicAnchor(schema))
+            this.dynamicAnchors.push(schema);
+    }
+    Pop(schema) {
+        if (!Schema.IsSchemaObject(schema))
+            return;
+        if (Schema.IsId(schema))
+            this.ids.pop();
+        if (Schema.IsAnchor(schema))
+            this.anchors.pop();
+        if (Schema.IsRecursiveAnchorTrue(schema))
+            this.recursiveAnchors.pop();
+        if (Schema.IsDynamicAnchor(schema))
+            this.dynamicAnchors.pop();
+    }
+    // ----------------------------------------------------------------
+    // Ref
+    // ----------------------------------------------------------------
+    FromContext(ref) {
+        return G.HasPropertyKey(this.context, ref) ? this.context[ref] : undefined;
+    }
+    FromRef(ref) {
+        return !ref.startsWith('#')
+            ? Resolve.Ref(this.schema, ref)
+            : Resolve.Ref(this.Base(), ref);
+    }
+    Ref(ref) {
+        return this.FromContext(ref) ?? this.FromRef(ref);
+    }
+    // ----------------------------------------------------------------
+    // RecursiveRef
+    // ----------------------------------------------------------------
+    RecursiveRef(recursiveRef) {
+        if (Schema.IsRecursiveAnchorTrue(this.Base())) {
+            return Resolve.Ref(this.recursiveAnchors[0], recursiveRef);
+        }
+        return Resolve.Ref(this.Base(), recursiveRef);
+    }
+}

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

@@ -0,0 +1,2 @@
+/** Returns a Unique Variable Name */
+export declare function Unique(): string;

package/build/schema/engine/_unique.mjs

@@ -0,0 +1,5 @@
+let index = 0;
+/** Returns a Unique Variable Name */
+export function Unique() {
+    return `var_${index++}`;
+}

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

@@ -0,0 +1,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildAdditionalItems(stack: Stack, context: BuildContext, schema: Schema.XAdditionalItems, value: string): string;
+export declare function CheckAdditionalItems(stack: Stack, context: CheckContext, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
+export declare function ErrorAdditionalItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalItems, value: unknown[]): boolean;

package/build/schema/engine/additionalItems.mjs

@@ -0,0 +1,50 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Unique } from './_unique.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Valid
+// ------------------------------------------------------------------
+function IsValid(schema) {
+    return Schema.IsItems(schema) && G.IsArray(schema.items);
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildAdditionalItems(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    const [item, index] = [Unique(), Unique()];
+    const isSchema = BuildSchema(stack, context, schema.additionalItems, item);
+    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([item, index], guarded)]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAdditionalItems(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((item, index) => {
+        return G.IsLessThan(index, schema.items.length)
+            || (CheckSchema(stack, context, schema.additionalItems, item) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    const isAdditionalItems = value.every((item, index) => {
+        const nextSchemaPath = `${schemaPath}/additionalItems`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsLessThan(index, schema.items.length) ||
+            (ErrorSchema(stack, context, nextSchemaPath, nextInstancePath, schema.additionalItems, item) && context.AddIndex(index));
+    });
+    return isAdditionalItems;
+}

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

@@ -0,0 +1,9 @@
+import * as S from '../types/index.mjs';
+import { Stack } from './_stack.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(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function BuildAdditionalProperties(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
+export declare function CheckAdditionalProperties(stack: Stack, context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorAdditionalProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/additionalProperties.mjs

@@ -0,0 +1,110 @@
+// deno-fmt-ignore-file
+import * as S from '../types/index.mjs';
+import * as V from './_externals.mjs';
+import { Unique } from './_unique.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Common: GetPropertiesPattern
+//
+// 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 GetPropertyKeyAsPattern(key) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return `^${escaped}$`;
+}
+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).map(GetPropertyKeyAsPattern));
+    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(stack, context, schema, value) {
+    const [key, _index] = [Unique(), Unique()];
+    const regexp = V.CreateVariable(new RegExp(GetPropertiesPattern(schema)));
+    const isSchema = BuildSchema(stack, context, schema.additionalProperties, `${value}[${key}]`);
+    const isKey = E.Call(E.Member(regexp, 'test'), [key]);
+    const addKey = context.AddKey(key);
+    const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
+    const result = E.Every(E.Keys(value), E.Constant(0), [key, _index], guarded);
+    return result;
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildAdditionalProperties(stack, context, schema, value) {
+    return CanAdditionalPropertiesFast(context, schema, value)
+        ? BuildAdditionalPropertiesFast(context, schema, value)
+        : BuildAdditionalPropertiesStandard(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAdditionalProperties(stack, context, schema, value) {
+    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
+        return regexp.test(key) ||
+            (CheckSchema(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
+    });
+    return isAdditionalProperties;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
+    const regexp = new RegExp(GetPropertiesPattern(schema));
+    const additionalProperties = [];
+    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
+        const nextSchemaPath = `${schemaPath}/additionalProperties`;
+        const nextInstancePath = `${instancePath}/${key}`;
+        const nextContext = new AccumulatedErrorContext();
+        const isAdditionalProperty = regexp.test(key) ||
+            (ErrorSchema(stack, 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/schema/engine/allOf.d.mts

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

package/build/schema/engine/allOf.mjs

@@ -0,0 +1,47 @@
+// deno-fmt-ignore-file
+import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { Reducer } from './_reducer.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildAllOfStandard(stack, context, schema, value) {
+    return Reducer(stack, context, schema.allOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(schema.allOf.length)));
+}
+function BuildAllOfFast(stack, context, schema, value) {
+    return E.ReduceAnd(schema.allOf.map((schema) => BuildSchema(stack, context, schema, value)));
+}
+export function BuildAllOf(stack, context, schema, value) {
+    return context.UseUnevaluated()
+        ? BuildAllOfStandard(stack, context, schema, value)
+        : BuildAllOfFast(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAllOf(stack, context, schema, value) {
+    const results = schema.allOf.reduce((result, schema) => {
+        const nextContext = new CheckContext();
+        return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
+    }, []);
+    return G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, value) {
+    const failedContexts = [];
+    const results = schema.allOf.reduce((result, schema, index) => {
+        const nextSchemaPath = `${schemaPath}/allOf/${index}`;
+        const nextContext = new AccumulatedErrorContext();
+        const isSchema = ErrorSchema(stack, 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,6 @@
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildAnyOf(stack: Stack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
+export declare function CheckAnyOf(stack: Stack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function ErrorAnyOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

package/build/schema/engine/anyOf.mjs

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

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

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