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

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

@@ -1,209 +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_StackFrame, _Stack_ApplyRefResult, _Stack_BuildBase, _Stack_ResourceBaseURL, _Stack_ReferenceBaseURL, _Stack_LexicalSchema, _Stack_RegisterResourceAnchorArray, _Stack_UnregisterResourceAnchorArray, _Stack_RegisterResourceAnchors, _Stack_UnregisterResourceAnchors, _Stack_RegisterResource, _Stack_UnregisterResource, _Stack_EnterResolvedResource, _Stack_ExitResolvedResource;
-import * as Schema from '../types/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-import { Resolve } from '../resolve/index.mjs';
-// --------------------------------------------------------------------------
-// Stack
-//
-// Tracks traversal state ($ids, $anchors, stack frames) and applies scope
-// updates. Reference resolution rules ($ref, $dynamicRef) are delegated to
-// the Resolve functions using state snapshots (Resolve.Scope).
-// --------------------------------------------------------------------------
-export class Stack {
-    constructor(context, schema) {
-        _Stack_instances.add(this);
-        this.context = context;
-        this.schema = schema;
-        this.ids = [];
-        this.resourceIds = [];
-        this.anchors = [];
-        this.recursiveAnchors = [];
-        this.dynamicAnchors = [];
-        this.retrievedResources = new Map();
-        this.retrievedFrames = [];
-        this.resolvedResources = new Map();
-        this.pendingResource = true;
-    }
-    // ----------------------------------------------------------------
-    // LexicalBaseURL
-    // ----------------------------------------------------------------
-    LexicalBaseURL() {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.ids);
-    }
-    // ----------------------------------------------------------------
-    // Push
-    // ----------------------------------------------------------------
-    Push(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema))
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).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);
-        const retrievedResource = this.retrievedResources.get(schema);
-        if (retrievedResource) {
-            this.retrievedFrames.push({
-                schema: retrievedResource.root,
-                base: retrievedResource.base,
-                idDepth: this.ids.length,
-                resourceDepth: this.resourceIds.length
-            });
-        }
-    }
-    // ----------------------------------------------------------------
-    // Pop
-    // ----------------------------------------------------------------
-    Pop(schema) {
-        if (!Schema.IsSchemaObject(schema))
-            return;
-        if (Schema.IsId(schema))
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, schema);
-        if (Schema.IsAnchor(schema))
-            this.anchors.pop();
-        if (Schema.IsRecursiveAnchorTrue(schema))
-            this.recursiveAnchors.pop();
-        if (Schema.IsDynamicAnchor(schema))
-            this.dynamicAnchors.pop();
-        if (this.retrievedResources.has(schema))
-            this.retrievedFrames.pop();
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ExitResolvedResource).call(this, schema);
-    }
-    // ----------------------------------------------------------------
-    // Ref
-    // ----------------------------------------------------------------
-    Ref(ref) {
-        const result = Resolve.ResolveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), ref);
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ApplyRefResult).call(this, result);
-        return result.schema;
-    }
-    // ----------------------------------------------------------------
-    // RecursiveRef
-    // ----------------------------------------------------------------
-    RecursiveRef(recursiveRef) {
-        const result = Resolve.ResolveRecursiveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), recursiveRef);
-        if (result)
-            this.pendingResource = true;
-        return result;
-    }
-    // ----------------------------------------------------------------
-    // DynamicRef
-    // ----------------------------------------------------------------
-    DynamicRef(dynamicRef) {
-        const result = Resolve.ResolveDynamicRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), dynamicRef);
-        if (result)
-            this.pendingResource = true;
-        return result;
-    }
-}
-_Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame() {
-    return {
-        context: this.context,
-        root: this.schema,
-        ids: this.ids,
-        lexicalSchema: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_LexicalSchema).call(this),
-        lexicalBase: this.LexicalBaseURL(),
-        referenceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ReferenceBaseURL).call(this),
-        resourceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this),
-        recursiveAnchors: this.recursiveAnchors,
-        dynamicAnchors: this.dynamicAnchors,
-        inRetrievedFrame: this.retrievedFrames.length > 0
-    };
-}, _Stack_ApplyRefResult = function _Stack_ApplyRefResult(result) {
-    if (!Guard.IsUndefined(result.schema))
-        this.pendingResource = true;
-    if (!Guard.IsUndefined(result.resolvedResource)) {
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_EnterResolvedResource).call(this, result.resolvedResource.target, result.resolvedResource.resource);
-    }
-    if (!Guard.IsUndefined(result.retrievedResource)) {
-        this.retrievedResources.set(result.retrievedResource.target, {
-            base: result.retrievedResource.base,
-            root: result.retrievedResource.root
-        });
-    }
-}, _Stack_BuildBase = function _Stack_BuildBase(stack) {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    const base = frame ? new URL(frame.base) : new URL(Resolve.DefaultBase);
-    const scoped = frame ? stack.slice(frame.idDepth) : stack;
-    return scoped.reduce((result, schema) => new URL(schema.$id, result), base).href;
-}, _Stack_ResourceBaseURL = function _Stack_ResourceBaseURL() {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    if (!frame)
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.resourceIds);
-    return this.resourceIds.slice(frame.resourceDepth).reduce((result, schema) => new URL(schema.$id, result), new URL(frame.base)).href;
-}, _Stack_ReferenceBaseURL = function _Stack_ReferenceBaseURL() {
-    if (this.retrievedFrames.length > 0)
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
-    const lexical = this.ids[this.ids.length - 1];
-    if (lexical && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(lexical.$id))
-        return this.LexicalBaseURL();
-    return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
-}, _Stack_LexicalSchema = function _Stack_LexicalSchema() {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    if (frame)
-        return this.ids.length > frame.idDepth ? this.ids[this.ids.length - 1] : frame.schema;
-    return this.ids.length > 0 ? this.ids[this.ids.length - 1] : this.schema;
-}, _Stack_RegisterResourceAnchorArray = function _Stack_RegisterResourceAnchorArray(schema) {
-    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, false));
-}, _Stack_UnregisterResourceAnchorArray = function _Stack_UnregisterResourceAnchorArray(schema) {
-    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, false));
-}, _Stack_RegisterResourceAnchors = function _Stack_RegisterResourceAnchors(schema, isRoot = true) {
-    if (Schema.IsSchemaBoolean(schema))
-        return;
-    if (Guard.IsArray(schema))
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchorArray).call(this, schema);
-    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 Guard.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, current[key], false);
-}, _Stack_UnregisterResourceAnchors = function _Stack_UnregisterResourceAnchors(schema, isRoot = true) {
-    if (Schema.IsSchemaBoolean(schema))
-        return;
-    if (Guard.IsArray(schema))
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchorArray).call(this, schema);
-    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 Guard.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, current[key], false);
-}, _Stack_RegisterResource = function _Stack_RegisterResource(schema) {
-    this.ids.push(schema);
-    const isResource = this.pendingResource;
-    this.pendingResource = false;
-    if (isResource)
-        this.resourceIds.push(schema);
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, true);
-}, _Stack_UnregisterResource = function _Stack_UnregisterResource(schema) {
-    this.ids.pop();
-    const isResource = this.resourceIds.length > 0 && Guard.IsEqual(this.resourceIds[this.resourceIds.length - 1], schema);
-    if (isResource)
-        this.resourceIds.pop();
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, true);
-}, _Stack_EnterResolvedResource = function _Stack_EnterResolvedResource(target, resource) {
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, resource);
-    this.resolvedResources.set(target, resource);
-}, _Stack_ExitResolvedResource = function _Stack_ExitResolvedResource(target) {
-    if (!this.resolvedResources.has(target))
-        return;
-    const resource = this.resolvedResources.get(target);
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, resource);
-    this.resolvedResources.delete(target);
-};

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,60 +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
-// ------------------------------------------------------------------
-function BuildAdditionalItemsStandard(stack, context, schema, value) {
-    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);
-    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(), Unique()];
-    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,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,123 +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 { 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 (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(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}/${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({
-        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, 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 => 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;

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

@@ -1,52 +0,0 @@
-// deno-fmt-ignore-file
-import { CheckContext, ErrorContext } 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 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 => 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 BuildSchemaBoolean(_stack: Stack, _context: BuildContext, schema: boolean, _value: string): string;
-export declare function CheckSchemaBoolean(_stack: Stack, _context: CheckContext, schema: boolean, _value: unknown): boolean;
-export declare function ErrorSchemaBoolean(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 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({
-        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;