typebox 1.0.43 → 1.0.45

package/build/schema/build.d.mts

@@ -1,5 +1,5 @@
 import * as Engine from './engine/index.mjs';
-import { type XSchema } from './types/index.mjs';
+import * as Schema from './types/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
 export interface EvaluateResult {
     IsEvaluated: boolean;
@@ -13,11 +13,11 @@ export declare class BuildResult {
     private readonly functions;
     private readonly call;
     private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, XSchema>, schema: XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
+    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], call: string, useUnevaluated: boolean);
     /** Returns the Context used for this build */
-    Context(): Record<PropertyKey, XSchema>;
+    Context(): Record<PropertyKey, Schema.XSchema>;
     /** Returns the Schema used for this build */
-    Schema(): XSchema;
+    Schema(): Schema.XSchema;
     /** Returns true if this build requires a Unevaluated context */
     UseUnevaluated(): boolean;
     /** Returns external variables */
@@ -30,6 +30,6 @@ export declare class BuildResult {
     Evaluate(): EvaluateResult;
 }
 /** Builds a schema into a optimized runtime validator */
-export declare function Build(schema: XSchema): BuildResult;
+export declare function Build(schema: Schema.XSchema): BuildResult;
 /** Builds a schema into a optimized runtime validator */
-export declare function Build(context: Record<PropertyKey, XSchema>, schema: XSchema): BuildResult;
+export declare function Build(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema): BuildResult;

package/build/schema/build.mjs

@@ -27,8 +27,9 @@ function CreateEvaluatedCheck(build, code) {
 // CreateDynamicCheck
 // ------------------------------------------------------------------
 function CreateDynamicCheck(build) {
-    const context = new Engine.CheckContext(build.Context(), build.Schema());
-    return (value) => Engine.CheckSchema(context, build.Schema(), value);
+    const stack = new Engine.Stack(build.Context(), build.Schema());
+    const context = new Engine.CheckContext();
+    return (value) => Engine.CheckSchema(stack, context, build.Schema(), value);
 }
 // ------------------------------------------------------------------
 // CreateCheck
@@ -89,8 +90,9 @@ export function Build(...args) {
     });
     Engine.ResetExternal();
     Engine.ResetFunctions();
-    const build = new Engine.BuildContext(context, schema, Engine.HasUnevaluated(context, schema));
-    const call = Engine.CreateFunction(build, schema, 'value');
+    const stack = new Engine.Stack(context, schema);
+    const build = new Engine.BuildContext(Engine.HasUnevaluated(context, schema));
+    const call = Engine.CreateFunction(stack, build, schema, 'value');
     const functions = Engine.GetFunctions();
     const externals = Engine.GetExternal();
     return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated());

package/build/schema/check.d.mts

@@ -1,5 +1,5 @@
-import { XSchema } from './types/index.mjs';
+import * as Schema from './types/index.mjs';
 /** Checks a value against the provided schema */
-export declare function Check(schema: XSchema, value: unknown): boolean;
+export declare function Check(schema: Schema.XSchema, value: unknown): boolean;
 /** Checks a value against the provided schema */
-export declare function Check(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): boolean;
+export declare function Check(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): boolean;

package/build/schema/check.mjs

@@ -1,12 +1,14 @@
 // deno-fmt-ignore-file
 // deno-lint-ignore-file
 import { Arguments } from '../system/arguments/index.mjs';
-import { CheckSchema, CheckContext } from './engine/index.mjs';
+import * as Engine from './engine/index.mjs';
 /** Checks a value against the provided schema */
 export function Check(...args) {
     const [context, schema, value] = Arguments.Match(args, {
         3: (context, schema, value) => [context, schema, value],
         2: (schema, value) => [{}, schema, value]
     });
-    return CheckSchema(new CheckContext(context, schema), schema, value);
+    const stack = new Engine.Stack(context, schema);
+    const checkContext = new Engine.CheckContext();
+    return Engine.CheckSchema(stack, checkContext, schema, value);
 }

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

@@ -1,42 +1,32 @@
-import * as S from '../types/index.mjs';
 import type { TValidationError } from '../../error/index.mjs';
 export declare function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean;
-export declare class BaseContext {
-    protected readonly context: Record<PropertyKey, S.XSchema>;
-    protected readonly schema: S.XSchema;
-    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
-    GetContext(): Record<PropertyKey, object | boolean>;
-    GetSchema(): object | boolean;
-}
-export declare class BuildContext extends BaseContext {
+export declare class BuildContext {
     private readonly hasUnevaluated;
-    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, hasUnevaluated: boolean);
+    constructor(hasUnevaluated: boolean);
     UseUnevaluated(): boolean;
     AddIndex(index: string): string;
     AddKey(key: string): string;
-    Clone(): string;
     Merge(results: string): string;
 }
-export declare class CheckContext extends BaseContext {
+export declare class CheckContext {
     private readonly indices;
     private readonly keys;
-    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
+    constructor();
     AddIndex(index: number): true;
     AddKey(key: string): true;
     GetIndices(): Set<number>;
     GetKeys(): Set<string>;
-    Clone(): CheckContext;
     Merge(results: CheckContext[]): true;
 }
 export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
     private readonly callback;
-    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, callback: ErrorContextCallback);
+    constructor(callback: ErrorContextCallback);
     AddError(error: TValidationError): false;
 }
 export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
-    constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema);
+    constructor();
     AddError(error: TValidationError): false;
     GetErrors(): TValidationError[];
 }

package/build/schema/engine/_context.mjs

