@evalops/maestro 0.10.20 → 0.10.22

package/node_modules/@sinclair/typebox/build/esm/value/hash/hash.mjs

@@ -1,146 +0,0 @@
-import { IsArray, IsBoolean, IsBigInt, IsDate, IsNull, IsNumber, IsObject, IsString, IsSymbol, IsUint8Array, IsUndefined } from '../guard/index.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValueHashError extends TypeBoxError {
-    constructor(value) {
-        super(`Unable to hash value`);
-        this.value = value;
-    }
-}
-// ------------------------------------------------------------------
-// ByteMarker
-// ------------------------------------------------------------------
-var ByteMarker;
-(function (ByteMarker) {
-    ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
-    ByteMarker[ByteMarker["Null"] = 1] = "Null";
-    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
-    ByteMarker[ByteMarker["Number"] = 3] = "Number";
-    ByteMarker[ByteMarker["String"] = 4] = "String";
-    ByteMarker[ByteMarker["Object"] = 5] = "Object";
-    ByteMarker[ByteMarker["Array"] = 6] = "Array";
-    ByteMarker[ByteMarker["Date"] = 7] = "Date";
-    ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
-    ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
-    ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
-})(ByteMarker || (ByteMarker = {}));
-// ------------------------------------------------------------------
-// State
-// ------------------------------------------------------------------
-let Accumulator = BigInt('14695981039346656037');
-const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
-const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
-const F64 = new Float64Array(1);
-const F64In = new DataView(F64.buffer);
-const F64Out = new Uint8Array(F64.buffer);
-// ------------------------------------------------------------------
-// NumberToBytes
-// ------------------------------------------------------------------
-function* NumberToBytes(value) {
-    const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
-    for (let i = 0; i < byteCount; i++) {
-        yield (value >> (8 * (byteCount - 1 - i))) & 0xff;
-    }
-}
-// ------------------------------------------------------------------
-// Hashing Functions
-// ------------------------------------------------------------------
-function ArrayType(value) {
-    FNV1A64(ByteMarker.Array);
-    for (const item of value) {
-        Visit(item);
-    }
-}
-function BooleanType(value) {
-    FNV1A64(ByteMarker.Boolean);
-    FNV1A64(value ? 1 : 0);
-}
-function BigIntType(value) {
-    FNV1A64(ByteMarker.BigInt);
-    F64In.setBigInt64(0, value);
-    for (const byte of F64Out) {
-        FNV1A64(byte);
-    }
-}
-function DateType(value) {
-    FNV1A64(ByteMarker.Date);
-    Visit(value.getTime());
-}
-function NullType(value) {
-    FNV1A64(ByteMarker.Null);
-}
-function NumberType(value) {
-    FNV1A64(ByteMarker.Number);
-    F64In.setFloat64(0, value);
-    for (const byte of F64Out) {
-        FNV1A64(byte);
-    }
-}
-function ObjectType(value) {
-    FNV1A64(ByteMarker.Object);
-    for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
-        Visit(key);
-        Visit(value[key]);
-    }
-}
-function StringType(value) {
-    FNV1A64(ByteMarker.String);
-    for (let i = 0; i < value.length; i++) {
-        for (const byte of NumberToBytes(value.charCodeAt(i))) {
-            FNV1A64(byte);
-        }
-    }
-}
-function SymbolType(value) {
-    FNV1A64(ByteMarker.Symbol);
-    Visit(value.description);
-}
-function Uint8ArrayType(value) {
-    FNV1A64(ByteMarker.Uint8Array);
-    for (let i = 0; i < value.length; i++) {
-        FNV1A64(value[i]);
-    }
-}
-function UndefinedType(value) {
-    return FNV1A64(ByteMarker.Undefined);
-}
-function Visit(value) {
-    if (IsArray(value))
-        return ArrayType(value);
-    if (IsBoolean(value))
-        return BooleanType(value);
-    if (IsBigInt(value))
-        return BigIntType(value);
-    if (IsDate(value))
-        return DateType(value);
-    if (IsNull(value))
-        return NullType(value);
-    if (IsNumber(value))
-        return NumberType(value);
-    if (IsObject(value))
-        return ObjectType(value);
-    if (IsString(value))
-        return StringType(value);
-    if (IsSymbol(value))
-        return SymbolType(value);
-    if (IsUint8Array(value))
-        return Uint8ArrayType(value);
-    if (IsUndefined(value))
-        return UndefinedType(value);
-    throw new ValueHashError(value);
-}
-function FNV1A64(byte) {
-    Accumulator = Accumulator ^ Bytes[byte];
-    Accumulator = (Accumulator * Prime) % Size;
-}
-// ------------------------------------------------------------------
-// Hash
-// ------------------------------------------------------------------
-/** Creates a FNV1A-64 non cryptographic hash of the given value */
-export function Hash(value) {
-    Accumulator = BigInt('14695981039346656037');
-    Visit(value);
-    return Accumulator;
-}

