@openclaw/msteams 2026.5.27 → 2026.5.28-beta.2

package/node_modules/lru-cache/package.json

@@ -1,154 +1,34 @@
 {
   "name": "lru-cache",
   "description": "A cache object that deletes the least-recently-used items.",
-  "version": "11.5.0",
+  "version": "6.0.0",
   "author": "Isaac Z. Schlueter <i@izs.me>",
   "keywords": [
     "mru",
     "lru",
     "cache"
   ],
-  "sideEffects": false,
   "scripts": {
-    "build": "npm run prepare",
-    "prepare": "tshy && bash scripts/build.sh",
-    "pretest": "npm run prepare",
-    "presnap": "npm run prepare",
     "test": "tap",
     "snap": "tap",
     "preversion": "npm test",
     "postversion": "npm publish",
-    "prepublishOnly": "git push origin --follow-tags",
-    "format": "prettier --write .",
-    "typedoc": "typedoc --tsconfig ./.tshy/esm.json ./src/*.ts",
-    "benchmark-results-typedoc": "bash scripts/benchmark-results-typedoc.sh",
-    "prebenchmark": "npm run prepare",
-    "benchmark": "make -C benchmark",
-    "preprofile": "npm run prepare",
-    "profile": "make -C benchmark profile",
-    "lint": "oxlint --fix src test",
-    "postsnap": "npm run lint",
-    "postlint": "npm run format"
-  },
-  "main": "./dist/commonjs/index.min.js",
-  "types": "./dist/commonjs/index.d.ts",
-  "tshy": {
-    "esmDialects": [
-      "browser",
-      "node"
-    ],
-    "commonjsDialects": [
-      "browser",
-      "node"
-    ],
-    "exports": {
-      "./raw": "./src/index.ts",
-      ".": {
-        "import": {
-          "browser": {
-            "types": "./dist/esm/browser/index.d.ts",
-            "default": "./dist/esm/browser/index.min.js"
-          },
-          "node": {
-            "types": "./dist/esm/node/index.d.ts",
-            "default": "./dist/esm/node/index.min.js"
-          },
-          "types": "./dist/esm/index.d.ts",
-          "default": "./dist/esm/index.min.js"
-        },
-        "require": {
-          "browser": {
-            "types": "./dist/commonjs/browser/index.d.ts",
-            "default": "./dist/commonjs/browser/index.min.js"
-          },
-          "node": {
-            "types": "./dist/commonjs/node/index.d.ts",
-            "default": "./dist/commonjs/node/index.min.js"
-          },
-          "types": "./dist/commonjs/index.d.ts",
-          "default": "./dist/commonjs/index.min.js"
-        }
-      }
-    },
-    "selfLink": false
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/isaacs/node-lru-cache.git"
+    "prepublishOnly": "git push origin --follow-tags"
   },
+  "main": "index.js",
+  "repository": "git://github.com/isaacs/node-lru-cache.git",
   "devDependencies": {
     "benchmark": "^2.1.4",
-    "esbuild": "^0.28.0",
-    "marked": "^4.2.12",
-    "mkdirp": "^3.0.1",
-    "oxlint": "^1.65.0",
-    "oxlint-tsgolint": "^0.22.1",
-    "prettier": "^3.8.3",
-    "tap": "^21.7.4",
-    "tshy": "^4.1.2",
-    "typedoc": "^0.28.19"
+    "tap": "^14.10.7"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "yallist": "^4.0.0"
   },
-  "license": "BlueOak-1.0.0",
   "files": [
-    "dist"
+    "index.js"
   ],
   "engines": {
-    "node": "20 || >=22"
-  },
-  "exports": {
-    "./raw": {
-      "import": {
-        "browser": {
-          "types": "./dist/esm/browser/index.d.ts",
-          "default": "./dist/esm/browser/index.js"
-        },
-        "node": {
-          "types": "./dist/esm/node/index.d.ts",
-          "default": "./dist/esm/node/index.js"
-        },
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "browser": {
-          "types": "./dist/commonjs/browser/index.d.ts",
-          "default": "./dist/commonjs/browser/index.js"
-        },
-        "node": {
-          "types": "./dist/commonjs/node/index.d.ts",
-          "default": "./dist/commonjs/node/index.js"
-        },
-        "types": "./dist/commonjs/index.d.ts",
-        "default": "./dist/commonjs/index.js"
-      }
-    },
-    ".": {
-      "import": {
-        "browser": {
-          "types": "./dist/esm/browser/index.d.ts",
-          "default": "./dist/esm/browser/index.min.js"
-        },
-        "node": {
-          "types": "./dist/esm/node/index.d.ts",
-          "default": "./dist/esm/node/index.min.js"
-        },
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.min.js"
-      },
-      "require": {
-        "browser": {
-          "types": "./dist/commonjs/browser/index.d.ts",
-          "default": "./dist/commonjs/browser/index.min.js"
-        },
-        "node": {
-          "types": "./dist/commonjs/node/index.d.ts",
-          "default": "./dist/commonjs/node/index.min.js"
-        },
-        "types": "./dist/commonjs/index.d.ts",
-        "default": "./dist/commonjs/index.min.js"
-      }
-    }
-  },
-  "type": "module",
-  "module": "./dist/esm/index.min.js"
+    "node": ">=10"
+  }
 }

