initial commit

server/node_modules/lru-memoizer/lib/async.d.ts

@@ -0,0 +1,85 @@
+import { syncMemoizer } from './sync';
+import { INodeStyleCallBack as CB, ResultBase, IParamsBase0, IParamsBase1, IParamsBase2, IParamsBase3, IParamsBase4, IParamsBase5, IParamsBase6 } from './util';
+export interface IMemoized<T1, T2, T3, T4, T5, T6, TResult> extends ResultBase {
+    (cb: CB<TResult>): void;
+    (a1: T1, cb: CB<TResult>): void;
+    (a1: T1, a2: T2, cb: CB<TResult>): void;
+    (a1: T1, a2: T2, a3: T3, cb: CB<TResult>): void;
+    (a1: T1, a2: T2, a3: T3, a4: T4, cb: CB<TResult>): void;
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, cb: CB<TResult>): void;
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction0<TResult> {
+    (cb: CB<TResult>): void;
+}
+interface IMemoizableFunction1<T1, TResult> {
+    (a1: T1, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction2<T1, T2, TResult> {
+    (a1: T1, a2: T2, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction3<T1, T2, T3, TResult> {
+    (a1: T1, a2: T2, a3: T3, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction4<T1, T2, T3, T4, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction5<T1, T2, T3, T4, T5, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, cb: CB<TResult>): void;
+}
+interface IMemoizableFunction6<T1, T2, T3, T4, T5, T6, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, cb: CB<TResult>): void;
+}
+interface AsyncParams0<TResult> extends IParamsBase0<TResult> {
+    load: IMemoizableFunction0<TResult>;
+}
+interface AsyncParams1<T1, TResult> extends IParamsBase1<T1, TResult> {
+    load: IMemoizableFunction1<T1, TResult>;
+}
+interface AsyncParams2<T1, T2, TResult> extends IParamsBase2<T1, T2, TResult> {
+    load: IMemoizableFunction2<T1, T2, TResult>;
+}
+interface AsyncParams3<T1, T2, T3, TResult> extends IParamsBase3<T1, T2, T3, TResult> {
+    load: IMemoizableFunction3<T1, T2, T3, TResult>;
+}
+interface AsyncParams4<T1, T2, T3, T4, TResult> extends IParamsBase4<T1, T2, T3, T4, TResult> {
+    load: IMemoizableFunction4<T1, T2, T3, T4, TResult>;
+}
+interface AsyncParams5<T1, T2, T3, T4, T5, TResult> extends IParamsBase5<T1, T2, T3, T4, T5, TResult> {
+    load: IMemoizableFunction5<T1, T2, T3, T4, T5, TResult>;
+}
+interface AsyncParams6<T1, T2, T3, T4, T5, T6, TResult> extends IParamsBase6<T1, T2, T3, T4, T5, T6, TResult> {
+    /**
+     * The function that loads the resource when is not in the cache.
+     */
+    load: IMemoizableFunction6<T1, T2, T3, T4, T5, T6, TResult>;
+}
+declare function asyncMemoizer<TResult>(options: AsyncParams0<TResult>): IMemoized<unknown, unknown, unknown, unknown, unknown, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, TResult>(options: AsyncParams1<T1, TResult>): IMemoized<T1, unknown, unknown, unknown, unknown, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, T2, TResult>(options: AsyncParams2<T1, T2, TResult>): IMemoized<T1, T2, unknown, unknown, unknown, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, T2, T3, TResult>(options: AsyncParams3<T1, T2, T3, TResult>): IMemoized<T1, T2, T3, unknown, unknown, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, T2, T3, T4, TResult>(options: AsyncParams4<T1, T2, T3, T4, TResult>): IMemoized<T1, T2, T3, T4, unknown, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, T2, T3, T4, T5, TResult>(options: AsyncParams5<T1, T2, T3, T4, T5, TResult>): IMemoized<T1, T2, T3, T4, T5, unknown, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+declare function asyncMemoizer<T1, T2, T3, T4, T5, T6, TResult>(options: AsyncParams6<T1, T2, T3, T4, T5, T6, TResult>): IMemoized<T1, T2, T3, T4, T5, T6, TResult>;
+declare namespace asyncMemoizer {
+    var sync: typeof syncMemoizer;
+}
+export { asyncMemoizer };

server/node_modules/lru-memoizer/lib/freeze.d.ts

@@ -0,0 +1 @@
+export declare function deepFreeze(o: any): any;

server/node_modules/lru-memoizer/lib/freeze.js

@@ -0,0 +1,23 @@
+"use strict";
+// From https://raw.githubusercontent.com/nikoskalogridis/deep-freeze/fb921b32064dce1645197be2bf975fe0385450b0/index.js
+// which is sadly, no longer maintained
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepFreeze = void 0;
+function deepFreeze(o) {
+    if (o) {
+        Object.freeze(o);
+        Object.getOwnPropertyNames(o).forEach(function (prop) {
+            if (o.hasOwnProperty(prop)
+                && o[prop] !== null
+                && (typeof o[prop] === 'object' || typeof o[prop] === 'function')
+                && (o[prop].constructor !== Buffer)
+                && !Object.isFrozen(o[prop])) {
+                deepFreeze(o[prop]);
+            }
+        });
+    }
+    return o;
+}
+exports.deepFreeze = deepFreeze;
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJlZXplLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZyZWV6ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsdUhBQXVIO0FBQ3ZILHVDQUF1Qzs7O0FBRXZDLFNBQWdCLFVBQVUsQ0FBRSxDQUFNO0lBQ2hDLElBQUksQ0FBQyxFQUFFO1FBQ0wsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUVqQixNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFVBQVUsSUFBSTtZQUNsRCxJQUFJLENBQUMsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDO21CQUNyQixDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssSUFBSTttQkFDaEIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxRQUFRLElBQUksT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssVUFBVSxDQUFDO21CQUM5RCxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxXQUFXLEtBQUssTUFBTSxDQUFDO21CQUNoQyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUU7Z0JBQzVCLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQzthQUNyQjtRQUNMLENBQUMsQ0FBQyxDQUFDO0tBQ0o7SUFFRCxPQUFPLENBQUMsQ0FBQztBQUNYLENBQUM7QUFoQkQsZ0NBZ0JDO0FBQUEsQ0FBQyJ9

server/node_modules/lru-memoizer/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { asyncMemoizer } from './async';
+export = asyncMemoizer;

server/node_modules/lru-memoizer/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+var async_1 = require("./async");
+module.exports = async_1.asyncMemoizer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLGlDQUF3QztBQUV4QyxpQkFBUyxxQkFBYSxDQUFDIn0=

server/node_modules/lru-memoizer/lib/sync.d.ts

@@ -0,0 +1,65 @@
+import { ResultBase, IParamsBase0, IParamsBase1, IParamsBase2, IParamsBase3, IParamsBase4, IParamsBase5, IParamsBase6, IParamsBasePlus } from './util';
+interface IMemoizedSync<T1, T2, T3, T4, T5, T6, TResult> extends ResultBase {
+    (arg1: T1): TResult;
+    (arg1: T1, arg2: T2): TResult;
+    (arg1: T1, arg2: T2, arg3: T3): TResult;
+    (arg1: T1, arg2: T2, arg3: T3, arg4: T4): TResult;
+    (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): TResult;
+    (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6): TResult;
+}
+interface IMemoizableFunctionSync0<TResult> {
+    (): TResult;
+}
+interface IMemoizableFunctionSync1<T1, TResult> {
+    (arg1: T1): TResult;
+}
+interface IMemoizableFunctionSync2<T1, T2, TResult> {
+    (arg1: T1, arg2: T2): TResult;
+}
+interface IMemoizableFunctionSync3<T1, T2, T3, TResult> {
+    (arg1: T1, arg2: T2, arg3: T3): TResult;
+}
+interface IMemoizableFunctionSync4<T1, T2, T3, T4, TResult> {
+    (arg1: T1, arg2: T2, arg3: T3, arg4: T4): TResult;
+}
+interface IMemoizableFunctionSync5<T1, T2, T3, T4, T5, TResult> {
+    (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): TResult;
+}
+interface IMemoizableFunctionSync6<T1, T2, T3, T4, T5, T6, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6): TResult;
+}
+interface IMemoizableFunctionSyncPlus<TResult> {
+    (...args: any[]): TResult;
+}
+export interface SyncParams0<TResult> extends IParamsBase0<TResult> {
+    load: IMemoizableFunctionSync0<TResult>;
+}
+export interface SyncParams1<T1, TResult> extends IParamsBase1<T1, TResult> {
+    load: IMemoizableFunctionSync1<T1, TResult>;
+}
+export interface SyncParams2<T1, T2, TResult> extends IParamsBase2<T1, T2, TResult> {
+    load: IMemoizableFunctionSync2<T1, T2, TResult>;
+}
+export interface SyncParams3<T1, T2, T3, TResult> extends IParamsBase3<T1, T2, T3, TResult> {
+    load: IMemoizableFunctionSync3<T1, T2, T3, TResult>;
+}
+export interface SyncParams4<T1, T2, T3, T4, TResult> extends IParamsBase4<T1, T2, T3, T4, TResult> {
+    load: IMemoizableFunctionSync4<T1, T2, T3, T4, TResult>;
+}
+export interface SyncParams5<T1, T2, T3, T4, T5, TResult> extends IParamsBase5<T1, T2, T3, T4, T5, TResult> {
+    load: IMemoizableFunctionSync5<T1, T2, T3, T4, T5, TResult>;
+}
+export interface SyncParams6<T1, T2, T3, T4, T5, T6, TResult> extends IParamsBase6<T1, T2, T3, T4, T5, T6, TResult> {
+    load: IMemoizableFunctionSync6<T1, T2, T3, T4, T5, T6, TResult>;
+}
+export interface SyncParamsPlus<TResult> extends IParamsBasePlus {
+    load: IMemoizableFunctionSyncPlus<TResult>;
+}
+export declare function syncMemoizer<TResult>(options: SyncParams0<TResult>): IMemoizedSync<unknown, unknown, unknown, unknown, unknown, unknown, TResult>;
+export declare function syncMemoizer<T1, TResult>(options: SyncParams1<T1, TResult>): IMemoizedSync<T1, unknown, unknown, unknown, unknown, unknown, TResult>;
+export declare function syncMemoizer<T1, T2, TResult>(options: SyncParams2<T1, T2, TResult>): IMemoizedSync<T1, T2, unknown, unknown, unknown, unknown, TResult>;
+export declare function syncMemoizer<T1, T2, T3, TResult>(options: SyncParams3<T1, T2, T3, TResult>): IMemoizedSync<T1, T2, T3, unknown, unknown, unknown, TResult>;
+export declare function syncMemoizer<T1, T2, T3, T4, TResult>(options: SyncParams4<T1, T2, T3, T4, TResult>): IMemoizedSync<T1, T2, T3, T4, unknown, unknown, TResult>;
+export declare function syncMemoizer<T1, T2, T3, T4, T5, TResult>(options: SyncParams5<T1, T2, T3, T4, T5, TResult>): IMemoizedSync<T1, T2, T3, T4, T5, unknown, TResult>;
+export declare function syncMemoizer<T1, T2, T3, T4, T5, T6, TResult>(options: SyncParams6<T1, T2, T3, T4, T5, T6, TResult>): IMemoizedSync<T1, T2, T3, T4, T5, T6, TResult>;
+export {};

