@openclaw/facetime 0.0.0 → 2026.9.7

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

@@ -0,0 +1,36 @@
+import * as Schema from '../types/index.mjs';
+export declare const DefaultUri = "urn:typebox:root";
+export interface XStack {
+    /** The schema context. */
+    readonly context: Record<string, Schema.XSchema>;
+    /** The entry schema. */
+    readonly schema: Schema.XSchema;
+    /** Visited $id schemas, kept only to detect resource re-entry (see resolve.ts FindResolvedResource). */
+    readonly ids: Schema.XId[];
+    /** Nearest enclosing $id schema, used as the root for local pointer resolution. */
+    readonly lexicalSchema: Schema.XSchema;
+    /** First $recursiveAnchor: true schema seen on the path. */
+    readonly recursiveAnchor: Schema.XRecursiveAnchor | undefined;
+    /** Dynamic anchors visible at this point in the traversal. */
+    readonly dynamicAnchors: Schema.XDynamicAnchor[];
+    /** Lexical base URL, used to resolve relative $id and $ref values within the current schema. */
+    readonly lexicalBase: string;
+    /** Base URL of the current resource, reset each time a new resource $id is entered. */
+    readonly resourceBase: string;
+    /** Base URL that $ref values resolve against. */
+    readonly referenceBase: string;
+    /** Resource entry point bookkeeping: schema -> the base/root to apply when that schema is next pushed. */
+    readonly resourceEntries: Map<Schema.XSchemaObject, {
+        base: string;
+        root: Schema.XSchemaObject;
+    }>;
+    /** True while referenceBase should track resourceBase rather than lexicalBase. */
+    readonly useResourceBaseForReference: boolean;
+    /** True until the next $id schema is entered, marking it as a fresh resource root. */
+    readonly pendingResource: boolean;
+    /** True once traversal has entered a retrieved or legacy resource. */
+    readonly enteredResource: boolean;
+}
+export declare function NextUri(ref: string, base: string): URL;
+export declare function Stack(context: Record<string, Schema.XSchema>, schema: Schema.XSchema): XStack;
+export declare function NextStack(stack: XStack, schema: Schema.XSchema): XStack;

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

