@openclaw/tavily-plugin 0.0.0 → 2026.6.11-beta.2

package/node_modules/typebox/build/schema/types/multipleOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XMultipleOf<MultipleOf extends number | bigint = number | bigint> {
+    multipleOf: MultipleOf;
+}
+/**
+ * Returns true if the schema contains a valid multipleOf property
+ * @specification Json Schema 7
+ */
+export declare function IsMultipleOf(schema: XSchemaObject): schema is XMultipleOf;

package/node_modules/typebox/build/schema/types/multipleOf.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid multipleOf property
+ * @specification Json Schema 7
+ */
+export function IsMultipleOf(schema) {
+    return Guard.HasPropertyKey(schema, 'multipleOf')
+        && (Guard.IsNumber(schema.multipleOf) || Guard.IsBigInt(schema.multipleOf));
+}

package/node_modules/typebox/build/schema/types/not.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XNot<Not extends XSchema = XSchema> {
+    not: Not;
+}
+/**
+ * Returns true if the schema contains a valid not property
+ * @specification Json Schema 7
+ */
+export declare function IsNot(schema: XSchemaObject): schema is XNot;

package/node_modules/typebox/build/schema/types/not.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid not property
+ * @specification Json Schema 7
+ */
+export function IsNot(schema) {
+    return Guard.HasPropertyKey(schema, 'not')
+        && IsSchema(schema.not);
+}

package/node_modules/typebox/build/schema/types/oneOf.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XOneOf<OneOf extends XSchema[] = XSchema[]> {
+    oneOf: OneOf;
+}
+/**
+ * Returns true if the schema contains a valid oneOf property
+ * @specification Json Schema 7
+ */
+export declare function IsOneOf(schema: XSchemaObject): schema is XOneOf;

package/node_modules/typebox/build/schema/types/oneOf.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid oneOf property
+ * @specification Json Schema 7
+ */
+export function IsOneOf(schema) {
+    return Guard.HasPropertyKey(schema, 'oneOf')
+        && Guard.IsArray(schema.oneOf)
+        && schema.oneOf.every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/pattern.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XPattern<Pattern extends string | RegExp = string | RegExp> {
+    pattern: Pattern;
+}
+/**
+ * Returns true if the schema contains a valid pattern property
+ * @specification Json Schema 7
+ */
+export declare function IsPattern(schema: XSchemaObject): schema is XPattern;

package/node_modules/typebox/build/schema/types/pattern.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid pattern property
+ * @specification Json Schema 7
+ */
+export function IsPattern(schema) {
+    return Guard.HasPropertyKey(schema, 'pattern')
+        && (Guard.IsString(schema.pattern)
+            || schema.pattern instanceof RegExp);
+}

package/node_modules/typebox/build/schema/types/patternProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPatternProperties<PatternProperties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    patternProperties: PatternProperties;
+}
+/**
+ * Returns true if the schema contains a valid patternProperties property
+ * @specification Json Schema 7
+ */
+export declare function IsPatternProperties(schema: XSchemaObject): schema is XPatternProperties;

package/node_modules/typebox/build/schema/types/patternProperties.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid patternProperties property
+ * @specification Json Schema 7
+ */
+export function IsPatternProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'patternProperties')
+        && Guard.IsObject(schema.patternProperties)
+        && Object.values(schema.patternProperties).every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/prefixItems.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPrefixItems<PrefixItems extends XSchema[] = XSchema[]> {
+    prefixItems: PrefixItems;
+}
+/**
+ * Returns true if the schema contains a valid prefixItems property
+ */
+export declare function IsPrefixItems(schema: XSchemaObject): schema is XPrefixItems;

package/node_modules/typebox/build/schema/types/prefixItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid prefixItems property
+ */
+export function IsPrefixItems(schema) {
+    return Guard.HasPropertyKey(schema, 'prefixItems')
+        && Guard.IsArray(schema.prefixItems)
+        && schema.prefixItems.every(schema => IsSchema(schema));
+}

package/node_modules/typebox/build/schema/types/properties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XProperties<Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
+    properties: Properties;
+}
+/**
+ * Returns true if the schema contains a valid properties property
+ * @specification Json Schema 7
+ */
+export declare function IsProperties(schema: XSchemaObject): schema is XProperties;

