@depup/typebox 1.3.27-depup.0 → 1.3.30-depup.0

package/build/schema/engine/additionalProperties.mjs

@@ -1,6 +1,6 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
-import * as V from './_externals.mjs';
+import * as Schema from '../types/index.mjs';
+import * as Externals from './_externals.mjs';
 import { Unique } from './_unique.mjs';
 import { UnicodeRegExp } from './_regexp.mjs';
 import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
@@ -34,9 +34,9 @@ function GetPropertyKeyAsPattern(key) {
 }
 function GetPropertiesPattern(schema) {
     const patterns = [];
-    if (S.IsPatternProperties(schema))
+    if (Schema.IsPatternProperties(schema))
         patterns.push(...G.Keys(schema.patternProperties));
-    if (S.IsProperties(schema))
+    if (Schema.IsProperties(schema))
         patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
     return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
 }
@@ -56,9 +56,9 @@ function GetPropertiesPattern(schema) {
 //
 // ------------------------------------------------------------------
 export function CanAdditionalPropertiesFast(_context, schema, _value) {
-    return S.IsRequired(schema)
-        && S.IsProperties(schema)
-        && !S.IsPatternProperties(schema)
+    return Schema.IsRequired(schema)
+        && Schema.IsProperties(schema)
+        && !Schema.IsPatternProperties(schema)
         && G.IsEqual(schema.additionalProperties, false)
         && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
 }
@@ -70,7 +70,7 @@ export function BuildAdditionalPropertiesFast(_context, schema, value) {
 // ------------------------------------------------------------------
 export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
     const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
+    const regexp = Externals.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
     const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
     const isKey = E.Call(E.Member(regexp, 'test'), [key]);
     const addKey = context.AddKey(key);
@@ -114,10 +114,6 @@ export function ErrorAdditionalProperties(stack, context, schemaPath, instancePa
             additionalProperties.push(key);
         return isAdditionalProperty;
     });
-    return isAdditionalProperties || context.AddError({
-        keyword: 'additionalProperties',
-        schemaPath,
-        instancePath,
-        params: { additionalProperties },
-    });
+    return isAdditionalProperties ||
+        context.AddError('additionalProperties', schemaPath, instancePath, { additionalProperties });
 }

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

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

package/build/schema/engine/allOf.mjs

@@ -42,6 +42,6 @@ export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     const isAllOf = G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
     if (!isAllOf)
-        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
+        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
     return isAllOf;
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as 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;
+export declare function BuildAnyOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
+export declare function CheckAnyOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
+export declare function ErrorAnyOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

package/build/schema/engine/anyOf.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
-import { CheckContext, ErrorContext } from './_context.mjs';
 import { Reducer } from './_reducer.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { CheckContext, ErrorContext } from './_context.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -42,11 +42,6 @@ export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, val
     }, []);
     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: {}
-    });
+        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
+    return isAnyOf || context.AddError('anyOf', schemaPath, instancePath, {});
 }

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

@@ -1,5 +1,5 @@
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorSchemaBoolean(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;
+export declare function BuildSchemaBoolean(_stack: Stack.XStack, _context: BuildContext, schema: boolean, _value: string): string;
+export declare function CheckSchemaBoolean(_stack: Stack.XStack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
+export declare function ErrorSchemaBoolean(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

package/build/schema/engine/boolean.mjs

@@ -16,10 +16,6 @@ export function CheckSchemaBoolean(_stack, _context, schema, _value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckSchemaBoolean(stack, context, schema, value) || context.AddError({
-        keyword: 'boolean',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
+    return CheckSchemaBoolean(stack, context, schema, value) ||
+        context.AddError('boolean', schemaPath, instancePath, {});
 }

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

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

package/build/schema/engine/const.mjs

@@ -21,10 +21,6 @@ export function CheckConst(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckConst(stack, context, schema, value) || context.AddError({
-        keyword: 'const',
-        schemaPath,
-        instancePath,
-        params: { allowedValue: schema.const },
-    });
+    return CheckConst(stack, context, schema, value) ||
+        context.AddError('const', schemaPath, instancePath, { allowedValue: schema.const });
 }

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

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

package/build/schema/engine/contains.mjs

@@ -45,10 +45,6 @@ export function CheckContains(stack, context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains: 1 },
-    });
+    return CheckContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains: 1 });
 }

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

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