@@ -0,0 +1,150 @@
+import { Guard } from '../../guard/index.mjs';
+import * as Schema from '../types/index.mjs';
+// ------------------------------------------------------------------
+// DefaultUri
+// ------------------------------------------------------------------
+export const DefaultUri = 'urn:typebox:root';
+// ------------------------------------------------------------------
+// NextUri
+//
+// Resolves a relative or absolute ref against a base URI or URN.
+// Hierarchical bases (http, https, etc.) resolve using the normal
+// URL rules. URN bases have no path to resolve against, so the ref
+// is appended after the base's last ':' segment instead.
+// ------------------------------------------------------------------
+export function NextUri(ref, base) {
+    return (URL.canParse(ref, base)) ? new URL(ref, base) : Guard.IsEqual(base, DefaultUri) ? new URL(`${base}:${ref}`) : new URL(`${base.slice(0, base.lastIndexOf(':'))}:${ref}`);
+}
+// ------------------------------------------------------------------
+// Stack
+//
+// Creates the root frame a schema traversal starts from.
+// ------------------------------------------------------------------
+export function Stack(context, schema) {
+    const base = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? NextUri(schema.$id, DefaultUri).href : DefaultUri;
+    return {
+        context,
+        schema,
+        lexicalSchema: schema,
+        lexicalBase: base,
+        resourceBase: base,
+        referenceBase: base,
+        ids: [],
+        useResourceBaseForReference: true,
+        recursiveAnchor: undefined,
+        dynamicAnchors: [],
+        resourceEntries: new Map(),
+        pendingResource: true,
+        enteredResource: false
+    };
+}
+// ------------------------------------------------------------------
+// RegisterResourceAnchors
+//
+// Collects $dynamicAnchor schemas reachable from a resource root,
+// stopping at nested $id boundaries which own their own anchors.
+// ------------------------------------------------------------------
+function RegisterResourceAnchors(anchors, schema, isRoot = true) {
+    if (Schema.IsSchemaBoolean(schema))
+        return anchors;
+    if (Array.isArray(schema))
+        return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
+    if (!Schema.IsSchemaObject(schema))
+        return anchors;
+    if (!isRoot && Schema.IsId(schema))
+        return anchors;
+    const next = !isRoot && Schema.IsDynamicAnchor(schema) ? [...anchors, schema] : anchors;
+    return Object.keys(schema).reduce((result, key) => RegisterResourceAnchors(result, schema[key], false), next);
+}
+// ------------------------------------------------------------------
+// ResourceEntry
+//
+// A ref crossing (Resolve.Ref) may have marked `schema` as the entry
+// point of a retrieved/legacy resource. If so the frame resets to
+// that resource's base/root instead of chaining onto the parent.
+// ------------------------------------------------------------------
+function ResourceEntry(stack, schema) {
+    return stack.resourceEntries.get(schema);
+}
+function NextEnteredResource(stack, schema) {
+    return stack.enteredResource || ResourceEntry(stack, schema) !== undefined;
+}
+// ------------------------------------------------------------------
+// NextStack
+//
+// Each Next* helper below computes one XStack field in isolation from
+// the previous frame and the schema being pushed.
+// ------------------------------------------------------------------
+function IsRelativeId(schema) {
+    return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(schema.$id);
+}
+function NextIds(stack, schema) {
+    return Schema.IsId(schema) ? [...stack.ids, schema] : stack.ids;
+}
+function NextRecursiveAnchor(stack, schema) {
+    return stack.recursiveAnchor ?? (Schema.IsRecursiveAnchorTrue(schema) ? schema : undefined);
+}
+function NextDynamicAnchors(stack, schema) {
+    const registered = Schema.IsId(schema) ? RegisterResourceAnchors(stack.dynamicAnchors, schema) : stack.dynamicAnchors;
+    return Schema.IsDynamicAnchor(schema) ? [...registered, schema] : registered;
+}
+function NextPendingResource(stack, schema) {
+    return Schema.IsId(schema) ? false : stack.pendingResource;
+}
+function NextLexicalBase(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.base;
+    return Schema.IsId(schema) ? NextUri(schema.$id, stack.lexicalBase).href : stack.lexicalBase;
+}
+function NextResourceBase(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.base;
+    return (Schema.IsId(schema) && stack.pendingResource) ? NextUri(schema.$id, stack.resourceBase).href : stack.resourceBase;
+}
+function NextUseResourceBaseForReference(stack, schema) {
+    return Schema.IsId(schema) ? !IsRelativeId(schema) : stack.useResourceBaseForReference;
+}
+function NextReferenceBase(stack, schema) {
+    const isRetrieved = NextEnteredResource(stack, schema);
+    const useResourceBaseForReference = NextUseResourceBaseForReference(stack, schema);
+    return (isRetrieved || useResourceBaseForReference) ? NextResourceBase(stack, schema) : NextLexicalBase(stack, schema);
+}
+function NextLexicalSchema(stack, schema) {
+    const entry = ResourceEntry(stack, schema);
+    if (entry)
+        return entry.root;
+    return Schema.IsId(schema) ? schema : stack.lexicalSchema;
+}
+// ------------------------------------------------------------------
+// NextStack | HasStackKeywords (Optimization)
+//
+// HasStackKeywords narrows schema to an object and checks whether it
+// carries $id, $dynamicAnchor, a first-seen $recursiveAnchor, or a
+// resource-entry point. When none apply, NextStack skips the frame
+// rebuild and returns the parent stack as-is.
+// ------------------------------------------------------------------
+function HasStackKeywords(stack, schema) {
+    return Schema.IsSchemaObject(schema) && (Schema.IsId(schema) ||
+        Schema.IsDynamicAnchor(schema) ||
+        (Guard.IsUndefined(stack.recursiveAnchor) && Schema.IsRecursiveAnchorTrue(schema)) ||
+        !Guard.IsUndefined(ResourceEntry(stack, schema)));
+}
+export function NextStack(stack, schema) {
+    return HasStackKeywords(stack, schema)
+        ? {
+            ...stack,
+            ids: NextIds(stack, schema),
+            dynamicAnchors: NextDynamicAnchors(stack, schema),
+            recursiveAnchor: NextRecursiveAnchor(stack, schema),
+            pendingResource: NextPendingResource(stack, schema),
+            lexicalBase: NextLexicalBase(stack, schema),
+            resourceBase: NextResourceBase(stack, schema),
+            useResourceBaseForReference: NextUseResourceBaseForReference(stack, schema),
+            referenceBase: NextReferenceBase(stack, schema),
+            lexicalSchema: NextLexicalSchema(stack, schema),
+            enteredResource: NextEnteredResource(stack, schema)
+        }
+        : stack;
+}

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

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

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

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

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

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

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

