@astrofoundry/pi-astro 0.17.1 → 0.18.2

package/node_modules/typebox/build/guard/native.mjs

@@ -1,60 +0,0 @@
-import * as Guard from './guard.mjs';
-// --------------------------------------------------------------------------
-// Native
-// --------------------------------------------------------------------------
-/** Returns true if this value is a F32 */
-export function IsF32(value) {
-    return Guard.IsNumber(value) &&
-        Guard.IsEqual(value, Math.fround(value));
-}
-/** Returns true if this value is a F64 */
-export function IsF64(value) {
-    return Guard.IsNumber(value);
-}
-/** Returns true if this value is a U8 */
-export function IsU8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 255);
-}
-/** Returns true if this value is a U16 */
-export function IsU16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 65535);
-}
-/** Returns true if this value is a U32 */
-export function IsU32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 4294967295);
-}
-/** Returns true if this value is a U64 */
-export function IsU64(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0);
-}
-/** Returns true if this value is a I8 */
-export function IsI8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -128) &&
-        Guard.IsLessEqualThan(value, 127);
-}
-/** Returns true if this value is a I16 */
-export function IsI16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -32768) &&
-        Guard.IsLessEqualThan(value, 32767);
-}
-/** Returns true if this value is a I32 */
-export function IsI32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -2147483648) &&
-        Guard.IsLessEqualThan(value, 2147483647);
-}
-/** Returns true if this value is a I64 */
-export function IsI64(value) {
-    return Guard.IsBigInt(value) &&
-        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
-        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
-}

package/node_modules/typebox/build/guard/string.d.mts

@@ -1,6 +0,0 @@
-/** Returns the number of grapheme clusters in a string */
-export declare function GraphemeCount(value: string): number;
-/** Fast check for minimum grapheme length, falls back to full check if needed */
-export declare function IsMinLengthFast(value: string, minLength: number): boolean;
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;

package/node_modules/typebox/build/guard/string.mjs

@@ -1,164 +0,0 @@
-// --------------------------------------------------------------------------
-// IsBetween
-// --------------------------------------------------------------------------
-function IsBetween(value, min, max) {
-    return value >= min && value <= max;
-}
-// --------------------------------------------------------------------------
-// IsRegionalIndicator
-// --------------------------------------------------------------------------
-function IsRegionalIndicator(value) {
-    return IsBetween(value, 0x1F1E6, 0x1F1FF);
-}
-// --------------------------------------------------------------------------
-// IsVariationSelector
-// --------------------------------------------------------------------------
-function IsVariationSelector(value) {
-    return IsBetween(value, 0xFE00, 0xFE0F);
-}
-// --------------------------------------------------------------------------
-// IsCombiningMark
-// --------------------------------------------------------------------------
-function IsCombiningMark(value) {
-    return (IsBetween(value, 0x0300, 0x036F) ||
-        IsBetween(value, 0x1AB0, 0x1AFF) ||
-        IsBetween(value, 0x1DC0, 0x1DFF) ||
-        IsBetween(value, 0xFE20, 0xFE2F));
-}
-// --------------------------------------------------------------------------
-// CodePointLength
-// --------------------------------------------------------------------------
-function CodePointLength(value) {
-    return value > 0xFFFF ? 2 : 1;
-}
-// --------------------------------------------------------------------------
-// ConsumeModifiers (helper)
-// --------------------------------------------------------------------------
-function ConsumeModifiers(value, index) {
-    while (index < value.length) {
-        const point = value.codePointAt(index);
-        if (IsCombiningMark(point) || IsVariationSelector(point)) {
-            index += CodePointLength(point);
-        }
-        else {
-            break;
-        }
-    }
-    return index;
-}
-// --------------------------------------------------------------------------
-// NextGraphemeClusterIndex
-// --------------------------------------------------------------------------
-function NextGraphemeClusterIndex(value, clusterStart) {
-    const startCP = value.codePointAt(clusterStart);
-    let clusterEnd = clusterStart + CodePointLength(startCP);
-    // Consume combining marks & variation selectors
-    clusterEnd = ConsumeModifiers(value, clusterEnd);
-    // Handle multi-ZWJ sequences
-    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
-        const nextCP = value.codePointAt(clusterEnd + 1);
-        clusterEnd += 1 + CodePointLength(nextCP);
-        clusterEnd = ConsumeModifiers(value, clusterEnd);
-    }
-    // Handle regional indicator pairs (flags)
-    if (IsRegionalIndicator(startCP) &&
-        clusterEnd < value.length &&
-        IsRegionalIndicator(value.codePointAt(clusterEnd))) {
-        clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
-    }
-    return clusterEnd;
-}
-// --------------------------------------------------------------------------
-// IsGraphemeCodePoint
-// --------------------------------------------------------------------------
-function IsGraphemeCodePoint(value) {
-    return (IsBetween(value, 0xD800, 0xDBFF) || // High surrogate
-        IsBetween(value, 0x0300, 0x036F) || // Combining diacritical marks
-        (value === 0x200D) // Zero-width joiner
-    );
-}
-// --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
-// IsMinLength
-// --------------------------------------------------------------------------
-/** Checks if a string has at least a minimum number of grapheme clusters */
-function IsMinLength(value, minLength) {
-    // ----------------------------------------------------------------
-    // Inaccessible via public interface (review)
-    //
-    // deno-coverage-ignore-start
-    // ----------------------------------------------------------------
-    if (minLength === 0)
-        return true; // 0-length
-    // deno-coverage-ignore-stop
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count >= minLength)
-            return true;
-    }
-    return false;
-}
-// --------------------------------------------------------------------------
-// IsMaxLength
-// --------------------------------------------------------------------------
-/** Checks if a string has at most a maximum number of grapheme clusters */
-function IsMaxLength(value, maxLength) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-        if (count > maxLength)
-            return false;
-    }
-    return true;
-}
-// --------------------------------------------------------------------------
-// IsMinLengthFast
-// --------------------------------------------------------------------------
-/** Fast check for minimum grapheme length, falls back to full check if needed */
-export function IsMinLengthFast(value, minLength) {
-    if (minLength === 0)
-        return true; // 0-length
-    let index = 0;
-    while (index < value.length) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMinLength(value, minLength);
-        }
-        index++;
-        if (index >= minLength)
-            return true;
-    }
-    return false;
-}
-// --------------------------------------------------------------------------
-// IsMaxLengthFast
-// --------------------------------------------------------------------------
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export function IsMaxLengthFast(value, maxLength) {
-    let index = 0;
-    while (index < value.length) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMaxLength(value, maxLength);
-        }
-        index++;
-        if (index > maxLength)
-            return false;
-    }
-    return true;
-}

