@xfey/tenso 0.1.130

package/node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs

@@ -0,0 +1,8 @@
+function DiscardKey(value, key) {
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+/** Discards property keys from the given value. This function returns a shallow Clone. */
+export function Discard(value, keys) {
+    return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/discard/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/enum/enum.d.mts

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+export type TEnumRecord = Record<TEnumKey, TEnumValue>;
+export type TEnumValue = string | number;
+export type TEnumKey = string;
+export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
+    [Kind]: 'Union';
+    [Hint]: 'Enum';
+    static: T[keyof T];
+    anyOf: TLiteral<T[keyof T]>[];
+}
+/** `[Json]` Creates a Enum type */
+export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

package/node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs

@@ -0,0 +1,18 @@
+import { Literal } from '../literal/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { Union } from '../union/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsUndefined } from '../guard/value.mjs';
+/** `[Json]` Creates a Enum type */
+export function Enum(item, options) {
+    if (IsUndefined(item))
+        throw new Error('Enum undefined or empty');
+    const values1 = globalThis.Object.getOwnPropertyNames(item)
+        .filter((key) => isNaN(key))
+        .map((key) => item[key]);
+    const values2 = [...new Set(values1)];
+    const anyOf = values2.map((value) => Literal(value));
+    return Union(anyOf, { ...options, [Hint]: 'Enum' });
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/enum/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/error/error.d.mts

@@ -0,0 +1,4 @@
+/** The base Error type thrown for all TypeBox exceptions  */
+export declare class TypeBoxError extends Error {
+    constructor(message: string);
+}

package/node_modules/@sinclair/typebox/build/esm/type/error/error.mjs

@@ -0,0 +1,6 @@
+/** The base Error type thrown for all TypeBox exceptions  */
+export class TypeBoxError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

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

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

package/node_modules/@sinclair/typebox/build/esm/type/error/index.mjs

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

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TExclude } from './exclude.mjs';
+type TFromProperties<K extends TProperties, T extends TSchema> = ({
+    [K2 in keyof K]: TExclude<K[K2], T>;
+});
+type TFromMappedResult<R extends TMappedResult, T extends TSchema> = (TFromProperties<R['properties'], T>);
+export type TExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>> = (TMappedResult<P>);
+export declare function ExcludeFromMappedResult<R extends TMappedResult, T extends TSchema, P extends TProperties = TFromMappedResult<R, T>>(R: R, T: T): TMappedResult<P>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Exclude } from './exclude.mjs';
+// prettier-ignore
+function FromProperties(P, U) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Exclude(P[K2], U);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, T) {
+    return FromProperties(R.properties, T);
+}
+// prettier-ignore
+export function ExcludeFromMappedResult(R, T) {
+    const P = FromMappedResult(R, T);
+    return MappedResult(P);
+}

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.d.mts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index.mjs';
+import { TExclude } from './exclude.mjs';
+import { type TTemplateLiteral, type TTemplateLiteralToUnion } from '../template-literal/index.mjs';
+export type TExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema> = (TExclude<TTemplateLiteralToUnion<L>, R>);
+export declare function ExcludeFromTemplateLiteral<L extends TTemplateLiteral, R extends TSchema>(L: L, R: R): TExcludeFromTemplateLiteral<L, R>;

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs

@@ -0,0 +1,5 @@
+import { Exclude } from './exclude.mjs';
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+export function ExcludeFromTemplateLiteral(L, R) {
+    return Exclude(TemplateLiteralToUnion(L), R);
+}

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.d.mts

@@ -0,0 +1,21 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { UnionToTuple, AssertRest, AssertType } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TTemplateLiteral } from '../template-literal/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type Static } from '../static/index.mjs';
+import { type TUnionEvaluated } from '../union/index.mjs';
+import { type TExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+import { type TExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs';
+type TExcludeRest<L extends TSchema[], R extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof L]: Static<AssertType<L[K]>> extends Static<R> ? never : L[K];
+}[number]>> extends infer R extends TSchema[] ? TUnionEvaluated<R> : never;
+export type TExclude<L extends TSchema, R extends TSchema> = (L extends TUnion<infer S> ? TExcludeRest<S, R> : L extends R ? TNever : L);
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export declare function Exclude<L extends TMappedResult, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromMappedResult<L, R>;
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export declare function Exclude<L extends TTemplateLiteral, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExcludeFromTemplateLiteral<L, R>;
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
+export {};

package/node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs

@@ -0,0 +1,25 @@
+import { CreateType } from '../create/type.mjs';
+import { Union } from '../union/index.mjs';
+import { Never } from '../never/index.mjs';
+import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
+import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+import { ExcludeFromTemplateLiteral } from './exclude-from-template-literal.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
+function ExcludeRest(L, R) {
+    const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+    return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+export function Exclude(L, R, options = {}) {
+    // overloads
+    if (IsTemplateLiteral(L))
+        return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+    if (IsMappedResult(L))
+        return CreateType(ExcludeFromMappedResult(L, R), options);
+    // prettier-ignore
+    return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) :
+        ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}

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

@@ -0,0 +1,3 @@
+export * from './exclude-from-mapped-result.mjs';
+export * from './exclude-from-template-literal.mjs';
+export * from './exclude.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/exclude/index.mjs

@@ -0,0 +1,3 @@
+export * from './exclude-from-mapped-result.mjs';
+export * from './exclude-from-template-literal.mjs';
+export * from './exclude.mjs';

package/node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../schema/index.mjs';
+import { TypeBoxError } from '../error/index.mjs';
+export declare class ExtendsResolverError extends TypeBoxError {
+}
+export declare enum ExtendsResult {
+    Union = 0,
+    True = 1,
+    False = 2
+}
+export declare function ExtendsCheck(left: TSchema, right: TSchema): ExtendsResult;