@@ -1,12 +1,12 @@
 // deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // HasUnevaluated
 // ------------------------------------------------------------------
 function HasUnevaluatedFromObject(value) {
-    return (S.IsUnevaluatedItems(value)
-        || S.IsUnevaluatedProperties(value)
+    return (Schema.IsUnevaluatedItems(value)
+        || Schema.IsUnevaluatedProperties(value)
         || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
 }
 function HasUnevaluatedFromArray(value) {
@@ -21,26 +21,10 @@ export function HasUnevaluated(context, schema) {
     return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
 }
 // ------------------------------------------------------------------
-// BaseContext
-// ------------------------------------------------------------------
-export class BaseContext {
-    constructor(context, schema) {
-        this.context = context;
-        this.schema = schema;
-    }
-    GetContext() {
-        return this.context;
-    }
-    GetSchema() {
-        return this.schema;
-    }
-}
-// ------------------------------------------------------------------
 // BuildContext
 // ------------------------------------------------------------------
-export class BuildContext extends BaseContext {
-    constructor(context, schema, hasUnevaluated) {
-        super(context, schema);
+export class BuildContext {
+    constructor(hasUnevaluated) {
         this.hasUnevaluated = hasUnevaluated;
     }
     UseUnevaluated() {
@@ -52,9 +36,6 @@ export class BuildContext extends BaseContext {
     AddKey(key) {
         return E.Call(E.Member('context', 'AddKey'), [key]);
     }
-    Clone() {
-        return E.Call(E.Member('context', 'Clone'), []);
-    }
     Merge(results) {
         return E.Call(E.Member('context', 'Merge'), [results]);
     }
@@ -62,9 +43,8 @@ export class BuildContext extends BaseContext {
 // ------------------------------------------------------------------
 // CheckContext
 // ------------------------------------------------------------------
-export class CheckContext extends BaseContext {
-    constructor(context, schema) {
-        super(context, schema);
+export class CheckContext {
+    constructor() {
         this.indices = new Set();
         this.keys = new Set();
     }
@@ -82,9 +62,6 @@ export class CheckContext extends BaseContext {
     GetKeys() {
         return this.keys;
     }
-    Clone() {
-        return new CheckContext(this.context, this.schema);
-    }
     Merge(results) {
         for (const context of results) {
             context.indices.forEach(value => this.indices.add(value));
@@ -94,8 +71,8 @@ export class CheckContext extends BaseContext {
     }
 }
 export class ErrorContext extends CheckContext {
-    constructor(context, schema, callback) {
-        super(context, schema);
+    constructor(callback) {
+        super();
         this.callback = callback;
     }
     AddError(error) {
@@ -107,8 +84,8 @@ export class ErrorContext extends CheckContext {
 // AccumulatedErrorContext
 // ------------------------------------------------------------------
 export class AccumulatedErrorContext extends ErrorContext {
-    constructor(context, schema) {
-        super(context, schema, error => this.errors.push(error));
+    constructor() {
+        super(error => this.errors.push(error));
         this.errors = [];
     }
     AddError(error) {

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

@@ -5,5 +5,5 @@ export interface TExternal {
     variables: unknown[];
 }
 export declare function ResetExternal(): void;
-export declare function CreateExternalVariable(value: unknown): string;
+export declare function CreateVariable(value: unknown): string;
 export declare function GetExternal(): TExternal;

package/build/schema/engine/_externals.mjs

@@ -19,9 +19,9 @@ export function ResetExternal() {
     resetCount += 1;
 }
 // ------------------------------------------------------------------
-// CreateExternalVariable
+// CreateVariable
 // ------------------------------------------------------------------
-export function CreateExternalVariable(value) {
+export function CreateVariable(value) {
     const call = `${state.identifier}[${state.variables.length}]`;
     state.variables.push(value);
     return call;

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

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+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(context: BuildContext, schema: S.XSchema, value: string): string;
+export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;

package/build/schema/engine/_functions.mjs

@@ -1,4 +1,5 @@
 // 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';
@@ -14,8 +15,8 @@ function CreateCallExpression(context, schema, hash, value) {
 // ------------------------------------------------------------------
 // CreateFunctionExpression
 // ------------------------------------------------------------------
-function CreateFunctionExpression(context, schema, hash) {
-    const expression = BuildSchema(context, schema, 'value');
+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));
@@ -35,12 +36,12 @@ export function GetFunctions() {
 // ------------------------------------------------------------------
 // CreateFunction
 // ------------------------------------------------------------------
-export function CreateFunction(context, schema, value) {
-    const hash = Hashing.Hash(schema);
+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(context, schema, hash));
+    functions.set(hash, CreateFunctionExpression(stack, context, schema, hash));
     return call;
 }

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

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

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

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

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

package/build/schema/engine/_reducer.mjs

@@ -35,10 +35,10 @@ import { BuildSchema } from './schema.mjs';
 // })()
 //
 // ------------------------------------------------------------------
-export function Reducer(context, schemas, value, check) {
+export function Reducer(stack, context, schemas, value, check) {
     const results = E.ConstDeclaration('results', '[]');
-    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, context.Clone()));
-    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(context, schema, value)), [`context_${index}`])));
+    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

@@ -1,5 +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(context: BuildContext, schema: S.XRefine, value: string): string;
-export declare function CheckRefine(context: CheckContext, schema: S.XRefine, value: unknown): boolean;
-export declare function ErrorRefine(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;
+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

@@ -4,20 +4,20 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildRefine(context, schema, value) {
-    const refinements = V.CreateExternalVariable(schema['~refine'].map((refinement) => refinement));
+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(context, schema, value) {
+export function CheckRefine(stack, context, schema, value) {
     return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRefine(context, schemaPath, instancePath, schema, value) {
+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',

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('root', 'memory://'));
+    }
+    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

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

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

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

@@ -1,8 +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(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;
+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;