first commit

node_modules/@types/cacheable-request/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/@types/cacheable-request/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/cacheable-request`
+
+# Summary
+This package contains type definitions for cacheable-request (https://github.com/lukechilds/cacheable-request#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cacheable-request.
+
+### Additional Details
+ * Last updated: Wed, 09 Nov 2022 16:32:53 GMT
+ * Dependencies: [@types/http-cache-semantics](https://npmjs.com/package/@types/http-cache-semantics), [@types/keyv](https://npmjs.com/package/@types/keyv), [@types/node](https://npmjs.com/package/@types/node), [@types/responselike](https://npmjs.com/package/@types/responselike)
+ * Global values: none
+
+# Credits
+These definitions were written by [BendingBender](https://github.com/BendingBender), and [Paul Melnikow](https://github.com/paulmelnikow).

node_modules/@types/cacheable-request/index.d.ts

@@ -0,0 +1,137 @@
+// Type definitions for cacheable-request 6.0
+// Project: https://github.com/lukechilds/cacheable-request#readme
+// Definitions by: BendingBender <https://github.com/BendingBender>
+//                 Paul Melnikow <https://github.com/paulmelnikow>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+/// <reference types="node" />
+
+import { request, RequestOptions, ClientRequest, ServerResponse } from 'http';
+import { URL } from 'url';
+import { EventEmitter } from 'events';
+import { Store } from 'keyv';
+import { Options as CacheSemanticsOptions } from 'http-cache-semantics';
+import ResponseLike = require('responselike');
+
+export = CacheableRequest;
+
+declare const CacheableRequest: CacheableRequest;
+
+type RequestFn = typeof request;
+
+interface CacheableRequest {
+    new (requestFn: RequestFn, storageAdapter?: string | CacheableRequest.StorageAdapter): (
+        opts: string | URL | (RequestOptions & CacheSemanticsOptions),
+        cb?: (response: ServerResponse | ResponseLike) => void
+    ) => CacheableRequest.Emitter;
+
+    RequestError: typeof RequestErrorCls;
+    CacheError: typeof CacheErrorCls;
+}
+
+declare namespace CacheableRequest {
+    type StorageAdapter = Store<any>;
+
+    interface Options {
+        /**
+         * If the cache should be used. Setting this to `false` will completely bypass the cache for the current request.
+         * @default true
+         */
+        cache?: boolean | undefined;
+
+        /**
+         * If set to `true` once a cached resource has expired it is deleted and will have to be re-requested.
+         *
+         * If set to `false`, after a cached resource's TTL expires it is kept in the cache and will be revalidated
+         * on the next request with `If-None-Match`/`If-Modified-Since` headers.
+         * @default false
+         */
+        strictTtl?: boolean | undefined;
+
+        /**
+         * Limits TTL. The `number` represents milliseconds.
+         * @default undefined
+         */
+        maxTtl?: number | undefined;
+
+        /**
+         * When set to `true`, if the DB connection fails we will automatically fallback to a network request.
+         * DB errors will still be emitted to notify you of the problem even though the request callback may succeed.
+         * @default false
+         */
+        automaticFailover?: boolean | undefined;
+
+        /**
+         * Forces refreshing the cache. If the response could be retrieved from the cache, it will perform a
+         * new request and override the cache instead.
+         * @default false
+         */
+        forceRefresh?: boolean | undefined;
+    }
+
+    interface Emitter extends EventEmitter {
+        addListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        addListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        addListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        on(event: 'request', listener: (request: ClientRequest) => void): this;
+        on(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        on(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        once(event: 'request', listener: (request: ClientRequest) => void): this;
+        once(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        once(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        prependListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        prependListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        prependListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        prependOnceListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        prependOnceListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        prependOnceListener(
+            event: 'error',
+            listener: (error: RequestError | CacheError) => void
+        ): this;
+        removeListener(event: 'request', listener: (request: ClientRequest) => void): this;
+        removeListener(
+            event: 'response',
+            listener: (response: ServerResponse | ResponseLike) => void
+        ): this;
+        removeListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        off(event: 'request', listener: (request: ClientRequest) => void): this;
+        off(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
+        off(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+        removeAllListeners(event?: 'request' | 'response' | 'error'): this;
+        listeners(event: 'request'): Array<(request: ClientRequest) => void>;
+        listeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>;
+        listeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+        rawListeners(event: 'request'): Array<(request: ClientRequest) => void>;
+        rawListeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>;
+        rawListeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+        emit(event: 'request', request: ClientRequest): boolean;
+        emit(event: 'response', response: ServerResponse | ResponseLike): boolean;
+        emit(event: 'error', error: RequestError | CacheError): boolean;
+        eventNames(): Array<'request' | 'response' | 'error'>;
+        listenerCount(type: 'request' | 'response' | 'error'): number;
+    }
+
+    type RequestError = RequestErrorCls;
+    type CacheError = CacheErrorCls;
+}
+
+declare class RequestErrorCls extends Error {
+    readonly name: 'RequestError';
+
+    constructor(error: Error);
+}
+declare class CacheErrorCls extends Error {
+    readonly name: 'CacheError';
+
+    constructor(error: Error);
+}

node_modules/@types/cacheable-request/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@types/cacheable-request",
+    "version": "6.0.3",
+    "description": "TypeScript definitions for cacheable-request",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/cacheable-request",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "BendingBender",
+            "url": "https://github.com/BendingBender",
+            "githubUsername": "BendingBender"
+        },
+        {
+            "name": "Paul Melnikow",
+            "url": "https://github.com/paulmelnikow",
+            "githubUsername": "paulmelnikow"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/cacheable-request"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/http-cache-semantics": "*",
+        "@types/keyv": "^3.1.4",
+        "@types/node": "*",
+        "@types/responselike": "^1.0.0"
+    },
+    "typesPublisherContentHash": "9345f1216c9d26f9046880c34f6329b2874405d68cf13d1f1f771fbb4d96549f",
+    "typeScriptVersion": "4.1"
+}

node_modules/@types/http-cache-semantics/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/@types/http-cache-semantics/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/http-cache-semantics`
+
+# Summary
+This package contains type definitions for http-cache-semantics (https://github.com/kornelski/http-cache-semantics#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics.
+
+### Additional Details
+ * Last updated: Tue, 07 Nov 2023 03:09:37 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [BendingBender](https://github.com/BendingBender).

node_modules/@types/http-cache-semantics/index.d.ts

@@ -0,0 +1,165 @@
+export = CachePolicy;
+
+declare class CachePolicy {
+    constructor(req: CachePolicy.Request, res: CachePolicy.Response, options?: CachePolicy.Options);
+
+    /**
+     * Returns `true` if the response can be stored in a cache.
+     * If it's `false` then you MUST NOT store either the request or the response.
+     */
+    storable(): boolean;
+
+    /**
+     * This is the most important method. Use this method to check whether the cached response is still fresh
+     * in the context of the new request.
+     *
+     * If it returns `true`, then the given `request` matches the original response this cache policy has been
+     * created with, and the response can be reused without contacting the server. Note that the old response
+     * can't be returned without being updated, see `responseHeaders()`.
+     *
+     * If it returns `false`, then the response may not be matching at all (e.g. it's for a different URL or method),
+     * or may require to be refreshed first (see `revalidationHeaders()`).
+     */
+    satisfiesWithoutRevalidation(newRequest: CachePolicy.Request): boolean;
+
+    /**
+     * Returns updated, filtered set of response headers to return to clients receiving the cached response.
+     * This function is necessary, because proxies MUST always remove hop-by-hop headers (such as `TE` and `Connection`)
+     * and update response's `Age` to avoid doubling cache time.
+     *
+     * @example
+     * cachedResponse.headers = cachePolicy.responseHeaders(cachedResponse);
+     */
+    responseHeaders(): CachePolicy.Headers;
+
+    /**
+     * Returns approximate time in milliseconds until the response becomes stale (i.e. not fresh).
+     *
+     * After that time (when `timeToLive() <= 0`) the response might not be usable without revalidation. However,
+     * there are exceptions, e.g. a client can explicitly allow stale responses, so always check with
+     * `satisfiesWithoutRevalidation()`.
+     */
+    timeToLive(): number;
+
+    /**
+     * Chances are you'll want to store the `CachePolicy` object along with the cached response.
+     * `obj = policy.toObject()` gives a plain JSON-serializable object.
+     */
+    toObject(): CachePolicy.CachePolicyObject;
+
+    /**
+     * `policy = CachePolicy.fromObject(obj)` creates an instance from object created by `toObject()`.
+     */
+    static fromObject(obj: CachePolicy.CachePolicyObject): CachePolicy;
+
+    /**
+     * Returns updated, filtered set of request headers to send to the origin server to check if the cached
+     * response can be reused. These headers allow the origin server to return status 304 indicating the
+     * response is still fresh. All headers unrelated to caching are passed through as-is.
+     *
+     * Use this method when updating cache from the origin server.
+     *
+     * @example
+     * updateRequest.headers = cachePolicy.revalidationHeaders(updateRequest);
+     */
+    revalidationHeaders(newRequest: CachePolicy.Request): CachePolicy.Headers;
+
+    /**
+     * Use this method to update the cache after receiving a new response from the origin server.
+     */
+    revalidatedPolicy(
+        revalidationRequest: CachePolicy.Request,
+        revalidationResponse: CachePolicy.Response,
+    ): CachePolicy.RevalidationPolicy;
+}
+
+declare namespace CachePolicy {
+    interface Request {
+        url?: string | undefined;
+        method?: string | undefined;
+        headers: Headers;
+    }
+
+    interface Response {
+        status?: number | undefined;
+        headers: Headers;
+    }
+
+    interface Options {
+        /**
+         * If `true`, then the response is evaluated from a perspective of a shared cache (i.e. `private` is not
+         * cacheable and `s-maxage` is respected). If `false`, then the response is evaluated from a perspective
+         * of a single-user cache (i.e. `private` is cacheable and `s-maxage` is ignored).
+         * `true` is recommended for HTTP clients.
+         * @default true
+         */
+        shared?: boolean | undefined;
+        /**
+         * A fraction of response's age that is used as a fallback cache duration. The default is 0.1 (10%),
+         * e.g. if a file hasn't been modified for 100 days, it'll be cached for 100*0.1 = 10 days.
+         * @default 0.1
+         */
+        cacheHeuristic?: number | undefined;
+        /**
+         * A number of milliseconds to assume as the default time to cache responses with `Cache-Control: immutable`.
+         * Note that [per RFC](https://httpwg.org/specs/rfc8246.html#the-immutable-cache-control-extension)
+         * these can become stale, so `max-age` still overrides the default.
+         * @default 24*3600*1000 (24h)
+         */
+        immutableMinTimeToLive?: number | undefined;
+        /**
+         * If `true`, common anti-cache directives will be completely ignored if the non-standard `pre-check`
+         * and `post-check` directives are present. These two useless directives are most commonly found
+         * in bad StackOverflow answers and PHP's "session limiter" defaults.
+         * @default false
+         */
+        ignoreCargoCult?: boolean | undefined;
+        /**
+         * If `false`, then server's `Date` header won't be used as the base for `max-age`. This is against the RFC,
+         * but it's useful if you want to cache responses with very short `max-age`, but your local clock
+         * is not exactly in sync with the server's.
+         * @default true
+         */
+        trustServerDate?: boolean | undefined;
+    }
+
+    interface CachePolicyObject {
+        v: number;
+        t: number;
+        sh: boolean;
+        ch: number;
+        imm: number;
+        st: number;
+        resh: Headers;
+        rescc: { [key: string]: string };
+        m: string;
+        u?: string | undefined;
+        h?: string | undefined;
+        a: boolean;
+        reqh: Headers | null;
+        reqcc: { [key: string]: string };
+    }
+
+    interface Headers {
+        [header: string]: string | string[] | undefined;
+    }
+
+    interface RevalidationPolicy {
+        /**
+         * A new `CachePolicy` with HTTP headers updated from `revalidationResponse`. You can always replace
+         * the old cached `CachePolicy` with the new one.
+         */
+        policy: CachePolicy;
+        /**
+         * Boolean indicating whether the response body has changed.
+         *
+         * - If `false`, then a valid 304 Not Modified response has been received, and you can reuse the old
+         * cached response body.
+         * - If `true`, you should use new response's body (if present), or make another request to the origin
+         * server without any conditional headers (i.e. don't use `revalidationHeaders()` this time) to get
+         * the new resource.
+         */
+        modified: boolean;
+        matches: boolean;
+    }
+}

node_modules/@types/http-cache-semantics/package.json

@@ -0,0 +1,25 @@
+{
+    "name": "@types/http-cache-semantics",
+    "version": "4.0.4",
+    "description": "TypeScript definitions for http-cache-semantics",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/http-cache-semantics",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "BendingBender",
+            "githubUsername": "BendingBender",
+            "url": "https://github.com/BendingBender"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/http-cache-semantics"
+    },
+    "scripts": {},
+    "dependencies": {},
+    "typesPublisherContentHash": "6cf8e230d4a5ae72d31765a8facf404307c59791befc65343d177843c7bbae91",
+    "typeScriptVersion": "4.5"
+}

node_modules/@types/keyv/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/@types/keyv/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/keyv`
+
+# Summary
+This package contains type definitions for keyv (https://github.com/lukechilds/keyv).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/keyv.
+
+### Additional Details
+ * Last updated: Thu, 17 Mar 2022 05:31:42 GMT
+ * Dependencies: [@types/node](https://npmjs.com/package/@types/node)
+ * Global values: none
+
+# Credits
+These definitions were written by [AryloYeung](https://github.com/Arylo), and [BendingBender](https://github.com/BendingBender).

node_modules/@types/keyv/index.d.ts

@@ -0,0 +1,90 @@
+// Type definitions for keyv 3.1
+// Project: https://github.com/lukechilds/keyv
+// Definitions by: AryloYeung <https://github.com/Arylo>
+//                 BendingBender <https://github.com/BendingBender>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+
+type WithRequiredProperties<T, K extends keyof T> = T & Required<Pick<T, K>>;
+
+declare class Keyv<TValue = any, TOpts extends { [key: string]: any } = {}> extends EventEmitter {
+    /**
+     * `this.opts` is an object containing at least the properties listed
+     * below. However, `Keyv.Options` allows arbitrary properties as well.
+     * These properties can be specified as the second type parameter to `Keyv`.
+     */
+    opts: WithRequiredProperties<
+        Keyv.Options<TValue>,
+        'deserialize' | 'namespace' | 'serialize' | 'store' | 'uri'
+    > &
+        TOpts;
+
+    /**
+     * @param opts The options object is also passed through to the storage adapter. Check your storage adapter docs for any extra options.
+     */
+    constructor(opts?: Keyv.Options<TValue> & TOpts);
+    /**
+     * @param uri The connection string URI.
+     *
+     * Merged into the options object as options.uri.
+     * @param opts The options object is also passed through to the storage adapter. Check your storage adapter docs for any extra options.
+     */
+    constructor(uri?: string, opts?: Keyv.Options<TValue> & TOpts);
+
+    /** Returns the value. */
+    get<TRaw extends boolean = false>(key: string, options?: { raw?: TRaw }):
+      Promise<(TRaw extends false
+        ? TValue
+        : Keyv.DeserializedData<TValue>)  | undefined>;
+    /**
+     * Set a value.
+     *
+     * By default keys are persistent. You can set an expiry TTL in milliseconds.
+     */
+    set(key: string, value: TValue, ttl?: number): Promise<true>;
+    /**
+     * Deletes an entry.
+     *
+     * Returns `true` if the key existed, `false` if not.
+     */
+    delete(key: string): Promise<boolean>;
+    /** Delete all entries in the current namespace. */
+    clear(): Promise<void>;
+}
+
+declare namespace Keyv {
+    interface Options<TValue> {
+        /** Namespace for the current instance. */
+        namespace?: string | undefined;
+        /** A custom serialization function. */
+        serialize?: ((data: DeserializedData<TValue>) => string) | undefined;
+        /** A custom deserialization function. */
+        deserialize?: ((data: string) => DeserializedData<TValue> | undefined) | undefined;
+        /** The connection string URI. */
+        uri?: string | undefined;
+        /** The storage adapter instance to be used by Keyv. */
+        store?: Store<TValue> | undefined;
+        /** Default TTL. Can be overridden by specififying a TTL on `.set()`. */
+        ttl?: number | undefined;
+        /** Specify an adapter to use. e.g `'redis'` or `'mongodb'`. */
+        adapter?: 'redis' | 'mongodb' | 'mongo' | 'sqlite' | 'postgresql' | 'postgres' | 'mysql' | undefined;
+
+        [key: string]: any;
+    }
+
+    interface DeserializedData<TValue> {
+        value: TValue; expires: number | null;
+    }
+
+    interface Store<TValue> {
+        get(key: string): TValue | Promise<TValue | undefined> | undefined;
+        set(key: string, value: TValue, ttl?: number): any;
+        delete(key: string): boolean | Promise<boolean>;
+        clear(): void | Promise<void>;
+    }
+}
+
+export = Keyv;

node_modules/@types/keyv/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@types/keyv",
+    "version": "3.1.4",
+    "description": "TypeScript definitions for keyv",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/keyv",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "AryloYeung",
+            "url": "https://github.com/Arylo",
+            "githubUsername": "Arylo"
+        },
+        {
+            "name": "BendingBender",
+            "url": "https://github.com/BendingBender",
+            "githubUsername": "BendingBender"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/keyv"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "typesPublisherContentHash": "e83393e0860475d12e960cede22532e18e129cf659f31f2a0298a88cb5d02d36",
+    "typeScriptVersion": "3.9"
+}

node_modules/@types/lodash-es/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    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

node_modules/@types/lodash-es/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/lodash-es`
+
+# Summary
+This package contains type definitions for lodash-es (http://lodash.com/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/lodash-es.
+
+### Additional Details
+ * Last updated: Tue, 21 Nov 2023 16:07:37 GMT
+ * Dependencies: [@types/lodash](https://npmjs.com/package/@types/lodash)
+
+# Credits
+These definitions were written by [Stephen Lautier](https://github.com/stephenlautier), and [e-cloud](https://github.com/e-cloud).

node_modules/@types/lodash-es/add.d.ts

@@ -0,0 +1,2 @@
+import { add } from "lodash";
+export default add;

node_modules/@types/lodash-es/after.d.ts

@@ -0,0 +1,2 @@
+import { after } from "lodash";
+export default after;

node_modules/@types/lodash-es/array.d.ts

@@ -0,0 +1,67 @@
+import { default as chunk } from "./chunk";
+import { default as compact } from "./compact";
+import { default as concat } from "./concat";
+import { default as difference } from "./difference";
+import { default as differenceBy } from "./differenceBy";
+import { default as differenceWith } from "./differenceWith";
+import { default as drop } from "./drop";
+import { default as dropRight } from "./dropRight";
+import { default as dropRightWhile } from "./dropRightWhile";
+import { default as dropWhile } from "./dropWhile";
+import { default as fill } from "./fill";
+import { default as findIndex } from "./findIndex";
+import { default as findLastIndex } from "./findLastIndex";
+import { default as first } from "./first";
+import { default as flatten } from "./flatten";
+import { default as flattenDeep } from "./flattenDeep";
+import { default as flattenDepth } from "./flattenDepth";
+import { default as fromPairs } from "./fromPairs";
+import { default as head } from "./head";
+import { default as indexOf } from "./indexOf";
+import { default as initial } from "./initial";
+import { default as intersection } from "./intersection";
+import { default as intersectionBy } from "./intersectionBy";
+import { default as intersectionWith } from "./intersectionWith";
+import { default as join } from "./join";
+import { default as last } from "./last";
+import { default as lastIndexOf } from "./lastIndexOf";
+import { default as nth } from "./nth";
+import { default as pull } from "./pull";
+import { default as pullAll } from "./pullAll";
+import { default as pullAllBy } from "./pullAllBy";
+import { default as pullAllWith } from "./pullAllWith";
+import { default as pullAt } from "./pullAt";
+import { default as remove } from "./remove";
+import { default as reverse } from "./reverse";
+import { default as slice } from "./slice";
+import { default as sortedIndex } from "./sortedIndex";
+import { default as sortedIndexBy } from "./sortedIndexBy";
+import { default as sortedIndexOf } from "./sortedIndexOf";
+import { default as sortedLastIndex } from "./sortedLastIndex";
+import { default as sortedLastIndexBy } from "./sortedLastIndexBy";
+import { default as sortedLastIndexOf } from "./sortedLastIndexOf";
+import { default as sortedUniq } from "./sortedUniq";
+import { default as sortedUniqBy } from "./sortedUniqBy";
+import { default as tail } from "./tail";
+import { default as take } from "./take";
+import { default as takeRight } from "./takeRight";
+import { default as takeRightWhile } from "./takeRightWhile";
+import { default as takeWhile } from "./takeWhile";
+import { default as union } from "./union";
+import { default as unionBy } from "./unionBy";
+import { default as unionWith } from "./unionWith";
+import { default as uniq } from "./uniq";
+import { default as uniqBy } from "./uniqBy";
+import { default as uniqWith } from "./uniqWith";
+import { default as unzip } from "./unzip";
+import { default as unzipWith } from "./unzipWith";
+import { default as without } from "./without";
+import { default as xor } from "./xor";
+import { default as xorBy } from "./xorBy";
+import { default as xorWith } from "./xorWith";
+import { default as zip } from "./zip";
+import { default as zipObject } from "./zipObject";
+import { default as zipObjectDeep } from "./zipObjectDeep";
+import { default as zipWith } from "./zipWith";
+
+export { default } from "./array.default";

node_modules/@types/lodash-es/array.default.d.ts

@@ -0,0 +1,134 @@
+import chunk from "./chunk";
+import compact from "./compact";
+import concat from "./concat";
+import difference from "./difference";
+import differenceBy from "./differenceBy";
+import differenceWith from "./differenceWith";
+import drop from "./drop";
+import dropRight from "./dropRight";
+import dropRightWhile from "./dropRightWhile";
+import dropWhile from "./dropWhile";
+import fill from "./fill";
+import findIndex from "./findIndex";
+import findLastIndex from "./findLastIndex";
+import first from "./first";
+import flatten from "./flatten";
+import flattenDeep from "./flattenDeep";
+import flattenDepth from "./flattenDepth";
+import fromPairs from "./fromPairs";
+import head from "./head";
+import indexOf from "./indexOf";
+import initial from "./initial";
+import intersection from "./intersection";
+import intersectionBy from "./intersectionBy";
+import intersectionWith from "./intersectionWith";
+import join from "./join";
+import last from "./last";
+import lastIndexOf from "./lastIndexOf";
+import nth from "./nth";
+import pull from "./pull";
+import pullAll from "./pullAll";
+import pullAllBy from "./pullAllBy";
+import pullAllWith from "./pullAllWith";
+import pullAt from "./pullAt";
+import remove from "./remove";
+import reverse from "./reverse";
+import slice from "./slice";
+import sortedIndex from "./sortedIndex";
+import sortedIndexBy from "./sortedIndexBy";
+import sortedIndexOf from "./sortedIndexOf";
+import sortedLastIndex from "./sortedLastIndex";
+import sortedLastIndexBy from "./sortedLastIndexBy";
+import sortedLastIndexOf from "./sortedLastIndexOf";
+import sortedUniq from "./sortedUniq";
+import sortedUniqBy from "./sortedUniqBy";
+import tail from "./tail";
+import take from "./take";
+import takeRight from "./takeRight";
+import takeRightWhile from "./takeRightWhile";
+import takeWhile from "./takeWhile";
+import union from "./union";
+import unionBy from "./unionBy";
+import unionWith from "./unionWith";
+import uniq from "./uniq";
+import uniqBy from "./uniqBy";
+import uniqWith from "./uniqWith";
+import unzip from "./unzip";
+import unzipWith from "./unzipWith";
+import without from "./without";
+import xor from "./xor";
+import xorBy from "./xorBy";
+import xorWith from "./xorWith";
+import zip from "./zip";
+import zipObject from "./zipObject";
+import zipObjectDeep from "./zipObjectDeep";
+import zipWith from "./zipWith";
+
+declare const defaultExport: {
+    chunk: typeof chunk;
+    compact: typeof compact;
+    concat: typeof concat;
+    difference: typeof difference;
+    differenceBy: typeof differenceBy;
+    differenceWith: typeof differenceWith;
+    drop: typeof drop;
+    dropRight: typeof dropRight;
+    dropRightWhile: typeof dropRightWhile;
+    dropWhile: typeof dropWhile;
+    fill: typeof fill;
+    findIndex: typeof findIndex;
+    findLastIndex: typeof findLastIndex;
+    first: typeof first;
+    flatten: typeof flatten;
+    flattenDeep: typeof flattenDeep;
+    flattenDepth: typeof flattenDepth;
+    fromPairs: typeof fromPairs;
+    head: typeof head;
+    indexOf: typeof indexOf;
+    initial: typeof initial;
+    intersection: typeof intersection;
+    intersectionBy: typeof intersectionBy;
+    intersectionWith: typeof intersectionWith;
+    join: typeof join;
+    last: typeof last;
+    lastIndexOf: typeof lastIndexOf;
+    nth: typeof nth;
+    pull: typeof pull;
+    pullAll: typeof pullAll;
+    pullAllBy: typeof pullAllBy;
+    pullAllWith: typeof pullAllWith;
+    pullAt: typeof pullAt;
+    remove: typeof remove;
+    reverse: typeof reverse;
+    slice: typeof slice;
+    sortedIndex: typeof sortedIndex;
+    sortedIndexBy: typeof sortedIndexBy;
+    sortedIndexOf: typeof sortedIndexOf;
+    sortedLastIndex: typeof sortedLastIndex;
+    sortedLastIndexBy: typeof sortedLastIndexBy;
+    sortedLastIndexOf: typeof sortedLastIndexOf;
+    sortedUniq: typeof sortedUniq;
+    sortedUniqBy: typeof sortedUniqBy;
+    tail: typeof tail;
+    take: typeof take;
+    takeRight: typeof takeRight;
+    takeRightWhile: typeof takeRightWhile;
+    takeWhile: typeof takeWhile;
+    union: typeof union;
+    unionBy: typeof unionBy;
+    unionWith: typeof unionWith;
+    uniq: typeof uniq;
+    uniqBy: typeof uniqBy;
+    uniqWith: typeof uniqWith;
+    unzip: typeof unzip;
+    unzipWith: typeof unzipWith;
+    without: typeof without;
+    xor: typeof xor;
+    xorBy: typeof xorBy;
+    xorWith: typeof xorWith;
+    zip: typeof zip;
+    zipObject: typeof zipObject;
+    zipObjectDeep: typeof zipObjectDeep;
+    zipWith: typeof zipWith;
+};
+export default defaultExport;

node_modules/@types/lodash-es/ary.d.ts

@@ -0,0 +1,2 @@
+import { ary } from "lodash";
+export default ary;

node_modules/@types/lodash-es/assign.d.ts

@@ -0,0 +1,2 @@
+import { assign } from "lodash";
+export default assign;

node_modules/@types/lodash-es/assignIn.d.ts

@@ -0,0 +1,2 @@
+import { assignIn } from "lodash";
+export default assignIn;

node_modules/@types/lodash-es/assignInWith.d.ts

@@ -0,0 +1,2 @@
+import { assignInWith } from "lodash";
+export default assignInWith;

node_modules/@types/lodash-es/assignWith.d.ts

@@ -0,0 +1,2 @@
+import { assignWith } from "lodash";
+export default assignWith;

node_modules/@types/lodash-es/at.d.ts

@@ -0,0 +1,2 @@
+import { at } from "lodash";
+export default at;

node_modules/@types/lodash-es/attempt.d.ts

@@ -0,0 +1,2 @@
+import { attempt } from "lodash";
+export default attempt;

node_modules/@types/lodash-es/before.d.ts

@@ -0,0 +1,2 @@
+import { before } from "lodash";
+export default before;

node_modules/@types/lodash-es/bind.d.ts

@@ -0,0 +1,2 @@
+import { bind } from "lodash";
+export default bind;

node_modules/@types/lodash-es/bindAll.d.ts

@@ -0,0 +1,2 @@
+import { bindAll } from "lodash";
+export default bindAll;

node_modules/@types/lodash-es/bindKey.d.ts

@@ -0,0 +1,2 @@
+import { bindKey } from "lodash";
+export default bindKey;

node_modules/@types/lodash-es/camelCase.d.ts

@@ -0,0 +1,2 @@
+import { camelCase } from "lodash";
+export default camelCase;

node_modules/@types/lodash-es/capitalize.d.ts

@@ -0,0 +1,2 @@
+import { capitalize } from "lodash";
+export default capitalize;

node_modules/@types/lodash-es/castArray.d.ts

@@ -0,0 +1,2 @@
+import { castArray } from "lodash";
+export default castArray;

node_modules/@types/lodash-es/ceil.d.ts

@@ -0,0 +1,2 @@
+import { ceil } from "lodash";
+export default ceil;

node_modules/@types/lodash-es/chain.d.ts

@@ -0,0 +1,2 @@
+import { chain } from "lodash";
+export default chain;

node_modules/@types/lodash-es/chunk.d.ts

@@ -0,0 +1,2 @@
+import { chunk } from "lodash";
+export default chunk;

node_modules/@types/lodash-es/clamp.d.ts

@@ -0,0 +1,2 @@
+import { clamp } from "lodash";
+export default clamp;

node_modules/@types/lodash-es/clone.d.ts

@@ -0,0 +1,2 @@
+import { clone } from "lodash";
+export default clone;

node_modules/@types/lodash-es/cloneDeep.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeep } from "lodash";
+export default cloneDeep;

node_modules/@types/lodash-es/cloneDeepWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneDeepWith } from "lodash";
+export default cloneDeepWith;

node_modules/@types/lodash-es/cloneWith.d.ts

@@ -0,0 +1,2 @@
+import { cloneWith } from "lodash";
+export default cloneWith;

node_modules/@types/lodash-es/collection.d.ts

@@ -0,0 +1,30 @@
+import { default as countBy } from "./countBy";
+import { default as each } from "./each";
+import { default as eachRight } from "./eachRight";
+import { default as every } from "./every";
+import { default as filter } from "./filter";
+import { default as find } from "./find";
+import { default as findLast } from "./findLast";
+import { default as flatMap } from "./flatMap";
+import { default as flatMapDeep } from "./flatMapDeep";
+import { default as flatMapDepth } from "./flatMapDepth";
+import { default as forEach } from "./forEach";
+import { default as forEachRight } from "./forEachRight";
+import { default as groupBy } from "./groupBy";
+import { default as includes } from "./includes";
+import { default as invokeMap } from "./invokeMap";
+import { default as keyBy } from "./keyBy";
+import { default as map } from "./map";
+import { default as orderBy } from "./orderBy";
+import { default as partition } from "./partition";
+import { default as reduce } from "./reduce";
+import { default as reduceRight } from "./reduceRight";
+import { default as reject } from "./reject";
+import { default as sample } from "./sample";
+import { default as sampleSize } from "./sampleSize";
+import { default as shuffle } from "./shuffle";
+import { default as size } from "./size";
+import { default as some } from "./some";
+import { default as sortBy } from "./sortBy";
+
+export { default } from "./collection.default";

node_modules/@types/lodash-es/collection.default.d.ts

@@ -0,0 +1,60 @@
+import countBy from "./countBy";
+import each from "./each";
+import eachRight from "./eachRight";
+import every from "./every";
+import filter from "./filter";
+import find from "./find";
+import findLast from "./findLast";
+import flatMap from "./flatMap";
+import flatMapDeep from "./flatMapDeep";
+import flatMapDepth from "./flatMapDepth";
+import forEach from "./forEach";
+import forEachRight from "./forEachRight";
+import groupBy from "./groupBy";
+import includes from "./includes";
+import invokeMap from "./invokeMap";
+import keyBy from "./keyBy";
+import map from "./map";
+import orderBy from "./orderBy";
+import partition from "./partition";
+import reduce from "./reduce";
+import reduceRight from "./reduceRight";
+import reject from "./reject";
+import sample from "./sample";
+import sampleSize from "./sampleSize";
+import shuffle from "./shuffle";
+import size from "./size";
+import some from "./some";
+import sortBy from "./sortBy";
+
+declare const defaultExport: {
+    countBy: typeof countBy;
+    each: typeof each;
+    eachRight: typeof eachRight;
+    every: typeof every;
+    filter: typeof filter;
+    find: typeof find;
+    findLast: typeof findLast;
+    flatMap: typeof flatMap;
+    flatMapDeep: typeof flatMapDeep;
+    flatMapDepth: typeof flatMapDepth;
+    forEach: typeof forEach;
+    forEachRight: typeof forEachRight;
+    groupBy: typeof groupBy;
+    includes: typeof includes;
+    invokeMap: typeof invokeMap;
+    keyBy: typeof keyBy;
+    map: typeof map;
+    orderBy: typeof orderBy;
+    partition: typeof partition;
+    reduce: typeof reduce;
+    reduceRight: typeof reduceRight;
+    reject: typeof reject;
+    sample: typeof sample;
+    sampleSize: typeof sampleSize;
+    shuffle: typeof shuffle;
+    size: typeof size;
+    some: typeof some;
+    sortBy: typeof sortBy;
+};
+export default defaultExport;

node_modules/@types/lodash-es/compact.d.ts

@@ -0,0 +1,2 @@
+import { compact } from "lodash";
+export default compact;

node_modules/@types/lodash-es/concat.d.ts

@@ -0,0 +1,2 @@
+import { concat } from "lodash";
+export default concat;

node_modules/@types/lodash-es/cond.d.ts

@@ -0,0 +1,2 @@
+import { cond } from "lodash";
+export default cond;

node_modules/@types/lodash-es/conforms.d.ts

@@ -0,0 +1,2 @@
+import { conforms } from "lodash";
+export default conforms;

node_modules/@types/lodash-es/conformsTo.d.ts

@@ -0,0 +1,2 @@
+import { conformsTo } from "lodash";
+export default conformsTo;

node_modules/@types/lodash-es/constant.d.ts

@@ -0,0 +1,2 @@
+import { constant } from "lodash";
+export default constant;

node_modules/@types/lodash-es/countBy.d.ts

@@ -0,0 +1,2 @@
+import { countBy } from "lodash";
+export default countBy;

node_modules/@types/lodash-es/create.d.ts

@@ -0,0 +1,2 @@
+import { create } from "lodash";
+export default create;

node_modules/@types/lodash-es/curry.d.ts

@@ -0,0 +1,2 @@
+import { curry } from "lodash";
+export default curry;

node_modules/@types/lodash-es/curryRight.d.ts

@@ -0,0 +1,2 @@
+import { curryRight } from "lodash";
+export default curryRight;

node_modules/@types/lodash-es/date.d.ts

@@ -0,0 +1,3 @@
+import { default as now } from "./now";
+
+export { default } from "./date.default";

node_modules/@types/lodash-es/date.default.d.ts

@@ -0,0 +1,6 @@
+import now from "./now";
+
+declare const defaultExport: {
+    now: typeof now;
+};
+export default defaultExport;

node_modules/@types/lodash-es/debounce.d.ts

@@ -0,0 +1,4 @@
+import { debounce, DebouncedFunc, DebounceSettings } from "lodash";
+
+export { DebouncedFunc, DebounceSettings };
+export default debounce;

node_modules/@types/lodash-es/deburr.d.ts

@@ -0,0 +1,2 @@
+import { deburr } from "lodash";
+export default deburr;

node_modules/@types/lodash-es/defaultTo.d.ts

@@ -0,0 +1,2 @@
+import { defaultTo } from "lodash";
+export default defaultTo;

node_modules/@types/lodash-es/defaults.d.ts

@@ -0,0 +1,2 @@
+import { defaults } from "lodash";
+export default defaults;

node_modules/@types/lodash-es/defaultsDeep.d.ts

@@ -0,0 +1,2 @@
+import { defaultsDeep } from "lodash";
+export default defaultsDeep;

node_modules/@types/lodash-es/defer.d.ts

@@ -0,0 +1,2 @@
+import { defer } from "lodash";
+export default defer;

node_modules/@types/lodash-es/delay.d.ts

@@ -0,0 +1,2 @@
+import { delay } from "lodash";
+export default delay;

node_modules/@types/lodash-es/difference.d.ts

@@ -0,0 +1,2 @@
+import { difference } from "lodash";
+export default difference;

node_modules/@types/lodash-es/differenceBy.d.ts

@@ -0,0 +1,2 @@
+import { differenceBy } from "lodash";
+export default differenceBy;

node_modules/@types/lodash-es/differenceWith.d.ts

@@ -0,0 +1,2 @@
+import { differenceWith } from "lodash";
+export default differenceWith;

node_modules/@types/lodash-es/divide.d.ts

@@ -0,0 +1,2 @@
+import { divide } from "lodash";
+export default divide;

node_modules/@types/lodash-es/drop.d.ts

@@ -0,0 +1,2 @@
+import { drop } from "lodash";
+export default drop;

node_modules/@types/lodash-es/dropRight.d.ts

@@ -0,0 +1,2 @@
+import { dropRight } from "lodash";
+export default dropRight;

node_modules/@types/lodash-es/dropRightWhile.d.ts

@@ -0,0 +1,2 @@
+import { dropRightWhile } from "lodash";
+export default dropRightWhile;

node_modules/@types/lodash-es/dropWhile.d.ts

@@ -0,0 +1,2 @@
+import { dropWhile } from "lodash";
+export default dropWhile;

node_modules/@types/lodash-es/each.d.ts

@@ -0,0 +1,2 @@
+import { each } from "lodash";
+export default each;

node_modules/@types/lodash-es/eachRight.d.ts

@@ -0,0 +1,2 @@
+import { eachRight } from "lodash";
+export default eachRight;

node_modules/@types/lodash-es/endsWith.d.ts

@@ -0,0 +1,2 @@
+import { endsWith } from "lodash";
+export default endsWith;

node_modules/@types/lodash-es/entries.d.ts

@@ -0,0 +1,2 @@
+import { entries } from "lodash";
+export default entries;

node_modules/@types/lodash-es/entriesIn.d.ts

@@ -0,0 +1,2 @@
+import { entriesIn } from "lodash";
+export default entriesIn;

node_modules/@types/lodash-es/eq.d.ts

@@ -0,0 +1,2 @@
+import { eq } from "lodash";
+export default eq;

node_modules/@types/lodash-es/escape.d.ts

@@ -0,0 +1,2 @@
+import { escape } from "lodash";
+export default escape;

node_modules/@types/lodash-es/escapeRegExp.d.ts

@@ -0,0 +1,2 @@
+import { escapeRegExp } from "lodash";
+export default escapeRegExp;

node_modules/@types/lodash-es/every.d.ts

@@ -0,0 +1,2 @@
+import { every } from "lodash";
+export default every;

node_modules/@types/lodash-es/extend.d.ts

@@ -0,0 +1,2 @@
+import { extend } from "lodash";
+export default extend;

node_modules/@types/lodash-es/extendWith.d.ts

@@ -0,0 +1,2 @@
+import { extendWith } from "lodash";
+export default extendWith;

node_modules/@types/lodash-es/fill.d.ts

@@ -0,0 +1,2 @@
+import { fill } from "lodash";
+export default fill;

node_modules/@types/lodash-es/filter.d.ts

@@ -0,0 +1,2 @@
+import { filter } from "lodash";
+export default filter;

node_modules/@types/lodash-es/find.d.ts

@@ -0,0 +1,2 @@
+import { find } from "lodash";
+export default find;

node_modules/@types/lodash-es/findIndex.d.ts

@@ -0,0 +1,2 @@
+import { findIndex } from "lodash";
+export default findIndex;

node_modules/@types/lodash-es/findKey.d.ts

@@ -0,0 +1,2 @@
+import { findKey } from "lodash";
+export default findKey;

node_modules/@types/lodash-es/findLast.d.ts

@@ -0,0 +1,2 @@
+import { findLast } from "lodash";
+export default findLast;

node_modules/@types/lodash-es/findLastIndex.d.ts

@@ -0,0 +1,2 @@
+import { findLastIndex } from "lodash";
+export default findLastIndex;

node_modules/@types/lodash-es/findLastKey.d.ts

@@ -0,0 +1,2 @@
+import { findLastKey } from "lodash";
+export default findLastKey;

node_modules/@types/lodash-es/first.d.ts

@@ -0,0 +1,2 @@
+import { first } from "lodash";
+export default first;

node_modules/@types/lodash-es/flatMap.d.ts

@@ -0,0 +1,2 @@
+import { flatMap } from "lodash";
+export default flatMap;

node_modules/@types/lodash-es/flatMapDeep.d.ts

@@ -0,0 +1,2 @@
+import { flatMapDeep } from "lodash";
+export default flatMapDeep;

node_modules/@types/lodash-es/flatMapDepth.d.ts

@@ -0,0 +1,2 @@
+import { flatMapDepth } from "lodash";
+export default flatMapDepth;

node_modules/@types/lodash-es/flatten.d.ts

@@ -0,0 +1,2 @@
+import { flatten } from "lodash";
+export default flatten;

node_modules/@types/lodash-es/flattenDeep.d.ts

@@ -0,0 +1,2 @@
+import { flattenDeep } from "lodash";
+export default flattenDeep;

node_modules/@types/lodash-es/flattenDepth.d.ts

@@ -0,0 +1,2 @@
+import { flattenDepth } from "lodash";
+export default flattenDepth;

node_modules/@types/lodash-es/flip.d.ts

@@ -0,0 +1,2 @@
+import { flip } from "lodash";
+export default flip;

node_modules/@types/lodash-es/floor.d.ts

@@ -0,0 +1,2 @@
+import { floor } from "lodash";
+export default floor;

node_modules/@types/lodash-es/flow.d.ts

@@ -0,0 +1,2 @@
+import { flow } from "lodash";
+export default flow;

node_modules/@types/lodash-es/flowRight.d.ts

@@ -0,0 +1,2 @@
+import { flowRight } from "lodash";
+export default flowRight;

node_modules/@types/lodash-es/forEach.d.ts

@@ -0,0 +1,2 @@
+import { forEach } from "lodash";
+export default forEach;