package/node_modules/typebox/build/index.d.mts

@@ -1,8 +0,0 @@
-export * from './type/action/index.mjs';
-export * from './type/engine/index.mjs';
-export * from './type/extends/index.mjs';
-export * from './type/script/index.mjs';
-export * from './type/types/index.mjs';
-export * as Type from './typebox.mjs';
-import * as Type from './typebox.mjs';
-export default Type;

package/node_modules/typebox/build/index.mjs

@@ -1,14 +0,0 @@
-// ------------------------------------------------------------------
-// Standard
-// ------------------------------------------------------------------
-export * from './type/action/index.mjs';
-export * from './type/engine/index.mjs';
-export * from './type/extends/index.mjs';
-export * from './type/script/index.mjs';
-export * from './type/types/index.mjs';
-// ------------------------------------------------------------------
-// TypeBox
-// ------------------------------------------------------------------
-export * as Type from './typebox.mjs';
-import * as Type from './typebox.mjs';
-export default Type;

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

@@ -1,39 +0,0 @@
-import * as Engine from './engine/index.mjs';
-import * as Schema from './types/index.mjs';
-export type CheckFunction = (value: unknown) => boolean;
-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 entry;
-    private readonly useUnevaluated;
-    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 */
-    Schema(): Schema.XSchema;
-    /** Returns true if this build requires a Unevaluated context */
-    UseUnevaluated(): boolean;
-    /** Returns external variables */
-    External(): Engine.TExternal;
-    /** Returns check functions */
-    Functions(): string[];
-    /** Return entry function call. */
-    Entry(): string;
-    /** Evaluates the build into a validation function */
-    Evaluate(): EvaluateResult;
-}
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(schema: Schema.XSchema): BuildResult;
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema): BuildResult;

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

@@ -1,118 +0,0 @@
-// 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/typebox/build/schema/check.d.mts

@@ -1,6 +0,0 @@
-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/typebox/build/schema/check.mjs

@@ -1,14 +0,0 @@
-// 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

@@ -1,22 +0,0 @@
-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

@@ -1,46 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-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

@@ -1,129 +0,0 @@
-// 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

@@ -1,3 +0,0 @@
-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;