@dungle-scrubs/tallow 0.8.0

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/array/array.d.mts

@@ -0,0 +1,28 @@
+import { Ensure } from '../helpers/index.mjs';
+import type { SchemaOptions, TSchema } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface ArrayOptions extends SchemaOptions {
+    /** The minimum number of items in this array */
+    minItems?: number;
+    /** The maximum number of items in this array */
+    maxItems?: number;
+    /** Should this schema contain unique items */
+    uniqueItems?: boolean;
+    /** A schema for which some elements should match */
+    contains?: TSchema;
+    /** A minimum number of contains schema matches */
+    minContains?: number;
+    /** A maximum number of contains schema matches */
+    maxContains?: number;
+}
+type ArrayStatic<T extends TSchema, P extends unknown[]> = Ensure<Static<T, P>[]>;
+export interface TArray<T extends TSchema = TSchema> extends TSchema, ArrayOptions {
+    [Kind]: 'Array';
+    static: ArrayStatic<T, this['params']>;
+    type: 'array';
+    items: T;
+}
+/** `[Json]` Creates an Array type */
+export declare function Array<Type extends TSchema>(items: Type, options?: ArrayOptions): TArray<Type>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/array/array.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates an Array type */
+export function Array(items, options) {
+    return CreateType({ [Kind]: 'Array', type: 'array', items }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/array/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/array/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.d.mts

@@ -0,0 +1,11 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TAsyncIterator<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'AsyncIterator';
+    static: AsyncIterableIterator<Static<T, this['params']>>;
+    type: 'AsyncIterator';
+    items: T;
+}
+/** `[JavaScript]` Creates a AsyncIterator type */
+export declare function AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/type.mjs';
+/** `[JavaScript]` Creates a AsyncIterator type */
+export function AsyncIterator(items, options) {
+    return CreateType({ [Kind]: 'AsyncIterator', type: 'AsyncIterator', items }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.d.mts

@@ -0,0 +1,14 @@
+import { Ensure } from '../helpers/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TPromise } from '../promise/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<(TComputed<'Awaited', [TComputed<Target, Parameters>]>)>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Awaited', [TRef<Ref>]>>;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, [...Result, TAwaited<Left>]> : Result);
+export type TAwaited<Type extends TSchema> = (Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TPromise<infer Type extends TSchema> ? TAwaited<Type> : Type);
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export declare function Awaited<T extends TSchema>(type: T, options?: SchemaOptions): TAwaited<T>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs

@@ -0,0 +1,37 @@
+import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Ref } from '../ref/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsPromise, IsRef, IsComputed } from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Awaited', [Computed(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return Computed('Awaited', [Ref($ref)]);
+}
+// prettier-ignore
+function FromIntersect(types) {
+    return Intersect(FromRest(types));
+}
+// prettier-ignore
+function FromUnion(types) {
+    return Union(FromRest(types));
+}
+// prettier-ignore
+function FromPromise(type) {
+    return Awaited(type);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => Awaited(type));
+}
+/** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+export function Awaited(type, options) {
+    return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect(type.allOf) : IsUnion(type) ? FromUnion(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/awaited/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/awaited/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.d.mts

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface BigIntOptions extends SchemaOptions {
+    exclusiveMaximum?: bigint;
+    exclusiveMinimum?: bigint;
+    maximum?: bigint;
+    minimum?: bigint;
+    multipleOf?: bigint;
+}
+export interface TBigInt extends TSchema, BigIntOptions {
+    [Kind]: 'BigInt';
+    static: bigint;
+    type: 'bigint';
+}
+/** `[JavaScript]` Creates a BigInt type */
+export declare function BigInt(options?: BigIntOptions): TBigInt;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
+/** `[JavaScript]` Creates a BigInt type */
+export function BigInt(options) {
+    return CreateType({ [Kind]: 'BigInt', type: 'bigint' }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/bigint/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/bigint/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.d.mts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface TBoolean extends TSchema {
+    [Kind]: 'Boolean';
+    static: boolean;
+    type: 'boolean';
+}
+/** `[Json]` Creates a Boolean type */
+export declare function Boolean(options?: SchemaOptions): TBoolean;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/index.mjs';
+/** `[Json]` Creates a Boolean type */
+export function Boolean(options) {
+    return CreateType({ [Kind]: 'Boolean', type: 'boolean' }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/boolean/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/boolean/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/index.d.mts

@@ -0,0 +1,2 @@
+export * from './type.mjs';
+export * from './value.mjs';

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/index.mjs

@@ -0,0 +1,2 @@
+export * from './type.mjs';
+export * from './value.mjs';

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/type.d.mts

@@ -0,0 +1,5 @@
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
+/** Clones a Rest */
+export declare function CloneRest<T extends TSchema[]>(schemas: T): T;
+/** Clones a Type */
+export declare function CloneType<T extends TSchema>(schema: T, options?: SchemaOptions): T;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs

@@ -0,0 +1,9 @@
+import { Clone } from './value.mjs';
+/** Clones a Rest */
+export function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+/** Clones a Type */
+export function CloneType(schema, options) {
+    return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/value.d.mts

@@ -0,0 +1,2 @@
+/** Clones a value */
+export declare function Clone<T>(value: T): T;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs

@@ -0,0 +1,36 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ArrayType(value) {
+    return value.map((value) => Visit(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function RegExpType(value) {
+    return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Visit(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Visit(value[key]);
+    }
+    return result;
+}
+// prettier-ignore
+function Visit(value) {
+    return (ValueGuard.IsArray(value) ? ArrayType(value) :
+        ValueGuard.IsDate(value) ? DateType(value) :
+            ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                ValueGuard.IsRegExp(value) ? RegExpType(value) :
+                    ValueGuard.IsObject(value) ? ObjectType(value) :
+                        value);
+}
+/** Clones a value */
+export function Clone(value) {
+    return Visit(value);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/composite/composite.d.mts

@@ -0,0 +1,18 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { Evaluate } from '../helpers/index.mjs';
+import { type TIntersectEvaluated } from '../intersect/index.mjs';
+import { type TIndexFromPropertyKeys } from '../indexed/index.mjs';
+import { type TKeyOfPropertyKeys } from '../keyof/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
+import { TSetDistinct } from '../sets/index.mjs';
+type TCompositeKeys<T extends TSchema[], Acc extends PropertyKey[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TCompositeKeys<R, [...Acc, ...TKeyOfPropertyKeys<L>]> : TSetDistinct<Acc>);
+type TFilterNever<T extends TSchema[], Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? L extends TNever ? TFilterNever<R, [...Acc]> : TFilterNever<R, [...Acc, L]> : Acc);
+type TCompositeProperty<T extends TSchema[], K extends PropertyKey, Acc extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TCompositeProperty<R, K, [...Acc, ...TIndexFromPropertyKeys<L, [K]>]> : TFilterNever<Acc>);
+type TCompositeProperties<T extends TSchema[], K extends PropertyKey[], Acc = {}> = (K extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TCompositeProperties<T, R, Acc & {
+    [_ in L]: TIntersectEvaluated<TCompositeProperty<T, L>>;
+}> : Acc);
+type TCompositeEvaluate<T extends TSchema[], K extends PropertyKey[] = TCompositeKeys<T>, P extends TProperties = Evaluate<TCompositeProperties<T, K>>, R extends TSchema = TObject<P>> = R;
+export type TComposite<T extends TSchema[]> = TCompositeEvaluate<T>;
+export declare function Composite<T extends TSchema[]>(T: [...T], options?: ObjectOptions): TComposite<T>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs

@@ -0,0 +1,42 @@
+import { IntersectEvaluated } from '../intersect/index.mjs';
+import { IndexFromPropertyKeys } from '../indexed/index.mjs';
+import { KeyOfPropertyKeys } from '../keyof/index.mjs';
+import { Object } from '../object/index.mjs';
+import { SetDistinct } from '../sets/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsNever } from '../guard/kind.mjs';
+// prettier-ignore
+function CompositeKeys(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...KeyOfPropertyKeys(L));
+    return SetDistinct(Acc);
+}
+// prettier-ignore
+function FilterNever(T) {
+    return T.filter(L => !IsNever(L));
+}
+// prettier-ignore
+function CompositeProperty(T, K) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...IndexFromPropertyKeys(L, [K]));
+    return FilterNever(Acc);
+}
+// prettier-ignore
+function CompositeProperties(T, K) {
+    const Acc = {};
+    for (const L of K) {
+        Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+    }
+    return Acc;
+}
+// prettier-ignore
+export function Composite(T, options) {
+    const K = CompositeKeys(T);
+    const P = CompositeProperties(T, K);
+    const R = Object(P, options);
+    return R;
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/composite/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/composite/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/computed/computed.d.mts

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/symbols.mjs';
+export interface TComputed<Target extends string = string, Parameters extends TSchema[] = []> extends TSchema {
+    [Kind]: 'Computed';
+    target: Target;
+    parameters: Parameters;
+}
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export declare function Computed<Target extends string, Parameters extends TSchema[]>(target: Target, parameters: [...Parameters], options?: SchemaOptions): TComputed<Target, Parameters>;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/index.mjs';
+import { Kind } from '../symbols/symbols.mjs';
+/** `[Internal]` Creates a deferred computed type. This type is used exclusively in modules to defer resolution of computable types that contain interior references  */
+export function Computed(target, parameters, options) {
+    return CreateType({ [Kind]: 'Computed', target, parameters }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/computed/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/computed/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/const/const.d.mts

@@ -0,0 +1,27 @@
+import type { AssertRest, Evaluate } from '../helpers/index.mjs';
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { type TAny } from '../any/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TDate } from '../date/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNever } from '../never/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TObject } from '../object/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
+import { type TUint8Array } from '../uint8array/index.mjs';
+import { type TUnknown } from '../unknown/index.mjs';
+type TFromArray<T extends readonly unknown[]> = T extends readonly [infer L extends unknown, ...infer R extends unknown[]] ? [FromValue<L, false>, ...TFromArray<R>] : T;
+type TFromProperties<T extends Record<PropertyKey, unknown>> = {
+    -readonly [K in keyof T]: FromValue<T[K], false> extends infer R extends TSchema ? TReadonly<R> : TReadonly<TNever>;
+};
+type TConditionalReadonly<T extends TSchema, Root extends boolean> = Root extends true ? T : TReadonly<T>;
+type FromValue<T, Root extends boolean> = T extends AsyncIterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends IterableIterator<unknown> ? TConditionalReadonly<TAny, Root> : T extends readonly unknown[] ? TReadonly<TTuple<AssertRest<TFromArray<T>>>> : T extends Uint8Array ? TUint8Array : T extends Date ? TDate : T extends Record<PropertyKey, unknown> ? TConditionalReadonly<TObject<Evaluate<TFromProperties<T>>>, Root> : T extends Function ? TConditionalReadonly<TFunction<[], TUnknown>, Root> : T extends undefined ? TUndefined : T extends null ? TNull : T extends symbol ? TSymbol : T extends number ? TLiteral<T> : T extends boolean ? TLiteral<T> : T extends string ? TLiteral<T> : T extends bigint ? TBigInt : TObject<{}>;
+declare function FromValue<T, Root extends boolean>(value: T, root: Root): FromValue<T, Root>;
+export type TConst<T> = FromValue<T, true>;
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export declare function Const</* const (not supported in 4.0) */ T>(T: T, options?: SchemaOptions): TConst<T>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/const/const.mjs

@@ -0,0 +1,54 @@
+import { Any } from '../any/index.mjs';
+import { BigInt } from '../bigint/index.mjs';
+import { Date } from '../date/index.mjs';
+import { Function as FunctionType } from '../function/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Null } from '../null/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Symbol } from '../symbol/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Undefined } from '../undefined/index.mjs';
+import { Uint8Array } from '../uint8array/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { CreateType } from '../create/index.mjs';
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
+// prettier-ignore
+function FromArray(T) {
+    return T.map(L => FromValue(L, false));
+}
+// prettier-ignore
+function FromProperties(value) {
+    const Acc = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(value))
+        Acc[K] = Readonly(FromValue(value[K], false));
+    return Acc;
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : Readonly(T));
+}
+// prettier-ignore
+function FromValue(value, root) {
+    return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
+        IsIterator(value) ? ConditionalReadonly(Any(), root) :
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
+                IsUint8Array(value) ? Uint8Array() :
+                    IsDate(value) ? Date() :
+                        IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :
+                            IsFunction(value) ? ConditionalReadonly(FunctionType([], Unknown()), root) :
+                                IsUndefined(value) ? Undefined() :
+                                    IsNull(value) ? Null() :
+                                        IsSymbol(value) ? Symbol() :
+                                            IsBigInt(value) ? BigInt() :
+                                                IsNumber(value) ? Literal(value) :
+                                                    IsBoolean(value) ? Literal(value) :
+                                                        IsString(value) ? Literal(value) :
+                                                            Object({}));
+}
+/** `[JavaScript]` Creates a readonly const type from the given value. */
+export function Const(T, options) {
+    return CreateType(FromValue(T, true), options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/const/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/const/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.d.mts

@@ -0,0 +1,23 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Static } from '../static/index.mjs';
+import type { Ensure } from '../helpers/index.mjs';
+import type { TReadonlyOptional } from '../readonly-optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+type StaticReturnType<U extends TSchema, P extends unknown[]> = Static<U, P>;
+type StaticParameter<T extends TSchema, P extends unknown[]> = T extends TReadonlyOptional<T> ? [Readonly<Static<T, P>>?] : T extends TReadonly<T> ? [Readonly<Static<T, P>>] : T extends TOptional<T> ? [Static<T, P>?] : [
+    Static<T, P>
+];
+type StaticParameters<T extends TSchema[], P extends unknown[], Acc extends unknown[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? StaticParameters<R, P, [...Acc, ...StaticParameter<L, P>]> : Acc);
+type StaticConstructor<T extends TSchema[], U extends TSchema, P extends unknown[]> = Ensure<new (...param: StaticParameters<T, P>) => StaticReturnType<U, P>>;
+export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Constructor';
+    static: StaticConstructor<T, U, this['params']>;
+    type: 'Constructor';
+    parameters: T;
+    returns: U;
+}
+/** `[JavaScript]` Creates a Constructor type */
+export declare function Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a Constructor type */
+export function Constructor(parameters, returns, options) {
+    return CreateType({ [Kind]: 'Constructor', type: 'Constructor', parameters, returns }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.d.mts

@@ -0,0 +1,7 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import { type TTuple } from '../tuple/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TConstructorParameters<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _InstanceType extends TSchema> ? TTuple<Parameters> : TNever);
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+export declare function ConstructorParameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TConstructorParameters<Type>;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs

@@ -0,0 +1,7 @@
+import { Tuple } from '../tuple/index.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+export function ConstructorParameters(schema, options) {
+    return (KindGuard.IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options));
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/immutable.d.mts

@@ -0,0 +1,2 @@
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+export declare function Immutable(value: unknown): unknown;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs

@@ -0,0 +1,33 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ImmutableArray(value) {
+    return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+    return value;
+}
+function ImmutableUint8Array(value) {
+    return value;
+}
+function ImmutableRegExp(value) {
+    return value;
+}
+function ImmutableObject(value) {
+    const result = {};
+    for (const key of Object.getOwnPropertyNames(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+        result[key] = Immutable(value[key]);
+    }
+    return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+// prettier-ignore
+export function Immutable(value) {
+    return (ValueGuard.IsArray(value) ? ImmutableArray(value) :
+        ValueGuard.IsDate(value) ? ImmutableDate(value) :
+            ValueGuard.IsUint8Array(value) ? ImmutableUint8Array(value) :
+                ValueGuard.IsRegExp(value) ? ImmutableRegExp(value) :
+                    ValueGuard.IsObject(value) ? ImmutableObject(value) :
+                        value);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/index.mjs

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/type.d.mts

@@ -0,0 +1,3 @@
+import { SchemaOptions } from '../schema/schema.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export declare function CreateType(schema: Record<any, unknown>, options?: SchemaOptions): unknown;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/create/type.mjs

@@ -0,0 +1,15 @@
+import { TypeSystemPolicy } from '../../system/policy.mjs';
+import { Immutable } from './immutable.mjs';
+import { Clone } from '../clone/value.mjs';
+/** Creates TypeBox schematics using the configured InstanceMode */
+export function CreateType(schema, options) {
+    const result = options !== undefined ? { ...options, ...schema } : schema;
+    switch (TypeSystemPolicy.InstanceMode) {
+        case 'freeze':
+            return Immutable(result);
+        case 'clone':
+            return Clone(result);
+        default:
+            return result;
+    }
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/date/date.d.mts

@@ -0,0 +1,21 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface DateOptions extends SchemaOptions {
+    /** The exclusive maximum timestamp value */
+    exclusiveMaximumTimestamp?: number;
+    /** The exclusive minimum timestamp value */
+    exclusiveMinimumTimestamp?: number;
+    /** The maximum timestamp value */
+    maximumTimestamp?: number;
+    /** The minimum timestamp value */
+    minimumTimestamp?: number;
+    /** The multiple of timestamp value */
+    multipleOfTimestamp?: number;
+}
+export interface TDate extends TSchema, DateOptions {
+    [Kind]: 'Date';
+    static: Date;
+    type: 'date';
+}
+/** `[JavaScript]` Creates a Date type */
+export declare function Date(options?: DateOptions): TDate;

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/date/date.mjs

@@ -0,0 +1,6 @@
+import { Kind } from '../symbols/index.mjs';
+import { CreateType } from '../create/type.mjs';
+/** `[JavaScript]` Creates a Date type */
+export function Date(options) {
+    return CreateType({ [Kind]: 'Date', type: 'Date' }, options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/date/index.d.mts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/esm/type/date/index.mjs

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

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

@@ -0,0 +1,2 @@
+/** Discards property keys from the given value. This function returns a shallow Clone. */
+export declare function Discard(value: Record<PropertyKey, any>, keys: PropertyKey[]): Record<PropertyKey, any>;