@daniel156161/prism 0.2.76 → 0.2.78

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/build.mjs

@@ -0,0 +1,118 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Environment } from '../system/environment/index.mjs';
+import { Hashing } from '../system/hashing/index.mjs';
+import { Guard } from '../guard/index.mjs';
+import { Format } from '../format/index.mjs';
+import * as Engine from './engine/index.mjs';
+// ------------------------------------------------------------------
+// CreateCode
+// ------------------------------------------------------------------
+function CreateCode(build) {
+    const functions = build.Functions().join(';\n');
+    const statements = build.UseUnevaluated()
+        ? ['const context = new CheckContext({}, {})', `return ${build.Entry()}`]
+        : [`return ${build.Entry()}`];
+    return `${functions}; return (value) => { ${statements.join('; ')} }`;
+}
+// ------------------------------------------------------------------
+// CreateEvaluatedCheck
+// ------------------------------------------------------------------
+function CreateEvaluatedCheck(build, code) {
+    const factory = Environment.Evaluate('CheckContext', 'Guard', 'Format', 'Hashing', build.External().identifier, code);
+    return factory(Engine.CheckContext, Guard, Format, Hashing, build.External().variables);
+}
+// ------------------------------------------------------------------
+// CreateDynamicCheck
+// ------------------------------------------------------------------
+function CreateDynamicCheck(build) {
+    const stack = new Engine.Stack(build.Context(), build.Schema());
+    const context = new Engine.CheckContext();
+    return (value) => Engine.CheckSchema(stack, context, build.Schema(), value);
+}
+// ------------------------------------------------------------------
+// CreateCheck
+// ------------------------------------------------------------------
+function CreateCheck(build, code) {
+    return Environment.CanEvaluate()
+        ? CreateEvaluatedCheck(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, entry, useUnevaluated) {
+        this.context = context;
+        this.schema = schema;
+        this.external = external;
+        this.functions = functions;
+        this.entry = entry;
+        this.useUnevaluated = useUnevaluated;
+    }
+    /** Returns the Context used for this build */
+    Context() {
+        return this.context;
+    }
+    /** Returns the Schema used for this build */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns true if this build requires a Unevaluated context */
+    UseUnevaluated() {
+        return this.useUnevaluated;
+    }
+    /** Returns external variables */
+    External() {
+        return this.external;
+    }
+    /** Returns check functions */
+    Functions() {
+        return this.functions;
+    }
+    /** Return entry function call. */
+    Entry() {
+        return this.entry;
+    }
+    /** Evaluates the build into a validation function */
+    Evaluate() {
+        const code = CreateCode(this);
+        const check = CreateCheck(this, code);
+        return new EvaluateResult(Environment.CanEvaluate(), code, check);
+    }
+}
+/** Builds a schema into a optimized runtime validator */
+export function Build(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    Engine.ResetExternal();
+    Engine.ResetFunctions();
+    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/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/check.d.mts

@@ -0,0 +1,6 @@
+import { type Static } from '../type/types/static.mjs';
+import * as Schema from './types/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<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<Schema>;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/check.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/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]
+    });
+    const stack = new Engine.Stack(context, schema);
+    const checkContext = new Engine.CheckContext();
+    return Engine.CheckSchema(stack, checkContext, schema, value);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/compile.d.mts

@@ -0,0 +1,22 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type Static } from '../type/types/static.mjs';
+import * as Schema from './types/index.mjs';
+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;
+    /** Returns the underlying Schema used to construct this Validator. */
+    Schema(): Schema;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Value;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Value;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
+}
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(schema: Schema): Validator<Schema>;
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema): Validator<Schema>;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/compile.mjs