package/node_modules/@sinclair/typebox/build/esm/value/hash/index.d.mts

@@ -1 +0,0 @@
-export * from './hash.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/hash/index.mjs

@@ -1 +0,0 @@
-export * from './hash.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/index.d.mts

@@ -1,20 +0,0 @@
-export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-export * from './guard/index.mjs';
-export * from './assert/index.mjs';
-export * from './cast/index.mjs';
-export * from './check/index.mjs';
-export * from './clean/index.mjs';
-export * from './clone/index.mjs';
-export * from './convert/index.mjs';
-export * from './create/index.mjs';
-export * from './decode/index.mjs';
-export * from './default/index.mjs';
-export * from './delta/index.mjs';
-export * from './encode/index.mjs';
-export * from './equal/index.mjs';
-export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
-export * from './parse/index.mjs';
-export * from './pointer/index.mjs';
-export * from './transform/index.mjs';
-export { Value } from './value/index.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/index.mjs

@@ -1,32 +0,0 @@
-// ------------------------------------------------------------------
-// Errors (re-export)
-// ------------------------------------------------------------------
-export { ValueErrorType, ValueErrorIterator } from '../errors/index.mjs';
-// ------------------------------------------------------------------
-// Guards
-// ------------------------------------------------------------------
-export * from './guard/index.mjs';
-// ------------------------------------------------------------------
-// Operators
-// ------------------------------------------------------------------
-export * from './assert/index.mjs';
-export * from './cast/index.mjs';
-export * from './check/index.mjs';
-export * from './clean/index.mjs';
-export * from './clone/index.mjs';
-export * from './convert/index.mjs';
-export * from './create/index.mjs';
-export * from './decode/index.mjs';
-export * from './default/index.mjs';
-export * from './delta/index.mjs';
-export * from './encode/index.mjs';
-export * from './equal/index.mjs';
-export * from './hash/index.mjs';
-export * from './mutate/index.mjs';
-export * from './parse/index.mjs';
-export * from './pointer/index.mjs';
-export * from './transform/index.mjs';
-// ------------------------------------------------------------------
-// Namespace
-// ------------------------------------------------------------------
-export { Value } from './value/index.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/mutate/index.d.mts

@@ -1 +0,0 @@
-export * from './mutate.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/mutate/index.mjs

@@ -1 +0,0 @@
-export * from './mutate.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/mutate/mutate.d.mts

@@ -1,9 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-export declare class ValueMutateError extends TypeBoxError {
-    constructor(message: string);
-}
-export type Mutable = {
-    [key: string]: unknown;
-} | unknown[];
-/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
-export declare function Mutate(current: Mutable, next: Mutable): void;

package/node_modules/@sinclair/typebox/build/esm/value/mutate/mutate.mjs

