@astrofoundry/pi-astro 0.16.1 → 0.18.1

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

@@ -1,20 +0,0 @@
-import { Settings } from '../../system/settings/index.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// IsExactOptional
-// ------------------------------------------------------------------
-export function IsExactOptional(required, key) {
-    return required.includes(key) || Settings.Get().exactOptionalPropertyTypes;
-}
-// ------------------------------------------------------------------
-// ExactOptionalBuild
-// ------------------------------------------------------------------
-export function InexactOptionalBuild(value, key) {
-    return E.IsUndefined(E.Member(value, key));
-}
-// ------------------------------------------------------------------
-// ExactOptionalCheck
-// ------------------------------------------------------------------
-export function InexactOptionalCheck(value, key) {
-    return G.IsUndefined(value[key]);
-}

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

@@ -1,7 +0,0 @@
-export interface TExternal {
-    identifier: 'External';
-    variables: unknown[];
-}
-export declare function CreateVariable(value: unknown): string;
-export declare function ResetExternal(): void;
-export declare function GetExternal(): TExternal;

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

@@ -1,25 +0,0 @@
-// deno-fmt-ignore-file
-const state = {
-    identifier: 'External',
-    variables: []
-};
-// ------------------------------------------------------------------
-// CreateVariable
-// ------------------------------------------------------------------
-export function CreateVariable(value) {
-    const call = `External[${state.variables.length}]`;
-    state.variables.push(value);
-    return call;
-}
-// ------------------------------------------------------------------
-// ResetExternal
-// ------------------------------------------------------------------
-export function ResetExternal() {
-    state.variables = [];
-}
-// ------------------------------------------------------------------
-// GetExternals
-// ------------------------------------------------------------------
-export function GetExternal() {
-    return { ...state };
-}

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

@@ -1,6 +0,0 @@
-import * as Schema from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function ResetFunctions(): void;
-export declare function GetFunctions(): string[];
-export declare function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;

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

@@ -1,47 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import { Hashing } from '../../system/hashing/index.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-const functions = new Map();
-// ------------------------------------------------------------------
-// CreateCallExpression
-// ------------------------------------------------------------------
-function CreateCallExpression(context, _schema, hash, value) {
-    return context.UseUnevaluated()
-        ? E.Call(`check_${hash}`, ['context', value])
-        : E.Call(`check_${hash}`, [value]);
-}
-// ------------------------------------------------------------------
-// CreateFunctionExpression
-// ------------------------------------------------------------------
-function CreateFunctionExpression(stack, context, schema, hash) {
-    const expression = BuildSchema(stack, context, schema, 'value');
-    return context.UseUnevaluated()
-        ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
-        : E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['value'], expression));
-}
-// ------------------------------------------------------------------
-// ResetFunctions
-// ------------------------------------------------------------------
-export function ResetFunctions() {
-    functions.clear();
-}
-// ------------------------------------------------------------------
-// GetFunctions
-// ------------------------------------------------------------------
-export function GetFunctions() {
-    return [...functions.values()];
-}
-// ------------------------------------------------------------------
-// CreateFunction
-// ------------------------------------------------------------------
-export function CreateFunction(stack, context, schema, value) {
-    const hash = Schema.IsSchemaObject(schema) ? Hashing.Hash({ __baseURL: stack.BaseURL().href, ...schema }) : Hashing.Hash(schema);
-    const call = CreateCallExpression(context, schema, hash, value);
-    if (functions.has(hash))
-        return call;
-    functions.set(hash, '');
-    functions.set(hash, CreateFunctionExpression(stack, context, schema, hash));
-    return call;
-}

package/node_modules/typebox/build/schema/engine/_guard.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 BuildGuard(_stack: Stack, _context: BuildContext, schema: Schema.XGuard, value: string): string;
-export declare function CheckGuard(_stack: Stack, _context: CheckContext, schema: Schema.XGuard, value: unknown): boolean;
-export declare function ErrorGuard(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XGuard, value: unknown): boolean;

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

