@astrofoundry/pi-astro 0.17.1 → 0.18.2

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

@@ -1,52 +0,0 @@
-// deno-fmt-ignore-file
-import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
-import { Reducer } from './_reducer.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.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 AccumulatedErrorContext();
-        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 => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isAnyOf || context.AddError({
-        keyword: 'anyOf',
-        schemaPath,
-        instancePath,
-        params: {}
-    });
-}

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

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

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

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

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

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

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

@@ -1,30 +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({
-        keyword: 'const',
-        schemaPath,
-        instancePath,
-        params: { 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 { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildContains(stack: Stack, context: BuildContext, schema: Schema.XContains, value: string): string;
-export declare function CheckContains(stack: Stack, context: CheckContext, schema: Schema.XContains, value: unknown[]): boolean;
-export declare function ErrorContains(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XContains, value: unknown[]): boolean;

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

@@ -1,42 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import { 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
-// ------------------------------------------------------------------
-export function BuildContains(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
-    const item = Unique();
-    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
-    const isSome = E.Call(E.Member(value, 'some'), [E.ArrowFunction([item], BuildSchema(stack, context, schema.contains, item))]);
-    return E.And(isLength, isSome);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckContains(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    return !G.IsEqual(value.length, 0) &&
-        value.some((item) => CheckSchema(stack, context, schema.contains, item));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckContains(stack, context, schema, value) || context.AddError({
-        keyword: 'contains',
-        schemaPath,
-        instancePath,
-        params: { minContains: 1 },
-    });
-}

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

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

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

@@ -1,45 +0,0 @@
-// deno-fmt-ignore-file
-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/${key}`;
-        return !G.HasPropertyKey(value, key) || (G.IsArray(schema)
-            ? schema.every((dependency) => G.HasPropertyKey(value, dependency) || context.AddError({
-                keyword: 'dependencies',
-                schemaPath,
-                instancePath,
-                params: { 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 { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentRequired(_stack: Stack, _context: BuildContext, schema: Schema.XDependentRequired, value: string): string;
-export declare function CheckDependentRequired(_stack: Stack, _context: CheckContext, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentRequired(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentRequired, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,40 +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({
-            keyword: 'dependentRequired',
-            schemaPath,
-            instancePath,
-            params: { 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 { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDependentSchemas(stack: Stack, context: BuildContext, schema: Schema.XDependentSchemas, value: string): string;
-export declare function CheckDependentSchemas(stack: Stack, context: CheckContext, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorDependentSchemas(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XDependentSchemas, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,38 +0,0 @@
-// deno-fmt-ignore-file
-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/${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 { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildDynamicRef(stack: Stack, context: BuildContext, schema: Schema.XDynamicRef, value: string): string;
-export declare function CheckDynamicRef(stack: Stack, context: CheckContext, schema: Schema.XDynamicRef, value: unknown): boolean;
-export declare function ErrorDynamicRef(stack: Stack, context: ErrorContext, _schemaPath: string, instancePath: string, schema: Schema.XDynamicRef, value: unknown): boolean;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-import * as Functions from './_functions.mjs';
-import * as Schema from '../types/index.mjs';
-import { CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return Functions.CreateFunction(stack, context, target, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckDynamicRef(stack, context, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
-    const target = stack.DynamicRef(schema) ?? false;
-    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', 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 { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildEnum(_stack: Stack, _context: BuildContext, schema: Schema.XEnum, value: string): string;
-export declare function CheckEnum(_stack: Stack, _context: CheckContext, schema: Schema.XEnum, value: unknown): boolean;
-export declare function ErrorEnum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XEnum, value: unknown): boolean;

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

@@ -1,33 +0,0 @@
-// deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildEnum(_stack, _context, schema, value) {
-    return E.ReduceOr(schema.enum.map(option => {
-        if (G.IsValueLike(option))
-            return E.IsEqual(value, E.Constant(option));
-        const variable = Externals.CreateVariable(option);
-        return E.IsDeepEqual(value, variable);
-    }));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckEnum(_stack, _context, schema, value) {
-    return schema.enum.some(option => G.IsValueLike(option)
-        ? G.IsEqual(value, option)
-        : G.IsDeepEqual(value, option));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckEnum(stack, context, schema, value) || context.AddError({
-        keyword: 'enum',
-        schemaPath,
-        instancePath,
-        params: { allowedValues: schema.enum }
-    });
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildExclusiveMaximum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMaximum, value: string): string;
-export declare function CheckExclusiveMaximum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMaximum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMaximum, value: number | bigint): boolean;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildExclusiveMaximum(_stack, _context, schema, value) {
-    return E.IsLessThan(value, E.Constant(schema.exclusiveMaximum));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckExclusiveMaximum(_stack, _context, schema, value) {
-    return G.IsLessThan(value, schema.exclusiveMaximum);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError({
-        keyword: 'exclusiveMaximum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '<', limit: schema.exclusiveMaximum }
-    });
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildExclusiveMinimum(_stack: Stack, _context: BuildContext, schema: Schema.XExclusiveMinimum, value: string): string;
-export declare function CheckExclusiveMinimum(_stack: Stack, _context: CheckContext, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;
-export declare function ErrorExclusiveMinimum(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XExclusiveMinimum, value: number | bigint): boolean;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildExclusiveMinimum(_stack, _context, schema, value) {
-    return E.IsGreaterThan(value, E.Constant(schema.exclusiveMinimum));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckExclusiveMinimum(_stack, _context, schema, value) {
-    return G.IsGreaterThan(value, schema.exclusiveMinimum);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError({
-        keyword: 'exclusiveMinimum',
-        schemaPath,
-        instancePath,
-        params: { comparison: '>', limit: schema.exclusiveMinimum }
-    });
-}

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

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

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

@@ -1,26 +0,0 @@
-// deno-fmt-ignore-file
-import { Format } from '../../format/index.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildFormat(_stack, _context, schema, value) {
-    return E.Call(E.Member('Format', 'Test'), [E.Constant(schema.format), value]);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckFormat(_stack, _context, schema, value) {
-    return Format.Test(schema.format, value);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
-    return CheckFormat(stack, context, schema, value) || context.AddError({
-        keyword: 'format',
-        schemaPath,
-        instancePath,
-        params: { format: schema.format },
-    });
-}

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

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

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

@@ -1,47 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildIf(stack, context, schema, value) {
-    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
-    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
-    return E.Ternary(BuildSchema(stack, context, schema.if, value), BuildSchema(stack, context, thenSchema, value), BuildSchema(stack, context, elseSchema, value));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckIf(stack, context, schema, value) {
-    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
-    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
-    return CheckSchema(stack, context, schema.if, value)
-        ? CheckSchema(stack, context, thenSchema, value)
-        : CheckSchema(stack, context, elseSchema, value);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
-    const thenSchema = Schema.IsThen(schema) ? schema.then : true;
-    const elseSchema = Schema.IsElse(schema) ? schema.else : true;
-    const trueContext = new AccumulatedErrorContext();
-    const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value)
-        ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
-            keyword: 'if',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'then' },
-        })
-        : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
-            keyword: 'if',
-            schemaPath,
-            instancePath,
-            params: { failingKeyword: 'else' },
-        });
-    if (isIf)
-        context.Merge([trueContext]);
-    return isIf;
-}

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

@@ -1,49 +0,0 @@
-export * from './_context.mjs';
-export * from './_externals.mjs';
-export * from './_guard.mjs';
-export * from './_functions.mjs';
-export * from './_reducer.mjs';
-export * from './_refine.mjs';
-export * from './_stack.mjs';
-export * from './additionalItems.mjs';
-export * from './additionalProperties.mjs';
-export * from './allOf.mjs';
-export * from './anyOf.mjs';
-export * from './boolean.mjs';
-export * from './const.mjs';
-export * from './contains.mjs';
-export * from './dependencies.mjs';
-export * from './dependentRequired.mjs';
-export * from './dependentSchemas.mjs';
-export * from './enum.mjs';
-export * from './exclusiveMaximum.mjs';
-export * from './exclusiveMinimum.mjs';
-export * from './format.mjs';
-export * from './if.mjs';
-export * from './items.mjs';
-export * from './maxContains.mjs';
-export * from './maxItems.mjs';
-export * from './maxLength.mjs';
-export * from './maxProperties.mjs';
-export * from './maximum.mjs';
-export * from './minContains.mjs';
-export * from './minItems.mjs';
-export * from './minLength.mjs';
-export * from './minProperties.mjs';
-export * from './minimum.mjs';
-export * from './multipleOf.mjs';
-export * from './not.mjs';
-export * from './oneOf.mjs';
-export * from './pattern.mjs';
-export * from './patternProperties.mjs';
-export * from './prefixItems.mjs';
-export * from './properties.mjs';
-export * from './propertyNames.mjs';
-export * from './recursiveRef.mjs';
-export * from './ref.mjs';
-export * from './required.mjs';
-export * from './schema.mjs';
-export * from './type.mjs';
-export * from './unevaluatedItems.mjs';
-export * from './unevaluatedProperties.mjs';
-export * from './uniqueItems.mjs';