package/node_modules/typebox/build/schema/types/properties.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid properties property
+ * @specification Json Schema 7
+ */
+export function IsProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'properties')
+        && Guard.IsObject(schema.properties)
+        && Object.values(schema.properties).every(value => IsSchema(value));
+}

package/node_modules/typebox/build/schema/types/propertyNames.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XPropertyNames<PropertyNames extends XSchema = XSchema> {
+    propertyNames: PropertyNames;
+}
+/**
+ * Returns true if the schema contains a valid propertyNames property
+ * @specification Json Schema 7
+ */
+export declare function IsPropertyNames(schema: XSchemaObject): schema is XPropertyNames;

package/node_modules/typebox/build/schema/types/propertyNames.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid propertyNames property
+ * @specification Json Schema 7
+ */
+export function IsPropertyNames(schema) {
+    return Guard.HasPropertyKey(schema, 'propertyNames')
+        && (Guard.IsObject(schema.propertyNames)
+            || IsSchema(schema.propertyNames));
+}

package/node_modules/typebox/build/schema/types/recursiveAnchor.d.mts

@@ -0,0 +1,12 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRecursiveAnchor<Anchor extends string = string> {
+    $recursiveAnchor: Anchor;
+}
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property
+ */
+export declare function IsRecursiveAnchor(schema: XSchemaObject): schema is XRecursiveAnchor;
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property that is true
+ */
+export declare function IsRecursiveAnchorTrue(schema: XSchemaObject): schema is XRecursiveAnchor;

package/node_modules/typebox/build/schema/types/recursiveAnchor.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property
+ */
+export function IsRecursiveAnchor(schema) {
+    return Guard.HasPropertyKey(schema, '$recursiveAnchor')
+        && Guard.IsBoolean(schema.$recursiveAnchor);
+}
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property that is true
+ */
+export function IsRecursiveAnchorTrue(schema) {
+    return IsRecursiveAnchor(schema)
+        && Guard.IsEqual(schema.$recursiveAnchor, true);
+}

package/node_modules/typebox/build/schema/types/recursiveRef.d.mts

@@ -0,0 +1,8 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRecursiveRef<Ref extends string = string> {
+    $recursiveRef: Ref;
+}
+/**
+ * Returns true if the schema contains a valid $recursiveRef property
+ */
+export declare function IsRecursiveRef(schema: XSchemaObject): schema is XRecursiveRef;

package/node_modules/typebox/build/schema/types/recursiveRef.mjs

@@ -0,0 +1,12 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $recursiveRef property
+ */
+export function IsRecursiveRef(schema) {
+    return Guard.HasPropertyKey(schema, '$recursiveRef')
+        && Guard.IsString(schema.$recursiveRef);
+}

package/node_modules/typebox/build/schema/types/ref.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRef<Ref extends string = string> {
+    $ref: Ref;
+}
+/**
+ * Returns true if the schema contains a valid $ref property
+ * @specification Json Schema 7
+ */
+export declare function IsRef(schema: XSchemaObject): schema is XRef;

package/node_modules/typebox/build/schema/types/ref.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid $ref property
+ * @specification Json Schema 7
+ */
+export function IsRef(schema) {
+    return Guard.HasPropertyKey(schema, '$ref')
+        && Guard.IsString(schema.$ref);
+}

package/node_modules/typebox/build/schema/types/required.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XRequired<Required extends string[] = string[]> {
+    required: Required;
+}
+/**
+ * Returns true if the schema contains a valid required property
+ * @specification Json Schema 7
+ */
+export declare function IsRequired(schema: XSchemaObject): schema is XRequired;

package/node_modules/typebox/build/schema/types/required.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid required property
+ * @specification Json Schema 7
+ */
+export function IsRequired(schema) {
+    return Guard.HasPropertyKey(schema, 'required')
+        && Guard.IsArray(schema.required)
+        && schema.required.every(value => Guard.IsString(value));
+}

package/node_modules/typebox/build/schema/types/schema.d.mts

