pi-proactive 0.2.0-beta.2 → 0.2.0-beta.4

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/unicode/unicode.d.mts

@@ -1,6 +0,0 @@
-/** Returns the total number of Unicode code points in the string */
-export declare function CodePointCount(value: string): number;
-/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;
-/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
-export declare function IsMinLength(value: string, minLength: number): boolean;

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

@@ -1,35 +0,0 @@
-// ------------------------------------------------------------------
-// CodePointCount (10-bit Shift Branchless)
-//
-// Counts code points by enumerating UTF-16 sequences and incrementing
-// when not within a high/low pairing. Because surrogate blocks are
-// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
-// collapse each unit to a constant per block (high: 0x36, low: 0x37)
-// and shift again into a packed (0x3637) for comparison. Fetch calls
-// to charCodeAt(...) are kept to one call per iteration.
-//
-// ------------------------------------------------------------------
-/** Returns the total number of Unicode code points in the string */
-export function CodePointCount(value) {
-    let result = 0, index = 0, prev = 0;
-    while (index < value.length) {
-        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
-        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
-        prev = next;
-    }
-    return result;
-}
-// ------------------------------------------------------------------
-// IsMaxLength
-// ------------------------------------------------------------------
-/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
-export function IsMaxLength(value, maxLength) {
-    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
-}
-// ------------------------------------------------------------------
-// IsMinLength
-// ------------------------------------------------------------------
-/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
-export function IsMinLength(value, minLength) {
-    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
-}

package/node_modules/typebox/build/guard/unicode/unicode_segment.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 IsMinLength(value: string, minLength: number): boolean;
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;

package/node_modules/typebox/build/guard/unicode/unicode_segment.mjs

@@ -1,165 +0,0 @@
-// --------------------------------------------------------------------------
-// IsBetween
-// --------------------------------------------------------------------------
-function IsBetween(value, min, max) {
-    return value >= min && value <= max;
-}
-// --------------------------------------------------------------------------
-// IsZeroWidthJoiner
-// --------------------------------------------------------------------------
-function IsZeroWidthJoiner(value) {
-    return (value === 0x200D);
-}
-// --------------------------------------------------------------------------
-// IsHighSurrogate
-// --------------------------------------------------------------------------
-function IsHighSurrogate(value) {
-    return IsBetween(value, 0xD800, 0xDBFF);
-}
-// --------------------------------------------------------------------------
-// IsRegionalIndicator
-// --------------------------------------------------------------------------
-function IsRegionalIndicator(value) {
-    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 && IsZeroWidthJoiner(value.codePointAt(clusterEnd))) {
-        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 ((value >= 0x0300) && ( // above special range
-    IsHighSurrogate(value) ||
-        IsCombiningMark(value) ||
-        IsVariationSelector(value) ||
-        IsZeroWidthJoiner(value)));
-}
-// --------------------------------------------------------------------------
-// IsMinLengthSegmented
-// --------------------------------------------------------------------------
-/** Checks if a string has at least a minimum number of grapheme clusters */
-function IsMinLengthSegmented(value, minLength) {
-    // if (minLength === 0) return true // 0-length (unreachable)
-    let count = 0, index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        if ((++count) >= minLength)
-            return true;
-    }
-    return false;
-}
-// --------------------------------------------------------------------------
-// IsMaxLengthSegmented
-// --------------------------------------------------------------------------
-/** Checks if a string has at most a maximum number of grapheme clusters */
-function IsMaxLengthSegmented(value, maxLength) {
-    let count = 0, index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        if ((++count) > maxLength)
-            return false;
-    }
-    return true;
-}
-// --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0, index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
-// IsMinLength
-// --------------------------------------------------------------------------
-/** Fast check for minimum grapheme length, falls back to full check if needed */
-export function IsMinLength(value, minLength) {
-    if (minLength === 0)
-        return true; // 0-length
-    if (value.length < minLength)
-        return false; // length is upper bound on grapheme count
-    let index = 0;
-    while (true) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMinLengthSegmented(value, minLength);
-        }
-        if ((++index) >= minLength)
-            return true;
-    }
-}
-// --------------------------------------------------------------------------
-// IsMaxLength
-// --------------------------------------------------------------------------
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export function IsMaxLength(value, maxLength) {
-    if (value.length <= maxLength)
-        return true; // length is upper bound on grapheme count
-    let index = 0;
-    while (true) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMaxLengthSegmented(value, maxLength);
-        }
-        if ((++index) > maxLength)
-            return false;
-    }
-}

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 * 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', 'Hashing', build.External().identifier, code);
-    return factory(Engine.CheckContext, Guard, Hashing, build.External().variables);
-}
-// ------------------------------------------------------------------
-// CreateDynamicCheck
-// ------------------------------------------------------------------
-function CreateDynamicCheck(build) {
-    const stack = 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.ResetUnique();
-    Engine.ResetExternal();
-    Engine.ResetFunctions();
-    const stack = 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 = 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,23 +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 evaluateResult;
-    private readonly context;
-    private readonly schema;
-    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;
-    /** Returns an array of validation errors for the given value. */
-    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 { ThrowParseError } from './parse.mjs';
-// ------------------------------------------------------------------
-// Validator
-// ------------------------------------------------------------------
-export class Validator {
-    constructor(context, schema) {
-        this.evaluateResult = Build.Build(context, schema).Evaluate();
-        this.context = context;
-        this.schema = schema;
-    }
-    /** 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.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;
-        ThrowParseError(this.context, this.schema, value);
-    }
-    /** Returns an array of validation errors for the given value. */
-    Errors(value) {
-        return Errors(this.context, this.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,34 +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 declare class ErrorContext extends CheckContext {
-    private readonly errors;
-    constructor();
-    AtCapacity(): boolean;
-    AddError<Keyword extends TValidationError['keyword']>(keyword: Keyword, schemaPath: string, instancePath: string, params: Extract<TValidationError, {
-        keyword: Keyword;
-    }>['params']): false;
-    AddErrors(error: TValidationError[]): false;
-    GetErrors(): TValidationError[];
-    private AddErrorObject;
-}