Initial commit: Crypto trader application

frontend/node_modules/fast-equals/LICENSE

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

frontend/node_modules/fast-equals/README.md

@@ -0,0 +1,477 @@
+# fast-equals
+
+<img src="https://img.shields.io/badge/build-passing-brightgreen.svg"/>
+<img src="https://img.shields.io/badge/coverage-100%25-brightgreen.svg"/>
+<img src="https://img.shields.io/badge/license-MIT-blue.svg"/>
+
+Perform [blazing fast](#benchmarks) equality comparisons (either deep or shallow) on two objects passed, while also
+maintaining a high degree of flexibility for various implementation use-cases. It has no dependencies, and is ~2kB when
+minified and gzipped.
+
+The following types are handled out-of-the-box:
+
+- Plain objects (including `react` elements and `Arguments`)
+- Arrays
+- `ArrayBuffer` / `TypedArray` / `DataView` instances
+- `Date` objects
+- `RegExp` objects
+- `Map` / `Set` iterables
+- `Promise` objects
+- Primitive wrappers (`new Boolean()` / `new Number()` / `new String()`)
+- Custom class instances, including subclasses of native classes
+
+Methods are available for deep, shallow, or referential equality comparison. In addition, you can opt into support for
+circular objects, or performing a "strict" comparison with unconventional property definition, or both. You can also
+customize any specific type comparison based on your application's use-cases.
+
+## Table of contents
+
+- [fast-equals](#fast-equals)
+  - [Table of contents](#table-of-contents)
+  - [Usage](#usage)
+    - [Specific builds](#specific-builds)
+  - [Available methods](#available-methods)
+    - [deepEqual](#deepequal)
+      - [Comparing `Map`s](#comparing-maps)
+    - [shallowEqual](#shallowequal)
+    - [sameValueZeroEqual](#samevaluezeroequal)
+    - [circularDeepEqual](#circulardeepequal)
+    - [circularShallowEqual](#circularshallowequal)
+    - [strictDeepEqual](#strictdeepequal)
+    - [strictShallowEqual](#strictshallowequal)
+    - [strictCircularDeepEqual](#strictcirculardeepequal)
+    - [strictCircularShallowEqual](#strictcircularshallowequal)
+    - [createCustomEqual](#createcustomequal)
+      - [unknownTagComparators](#unknowntagcomparators)
+      - [Recipes](#recipes)
+  - [Benchmarks](#benchmarks)
+  - [Development](#development)
+
+## Usage
+
+```ts
+import { deepEqual } from 'fast-equals';
+
+console.log(deepEqual({ foo: 'bar' }, { foo: 'bar' })); // true
+```
+
+### Specific builds
+
+By default, npm should resolve the correct build of the package based on your consumption (ESM vs CommonJS). However, if
+you want to force use of a specific build, they can be located here:
+
+- ESM => `fast-equals/dist/esm/index.mjs`
+- CommonJS => `fast-equals/dist/cjs/index.cjs`
+- UMD => `fast-equals/dist/umd/index.js`
+- Minified UMD => `fast-equals/dist/min/index.js`
+
+If you are having issues loading a specific build type,
+[please file an issue](https://github.com/planttheidea/fast-equals/issues).
+
+## Available methods
+
+### deepEqual
+
+Performs a deep equality comparison on the two objects passed and returns a boolean representing the value equivalency
+of the objects.
+
+```ts
+import { deepEqual } from 'fast-equals';
+
+const objectA = { foo: { bar: 'baz' } };
+const objectB = { foo: { bar: 'baz' } };
+
+console.log(objectA === objectB); // false
+console.log(deepEqual(objectA, objectB)); // true
+```
+
+#### Comparing `Map`s
+
+`Map` objects support complex keys (objects, Arrays, etc.), however
+[the spec for key lookups in `Map` are based on `SameZeroValue`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#key_equality).
+If the spec were followed for comparison, the following would always be `false`:
+
+```ts
+const mapA = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);
+const mapB = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);
+
+deepEqual(mapA, mapB);
+```
+
+To support true deep equality of all contents, `fast-equals` will perform a deep equality comparison for key and value
+parirs. Therefore, the above would be `true`.
+
+### shallowEqual
+
+Performs a shallow equality comparison on the two objects passed and returns a boolean representing the value
+equivalency of the objects.
+
+```ts
+import { shallowEqual } from 'fast-equals';
+
+const nestedObject = { bar: 'baz' };
+
+const objectA = { foo: nestedObject };
+const objectB = { foo: nestedObject };
+const objectC = { foo: { bar: 'baz' } };
+
+console.log(objectA === objectB); // false
+console.log(shallowEqual(objectA, objectB)); // true
+console.log(shallowEqual(objectA, objectC)); // false
+```
+
+### sameValueZeroEqual
+
+Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) comparison on the two
+objects passed and returns a boolean representing the value equivalency of the objects. In simple terms, this means
+either strictly equal or both `NaN`.
+
+```ts
+import { sameValueZeroEqual } from 'fast-equals';
+
+const mainObject = { foo: NaN, bar: 'baz' };
+
+const objectA = 'baz';
+const objectB = NaN;
+const objectC = { foo: NaN, bar: 'baz' };
+
+console.log(sameValueZeroEqual(mainObject.bar, objectA)); // true
+console.log(sameValueZeroEqual(mainObject.foo, objectB)); // true
+console.log(sameValueZeroEqual(mainObject, objectC)); // false
+```
+
+### circularDeepEqual
+
+Performs the same comparison as `deepEqual` but supports circular objects. It is slower than `deepEqual`, so only use if
+you know circular objects are present.
+
+```ts
+function Circular(value) {
+  this.me = {
+    deeply: {
+      nested: {
+        reference: this,
+      },
+    },
+    value,
+  };
+}
+
+console.log(circularDeepEqual(new Circular('foo'), new Circular('foo'))); // true
+console.log(circularDeepEqual(new Circular('foo'), new Circular('bar'))); // false
+```
+
+Just as with `deepEqual`, [both keys and values are compared for deep equality](#comparing-maps).
+
+### circularShallowEqual
+
+Performs the same comparison as `shallowequal` but supports circular objects. It is slower than `shallowEqual`, so only
+use if you know circular objects are present.
+
+```ts
+const array = ['foo'];
+
+array.push(array);
+
+console.log(circularShallowEqual(array, ['foo', array])); // true
+console.log(circularShallowEqual(array, [array])); // false
+```
+
+### strictDeepEqual
+
+Performs the same comparison as `deepEqual` but performs a strict comparison of the objects. In this includes:
+
+- Checking symbol properties
+- Checking non-enumerable properties in object comparisons
+- Checking full descriptor of properties on the object to match
+- Checking non-index properties on arrays
+- Checking non-key properties on `Map` / `Set` objects
+
+```ts
+const array = [{ foo: 'bar' }];
+const otherArray = [{ foo: 'bar' }];
+
+array.bar = 'baz';
+otherArray.bar = 'baz';
+
+console.log(strictDeepEqual(array, otherArray)); // true;
+console.log(strictDeepEqual(array, [{ foo: 'bar' }])); // false;
+```
+
+### strictShallowEqual
+
+Performs the same comparison as `shallowEqual` but performs a strict comparison of the objects. In this includes:
+
+- Checking non-enumerable properties in object comparisons
+- Checking full descriptor of properties on the object to match
+- Checking non-index properties on arrays
+- Checking non-key properties on `Map` / `Set` objects
+
+```ts
+const array = ['foo'];
+const otherArray = ['foo'];
+
+array.bar = 'baz';
+otherArray.bar = 'baz';
+
+console.log(strictDeepEqual(array, otherArray)); // true;
+console.log(strictDeepEqual(array, ['foo'])); // false;
+```
+
+### strictCircularDeepEqual
+
+Performs the same comparison as `circularDeepEqual` but performs a strict comparison of the objects. In this includes:
+
+- Checking `Symbol` properties on the object
+- Checking non-enumerable properties in object comparisons
+- Checking full descriptor of properties on the object to match
+- Checking non-index properties on arrays
+- Checking non-key properties on `Map` / `Set` objects
+
+```ts
+function Circular(value) {
+  this.me = {
+    deeply: {
+      nested: {
+        reference: this,
+      },
+    },
+    value,
+  };
+}
+
+const first = new Circular('foo');
+
+Object.defineProperty(first, 'bar', {
+  enumerable: false,
+  value: 'baz',
+});
+
+const second = new Circular('foo');
+
+Object.defineProperty(second, 'bar', {
+  enumerable: false,
+  value: 'baz',
+});
+
+console.log(circularDeepEqual(first, second)); // true
+console.log(circularDeepEqual(first, new Circular('foo'))); // false
+```
+
+### strictCircularShallowEqual
+
+Performs the same comparison as `circularShallowEqual` but performs a strict comparison of the objects. In this
+includes:
+
+- Checking non-enumerable properties in object comparisons
+- Checking full descriptor of properties on the object to match
+- Checking non-index properties on arrays
+- Checking non-key properties on `Map` / `Set` objects
+
+```ts
+const array = ['foo'];
+const otherArray = ['foo'];
+
+array.push(array);
+otherArray.push(otherArray);
+
+array.bar = 'baz';
+otherArray.bar = 'baz';
+
+console.log(circularShallowEqual(array, otherArray)); // true
+console.log(circularShallowEqual(array, ['foo', array])); // false
+```
+
+### createCustomEqual
+
+Creates a custom equality comparator that will be used on nested values in the object. Unlike `deepEqual` and
+`shallowEqual`, this is a factory method that receives the default options used internally, and allows you to override
+the defaults as needed. This is generally for extreme edge-cases, or supporting legacy environments.
+
+The signature is as follows:
+
+```ts
+interface Cache<Key extends object, Value> {
+  delete(key: Key): boolean;
+  get(key: Key): Value | undefined;
+  set(key: Key, value: any): any;
+}
+
+interface ComparatorConfig<Meta> {
+  areArraysEqual: TypeEqualityComparator<any[], Meta>;
+  areDatesEqual: TypeEqualityComparator<Date, Meta>;
+  areErrorsEqual: TypeEqualityComparator<Error, Meta>;
+  areFunctionsEqual: TypeEqualityComparator<(...args: any[]) => any, Meta>;
+  areMapsEqual: TypeEqualityComparator<Map<any, any>, Meta>;
+  areObjectsEqual: TypeEqualityComparator<Record<string, any>, Meta>;
+  arePrimitiveWrappersEqual: TypeEqualityComparator<boolean | string | number, Meta>;
+  areRegExpsEqual: TypeEqualityComparator<RegExp, Meta>;
+  areSetsEqual: TypeEqualityComparator<Set<any>, Meta>;
+  areTypedArraysEqual: TypeEqualityComparator<TypedArray, Meta>;
+  areUrlsEqual: TypeEqualityComparator<URL, Meta>;
+  unknownTagComparators: Record<string, TypeEqualityComparator<string, any>>;
+}
+
+function createCustomEqual<Meta>(options: {
+  circular?: boolean;
+  createCustomConfig?: (defaultConfig: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
+  createInternalComparator?: (
+    compare: <A, B>(a: A, b: B, state: State<Meta>) => boolean,
+  ) => (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;
+  createState?: () => { cache?: Cache; meta?: Meta };
+  strict?: boolean;
+}): <A, B>(a: A, b: B) => boolean;
+```
+
+Create a custom equality comparator. This allows complete control over building a bespoke equality method, in case your
+use-case requires a higher degree of performance, legacy environment support, or any other non-standard usage. The
+[recipes](#recipes) provide examples of use in different use-cases, but if you have a specific goal in mind and would
+like assistance feel free to [file an issue](https://github.com/planttheidea/fast-equals/issues).
+
+_**NOTE**: `Map` implementations compare equality for both keys and value. When using a custom comparator and comparing
+equality of the keys, the iteration index is provided as both `indexOrKeyA` and `indexOrKeyB` to help use-cases where
+ordering of keys matters to equality._
+
+#### unknownTagComparators
+
+If you want to compare objects that have a custom `@@toStringTag`, you can provide a map of the custom tags you want to
+support via the `unknownTagComparators` option. See [this recipe]('./recipes/special-objects.md) for an example.
+
+#### Recipes
+
+Some recipes have been created to provide examples of use-cases for `createCustomEqual`. Even if not directly applicable
+to the problem you are solving, they can offer guidance of how to structure your solution.
+
+- [Legacy environment support for `RegExp` comparators](./recipes/legacy-regexp-support.md)
+- [Explicit property check](./recipes/explicit-property-check.md)
+- [Using `meta` in comparison](./recipes//using-meta-in-comparison.md)
+- [Comparing non-standard properties](./recipes/non-standard-properties.md)
+- [Strict property descriptor comparison](./recipes/strict-property-descriptor-check.md)
+- [Legacy environment support for circualr equal comparators](./recipes/legacy-circular-equal-support.md)
+- [Custom `@@toStringTag` support](./recipes/special-objects.md)
+
+## Benchmarks
+
+All benchmarks were performed on an i9-11900H Ubuntu Linux 24.04 laptop with 64GB of memory using NodeJS version
+`20.17.0`, and are based on averages of running comparisons based deep equality on the following object types:
+
+- Primitives (`String`, `Number`, `null`, `undefined`)
+- `Function`
+- `Object`
+- `Array`
+- `Date`
+- `RegExp`
+- `react` elements
+- A mixed object with a combination of all the above types
+
+```bash
+Testing mixed objects equal...
+┌────────────────────────────────────────┬────────────────┐
+│ Name                                   │ Ops / sec      │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (passed)                   │ 1416193.769468 │
+├────────────────────────────────────────┼────────────────┤
+│ fast-deep-equal (passed)               │ 1284824.583215 │
+├────────────────────────────────────────┼────────────────┤
+│ react-fast-compare (passed)            │ 1246947.505444 │
+├────────────────────────────────────────┼────────────────┤
+│ shallow-equal-fuzzy (passed)           │ 1238082.379207 │
+├────────────────────────────────────────┼────────────────┤
+│ nano-equal (failed)                    │ 946782.33704   │
+├────────────────────────────────────────┼────────────────┤
+│ dequal/lite (passed)                   │ 758213.632866  │
+├────────────────────────────────────────┼────────────────┤
+│ dequal (passed)                        │ 756789.655029  │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (circular) (passed)        │ 726093.253185  │
+├────────────────────────────────────────┼────────────────┤
+│ underscore.isEqual (passed)            │ 489748.701783  │
+├────────────────────────────────────────┼────────────────┤
+│ assert.deepStrictEqual (passed)        │ 453761.890107  │
+├────────────────────────────────────────┼────────────────┤
+│ lodash.isEqual (passed)                │ 288264.867811  │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (strict) (passed)          │ 217221.619705  │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (strict circular) (passed) │ 186916.942934  │
+├────────────────────────────────────────┼────────────────┤
+│ deep-eql (passed)                      │ 162487.877883  │
+├────────────────────────────────────────┼────────────────┤
+│ deep-equal (passed)                    │ 916.680714     │
+└────────────────────────────────────────┴────────────────┘
+
+Testing mixed objects not equal...
+┌────────────────────────────────────────┬────────────────┐
+│ Name                                   │ Ops / sec      │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (passed)                   │ 4687012.640614 │
+├────────────────────────────────────────┼────────────────┤
+│ fast-deep-equal (passed)               │ 3418170.156109 │
+├────────────────────────────────────────┼────────────────┤
+│ react-fast-compare (passed)            │ 3283516.669966 │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (circular) (passed)        │ 3268062.099602 │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (strict) (passed)          │ 1747578.66456  │
+├────────────────────────────────────────┼────────────────┤
+│ fast-equals (strict circular) (passed) │ 1477873.624956 │
+├────────────────────────────────────────┼────────────────┤
+│ dequal/lite (passed)                   │ 1335397.839502 │
+├────────────────────────────────────────┼────────────────┤
+│ dequal (passed)                        │ 1319426.71146  │
+├────────────────────────────────────────┼────────────────┤
+│ shallow-equal-fuzzy (failed)           │ 1237432.986615 │
+├────────────────────────────────────────┼────────────────┤
+│ nano-equal (passed)                    │ 1064383.319776 │
+├────────────────────────────────────────┼────────────────┤
+│ underscore.isEqual (passed)            │ 920462.516736  │
+├────────────────────────────────────────┼────────────────┤
+│ lodash.isEqual (passed)                │ 379370.998021  │
+├────────────────────────────────────────┼────────────────┤
+│ deep-eql (passed)                      │ 184111.383127  │
+├────────────────────────────────────────┼────────────────┤
+│ assert.deepStrictEqual (passed)        │ 20775.59065    │
+├────────────────────────────────────────┼────────────────┤
+│ deep-equal (passed)                    │ 3678.51009     │
+└────────────────────────────────────────┴────────────────┘
+```
+
+Caveats that impact the benchmark (and accuracy of comparison):
+
+- `Map`s, `Promise`s, and `Set`s were excluded from the benchmark entirely because no library other than `deep-eql`
+  fully supported their comparison
+- `fast-deep-equal`, `react-fast-compare` and `nano-equal` throw on objects with `null` as prototype
+  (`Object.create(null)`)
+- `assert.deepStrictEqual` does not support `NaN` or `SameValueZero` equality for dates
+- `deep-eql` does not support `SameValueZero` equality for zero equality (positive and negative zero are not equal)
+- `deep-equal` does not support `NaN` and does not strictly compare object type, or date / regexp values, nor uses
+  `SameValueZero` equality for dates
+- `fast-deep-equal` does not support `NaN` or `SameValueZero` equality for dates
+- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValueZero`
+  equality for dates
+- `react-fast-compare` does not support `NaN` or `SameValueZero` equality for dates, and does not compare `function`
+  equality
+- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValueZero` equality for dates
+- `underscore.isEqual` does not support `SameValueZero` equality for primitives or dates
+
+All of these have the potential of inflating the respective library's numbers in comparison to `fast-equals`, but it was
+the closest apples-to-apples comparison I could create of a reasonable sample size. It should be noted that `react`
+elements can be circular objects, however simple elements are not; I kept the `react` comparison very basic to allow it
+to be included.
+
+## Development
+
+Standard practice, clone the repo and `npm i` to get the dependencies. The following npm scripts are available:
+
+- benchmark => run benchmark tests against other equality libraries
+- build => build `main`, `module`, and `browser` distributables with `rollup`
+- clean => run `rimraf` on the `dist` folder
+- dev => start `vite` playground App
+- dist => run `build`
+- lint => run ESLint on all files in `src` folder (also runs on `dev` script)
+- lint:fix => run `lint` script, but with auto-fixer
+- prepublish:compile => run `lint`, `test:coverage`, `transpile:lib`, `transpile:es`, and `dist` scripts
+- start => run `dev`
+- test => run AVA with NODE_ENV=test on all files in `test` folder
+- test:coverage => run same script as `test` with code coverage calculation via `nyc`
+- test:watch => run same script as `test` but keep persistent watcher

frontend/node_modules/fast-equals/index.d.ts

@@ -0,0 +1,260 @@
+/**
+ * Cache used to store references to objects, used for circular
+ * reference checks.
+ */
+interface Cache<Key extends object, Value> {
+  delete(key: Key): boolean;
+  get(key: Key): Value | undefined;
+  set(key: Key, value: any): any;
+}
+interface State<Meta> {
+  /**
+   * Cache used to identify circular references
+   */
+  readonly cache: Cache<any, any> | undefined;
+  /**
+   * Method used to determine equality of nested value.
+   */
+  readonly equals: InternalEqualityComparator<Meta>;
+  /**
+   * Additional value that can be used for comparisons.
+   */
+  meta: Meta;
+  /**
+   * Whether the equality comparison is strict, meaning it matches
+   * all properties (including symbols and non-enumerable properties)
+   * with equal shape of descriptors.
+   */
+  readonly strict: boolean;
+}
+interface CircularState<Meta> extends State<Meta> {
+  readonly cache: Cache<any, any>;
+}
+interface DefaultState<Meta> extends State<Meta> {
+  readonly cache: undefined;
+}
+interface Dictionary<Value = any> {
+  [key: string | symbol]: Value;
+  $$typeof?: any;
+}
+interface ComparatorConfig<Meta> {
+  /**
+   * Whether the array buffers passed are equal in value. In strict mode, this includes
+   * additional properties added to the array.
+   */
+  areArrayBuffersEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the arrays passed are equal in value. In strict mode, this includes
+   * additional properties added to the array.
+   */
+  areArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the data views passed are equal in value.
+   */
+  areDataViewsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the dates passed are equal in value.
+   */
+  areDatesEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the errors passed are equal in value.
+   */
+  areErrorsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the functions passed are equal in value.
+   */
+  areFunctionsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the maps passed are equal in value. In strict mode, this includes
+   * additional properties added to the map.
+   */
+  areMapsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the numbers passed are equal in value.
+   */
+  areNumbersEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the objects passed are equal in value. In strict mode, this includes
+   * non-enumerable properties added to the map, as well as symbol properties.
+   */
+  areObjectsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the primitive wrappers passed are equal in value.
+   */
+  arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the regexps passed are equal in value.
+   */
+  areRegExpsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the sets passed are equal in value. In strict mode, this includes
+   * additional properties added to the set.
+   */
+  areSetsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the typed arrays passed are equal in value. In strict mode, this includes
+   * additional properties added to the typed array.
+   */
+  areTypedArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the URLs passed are equal in value.
+   */
+  areUrlsEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
+   * called when no other comparator applies.
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+   */
+  unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
+}
+type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
+type CreateState<Meta> = () => {
+  cache?: Cache<any, any> | undefined;
+  meta?: Meta;
+};
+type EqualityComparator<Meta> = <A, B>(a: A, b: B, state: State<Meta>) => boolean;
+type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) => boolean;
+type EqualityComparatorCreator<Meta> = (fn: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
+type InternalEqualityComparator<Meta> = (
+  a: any,
+  b: any,
+  indexOrKeyA: any,
+  indexOrKeyB: any,
+  parentA: any,
+  parentB: any,
+  state: State<Meta>,
+) => boolean;
+type PrimitiveWrapper = Boolean | Number | String;
+/**
+ * Type which encompasses possible instances of TypedArray
+ * classes.
+ */
+type TypedArray =
+  | BigInt64Array
+  | BigUint64Array
+  | Float32Array
+  | Float64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | Uint16Array
+  | Uint32Array
+  | Uint8Array
+  | Uint8ClampedArray;
+type TypeEqualityComparator<Type, Meta = undefined> = (a: Type, b: Type, state: State<Meta>) => boolean;
+interface CustomEqualCreatorOptions<Meta> {
+  /**
+   * Whether circular references should be supported. It causes the
+   * comparison to be slower, but for objects that have circular references
+   * it is required to avoid stack overflows.
+   */
+  circular?: boolean;
+  /**
+   * Create a custom configuration of type-specific equality comparators.
+   * This receives the default configuration, which allows either replacement
+   * or supersetting of the default methods.
+   */
+  createCustomConfig?: CreateCustomComparatorConfig<Meta>;
+  /**
+   * Create a custom internal comparator, which is used as an override to the
+   * default entry point for nested value equality comparisons. This is often
+   * used for doing custom logic for specific types (such as handling a specific
+   * class instance differently than other objects) or to incorporate `meta` in
+   * the comparison. See the recipes for examples.
+   */
+  createInternalComparator?: (compare: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
+  /**
+   * Create a custom `state` object passed between the methods. This allows for
+   * custom `cache` and/or `meta` values to be used.
+   */
+  createState?: CreateState<Meta>;
+  /**
+   * Whether the equality comparison is strict, meaning it matches
+   * all properties (including symbols and non-enumerable properties)
+   * with equal shape of descriptors.
+   */
+  strict?: boolean;
+}
+
+/**
+ * Whether the values passed are strictly equal or both NaN.
+ */
+declare function sameValueZeroEqual(a: any, b: any): boolean;
+
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+declare const deepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+declare const strictDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+declare const strictCircularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+declare const strictShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Create a custom equality comparison method.
+ *
+ * This can be done to create very targeted comparisons in extreme hot-path scenarios
+ * where the standard methods are not performant enough, but can also be used to provide
+ * support for legacy environments that do not support expected features like
+ * `RegExp.prototype.flags` out of the box.
+ */
+declare function createCustomEqual<Meta = undefined>(
+  options?: CustomEqualCreatorOptions<Meta>,
+): <A, B>(a: A, b: B) => boolean;
+
+export {
+  circularDeepEqual,
+  circularShallowEqual,
+  createCustomEqual,
+  deepEqual,
+  sameValueZeroEqual,
+  shallowEqual,
+  strictCircularDeepEqual,
+  strictCircularShallowEqual,
+  strictDeepEqual,
+  strictShallowEqual,
+};
+export type {
+  AnyEqualityComparator,
+  Cache,
+  CircularState,
+  ComparatorConfig,
+  CreateCustomComparatorConfig,
+  CreateState,
+  CustomEqualCreatorOptions,
+  DefaultState,
+  Dictionary,
+  EqualityComparator,
+  EqualityComparatorCreator,
+  InternalEqualityComparator,
+  PrimitiveWrapper,
+  State,
+  TypeEqualityComparator,
+  TypedArray,
+};

frontend/node_modules/fast-equals/package.json

@@ -0,0 +1,113 @@
+{
+  "author": "tony_quetano@planttheidea.com",
+  "browser": "dist/umd/index.js",
+  "bugs": {
+    "url": "https://github.com/planttheidea/fast-equals/issues"
+  },
+  "description": "A blazing fast equality comparison, either shallow or deep",
+  "devDependencies": {
+    "@planttheidea/build-tools": "^1.2.3",
+    "@types/lodash": "^4.17.21",
+    "@types/node": "^24.10.3",
+    "@types/ramda": "^0.31.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@typescript-eslint/eslint-plugin": "^8.49.0",
+    "@typescript-eslint/parser": "^8.49.0",
+    "@vitest/coverage-v8": "^4.0.15",
+    "cli-table3": "^0.6.5",
+    "decircularize": "^1.0.0",
+    "deep-eql": "^5.0.2",
+    "deep-equal": "^2.2.3",
+    "dequal": "^2.0.3",
+    "eslint": "^9.39.2",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-plugin-import": "^2.32.0",
+    "fast-deep-equal": "^3.1.3",
+    "fast-glob": "^3.3.3",
+    "lodash": "^4.17.21",
+    "nano-equal": "^2.0.2",
+    "prettier": "^3.7.4",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "react-fast-compare": "^3.2.2",
+    "release-it": "^19.1.0",
+    "rollup": "^4.53.3",
+    "shallow-equal-fuzzy": "^0.0.2",
+    "tinybench": "^6.0.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.49.0",
+    "underscore": "^1.13.7",
+    "vite": "^7.2.7",
+    "vitest": "^4.0.15"
+  },
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/es/index.d.mts",
+        "default": "./dist/es/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      },
+      "default": {
+        "types": "./dist/umd/index.d.ts",
+        "default": "./dist/umd/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "index.d.ts",
+    "package.json"
+  ],
+  "homepage": "https://github.com/planttheidea/fast-equals#readme",
+  "keywords": [
+    "fast",
+    "equal",
+    "equals",
+    "deep-equal",
+    "equivalent"
+  ],
+  "license": "MIT",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/es/index.mjs",
+  "name": "fast-equals",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/planttheidea/fast-equals.git"
+  },
+  "scripts": {
+    "benchmark": "npm run build && node benchmark/index.js",
+    "build": "npm run clean && npm run build:dist && npm run build:types",
+    "build:dist": "NODE_ENV=production rollup -c config/rollup.config.js",
+    "build:types": "pti fix-types -l dist",
+    "clean": "rm -rf dist",
+    "clean:cjs": "rm -rf dist/cjs",
+    "clean:es": "rm -rf dist/es",
+    "clean:umd": "rm -rf dist/umd",
+    "dev": "vite --config=config/vite.config.ts",
+    "format": "prettier . --log-level=warn --write",
+    "format:check": "prettier . --log-level=warn --check",
+    "lint": "eslint --max-warnings=0",
+    "lint:fix": "npm run lint -- --fix",
+    "release:alpha": "release-it --config=config/release-it/alpha.json",
+    "release:beta": "release-it --config=config/release-it/beta.json",
+    "release:rc": "release-it --config=config/release-it/rc.json",
+    "release:scripts": "npm run format:check && npm run typecheck && npm run lint && npm run test && npm run build",
+    "release:stable": "release-it --config=config/release-it/stable.json",
+    "start": "npm run dev",
+    "test": "vitest run --config=config/vitest.config.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./index.d.ts",
+  "version": "5.4.0"
+}