@@ -0,0 +1,9 @@
+export type XSchemaObject = object;
+/** Returns true if this value is object like */
+export declare function IsSchemaObject(value: unknown): value is XSchemaObject;
+export type XSchemaBoolean = boolean;
+/** Returns true if this value is a boolean */
+export declare function IsBooleanSchema(value: unknown): value is XSchemaBoolean;
+export type XSchema = XSchemaObject | XSchemaBoolean;
+/** Returns true if this value is schema like */
+export declare function IsSchema(value: unknown): value is XSchema;

package/node_modules/typebox/build/schema/types/schema.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+/** Returns true if this value is object like */
+export function IsSchemaObject(value) {
+    return Guard.IsObject(value) && !Guard.IsArray(value);
+}
+/** Returns true if this value is a boolean */
+export function IsBooleanSchema(value) {
+    return Guard.IsBoolean(value);
+}
+/** Returns true if this value is schema like */
+export function IsSchema(value) {
+    return IsSchemaObject(value) || IsBooleanSchema(value);
+}

package/node_modules/typebox/build/schema/types/then.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XThen<Then extends XSchema = XSchema> {
+    then: Then;
+}
+/**
+ * Returns true if the schema contains a valid then property
+ * @specification Json Schema 7
+ */
+export declare function IsThen(schema: XSchemaObject): schema is XThen;

package/node_modules/typebox/build/schema/types/then.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid then property
+ * @specification Json Schema 7
+ */
+export function IsThen(schema) {
+    return Guard.HasPropertyKey(schema, 'then')
+        && IsSchema(schema.then);
+}

package/node_modules/typebox/build/schema/types/type.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XType<Type extends string | string[] = string | string[]> {
+    type: Type;
+}
+/**
+ * Returns true if the schema contains a valid type property
+ * @specification Json Schema 7
+ */
+export declare function IsType(schema: XSchemaObject): schema is XType;

package/node_modules/typebox/build/schema/types/type.mjs

@@ -0,0 +1,15 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid type property
+ * @specification Json Schema 7
+ */
+export function IsType(schema) {
+    return Guard.HasPropertyKey(schema, 'type')
+        && (Guard.IsString(schema.type)
+            || (Guard.IsArray(schema.type)
+                && schema.type.every(value => Guard.IsString(value))));
+}

package/node_modules/typebox/build/schema/types/unevaluatedItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XUnevaluatedItems<unevaluatedItems extends XSchema = XSchema> {
+    unevaluatedItems: XSchema;
+}
+/**
+ * Returns true if the schema contains a valid unevaluatedItems property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsUnevaluatedItems(schema: XSchemaObject): schema is XUnevaluatedItems;

package/node_modules/typebox/build/schema/types/unevaluatedItems.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid unevaluatedItems property
+ * @specification Json Schema 2019-09
+ */
+export function IsUnevaluatedItems(schema) {
+    return Guard.HasPropertyKey(schema, 'unevaluatedItems')
+        && IsSchema(schema.unevaluatedItems);
+}

package/node_modules/typebox/build/schema/types/unevaluatedProperties.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject, type XSchema } from './schema.mjs';
+export interface XUnevaluatedProperties<UnevaluatedProperties extends XSchema = XSchema> {
+    unevaluatedProperties: UnevaluatedProperties;
+}
+/**
+ * Returns true if the schema contains a valid unevaluatedProperties property
+ * @specification Json Schema 2019-09
+ */
+export declare function IsUnevaluatedProperties(schema: XSchemaObject): schema is XUnevaluatedProperties;

package/node_modules/typebox/build/schema/types/unevaluatedProperties.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid unevaluatedProperties property
+ * @specification Json Schema 2019-09
+ */
+export function IsUnevaluatedProperties(schema) {
+    return Guard.HasPropertyKey(schema, 'unevaluatedProperties')
+        && IsSchema(schema.unevaluatedProperties);
+}

package/node_modules/typebox/build/schema/types/uniqueItems.d.mts

