@wecode-ai/weibo-openclaw-plugin 1.0.0 → 1.0.2

package/node_modules/@sinclair/typebox/build/esm/value/transform/decode.mjs

@@ -0,0 +1,207 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
+import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
+import { Check } from '../check/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// thrown externally
+// prettier-ignore
+export class TransformDecodeCheckError extends TypeBoxError {
+    constructor(schema, value, error) {
+        super(`Unable to decode value as it does not match the expected schema`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+    }
+}
+// prettier-ignore
+export class TransformDecodeError extends TypeBoxError {
+    constructor(schema, path, value, error) {
+        super(error instanceof Error ? error.message : 'Unknown error');
+        this.schema = schema;
+        this.path = path;
+        this.value = value;
+        this.error = error;
+    }
+}
+// ------------------------------------------------------------------
+// Decode
+// ------------------------------------------------------------------
+// prettier-ignore
+function Default(schema, path, value) {
+    try {
+        return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
+    }
+    catch (error) {
+        throw new TransformDecodeError(schema, path, value, error);
+    }
+}
+// prettier-ignore
+function FromArray(schema, references, path, value) {
+    return (IsArray(value))
+        ? Default(schema, path, value.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value)))
+        : Default(schema, path, value);
+}
+// prettier-ignore
+function FromIntersect(schema, references, path, value) {
+    if (!IsObject(value) || IsValueType(value))
+        return Default(schema, path, value);
+    const knownEntries = KeyOfPropertyEntries(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
+    const knownProperties = { ...value };
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+        }
+    if (!IsTransform(schema.unevaluatedProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromImport(schema, references, path, value) {
+    const additional = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const result = Visit(target, [...references, ...additional], path, value);
+    return Default(schema, path, result);
+}
+function FromNot(schema, references, path, value) {
+    return Default(schema, path, Visit(schema.not, references, path, value));
+}
+// prettier-ignore
+function FromObject(schema, references, path, value) {
+    if (!IsObject(value))
+        return Default(schema, path, value);
+    const knownKeys = KeyOfPropertyKeys(schema);
+    const knownProperties = { ...value };
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // decode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
+    if (!IsSchema(schema.additionalProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromRecord(schema, references, path, value) {
+    if (!IsObject(value))
+        return Default(schema, path, value);
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const knownKeys = new RegExp(pattern);
+    const knownProperties = { ...value };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
+    if (!IsSchema(schema.additionalProperties)) {
+        return Default(schema, path, knownProperties);
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const unknownProperties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+        }
+    return Default(schema, path, unknownProperties);
+}
+// prettier-ignore
+function FromRef(schema, references, path, value) {
+    const target = Deref(schema, references);
+    return Default(schema, path, Visit(target, references, path, value));
+}
+// prettier-ignore
+function FromThis(schema, references, path, value) {
+    const target = Deref(schema, references);
+    return Default(schema, path, Visit(target, references, path, value));
+}
+// prettier-ignore
+function FromTuple(schema, references, path, value) {
+    return (IsArray(value) && IsArray(schema.items))
+        ? Default(schema, path, schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value[index])))
+        : Default(schema, path, value);
+}
+// prettier-ignore
+function FromUnion(schema, references, path, value) {
+    for (const subschema of schema.anyOf) {
+        if (!Check(subschema, references, value))
+            continue;
+        // note: ensure interior is decoded first
+        const decoded = Visit(subschema, references, path, value);
+        return Default(schema, path, decoded);
+    }
+    return Default(schema, path, value);
+}
+// prettier-ignore
+function Visit(schema, references, path, value) {
+    const references_ = Pushref(schema, references);
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        case 'Array':
+            return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
+        case 'Intersect':
+            return FromIntersect(schema_, references_, path, value);
+        case 'Not':
+            return FromNot(schema_, references_, path, value);
+        case 'Object':
+            return FromObject(schema_, references_, path, value);
+        case 'Record':
+            return FromRecord(schema_, references_, path, value);
+        case 'Ref':
+            return FromRef(schema_, references_, path, value);
+        case 'Symbol':
+            return Default(schema_, path, value);
+        case 'This':
+            return FromThis(schema_, references_, path, value);
+        case 'Tuple':
+            return FromTuple(schema_, references_, path, value);
+        case 'Union':
+            return FromUnion(schema_, references_, path, value);
+        default:
+            return Default(schema_, path, value);
+    }
+}
+/**
+ * `[Internal]` Decodes the value and returns the result. This function requires that
+ * the caller `Check` the value before use. Passing unchecked values may result in
+ * undefined behavior. Refer to the `Value.Decode()` for implementation details.
+ */
+export function TransformDecode(schema, references, value) {
+    return Visit(schema, references, '', value);
+}

package/node_modules/@sinclair/typebox/build/esm/value/transform/encode.d.mts

@@ -0,0 +1,23 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { ValueError } from '../../errors/index.mjs';
+import type { TSchema } from '../../type/schema/index.mjs';
+export declare class TransformEncodeCheckError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly value: unknown;
+    readonly error: ValueError;
+    constructor(schema: TSchema, value: unknown, error: ValueError);
+}
+export declare class TransformEncodeError extends TypeBoxError {
+    readonly schema: TSchema;
+    readonly path: string;
+    readonly value: unknown;
+    readonly error: Error;
+    constructor(schema: TSchema, path: string, value: unknown, error: Error);
+}
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
+export declare function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/node_modules/@sinclair/typebox/build/esm/value/transform/encode.mjs

@@ -0,0 +1,218 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
+import { Kind, TransformKind } from '../../type/symbols/index.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { KeyOfPropertyKeys, KeyOfPropertyEntries } from '../../type/keyof/index.mjs';
+import { Deref, Pushref } from '../deref/index.mjs';
+import { Check } from '../check/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { HasPropertyKey, IsObject, IsArray, IsValueType, IsUndefined as IsUndefinedValue } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema, IsUndefined } from '../../type/guard/kind.mjs';
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+// prettier-ignore
+export class TransformEncodeCheckError extends TypeBoxError {
+    constructor(schema, value, error) {
+        super(`The encoded value does not match the expected schema`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+    }
+}
+// prettier-ignore
+export class TransformEncodeError extends TypeBoxError {
+    constructor(schema, path, value, error) {
+        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
+        this.schema = schema;
+        this.path = path;
+        this.value = value;
+        this.error = error;
+    }
+}
+// ------------------------------------------------------------------
+// Encode
+// ------------------------------------------------------------------
+// prettier-ignore
+function Default(schema, path, value) {
+    try {
+        return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
+    }
+    catch (error) {
+        throw new TransformEncodeError(schema, path, value, error);
+    }
+}
+// prettier-ignore
+function FromArray(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    return IsArray(defaulted)
+        ? defaulted.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value))
+        : defaulted;
+}
+// prettier-ignore
+function FromImport(schema, references, path, value) {
+    const additional = globalThis.Object.values(schema.$defs);
+    const target = schema.$defs[schema.$ref];
+    const result = Default(schema, path, value);
+    return Visit(target, [...references, ...additional], path, result);
+}
+// prettier-ignore
+function FromIntersect(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsObject(value) || IsValueType(value))
+        return defaulted;
+    const knownEntries = KeyOfPropertyEntries(schema);
+    const knownKeys = knownEntries.map(entry => entry[0]);
+    const knownProperties = { ...defaulted };
+    for (const [knownKey, knownSchema] of knownEntries)
+        if (knownKey in knownProperties) {
+            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+        }
+    if (!IsTransform(schema.unevaluatedProperties)) {
+        return knownProperties;
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const unevaluatedProperties = schema.unevaluatedProperties;
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(unevaluatedProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
+}
+// prettier-ignore
+function FromNot(schema, references, path, value) {
+    return Default(schema.not, path, Default(schema, path, value));
+}
+// prettier-ignore
+function FromObject(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsObject(defaulted))
+        return defaulted;
+    const knownKeys = KeyOfPropertyKeys(schema);
+    const knownProperties = { ...defaulted };
+    for (const key of knownKeys) {
+        if (!HasPropertyKey(knownProperties, key))
+            continue;
+        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
+        // property policy, then we need to continue. This is a special case for optional property handling 
+        // where a transforms wrapped in a optional modifiers should not run.
+        if (IsUndefinedValue(knownProperties[key]) && (!IsUndefined(schema.properties[key]) ||
+            TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+            continue;
+        // encode property
+        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    }
+    if (!IsSchema(schema.additionalProperties)) {
+        return knownProperties;
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.includes(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
+}
+// prettier-ignore
+function FromRecord(schema, references, path, value) {
+    const defaulted = Default(schema, path, value);
+    if (!IsObject(value))
+        return defaulted;
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const knownKeys = new RegExp(pattern);
+    const knownProperties = { ...defaulted };
+    for (const key of Object.getOwnPropertyNames(value))
+        if (knownKeys.test(key)) {
+            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+        }
+    if (!IsSchema(schema.additionalProperties)) {
+        return knownProperties;
+    }
+    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+    const additionalProperties = schema.additionalProperties;
+    const properties = { ...knownProperties };
+    for (const key of unknownKeys)
+        if (!knownKeys.test(key)) {
+            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
+        }
+    return properties;
+}
+// prettier-ignore
+function FromRef(schema, references, path, value) {
+    const target = Deref(schema, references);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
+}
+// prettier-ignore
+function FromThis(schema, references, path, value) {
+    const target = Deref(schema, references);
+    const resolved = Visit(target, references, path, value);
+    return Default(schema, path, resolved);
+}
+// prettier-ignore
+function FromTuple(schema, references, path, value) {
+    const value1 = Default(schema, path, value);
+    return IsArray(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
+}
+// prettier-ignore
+function FromUnion(schema, references, path, value) {
+    // test value against union variants
+    for (const subschema of schema.anyOf) {
+        if (!Check(subschema, references, value))
+            continue;
+        const value1 = Visit(subschema, references, path, value);
+        return Default(schema, path, value1);
+    }
+    // test transformed value against union variants
+    for (const subschema of schema.anyOf) {
+        const value1 = Visit(subschema, references, path, value);
+        if (!Check(schema, references, value1))
+            continue;
+        return Default(schema, path, value1);
+    }
+    return Default(schema, path, value);
+}
+// prettier-ignore
+function Visit(schema, references, path, value) {
+    const references_ = Pushref(schema, references);
+    const schema_ = schema;
+    switch (schema[Kind]) {
+        case 'Array':
+            return FromArray(schema_, references_, path, value);
+        case 'Import':
+            return FromImport(schema_, references_, path, value);
+        case 'Intersect':
+            return FromIntersect(schema_, references_, path, value);
+        case 'Not':
+            return FromNot(schema_, references_, path, value);
+        case 'Object':
+            return FromObject(schema_, references_, path, value);
+        case 'Record':
+            return FromRecord(schema_, references_, path, value);
+        case 'Ref':
+            return FromRef(schema_, references_, path, value);
+        case 'This':
+            return FromThis(schema_, references_, path, value);
+        case 'Tuple':
+            return FromTuple(schema_, references_, path, value);
+        case 'Union':
+            return FromUnion(schema_, references_, path, value);
+        default:
+            return Default(schema_, path, value);
+    }
+}
+/**
+ * `[Internal]` Encodes the value and returns the result. This function expects the
+ * caller to pass a statically checked value. This function does not check the encoded
+ * result, meaning the result should be passed to `Check` before use. Refer to the
+ * `Value.Encode()` function for implementation details.
+ */
+export function TransformEncode(schema, references, value) {
+    return Visit(schema, references, '', value);
+}

package/node_modules/@sinclair/typebox/build/esm/value/transform/has.d.mts

@@ -0,0 +1,3 @@
+import type { TSchema } from '../../type/schema/index.mjs';
+/** Returns true if this schema contains a transform codec */
+export declare function HasTransform(schema: TSchema, references: TSchema[]): boolean;

package/node_modules/@sinclair/typebox/build/esm/value/transform/has.mjs

@@ -0,0 +1,129 @@
+import { Deref, Pushref } from '../deref/index.mjs';
+import { Kind } from '../../type/symbols/index.mjs';
+// ------------------------------------------------------------------
+// KindGuard
+// ------------------------------------------------------------------
+import { IsTransform, IsSchema } from '../../type/guard/kind.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsUndefined } from '../guard/index.mjs';
+// prettier-ignore
+function FromArray(schema, references) {
+    return IsTransform(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function FromAsyncIterator(schema, references) {
+    return IsTransform(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function FromConstructor(schema, references) {
+    return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function FromFunction(schema, references) {
+    return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function FromIntersect(schema, references) {
+    return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function FromImport(schema, references) {
+    const additional = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => [...result, schema.$defs[key]], []);
+    const target = schema.$defs[schema.$ref];
+    return IsTransform(schema) || Visit(target, [...additional, ...references]);
+}
+// prettier-ignore
+function FromIterator(schema, references) {
+    return IsTransform(schema) || Visit(schema.items, references);
+}
+// prettier-ignore
+function FromNot(schema, references) {
+    return IsTransform(schema) || Visit(schema.not, references);
+}
+// prettier-ignore
+function FromObject(schema, references) {
+    return (IsTransform(schema) ||
+        Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
+        (IsSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
+}
+// prettier-ignore
+function FromPromise(schema, references) {
+    return IsTransform(schema) || Visit(schema.item, references);
+}
+// prettier-ignore
+function FromRecord(schema, references) {
+    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+    const property = schema.patternProperties[pattern];
+    return IsTransform(schema) || Visit(property, references) || (IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties));
+}
+// prettier-ignore
+function FromRef(schema, references) {
+    if (IsTransform(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+// prettier-ignore
+function FromThis(schema, references) {
+    if (IsTransform(schema))
+        return true;
+    return Visit(Deref(schema, references), references);
+}
+// prettier-ignore
+function FromTuple(schema, references) {
+    return IsTransform(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)));
+}
+// prettier-ignore
+function FromUnion(schema, references) {
+    return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references));
+}
+// prettier-ignore
+function Visit(schema, references) {
+    const references_ = Pushref(schema, references);
+    const schema_ = schema;
+    if (schema.$id && visited.has(schema.$id))
+        return false;
+    if (schema.$id)
+        visited.add(schema.$id);
+    switch (schema[Kind]) {
+        case 'Array':
+            return FromArray(schema_, references_);
+        case 'AsyncIterator':
+            return FromAsyncIterator(schema_, references_);
+        case 'Constructor':
+            return FromConstructor(schema_, references_);
+        case 'Function':
+            return FromFunction(schema_, references_);
+        case 'Import':
+            return FromImport(schema_, references_);
+        case 'Intersect':
+            return FromIntersect(schema_, references_);
+        case 'Iterator':
+            return FromIterator(schema_, references_);
+        case 'Not':
+            return FromNot(schema_, references_);
+        case 'Object':
+            return FromObject(schema_, references_);
+        case 'Promise':
+            return FromPromise(schema_, references_);
+        case 'Record':
+            return FromRecord(schema_, references_);
+        case 'Ref':
+            return FromRef(schema_, references_);
+        case 'This':
+            return FromThis(schema_, references_);
+        case 'Tuple':
+            return FromTuple(schema_, references_);
+        case 'Union':
+            return FromUnion(schema_, references_);
+        default:
+            return IsTransform(schema);
+    }
+}
+const visited = new Set();
+/** Returns true if this schema contains a transform codec */
+export function HasTransform(schema, references) {
+    visited.clear();
+    return Visit(schema, references);
+}

package/node_modules/@sinclair/typebox/build/esm/value/transform/index.d.mts

@@ -0,0 +1,3 @@
+export * from './decode.mjs';
+export * from './encode.mjs';
+export * from './has.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/transform/index.mjs

@@ -0,0 +1,3 @@
+export * from './decode.mjs';
+export * from './encode.mjs';
+export * from './has.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/value/index.d.mts

@@ -0,0 +1 @@
+export * as Value from './value.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/value/index.mjs

@@ -0,0 +1 @@
+export * as Value from './value.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/value/value.d.mts

@@ -0,0 +1,16 @@
+export { Errors, ValueErrorIterator } from '../../errors/index.mjs';
+export { Assert } from '../assert/index.mjs';
+export { Cast } from '../cast/index.mjs';
+export { Check } from '../check/index.mjs';
+export { Clean } from '../clean/index.mjs';
+export { Clone } from '../clone/index.mjs';
+export { Convert } from '../convert/index.mjs';
+export { Create } from '../create/index.mjs';
+export { Decode } from '../decode/index.mjs';
+export { Default } from '../default/index.mjs';
+export { Diff, Patch, Edit } from '../delta/index.mjs';
+export { Encode } from '../encode/index.mjs';
+export { Equal } from '../equal/index.mjs';
+export { Hash } from '../hash/index.mjs';
+export { Mutate, type Mutable } from '../mutate/index.mjs';
+export { Parse } from '../parse/index.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/value/value.mjs

@@ -0,0 +1,16 @@
+export { Errors, ValueErrorIterator } from '../../errors/index.mjs';
+export { Assert } from '../assert/index.mjs';
+export { Cast } from '../cast/index.mjs';
+export { Check } from '../check/index.mjs';
+export { Clean } from '../clean/index.mjs';
+export { Clone } from '../clone/index.mjs';
+export { Convert } from '../convert/index.mjs';
+export { Create } from '../create/index.mjs';
+export { Decode } from '../decode/index.mjs';
+export { Default } from '../default/index.mjs';
+export { Diff, Patch, Edit } from '../delta/index.mjs';
+export { Encode } from '../encode/index.mjs';
+export { Equal } from '../equal/index.mjs';
+export { Hash } from '../hash/index.mjs';
+export { Mutate } from '../mutate/index.mjs';
+export { Parse } from '../parse/index.mjs';

package/node_modules/@sinclair/typebox/compiler/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/compiler/index.js",
+  "types": "../build/cjs/compiler/index.d.ts"
+}

package/node_modules/@sinclair/typebox/errors/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/errors/index.js",
+  "types": "../build/cjs/errors/index.d.ts"
+}

package/node_modules/@sinclair/typebox/license

@@ -0,0 +1,25 @@
+TypeBox
+
+Json Schema Type Builder with Static Type Resolution for TypeScript 
+
+The MIT License (MIT)
+
+Copyright (c) 2017-2026 Haydn Paterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.