@@ -1,26 +0,0 @@
-// deno-fmt-ignore-file
-import * as Externals from './_externals.mjs';
-import { EmitGuard as E } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildGuard(_stack, _context, schema, value) {
-    return E.Call(E.Member(E.Member(Externals.CreateVariable(schema), '~guard'), 'check'), [value]);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckGuard(_stack, _context, schema, value) {
-    return schema['~guard'].check(value);
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorGuard(_stack, context, schemaPath, instancePath, schema, value) {
-    return schema['~guard'].check(value) || context.AddError({
-        keyword: '~guard',
-        schemaPath,
-        instancePath,
-        params: { errors: schema['~guard'].errors(value) },
-    });
-}

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

@@ -1,4 +0,0 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext } from './_context.mjs';
-export declare function Reducer(stack: Stack, context: BuildContext, schemas: S.XSchema[], value: string, check: string): string;

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

@@ -1,45 +0,0 @@
-// deno-fmt-ignore-file
-import { EmitGuard as E } from '../../guard/index.mjs';
-import { BuildSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Reducer
-//
-// This function is used to generate an reducer evaluation context 
-// for the allOf, anyOf, oneOf and not keywords. The reducer mechansism
-// is required from 2019-09 onwards to gather evaluated keys and indices
-// for the unevaluatedItems and unevaluatedProperties keywords.
-//
-// ------------------------------------------------------------------
-//
-// const context = new Context() // exterior
-//
-// (() => {
-//   const results = []
-//
-//   const context_0 = context.Clone()
-//   const context_1 = context.Clone()
-//   const context_2 = context.Clone()
-//   const context_3 = context.Clone()
-//   
-//   const condition_0 = ((context) => <subschema>)(context_0)
-//   const condition_1 = ((context) => <subschema>)(context_1)
-//   const condition_2 = ((context) => <subschema>)(context_2)
-//   const condition_3 = ((context) => <subschema>)(context_3)
-// 
-//   if(condition_0) results.push(context_0)
-//   if(condition_1) results.push(context_1)
-//   if(condition_2) results.push(context_2)
-//   if(condition_3) results.push(context_3)
-//
-//   return <check> && context.Merge(results)
-// })()
-//
-// ------------------------------------------------------------------
-export function Reducer(stack, context, schemas, value, check) {
-    const results = E.ConstDeclaration('results', '[]');
-    const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, E.New('CheckContext', [])));
-    const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(stack, context, schema, value)), [`context_${index}`])));
-    const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])));
-    const returns = E.Return(E.And(check, context.Merge('results')));
-    return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), []);
-}

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

@@ -1,6 +0,0 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRefine(_stack: Stack, _context: BuildContext, schema: S.XRefine, value: string): string;
-export declare function CheckRefine(_stack: Stack, _context: CheckContext, schema: S.XRefine, value: unknown): boolean;
-export declare function ErrorRefine(_stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRefine, value: unknown): boolean;

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

@@ -1,29 +0,0 @@
-// deno-fmt-ignore-file
-import * as V from './_externals.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Build
-// ------------------------------------------------------------------
-export function BuildRefine(_stack, _context, schema, value) {
-    const refinements = V.CreateVariable(schema['~refine'].map((refinement) => refinement));
-    return E.Every(refinements, E.Constant(0), ['refinement', '_'], E.Call(E.Member('refinement', 'check'), [value]));
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckRefine(_stack, _context, schema, value) {
-    return G.Every(schema['~refine'], 0, (refinement, _) => refinement.check(value));
-}
-// ------------------------------------------------------------------
-// Error
-// ------------------------------------------------------------------
-export function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
-    return G.EveryAll(schema['~refine'], 0, (refinement, index) => {
-        return refinement.check(value) || context.AddError({
-            keyword: '~refine',
-            schemaPath,
-            instancePath,
-            params: { index, message: refinement.error(value) },
-        });
-    });
-}

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

@@ -1,18 +0,0 @@
-import * as Schema from '../types/index.mjs';
-export declare class Stack {
-    #private;
-    private readonly context;
-    private readonly schema;
-    private readonly ids;
-    private readonly anchors;
-    private readonly recursiveAnchors;
-    private readonly dynamicAnchors;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    BaseURL(): URL;
-    Base(): Schema.XSchemaObject;
-    Push(schema: Schema.XSchema): void;
-    Pop(schema: Schema.XSchema): void;
-    Ref(ref: Schema.XRef): Schema.XSchema | undefined;
-    RecursiveRef(recursiveRef: Schema.XRecursiveRef): Schema.XSchema | undefined;
-    DynamicRef(dynamicRef: Schema.XDynamicRef): Schema.XSchema | undefined;
-}

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

