init

node_modules/memoize-one/dist/are-inputs-equal.d.ts

@@ -0,0 +1 @@
+export default function areInputsEqual(newInputs: readonly unknown[], lastInputs: readonly unknown[]): boolean;

node_modules/memoize-one/dist/memoize-one.cjs.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var safeIsNaN = Number.isNaN ||
+    function ponyfill(value) {
+        return typeof value === 'number' && value !== value;
+    };
+function isEqual(first, second) {
+    if (first === second) {
+        return true;
+    }
+    if (safeIsNaN(first) && safeIsNaN(second)) {
+        return true;
+    }
+    return false;
+}
+function areInputsEqual(newInputs, lastInputs) {
+    if (newInputs.length !== lastInputs.length) {
+        return false;
+    }
+    for (var i = 0; i < newInputs.length; i++) {
+        if (!isEqual(newInputs[i], lastInputs[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function memoizeOne(resultFn, isEqual) {
+    if (isEqual === void 0) { isEqual = areInputsEqual; }
+    var cache = null;
+    function memoized() {
+        var newArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            newArgs[_i] = arguments[_i];
+        }
+        if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
+            return cache.lastResult;
+        }
+        var lastResult = resultFn.apply(this, newArgs);
+        cache = {
+            lastResult: lastResult,
+            lastArgs: newArgs,
+            lastThis: this,
+        };
+        return lastResult;
+    }
+    memoized.clear = function clear() {
+        cache = null;
+    };
+    return memoized;
+}
+
+module.exports = memoizeOne;

node_modules/memoize-one/dist/memoize-one.cjs.js.flow

@@ -0,0 +1,11 @@
+// @flow
+
+// These types are not as powerful as the TypeScript types, but they get the job done
+
+export type EqualityFn = (newArgs: mixed[], lastArgs: mixed[]) => boolean;
+
+// default export
+declare export default function memoizeOne<ResultFn: (...any[]) => mixed>(
+  fn: ResultFn,
+  isEqual?: EqualityFn,
+): ResultFn & { clear: () => void };

node_modules/memoize-one/dist/memoize-one.d.ts

@@ -0,0 +1,7 @@
+export declare type EqualityFn<TFunc extends (...args: any[]) => any> = (newArgs: Parameters<TFunc>, lastArgs: Parameters<TFunc>) => boolean;
+export declare type MemoizedFn<TFunc extends (this: any, ...args: any[]) => any> = {
+    clear: () => void;
+    (this: ThisParameterType<TFunc>, ...args: Parameters<TFunc>): ReturnType<TFunc>;
+};
+declare function memoizeOne<TFunc extends (this: any, ...newArgs: any[]) => any>(resultFn: TFunc, isEqual?: EqualityFn<TFunc>): MemoizedFn<TFunc>;
+export default memoizeOne;

node_modules/memoize-one/dist/memoize-one.esm.js

@@ -0,0 +1,51 @@
+var safeIsNaN = Number.isNaN ||
+    function ponyfill(value) {
+        return typeof value === 'number' && value !== value;
+    };
+function isEqual(first, second) {
+    if (first === second) {
+        return true;
+    }
+    if (safeIsNaN(first) && safeIsNaN(second)) {
+        return true;
+    }
+    return false;
+}
+function areInputsEqual(newInputs, lastInputs) {
+    if (newInputs.length !== lastInputs.length) {
+        return false;
+    }
+    for (var i = 0; i < newInputs.length; i++) {
+        if (!isEqual(newInputs[i], lastInputs[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function memoizeOne(resultFn, isEqual) {
+    if (isEqual === void 0) { isEqual = areInputsEqual; }
+    var cache = null;
+    function memoized() {
+        var newArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            newArgs[_i] = arguments[_i];
+        }
+        if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
+            return cache.lastResult;
+        }
+        var lastResult = resultFn.apply(this, newArgs);
+        cache = {
+            lastResult: lastResult,
+            lastArgs: newArgs,
+            lastThis: this,
+        };
+        return lastResult;
+    }
+    memoized.clear = function clear() {
+        cache = null;
+    };
+    return memoized;
+}
+
+export { memoizeOne as default };

node_modules/memoize-one/dist/memoize-one.js

@@ -0,0 +1,59 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.memoizeOne = factory());
+})(this, (function () { 'use strict';
+
+  var safeIsNaN = Number.isNaN ||
+      function ponyfill(value) {
+          return typeof value === 'number' && value !== value;
+      };
+  function isEqual(first, second) {
+      if (first === second) {
+          return true;
+      }
+      if (safeIsNaN(first) && safeIsNaN(second)) {
+          return true;
+      }
+      return false;
+  }
+  function areInputsEqual(newInputs, lastInputs) {
+      if (newInputs.length !== lastInputs.length) {
+          return false;
+      }
+      for (var i = 0; i < newInputs.length; i++) {
+          if (!isEqual(newInputs[i], lastInputs[i])) {
+              return false;
+          }
+      }
+      return true;
+  }
+
+  function memoizeOne(resultFn, isEqual) {
+      if (isEqual === void 0) { isEqual = areInputsEqual; }
+      var cache = null;
+      function memoized() {
+          var newArgs = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+              newArgs[_i] = arguments[_i];
+          }
+          if (cache && cache.lastThis === this && isEqual(newArgs, cache.lastArgs)) {
+              return cache.lastResult;
+          }
+          var lastResult = resultFn.apply(this, newArgs);
+          cache = {
+              lastResult: lastResult,
+              lastArgs: newArgs,
+              lastThis: this,
+          };
+          return lastResult;
+      }
+      memoized.clear = function clear() {
+          cache = null;
+      };
+      return memoized;
+  }
+
+  return memoizeOne;
+
+}));

node_modules/memoize-one/dist/memoize-one.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).memoizeOne=t()}(this,(function(){"use strict";var e=Number.isNaN||function(e){return"number"==typeof e&&e!=e};function t(t,n){if(t.length!==n.length)return!1;for(var r=0;r<t.length;r++)if(i=t[r],u=n[r],!(i===u||e(i)&&e(u)))return!1;var i,u;return!0}return function(e,n){void 0===n&&(n=t);var r=null;function i(){for(var t=[],i=0;i<arguments.length;i++)t[i]=arguments[i];if(r&&r.lastThis===this&&n(t,r.lastArgs))return r.lastResult;var u=e.apply(this,t);return r={lastResult:u,lastArgs:t,lastThis:this},u}return i.clear=function(){r=null},i}}));