@@ -0,0 +1,9 @@
+import { type XSchemaObject } from './schema.mjs';
+export interface XUniqueItems<UniqueItems extends boolean = boolean> {
+    uniqueItems: UniqueItems;
+}
+/**
+ * Returns true if the schema contains a valid uniqueItems property
+ * @specification Json Schema 7
+ */
+export declare function IsUniqueItems(schema: XSchemaObject): schema is XUniqueItems;

package/node_modules/typebox/build/schema/types/uniqueItems.mjs

@@ -0,0 +1,13 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/**
+ * Returns true if the schema contains a valid uniqueItems property
+ * @specification Json Schema 7
+ */
+export function IsUniqueItems(schema) {
+    return Guard.HasPropertyKey(schema, 'uniqueItems')
+        && Guard.IsBoolean(schema.uniqueItems);
+}

package/node_modules/typebox/build/system/arguments/arguments.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
+ * are parsed using argument length only.
+ */
+export declare function Match<Result>(args: unknown[], match: Record<number, (...args: unknown[]) => unknown>): Result;

package/node_modules/typebox/build/system/arguments/arguments.mjs

@@ -0,0 +1,9 @@
+/**
+ * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
+ * are parsed using argument length only.
+ */
+export function Match(args, match) {
+    return (match[args.length]?.(...args) ?? (() => {
+        throw Error('Invalid Arguments');
+    })());
+}

package/node_modules/typebox/build/system/arguments/index.d.mts

@@ -0,0 +1 @@
+export * as Arguments from './arguments.mjs';

package/node_modules/typebox/build/system/arguments/index.mjs

@@ -0,0 +1 @@
+export * as Arguments from './arguments.mjs';

package/node_modules/typebox/build/system/environment/environment.d.mts

@@ -0,0 +1 @@
+export * from './evaluate.mjs';

package/node_modules/typebox/build/system/environment/environment.mjs

@@ -0,0 +1 @@
+export * from './evaluate.mjs';

package/node_modules/typebox/build/system/environment/evaluate.d.mts

@@ -0,0 +1,9 @@
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export declare function CanEvaluate(): boolean;
+/**
+ * Evaluates code in the current environment. This function will throw if the
+ * environment Content-Security-Policy does not support `unsafe-eval`. Use the
+ * Environment.CanEvaluate() to determine if the environment supports Evaluate
+ * before calling this function.
+ */
+export declare function Evaluate(...args: string[]): globalThis.Function;

package/node_modules/typebox/build/system/environment/evaluate.mjs

@@ -0,0 +1,37 @@
+import { Settings } from '../settings/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+let supported = undefined;
+// ------------------------------------------------------------------
+// TryEvaluate
+// ------------------------------------------------------------------
+function TryEvaluate() {
+    try {
+        Evaluate('null')();
+        return true;
+    } // deno-coverage-ignore-start - unreachable in test-suite
+    catch {
+        return false;
+    }
+    // deno-coverage-ignore-stop
+}
+// ------------------------------------------------------------------
+// CanEvaluate
+// ------------------------------------------------------------------
+/** Returns true if the environment supports dynamic JavaScript evaluation */
+export function CanEvaluate() {
+    if (Guard.IsUndefined(supported))
+        supported = TryEvaluate();
+    return supported && Settings.Get().useAcceleration;
+}
+// ------------------------------------------------------------------
+// Evaluate
+// ------------------------------------------------------------------
+/**
+ * Evaluates code in the current environment. This function will throw if the
+ * environment Content-Security-Policy does not support `unsafe-eval`. Use the
+ * Environment.CanEvaluate() to determine if the environment supports Evaluate
+ * before calling this function.
+ */
+export function Evaluate(...args) {
+    return new (globalThis.Function)(...args);
+}

package/node_modules/typebox/build/system/environment/index.d.mts

@@ -0,0 +1 @@
+export * as Environment from './environment.mjs';

package/node_modules/typebox/build/system/environment/index.mjs

@@ -0,0 +1 @@
+export * as Environment from './environment.mjs';

package/node_modules/typebox/build/system/hashing/hash.d.mts

@@ -0,0 +1,4 @@
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export declare function HashCode(value: unknown): bigint;
+/** Generates a FNV1A-64 non cryptographic hash of the given value */
+export declare function Hash(value: unknown): string;