package/build/schema/engine/dependencies.mjs

@@ -34,12 +34,9 @@ export function ErrorDependencies(stack, context, schemaPath, instancePath, sche
     const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([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,
-                instancePath,
-                params: { property: key, dependencies: schema },
-            })) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
+            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
+                context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))
+            : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
     });
     return isLength || isEvery;
 }

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

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

package/build/schema/engine/dependentRequired.mjs

@@ -29,12 +29,8 @@ export function CheckDependentRequired(_stack, _context, schema, value) {
 export function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
     const isLength = G.IsEqual(G.Keys(value).length, 0);
     const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-            keyword: 'dependentRequired',
-            schemaPath,
-            instancePath,
-            params: { property: key, dependencies: keys },
-        }));
+        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) ||
+            context.AddError('dependentRequired', schemaPath, instancePath, { property: key, dependencies: keys }));
     });
     return isLength || isEveryEntry;
 }

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

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

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDynamicRef(stack: Stack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
-export declare function CheckDynamicRef(stack: Stack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
-export declare function ErrorDynamicRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function BuildDynamicRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
+export declare function CheckDynamicRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
+export declare function ErrorDynamicRef(stack: Stack.XStack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

package/build/schema/engine/dynamicRef.mjs

@@ -1,25 +1,29 @@
 // deno-fmt-ignore-file
-import * as Functions from './_functions.mjs';
 import * as Schema from '../types/index.mjs';
+import * as Functions from './_functions.mjs';
+import { Resolve } from '../resolve/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
 export function BuildDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return Functions.CreateFunction(stack, context, target, value);
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return Functions.CreateFunction(nextStack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
 export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
+    const target = Resolve.DynamicRef(stack, schema) ?? false;
+    const nextStack = target ? { ...stack, pendingResource: true } : stack;
+    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, '#', instancePath, target, value));
 }

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

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

package/build/schema/engine/enum.mjs

@@ -24,10 +24,6 @@ export function CheckEnum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckEnum(stack, context, schema, value) || context.AddError({
-        keyword: 'enum',
-        schemaPath,
-        instancePath,
-        params: { allowedValues: schema.enum }
-    });
+    return CheckEnum(stack, context, schema, value) ||
+        context.AddError('enum', schemaPath, instancePath, { allowedValues: schema.enum });
 }

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

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

package/build/schema/engine/exclusiveMaximum.mjs

@@ -16,10 +16,6 @@ export function CheckExclusiveMaximum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError({
-        keyword: 'exclusiveMaximum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '<', limit: schema.exclusiveMaximum }
-    });
+    return CheckExclusiveMaximum(stack, context, schema, value) ||
+        context.AddError('exclusiveMaximum', schemaPath, instancePath, { comparison: '<', limit: schema.exclusiveMaximum });
 }

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

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

package/build/schema/engine/exclusiveMinimum.mjs

