up n_m

node_modules/react-fast-compare/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2018 Formidable Labs
+Copyright (c) 2017 Evgeny Poberezkin
+
+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/react-fast-compare/README.md

@@ -0,0 +1,165 @@
+[![React Fast Compare — Formidable, We build the modern web](https://raw.githubusercontent.com/FormidableLabs/react-fast-compare/master/react-fast-compare-Hero.png)](https://formidable.com/open-source/)
+
+[![Downloads][downloads_img]][npm_site]
+[![Bundle Size][bundle_img]](#bundle-size)
+[![GH Actions Status][actions_img]][actions_site]
+[![Coverage Status][cov_img]][cov_site]
+[![npm version][npm_img]][npm_site]
+[![Maintenance Status][maintenance_img]](#maintenance-status)
+
+The fastest deep equal comparison for React. Very quick general-purpose deep
+comparison, too. Great for `React.memo` and `shouldComponentUpdate`.
+
+This is a fork of the brilliant
+[fast-deep-equal](https://github.com/epoberezkin/fast-deep-equal) with some
+extra handling for React.
+
+![benchmark chart](https://raw.githubusercontent.com/FormidableLabs/react-fast-compare/master/assets/benchmarking.png "benchmarking chart")
+
+(Check out the [benchmarking details](#benchmarking-this-library).)
+
+## Install
+
+```sh
+$ yarn add react-fast-compare
+# or
+$ npm install react-fast-compare
+```
+
+## Highlights
+
+- ES5 compatible; works in node.js (0.10+) and browsers (IE9+)
+- deeply compares any value (besides objects with circular references)
+- handles React-specific circular references, like elements
+- checks equality Date and RegExp objects
+- should as fast as [fast-deep-equal](https://github.com/epoberezkin/fast-deep-equal) via a single unified library, and with added guardrails for circular references.
+- small: under 660 bytes minified+gzipped
+
+## Usage
+
+```jsx
+const isEqual = require("react-fast-compare");
+
+// general usage
+console.log(isEqual({ foo: "bar" }, { foo: "bar" })); // true
+
+// React.memo
+// only re-render ExpensiveComponent when the props have deeply changed
+const DeepMemoComponent = React.memo(ExpensiveComponent, isEqual);
+
+// React.Component shouldComponentUpdate
+// only re-render AnotherExpensiveComponent when the props have deeply changed
+class AnotherExpensiveComponent extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return !isEqual(this.props, nextProps);
+  }
+  render() {
+    // ...
+  }
+}
+```
+
+## Do I Need `React.memo` (or `shouldComponentUpdate`)?
+
+> What's faster than a really fast deep comparison? No deep comparison at all.
+
+—This Readme
+
+Deep checks in `React.memo` or a `shouldComponentUpdate` should not be used blindly.
+First, see if the default
+[React.memo](https://reactjs.org/docs/react-api.html#reactmemo) or
+[PureComponent](https://reactjs.org/docs/react-api.html#reactpurecomponent)
+will work for you. If it won't (if you need deep checks), it's wise to make
+sure you've correctly indentified the bottleneck in your application by
+[profiling the performance](https://reactjs.org/docs/optimizing-performance.html#profiling-components-with-the-chrome-performance-tab).
+After you've determined that you _do_ need deep equality checks and you've
+identified the minimum number of places to apply them, then this library may
+be for you!
+
+## Benchmarking this Library
+
+The absolute values are much less important than the relative differences
+between packages.
+
+Benchmarking source can be found
+[here](https://github.com/FormidableLabs/react-fast-compare/blob/master/benchmark/index.js).
+Each "operation" consists of running all relevant tests. The React benchmark
+uses both the generic tests and the react tests; these runs will be slower
+simply because there are more tests in each operation.
+
+The results below are from a local test on a laptop _(stats last updated 6/2/2020)_:
+
+### Generic Data
+
+```
+react-fast-compare x 177,600 ops/sec ±1.73% (92 runs sampled)
+fast-deep-equal x 184,211 ops/sec ±0.65% (87 runs sampled)
+lodash.isEqual x 39,826 ops/sec ±1.32% (86 runs sampled)
+nano-equal x 176,023 ops/sec ±0.89% (92 runs sampled)
+shallow-equal-fuzzy x 146,355 ops/sec ±0.64% (89 runs sampled)
+  fastest: fast-deep-equal
+```
+
+`react-fast-compare` and `fast-deep-equal` should be the same speed for these
+tests; any difference is just noise. `react-fast-compare` won't be faster than
+`fast-deep-equal`, because it's based on it.
+
+### React and Generic Data
+
+```
+react-fast-compare x 86,392 ops/sec ±0.70% (93 runs sampled)
+fast-deep-equal x 85,567 ops/sec ±0.95% (92 runs sampled)
+lodash.isEqual x 7,369 ops/sec ±1.78% (84 runs sampled)
+  fastest: react-fast-compare,fast-deep-equal
+```
+
+Two of these packages cannot handle comparing React elements, because they
+contain circular reference: `nano-equal` and `shallow-equal-fuzzy`.
+
+### Running Benchmarks
+
+```sh
+$ yarn install
+$ yarn run benchmark
+```
+
+## Differences between this library and `fast-deep-equal`
+
+`react-fast-compare` is based on `fast-deep-equal`, with some additions:
+
+- `react-fast-compare` has `try`/`catch` guardrails for stack overflows from undetected (non-React) circular references.
+- `react-fast-compare` has a _single_ unified entry point for all uses. No matter what your target application is, `import equal from 'react-fast-compare'` just works. `fast-deep-equal` has multiple entry points for different use cases.
+
+This version of `react-fast-compare` tracks `fast-deep-equal@3.1.1`.
+
+## Bundle Size
+
+There are a variety of ways to calculate bundle size for JavaScript code.
+You can see our size test code in the `compress` script in
+[`package.json`](https://github.com/FormidableLabs/react-fast-compare/blob/master/package.json).
+[Bundlephobia's calculation](https://bundlephobia.com/result?p=react-fast-compare) is slightly higher,
+as they [do not mangle during minification](https://github.com/pastelsky/package-build-stats/blob/v6.1.1/src/getDependencySizeTree.js#L139).
+
+## License
+
+[MIT](https://github.com/FormidableLabs/react-fast-compare/blob/readme/LICENSE)
+
+## Contributing
+
+Please see our [contributions guide](./CONTRIBUTING.md).
+
+## Maintenance Status
+
+**Active:** Formidable is actively working on this project, and we expect to continue for work for the foreseeable future. Bug reports, feature requests and pull requests are welcome.
+
+[actions_img]: https://github.com/FormidableLabs/react-fast-compare/actions/workflows/ci.yml/badge.svg
+[actions_site]: https://github.com/formidablelabs/react-fast-compare/actions/workflows/ci.yml
+[cov_img]: https://codecov.io/gh/FormidableLabs/react-fast-compare/branch/master/graph/badge.svg
+[cov_site]: https://codecov.io/gh/FormidableLabs/react-fast-compare
+[npm_img]: https://badge.fury.io/js/react-fast-compare.svg
+[npm_site]: http://badge.fury.io/js/react-fast-compare
+[appveyor_img]: https://ci.appveyor.com/api/projects/status/github/formidablelabs/react-fast-compare?branch=master&svg=true
+[appveyor_site]: https://ci.appveyor.com/project/FormidableLabs/react-fast-compare
+[bundle_img]: https://img.shields.io/badge/minzipped%20size-656%20B-flatgreen.svg
+[downloads_img]: https://img.shields.io/npm/dm/react-fast-compare.svg
+[maintenance_img]: https://img.shields.io/badge/maintenance-active-flatgreen.svg

node_modules/react-fast-compare/index.d.ts

@@ -0,0 +1,2 @@
+declare function isEqual<A = any, B = any>(a: A, b: B): boolean;
+export = isEqual;

node_modules/react-fast-compare/index.js

@@ -0,0 +1,139 @@
+/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */
+
+var hasElementType = typeof Element !== 'undefined';
+var hasMap = typeof Map === 'function';
+var hasSet = typeof Set === 'function';
+var hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;
+
+// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js
+
+function equal(a, b) {
+  // START: fast-deep-equal es6/index.js 3.1.3
+  if (a === b) return true;
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    if (a.constructor !== b.constructor) return false;
+
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (!equal(a[i], b[i])) return false;
+      return true;
+    }
+
+    // START: Modifications:
+    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code
+    //    to co-exist with es5.
+    // 2. Replace `for of` with es5 compliant iteration using `for`.
+    //    Basically, take:
+    //
+    //    ```js
+    //    for (i of a.entries())
+    //      if (!b.has(i[0])) return false;
+    //    ```
+    //
+    //    ... and convert to:
+    //
+    //    ```js
+    //    it = a.entries();
+    //    while (!(i = it.next()).done)
+    //      if (!b.has(i.value[0])) return false;
+    //    ```
+    //
+    //    **Note**: `i` access switches to `i.value`.
+    var it;
+    if (hasMap && (a instanceof Map) && (b instanceof Map)) {
+      if (a.size !== b.size) return false;
+      it = a.entries();
+      while (!(i = it.next()).done)
+        if (!b.has(i.value[0])) return false;
+      it = a.entries();
+      while (!(i = it.next()).done)
+        if (!equal(i.value[1], b.get(i.value[0]))) return false;
+      return true;
+    }
+
+    if (hasSet && (a instanceof Set) && (b instanceof Set)) {
+      if (a.size !== b.size) return false;
+      it = a.entries();
+      while (!(i = it.next()).done)
+        if (!b.has(i.value[0])) return false;
+      return true;
+    }
+    // END: Modifications
+
+    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (a[i] !== b[i]) return false;
+      return true;
+    }
+
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+    // START: Modifications:
+    // Apply guards for `Object.create(null)` handling. See:
+    // - https://github.com/FormidableLabs/react-fast-compare/issues/64
+    // - https://github.com/epoberezkin/fast-deep-equal/issues/49
+    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') return a.toString() === b.toString();
+    // END: Modifications
+
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) return false;
+
+    for (i = length; i-- !== 0;)
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+    // END: fast-deep-equal
+
+    // START: react-fast-compare
+    // custom handling for DOM elements
+    if (hasElementType && a instanceof Element) return false;
+
+    // custom handling for React/Preact
+    for (i = length; i-- !== 0;) {
+      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {
+        // React-specific: avoid traversing React elements' _owner
+        // Preact-specific: avoid traversing Preact elements' __v and __o
+        //    __v = $_original / $_vnode
+        //    __o = $_owner
+        // These properties contain circular references and are not needed when
+        // comparing the actual elements (and not their owners)
+        // .$$typeof and ._store on just reasonable markers of elements
+
+        continue;
+      }
+
+      // all other properties should be traversed as usual
+      if (!equal(a[keys[i]], b[keys[i]])) return false;
+    }
+    // END: react-fast-compare
+
+    // START: fast-deep-equal
+    return true;
+  }
+
+  return a !== a && b !== b;
+}
+// end fast-deep-equal
+
+module.exports = function isEqual(a, b) {
+  try {
+    return equal(a, b);
+  } catch (error) {
+    if (((error.message || '').match(/stack|recursion/i))) {
+      // warn on circular references, don't crash
+      // browsers give this different errors name and messages:
+      // chrome/safari: "RangeError", "Maximum call stack size exceeded"
+      // firefox: "InternalError", too much recursion"
+      // edge: "Error", "Out of stack space"
+      console.warn('react-fast-compare cannot handle circular refs');
+      return false;
+    }
+    // some other error. we should definitely know about these
+    throw error;
+  }
+};

node_modules/react-fast-compare/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "react-fast-compare",
+  "version": "3.2.2",
+  "description": "Fastest deep equal comparison for React. Great for React.memo & shouldComponentUpdate. Also really fast general-purpose deep comparison.",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "preversion": "yarn test",
+    "benchmark": "node benchmark",
+    "eslint": "eslint \"*.js\" benchmark test",
+    "tslint": "eslint test/typescript/*.tsx",
+    "test-browser": "karma start test/browser/karma.conf.js",
+    "test-node": "mocha \"test/node/*.spec.js\"",
+    "test-node-cov": "nyc mocha \"test/node/*.spec.js\"",
+    "test-ts-usage": "tsc --esModuleInterop --jsx react --noEmit test/typescript/sample-react-redux-usage.tsx test/typescript/sample-usage.tsx",
+    "test-ts-defs": "tsc --target ES5 index.d.ts",
+    "test": "builder concurrent --buffer eslint tslint test-ts-usage test-ts-defs test-node-cov test-browser",
+    "compress": "terser --compress --mangle=\"toplevel:true\" -- index.js",
+    "size-min-gz": "yarn -s compress | gzip -9 | wc -c"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FormidableLabs/react-fast-compare"
+  },
+  "keywords": [
+    "fast",
+    "equal",
+    "react",
+    "compare",
+    "shouldComponentUpdate",
+    "deep-equal"
+  ],
+  "author": "Chris Bolin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/FormidableLabs/react-fast-compare/issues"
+  },
+  "homepage": "https://github.com/FormidableLabs/react-fast-compare",
+  "devDependencies": {
+    "@babel/core": "^7.21.0",
+    "@babel/preset-env": "^7.20.2",
+    "@changesets/cli": "^2.26.1",
+    "@svitejs/changesets-changelog-github-compact": "^0.1.1",
+    "@testing-library/dom": "^9.0.1",
+    "@testing-library/preact": "^3.2.3",
+    "@types/node": "^18.15.0",
+    "@types/react": "^16.9.35",
+    "@types/react-dom": "^16.9.8",
+    "@types/react-redux": "^7.1.25",
+    "@typescript-eslint/parser": "^5.54.1",
+    "assert": "^2.0.0",
+    "babel-loader": "^9.1.2",
+    "benchmark": "^2.1.4",
+    "builder": "^5.0.0",
+    "codecov": "^3.8.3",
+    "core-js": "^3.29.0",
+    "eslint": "^8.35.0",
+    "eslint-plugin-react": "^7.32.2",
+    "fast-deep-equal": "3.1.3",
+    "fast-deep-equal-git": "epoberezkin/fast-deep-equal#v3.1.3",
+    "jsdom": "^21.1.0",
+    "jsdom-global": "^3.0.2",
+    "karma": "^6.4.1",
+    "karma-chrome-launcher": "^3.1.1",
+    "karma-firefox-launcher": "^2.1.2",
+    "karma-mocha": "^2.0.1",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-safari-launcher": "^1.0.0",
+    "karma-webpack": "^5.0.0",
+    "lodash": "^4.17.10",
+    "mocha": "^10.2.0",
+    "nano-equal": "^2.0.2",
+    "nyc": "^15.1.0",
+    "preact": "^10.13.1",
+    "process": "^0.11.10",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-redux": "^8.0.5",
+    "react-test-renderer": "^18.2.0",
+    "redux": "^4.2.1",
+    "shallow-equal-fuzzy": "0.0.2",
+    "sinon": "^15.0.1",
+    "terser": "^5.16.6",
+    "typescript": "^4.9.5",
+    "webpack": "^5.76.0"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "nyc": {
+    "exclude": [
+      "**/test/**",
+      "node_modules"
+    ],
+    "reporter": [
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "types": "index.d.ts"
+}