server/node_modules/lru-memoizer/lib/sync.js

@@ -0,0 +1,114 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncMemoizer = void 0;
+var lru_cache_1 = __importDefault(require("lru-cache"));
+var events_1 = require("events");
+var lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
+var freeze_1 = require("./freeze");
+function syncMemoizer(options) {
+    var cache = new lru_cache_1.default(options);
+    var load = options.load;
+    var hash = options.hash;
+    var bypass = options.bypass;
+    var itemMaxAge = options.itemMaxAge;
+    var freeze = options.freeze;
+    var clone = options.clone;
+    var emitter = new events_1.EventEmitter();
+    var defaultResult = Object.assign({
+        del: del,
+        reset: function () { return cache.reset(); },
+        keys: cache.keys.bind(cache),
+        on: emitter.on.bind(emitter),
+        once: emitter.once.bind(emitter),
+    }, options);
+    if (options.disable) {
+        return Object.assign(load, defaultResult);
+    }
+    function del() {
+        var key = hash.apply(void 0, __spread(arguments));
+        cache.del(key);
+    }
+    function emit(event) {
+        var parameters = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            parameters[_i - 1] = arguments[_i];
+        }
+        emitter.emit.apply(emitter, __spread([event], parameters));
+    }
+    function isPromise(result) {
+        // detect native, bluebird, A+ promises
+        return result && result.then && typeof result.then === 'function';
+    }
+    function processResult(result) {
+        var res = result;
+        if (clone) {
+            if (isPromise(res)) {
+                res = res.then(lodash_clonedeep_1.default);
+            }
+            else {
+                res = lodash_clonedeep_1.default(res);
+            }
+        }
+        if (freeze) {
+            if (isPromise(res)) {
+                res = res.then(freeze_1.deepFreeze);
+            }
+            else {
+                freeze_1.deepFreeze(res);
+            }
+        }
+        return res;
+    }
+    var result = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (bypass && bypass.apply(void 0, __spread(args))) {
+            emit.apply(void 0, __spread(['miss'], args));
+            return load.apply(void 0, __spread(args));
+        }
+        var key = hash.apply(void 0, __spread(args));
+        var fromCache = cache.get(key);
+        if (fromCache) {
+            emit.apply(void 0, __spread(['hit'], args));
+            return processResult(fromCache);
+        }
+        emit.apply(void 0, __spread(['miss'], args));
+        var result = load.apply(void 0, __spread(args));
+        if (itemMaxAge) {
+            // @ts-ignore
+            cache.set(key, result, itemMaxAge.apply(void 0, __spread(args.concat([result]))));
+        }
+        else {
+            cache.set(key, result);
+        }
+        return processResult(result);
+    };
+    return Object.assign(result, defaultResult);
+}
+exports.syncMemoizer = syncMemoizer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9zeW5jLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsd0RBQTRCO0FBQzVCLGlDQUFzQztBQUN0QyxzRUFBeUM7QUFDekMsbUNBQXNDO0FBaUd0QyxTQUFnQixZQUFZLENBQzFCLE9BQWdDO0lBRWhDLElBQU0sS0FBSyxHQUFRLElBQUksbUJBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNwQyxJQUFNLElBQUksR0FBUyxPQUFPLENBQUMsSUFBSSxDQUFDO0lBQ2hDLElBQU0sSUFBSSxHQUFTLE9BQU8sQ0FBQyxJQUFJLENBQUM7SUFDaEMsSUFBTSxNQUFNLEdBQU8sT0FBTyxDQUFDLE1BQU0sQ0FBQztJQUNsQyxJQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsVUFBVSxDQUFDO0lBQ3RDLElBQU0sTUFBTSxHQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUM7SUFDbEMsSUFBTSxLQUFLLEdBQVEsT0FBTyxDQUFDLEtBQUssQ0FBQztJQUNqQyxJQUFNLE9BQU8sR0FBTSxJQUFJLHFCQUFZLEVBQUUsQ0FBQztJQUV0QyxJQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQ2xDLEdBQUcsS0FBQTtRQUNILEtBQUssRUFBRSxjQUFNLE9BQUEsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFiLENBQWE7UUFDMUIsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQztRQUM1QixFQUFFLEVBQUUsT0FBTyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO1FBQzVCLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7S0FDakMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUVaLElBQUksT0FBTyxDQUFDLE9BQU8sRUFBRTtRQUNuQixPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLGFBQWEsQ0FBQyxDQUFDO0tBQzNDO0lBRUQsU0FBUyxHQUFHO1FBQ1YsSUFBTSxHQUFHLEdBQUcsSUFBSSx3QkFBSSxTQUFTLEVBQUMsQ0FBQztRQUMvQixLQUFLLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2pCLENBQUM7SUFFRCxTQUFTLElBQUksQ0FBQyxLQUFhO1FBQUUsb0JBQW9CO2FBQXBCLFVBQW9CLEVBQXBCLHFCQUFvQixFQUFwQixJQUFvQjtZQUFwQixtQ0FBb0I7O1FBQy9DLE9BQU8sQ0FBQyxJQUFJLE9BQVosT0FBTyxZQUFNLEtBQUssR0FBSyxVQUFVLEdBQUU7SUFDckMsQ0FBQztJQUVELFNBQVMsU0FBUyxDQUFDLE1BQVc7UUFDNUIsdUNBQXVDO1FBQ3ZDLE9BQU8sTUFBTSxJQUFJLE1BQU0sQ0FBQyxJQUFJLElBQUksT0FBTyxNQUFNLENBQUMsSUFBSSxLQUFLLFVBQVUsQ0FBQztJQUNwRSxDQUFDO0lBRUQsU0FBUyxhQUFhLENBQUMsTUFBVztRQUNoQyxJQUFJLEdBQUcsR0FBRyxNQUFNLENBQUM7UUFFakIsSUFBSSxLQUFLLEVBQUU7WUFDVCxJQUFJLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFBRTtnQkFDbEIsR0FBRyxHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUMsMEJBQVMsQ0FBQyxDQUFDO2FBQzNCO2lCQUFNO2dCQUNMLEdBQUcsR0FBRywwQkFBUyxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ3RCO1NBQ0Y7UUFFRCxJQUFJLE1BQU0sRUFBRTtZQUNWLElBQUksU0FBUyxDQUFDLEdBQUcsQ0FBQyxFQUFFO2dCQUNsQixHQUFHLEdBQUcsR0FBRyxDQUFDLElBQUksQ0FBQyxtQkFBVSxDQUFDLENBQUM7YUFDNUI7aUJBQU07Z0JBQ0wsbUJBQVUsQ0FBQyxHQUFHLENBQUMsQ0FBQzthQUNqQjtTQUNGO1FBRUQsT0FBTyxHQUFHLENBQUM7SUFDYixDQUFDO0lBRUQsSUFBTSxNQUFNLEdBQThEO1FBQ3hFLGNBQWM7YUFBZCxVQUFjLEVBQWQscUJBQWMsRUFBZCxJQUFjO1lBQWQseUJBQWM7O1FBRWQsSUFBSSxNQUFNLElBQUksTUFBTSx3QkFBSSxJQUFJLEVBQUMsRUFBRTtZQUM3QixJQUFJLHlCQUFDLE1BQU0sR0FBSyxJQUFJLEdBQUU7WUFDdEIsT0FBTyxJQUFJLHdCQUFJLElBQUksR0FBRTtTQUN0QjtRQUVELElBQUksR0FBRyxHQUFHLElBQUksd0JBQUksSUFBSSxFQUFDLENBQUM7UUFFeEIsSUFBSSxTQUFTLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUUvQixJQUFJLFNBQVMsRUFBRTtZQUNiLElBQUkseUJBQUMsS0FBSyxHQUFLLElBQUksR0FBRTtZQUVyQixPQUFPLGFBQWEsQ0FBQyxTQUFTLENBQUMsQ0FBQztTQUNqQztRQUVELElBQUkseUJBQUMsTUFBTSxHQUFLLElBQUksR0FBRTtRQUN0QixJQUFNLE1BQU0sR0FBRyxJQUFJLHdCQUFJLElBQUksRUFBQyxDQUFDO1FBRTdCLElBQUksVUFBVSxFQUFFO1lBQ2QsYUFBYTtZQUNiLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxVQUFVLHdCQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBRSxNQUFNLENBQUUsQ0FBQyxHQUFFLENBQUM7U0FDaEU7YUFBTTtZQUNMLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1NBQ3hCO1FBRUQsT0FBTyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDL0IsQ0FBQyxDQUFDO0lBRUYsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxhQUFhLENBQVEsQ0FBQztBQUNyRCxDQUFDO0FBNUZELG9DQTRGQyJ9