@@ -1,107 +0,0 @@
-// deno-fmt-ignore-file
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors, _Stack_FromContext, _Stack_FromRef;
-import * as Schema from '../types/index.mjs';
-import { Guard as G } from '../../guard/index.mjs';
-import { Resolve } from '../resolve/index.mjs';
-export class Stack {
-    constructor(context, schema) {
-        _Stack_instances.add(this);
-        this.context = context;
-        this.schema = schema;
-        this.ids = [];
-        this.anchors = [];
-        this.recursiveAnchors = [];
-        this.dynamicAnchors = [];
-    }
-    // ----------------------------------------------------------------
-    // Base
-    // ----------------------------------------------------------------
-    BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), new URL('http://unknown'));
-    }
-    Base() {
-        return this.ids[this.ids.length - 1] ?? this.schema;
-    }
-    // ----------------------------------------------------------------
-    // Stack
-    // ----------------------------------------------------------------
-    Push(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema)) {
-            this.ids.push(schema);
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
-        }
-        if (Schema.IsAnchor(schema))
-            this.anchors.push(schema);
-        if (Schema.IsRecursiveAnchorTrue(schema))
-            this.recursiveAnchors.push(schema);
-        if (Schema.IsDynamicAnchor(schema))
-            this.dynamicAnchors.push(schema);
-    }
-    Pop(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema)) {
-            this.ids.pop();
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
-        }
-        if (Schema.IsAnchor(schema))
-            this.anchors.pop();
-        if (Schema.IsRecursiveAnchorTrue(schema))
-            this.recursiveAnchors.pop();
-        if (Schema.IsDynamicAnchor(schema))
-            this.dynamicAnchors.pop();
-    }
-    Ref(ref) {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromContext).call(this, ref) ?? __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_FromRef).call(this, ref);
-    }
-    // ----------------------------------------------------------------
-    // RecursiveRef
-    // ----------------------------------------------------------------
-    RecursiveRef(recursiveRef) {
-        return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.Base(), recursiveRef.$recursiveRef);
-    }
-    // ----------------------------------------------------------------
-    // DynamicRef
-    // ----------------------------------------------------------------
-    DynamicRef(dynamicRef) {
-        const root = this.schema;
-        return Resolve.DynamicRef(root, this.Base(), dynamicRef, this.dynamicAnchors);
-    }
-}
-_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
-    if (!Schema.IsSchemaObject(schema))
-        return;
-    const current = schema;
-    if (!isRoot && Schema.IsId(current))
-        return;
-    if (!isRoot && Schema.IsDynamicAnchor(current))
-        this.dynamicAnchors.push(current);
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
-}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
-    if (!Schema.IsSchemaObject(schema))
-        return;
-    const current = schema;
-    if (!isRoot && Schema.IsId(current))
-        return;
-    if (!isRoot && Schema.IsDynamicAnchor(current))
-        this.dynamicAnchors.pop();
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-}, _Stack_FromContext = function _Stack_FromContext(ref) {
-    return G.HasPropertyKey(this.context, ref.$ref) ? this.context[ref.$ref] : undefined;
-}, _Stack_FromRef = function _Stack_FromRef(ref) {
-    const root = this.schema;
-    return !ref.$ref.startsWith('#')
-        ? Resolve.Ref(root, ref.$ref)
-        : Resolve.Ref(this.Base(), ref.$ref);
-};

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

@@ -1,2 +0,0 @@
-/** Returns a Unique Variable Name */
-export declare function Unique(): string;

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

@@ -1,5 +0,0 @@
-let index = 0;
-/** Returns a Unique Variable Name */
-export function Unique() {
-    return `var_${index++}`;
-}

package/node_modules/typebox/build/schema/engine/additionalItems.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 BuildAdditionalItems(stack: Stack, context: BuildContext, schema: Schema.XAdditionalItems, value: string): string;
-export declare function CheckAdditionalItems(stack: Stack, context: CheckContext, schema: Schema.XAdditionalItems, value: unknown[]): boolean;
-export declare function ErrorAdditionalItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAdditionalItems, value: unknown[]): boolean;

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