@@ -1,98 +0,0 @@
-import { IsObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
-import { ValuePointer } from '../pointer/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
-// ------------------------------------------------------------------
-// IsStandardObject
-// ------------------------------------------------------------------
-function IsStandardObject(value) {
-    return IsObject(value) && !IsArray(value);
-}
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValueMutateError extends TypeBoxError {
-    constructor(message) {
-        super(message);
-    }
-}
-function ObjectType(root, path, current, next) {
-    if (!IsStandardObject(current)) {
-        ValuePointer.Set(root, path, Clone(next));
-    }
-    else {
-        const currentKeys = Object.getOwnPropertyNames(current);
-        const nextKeys = Object.getOwnPropertyNames(next);
-        for (const currentKey of currentKeys) {
-            if (!nextKeys.includes(currentKey)) {
-                delete current[currentKey];
-            }
-        }
-        for (const nextKey of nextKeys) {
-            if (!currentKeys.includes(nextKey)) {
-                current[nextKey] = null;
-            }
-        }
-        for (const nextKey of nextKeys) {
-            Visit(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
-        }
-    }
-}
-function ArrayType(root, path, current, next) {
-    if (!IsArray(current)) {
-        ValuePointer.Set(root, path, Clone(next));
-    }
-    else {
-        for (let index = 0; index < next.length; index++) {
-            Visit(root, `${path}/${index}`, current[index], next[index]);
-        }
-        current.splice(next.length);
-    }
-}
-function TypedArrayType(root, path, current, next) {
-    if (IsTypedArray(current) && current.length === next.length) {
-        for (let i = 0; i < current.length; i++) {
-            current[i] = next[i];
-        }
-    }
-    else {
-        ValuePointer.Set(root, path, Clone(next));
-    }
-}
-function ValueType(root, path, current, next) {
-    if (current === next)
-        return;
-    ValuePointer.Set(root, path, next);
-}
-function Visit(root, path, current, next) {
-    if (IsArray(next))
-        return ArrayType(root, path, current, next);
-    if (IsTypedArray(next))
-        return TypedArrayType(root, path, current, next);
-    if (IsStandardObject(next))
-        return ObjectType(root, path, current, next);
-    if (IsValueType(next))
-        return ValueType(root, path, current, next);
-}
-// ------------------------------------------------------------------
-// IsNonMutableValue
-// ------------------------------------------------------------------
-function IsNonMutableValue(value) {
-    return IsTypedArray(value) || IsValueType(value);
-}
-function IsMismatchedValue(current, next) {
-    // prettier-ignore
-    return ((IsStandardObject(current) && IsArray(next)) ||
-        (IsArray(current) && IsStandardObject(next)));
-}
-// ------------------------------------------------------------------
-// Mutate
-// ------------------------------------------------------------------
-/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
-export function Mutate(current, next) {
-    if (IsNonMutableValue(current) || IsNonMutableValue(next))
-        throw new ValueMutateError('Only object and array types can be mutated at the root level');
-    if (IsMismatchedValue(current, next))
-        throw new ValueMutateError('Cannot assign due type mismatch of assignable values');
-    Visit(current, '', current, next);
-}

package/node_modules/@sinclair/typebox/build/esm/value/parse/index.d.mts

@@ -1 +0,0 @@
-export * from './parse.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/parse/index.mjs

@@ -1 +0,0 @@
-export * from './parse.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/parse/parse.d.mts

@@ -1,22 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { TSchema } from '../../type/schema/index.mjs';
-import { StaticDecode } from '../../type/static/index.mjs';
-export declare class ParseError extends TypeBoxError {
-    constructor(message: string);
-}
-export type TParseOperation = 'Assert' | 'Cast' | 'Clean' | 'Clone' | 'Convert' | 'Decode' | 'Default' | 'Encode' | ({} & string);
-export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
-export declare namespace ParseRegistry {
-    function Delete(key: string): void;
-    function Set(key: string, callback: TParseFunction): void;
-    function Get(key: string): TParseFunction | undefined;
-}
-export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
-/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
-export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
-/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
-export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
-/** Parses a value using the specified operations. */
-export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
-/** Parses a value using the specified operations. */
-export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/node_modules/@sinclair/typebox/build/esm/value/parse/parse.mjs

@@ -1,81 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { TransformDecode, TransformEncode, HasTransform } from '../transform/index.mjs';
-import { Assert } from '../assert/index.mjs';
-import { Cast } from '../cast/index.mjs';
-import { Clean } from '../clean/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Convert } from '../convert/index.mjs';
-import { Default } from '../default/index.mjs';
-// ------------------------------------------------------------------
-// Guards
-// ------------------------------------------------------------------
-import { IsArray, IsUndefined } from '../guard/index.mjs';
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export class ParseError extends TypeBoxError {
-    constructor(message) {
-        super(message);
-    }
-}
-// prettier-ignore
-export var ParseRegistry;
-(function (ParseRegistry) {
-    const registry = new Map([
-        ['Assert', (type, references, value) => { Assert(type, references, value); return value; }],
-        ['Cast', (type, references, value) => Cast(type, references, value)],
-        ['Clean', (type, references, value) => Clean(type, references, value)],
-        ['Clone', (_type, _references, value) => Clone(value)],
-        ['Convert', (type, references, value) => Convert(type, references, value)],
-        ['Decode', (type, references, value) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
-        ['Default', (type, references, value) => Default(type, references, value)],
-        ['Encode', (type, references, value) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
-    ]);
-    // Deletes an entry from the registry
-    function Delete(key) {
-        registry.delete(key);
-    }
-    ParseRegistry.Delete = Delete;
-    // Sets an entry in the registry
-    function Set(key, callback) {
-        registry.set(key, callback);
-    }
-    ParseRegistry.Set = Set;
-    // Gets an entry in the registry
-    function Get(key) {
-        return registry.get(key);
-    }
-    ParseRegistry.Get = Get;
-})(ParseRegistry || (ParseRegistry = {}));
-// ------------------------------------------------------------------
-// Default Parse Pipeline
-// ------------------------------------------------------------------
-// prettier-ignore
-export const ParseDefault = [
-    'Clone',
-    'Clean',
-    'Default',
-    'Convert',
-    'Assert',
-    'Decode'
-];
-// ------------------------------------------------------------------
-// ParseValue
-// ------------------------------------------------------------------
-function ParseValue(operations, type, references, value) {
-    return operations.reduce((value, operationKey) => {
-        const operation = ParseRegistry.Get(operationKey);
-        if (IsUndefined(operation))
-            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
-        return operation(type, references, value);
-    }, value);
-}
-/** Parses a value */
-export function Parse(...args) {
-    // prettier-ignore
-    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
-        args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
-            args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
-                (() => { throw new ParseError('Invalid Arguments'); })());
-    return ParseValue(operations, schema, references, value);
-}

package/node_modules/@sinclair/typebox/build/esm/value/pointer/index.d.mts

@@ -1 +0,0 @@
-export * as ValuePointer from './pointer.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/pointer/index.mjs

@@ -1 +0,0 @@
-export * as ValuePointer from './pointer.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/pointer/pointer.d.mts

@@ -1,22 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-export declare class ValuePointerRootSetError extends TypeBoxError {
-    readonly value: unknown;
-    readonly path: string;
-    readonly update: unknown;
-    constructor(value: unknown, path: string, update: unknown);
-}
-export declare class ValuePointerRootDeleteError extends TypeBoxError {
-    readonly value: unknown;
-    readonly path: string;
-    constructor(value: unknown, path: string);
-}
-/** Formats the given pointer into navigable key components */
-export declare function Format(pointer: string): IterableIterator<string>;
-/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-export declare function Set(value: any, pointer: string, update: unknown): void;
-/** Deletes a value at the given pointer */
-export declare function Delete(value: any, pointer: string): void;
-/** Returns true if a value exists at the given pointer */
-export declare function Has(value: any, pointer: string): boolean;
-/** Gets the value at the given pointer */
-export declare function Get(value: any, pointer: string): any;

package/node_modules/@sinclair/typebox/build/esm/value/pointer/pointer.mjs

@@ -1,115 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValuePointerRootSetError extends TypeBoxError {
-    constructor(value, path, update) {
-        super('Cannot set root value');
-        this.value = value;
-        this.path = path;
-        this.update = update;
-    }
-}
-export class ValuePointerRootDeleteError extends TypeBoxError {
-    constructor(value, path) {
-        super('Cannot delete root value');
-        this.value = value;
-        this.path = path;
-    }
-}
-// ------------------------------------------------------------------
-// ValuePointer
-// ------------------------------------------------------------------
-/** Provides functionality to update values through RFC6901 string pointers */
-// prettier-ignore
-function Escape(component) {
-    return component.indexOf('~') === -1 ? component : component.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-/** Formats the given pointer into navigable key components */
-// prettier-ignore
-export function* Format(pointer) {
-    if (pointer === '')
-        return;
-    let [start, end] = [0, 0];
-    for (let i = 0; i < pointer.length; i++) {
-        const char = pointer.charAt(i);
-        if (char === '/') {
-            if (i === 0) {
-                start = i + 1;
-            }
-            else {
-                end = i;
-                yield Escape(pointer.slice(start, end));
-                start = i + 1;
-            }
-        }
-        else {
-            end = i;
-        }
-    }
-    yield Escape(pointer.slice(start));
-}
-/** Sets the value at the given pointer. If the value at the pointer does not exist it is created */
-// prettier-ignore
-export function Set(value, pointer, update) {
-    if (pointer === '')
-        throw new ValuePointerRootSetError(value, pointer, update);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined)
-            next[component] = {};
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    owner[key] = update;
-}
-/** Deletes a value at the given pointer */
-// prettier-ignore
-export function Delete(value, pointer) {
-    if (pointer === '')
-        throw new ValuePointerRootDeleteError(value, pointer);
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined || next[component] === null)
-            return;
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    if (Array.isArray(owner)) {
-        const index = parseInt(key);
-        owner.splice(index, 1);
-    }
-    else {
-        delete owner[key];
-    }
-}
-/** Returns true if a value exists at the given pointer */
-// prettier-ignore
-export function Has(value, pointer) {
-    if (pointer === '')
-        return true;
-    let [owner, next, key] = [null, value, ''];
-    for (const component of Format(pointer)) {
-        if (next[component] === undefined)
-            return false;
-        owner = next;
-        next = next[component];
-        key = component;
-    }
-    return Object.getOwnPropertyNames(owner).includes(key);
-}
-/** Gets the value at the given pointer */
-// prettier-ignore
-export function Get(value, pointer) {
-    if (pointer === '')
-        return value;
-    let current = value;
-    for (const component of Format(pointer)) {
-        if (current[component] === undefined)
-            return undefined;
-        current = current[component];
-    }
-    return current;
-}

package/node_modules/@sinclair/typebox/build/esm/value/transform/decode.d.mts

@@ -1,22 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { ValueError } from '../../errors/index.mjs';
-import type { TSchema } from '../../type/schema/index.mjs';
-export declare class TransformDecodeCheckError extends TypeBoxError {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformDecodeError extends TypeBoxError {
-    readonly schema: TSchema;
-    readonly path: string;
-    readonly value: unknown;
-    readonly error: Error;
-    constructor(schema: TSchema, path: string, value: unknown, error: Error);
-}
-/**
- * `[Internal]` Decodes the value and returns the result. This function requires that
- * the caller `Check` the value before use. Passing unchecked values may result in
- * undefined behavior. Refer to the `Value.Decode()` for implementation details.
- */
-export declare function TransformDecode(schema: TSchema, references: TSchema[], value: unknown): unknown;