package/node_modules/lru-memoizer/README.md

@@ -12,9 +12,9 @@ This module uses an [lru-cache](https://github.com/isaacs/node-lru-cache) intern
 
 The `load` function can have N parameters and the last one must be a callback. The callback should be an errback (first parameter is `err`).
 
-The `hash` function purpose is generate a custom hash for storing results. It has all the arguments applied to it minus the callback, and must return a synchronous string.
+The `hash` function purpose is generate a custom hash for storing results. It has all the arguments applied to it minus the callback, and must return an string synchronous.
 
-The `disable` function allows you to conditionally disable the use of the cache. Useful for test environments.
+The `disable` function allows you to conditionally disable the use of the cache.  Useful for test environments.
 
 The `freeze` option (defaults to **false**) allows you to deep-freeze the result of the async function.
 
@@ -23,9 +23,10 @@ The `clone` option (defaults to **false**) allows you to deep-clone the result e
 ## Usage
 
 ```javascript
-const memoizer = require("lru-memoizer");
 
-const memoizedGet = memoizer({
+var memoizer = require('lru-memoizer');
+
+var memoizedGet = memoizer({
   //defines how to load the resource when
   //it is not in the cache.
   load: function (options, callback) {
@@ -42,31 +43,29 @@ const memoizedGet = memoizer({
 
   //all other params for the LRU cache.
   max: 100,
-  ttl: 1000 * 60,
+  maxAge: 1000 * 60
 });
 
-memoizedGet(
-  {
-    url: "https://google.com",
-    qs: { foo: 123 },
-  },
-  function (err, result, body) {
-    //console.log(body);
-  }
-);
+memoizedGet({
+  url: 'https://google.com',
+  qs: { foo: 123 }
+}, function (err, result, body) {
+ //console.log(body);
+})
+
 ```
 
-## Synchronous lru-memoizer
+## Sync lru-memoizer
 
-Use `memoizer.sync` to cache things that are slow to calculate, methods returning promises, or only if you don't want to use a callback and want it synchronous.
+Use `memoizer.sync` to cache things that are slow to calculate or methods returning promises.
 
-```javascript
-const memoizer = require("lru-memoizer");
-const memoizedGet = memoizer.sync({
+```
+var memoizer = require('lru-memoizer');
+var memoizedGet = memoizer.sync({
   //defines how to load the resource when
   //it is not in the cache.
   load: function (params) {
-    return somethingHardToCompute();
+    //return something_hard_to_compute;s
   },
 
   //defines how to create a cache key from the params.
@@ -76,13 +75,13 @@ const memoizedGet = memoizer.sync({
 
   //all other params for the LRU cache.
   max: 100,
-  ttl: 1000 * 60,
+  maxAge: 1000 * 60
 });
 ```
 
 ## Similar modules
 
-This module is very similar to [async-cache](https://github.com/isaacs/async-cache)<sup>(deprecated)</sup>, the main difference is the `hash` function.
+This module is very similar to [async-cache](https://github.com/isaacs/async-cache), the main difference is the `hash` function.
 
 ## License
 

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

@@ -30,39 +30,56 @@ interface IMemoizableFunction5<T1, T2, T3, T4, T5, TResult> {
 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;
 }
-type AsyncParams0<TResult> = IParamsBase0<TResult> & {
+interface AsyncParams0<TResult> extends IParamsBase0<TResult> {
     load: IMemoizableFunction0<TResult>;
-};
-type AsyncParams1<T1, TResult> = IParamsBase1<T1, TResult> & {
+}
+interface AsyncParams1<T1, TResult> extends IParamsBase1<T1, TResult> {
     load: IMemoizableFunction1<T1, TResult>;
-};
-type AsyncParams2<T1, T2, TResult> = IParamsBase2<T1, T2, TResult> & {
+}
+interface AsyncParams2<T1, T2, TResult> extends IParamsBase2<T1, T2, TResult> {
     load: IMemoizableFunction2<T1, T2, TResult>;
-};
-type AsyncParams3<T1, T2, T3, TResult> = IParamsBase3<T1, T2, T3, TResult> & {
+}
+interface AsyncParams3<T1, T2, T3, TResult> extends IParamsBase3<T1, T2, T3, TResult> {
     load: IMemoizableFunction3<T1, T2, T3, TResult>;
-};
-type AsyncParams4<T1, T2, T3, T4, TResult> = IParamsBase4<T1, T2, T3, T4, TResult> & {
+}
+interface AsyncParams4<T1, T2, T3, T4, TResult> extends IParamsBase4<T1, T2, T3, T4, TResult> {
     load: IMemoizableFunction4<T1, T2, T3, T4, TResult>;
-};
-type AsyncParams5<T1, T2, T3, T4, T5, TResult> = IParamsBase5<T1, T2, T3, T4, T5, 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>;
-};
-type AsyncParams6<T1, T2, T3, T4, T5, T6, TResult> = IParamsBase6<T1, T2, T3, T4, T5, T6, 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 };
-//# sourceMappingURL=async.d.ts.map

package/node_modules/lru-memoizer/lib/async.js

@@ -1,104 +1,162 @@
 "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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.asyncMemoizer = void 0;
-const lru_cache_1 = require("lru-cache");
-const events_1 = require("events");
-const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
-const freeze_1 = require("./freeze");
-const sync_1 = require("./sync");
+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");
+var sync_1 = require("./sync");
 function asyncMemoizer(options) {
-    const cache = new lru_cache_1.LRUCache(options);
-    const load = options.load;
-    const hash = options.hash;
-    const bypass = options.bypass;
-    const itemTTL = options.itemTTL;
-    const freeze = options.freeze;
-    const clone = options.clone;
-    const queueTTL = options.queueTTL || 1000;
-    const loading = new Map();
-    const emitter = new events_1.EventEmitter();
-    const memoizerMethods = Object.assign({
-        del,
-        reset: () => cache.clear(),
-        keys: () => [...cache.keys()],
+    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 queueMaxAge = options.queueMaxAge || 1000;
+    var loading = new Map();
+    var emitter = new events_1.EventEmitter();
+    var memoizerMethods = 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, memoizerMethods);
     }
-    function del(...args) {
-        const key = hash(...args);
-        cache.delete(key);
+    function del() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var key = hash.apply(void 0, __spread(args));
+        cache.del(key);
     }
     function add(key, parameters, result) {
         if (freeze) {
             result.forEach(freeze_1.deepFreeze);
         }
-        if (itemTTL) {
-            cache.set(key, result, { ttl: itemTTL(...parameters.concat(result)) });
+        if (itemMaxAge) {
+            cache.set(key, result, itemMaxAge.apply(void 0, __spread(parameters.concat(result))));
         }
         else {
             cache.set(key, result);
         }
     }
     function runCallbacks(callbacks, args) {
-        for (const callback of callbacks) {
-            // Simulate async call when returning from cache
-            // and yield between callback resolution
-            if (clone) {
-                setImmediate(callback, ...args.map(lodash_clonedeep_1.default));
+        var e_1, _a;
+        try {
+            for (var callbacks_1 = __values(callbacks), callbacks_1_1 = callbacks_1.next(); !callbacks_1_1.done; callbacks_1_1 = callbacks_1.next()) {
+                var callback = callbacks_1_1.value;
+                // Simulate async call when returning from cache
+                // and yield between callback resolution
+                if (clone) {
+                    setImmediate.apply(void 0, __spread([callback], args.map(lodash_clonedeep_1.default)));
+                }
+                else {
+                    setImmediate.apply(void 0, __spread([callback], args));
+                }
             }
-            else {
-                setImmediate(callback, ...args);
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (callbacks_1_1 && !callbacks_1_1.done && (_a = callbacks_1.return)) _a.call(callbacks_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
     }
-    function emit(event, ...parameters) {
-        emitter.emit(event, ...parameters);
+    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 memoizedFunction(...args) {
-        const parameters = args.slice(0, -1);
-        const callback = args.slice(-1).pop();
-        let key;
-        if (bypass && bypass(...parameters)) {
-            emit('miss', ...parameters);
-            return load(...args);
+    function memoizedFunction() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var parameters = args.slice(0, -1);
+        var callback = args.slice(-1).pop();
+        var key;
+        if (bypass && bypass.apply(void 0, __spread(parameters))) {
+            emit.apply(void 0, __spread(['miss'], parameters));
+            return load.apply(void 0, __spread(args));
         }
         if (parameters.length === 0 && !hash) {
             //the load function only receives callback.
             key = '_';
         }
         else {
-            key = hash(...parameters);
+            key = hash.apply(void 0, __spread(parameters));
         }
-        const fromCache = cache.get(key);
+        var fromCache = cache.get(key);
         if (fromCache) {
-            emit('hit', ...parameters);
+            emit.apply(void 0, __spread(['hit'], parameters));
             // found, invoke callback
             return runCallbacks([callback], [null].concat(fromCache));
         }
-        const pendingLoad = loading.get(key);
+        var pendingLoad = loading.get(key);
         if (pendingLoad && pendingLoad.expiresAt > Date.now()) {
             // request already in progress, queue and return
             pendingLoad.queue.push(callback);
-            emit('queue', ...parameters);
+            emit.apply(void 0, __spread(['queue'], parameters));
             return;
         }
-        emit('miss', ...parameters);
-        const started = Date.now();
+        emit.apply(void 0, __spread(['miss'], parameters));
+        var started = Date.now();
         // no pending request or not resolved before expiration
         // create a new queue and invoke load
-        const queue = [callback];
+        var queue = [callback];
         loading.set(key, {
-            queue,
-            expiresAt: started + queueTTL
+            queue: queue,
+            expiresAt: started + queueMaxAge
         });
-        const loadHandler = (...args) => {
-            const err = args[0];
+        var loadHandler = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var err = args[0];
             if (!err) {
                 add(key, parameters, args.slice(1));
             }
@@ -107,14 +165,14 @@ function asyncMemoizer(options) {
             // that will only cause a new call to be performed and a new queue to be
             // created
             loading.delete(key);
-            emit('loaded', Date.now() - started, ...parameters);
+            emit.apply(void 0, __spread(['loaded', Date.now() - started], parameters));
             runCallbacks(queue, args);
         };
-        load(...parameters, loadHandler);
+        load.apply(void 0, __spread(parameters, [loadHandler]));
     }
     ;
     return Object.assign(memoizedFunction, memoizerMethods);
 }
 exports.asyncMemoizer = asyncMemoizer;
 asyncMemoizer.sync = sync_1.syncMemoizer;
-//# sourceMappingURL=async.js.map
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,2 +1 @@
 export declare function deepFreeze(o: any): any;
-//# sourceMappingURL=freeze.d.ts.map

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

@@ -20,4 +20,4 @@ function deepFreeze(o) {
 }
 exports.deepFreeze = deepFreeze;
 ;
-//# sourceMappingURL=freeze.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJlZXplLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2ZyZWV6ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsdUhBQXVIO0FBQ3ZILHVDQUF1Qzs7O0FBRXZDLFNBQWdCLFVBQVUsQ0FBRSxDQUFNO0lBQ2hDLElBQUksQ0FBQyxFQUFFO1FBQ0wsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUVqQixNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFVBQVUsSUFBSTtZQUNsRCxJQUFJLENBQUMsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDO21CQUNyQixDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssSUFBSTttQkFDaEIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxRQUFRLElBQUksT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssVUFBVSxDQUFDO21CQUM5RCxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxXQUFXLEtBQUssTUFBTSxDQUFDO21CQUNoQyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEVBQUU7Z0JBQzVCLFVBQVUsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQzthQUNyQjtRQUNMLENBQUMsQ0FBQyxDQUFDO0tBQ0o7SUFFRCxPQUFPLENBQUMsQ0FBQztBQUNYLENBQUM7QUFoQkQsZ0NBZ0JDO0FBQUEsQ0FBQyJ9

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

@@ -1,3 +1,2 @@
 import { asyncMemoizer } from './async';
 export = asyncMemoizer;
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -31,30 +31,30 @@ interface IMemoizableFunctionSync6<T1, T2, T3, T4, T5, T6, TResult> {
 interface IMemoizableFunctionSyncPlus<TResult> {
     (...args: any[]): TResult;
 }
-export type SyncParams0<TResult> = IParamsBase0<TResult> & {
+export interface SyncParams0<TResult> extends IParamsBase0<TResult> {
     load: IMemoizableFunctionSync0<TResult>;
-};
-export type SyncParams1<T1, TResult> = IParamsBase1<T1, TResult> & {
+}
+export interface SyncParams1<T1, TResult> extends IParamsBase1<T1, TResult> {
     load: IMemoizableFunctionSync1<T1, TResult>;
-};
-export type SyncParams2<T1, T2, TResult> = IParamsBase2<T1, T2, TResult> & {
+}
+export interface SyncParams2<T1, T2, TResult> extends IParamsBase2<T1, T2, TResult> {
     load: IMemoizableFunctionSync2<T1, T2, TResult>;
-};
-export type SyncParams3<T1, T2, T3, TResult> = IParamsBase3<T1, T2, T3, TResult> & {
+}
+export interface SyncParams3<T1, T2, T3, TResult> extends IParamsBase3<T1, T2, T3, TResult> {
     load: IMemoizableFunctionSync3<T1, T2, T3, TResult>;
-};
-export type SyncParams4<T1, T2, T3, T4, TResult> = IParamsBase4<T1, T2, T3, T4, TResult> & {
+}
+export interface SyncParams4<T1, T2, T3, T4, TResult> extends IParamsBase4<T1, T2, T3, T4, TResult> {
     load: IMemoizableFunctionSync4<T1, T2, T3, T4, TResult>;
-};
-export type SyncParams5<T1, T2, T3, T4, T5, TResult> = IParamsBase5<T1, T2, T3, T4, T5, 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 type SyncParams6<T1, T2, T3, T4, T5, T6, TResult> = IParamsBase6<T1, T2, T3, T4, T5, T6, 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 type SyncParamsPlus<TResult> = IParamsBasePlus & {
+}
+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>;
@@ -63,4 +63,3 @@ export declare function syncMemoizer<T1, T2, T3, T4, TResult>(options: SyncParam
 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 {};
-//# sourceMappingURL=sync.d.ts.map