server/node_modules/lru-memoizer/lib/util.d.ts

@@ -0,0 +1,162 @@
+import LRU from 'lru-cache';
+export declare type Listener = (...as: any[]) => void;
+export declare type INodeStyleCallBack<Success> = (err: Error | null, result?: Success) => void;
+export interface ResultBase {
+    /**
+     * Returns all keys in the cache.
+     */
+    keys: () => string[];
+    /**
+     * Clear the cache.
+     */
+    reset: () => void;
+    /**
+     * Delete an item given the parameters.
+     */
+    del: <T1, T2, T3, T4, T5, T6>(a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6) => void;
+    on(event: 'hit', handler: Listener): void;
+    on(event: 'miss', handler: Listener): void;
+    on(event: 'queue', handler: Listener): void;
+}
+export interface IHashingFunction0 {
+    (): string;
+}
+export interface IHashingFunction1<T1> {
+    (a1: T1): string;
+}
+export interface IHashingFunction2<T1, T2> {
+    (a1: T1, a2: T2): string;
+}
+export interface IHashingFunction3<T1, T2, T3> {
+    (a1: T1, a2: T2, a3: T3): string;
+}
+export interface IHashingFunction4<T1, T2, T3, T4> {
+    (a1: T1, a2: T2, a3: T3, a4: T4): string;
+}
+export interface IHashingFunction5<T1, T2, T3, T4, T5> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5): string;
+}
+export interface IHashingFunction6<T1, T2, T3, T4, T5, T6> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6): string;
+}
+export interface IHashingFunctionPlus {
+    (...rest: any[]): string;
+}
+export interface IBypassFunction0 {
+    (): boolean;
+}
+export interface IBypassFunction1<T1> {
+    (a1: T1): boolean;
+}
+export interface IBypassFunction2<T1, T2> {
+    (a1: T1, a2: T2): boolean;
+}
+export interface IBypassFunction3<T1, T2, T3> {
+    (a1: T1, a2: T2, a3: T3): boolean;
+}
+export interface IBypassFunction4<T1, T2, T3, T4> {
+    (a1: T1, a2: T2, a3: T3, a4: T4): boolean;
+}
+export interface IBypassFunction5<T1, T2, T3, T4, T5> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5): boolean;
+}
+export interface IBypassFunction6<T1, T2, T3, T4, T5, T6> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6): boolean;
+}
+export interface IBypassFunctionPlus {
+    (...rest: any[]): boolean;
+}
+export interface IMaxAgeFunction0<TResult> {
+    (res: TResult): number;
+}
+export interface IMaxAgeFunction1<T1, TResult> {
+    (a1: T1, res: TResult): number;
+}
+export interface IMaxAgeFunction2<T1, T2, TResult> {
+    (a1: T1, a2: T2, res: TResult): number;
+}
+export interface IMaxAgeFunction3<T1, T2, T3, TResult> {
+    (a1: T1, a2: T2, a3: T3, res: TResult): number;
+}
+export interface IMaxAgeFunction4<T1, T2, T3, T4, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, res: TResult): number;
+}
+export interface IMaxAgeFunction5<T1, T2, T3, T4, T5, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, res: TResult): number;
+}
+export interface IMaxAgeFunction6<T1, T2, T3, T4, T5, T6, TResult> {
+    (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, res: TResult): number;
+}
+export interface IMaxAgeFunctionPlus {
+    (...rest: any[]): number;
+}
+export interface IParamsBase0<TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction0;
+    bypass?: IBypassFunction0;
+    itemMaxAge?: IMaxAgeFunction0<TResult>;
+}
+export interface IParamsBase1<T1, TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction1<T1>;
+    bypass?: IBypassFunction1<T1>;
+    itemMaxAge?: IMaxAgeFunction1<T1, TResult>;
+}
+export interface IParamsBase2<T1, T2, TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction2<T1, T2>;
+    bypass?: IBypassFunction2<T1, T2>;
+    itemMaxAge?: IMaxAgeFunction2<T1, T2, TResult>;
+}
+export interface IParamsBase3<T1, T2, T3, TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction3<T1, T2, T3>;
+    bypass?: IBypassFunction3<T1, T2, T3>;
+    itemMaxAge?: IMaxAgeFunction3<T1, T2, T3, TResult>;
+}
+export interface IParamsBase4<T1, T2, T3, T4, TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction4<T1, T2, T3, T4>;
+    bypass?: IBypassFunction4<T1, T2, T3, T4>;
+    itemMaxAge?: IMaxAgeFunction4<T1, T2, T3, T4, TResult>;
+}
+export interface IParamsBase5<T1, T2, T3, T4, T5, TResult> extends IParamsBaseCommons {
+    hash: IHashingFunction5<T1, T2, T3, T4, T5>;
+    bypass?: IBypassFunction5<T1, T2, T3, T4, T5>;
+    itemMaxAge?: IMaxAgeFunction5<T1, T2, T3, T4, T5, TResult>;
+}
+export interface IParamsBase6<T1, T2, T3, T4, T5, T6, TResult> extends IParamsBaseCommons {
+    /**
+     * A function to generate the key of the cache.
+     */
+    hash: IHashingFunction6<T1, T2, T3, T4, T5, T6>;
+    /**
+     * Return true if the result should not be retrieved from the cache.
+     */
+    bypass?: IBypassFunction6<T1, T2, T3, T4, T5, T6>;
+    /**
+     * An optional function to indicate the maxAge of an specific item.
+     */
+    itemMaxAge?: IMaxAgeFunction6<T1, T2, T3, T4, T5, T6, TResult>;
+}
+export interface IParamsBasePlus extends IParamsBaseCommons {
+    hash: IHashingFunctionPlus;
+    bypass?: IBypassFunctionPlus;
+    itemMaxAge?: IMaxAgeFunctionPlus;
+}
+interface IParamsBaseCommons extends LRU.Options<string, any> {
+    /**
+     * Indicates if the resource should be freezed.
+     */
+    freeze?: boolean;
+    /**
+     * Indicates if the resource should be cloned before is returned.
+     */
+    clone?: boolean;
+    /**
+     * Disable the cache and executes the load logic directly.
+     */
+    disable?: boolean;
+    /**
+     * Do not queue requests if initial call is more than `queueMaxAge` milliseconds old.
+     * Instead, invoke `load` again and create a new queue.
+     * Defaults to 1000ms.
+     */
+    queueMaxAge?: number;
+}
+export {};

server/node_modules/lru-memoizer/lib/util.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy91dGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==