@dungle-scrubs/tallow 0.8.0

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/guard/value.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasPropertyKey = HasPropertyKey;
+exports.IsAsyncIterator = IsAsyncIterator;
+exports.IsArray = IsArray;
+exports.IsBigInt = IsBigInt;
+exports.IsBoolean = IsBoolean;
+exports.IsDate = IsDate;
+exports.IsFunction = IsFunction;
+exports.IsIterator = IsIterator;
+exports.IsNull = IsNull;
+exports.IsNumber = IsNumber;
+exports.IsObject = IsObject;
+exports.IsRegExp = IsRegExp;
+exports.IsString = IsString;
+exports.IsSymbol = IsSymbol;
+exports.IsUint8Array = IsUint8Array;
+exports.IsUndefined = IsUndefined;
+// --------------------------------------------------------------------------
+// PropertyKey
+// --------------------------------------------------------------------------
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+    return key in value;
+}
+// --------------------------------------------------------------------------
+// Object Instances
+// --------------------------------------------------------------------------
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an array */
+function IsArray(value) {
+    return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+    return typeof value === 'bigint';
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** Returns true if this value is a Date object */
+function IsDate(value) {
+    return value instanceof globalThis.Date;
+}
+/** Returns true if this value is a function */
+function IsFunction(value) {
+    return typeof value === 'function';
+}
+/** Returns true if this value is an iterator */
+function IsIterator(value) {
+    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+    return value === null;
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+    return typeof value === 'number';
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp(value) {
+    return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString(value) {
+    return typeof value === 'string';
+}
+/** Returns true if this value is symbol */
+function IsSymbol(value) {
+    return typeof value === 'symbol';
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array(value) {
+    return value instanceof globalThis.Uint8Array;
+}
+/** Returns true if this value is undefined */
+function IsUndefined(value) {
+    return value === undefined;
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/helpers/helpers.d.ts

@@ -0,0 +1,42 @@
+import type { TSchema } from '../schema/index';
+import type { TProperties } from '../object/index';
+import type { TNever } from '../never/index';
+export type TupleToIntersect<T extends any[]> = T extends [infer I] ? I : T extends [infer I, ...infer R] ? I & TupleToIntersect<R> : never;
+export type TupleToUnion<T extends any[]> = {
+    [K in keyof T]: T[K];
+}[number];
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
+export type UnionToTuple<U, Acc extends unknown[] = [], R = UnionLast<U>> = [U] extends [never] ? Acc : UnionToTuple<Exclude<U, R>, [Extract<U, R>, ...Acc]>;
+export type Trim<T> = T extends `${' '}${infer U}` ? Trim<U> : T extends `${infer U}${' '}` ? Trim<U> : T;
+export type Assert<T, E> = T extends E ? T : never;
+export type Evaluate<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+export type Ensure<T> = T extends infer U ? U : never;
+export type EmptyString = '';
+export type ZeroString = '0';
+type IncrementBase = {
+    m: '9';
+    t: '01';
+    '0': '1';
+    '1': '2';
+    '2': '3';
+    '3': '4';
+    '4': '5';
+    '5': '6';
+    '6': '7';
+    '7': '8';
+    '8': '9';
+    '9': '0';
+};
+type IncrementTake<T extends keyof IncrementBase> = IncrementBase[T];
+type IncrementStep<T extends string> = T extends IncrementBase['m'] ? IncrementBase['t'] : T extends `${infer L extends keyof IncrementBase}${infer R}` ? L extends IncrementBase['m'] ? `${IncrementTake<L>}${IncrementStep<R>}` : `${IncrementTake<L>}${R}` : never;
+type IncrementReverse<T extends string> = T extends `${infer L}${infer R}` ? `${IncrementReverse<R>}${L}` : T;
+export type TIncrement<T extends string> = IncrementReverse<IncrementStep<IncrementReverse<T>>>;
+/** Increments the given string value + 1 */
+export declare function Increment<T extends string>(T: T): TIncrement<T>;
+export type AssertProperties<T> = T extends TProperties ? T : TProperties;
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/helpers/helpers.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Increment = Increment;
+/** Increments the given string value + 1 */
+function Increment(T) {
+    return (parseInt(T) + 1).toString();
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/helpers/index.d.ts

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

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helpers"), exports);

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/index.d.ts

@@ -0,0 +1,71 @@
+export * from './any/index';
+export * from './argument/index';
+export * from './array/index';
+export * from './async-iterator/index';
+export * from './awaited/index';
+export * from './bigint/index';
+export * from './boolean/index';
+export * from './clone/index';
+export * from './composite/index';
+export * from './const/index';
+export * from './constructor/index';
+export * from './constructor-parameters/index';
+export * from './date/index';
+export * from './discard/index';
+export * from './enum/index';
+export * from './error/index';
+export * from './exclude/index';
+export * from './extends/index';
+export * from './extract/index';
+export * from './function/index';
+export * from './guard/index';
+export * from './helpers/index';
+export * from './indexed/index';
+export * from './instance-type/index';
+export * from './instantiate/index';
+export * from './integer/index';
+export * from './intersect/index';
+export * from './intrinsic/index';
+export * from './iterator/index';
+export * from './keyof/index';
+export * from './literal/index';
+export * from './mapped/index';
+export * from './module/index';
+export * from './never/index';
+export * from './not/index';
+export * from './null/index';
+export * from './number/index';
+export * from './object/index';
+export * from './omit/index';
+export * from './optional/index';
+export * from './parameters/index';
+export * from './partial/index';
+export * from './patterns/index';
+export * from './pick/index';
+export * from './promise/index';
+export * from './readonly/index';
+export * from './readonly-optional/index';
+export * from './record/index';
+export * from './recursive/index';
+export * from './ref/index';
+export * from './regexp/index';
+export * from './registry/index';
+export * from './required/index';
+export * from './rest/index';
+export * from './return-type/index';
+export * from './schema/index';
+export * from './sets/index';
+export * from './static/index';
+export * from './string/index';
+export * from './symbol/index';
+export * from './symbols/index';
+export * from './template-literal/index';
+export * from './transform/index';
+export * from './tuple/index';
+export * from './type/index';
+export * from './uint8array/index';
+export * from './undefined/index';
+export * from './union/index';
+export * from './unknown/index';
+export * from './unsafe/index';
+export * from './void/index';

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/index.js

@@ -0,0 +1,88 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./any/index"), exports);
+__exportStar(require("./argument/index"), exports);
+__exportStar(require("./array/index"), exports);
+__exportStar(require("./async-iterator/index"), exports);
+__exportStar(require("./awaited/index"), exports);
+__exportStar(require("./bigint/index"), exports);
+__exportStar(require("./boolean/index"), exports);
+__exportStar(require("./clone/index"), exports);
+__exportStar(require("./composite/index"), exports);
+__exportStar(require("./const/index"), exports);
+__exportStar(require("./constructor/index"), exports);
+__exportStar(require("./constructor-parameters/index"), exports);
+__exportStar(require("./date/index"), exports);
+__exportStar(require("./discard/index"), exports);
+__exportStar(require("./enum/index"), exports);
+__exportStar(require("./error/index"), exports);
+__exportStar(require("./exclude/index"), exports);
+__exportStar(require("./extends/index"), exports);
+__exportStar(require("./extract/index"), exports);
+__exportStar(require("./function/index"), exports);
+__exportStar(require("./guard/index"), exports);
+__exportStar(require("./helpers/index"), exports);
+__exportStar(require("./indexed/index"), exports);
+__exportStar(require("./instance-type/index"), exports);
+__exportStar(require("./instantiate/index"), exports);
+__exportStar(require("./integer/index"), exports);
+__exportStar(require("./intersect/index"), exports);
+__exportStar(require("./intrinsic/index"), exports);
+__exportStar(require("./iterator/index"), exports);
+__exportStar(require("./keyof/index"), exports);
+__exportStar(require("./literal/index"), exports);
+__exportStar(require("./mapped/index"), exports);
+__exportStar(require("./module/index"), exports);
+__exportStar(require("./never/index"), exports);
+__exportStar(require("./not/index"), exports);
+__exportStar(require("./null/index"), exports);
+__exportStar(require("./number/index"), exports);
+__exportStar(require("./object/index"), exports);
+__exportStar(require("./omit/index"), exports);
+__exportStar(require("./optional/index"), exports);
+__exportStar(require("./parameters/index"), exports);
+__exportStar(require("./partial/index"), exports);
+__exportStar(require("./patterns/index"), exports);
+__exportStar(require("./pick/index"), exports);
+__exportStar(require("./promise/index"), exports);
+__exportStar(require("./readonly/index"), exports);
+__exportStar(require("./readonly-optional/index"), exports);
+__exportStar(require("./record/index"), exports);
+__exportStar(require("./recursive/index"), exports);
+__exportStar(require("./ref/index"), exports);
+__exportStar(require("./regexp/index"), exports);
+__exportStar(require("./registry/index"), exports);
+__exportStar(require("./required/index"), exports);
+__exportStar(require("./rest/index"), exports);
+__exportStar(require("./return-type/index"), exports);
+__exportStar(require("./schema/index"), exports);
+__exportStar(require("./sets/index"), exports);
+__exportStar(require("./static/index"), exports);
+__exportStar(require("./string/index"), exports);
+__exportStar(require("./symbol/index"), exports);
+__exportStar(require("./symbols/index"), exports);
+__exportStar(require("./template-literal/index"), exports);
+__exportStar(require("./transform/index"), exports);
+__exportStar(require("./tuple/index"), exports);
+__exportStar(require("./type/index"), exports);
+__exportStar(require("./uint8array/index"), exports);
+__exportStar(require("./undefined/index"), exports);
+__exportStar(require("./union/index"), exports);
+__exportStar(require("./unknown/index"), exports);
+__exportStar(require("./unsafe/index"), exports);
+__exportStar(require("./void/index"), exports);

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/index.d.ts

@@ -0,0 +1,4 @@
+export * from './indexed-from-mapped-key';
+export * from './indexed-from-mapped-result';
+export * from './indexed-property-keys';
+export * from './indexed';

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./indexed-from-mapped-key"), exports);
+__exportStar(require("./indexed-from-mapped-result"), exports);
+__exportStar(require("./indexed-property-keys"), exports);
+__exportStar(require("./indexed"), exports);

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-from-mapped-key.d.ts

@@ -0,0 +1,13 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Ensure, Evaluate } from '../helpers/index';
+import type { TProperties } from '../object/index';
+import { type TIndex } from './indexed';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+type TMappedIndexPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TIndex<Type, [Key]>;
+};
+type TMappedIndexPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TMappedIndexPropertyKeys<Type, Right, Result & TMappedIndexPropertyKey<Type, Left>> : Result);
+type TMappedIndexProperties<Type extends TSchema, MappedKey extends TMappedKey> = Evaluate<TMappedIndexPropertyKeys<Type, MappedKey['keys']>>;
+export type TIndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>> = (Ensure<TMappedResult<Properties>>);
+export declare function IndexFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TMappedIndexProperties<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-from-mapped-key.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexFromMappedKey = IndexFromMappedKey;
+const indexed_1 = require("./indexed");
+const index_1 = require("../mapped/index");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function MappedIndexPropertyKey(type, key, options) {
+    return { [key]: (0, indexed_1.Index)(type, [key], (0, value_1.Clone)(options)) };
+}
+// prettier-ignore
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((result, left) => {
+        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+    }, {});
+}
+// prettier-ignore
+function MappedIndexProperties(type, mappedKey, options) {
+    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+function IndexFromMappedKey(type, mappedKey, options) {
+    const properties = MappedIndexProperties(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TIndexPropertyKeys } from './indexed-property-keys';
+import { type TIndex } from './index';
+type TFromProperties<Type extends TSchema, Properties extends TProperties> = ({
+    [K2 in keyof Properties]: TIndex<Type, TIndexPropertyKeys<Properties[K2]>>;
+});
+type TFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult> = (TFromProperties<Type, MappedResult['properties']>);
+export type TIndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>> = (TMappedResult<Properties>);
+export declare function IndexFromMappedResult<Type extends TSchema, MappedResult extends TMappedResult, Properties extends TProperties = TFromMappedResult<Type, MappedResult>>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-from-mapped-result.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexFromMappedResult = IndexFromMappedResult;
+const index_1 = require("../mapped/index");
+const indexed_property_keys_1 = require("./indexed-property-keys");
+const index_2 = require("./index");
+// prettier-ignore
+function FromProperties(type, properties, options) {
+    const result = {};
+    for (const K2 of Object.getOwnPropertyNames(properties)) {
+        result[K2] = (0, index_2.Index)(type, (0, indexed_property_keys_1.IndexPropertyKeys)(properties[K2]), options);
+    }
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(type, mappedResult, options) {
+    return FromProperties(type, mappedResult.properties, options);
+}
+// prettier-ignore
+function IndexFromMappedResult(type, mappedResult, options) {
+    const properties = FromMappedResult(type, mappedResult, options);
+    return (0, index_1.MappedResult)(properties);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-property-keys.d.ts

@@ -0,0 +1,14 @@
+import { type TTemplateLiteralGenerate, type TTemplateLiteral } from '../template-literal/index';
+import type { TLiteral, TLiteralValue } from '../literal/index';
+import type { TInteger } from '../integer/index';
+import type { TNumber } from '../number/index';
+import type { TSchema } from '../schema/index';
+import type { TUnion } from '../union/index';
+type TFromTemplateLiteral<TemplateLiteral extends TTemplateLiteral, Keys extends string[] = TTemplateLiteralGenerate<TemplateLiteral>> = (Keys);
+type TFromUnion<Types extends TSchema[], Result extends string[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromUnion<Right, [...Result, ...TIndexPropertyKeys<Left>]> : Result);
+type TFromLiteral<LiteralValue extends TLiteralValue> = (LiteralValue extends PropertyKey ? [`${LiteralValue}`] : []);
+export type TIndexPropertyKeys<Type extends TSchema> = (Type extends TTemplateLiteral ? TFromTemplateLiteral<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? TFromLiteral<Value> : Type extends TNumber ? ['[number]'] : Type extends TInteger ? ['[number]'] : [
+]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+export declare function IndexPropertyKeys<Type extends TSchema>(type: Type): TIndexPropertyKeys<Type>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed-property-keys.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexPropertyKeys = IndexPropertyKeys;
+const index_1 = require("../template-literal/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function FromTemplateLiteral(templateLiteral) {
+    const keys = (0, index_1.TemplateLiteralGenerate)(templateLiteral);
+    return keys.map(key => key.toString());
+}
+// prettier-ignore
+function FromUnion(types) {
+    const result = [];
+    for (const type of types)
+        result.push(...IndexPropertyKeys(type));
+    return result;
+}
+// prettier-ignore
+function FromLiteral(literalValue) {
+    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
+    );
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+// prettier-ignore
+function IndexPropertyKeys(type) {
+    return [...new Set(((0, kind_1.IsTemplateLiteral)(type) ? FromTemplateLiteral(type) :
+            (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf) :
+                (0, kind_1.IsLiteral)(type) ? FromLiteral(type.const) :
+                    (0, kind_1.IsNumber)(type) ? ['[number]'] :
+                        (0, kind_1.IsInteger)(type) ? ['[number]'] :
+                            []))];
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed.d.ts

@@ -0,0 +1,52 @@
+import { type TSchema, SchemaOptions } from '../schema/index';
+import { type Assert } from '../helpers/index';
+import { type TComputed } from '../computed/index';
+import { type TNever } from '../never/index';
+import { type TArray } from '../array/index';
+import { type TIntersect } from '../intersect/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TUnion } from '../union/index';
+import { type TRecursive } from '../recursive/index';
+import { type TRef } from '../ref/index';
+import { type TTuple } from '../tuple/index';
+import { type TIntersectEvaluated } from '../intersect/index';
+import { type TUnionEvaluated } from '../union/index';
+import { type TIndexPropertyKeys } from './indexed-property-keys';
+import { type TIndexFromMappedKey } from './indexed-from-mapped-key';
+import { type TIndexFromMappedResult } from './indexed-from-mapped-result';
+type TFromRest<Types extends TSchema[], Key extends PropertyKey, Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<Right, Key, [...Result, Assert<TIndexFromPropertyKey<Left, Key>, TSchema>]> : Result);
+type TFromIntersectRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? TFromIntersectRest<Right, [...Result]> : TFromIntersectRest<Right, [...Result, Left]> : Result);
+type TFromIntersect<Types extends TSchema[], Key extends PropertyKey> = (TIntersectEvaluated<TFromIntersectRest<TFromRest<Types, Key>>>);
+type TFromUnionRest<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TNever ? [] : TFromUnionRest<Right, [Left, ...Result]> : Result;
+type TFromUnion<Types extends TSchema[], Key extends PropertyKey> = (TUnionEvaluated<TFromUnionRest<TFromRest<Types, Key>>>);
+type TFromTuple<Types extends TSchema[], Key extends PropertyKey> = (Key extends keyof Types ? Types[Key] : Key extends '[number]' ? TUnionEvaluated<Types> : TNever);
+type TFromArray<Type extends TSchema, Key extends PropertyKey> = (Key extends '[number]' ? Type : TNever);
+type AssertPropertyKey<T> = Assert<T, string | number>;
+type TFromProperty<Properties extends TProperties, Key extends PropertyKey> = (Key extends keyof Properties ? Properties[Key] : `${AssertPropertyKey<Key>}` extends `${AssertPropertyKey<keyof Properties>}` ? Properties[AssertPropertyKey<Key>] : TNever);
+export type TIndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = (Type extends TRecursive<infer Type extends TSchema> ? TIndexFromPropertyKey<Type, Key> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<Types, Key> : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<Types, Key> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<Types, Key> : Type extends TArray<infer Type extends TSchema> ? TFromArray<Type, Key> : Type extends TObject<infer Properties extends TProperties> ? TFromProperty<Properties, Key> : TNever);
+export declare function IndexFromPropertyKey<Type extends TSchema, Key extends PropertyKey>(type: Type, propertyKey: Key): TIndexFromPropertyKey<Type, Key>;
+export type TIndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (PropertyKeys extends [infer Left extends PropertyKey, ...infer Right extends PropertyKey[]] ? TIndexFromPropertyKeys<Type, Right, [...Result, Assert<TIndexFromPropertyKey<Type, Left>, TSchema>]> : Result);
+export declare function IndexFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): TIndexFromPropertyKeys<Type, PropertyKeys>;
+type FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (TUnionEvaluated<TIndexFromPropertyKeys<Type, PropertyKeys>>);
+declare function FromSchema<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: [...PropertyKeys]): FromSchema<Type, PropertyKeys>;
+export type TIndexFromComputed<Type extends TSchema, Key extends TSchema> = (TComputed<'Index', [Type, Key]>);
+export declare function IndexFromComputed<Type extends TSchema, Key extends TSchema>(type: Type, key: Key): TIndexFromComputed<Type, Key>;
+export type TIndex<Type extends TSchema, PropertyKeys extends PropertyKey[]> = (FromSchema<Type, PropertyKeys>);
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TRef, Key extends TRef>(type: Type, key: Key, options?: SchemaOptions): TIndexFromComputed<Type, Key>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedResult extends TMappedResult>(type: Type, mappedResult: MappedResult, options?: SchemaOptions): TIndexFromMappedResult<Type, MappedResult>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, MappedKey extends TMappedKey>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TIndexFromMappedKey<Type, MappedKey>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, Key extends TSchema, PropertyKeys extends PropertyKey[] = TIndexPropertyKeys<Key>>(T: Type, K: Key, options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+/** `[Json]` Returns an Indexed property type for the given keys */
+export declare function Index<Type extends TSchema, PropertyKeys extends PropertyKey[]>(type: Type, propertyKeys: readonly [...PropertyKeys], options?: SchemaOptions): TIndex<Type, PropertyKeys>;
+export {};

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/indexed/indexed.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexFromPropertyKey = IndexFromPropertyKey;
+exports.IndexFromPropertyKeys = IndexFromPropertyKeys;
+exports.IndexFromComputed = IndexFromComputed;
+exports.Index = Index;
+const type_1 = require("../create/type");
+const index_1 = require("../error/index");
+const index_2 = require("../computed/index");
+const index_3 = require("../never/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const indexed_property_keys_1 = require("./indexed-property-keys");
+const indexed_from_mapped_key_1 = require("./indexed-from-mapped-key");
+const indexed_from_mapped_result_1 = require("./indexed-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+// prettier-ignore
+function FromRest(types, key) {
+    return types.map(type => IndexFromPropertyKey(type, key));
+}
+// prettier-ignore
+function FromIntersectRest(types) {
+    return types.filter(type => !(0, kind_1.IsNever)(type));
+}
+// prettier-ignore
+function FromIntersect(types, key) {
+    return ((0, index_4.IntersectEvaluated)(FromIntersectRest(FromRest(types, key))));
+}
+// prettier-ignore
+function FromUnionRest(types) {
+    return (types.some(L => (0, kind_1.IsNever)(L))
+        ? []
+        : types);
+}
+// prettier-ignore
+function FromUnion(types, key) {
+    return ((0, index_5.UnionEvaluated)(FromUnionRest(FromRest(types, key))));
+}
+// prettier-ignore
+function FromTuple(types, key) {
+    return (key in types ? types[key] :
+        key === '[number]' ? (0, index_5.UnionEvaluated)(types) :
+            (0, index_3.Never)());
+}
+// prettier-ignore
+function FromArray(type, key) {
+    return (key === '[number]'
+        ? type
+        : (0, index_3.Never)());
+}
+// prettier-ignore
+function FromProperty(properties, propertyKey) {
+    return (propertyKey in properties ? properties[propertyKey] : (0, index_3.Never)());
+}
+// prettier-ignore
+function IndexFromPropertyKey(type, propertyKey) {
+    return ((0, kind_1.IsIntersect)(type) ? FromIntersect(type.allOf, propertyKey) :
+        (0, kind_1.IsUnion)(type) ? FromUnion(type.anyOf, propertyKey) :
+            (0, kind_1.IsTuple)(type) ? FromTuple(type.items ?? [], propertyKey) :
+                (0, kind_1.IsArray)(type) ? FromArray(type.items, propertyKey) :
+                    (0, kind_1.IsObject)(type) ? FromProperty(type.properties, propertyKey) :
+                        (0, index_3.Never)());
+}
+// prettier-ignore
+function IndexFromPropertyKeys(type, propertyKeys) {
+    return propertyKeys.map(propertyKey => IndexFromPropertyKey(type, propertyKey));
+}
+// prettier-ignore
+function FromSchema(type, propertyKeys) {
+    return ((0, index_5.UnionEvaluated)(IndexFromPropertyKeys(type, propertyKeys)));
+}
+// prettier-ignore
+function IndexFromComputed(type, key) {
+    return (0, index_2.Computed)('Index', [type, key]);
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+function Index(type, key, options) {
+    // computed-type
+    if ((0, kind_1.IsRef)(type) || (0, kind_1.IsRef)(key)) {
+        const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+        if (!(0, kind_1.IsSchema)(type) || !(0, kind_1.IsSchema)(key))
+            throw new index_1.TypeBoxError(error);
+        return (0, index_2.Computed)('Index', [type, key]);
+    }
+    // mapped-types
+    if ((0, kind_1.IsMappedResult)(key))
+        return (0, indexed_from_mapped_result_1.IndexFromMappedResult)(type, key, options);
+    if ((0, kind_1.IsMappedKey)(key))
+        return (0, indexed_from_mapped_key_1.IndexFromMappedKey)(type, key, options);
+    // prettier-ignore
+    return (0, type_1.CreateType)((0, kind_1.IsSchema)(key)
+        ? FromSchema(type, (0, indexed_property_keys_1.IndexPropertyKeys)(key))
+        : FromSchema(type, key), options);
+}

package/extensions/lsp/node_modules/@sinclair/typebox/build/cjs/type/instance-type/index.d.ts

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