@@ -1,50 +0,0 @@
-// deno-fmt-ignore-file
-import * as Schema from '../types/index.mjs';
-import { 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
-// ------------------------------------------------------------------
-export function BuildAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return E.Constant(true);
-    const [item, index] = [Unique(), Unique()];
-    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalItems, item);
-    const isLength = E.IsLessThan(index, E.Constant(schema.items.length));
-    const addIndex = context.AddIndex(index);
-    const guarded = context.UseUnevaluated() ? E.Or(isLength, E.And(isSchema, addIndex)) : E.Or(isLength, isSchema);
-    return E.Call(E.Member(value, 'every'), [E.ArrowFunction([item, index], guarded)]);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAdditionalItems(stack, context, schema, value) {
-    if (!IsValid(schema))
-        return true;
-    const isAdditionalItems = value.every((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 = value.every((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,9 +0,0 @@
-import * as S from '../types/index.mjs';
-import { Stack } from './_stack.mjs';
-import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function CanAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties, _value: string): schema is S.XAdditionalProperties & S.XRequired;
-export declare function BuildAdditionalPropertiesFast(_context: BuildContext, schema: S.XAdditionalProperties & S.XRequired, value: string): string;
-export declare function BuildAdditionalPropertiesStandard(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
-export declare function BuildAdditionalProperties(stack: Stack, context: BuildContext, schema: S.XAdditionalProperties, value: string): string;
-export declare function CheckAdditionalProperties(stack: Stack, context: CheckContext, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorAdditionalProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XAdditionalProperties, value: Record<PropertyKey, unknown>): boolean;

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

@@ -1,110 +0,0 @@
-// deno-fmt-ignore-file
-import * as S from '../types/index.mjs';
-import * as V from './_externals.mjs';
-import { Unique } from './_unique.mjs';
-import { AccumulatedErrorContext } from './_context.mjs';
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
-import { BuildSchemaPushStack, CheckSchemaPushStack, ErrorSchemaPushStack } from './schema.mjs';
-// ------------------------------------------------------------------
-// Common: 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 (S.IsPatternProperties(schema))
-        patterns.push(...G.Keys(schema.patternProperties));
-    if (S.IsProperties(schema))
-        patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
-    return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesFast
-//
-// Optimized logic for schemas with `additionalProperties: false`.
-//
-// This fast-path applies only when:
-// - `additionalProperties` is explicitly set to false,
-// - the schema uses only `properties` (no `patternProperties`),
-// - and all defined properties are required (i.e., no optional keys).
-//
-// This constraint is common when enforcing strict object shapes
-// with only known, fixed keys. When all these conditions are met,
-// we can generate a simplified and efficient runtime check.
-//
-// ------------------------------------------------------------------
-export function CanAdditionalPropertiesFast(_context, schema, _value) {
-    return S.IsRequired(schema)
-        && S.IsProperties(schema)
-        && !S.IsPatternProperties(schema)
-        && G.IsEqual(schema.additionalProperties, false)
-        && G.IsEqual(G.Keys(schema.properties).length, schema.required.length);
-}
-export function BuildAdditionalPropertiesFast(_context, schema, value) {
-    return E.IsEqual(E.Member(E.Call(E.Member('Object', 'getOwnPropertyNames'), [value]), 'length'), E.Constant(schema.required.length));
-}
-// ------------------------------------------------------------------
-// BuildAdditionalPropertiesStandard
-// ------------------------------------------------------------------
-export function BuildAdditionalPropertiesStandard(stack, context, schema, value) {
-    const [key, _index] = [Unique(), Unique()];
-    const regexp = V.CreateVariable(new RegExp(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) {
-    return CanAdditionalPropertiesFast(context, schema, value)
-        ? BuildAdditionalPropertiesFast(context, schema, value)
-        : BuildAdditionalPropertiesStandard(stack, context, schema, value);
-}
-// ------------------------------------------------------------------
-// Check
-// ------------------------------------------------------------------
-export function CheckAdditionalProperties(stack, context, schema, value) {
-    const regexp = new RegExp(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 = new RegExp(GetPropertiesPattern(schema));
-    const additionalProperties = [];
-    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
-        const nextSchemaPath = `${schemaPath}/additionalProperties`;
-        const nextInstancePath = `${instancePath}/${key}`;
-        const nextContext = new AccumulatedErrorContext();
-        const isAdditionalProperty = regexp.test(key) ||
-            (ErrorSchemaPushStack(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
-        if (!isAdditionalProperty)
-            additionalProperties.push(key);
-        return isAdditionalProperty;
-    });
-    return isAdditionalProperties || context.AddError({
-        keyword: 'additionalProperties',
-        schemaPath,
-        instancePath,
-        params: { additionalProperties },
-    });
-}

package/node_modules/typebox/build/schema/engine/allOf.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 BuildAllOf(stack: Stack, context: BuildContext, schema: Schema.XAllOf, value: string): string;
-export declare function CheckAllOf(stack: Stack, context: CheckContext, schema: Schema.XAllOf, value: unknown): boolean;
-export declare function ErrorAllOf(stack: Stack, 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, AccumulatedErrorContext } 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 AccumulatedErrorContext();
-        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 => failed.GetErrors().forEach(error => context.AddError(error)));
-    return isAllOf;
-}

package/node_modules/typebox/build/schema/engine/anyOf.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 BuildAnyOf(stack: Stack, context: BuildContext, schema: Schema.XAnyOf, value: string): string;
-export declare function CheckAnyOf(stack: Stack, context: CheckContext, schema: Schema.XAnyOf, value: unknown): boolean;
-export declare function ErrorAnyOf(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XAnyOf, value: unknown): boolean;