@@ -0,0 +1,60 @@
+// 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

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

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

@@ -0,0 +1,120 @@
+// deno-fmt-ignore-file
+import * as Schema from '../types/index.mjs';
+import * as Externals from './_externals.mjs';
+import * as Pathing from './_pathing.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 (Schema.IsPatternProperties(schema))
+        patterns.push(...G.Keys(schema.patternProperties));
+    if (Schema.IsProperties(schema))
+        patterns.push(...G.Keys(schema.properties).map(GetPropertyKeyAsPattern));
+    return G.IsEqual(patterns.length, 0) ? '(?!)' : `(${patterns.join('|')})`;
+}
+// ------------------------------------------------------------------
+// BuildAdditionalPropertiesFast
+//
+// 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 Schema.IsRequired(schema)
+        && Schema.IsProperties(schema)
+        && !Schema.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 = Externals.CreateVariable(UnicodeRegExp(GetPropertiesPattern(schema)));
+    const isSchema = BuildSchemaPushStack(stack, context, schema.additionalProperties, `${value}[${key}]`);
+    const isKey = E.Call(E.Member(regexp, 'test'), [key]);
+    const addKey = context.AddKey(key);
+    const guarded = context.UseUnevaluated() ? E.Or(isKey, E.And(isSchema, addKey)) : E.Or(isKey, isSchema);
+    const result = E.Every(E.Keys(value), E.Constant(0), [key, _index], guarded);
+    return result;
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildAdditionalProperties(stack, context, schema, value) {
+    if (IsAdditionalPropertiesIgnored(context, schema.additionalProperties))
+        return E.Constant(true);
+    return CanAdditionalPropertiesFast(context, schema, value)
+        ? BuildAdditionalPropertiesFast(context, schema, value)
+        : BuildAdditionalPropertiesStandard(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckAdditionalProperties(stack, context, schema, value) {
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
+    const isAdditionalProperties = G.Every(G.Keys(value), 0, (key, _index) => {
+        return regexp.test(key) ||
+            (CheckSchemaPushStack(stack, context, schema.additionalProperties, value[key]) && context.AddKey(key));
+    });
+    return isAdditionalProperties;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value) {
+    const regexp = UnicodeRegExp(GetPropertiesPattern(schema));
+    const additionalProperties = [];
+    const isAdditionalProperties = G.EveryAll(G.Keys(value), 0, (key, _index) => {
+        const nextSchemaPath = `${schemaPath}/additionalProperties`;
+        const nextInstancePath = `${instancePath}/${Pathing.EncodeFragment(key)}`;
+        const isAdditionalProperty = regexp.test(key) ||
+            (ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key));
+        if (!isAdditionalProperty)
+            additionalProperties.push(key);
+        return isAdditionalProperty;
+    });
+    return isAdditionalProperties ||
+        context.AddError('additionalProperties', schemaPath, instancePath, { additionalProperties });
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+// 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
+// ------------------------------------------------------------------
+function BuildContainsStandard(stack, context, schema, value) {
+    const [item, index] = [Unique(), Unique()];
+    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
+    const isSome = E.SomeAll(value, [item, index], E.And(BuildSchema(stack, context, schema.contains, item), context.AddIndex(index)));
+    return E.And(isLength, isSome);
+}
+function BuildContainsFast(stack, context, schema, value) {
+    const [item] = [Unique()];
+    const isLength = E.Not(E.IsEqual(E.Member(value, 'length'), E.Constant(0)));
+    const isSome = E.Some(value, [item, '_'], BuildSchema(stack, context, schema.contains, item));
+    return E.And(isLength, isSome);
+}
+export function BuildContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return E.Constant(true);
+    return context.UseUnevaluated()
+        ? BuildContainsStandard(stack, context, schema, value)
+        : BuildContainsFast(stack, context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckContains(stack, context, schema, value) {
+    if (!IsValid(schema))
+        return true;
+    return !G.IsEqual(value.length, 0) && G.SomeAll(value, (item, index) => {
+        return CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index);
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
+    return CheckContains(stack, context, schema, value) ||
+        context.AddError('contains', schemaPath, instancePath, { minContains: 1 });
+}

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

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