@@ -0,0 +1,46 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import * as Build from './build.mjs';
+import { Errors } from './errors.mjs';
+import { ParseError } from './parse.mjs';
+// ------------------------------------------------------------------
+// Validator
+// ------------------------------------------------------------------
+export class Validator {
+    constructor(context, schema) {
+        this.buildResult = Build.Build(context, schema);
+        this.evaluateResult = this.buildResult.Evaluate();
+    }
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated() {
+        return this.evaluateResult.IsAccelerated();
+    }
+    /** Returns the underlying Schema used to construct this Validator. */
+    Schema() {
+        return this.buildResult.Schema();
+    }
+    /** Performs a type-guard check on the provided value. */
+    Check(value) {
+        return this.evaluateResult.Check(value);
+    }
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value) {
+        if (this.evaluateResult.Check(value))
+            return value;
+        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.buildResult.Context(), this.buildResult.Schema(), value);
+    }
+}
+/** Compiles this schema into a high performance Validator */
+export function Compile(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    return new Validator(context, schema);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_context.d.mts

@@ -0,0 +1,35 @@
+import type { TValidationError } from '../../error/index.mjs';
+export declare function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean;
+export declare class BuildContext {
+    private readonly hasUnevaluated;
+    constructor(hasUnevaluated: boolean);
+    UseUnevaluated(): boolean;
+    Push(): string;
+    Pop(): string;
+    AddIndex(index: string): string;
+    AddKey(key: string): string;
+    Merge(results: string): string;
+}
+export declare class CheckContext {
+    private readonly stack;
+    constructor();
+    Push(): true;
+    Pop(): true;
+    AddIndex(index: number): true;
+    AddKey(key: string): true;
+    GetIndices(): Set<number>;
+    GetKeys(): Set<string>;
+    Merge(results: CheckContext[]): true;
+}
+export type ErrorContextCallback = (error: TValidationError) => unknown;
+export declare class ErrorContext extends CheckContext {
+    private readonly callback;
+    constructor(callback: ErrorContextCallback);
+    AddError(error: TValidationError): false;
+}
+export declare class AccumulatedErrorContext extends ErrorContext {
+    private readonly errors;
+    constructor();
+    AddError(error: TValidationError): false;
+    GetErrors(): TValidationError[];
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_context.mjs

@@ -0,0 +1,129 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// HasUnevaluated
+// ------------------------------------------------------------------
+function HasUnevaluatedFromObject(value) {
+    return (Schema.IsUnevaluatedItems(value)
+        || Schema.IsUnevaluatedProperties(value)
+        || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key])));
+}
+function HasUnevaluatedFromArray(value) {
+    return value.some(value => HasUnevaluatedFromUnknown(value));
+}
+function HasUnevaluatedFromUnknown(value) {
+    return (G.IsArray(value) ? HasUnevaluatedFromArray(value) :
+        G.IsObject(value) ? HasUnevaluatedFromObject(value) :
+            false);
+}
+export function HasUnevaluated(context, schema) {
+    return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]));
+}
+// ------------------------------------------------------------------
+// BuildContext
+// ------------------------------------------------------------------
+export class BuildContext {
+    constructor(hasUnevaluated) {
+        this.hasUnevaluated = hasUnevaluated;
+    }
+    UseUnevaluated() {
+        return this.hasUnevaluated;
+    }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push() {
+        return E.Call(E.Member('context', 'Push'), []);
+    }
+    Pop() {
+        return E.Call(E.Member('context', 'Pop'), []);
+    }
+    // ----------------------------------------------------------------
+    // Top
+    // ----------------------------------------------------------------
+    AddIndex(index) {
+        return E.Call(E.Member('context', 'AddIndex'), [index]);
+    }
+    AddKey(key) {
+        return E.Call(E.Member('context', 'AddKey'), [key]);
+    }
+    Merge(results) {
+        return E.Call(E.Member('context', 'Merge'), [results]);
+    }
+}
+// ------------------------------------------------------------------
+// CheckContext
+// ------------------------------------------------------------------
+export class CheckContext {
+    constructor() {
+        const indices = new Set();
+        const keys = new Set();
+        this.stack = [{ indices, keys }];
+    }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push() {
+        const indices = new Set();
+        const keys = new Set();
+        this.stack.push({ indices, keys });
+        return true;
+    }
+    Pop() {
+        this.stack.pop();
+        return true;
+    }
+    // ----------------------------------------------------------------
+    // Top
+    // ----------------------------------------------------------------
+    AddIndex(index) {
+        this.GetIndices().add(index);
+        return true;
+    }
+    AddKey(key) {
+        this.GetKeys().add(key);
+        return true;
+    }
+    GetIndices() {
+        const top = this.stack[this.stack.length - 1];
+        return top.indices;
+    }
+    GetKeys() {
+        const top = this.stack[this.stack.length - 1];
+        return top.keys;
+    }
+    Merge(results) {
+        for (const context of results) {
+            context.GetIndices().forEach(value => this.GetIndices().add(value));
+            context.GetKeys().forEach(value => this.GetKeys().add(value));
+        }
+        return true;
+    }
+}
+export class ErrorContext extends CheckContext {
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+    AddError(error) {
+        this.callback(error);
+        return false;
+    }
+}
+// ------------------------------------------------------------------
+// AccumulatedErrorContext
+// ------------------------------------------------------------------
+export class AccumulatedErrorContext extends ErrorContext {
+    constructor() {
+        super(error => this.errors.push(error));
+        this.errors = [];
+    }
+    AddError(error) {
+        this.errors.push(error);
+        return false;
+    }
+    GetErrors() {
+        return this.errors;
+    }
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_exact_optional.d.mts

@@ -0,0 +1,3 @@
+export declare function IsExactOptional(required: string[], key: string): boolean;
+export declare function InexactOptionalBuild(value: string, key: string): string;
+export declare function InexactOptionalCheck(value: Record<PropertyKey, unknown>, key: string): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_exact_optional.mjs

@@ -0,0 +1,20 @@
+import { Settings } from '../../system/settings/index.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// IsExactOptional
+// ------------------------------------------------------------------
+export function IsExactOptional(required, key) {
+    return required.includes(key) || Settings.Get().exactOptionalPropertyTypes;
+}
+// ------------------------------------------------------------------
+// ExactOptionalBuild
+// ------------------------------------------------------------------
+export function InexactOptionalBuild(value, key) {
+    return E.IsUndefined(E.Member(value, key));
+}
+// ------------------------------------------------------------------
+// ExactOptionalCheck
+// ------------------------------------------------------------------
+export function InexactOptionalCheck(value, key) {
+    return G.IsUndefined(value[key]);
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_externals.d.mts

@@ -0,0 +1,7 @@
+export interface TExternal {
+    identifier: 'External';
+    variables: unknown[];
+}
+export declare function CreateVariable(value: unknown): string;
+export declare function ResetExternal(): void;
+export declare function GetExternal(): TExternal;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_externals.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+const state = {
+    identifier: 'External',
+    variables: []
+};
+// ------------------------------------------------------------------
+// CreateVariable
+// ------------------------------------------------------------------
+export function CreateVariable(value) {
+    const call = `External[${state.variables.length}]`;
+    state.variables.push(value);
+    return call;
+}
+// ------------------------------------------------------------------
+// ResetExternal
+// ------------------------------------------------------------------
+export function ResetExternal() {
+    state.variables = [];
+}
+// ------------------------------------------------------------------
+// GetExternals
+// ------------------------------------------------------------------
+export function GetExternal() {
+    return { ...state };
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_functions.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_functions.mjs

@@ -0,0 +1,66 @@
+// deno-fmt-ignore-file
+import { Hashing } from '../../system/hashing/index.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema } from './schema.mjs';
+const index = [0];
+const names = new Map;
+const funcs = new Map();
+// ------------------------------------------------------------------
+// CreateName
+// ------------------------------------------------------------------
+function NextName() {
+    return Hashing.Hash(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, name, value) {
+    return context.UseUnevaluated()
+        ? E.Call(`check_${name}`, ['context', value])
+        : E.Call(`check_${name}`, [value]);
+}
+// ------------------------------------------------------------------
+// CreateFunctionExpression
+// ------------------------------------------------------------------
+function CreateFunctionExpression(stack, context, schema, name) {
+    const expression = BuildSchema(stack, context, schema, 'value');
+    return context.UseUnevaluated()
+        ? E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['context', 'value'], expression))
+        : E.ConstDeclaration(`check_${name}`, E.ArrowFunction(['value'], expression));
+}
+// ------------------------------------------------------------------
+// ResetFunctions
+// ------------------------------------------------------------------
+export function ResetFunctions() {
+    index[0] = 0;
+    names.clear();
+    funcs.clear();
+}
+// ------------------------------------------------------------------
+// GetFunctions
+// ------------------------------------------------------------------
+export function GetFunctions() {
+    return [...funcs.values()];
+}
+// ------------------------------------------------------------------
+// CreateFunction
+// ------------------------------------------------------------------
+export function CreateFunction(stack, context, schema, value) {
+    const name = CreateName(schema, stack.BaseURL().href);
+    const call = CreateCallExpression(context, schema, name, value);
+    if (funcs.has(name))
+        return call;
+    funcs.set(name, '');
+    funcs.set(name, CreateFunctionExpression(stack, context, schema, name));
+    return call;
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_reducer.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_reducer.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_refine.d.mts

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_refine.mjs

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

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/schema/engine/_stack.d.mts

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