@@ -16,10 +16,6 @@ export function CheckExclusiveMinimum(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError({
-        keyword: 'exclusiveMinimum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '>', limit: schema.exclusiveMinimum }
-    });
+    return CheckExclusiveMinimum(stack, context, schema, value) ||
+        context.AddError('exclusiveMinimum', schemaPath, instancePath, { comparison: '>', limit: schema.exclusiveMinimum });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildFormat(_stack: Stack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
-export declare function CheckFormat(_stack: Stack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
-export declare function ErrorFormat(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;
+export declare function BuildFormat(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XFormat, value: string): string;
+export declare function CheckFormat(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XFormat, value: string): boolean;
+export declare function ErrorFormat(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XFormat, value: string): boolean;

package/build/schema/engine/format.mjs

@@ -17,10 +17,6 @@ export function CheckFormat(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckFormat(stack, context, schema, value) || context.AddError({
-        keyword: 'format',
-        schemaPath,
-        instancePath,
-        params: { format: schema.format },
-    });
+    return CheckFormat(stack, context, schema, value) ||
+        context.AddError('format', schemaPath, instancePath, { format: schema.format });
 }

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

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

package/build/schema/engine/if.mjs

@@ -1,8 +1,8 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
 import { ErrorContext } from './_context.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
@@ -29,18 +29,10 @@ export function ErrorIf(stack, context, schemaPath, instancePath, schema, value)
     const elseSchema = Schema.IsElse(schema) ? schema.else : true;
     const trueContext = new ErrorContext();
     const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
-        ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
-            keyword: 'if',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'then' },
-        })
-        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
-            keyword: 'if',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'else' },
-        });
+        ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) ||
+            context.AddError('if', schemaPath, instancePath, { failingKeyword: 'then' })
+        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) ||
+            context.AddError('if', schemaPath, instancePath, { failingKeyword: 'else' });
     if (isIf)
         context.Merge([trueContext]);
     return isIf;

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

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

package/build/schema/engine/items.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import * as Schema from '../types/index.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // ItemsSized
 // ------------------------------------------------------------------

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

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

package/build/schema/engine/maxContains.mjs

@@ -33,10 +33,6 @@ export function CheckMaxContains(stack, context, schema, value) {
 // ------------------------------------------------------------------
 export function ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value) {
     const minContains = Schema.IsMinContains(schema) ? schema.minContains : 1;
-    return CheckMaxContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains, maxContains: schema.maxContains },
-    });
+    return CheckMaxContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains, maxContains: schema.maxContains });
 }

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

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

package/build/schema/engine/maxItems.mjs

@@ -16,10 +16,6 @@ export function CheckMaxItems(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMaxItems(stack, context, schema, value) || context.AddError({
-        keyword: 'maxItems',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.maxItems }
-    });
+    return CheckMaxItems(stack, context, schema, value) ||
+        context.AddError('maxItems', schemaPath, instancePath, { limit: schema.maxItems });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxLength(_stack: Stack, _context: BuildContext, schema: Schema.XMaxLength, value: string): string;
-export declare function CheckMaxLength(_stack: Stack, _context: CheckContext, schema: Schema.XMaxLength, value: string): boolean;
-export declare function ErrorMaxLength(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxLength, value: string): boolean;
+export declare function BuildMaxLength(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaxLength, value: string): string;
+export declare function CheckMaxLength(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaxLength, value: string): boolean;
+export declare function ErrorMaxLength(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxLength, value: string): boolean;

package/build/schema/engine/maxLength.mjs

@@ -16,10 +16,6 @@ export function CheckMaxLength(_stack, _context, schema, value) {
 // Error
 // ------------------------------------------------------------------
 export function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMaxLength(stack, context, schema, value) || context.AddError({
-        keyword: 'maxLength',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.maxLength }
-    });
+    return CheckMaxLength(stack, context, schema, value) ||
+        context.AddError('maxLength', schemaPath, instancePath, { limit: schema.maxLength });
 }

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

@@ -1,6 +1,6 @@
 import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
+import * as Stack from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildMaxProperties(_stack: Stack, _context: BuildContext, schema: Schema.XMaxProperties, value: string): string;
-export declare function CheckMaxProperties(_stack: Stack, _context: CheckContext, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorMaxProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildMaxProperties(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XMaxProperties, value: string): string;
+export declare function CheckMaxProperties(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorMaxProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XMaxProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/maxProperties.mjs

@@ -16,10 +16,6 @@ export function CheckMaxProperties(_stack, _context, schema, value) {
 // Check
 // ------------------------------------------------------------------
 export function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckMaxProperties(stack, context, schema, value) || context.AddError({
-        keyword: 'maxProperties',
-        schemaPath,
-        instancePath,
-        params: { limit: schema.maxProperties },
-    });
+    return CheckMaxProperties(stack, context, schema, value) ||
+        context.AddError('maxProperties', schemaPath, instancePath, { limit: schema.maxProperties });
 }