pi-proactive 0.2.0-beta.5 → 0.2.0-beta.6

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

@@ -1,18 +0,0 @@
-// deno-fmt-ignore-file
-import { Arguments } from '../system/arguments/index.mjs';
-import { Get as GetLocalizationFunction } from '../system/locale/_config.mjs';
-import * as Engine from './engine/index.mjs';
-/** Returns an array of validation errors for the given value. */
-export function Errors(...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 errorContext = new Engine.ErrorContext();
-    const result = Engine.ErrorSchema(stack, errorContext, '#', '', schema, value);
-    const errors = errorContext.GetErrors();
-    const locale = GetLocalizationFunction();
-    const localized = errors.map(error => ({ ...error, message: locale(error) }));
-    return [result, localized];
-}

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

@@ -1,3 +0,0 @@
-export * from './schema.mjs';
-import * as Schema from './schema.mjs';
-export default Schema;

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

@@ -1,9 +0,0 @@
-// ------------------------------------------------------------------
-// Barrel
-// ------------------------------------------------------------------
-export * from './schema.mjs';
-// ------------------------------------------------------------------
-// Default
-// ------------------------------------------------------------------
-import * as Schema from './schema.mjs';
-export default Schema;

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

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

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

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

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

@@ -1,14 +0,0 @@
-import { type XStatic } from '../static/index.mjs';
-import * as S from '../types/index.mjs';
-export interface XIntern<Type extends unknown = unknown> {
-    '~unsafe': Type;
-    $ref: string;
-    $defs: Record<string, S.XSchemaObject>;
-}
-/**
- * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
- * schema. This function restructures the schema such that each distinct sub-schema is stored
- * exactly once in a $defs object and keyed by content hash. This function can be used to
- * both compress and optimize schemas prior to compilation.
- */
-export declare function Intern<const Schema extends S.XSchema>(schema: Schema): XIntern<XStatic<Schema>>;

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

