@depup/typebox 1.1.21-depup.0 → 1.3.8-depup.0

package/build/guard/guard.d.mts

@@ -1,7 +1,5 @@
 /** Returns true if this value is an array */
 export declare function IsArray(value: unknown): value is unknown[];
-/** Returns true if this value is an async iterator */
-export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<unknown>;
 /** Returns true if this value is bigint */
 export declare function IsBigInt(value: unknown): value is bigint;
 /** Returns true if this value is a boolean */
@@ -12,8 +10,6 @@ export declare function IsConstructor(value: unknown): value is new (...args: ne
 export declare function IsFunction(value: unknown): value is globalThis.Function;
 /** Returns true if this value is integer */
 export declare function IsInteger(value: unknown): value is number;
-/** Returns true if this value is an iterator */
-export declare function IsIterator(value: unknown): value is IterableIterator<unknown>;
 /** Returns true if this value is null */
 export declare function IsNull(value: unknown): value is null;
 /** Returns true if this value is number */
@@ -43,8 +39,20 @@ export declare function GraphemeCount(value: string): number;
 export declare function IsMaxLength(value: string, length: number): boolean;
 /** Returns true if the string has at least the given number of graphemes */
 export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if some element satisfies the callback, short-circuiting on the first success */
+export declare function Some<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+/** Returns true if some element satisfies the callback, using exhaustive enumeration */
+export declare function SomeAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
+/** Returns the count of elements that satisfy the callback */
+export declare function Counted(value: unknown[], callback: (value: unknown, index: number) => boolean): number;
+/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export declare function ShiftLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
 /** Returns true if this value has this property key */
 export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
     [_ in Key]: unknown;
@@ -53,11 +61,11 @@ export declare function HasPropertyKey<Key extends PropertyKey>(value: object, k
 export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
 /** Returns object entries as `[string, Value][]` */
 export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
 export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
 export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
 /** Returns the property values for the given object via `Object.values()` */
 export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
-/** Tests values for deep equality */
+/** Returns true if left and right values are structurally equal */
 export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/build/guard/guard.mjs

@@ -1,3 +1,4 @@
+// deno-fmt-ignore-file
 import * as String from './string.mjs';
 // --------------------------------------------------------------------------
 // Guards
@@ -6,10 +7,6 @@ import * as String from './string.mjs';
 export function IsArray(value) {
     return Array.isArray(value);
 }
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-    return IsObject(value) && Symbol.asyncIterator in value;
-}
 /** Returns true if this value is bigint */
 export function IsBigInt(value) {
     return IsEqual(typeof value, 'bigint');
@@ -37,10 +34,6 @@ export function IsFunction(value) {
 export function IsInteger(value) {
     return Number.isInteger(value);
 }
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-    return IsObject(value) && Symbol.iterator in value;
-}
 /** Returns true if this value is null */
 export function IsNull(value) {
     return IsEqual(value, null);
@@ -100,7 +93,7 @@ export function IsMultipleOf(dividend, divisor) {
     if (IsInteger(dividend) && (1 / divisor) % 1 === 0)
         return true;
     const mod = dividend % divisor;
-    return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
+    return Math.min(Math.abs(mod), Math.abs(mod - divisor), Math.abs(mod + divisor)) < tolerance;
 }
 // ------------------------------------------------------------------
 // IsClassInstance
@@ -145,6 +138,7 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
+/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
     for (let index = offset; index < value.length; index++) {
         if (!callback(value[index], index))
@@ -152,6 +146,7 @@ export function Every(value, offset, callback) {
     }
     return true;
 }
+/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
     for (let index = offset; index < value.length; index++) {
@@ -160,13 +155,41 @@ export function EveryAll(value, offset, callback) {
     }
     return result;
 }
+/** Returns true if some element satisfies the callback, short-circuiting on the first success */
+export function Some(value, callback) {
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            return true;
+    }
+    return false;
+}
+/** Returns true if some element satisfies the callback, using exhaustive enumeration */
+export function SomeAll(value, callback) {
+    let result = false;
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            result = true;
+    }
+    return result;
+}
+/** Returns the count of elements that satisfy the callback */
+export function Counted(value, callback) {
+    return value.reduce((result, value, index) => callback(value, index) ? ++result : result, 0);
+}
+/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
+export function ShiftLeft(array, true_, false_) {
+    return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));
+}
 // --------------------------------------------------------------------------
 // Object
 // --------------------------------------------------------------------------
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+export function IsUnsafePropertyKey(key) {
+    return IsEqual(key, '__proto__') || IsEqual(key, 'constructor') || IsEqual(key, 'prototype');
+}
 /** Returns true if this value has this property key */
 export function HasPropertyKey(value, key) {
-    const isProtoField = IsEqual(key, '__proto__') || IsEqual(key, 'constructor');
-    return isProtoField ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+    return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
 }
 /** Returns object entries as `[RegExp, Value][]` */
 export function EntriesRegExp(value) {
@@ -176,11 +199,11 @@ export function EntriesRegExp(value) {
 export function Entries(value) {
     return Object.entries(value);
 }
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
 export function Keys(value) {
     return Object.getOwnPropertyNames(value);
 }
-/** Returns the property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
 export function Symbols(value) {
     return Object.getOwnPropertySymbols(value);
 }
@@ -202,7 +225,9 @@ function DeepEqualArray(left, right) {
     return IsArray(right) && IsEqual(left.length, right.length) &&
         left.every((_, index) => IsDeepEqual(left[index], right[index]));
 }
-/** Tests values for deep equality */
+/** Returns true if left and right values are structurally equal */
 export function IsDeepEqual(left, right) {
-    return (IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right));
+    return (IsArray(left) ? DeepEqualArray(left, right) :
+        IsObject(left) ? DeepEqualObject(left, right) :
+            IsEqual(left, right));
 }

package/build/guard/string.mjs

@@ -5,6 +5,18 @@ function IsBetween(value, min, max) {
     return value >= min && value <= max;
 }
 // --------------------------------------------------------------------------
+// IsZeroWidthJoiner
+// --------------------------------------------------------------------------
+function IsZeroWidthJoiner(value) {
+    return (value === 0x200D);
+}
+// --------------------------------------------------------------------------
+// IsHighSurrogate
+// --------------------------------------------------------------------------
+function IsHighSurrogate(value) {
+    return IsBetween(value, 0xD800, 0xDBFF);
+}
+// --------------------------------------------------------------------------
 // IsRegionalIndicator
 // --------------------------------------------------------------------------
 function IsRegionalIndicator(value) {
@@ -72,10 +84,10 @@ function NextGraphemeClusterIndex(value, clusterStart) {
 // IsGraphemeCodePoint
 // --------------------------------------------------------------------------
 function IsGraphemeCodePoint(value) {
-    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
-        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
-        (value === 0x200D) // Zero-width joiner
-    );
+    return (IsHighSurrogate(value) ||
+        IsCombiningMark(value) ||
+        IsVariationSelector(value) ||
+        IsZeroWidthJoiner(value));
 }
 // --------------------------------------------------------------------------
 // GraphemeCount

package/build/schema/build.d.mts

@@ -1,19 +1,23 @@
 import * as Engine from './engine/index.mjs';
 import * as Schema from './types/index.mjs';
 export type CheckFunction = (value: unknown) => boolean;
-export interface EvaluateResult {
-    IsAccelerated: boolean;
-    Code: string;
-    Check: CheckFunction;
+export declare class EvaluateResult {
+    private readonly isAccelerated;
+    private readonly code;
+    private readonly check;
+    constructor(isAccelerated: boolean, code: string, check: CheckFunction);
+    IsAccelerated(): boolean;
+    Code(): string;
+    Check(value: unknown): boolean;
 }
 export declare class BuildResult {
     private readonly context;
     private readonly schema;
     private readonly external;
     private readonly functions;
-    private readonly call;
+    private readonly entry;
     private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: 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[], entry: string, useUnevaluated: boolean);
     /** Returns the Context used for this build */
     Context(): Record<PropertyKey, Schema.XSchema>;
     /** Returns the Schema used for this build */
@@ -25,7 +29,7 @@ export declare class BuildResult {
     /** Returns check functions */
     Functions(): string[];
     /** Return entry function call. */
-    Call(): string;
+    Entry(): string;
     /** Evaluates the build into a validation function */
     Evaluate(): EvaluateResult;
 }

package/build/schema/build.mjs

@@ -12,8 +12,8 @@ import * as Engine from './engine/index.mjs';
 function CreateCode(build) {
     const functions = build.Functions().join(';\n');
     const statements = build.UseUnevaluated()
-        ? ['const context = new CheckContext({}, {})', `return ${build.Call()}`]
-        : [`return ${build.Call()}`];
+        ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
+        : [`return ${build.Entry()}`];
     return `${functions}; return (value) => { ${statements.join('; ')} }`;
 }
 // ------------------------------------------------------------------
@@ -40,15 +40,34 @@ function CreateCheck(build, code) {
         : CreateDynamicCheck(build);
 }
 // ------------------------------------------------------------------
+// EvaluateResult
+// ------------------------------------------------------------------
+export class EvaluateResult {
+    constructor(isAccelerated, code, check) {
+        this.isAccelerated = isAccelerated;
+        this.code = code;
+        this.check = check;
+    }
+    IsAccelerated() {
+        return this.isAccelerated;
+    }
+    Code() {
+        return this.code;
+    }
+    Check(value) {
+        return this.check(value);
+    }
+}
+// ------------------------------------------------------------------
 // BuildResult
 // ------------------------------------------------------------------
 export class BuildResult {
-    constructor(context, schema, external, functions, call, useUnevaluated) {
+    constructor(context, schema, external, functions, entry, useUnevaluated) {
         this.context = context;
         this.schema = schema;
         this.external = external;
         this.functions = functions;
-        this.call = call;
+        this.entry = entry;
         this.useUnevaluated = useUnevaluated;
     }
     /** Returns the Context used for this build */
@@ -72,14 +91,14 @@ export class BuildResult {
         return this.functions;
     }
     /** Return entry function call. */
-    Call() {
-        return this.call;
+    Entry() {
+        return this.entry;
     }
     /** Evaluates the build into a validation function */
     Evaluate() {
-        const Code = CreateCode(this);
-        const Check = CreateCheck(this, Code);
-        return { IsAccelerated: Environment.CanEvaluate(), Code, Check };
+        const code = CreateCode(this);
+        const check = CreateCheck(this, code);
+        return new EvaluateResult(Environment.CanEvaluate(), code, check);
     }
 }
 /** Builds a schema into a optimized runtime validator */

package/build/schema/check.d.mts

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

package/build/schema/compile.d.mts

@@ -1,9 +1,9 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
-import * as Static from './static/index.mjs';
-export declare class Validator<Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static.XStatic<Schema>> {
-    private readonly build;
-    private readonly result;
+export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
+    private readonly buildResult;
+    private readonly evaluateResult;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;

package/build/schema/compile.mjs

@@ -9,31 +9,31 @@ import { ParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.build = Build.Build(context, schema);
-        this.result = this.build.Evaluate();
+        this.buildResult = Build.Build(context, schema);
+        this.evaluateResult = this.buildResult.Evaluate();
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
-        return this.result.IsAccelerated;
+        return this.evaluateResult.IsAccelerated();
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.build.Schema();
+        return this.buildResult.Schema();
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
-        return this.result.Check(value);
+        return this.evaluateResult.Check(value);
     }
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value) {
-        if (this.result.Check(value))
+        if (this.evaluateResult.Check(value))
             return value;
-        const [_result, errors] = Errors(this.build.Context(), this.build.Schema(), value);
-        throw new ParseError(this.build.Schema(), value, errors);
+        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        throw new ParseError(this.buildResult.Schema(), value, errors);
     }
     /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        return Errors(this.build.Context(), this.build.Schema(), value);
+        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/build/schema/engine/_context.mjs

@@ -7,10 +7,10 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 function HasUnevaluatedFromObject(value) {
     return (Schema.IsUnevaluatedItems(value)
         || Schema.IsUnevaluatedProperties(value)
-        || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
+        || G.Some(G.Keys(value), key => HasUnevaluatedFromUnknown(value[key])));
 }
 function HasUnevaluatedFromArray(value) {
-    return value.some(value => HasUnevaluatedFromUnknown(value));
+    return G.Some(value, value => HasUnevaluatedFromUnknown(value));
 }
 function HasUnevaluatedFromUnknown(value) {
     return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
@@ -18,7 +18,7 @@ function HasUnevaluatedFromUnknown(value) {
             false);
 }
 export function HasUnevaluated(context, schema) {
-    return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
+    return HasUnevaluatedFromUnknown(schema) || G.Some(G.Keys(context), key => HasUnevaluatedFromUnknown(context[key]));
 }
 // ------------------------------------------------------------------
 // BuildContext

package/build/schema/engine/_functions.mjs

@@ -1,47 +1,65 @@
 // 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();
+const index = [0];
+const names = new Map;
+const funcs = new Map();
+// ------------------------------------------------------------------
+// CreateName
+// ------------------------------------------------------------------
+function NextName() {
+    return `${index[0]++}`;
+}
+function CreateName(schema, href) {
+    if (!names.has(schema))
+        names.set(schema, new Map());
+    const hrefs = names.get(schema);
+    if (hrefs.has(href))
+        return hrefs.get(href);
+    const name = NextName();
+    hrefs.set(href, name);
+    return name;
+}
 // ------------------------------------------------------------------
 // CreateCallExpression
 // ------------------------------------------------------------------
-function CreateCallExpression(context, _schema, hash, value) {
+function CreateCallExpression(context, _schema, name, value) {
     return context.UseUnevaluated()
-        ? E.Call(`check_${hash}`, ['context', value])
-        : E.Call(`check_${hash}`, [value]);
+        ? E.Call(`check_${name}`, ['context', value])
+        : E.Call(`check_${name}`, [value]);
 }
 // ------------------------------------------------------------------
 // CreateFunctionExpression
 // ------------------------------------------------------------------
-function CreateFunctionExpression(stack, context, schema, hash) {
+function CreateFunctionExpression(stack, context, schema, name) {
     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));
+        ? E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['context', 'value'], expression))
+        : E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['value'], expression));
 }
 // ------------------------------------------------------------------
 // ResetFunctions
 // ------------------------------------------------------------------
 export function ResetFunctions() {
-    functions.clear();
+    index[0] = 0;
+    names.clear();
+    funcs.clear();
 }
 // ------------------------------------------------------------------
 // GetFunctions
 // ------------------------------------------------------------------
 export function GetFunctions() {
-    return [...functions.values()];
+    return [...funcs.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))
+    const name = CreateName(schema, stack.BaseURL().href);
+    const call = CreateCallExpression(context, schema, name, value);
+    if (funcs.has(name))
         return call;
-    functions.set(hash, '');
-    functions.set(hash, CreateFunctionExpression(stack, context, schema, hash));
+    funcs.set(name, '');
+    funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
     return call;
 }

