@openclaw/discord 2026.5.20 → 2026.5.22

package/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/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/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/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/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/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/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/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/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/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/typebox/build/schema/engine/_functions.mjs

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

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

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

package/node_modules/typebox/build/schema/engine/_guard.mjs

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

package/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/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/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/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/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;
+}

package/node_modules/typebox/build/schema/engine/_stack.mjs

@@ -0,0 +1,107 @@
+// 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 = [];
+        this.anchors = [];
+        this.recursiveAnchors = [];
+        this.dynamicAnchors = [];
+    }
+    // ----------------------------------------------------------------
+    // Base
+    // ----------------------------------------------------------------
+    BaseURL() {
+        return this.ids.reduce((result, schema) => new URL(schema.$id, result), new URL('http://unknown'));
+    }
+    Base() {
+        return this.ids[this.ids.length - 1] ?? this.schema;
+    }
+    // ----------------------------------------------------------------
+    // Stack
+    // ----------------------------------------------------------------
+    Push(schema) {
+        if (!Schema.IsSchemaObject(schema))
+            return;
+        if (Schema.IsId(schema)) {
+            this.ids.push(schema);
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, 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();
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
+        }
+        if (Schema.IsAnchor(schema))
+            this.anchors.pop();
+        if (Schema.IsRecursiveAnchorTrue(schema))
+            this.recursiveAnchors.pop();
+        if (Schema.IsDynamicAnchor(schema))
+            this.dynamicAnchors.pop();
+    }
+    Ref(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) {
+        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);
+};

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

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

package/node_modules/typebox/build/schema/engine/_unique.mjs

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

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

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