@@ -1,259 +0,0 @@
-import { Hashing, Memory } from '../../system/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { Resolve } from '../resolve/index.mjs';
-import * as S from '../types/index.mjs';
-// ----------------------------------------------------------------
-// UnsupportedKeyword
-// ----------------------------------------------------------------
-function UnsupportedKeyword(keyword) {
-    throw Error(`UnsupportedKeyword '${keyword}'`);
-}
-// ----------------------------------------------------------------
-// UnresolvableRef
-// ----------------------------------------------------------------
-function UnresolvableRef(ref) {
-    throw Error(`UnresolvableRef '${ref}'`);
-}
-// ----------------------------------------------------------------
-// HashKey
-// ----------------------------------------------------------------
-function HashKey(schema) {
-    return `x-${Hashing.Hash(schema)}`;
-}
-// ----------------------------------------------------------------
-// AdditionalItems
-// ----------------------------------------------------------------
-function FromAdditionalItems(context, schema) {
-    return FromSchema(context, schema.additionalItems);
-}
-// ----------------------------------------------------------------
-// AdditionalProperties
-// ----------------------------------------------------------------
-function FromAdditionalProperties(context, schema) {
-    return FromSchema(context, schema.additionalProperties);
-}
-// ----------------------------------------------------------------
-// AllOf
-// ----------------------------------------------------------------
-function FromAllOf(context, schema) {
-    return schema.allOf.map((inner) => FromSchema(context, inner));
-}
-// ----------------------------------------------------------------
-// AnyOf
-// ----------------------------------------------------------------
-function FromAnyOf(context, schema) {
-    return schema.anyOf.map((inner) => FromSchema(context, inner));
-}
-// ----------------------------------------------------------------
-// Contains
-// ----------------------------------------------------------------
-function FromContains(context, schema) {
-    return FromSchema(context, schema.contains);
-}
-// ----------------------------------------------------------------
-// DependentSchemas
-// ----------------------------------------------------------------
-function FromDependentSchemas(context, schema) {
-    return Guard.Keys(schema.dependentSchemas).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.dependentSchemas[key]) }), {});
-}
-// ----------------------------------------------------------------
-// Else
-// ----------------------------------------------------------------
-function FromElse(context, schema) {
-    return FromSchema(context, schema.else);
-}
-// ----------------------------------------------------------------
-// If
-// ----------------------------------------------------------------
-function FromIf(context, schema) {
-    return FromSchema(context, schema.if);
-}
-// ----------------------------------------------------------------
-// Items
-// ----------------------------------------------------------------
-function FromItems(context, schema) {
-    return S.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
-}
-// ----------------------------------------------------------------
-// ItemsSized
-// ----------------------------------------------------------------
-function FromItemsSized(context, schema) {
-    return schema.items.map((inner) => FromSchema(context, inner));
-}
-// ----------------------------------------------------------------
-// ItemsUnsized
-// ----------------------------------------------------------------
-function FromItemsUnsized(context, schema) {
-    return FromSchema(context, schema.items);
-}
-// ----------------------------------------------------------------
-// Not
-// ----------------------------------------------------------------
-function FromNot(context, schema) {
-    return FromSchema(context, schema.not);
-}
-// ----------------------------------------------------------------
-// OneOf
-// ----------------------------------------------------------------
-function FromOneOf(context, schema) {
-    return schema.oneOf.map((inner) => FromSchema(context, inner));
-}
-// ----------------------------------------------------------------
-// PatternProperties
-// ----------------------------------------------------------------
-function FromPatternProperties(context, schema) {
-    return Guard.Keys(schema.patternProperties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.patternProperties[key]) }), {});
-}
-// ----------------------------------------------------------------
-// PrefixItems
-// ----------------------------------------------------------------
-function FromPrefixItems(context, schema) {
-    return schema.prefixItems.map((inner) => FromSchema(context, inner));
-}
-// ----------------------------------------------------------------
-// Properties
-// ----------------------------------------------------------------
-function FromProperties(context, schema) {
-    return Guard.Keys(schema.properties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.properties[key]) }), {});
-}
-// ----------------------------------------------------------------
-// PropertyNames
-// ----------------------------------------------------------------
-function FromPropertyNames(context, schema) {
-    return FromSchema(context, schema.propertyNames);
-}
-// ----------------------------------------------------------------
-// Ref
-// ----------------------------------------------------------------
-function ResolveRef(context, schema, ref) {
-    return Resolve.Ref(context, schema, Resolve.DefaultBase, ref) ?? UnresolvableRef(ref);
-}
-function FromRef(context, schema) {
-    // Resolve target
-    const target = ResolveRef(context.context, context.schema, schema.$ref);
-    // Check if target is resolving, if not, resolve
-    const resolving = context.resolving.get(target);
-    if (Guard.IsUndefined(resolving))
-        return FromSchema(context, target);
-    // Target is mid-intern, so this is a cycle (point at its reserved placeholder)
-    resolving.used = true;
-    return { $ref: `#/$defs/${resolving.key}` };
-}
-// ----------------------------------------------------------------
-// Then
-// ----------------------------------------------------------------
-function FromThen(context, schema) {
-    return FromSchema(context, schema.then);
-}
-// ----------------------------------------------------------------
-// UnevaluatedItems
-// ----------------------------------------------------------------
-function FromUnevaluatedItems(context, schema) {
-    return FromSchema(context, schema.unevaluatedItems);
-}
-// ----------------------------------------------------------------
-// UnevaluatedProperties
-// ----------------------------------------------------------------
-function FromUnevaluatedProperties(context, schema) {
-    return FromSchema(context, schema.unevaluatedProperties);
-}
-// ----------------------------------------------------------------
-// SchemaObject
-// ----------------------------------------------------------------
-function FromSchemaObject(context, schema) {
-    // Reference schemas cannot contain other keywords
-    if (S.IsRef(schema))
-        return FromRef(context, schema);
-    // Check if the schema has already been resolved
-    const existing = resolved.get(schema);
-    if (!Guard.IsUndefined(existing))
-        return existing;
-    // These keywords are unsupported
-    if (S.IsDynamicRef(schema))
-        UnsupportedKeyword('$dynamicRef');
-    if (S.IsRecursiveRef(schema))
-        UnsupportedKeyword('$recursiveRef');
-    // Reserve a placeholder key in case a nested ref cycles back to this schema
-    const reservation = { key: `x-ref-${context.resolving.size}`, used: false };
-    context.resolving.set(schema, reservation);
-    // Intern each subschema
-    const remapped = {
-        ...(S.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
-        ...(S.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
-        ...(S.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
-        ...(S.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
-        ...(S.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
-        ...(S.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
-        ...(S.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
-        ...(S.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
-        ...(S.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
-        ...(S.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
-        ...(S.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
-        ...(S.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
-        ...(S.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
-        ...(S.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
-        ...(S.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
-        ...(S.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
-        ...(S.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
-        ...(S.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
-        ...(S.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
-    };
-    context.resolving.delete(schema);
-    // Finalize and register the result
-    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id']);
-    const key = reservation.used ? reservation.key : HashKey(interned);
-    registry.set(key, interned);
-    // Result
-    const result = { $ref: `#/$defs/${key}` };
-    resolved.set(schema, result);
-    return result;
-}
-// ----------------------------------------------------------------
-// SchemaBoolean
-// ----------------------------------------------------------------
-function FromSchemaBoolean(_context, schema) {
-    // Finalize and register the result
-    const key = HashKey(schema);
-    registry.set(key, schema);
-    // Result
-    const result = { $ref: `#/$defs/${key}` };
-    resolved.set(schema, result);
-    return result;
-}
-// ----------------------------------------------------------------
-// Schema
-// ----------------------------------------------------------------
-function FromSchema(context, schema) {
-    return S.IsSchemaBoolean(schema) ? FromSchemaBoolean(context, schema) : FromSchemaObject(context, schema);
-}
-// ----------------------------------------------------------------
-// BooleanEntry
-// ----------------------------------------------------------------
-function BooleanEntry(schema) {
-    const key = HashKey(schema);
-    return { $ref: `#/$defs/${key}`, $defs: { [key]: schema } };
-}
-// ----------------------------------------------------------------
-// Module-level accumulator state
-// ----------------------------------------------------------------
-const registry = new Map();
-const resolved = new Map();
-/**
- * [Experimental] Performs a Common Subexpression Elimination (CSE) transform on the given
- * schema. This function restructures the schema such that each distinct sub-schema is stored
- * exactly once in a $defs object and keyed by content hash. This function can be used to
- * both compress and optimize schemas prior to compilation.
- */
-export function Intern(schema) {
-    registry.clear();
-    resolved.clear();
-    if (S.IsSchemaBoolean(schema))
-        return BooleanEntry(schema);
-    const context = S.IsDefs(schema) ? schema.$defs : {};
-    const entry = S.IsRef(schema) ? ResolveRef(context, schema, schema.$ref) : schema;
-    if (S.IsSchemaBoolean(entry))
-        return BooleanEntry(entry);
-    const ref_context = { schema, context, resolving: new Map() };
-    const result = FromSchema(ref_context, entry);
-    return { $ref: result.$ref, $defs: Object.fromEntries(registry) };
-}

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

@@ -1,14 +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 ParseError {
-    schema: Schema.XSchema;
-    value: unknown;
-    errors: TLocalizedValidationError[];
-    constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
-}
-export declare function ThrowParseError(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): never;
-/** Parses a value against the provided schema */
-export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static<Schema>;
-/** Parses a value against the provided schema */
-export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static<Schema>;

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

@@ -1,32 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { Arguments } from '../system/arguments/index.mjs';
-import { Check } from './check.mjs';
-import { Errors } from './errors.mjs';
-// ------------------------------------------------------------------
-// ParseError
-// ------------------------------------------------------------------
-export class ParseError {
-    constructor(schema, value, errors) {
-        this.schema = schema;
-        this.value = value;
-        this.errors = errors;
-    }
-}
-// ------------------------------------------------------------------
-// ThrowParseError
-// ------------------------------------------------------------------
-export function ThrowParseError(context, schema, value) {
-    const result = Errors(context, schema, value);
-    throw new ParseError(schema, value, result[1]);
-}
-/** Parses a value against the provided schema */
-export function Parse(...args) {
-    const [context, schema, value] = Arguments.Match(args, {
-        3: (context, schema, value) => [context, schema, value],
-        2: (schema, value) => [{}, schema, value]
-    });
-    if (Check(context, schema, value))
-        return value;
-    ThrowParseError(context, schema, value);
-}

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

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

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

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

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

@@ -1,10 +0,0 @@
-/** Returns an array of path indices for the given pointer */
-export declare function Indices(pointer: string): string[];
-/** Returns true if a value exists at the current pointer */
-export declare function Has(value: unknown, pointer: string): unknown;
-/** Gets a value at the pointer, or undefined if not exists */
-export declare function Get(value: unknown, pointer: string): unknown;
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
-export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
-export declare function Delete(value: unknown, pointer: string): unknown;

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

@@ -1,106 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Asserts
-// ------------------------------------------------------------------
-function AssertNotRoot(indices) {
-    if (indices.length === 0)
-        throw Error('Cannot set root');
-}
-function AssertCanSet(value) {
-    if (!Guard.IsObject(value))
-        throw Error('Cannot set value');
-}
-function AssertIndex(index) {
-    if (Guard.IsUnsafePropertyKey(index))
-        throw Error('Pointer contains unsafe property key');
-}
-function AssertIndices(indices) {
-    for (const index of indices)
-        AssertIndex(index);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-function IsNumericIndex(index) {
-    return /^(0|[1-9]\d*)$/.test(index);
-}
-function TakeIndexRight(indices) {
-    return [
-        indices.slice(0, indices.length - 1),
-        indices.slice(indices.length - 1)[0]
-    ];
-}
-function HasIndex(index, value) {
-    return Guard.IsObject(value) && Guard.HasPropertyKey(value, index);
-}
-function GetIndex(index, value) {
-    return Guard.IsObject(value) && !Guard.IsUnsafePropertyKey(index) ? value[index] : undefined;
-}
-function GetIndices(indices, value) {
-    return indices.reduce((value, index) => GetIndex(index, value), value);
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-/** Returns an array of path indices for the given pointer */
-export function Indices(pointer) {
-    if (Guard.IsEqual(pointer.length, 0))
-        return [];
-    const indices = pointer.split("/").map(index => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-    return (indices.length > 0 && indices[0] === '') ? indices.slice(1) : indices;
-}
-// ------------------------------------------------------------------
-// Has
-// ------------------------------------------------------------------
-/** Returns true if a value exists at the current pointer */
-export function Has(value, pointer) {
-    let current = value;
-    return Indices(pointer).every(index => {
-        if (!HasIndex(index, current))
-            return false;
-        current = current[index];
-        return true;
-    });
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-/** Gets a value at the pointer, or undefined if not exists */
-export function Get(value, pointer) {
-    const indices = Indices(pointer);
-    return GetIndices(indices, value);
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-/** Sets a value at the given pointer. May throw if the target value is not indexable */
-export function Set(value, pointer, next) {
-    const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    parent[index] = next;
-    return value;
-}
-// ------------------------------------------------------------------
-// Delete
-// ------------------------------------------------------------------
-/** Deletes the value at the given pointer. May throw if the target value is not indexable */
-export function Delete(value, pointer) {
-    const indices = Indices(pointer);
-    AssertNotRoot(indices);
-    AssertIndices(indices);
-    const [head, index] = TakeIndexRight(indices);
-    const parent = GetIndices(head, value);
-    AssertCanSet(parent);
-    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
-        parent.splice(+index, 1);
-    }
-    else {
-        delete parent[index];
-    }
-    return value;
-}

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

@@ -1,9 +0,0 @@
-type TEscape0<Index extends string> = Index extends `${infer Left}~0${infer Right}` ? `${Left}~${TEscape<Right>}` : Index;
-type TEscape1<Index extends string> = Index extends `${infer Left}~1${infer Right}` ? `${Left}/${TEscape<Right>}` : Index;
-type TEscape<Index extends string, Escaped0 extends string = TEscape0<Index>, Escaped1 extends string = TEscape1<Escaped0>> = Escaped1;
-type IndicesReduce<Pointer extends string, Result extends string[] = []> = (Pointer extends `${infer Left extends string}/${infer Right extends string}` ? Left extends '' ? IndicesReduce<Right, Result> : IndicesReduce<Right, [...Result, TEscape<Left>]> : [...Result, TEscape<Pointer>]);
-type TIndices<Pointer extends string, Result extends string[] = Pointer extends '' ? [] : IndicesReduce<Pointer>> = Result;
-type TResolve<Value extends unknown, Indices extends string[]> = (Indices extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Value ? TResolve<Value[Left], Right> : undefined : Value);
-/** Type Level RFC 6901 Json Pointer Resolver */
-export type XPointerGet<Value extends unknown, Pointer extends string, Indices extends string[] = TIndices<Pointer>, Result extends unknown = TResolve<Value, Indices>> = Result;
-export {};

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

@@ -1,2 +0,0 @@
-// deno-fmt-ignore-file
-export {};

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

@@ -1 +0,0 @@
-export * as Resolve from './resolve.mjs';

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

@@ -1 +0,0 @@
-export * as Resolve from './resolve.mjs';

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

@@ -1,35 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare const DefaultBase = "https://json-schema.org";
-export interface StackFrame {
-    context: Record<string, Schema.XSchema>;
-    root: Schema.XSchemaObject;
-    lexicalSchema: Schema.XSchemaObject;
-    lexicalBase: string;
-    referenceBase: string;
-    resourceBase: string;
-    ids: Schema.XId[];
-    recursiveAnchors: Schema.XRecursiveAnchor[];
-    dynamicAnchors: Schema.XDynamicAnchor[];
-    inRetrievedFrame: boolean;
-}
-export interface RetrievedResource {
-    target: Schema.XSchemaObject;
-    base: string;
-    root: Schema.XSchemaObject;
-}
-export interface ResolvedResource {
-    target: Schema.XSchemaObject;
-    resource: Schema.XId;
-}
-export interface RefResult {
-    schema: Schema.XSchema | undefined;
-    retrievedResource?: RetrievedResource;
-    resolvedResource?: ResolvedResource;
-}
-export declare function Base(schema: Schema.XSchemaObject, base: string, target: Schema.XSchema): string | undefined;
-export declare function Resource(context: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string): Schema.XId | undefined;
-export declare function Ref(remotes: Record<string, Schema.XSchema>, schema: Schema.XSchemaObject, base: string, ref: string, applySchemaId?: boolean): Schema.XSchema | undefined;
-export declare function DynamicRef(context: Record<string, Schema.XSchema>, root: Schema.XSchemaObject, base: string, schema: Schema.XSchemaObject, dynamicRef: Schema.XDynamicRef, dynamicAnchors: Schema.XDynamicAnchor[]): Schema.XSchema | undefined;
-export declare function ResolveRef(stackframe: StackFrame, ref: Schema.XRef): RefResult;
-export declare function ResolveRecursiveRef(stackframe: StackFrame, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-export declare function ResolveDynamicRef(stackframe: StackFrame, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;