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

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,35 +0,0 @@
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
-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) {
-    EnableParseErrors();
-    const result = Errors(context, schema, value);
-    DisableParseErrors();
-    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,5 +0,0 @@
-export declare function Indices(pointer: string): string[];
-export declare function Has(value: unknown, pointer: string): boolean;
-export declare function Get(value: unknown, pointer: string): unknown;
-export declare function Set(value: unknown, pointer: string, next: unknown): unknown;
-export declare function Delete(value: unknown, pointer: string): unknown;

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

@@ -1,89 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Throw
-// ------------------------------------------------------------------
-function Throw(message) {
-    throw Error(message);
-}
-function ThrowUnsafePropertyKey() {
-    Throw('Pointer contains unsafe property key');
-}
-function ThrowCannotSetRoot() {
-    Throw('Cannot set value');
-}
-// ------------------------------------------------------------------
-// Indices
-// ------------------------------------------------------------------
-export function Indices(pointer) {
-    const indices = pointer.split('/').map(index => index.replace(/~1/g, '/').replace(/~0/g, '~'));
-    return indices[0] === '' ? indices.slice(1) : indices;
-}
-// ------------------------------------------------------------------
-// Has
-// ------------------------------------------------------------------
-export function Has(value, pointer) {
-    let current = value;
-    for (const index of Indices(pointer)) {
-        if (!Guard.IsObject(current) || !Guard.HasPropertyKey(current, index))
-            return false;
-        current = current[index];
-    }
-    return true;
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-export function Get(value, pointer) {
-    let current = value;
-    for (const index of Indices(pointer)) {
-        if (!Guard.IsObject(current) || Guard.IsUnsafePropertyKey(index))
-            return undefined;
-        current = current[index];
-    }
-    return current;
-}
-// ------------------------------------------------------------------
-// Get
-// ------------------------------------------------------------------
-function Parent(value, indices, last) {
-    let current = value;
-    for (const index of indices) {
-        if (Guard.IsUnsafePropertyKey(index))
-            ThrowUnsafePropertyKey();
-        current = Guard.IsObject(current) ? current[index] : undefined;
-    }
-    if (Guard.IsUnsafePropertyKey(last))
-        ThrowUnsafePropertyKey();
-    if (!Guard.IsObject(current))
-        ThrowCannotSetRoot();
-    return current;
-}
-// ------------------------------------------------------------------
-// Set
-// ------------------------------------------------------------------
-export function Set(value, pointer, next) {
-    const indices = Indices(pointer);
-    const last = indices.pop();
-    if (Guard.IsUndefined(last))
-        ThrowCannotSetRoot();
-    Parent(value, indices, last)[last] = next;
-    return value;
-}
-// ------------------------------------------------------------------
-// Delete
-// ------------------------------------------------------------------
-export function Delete(value, pointer) {
-    const indices = Indices(pointer);
-    const last = indices.pop();
-    if (Guard.IsUndefined(last))
-        ThrowCannotSetRoot();
-    const parent = Parent(value, indices, last);
-    if (Guard.IsArray(parent) && /^(0|[1-9]\d*)$/.test(last)) {
-        parent.splice(Number(last), 1);
-    }
-    else {
-        delete parent[last];
-    }
-    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,9 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from '../engine/_stack.mjs';
-export interface XRefResult {
-    schema: Schema.XSchema | undefined;
-    stack: Stack.XStack;
-}
-export declare function Ref(stack: Stack.XStack, ref: Schema.XRef): XRefResult;
-export declare function RecursiveRef(stack: Stack.XStack, recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-export declare function DynamicRef(stack: Stack.XStack, dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;

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

@@ -1,331 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import * as Schema from '../types/index.mjs';
-import * as Stack from '../engine/_stack.mjs';
-// ------------------------------------------------------------------
-// Helpers
-//
-// Utilities to compute schema base URIs, normalize absolute URLs,
-// strip URL fragments for canonical hrefs, find target base URIs,
-// resolve $ref root schemas, and identify JSON pointers vs anchors.
-// ------------------------------------------------------------------
-function RelativeBase(schema, base) {
-    return Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? Stack.NextUri(schema.$id, base.href) : base;
-}
-function AbsoluteBase(base) {
-    return Stack.NextUri(base, Stack.DefaultUri);
-}
-function CanonicalHref(url) {
-    return url.href.split('#')[0];
-}
-function Base(schema, base, target) {
-    return SearchBase(schema, AbsoluteBase(base), target);
-}
-function RefRoot(stack, ref) {
-    return (ref.$ref.startsWith('#') || stack.enteredResource) ? stack.lexicalSchema : stack.schema;
-}
-function IsPointerFragment(fragment) {
-    return fragment.startsWith('#/');
-}
-// ------------------------------------------------------------------
-// Search
-//
-// Recursive tree walks that locate things by identity, not URL.
-// SearchDynamicAnchor finds a node with a matching $dynamicAnchor.
-// SearchBase finds a specific target schema (by reference) and
-// returns its base URI, tracking $id rebasing as it descends.
-// ------------------------------------------------------------------
-function SearchDynamicAnchor(schema, name) {
-    if (Guard.IsObject(schema) && Schema.IsDynamicAnchor(schema) && Guard.IsEqual(schema.$dynamicAnchor, name)) {
-        return schema;
-    }
-    if (Guard.IsObject(schema)) {
-        for (const key of Guard.Keys(schema)) {
-            const result = SearchDynamicAnchor(schema[key], name);
-            if (result)
-                return result;
-        }
-    }
-    return undefined;
-}
-function SearchBase(schema, base, target) {
-    if (Guard.IsEqual(schema, target))
-        return base.href;
-    const nextBase = RelativeBase(schema, base);
-    if (Guard.IsArray(schema)) {
-        for (const item of schema) {
-            const result = SearchBase(item, nextBase, target);
-            if (!Guard.IsUndefined(result))
-                return result;
-        }
-    }
-    else if (Guard.IsObject(schema)) {
-        for (const key of Guard.Keys(schema)) {
-            const result = SearchBase(schema[key], nextBase, target);
-            if (!Guard.IsUndefined(result))
-                return result;
-        }
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Match
-//
-// Tests whether a schema node is what a reference URL points to.
-// MatchSchemaObject checks a single node in order: $id, $anchor,
-// $dynamicAnchor, then JSON pointer/hash. MatchFromArray,
-// MatchFromObject, and Match recurse through the tree to try every
-// node, skipping const and enum since their values are user data,
-// not schema.
-// ------------------------------------------------------------------
-function MatchWithHash(schema, ref) {
-    if (ref.href.endsWith('#'))
-        return schema;
-    if (!ref.hash.startsWith('#'))
-        return undefined;
-    const fragment = decodeURIComponent(ref.hash.slice(1));
-    if (!fragment.startsWith('/'))
-        return undefined;
-    return Pointer.Get(schema, fragment);
-}
-function MatchWithId(schema, base, ref) {
-    if (!Schema.IsId(schema))
-        return undefined;
-    if (Guard.IsEqual(schema.$id, ref.hash))
-        return schema;
-    const absoluteRef = new URL(ref.href, base.href);
-    if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
-        return ref.hash.startsWith('#') ? MatchWithHash(schema, ref) : schema;
-    return undefined;
-}
-function MatchWithAnchor(schema, base, ref) {
-    if (!Schema.IsAnchor(schema))
-        return undefined;
-    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    return Guard.IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : undefined;
-}
-function MatchWithDynamicAnchor(schema, base, ref) {
-    if (!Schema.IsDynamicAnchor(schema))
-        return undefined;
-    const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
-    const absoluteRef = new URL(ref.href, base.href);
-    const isMatch = Guard.IsEqual(absoluteAnchor.href, absoluteRef.href);
-    return isMatch ? schema : undefined;
-}
-function MatchSchemaObject(schema, base, ref) {
-    if (!Schema.IsSchemaObject(schema))
-        return undefined;
-    return MatchWithId(schema, base, ref) ??
-        MatchWithAnchor(schema, base, ref) ??
-        MatchWithDynamicAnchor(schema, base, ref) ??
-        MatchWithHash(schema, ref);
-}
-function MatchFromArray(schema, base, ref) {
-    if (!Guard.IsArray(schema))
-        return undefined;
-    return schema.reduce((result, item) => {
-        const match = Match(item, base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-function MatchFromObject(schema, base, ref) {
-    if (!Guard.IsObject(schema))
-        return undefined;
-    return Guard.Keys(schema).reduce((result, key) => {
-        if (Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum'))
-            return result;
-        const match = Match(schema[key], base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-function Match(schema, base, ref) {
-    const relativeBase = RelativeBase(schema, base);
-    return MatchSchemaObject(schema, relativeBase, ref) ??
-        MatchFromArray(schema, relativeBase, ref) ??
-        MatchFromObject(schema, relativeBase, ref);
-}
-// ------------------------------------------------------------------
-// Resource
-//
-// Wraps RefInternal to check whether the resolved schema is itself
-// a resource root (carries its own $id). Used by FindResolvedResource
-// to tell a boundary hit from a landing inside a resource.
-// ------------------------------------------------------------------
-function Resource(context, schema, base, ref) {
-    const result = RefInternal(context, schema, base, ref);
-    return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
-}
-// ------------------------------------------------------------------
-// FindDeferredResource
-//
-// Legacy Draft-4 schemas (no $schema keyword) treat a nested $id as
-// an in-place base change, not a new resource. A local ('#...') ref
-// landing at a different base than the current one needs a stack
-// entry so later lookups use the right base.
-// ------------------------------------------------------------------
-function FindDeferredResourceLegacy(stack, ref, schema) {
-    if (!ref.$ref.startsWith('#'))
-        return undefined;
-    if (!Schema.IsSchemaObject(stack.schema) || Guard.HasPropertyKey(stack.schema, '$schema'))
-        return undefined;
-    const targetBase = Base(stack.lexicalSchema, stack.referenceBase, schema);
-    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, stack.referenceBase))
-        return undefined;
-    return { target: schema, base: targetBase, root: /* safe-object-root */ stack.lexicalSchema };
-}
-function FindDeferredResourceModern(stack, canonical, schema) {
-    const remoteRoot = stack.context[canonical];
-    if (!Schema.IsSchemaObject(remoteRoot))
-        return undefined;
-    return { target: schema, base: canonical, root: remoteRoot };
-}
-function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
-    const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : undefined;
-    return Guard.IsUndefined(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
-}
-// ------------------------------------------------------------------
-// FindResolvedResource
-//
-// Handles a ref that crossed into a different resource but landed
-// on a schema without that resource's $id (e.g. a pointer into the
-// middle of a remote document). Enters the enclosing resource so
-// lexical/base lookups behave as if traversal walked in from its top.
-// ------------------------------------------------------------------
-function FindResolvedResource(stack, canonical, schema) {
-    if (Schema.IsId(schema))
-        return undefined;
-    const resource = Resource(stack.context, /* safe-object-root */ stack.schema, stack.referenceBase, canonical);
-    if (!resource || stack.ids.includes(resource))
-        return undefined;
-    return { resource };
-}
-// ------------------------------------------------------------------
-// RefInternal
-//
-// Shared lookup used by Ref, RecursiveRef, and DynamicRef. Tries,
-// in order: exact match in the pre-registered context, then a local
-// search within the given schema, then a search in a remote
-// document. Returns just the schema; caller-specific bookkeeping
-// (deferred/resolved resources) happens one level up.
-// ------------------------------------------------------------------
-function RefInternalWithContext(context, ref) {
-    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
-}
-function RefInternalWithLocal(schema, base, ref) {
-    return Match(schema, base, ref);
-}
-function RefInternalWithRemote(context, base, ref) {
-    const canonicalHref = CanonicalHref(ref);
-    if (!Guard.HasPropertyKey(context, canonicalHref) || Guard.IsEqual(canonicalHref, CanonicalHref(base)))
-        return undefined;
-    const remoteSchema = context[canonicalHref];
-    const remoteBase = RelativeBase(remoteSchema, new URL(canonicalHref));
-    return Guard.IsEqual(ref.hash, '') ? remoteSchema : Match(remoteSchema, remoteBase, ref);
-}
-function RefInternal(context, schema, base, ref) {
-    const absoluteBase = AbsoluteBase(base);
-    const target = Stack.NextUri(ref, absoluteBase.href);
-    return RefInternalWithContext(context, ref) ??
-        RefInternalWithLocal(schema, absoluteBase, target) ??
-        RefInternalWithRemote(context, absoluteBase, target);
-}
-// ------------------------------------------------------------------
-// RefNextStack
-//
-// Computes the next stack state from any deferred or resolved
-// resource found while following a $ref, carrying existing stack
-// state forward rather than rebuilding it.
-// ------------------------------------------------------------------
-function RefNextStackDeferred(stack, deferredResource) {
-    if (!deferredResource)
-        return stack;
-    const resourceEntries = new Map(stack.resourceEntries);
-    resourceEntries.set(deferredResource.target, { base: deferredResource.base, root: deferredResource.root });
-    return { ...stack, resourceEntries };
-}
-function RefNextStackResolved(stack, resolvedResource) {
-    return resolvedResource ? Stack.NextStack(stack, resolvedResource.resource) : stack;
-}
-function RefNextStack(stack, pendingResource, deferredResource, resolvedResource) {
-    const withDeferred = RefNextStackDeferred({ ...stack, pendingResource }, deferredResource);
-    const withResolved = RefNextStackResolved(withDeferred, resolvedResource);
-    return withResolved;
-}
-// ------------------------------------------------------------------
-// RefResult
-//
-// Builds the final XRefResult. RefResultFound gets the canonical
-// URL, checks if it's remote from the current resource, and looks
-// for a deferred or resolved resource crossing accordingly.
-// RefResultNotFound just advances pendingResource if a schema was
-// found without crossing into a resource.
-// ------------------------------------------------------------------
-function RefResultFound(stack, ref, schema) {
-    const canonical = CanonicalHref(Stack.NextUri(ref.$ref, stack.referenceBase));
-    const isRemote = !Guard.IsEqual(canonical, stack.resourceBase);
-    const deferredResource = FindDeferredResource(stack, ref, schema, canonical, isRemote);
-    const resolvedResource = isRemote ? FindResolvedResource(stack, canonical, schema) : undefined;
-    return { schema, stack: RefNextStack(stack, true, deferredResource, resolvedResource) };
-}
-function RefResultNotFound(stack, schema) {
-    return { schema, stack: RefNextStack(stack, !Guard.IsUndefined(schema)) };
-}
-// ------------------------------------------------------------------
-// Ref
-//
-// Picks the root to resolve against, and returns a XRefResult
-// containing the resolved schema and the next stack state for
-// subsequent evaluation.
-// ------------------------------------------------------------------
-export function Ref(stack, ref) {
-    const schema = RefInternal(stack.context, RefRoot(stack, ref), stack.referenceBase, ref.$ref);
-    return Schema.IsSchemaObject(schema) ? RefResultFound(stack, ref, schema) : RefResultNotFound(stack, schema);
-}
-// ------------------------------------------------------------------
-// RecursiveRef: Draft 2019-09
-//
-// If a $recursiveAnchor is active in scope, it's used as the root
-// instead of the lexical schema, letting the ref bind to the
-// outermost applicable schema rather than the innermost.
-// ------------------------------------------------------------------
-function IsRecursiveAnchorInScope(stack) {
-    return Schema.IsSchemaObject(stack.lexicalSchema) && Schema.IsRecursiveAnchorTrue(stack.lexicalSchema);
-}
-export function RecursiveRef(stack, recursiveRef) {
-    const schema = IsRecursiveAnchorInScope(stack) ? stack.recursiveAnchor : stack.lexicalSchema;
-    return RefInternal(stack.context, schema, stack.lexicalBase, recursiveRef.$recursiveRef);
-}
-// ------------------------------------------------------------------
-// DynamicRef: Draft 2020-12
-//
-// FindScopedDynamicAnchor checks anchors tracked on the stack first,
-// then falls back to a full tree search. If RefInternal finds a target
-// directly, DynamicRefWhenFound only continues the scoped search when
-// that target itself has a $dynamicAnchor. If RefInternal finds nothing,
-// DynamicRefWhenNotFound goes straight to a scoped anchor search
-// by name.
-// ------------------------------------------------------------------
-function DynamicRefFragment(stack, dynamicRef) {
-    return Stack.NextUri(dynamicRef.$dynamicRef, AbsoluteBase(stack.lexicalBase).href).hash;
-}
-function FindScopedDynamicAnchor(stack, name) {
-    return stack.dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? SearchDynamicAnchor(stack.schema, name);
-}
-function DynamicRefWhenFound(stack, dynamicRef, fragmentTarget) {
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    const fragment = DynamicRefFragment(stack, dynamicRef);
-    return IsPointerFragment(fragment) ? fragmentTarget : FindScopedDynamicAnchor(stack, fragmentTarget.$dynamicAnchor);
-}
-function DynamicRefWhenNotFound(stack, dynamicRef) {
-    const fragment = DynamicRefFragment(stack, dynamicRef);
-    // (review): We never observe this condition, but should be able to reach here in coverage.
-    // if (IsPointerFragment(fragment) || !fragment.startsWith('#')) return undefined
-    return FindScopedDynamicAnchor(stack, decodeURIComponent(fragment.slice(1)));
-}
-export function DynamicRef(stack, dynamicRef) {
-    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? stack.lexicalSchema : stack.schema;
-    const fragmentTarget = RefInternal(stack.context, fragmentRoot, stack.lexicalBase, dynamicRef.$dynamicRef);
-    return Guard.IsUndefined(fragmentTarget) ? DynamicRefWhenNotFound(stack, dynamicRef) : DynamicRefWhenFound(stack, dynamicRef, fragmentTarget);
-}

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

@@ -1,12 +0,0 @@
-export * from './engine/index.mjs';
-export * from './intern/index.mjs';
-export * from './meta/index.mjs';
-export * from './pointer/index.mjs';
-export * from './resolve/index.mjs';
-export * from './static/index.mjs';
-export * from './types/index.mjs';
-export * from './build.mjs';
-export * from './compile.mjs';
-export * from './check.mjs';
-export * from './parse.mjs';
-export * from './errors.mjs';

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

@@ -1,12 +0,0 @@
-export * from './engine/index.mjs';
-export * from './intern/index.mjs';
-export * from './meta/index.mjs';
-export * from './pointer/index.mjs';
-export * from './resolve/index.mjs';
-export * from './static/index.mjs';
-export * from './types/index.mjs';
-export * from './build.mjs';
-export * from './compile.mjs';
-export * from './check.mjs';
-export * from './parse.mjs';
-export * from './errors.mjs';

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

@@ -1,7 +0,0 @@
-type XCanonicalTuple<Value extends readonly unknown[]> = (Value extends [infer Left, ...infer Right extends unknown[]] ? [XCanonical<Left>, ...XCanonicalTuple<Right>] : []);
-type XCanonicalArray<Value extends unknown, Result extends unknown[] = XCanonical<Value>[]> = Result;
-type XCanonicalObject<Value extends object, Result extends Record<PropertyKey, unknown> = {
-    -readonly [Key in keyof Value]: XCanonical<Value[Key]>;
-}> = Result;
-export type XCanonical<Schema extends unknown> = (Schema extends readonly [...infer Schemas extends unknown[]] ? XCanonicalTuple<Schemas> : Schema extends readonly (infer Schema)[] ? XCanonicalArray<Schema> : Schema extends object ? XCanonicalObject<Schema> : Schema);
-export {};

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

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

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

@@ -1,6 +0,0 @@
-type XBuildTuple<Size extends number, Tuple extends unknown[] = []> = (Tuple['length'] extends Size ? Tuple : XBuildTuple<Size, [...Tuple, unknown]>);
-export type XLessThan<Left extends number, Right extends number> = Left extends Right ? false : XBuildTuple<Left> extends [...XBuildTuple<Right>, ...infer _Rest] ? false : true;
-export type XLessThanEqual<Left extends number, Right extends number> = (Left extends Right ? true : XLessThan<Left, Right>);
-export type XGreaterThan<Left extends number, Right extends number> = (XLessThan<Right, Left>);
-export type XGreaterThanEqual<Left extends number, Right extends number> = (XLessThanEqual<Right, Left>);
-export {};

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

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

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

@@ -1,18 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XMinItems } from '../types/minItems.mjs';
-import type { XMaxItems } from '../types/maxItems.mjs';
-import type { XAdditionalItems } from '../types/additionalItems.mjs';
-import type { XStaticSchema } from './schema.mjs';
-import type { XLessThan } from './_comparer.mjs';
-type XWithElements<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown[] = []> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XWithElements<Stack, Root, Right, [...Result, XStaticSchema<Stack, Root, Left>]> : Result);
-type XWithMaxItemsRemap<Elements extends unknown[], MaxItems extends number, Result extends unknown[] = []> = (Elements extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XLessThan<Result['length'], MaxItems> extends true ? XWithMaxItemsRemap<Right, MaxItems, [...Result, Left]> : Result : Result);
-type XWithMaxItems<Schema extends XSchema, Elements extends unknown[], Result extends unknown[] = Schema extends XMaxItems<infer MaxItems extends number> ? XWithMaxItemsRemap<Elements, MaxItems> : Elements> = Result;
-type XNeedsAdditionalItems<Schema extends XSchema, Elements extends unknown[], Result extends boolean = (Schema extends XMaxItems<infer MaxItems extends number> ? XLessThan<Elements['length'], MaxItems> : true)> = Result;
-type XWithMinItemsRemap<Elements extends unknown[], MinItems extends number, Result extends unknown[] = []> = (Elements extends [infer Left, ...infer Right] ? XLessThan<Result['length'], MinItems> extends true ? XWithMinItemsRemap<Right, MinItems, [...Result, Left]> : XWithMinItemsRemap<Right, MinItems, [...Result, Left?]> : Result);
-type XWithMinItems<Schema extends XSchema, Values extends unknown[], MinItems extends number = Schema extends XMinItems<infer MinItems extends number> ? MinItems : 0, Result extends unknown[] = XWithMinItemsRemap<Values, MinItems>> = Result;
-type XWithAdditionalItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, Elements extends unknown[], Result extends unknown[] = Schema extends XAdditionalItems<infer Schema extends XSchema> ? (Schema extends true ? [...Elements, ...unknown[]] : Schema extends false ? [...Elements] : [
-    ...Elements,
-    ...XStaticSchema<Stack, Root, Schema>[]
-]) : [...Elements, ...unknown[]]> = Result;
-export type XStaticElements<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], WithElements extends unknown[] = XWithElements<Stack, Root, PrefixItems>, WithMaxItems extends unknown[] = XWithMaxItems<Schema, WithElements>, NeedsAdditional extends boolean = XNeedsAdditionalItems<Schema, WithMaxItems>, WithMinItems extends unknown[] = XWithMinItems<Schema, WithMaxItems>, WithAdditionalItems extends unknown[] = NeedsAdditional extends true ? XWithAdditionalItems<Stack, Root, Schema, WithMinItems> : WithMinItems> = WithAdditionalItems;
-export {};

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

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

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

@@ -1,7 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-export type XStaticAdditionalProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Result extends Record<PropertyKey, unknown> = (Schema extends true ? {
-    [key: string]: unknown;
-} : Schema extends false ? {} : {
-    [key: string]: XStaticSchema<Stack, Root, Schema>;
-})> = Result;

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

@@ -1,3 +0,0 @@
-// deno-lint-ignore-file ban-types
-// deno-fmt-ignore-file
-export {};

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

@@ -1,3 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-export type XStaticAllOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = unknown> = (Schemas extends readonly [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAllOf<Stack, Root, Right, Result & XStaticSchema<Stack, Root, Left>> : Result);

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

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

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

@@ -1,3 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-export type XStaticAnyOf<Stack extends string[], Root extends XSchema, Schemas extends XSchema[], Result extends unknown = never> = (Schemas extends [infer Left extends XSchema, ...infer Right extends XSchema[]] ? XStaticAnyOf<Stack, Root, Right, XStaticSchema<Stack, Root, Left> | Result> : Result);

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

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

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

@@ -1 +0,0 @@
-export type XStaticConst<Value extends unknown> = Value;

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

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

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

@@ -1 +0,0 @@
-export type XStaticEnum<Values extends unknown[], Result extends unknown = never> = (Values extends [infer Left extends unknown, ...infer Right extends unknown[]] ? XStaticEnum<Right, Left | Result> : Result);

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

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