package/build/schema/engine/_refine.mjs

@@ -6,24 +6,24 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 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]));
+    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 export function CheckRefine(_stack, _context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.refine(value));
+    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.check(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({
+        return refinement.check(value) || context.AddError({
             keyword: '~refine',
             schemaPath,
             instancePath,
-            params: { index, message: refinement.message },
+            params: { index, message: refinement.error(value) },
         });
     });
 }

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

@@ -1,5 +1,6 @@
 import * as Schema from '../types/index.mjs';
 export declare class Stack {
+    #private;
     private readonly context;
     private readonly schema;
     private readonly ids;
@@ -11,8 +12,7 @@ export declare class Stack {
     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;
+    Ref(ref: Schema.XRef): Schema.XSchema | undefined;
+    RecursiveRef(recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
+    DynamicRef(dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
 }

package/build/schema/engine/_stack.mjs

@@ -1,9 +1,16 @@
 // deno-fmt-ignore-file
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors, _Stack_FromContext, _Stack_FromRef;
 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) {
+        _Stack_instances.add(this);
         this.context = context;
         this.schema = schema;
         this.ids = [];
@@ -26,8 +33,10 @@ export class Stack {
     Push(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema))
+        if (Schema.IsId(schema)) {
             this.ids.push(schema);
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
+        }
         if (Schema.IsAnchor(schema))
             this.anchors.push(schema);
         if (Schema.IsRecursiveAnchorTrue(schema))
@@ -38,8 +47,10 @@ export class Stack {
     Pop(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema))
+        if (Schema.IsId(schema)) {
             this.ids.pop();
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
+        }
         if (Schema.IsAnchor(schema))
             this.anchors.pop();
         if (Schema.IsRecursiveAnchorTrue(schema))
@@ -47,27 +58,50 @@ export class Stack {
         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);
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromContext).call(this, ref) ?? __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromRef).call(this, ref);
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
-        if (Schema.IsRecursiveAnchorTrue(this.Base())) {
-            return Resolve.Ref(this.recursiveAnchors[0], recursiveRef);
-        }
-        return Resolve.Ref(this.Base(), recursiveRef);
+        return Schema.IsRecursiveAnchorTrue(this.Base())
+            ? Resolve.Ref(this.recursiveAnchors[0], recursiveRef.$recursiveRef)
+            : Resolve.Ref(this.Base(), recursiveRef.$recursiveRef);
+    }
+    // ----------------------------------------------------------------
+    // DynamicRef
+    // ----------------------------------------------------------------
+    DynamicRef(dynamicRef) {
+        const root = this.schema;
+        return Resolve.DynamicRef(root, this.Base(), dynamicRef, this.dynamicAnchors);
     }
 }
+_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
+    if (!Schema.IsSchemaObject(schema))
+        return;
+    const current = schema;
+    if (!isRoot && Schema.IsId(current))
+        return;
+    if (!isRoot && Schema.IsDynamicAnchor(current))
+        this.dynamicAnchors.push(current);
+    for (const key of G.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
+}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
+    if (!Schema.IsSchemaObject(schema))
+        return;
+    const current = schema;
+    if (!isRoot && Schema.IsId(current))
+        return;
+    if (!isRoot && Schema.IsDynamicAnchor(current))
+        this.dynamicAnchors.pop();
+    for (const key of G.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
+}, _Stack_FromContext = function _Stack_FromContext(ref) {
+    return G.HasPropertyKey(this.context, ref.$ref) ? this.context[ref.$ref] : undefined;
+}, _Stack_FromRef = function _Stack_FromRef(ref) {
+    const root = this.schema;
+    return !ref.$ref.startsWith('#')
+        ? Resolve.Ref(root, ref.$ref)
+        : Resolve.Ref(this.Base(), ref.$ref);
+};