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

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

@@ -1,60 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
-// ------------------------------------------------------------------
-// Valid
-// ------------------------------------------------------------------
-function IsValid(schema) {
-    return Schema.IsItems(schema) && G.IsArray(schema.items);
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAdditionalItemsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
-    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
-    const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
-    const addIndex = context.AddIndex(index);
-    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, E.And(isSchema, addIndex)));
-}
-function BuildAdditionalItemsFast(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
-    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
-    const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
-    return E.Every(value, E.Constant(0), [item, index], E.Or(isLength, isSchema));
-}
-export function BuildAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
-    return context.UseUnevaluated()
-        ? BuildAdditionalItemsStandard(stack, context, schema, value)
-        : BuildAdditionalItemsFast(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    const isAdditionalItems = G.Every(value, 0, (item, index) => {
-        return G.IsLessThan(index, schema.items.length)
-            || (CheckSchemaPushStack(stack, context, schema.additionalItems, item) && context.AddIndex(index));
-    });
-    return isAdditionalItems;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    const isAdditionalItems = G.Every(value, 0, (item, index) => {
-        const nextSchemaPath = `${schemaPath}/additionalItems`;
-        const nextInstancePath = `${instancePath}/${index}`;
-        return G.IsLessThan(index, schema.items.length) ||
-            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalItems, item) && context.AddIndex(index));
-    });
-    return isAdditionalItems;
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAdditionalProperties(stack: Stack.XStack, context: BuildContext, schema: Schema.XAdditionalProperties, value: string): string;
-export declare function CheckAdditionalProperties(stack: Stack.XStack, context: CheckContext, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorAdditionalProperties(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,118 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
-import * as Externals from './_externals.mjs';
-import * as Pathing from './_pathing.mjs';
-import { UnicodeRegExp } from './_regexp.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
-// ------------------------------------------------------------------
-// Optimization: IsAdditionalPropertiesIgnored
-//
-// We can ignore additionalProperties if the schema is true-like and
-// we are not in an unevaluated context, noting that additional
-// properties are considered tracked, evaluated keys.
-// ------------------------------------------------------------------
-function IsAdditionalPropertiesIgnored(context, additionalProperties) {
-    return !context.UseUnevaluated() &&
-        (G.IsEqual(additionalProperties, true) ||
-            (G.IsObject(additionalProperties) && G.IsEqual(G.Keys(additionalProperties).length, 0)));
-}
-// ------------------------------------------------------------------
-// Optimization: GetPropertiesPattern
-//
-// Constructs a regular expression that matches all property keys
-// and pattern properties defined in a schema. This approach unifies
-// handling of both property types, avoiding separate logic paths.
-//
-// If no keys or patterns are present, it returns a pattern that
-// matches nothing: '(?!)'.
-//
-// ------------------------------------------------------------------
-function GetPropertyKeyAsPattern(key) {
-    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    return `^${escaped}$`;
-}
-function GetPropertiesPattern(schema) {
-    const patterns = [];
-    if (Schema.IsPatternProperties(schema))
-        patterns.push(...G.Keys(schema.patternProperties));
-    if (Schema.IsProperties(schema))
-        patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
-    return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesFast (AdditionalProperties False)
-//
-// - AdditionalProperties is explicitly set to false,
-// - The schema uses only Properties (no PatternProperties),
-// - Required contains exactly the keys in Properties.
-//
-// ------------------------------------------------------------------
-function HasExactRequiredProperties(schema) {
-    const keys = G.Keys(schema.properties);
-    return G.IsEqual(keys.length, schema.required.length)
-        && G.Every(keys, 0, (key) => schema.required.includes(key));
-}
-function CanAdditionalPropertiesFast(_context, schema, _value) {
-    return Schema.IsRequired(schema)
-        && Schema.IsProperties(schema)
-        && !Schema.IsPatternProperties(schema)
-        && G.IsEqual(schema.additionalProperties, false)
-        && HasExactRequiredProperties(schema);
-}
-function BuildAdditionalPropertiesFast(_context, schema, value) {
-    return E.IsEqual(E.Member(E.Call(E.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), E.Constant(schema.required.length));
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesStandard
-// ------------------------------------------------------------------
-function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
-    const [key, _index] = [Unique.CreateUnique(), Unique.CreateUnique()];
-    const regexp = Externals.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
-    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
-    const isKey = E.Call(E.Member(regexp, 'test'), [key]);
-    const addKey = context.AddKey(key);
-    const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
-    const result = E.Every(E.Keys(value), E.Constant(0), [key, _index], guarded);
-    return result;
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildAdditionalProperties(stack, context, schema, value) {
-    if (IsAdditionalPropertiesIgnored(context, schema.additionalProperties))
-        return E.Constant(true);
-    return CanAdditionalPropertiesFast(context, schema, value)
-        ? BuildAdditionalPropertiesFast(context, schema, value)
-        : BuildAdditionalPropertiesStandard(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAdditionalProperties(stack, context, schema, value) {
-    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
-    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
-        return regexp.test(key) ||
-            (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
-    });
-    return isAdditionalProperties;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
-    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
-    const additionalProperties = [];
-    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextSchemaPath = `${schemaPath}/additionalProperties`;
-        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
-        const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
-        if (!isAdditionalProperty)
-            additionalProperties.push(key);
-        return isAdditionalProperty;
-    });
-    return isAdditionalProperties ||
-        context.AddError('additionalProperties', schemaPath, instancePath, { additionalProperties });
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAllOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
-export declare function CheckAllOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
-export declare function ErrorAllOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAllOf, value: unknown): boolean;

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

@@ -1,47 +0,0 @@
-// deno-fmt-ignore-file
-import { CheckContext, ErrorContext } from './_context.mjs';
-import { Reducer } from './_reducer.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAllOfStandard(stack, context, schema, value) {
-    return Reducer(stack, context, schema.allOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(schema.allOf.length)));
-}
-function BuildAllOfFast(stack, context, schema, value) {
-    return E.ReduceAnd(schema.allOf.map((schema) => BuildSchema(stack, context, schema, value)));
-}
-export function BuildAllOf(stack, context, schema, value) {
-    return context.UseUnevaluated()
-        ? BuildAllOfStandard(stack, context, schema, value)
-        : BuildAllOfFast(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAllOf(stack, context, schema, value) {
-    const results = schema.allOf.reduce((result, schema) => {
-        const nextContext = new CheckContext();
-        return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
-    }, []);
-    return G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorAllOf(stack, context, schemaPath, instancePath, schema, value) {
-    const failedContexts = [];
-    const results = schema.allOf.reduce((result, schema, index) => {
-        const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-        const nextContext = new ErrorContext();
-        const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
-        if (!isSchema)
-            failedContexts.push(nextContext);
-        return isSchema ? [...result, nextContext] : result;
-    }, []);
-    const isAllOf = G.IsEqual(results.length, schema.allOf.length) && context.Merge(results);
-    if (!isAllOf)
-        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
-    return isAllOf;
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildAnyOf(stack: Stack.XStack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
-export declare function CheckAnyOf(stack: Stack.XStack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
-export declare function ErrorAnyOf(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;

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

@@ -1,47 +0,0 @@
-// deno-fmt-ignore-file
-import { Reducer } from './_reducer.mjs';
-import { CheckContext, ErrorContext } from './_context.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildAnyOfStandard(stack, context, schema, value) {
-    return Reducer(stack, context, schema.anyOf, value, E.IsGreaterThan(E.Member('results', 'length'), E.Constant(0)));
-}
-function BuildAnyOfFast(stack, context, schema, value) {
-    return E.ReduceOr(schema.anyOf.map((schema) => BuildSchema(stack, context, schema, value)));
-}
-export function BuildAnyOf(stack, context, schema, value) {
-    return context.UseUnevaluated()
-        ? BuildAnyOfStandard(stack, context, schema, value)
-        : BuildAnyOfFast(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAnyOf(stack, context, schema, value) {
-    const results = schema.anyOf.reduce((result, schema) => {
-        const nextContext = new CheckContext();
-        return CheckSchema(stack, nextContext, schema, value) ? [...result, nextContext] : result;
-    }, []);
-    return G.IsGreaterThan(results.length, 0) && context.Merge(results);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
-    const failedContexts = [];
-    const results = schema.anyOf.reduce((result, schema, index) => {
-        const nextContext = new ErrorContext();
-        const nextSchemaPath = `${schemaPath}/anyOf/${index}`;
-        const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
-        if (!isSchema)
-            failedContexts.push(nextContext);
-        return isSchema ? [...result, nextContext] : result;
-    }, []);
-    const isAnyOf = G.IsGreaterThan(results.length, 0) && context.Merge(results);
-    if (!isAnyOf)
-        failedContexts.forEach(failed => context.AddErrors(failed.GetErrors()));
-    return isAnyOf || context.AddError('anyOf', schemaPath, instancePath, {});
-}

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

@@ -1,5 +0,0 @@
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchemaBoolean(_stack: Stack.XStack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckSchemaBoolean(_stack: Stack.XStack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorSchemaBoolean(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: boolean, value: unknown): boolean;

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

@@ -1,21 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildSchemaBoolean(_stack, _context, schema, _value) {
-    return schema ? E.Constant(true) : E.Constant(false);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckSchemaBoolean(_stack, _context, schema, _value) {
-    return schema;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckSchemaBoolean(stack, context, schema, value) ||
-        context.AddError('boolean', schemaPath, instancePath, {});
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildConst(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XConst, value: string): string;
-export declare function CheckConst(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XConst, value: unknown): boolean;
-export declare function ErrorConst(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XConst, value: unknown): boolean;

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

@@ -1,26 +0,0 @@
-// deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildConst(_stack, _context, schema, value) {
-    return G.IsValueLike(schema.const)
-        ? E.IsEqual(value, E.Constant(schema.const))
-        : E.IsDeepEqual(value, Externals.CreateVariable(schema.const));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckConst(_stack, _context, schema, value) {
-    return G.IsValueLike(schema.const)
-        ? G.IsEqual(value, schema.const)
-        : G.IsDeepEqual(value, schema.const);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckConst(stack, context, schema, value) ||
-        context.AddError('const', schemaPath, instancePath, { allowedValue: schema.const });
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildContains(stack: Stack.XStack, context: BuildContext, schema: Schema.XContains, value: string): string;
-export declare function CheckContains(stack: Stack.XStack, context: CheckContext, schema: Schema.XContains, value: unknown[]): boolean;
-export declare function ErrorContains(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XContains, value: unknown[]): boolean;

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

@@ -1,50 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import * as Unique from './_unique.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Invalid
-// ------------------------------------------------------------------
-function IsValid(schema) {
-    return !(Schema.IsMinContains(schema) && G.IsEqual(schema.minContains, 0));
-}
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-function BuildContainsStandard(stack, context, schema, value) {
-    const [item, index] = [Unique.CreateUnique(), Unique.CreateUnique()];
-    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.SomeAll(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
-    return E.And(isLength, isSome);
-}
-function BuildContainsFast(stack, context, schema, value) {
-    const [item] = [Unique.CreateUnique()];
-    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.Some(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
-    return E.And(isLength, isSome);
-}
-export function BuildContains(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
-    return context.UseUnevaluated()
-        ? BuildContainsStandard(stack, context, schema, value)
-        : BuildContainsFast(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckContains(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    return !G.IsEqual(value.length, 0) && G.SomeAll(value, (item, index) => {
-        return CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index);
-    });
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckContains(stack, context, schema, value) ||
-        context.AddError('contains', schemaPath, instancePath, { minContains: 1 });
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependencies(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependencies, value: string): string;
-export declare function CheckDependencies(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependencies(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependencies, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,43 +0,0 @@
-// deno-fmt-ignore-file
-import * as Pathing from './_pathing.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildDependencies(stack, context, schema, value) {
-    const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
-    const isEveryDependency = E.ReduceAnd(G.Entries(schema.dependencies).map(([key, schema]) => {
-        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(stack, context, schema, value);
-        const isEveryKey = (schema) => E.ReduceAnd(schema.map((key) => E.HasPropertyKey(value, E.Constant(key))));
-        return E.Or(notKey, G.IsArray(schema) ? isEveryKey(schema) : isSchema);
-    }));
-    return E.Or(isLength, isEveryDependency);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckDependencies(stack, context, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependencies), 0, ([key, schema]) => {
-        return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((key) => G.HasPropertyKey(value, key))
-            : CheckSchema(stack, context, schema, value));
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorDependencies(stack, context, schemaPath, instancePath, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.EveryAll(G.Entries(schema.dependencies), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependencies/${Pathing.EncodeFragment(key)}`;
-        return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) ||
-                context.AddError('dependencies', schemaPath, instancePath, { property: key, dependencies: schema }))
-            : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
-    });
-    return isLength || isEvery;
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentRequired(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
-export declare function CheckDependentRequired(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentRequired(_stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,36 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildDependentRequired(_stack, _context, schema, value) {
-    const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
-    const isEvery = E.ReduceAnd(G.Entries(schema.dependentRequired).map(([key, keys]) => {
-        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const everyKey = E.ReduceAnd(keys.map((key) => E.HasPropertyKey(value, E.Constant(key))));
-        return E.Or(notKey, everyKey);
-    }));
-    return E.Or(isLength, isEvery);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckDependentRequired(_stack, _context, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) ||
-            keys.every((key) => G.HasPropertyKey(value, key));
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEveryEntry = G.EveryAll(G.Entries(schema.dependentRequired), 0, ([key, keys]) => {
-        return !G.HasPropertyKey(value, key) || G.EveryAll(keys, 0, (dependency) => G.HasPropertyKey(value, dependency) ||
-            context.AddError('dependentRequired', schemaPath, instancePath, { property: key, dependencies: keys }));
-    });
-    return isLength || isEveryEntry;
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentSchemas(stack: Stack.XStack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
-export declare function CheckDependentSchemas(stack: Stack.XStack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentSchemas(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,39 +0,0 @@
-// deno-fmt-ignore-file
-import * as Pathing from './_pathing.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildDependentSchemas(stack, context, schema, value) {
-    const isLength = E.IsEqual(E.Member(E.Keys(value), 'length'), E.Constant(0));
-    const isEvery = E.ReduceAnd(G.Entries(schema.dependentSchemas).map(([key, schema]) => {
-        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
-        const isSchema = BuildSchema(stack, context, schema, value);
-        return E.Or(notKey, isSchema);
-    }));
-    return E.Or(isLength, isEvery);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckDependentSchemas(stack, context, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.Every(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        return !G.HasPropertyKey(value, key) ||
-            CheckSchema(stack, context, schema, value);
-    });
-    return isLength || isEvery;
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value) {
-    const isLength = G.IsEqual(G.Keys(value).length, 0);
-    const isEvery = G.EveryAll(G.Entries(schema.dependentSchemas), 0, ([key, schema]) => {
-        const nextSchemaPath = `${schemaPath}/dependentSchemas/${Pathing.EncodeFragment(key)}`;
-        return !G.HasPropertyKey(value, key) ||
-            ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value);
-    });
-    return isLength || isEvery;
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDynamicRef(stack: Stack.XStack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
-export declare function CheckDynamicRef(stack: Stack.XStack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
-export declare function ErrorDynamicRef(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

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

@@ -1,29 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import * as Functions from './_functions.mjs';
-import { Resolve } from '../resolve/index.mjs';
-import { CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildDynamicRef(stack, context, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return Functions.CreateFunction(nextStack, context, target, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckDynamicRef(stack, context, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && CheckSchema(nextStack, context, target, value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value) {
-    const target = Resolve.DynamicRef(stack, schema) ?? false;
-    const nextStack = target ? { ...stack, pendingResource: true } : stack;
-    return (Schema.IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value));
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import * as Stack from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildEnum(_stack: Stack.XStack, _context: BuildContext, schema: Schema.XEnum, value: string): string;
-export declare function CheckEnum(_stack: Stack.XStack, _context: CheckContext, schema: Schema.XEnum, value: unknown): boolean;
-export declare function ErrorEnum(stack: Stack.XStack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XEnum, value: unknown): boolean;