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

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

@@ -1,327 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { Pointer } from '../pointer/index.mjs';
-import * as Schema from '../types/index.mjs';
-export const DefaultBase = 'https://json-schema.org';
-// ------------------------------------------------------------------
-// Find: FindDynamicAnchor
-// ------------------------------------------------------------------
-function FindDynamicAnchor(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 = FindDynamicAnchor(schema[key], name);
-            if (result)
-                return result;
-        }
-    }
-    // (no-coverage) - is it even possible to search for an anchor
-    // with embedded logical schema like allOf, anyOf, etc?
-    // if (Guard.IsArray(schema)) { // (no-coverage)
-    //   for (const item of schema) {
-    //     const result = FindDynamicAnchor(item, name)
-    //     if (result) return result
-    //   }
-    // }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Find: FindBase
-// ------------------------------------------------------------------
-function FindBase(schema, base, target) {
-    if (Guard.IsEqual(schema, target))
-        return base.href;
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
-    if (Guard.IsArray(schema)) {
-        for (const item of schema) {
-            const result = FindBase(item, nextBase, target);
-            if (!Guard.IsUndefined(result))
-                return result;
-        }
-    }
-    else if (Guard.IsObject(schema)) {
-        for (const key of Guard.Keys(schema)) {
-            const result = FindBase(schema[key], nextBase, target);
-            if (!Guard.IsUndefined(result))
-                return result;
-        }
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Match: MatchId
-// ------------------------------------------------------------------
-function MatchId(schema, base, ref) {
-    // ref is a bare fragment naming this schema's $id directly
-    if (Guard.IsEqual(schema.$id, ref.hash))
-        return schema;
-    const absoluteRef = new URL(ref.href, base.href);
-    // ref shares this $id's document, so resolve the fragment within it
-    if (Guard.IsEqual(base.pathname, absoluteRef.pathname))
-        return ref.hash.startsWith('#') ? MatchHash(schema, ref) : schema;
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Match: MatchAnchor
-// ------------------------------------------------------------------
-function MatchAnchor(schema, base, ref) {
-    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;
-}
-// ------------------------------------------------------------------
-// Match: MatchDynamicAnchor
-// ------------------------------------------------------------------
-function MatchDynamicAnchor(schema, base, ref) {
-    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;
-}
-// ------------------------------------------------------------------
-// Match: MatchHash
-// ------------------------------------------------------------------
-function MatchHash(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;
-    const result = Pointer.Get(schema, fragment);
-    return result;
-}
-// ------------------------------------------------------------------
-// Match: Match
-// ------------------------------------------------------------------
-function Match(schema, base, ref) {
-    if (Schema.IsId(schema)) {
-        const result = MatchId(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsAnchor(schema)) {
-        const result = MatchAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Schema.IsDynamicAnchor(schema)) {
-        const result = MatchDynamicAnchor(schema, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    return MatchHash(schema, ref);
-}
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(schema, base, ref) {
-    return schema.reduce((result, item) => {
-        const match = FromValue(item, base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-// ------------------------------------------------------------------
-// FromObject
-// ------------------------------------------------------------------
-function SkipProperty(key) {
-    return Guard.IsEqual(key, 'const') || Guard.IsEqual(key, 'enum');
-}
-function FromObject(schema, base, ref) {
-    return Guard.Keys(schema).reduce((result, key) => {
-        if (SkipProperty(key))
-            return result;
-        const match = FromValue(schema[key], base, ref);
-        return !Guard.IsUndefined(match) ? match : result;
-    }, undefined);
-}
-// ------------------------------------------------------------------
-// FromValue
-// ------------------------------------------------------------------
-function FromValue(schema, base, ref) {
-    const nextBase = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
-    if (Schema.IsSchemaObject(schema)) {
-        const result = Match(schema, nextBase, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    if (Guard.IsArray(schema))
-        return FromArray(schema, nextBase, ref);
-    if (Guard.IsObject(schema))
-        return FromObject(schema, nextBase, ref);
-    return undefined;
-}
-// ------------------------------------------------------------------
-// Base
-// ------------------------------------------------------------------
-export function Base(schema, base, target) {
-    return FindBase(schema, new URL(base || '.', DefaultBase), target);
-}
-// ------------------------------------------------------------------
-// Resource
-// ------------------------------------------------------------------
-export function Resource(context, schema, base, ref) {
-    const result = Ref(context, schema, base, ref, false);
-    return Schema.IsSchemaObject(result) && Schema.IsId(result) ? result : undefined;
-}
-// ------------------------------------------------------------------
-// CanonicalHref
-// ------------------------------------------------------------------
-function CanonicalHref(url) {
-    return url.href.split('#')[0];
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 1)
-// ------------------------------------------------------------------
-function RefContext(context, ref) {
-    return Guard.HasPropertyKey(context, ref) ? context[ref] : undefined;
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 2)
-// ------------------------------------------------------------------
-function RefLocal(schema, base, ref) {
-    return FromValue(schema, base, ref);
-}
-// ------------------------------------------------------------------
-// Ref: RefRemote (Phase 3)
-// ------------------------------------------------------------------
-function RefRemote(context, base, ref) {
-    const canonicalHref = CanonicalHref(ref);
-    if (Guard.IsEqual(canonicalHref, CanonicalHref(base)))
-        return undefined;
-    if (!Guard.HasPropertyKey(context, canonicalHref))
-        return undefined;
-    const remoteSchema = context[canonicalHref];
-    const remoteBase = (Schema.IsSchemaObject(remoteSchema) && Schema.IsId(remoteSchema)) ? new URL(remoteSchema.$id, canonicalHref) : new URL(canonicalHref);
-    const result = Guard.IsEqual(ref.hash, '') ? remoteSchema : FromValue(remoteSchema, remoteBase, ref);
-    return result;
-}
-// ------------------------------------------------------------------
-// RetrievedResource: LegacyRetrievedResource
-//
-// Draft-4 style schemas (no $schema keyword) treat a nested $id as an
-// in-place base URI change rather than a new resource boundary. A
-// local ('#...') ref that lands somewhere with a different base than
-// the current reference base needs a frame so later anchor/pointer
-// resolution is computed against the right base.
-// ------------------------------------------------------------------
-function LegacyRetrievedResource(root, lexicalSchema, referenceBase, ref, schema) {
-    if (!ref.$ref.startsWith('#'))
-        return undefined;
-    if (Guard.HasPropertyKey(root, '$schema'))
-        return undefined;
-    const targetBase = Base(lexicalSchema, referenceBase, schema);
-    if (Guard.IsUndefined(targetBase) || Guard.IsEqual(targetBase, referenceBase))
-        return undefined;
-    return { target: schema, base: targetBase, root: lexicalSchema };
-}
-// ------------------------------------------------------------------
-// RetrievedResource: RemoteRetrievedResource
-//
-// The ref's canonical URL names a document already loaded into
-// context. That document becomes the frame's root going forward.
-// ------------------------------------------------------------------
-function RemoteRetrievedResource(context, canonical, schema) {
-    const remoteRoot = context[canonical];
-    if (!Schema.IsSchemaObject(remoteRoot))
-        return undefined;
-    return { target: schema, base: canonical, root: remoteRoot };
-}
-// ------------------------------------------------------------------
-// RetrievedResource
-//
-// A genuinely remote document frame always wins over a same-document
-// legacy one: only one frame is ever entered per ref.
-// ------------------------------------------------------------------
-function FindRetrievedResource(stackframe, ref, schema, canonical, isRemote) {
-    const remote = isRemote ? RemoteRetrievedResource(stackframe.context, canonical, schema) : undefined;
-    if (!Guard.IsUndefined(remote))
-        return remote;
-    return LegacyRetrievedResource(stackframe.root, stackframe.lexicalSchema, stackframe.referenceBase, ref, schema);
-}
-// ------------------------------------------------------------------
-// ResolvedResource: FindResolvedResource
-//
-// The ref crossed into a different resource but landed on a schema
-// that doesn't itself carry that resource's $id (e.g. a pointer into
-// the middle of a remote document). The enclosing resource still
-// needs to be entered so lexical/base lookups behave as if traversal
-// had walked in from its top.
-// ------------------------------------------------------------------
-function FindResolvedResource(context, root, referenceBase, canonical, schema, ids) {
-    if (Schema.IsId(schema))
-        return undefined;
-    const resource = Resource(context, root, referenceBase, canonical);
-    if (!resource || ids.includes(resource))
-        return undefined;
-    return { target: schema, resource };
-}
-// ------------------------------------------------------------------
-// Ref
-// ------------------------------------------------------------------
-export function Ref(remotes, schema, base, ref, applySchemaId = true) {
-    const initialBase = new URL(base || '.', DefaultBase);
-    const resolvedBase = applySchemaId && Schema.IsId(schema) ? new URL(schema.$id, initialBase) : initialBase;
-    const initialRef = new URL(ref, resolvedBase.href);
-    return RefContext(remotes, ref) ?? RefLocal(schema, resolvedBase, initialRef) ?? RefRemote(remotes, resolvedBase, initialRef);
-}
-// ------------------------------------------------------------------
-// DynamicRef
-// ------------------------------------------------------------------
-export function DynamicRef(context, root, base, schema, dynamicRef, dynamicAnchors) {
-    const initialBase = new URL(base || '.', DefaultBase);
-    const fragmentRoot = dynamicRef.$dynamicRef.startsWith('#') ? schema : root;
-    const fragmentTarget = Ref(context, fragmentRoot, base, dynamicRef.$dynamicRef, false);
-    if (Guard.IsUndefined(fragmentTarget)) {
-        const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
-        if (!fragment.startsWith('#/') && fragment.startsWith('#')) {
-            const name = decodeURIComponent(fragment.slice(1));
-            const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, name)) ?? FindDynamicAnchor(root, name);
-            return anchorTarget;
-        }
-        return undefined;
-    }
-    if (!Schema.IsSchemaObject(fragmentTarget) || !Schema.IsDynamicAnchor(fragmentTarget))
-        return fragmentTarget;
-    const fragment = new URL(dynamicRef.$dynamicRef, initialBase).hash;
-    if (fragment.startsWith('#/'))
-        return fragmentTarget;
-    const anchorTarget = dynamicAnchors.find((anchor) => Guard.IsEqual(anchor.$dynamicAnchor, fragmentTarget.$dynamicAnchor));
-    return anchorTarget ?? fragmentTarget;
-}
-// ------------------------------------------------------------------
-// ResolveRef
-//
-// Resolves the schema a $ref points to, and describes whether that
-// crossing implies a "retrieved resource" frame or entering a
-// resource the target doesn't itself carry the $id for. The caller
-// decides whether and how to record these.
-// ------------------------------------------------------------------
-export function ResolveRef(stackframe, ref) {
-    const source = stackframe.inRetrievedFrame ? stackframe.lexicalSchema : stackframe.root;
-    const refRoot = ref.$ref.startsWith('#') ? stackframe.lexicalSchema : source;
-    const schema = Ref(stackframe.context, refRoot, stackframe.referenceBase, ref.$ref, false);
-    if (!schema || !Schema.IsSchemaObject(schema))
-        return { schema };
-    const canonical = new URL(ref.$ref, stackframe.referenceBase).href.split('#')[0];
-    const isRemote = !Guard.IsEqual(canonical, stackframe.resourceBase);
-    const retrievedResource = FindRetrievedResource(stackframe, ref, schema, canonical, isRemote);
-    const resolvedResource = isRemote ? FindResolvedResource(stackframe.context, stackframe.root, stackframe.referenceBase, canonical, schema, stackframe.ids) : undefined;
-    return { schema, retrievedResource, resolvedResource };
-}
-// ------------------------------------------------------------------
-// ResolveRecursiveRef
-// ------------------------------------------------------------------
-export function ResolveRecursiveRef(stackframe, recursiveRef) {
-    const refRoot = Schema.IsRecursiveAnchorTrue(stackframe.lexicalSchema) ? stackframe.recursiveAnchors[0] : stackframe.lexicalSchema;
-    return Ref(stackframe.context, refRoot, stackframe.lexicalBase, recursiveRef.$recursiveRef, false);
-}
-// ------------------------------------------------------------------
-// ResolveDynamicRef
-// ------------------------------------------------------------------
-export function ResolveDynamicRef(stackframe, dynamicRef) {
-    return DynamicRef(stackframe.context, stackframe.root, stackframe.lexicalBase, stackframe.lexicalSchema, dynamicRef, stackframe.dynamicAnchors);
-}

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

@@ -1,11 +0,0 @@
-export * from './engine/index.mjs';
-export * from './intern/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,11 +0,0 @@
-export * from './engine/index.mjs';
-export * from './intern/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 {};

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

@@ -1,15 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-import type { XIf } from '../types/if.mjs';
-import type { XElse } from '../types/else.mjs';
-import type { XThen } from '../types/then.mjs';
-export type XStaticIf<Stack extends string[], Root extends XSchema, Schema extends XIf, IfSchema extends XSchema, If extends unknown = XStaticSchema<Stack, Root, IfSchema>, Then extends unknown = Schema extends XThen<infer ThenSchema extends XSchema> ? XStaticSchema<Stack, Root, ThenSchema> : never, Else extends unknown = Schema extends XElse<infer ElseSchema extends XSchema> ? XStaticSchema<Stack, Root, ElseSchema> : never, IsThen extends boolean = Schema extends XThen ? true : false, IsElse extends boolean = Schema extends XElse ? true : false, Result extends unknown = ([
-    IsThen,
-    IsElse
-] extends [true, true] ? (If & Then) | Exclude<Else, If> : [
-    IsThen,
-    IsElse
-] extends [true, false] ? (If & Then) : [
-    IsThen,
-    IsElse
-] extends [false, true] ? Exclude<Else, If> : unknown)> = Result;

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

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

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

@@ -1 +0,0 @@
-export type { XStatic } from './static.mjs';

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,7 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-import type { XStaticElements } from './_elements.mjs';
-type XFromSized<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[]> = (XStaticElements<Stack, Root, Schema, Items>);
-type XFromUnsized<Stack extends string[], Root extends XSchema, Schema extends XSchema> = (XStaticSchema<Stack, Root, Schema>[]);
-export type XStaticItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, Items extends XSchema[] | XSchema, Result extends unknown = (Items extends XSchema[] ? XFromSized<Stack, Root, Schema, [...Items]> : Items extends XSchema ? XFromUnsized<Stack, Root, Items> : never)> = Result;
-export {};

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

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

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

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

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

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

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

@@ -1,7 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-export type XStaticPatternProperties<Stack extends string[], Root extends XSchema, Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>, InferredProperties extends Record<PropertyKey, unknown> = {
-    [Key in keyof Properties]: XStaticSchema<Stack, Root, Properties[Key]>;
-}, EvaluatedProperties extends unknown = {
-    [key: string]: InferredProperties[keyof InferredProperties];
-}> = EvaluatedProperties;

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

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

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

@@ -1,3 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticElements } from './_elements.mjs';
-export type XStaticPrefixItems<Stack extends string[], Root extends XSchema, Schema extends XSchema, PrefixItems extends XSchema[], Result extends unknown[] = XStaticElements<Stack, Root, Schema, PrefixItems>> = Result;

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

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

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

@@ -1,32 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XRequired } from '../types/required.mjs';
-import type { XStaticSchema } from './schema.mjs';
-type XIsReadonly<Schema extends XSchema> = (Schema extends {
-    readOnly: true;
-} ? true : Schema extends {
-    '~readonly': true;
-} ? true : false);
-type XRequiredArray<Schema extends XSchema, Result extends PropertyKey[] = Schema extends XRequired<infer Keys extends string[]> ? Keys : []> = Result;
-type XReadonlyKeys<Properties extends Record<PropertyKey, XSchema>, ReadonlyProperties extends Record<PropertyKey, unknown> = {
-    [Key in keyof Properties as XIsReadonly<Properties[Key]> extends true ? Key : never]: unknown;
-}, Result extends PropertyKey = keyof ReadonlyProperties> = Result;
-type XRequiredKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? never : Extract<keyof Properties, RequiredArray[number]>> = Result;
-type XUnknownKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = Exclude<RequiredArray[number], keyof Properties>> = Result;
-type XOptionalKeys<Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[], Result extends PropertyKey = RequiredArray extends [] ? keyof Properties : Exclude<keyof Properties, RequiredArray[number]>> = Result;
-type XReadonlyOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
-    readonly [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
-};
-type XReadonlyRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
-    readonly [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
-};
-type XOptionalProperties<Stack extends string[], Root extends XSchema, OptionalKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
-    [Key in Extract<keyof Properties, OptionalKeys>]?: XStaticSchema<Stack, Root, Properties[Key]>;
-};
-type XRequiredProperties<Stack extends string[], Root extends XSchema, RequiredKeys extends PropertyKey, Properties extends Record<PropertyKey, XSchema>> = {
-    [Key in Extract<keyof Properties, RequiredKeys>]: XStaticSchema<Stack, Root, Properties[Key]>;
-};
-type XUnknownProperties<UnknownKeys extends PropertyKey> = {
-    [Key in UnknownKeys]: unknown;
-};
-export type XStaticProperties<Stack extends string[], Root extends XSchema, Schema extends XSchema, Properties extends Record<PropertyKey, XSchema>, RequiredArray extends string[] = XRequiredArray<Schema>, ReadonlyKeys extends PropertyKey = XReadonlyKeys<Properties>, OptionalKeys extends PropertyKey = XOptionalKeys<Properties, RequiredArray>, RequiredKeys extends PropertyKey = XRequiredKeys<Properties, RequiredArray>, UnknownKeys extends PropertyKey = XUnknownKeys<Properties, RequiredArray>, ReadonlyOptionalProperties extends Record<PropertyKey, unknown> = XReadonlyOptionalProperties<Stack, Root, Extract<OptionalKeys, ReadonlyKeys>, Properties>, ReadonlyRequiredProperties extends Record<PropertyKey, unknown> = XReadonlyRequiredProperties<Stack, Root, Extract<RequiredKeys, ReadonlyKeys>, Properties>, OptionalProperties extends Record<PropertyKey, unknown> = XOptionalProperties<Stack, Root, Exclude<OptionalKeys, ReadonlyKeys>, Properties>, RequiredProperties extends Record<PropertyKey, unknown> = XRequiredProperties<Stack, Root, Exclude<RequiredKeys, ReadonlyKeys>, Properties>, UnknownProperties extends Record<PropertyKey, unknown> = XUnknownProperties<UnknownKeys>, Result extends Record<PropertyKey, unknown> = (ReadonlyOptionalProperties & ReadonlyRequiredProperties & OptionalProperties & RequiredProperties & UnknownProperties)> = Result;
-export {};

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

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

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

@@ -1,5 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XStaticSchema } from './schema.mjs';
-export type XStaticPropertyNames<Stack extends string[], Root extends XSchema, Schema extends XSchema, StaticKey extends unknown = XStaticSchema<Stack, Root, Schema>, Result extends Record<string, unknown> = [StaticKey] extends [PropertyKey] ? {
-    [Key in StaticKey]?: unknown;
-} : {}> = Result;

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

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

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

@@ -1,8 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XPointerGet } from '../pointer/pointer_get.mjs';
-import type { XStaticSchema } from './schema.mjs';
-type XCyclicCheck<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : XCyclicCheck<Right, MaxLength, [...Buffer, Left]> : true);
-type XCyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? XCyclicCheck<Stack, 2> : true);
-type XNormal<Pointer extends string, Result extends string = (Pointer extends `#${infer Rest extends string}` ? Rest : Pointer)> = Result;
-export type XStaticRef<Stack extends string[], Root extends XSchema, Ref extends string, Normal extends string = XNormal<Ref>, Target extends unknown = XPointerGet<Root, Normal>, Schema extends XSchema = Target extends XSchema ? Target : {}, Result extends unknown = (XCyclicGuard<Stack, Ref> extends true ? XStaticSchema<[...Stack, Ref], Root, Schema> : any)> = Result;
-export {};

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

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

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

@@ -1,3 +0,0 @@
-import type { XSchema } from '../types/schema.mjs';
-import type { XProperties } from '../types/properties.mjs';
-export type XStaticRequired<_Stack extends string[], _Root extends XSchema, Schema extends XSchema, Keys extends string[], Result extends Record<PropertyKey, unknown> = Schema extends XProperties ? {} : Record<Keys[number], unknown>> = Result;

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

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