Index: node_modules/reselect/src/autotrackMemoize/autotrackMemoize.ts
===================================================================
--- node_modules/reselect/src/autotrackMemoize/autotrackMemoize.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/reselect/src/autotrackMemoize/autotrackMemoize.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,100 @@
+import { createNode, updateNode } from './proxy'
+import type { Node } from './tracking'
+
+import { createCacheKeyComparator, referenceEqualityCheck } from '../lruMemoize'
+import type { AnyFunction, DefaultMemoizeFields, Simplify } from '../types'
+import { createCache } from './autotracking'
+
+/**
+ * Uses an "auto-tracking" approach inspired by the work of the Ember Glimmer team.
+ * It uses a Proxy to wrap arguments and track accesses to nested fields
+ * in your selector on first read. Later, when the selector is called with
+ * new arguments, it identifies which accessed fields have changed and
+ * only recalculates the result if one or more of those accessed fields have changed.
+ * This allows it to be more precise than the shallow equality checks in `lruMemoize`.
+ *
+ * __Design Tradeoffs for `autotrackMemoize`:__
+ * - Pros:
+ *    - It is likely to avoid excess calculations and recalculate fewer times than `lruMemoize` will,
+ *    which may also result in fewer component re-renders.
+ * - Cons:
+ *    - It only has a cache size of 1.
+ *    - It is slower than `lruMemoize`, because it has to do more work. (How much slower is dependent on the number of accessed fields in a selector, number of calls, frequency of input changes, etc)
+ *    - It can have some unexpected behavior. Because it tracks nested field accesses,
+ *    cases where you don't access a field will not recalculate properly.
+ *    For example, a badly-written selector like:
+ *      ```ts
+ *      createSelector([state => state.todos], todos => todos)
+ *      ```
+ *      that just immediately returns the extracted value will never update, because it doesn't see any field accesses to check.
+ *
+ * __Use Cases for `autotrackMemoize`:__
+ * - It is likely best used for cases where you need to access specific nested fields
+ * in data, and avoid recalculating if other fields in the same data objects are immutably updated.
+ *
+ * @param func - The function to be memoized.
+ * @returns A memoized function with a `.clearCache()` method attached.
+ *
+ * @example
+ * <caption>Using `createSelector`</caption>
+ * ```ts
+ * import { unstable_autotrackMemoize as autotrackMemoize, createSelector } from 'reselect'
+ *
+ * const selectTodoIds = createSelector(
+ *   [(state: RootState) => state.todos],
+ *   (todos) => todos.map(todo => todo.id),
+ *   { memoize: autotrackMemoize }
+ * )
+ * ```
+ *
+ * @example
+ * <caption>Using `createSelectorCreator`</caption>
+ * ```ts
+ * import { unstable_autotrackMemoize as autotrackMemoize, createSelectorCreator } from 'reselect'
+ *
+ * const createSelectorAutotrack = createSelectorCreator({ memoize: autotrackMemoize })
+ *
+ * const selectTodoIds = createSelectorAutotrack(
+ *   [(state: RootState) => state.todos],
+ *   (todos) => todos.map(todo => todo.id)
+ * )
+ * ```
+ *
+ * @template Func - The type of the function that is memoized.
+ *
+ * @see {@link https://reselect.js.org/api/unstable_autotrackMemoize autotrackMemoize}
+ *
+ * @since 5.0.0
+ * @public
+ * @experimental
+ */
+export function autotrackMemoize<Func extends AnyFunction>(func: Func) {
+  // we reference arguments instead of spreading them for performance reasons
+
+  const node: Node<Record<string, unknown>> = createNode(
+    [] as unknown as Record<string, unknown>
+  )
+
+  let lastArgs: IArguments | null = null
+
+  const shallowEqual = createCacheKeyComparator(referenceEqualityCheck)
+
+  const cache = createCache(() => {
+    const res = func.apply(null, node.proxy as unknown as any[])
+    return res
+  })
+
+  function memoized() {
+    if (!shallowEqual(lastArgs, arguments)) {
+      updateNode(node, arguments as unknown as Record<string, unknown>)
+      lastArgs = arguments
+    }
+    return cache.value
+  }
+
+  memoized.clearCache = () => {
+    return cache.clear()
+  }
+
+  return memoized as Func & Simplify<DefaultMemoizeFields>
+}
Index: node_modules/reselect/src/autotrackMemoize/autotracking.ts
===================================================================
--- node_modules/reselect/src/autotrackMemoize/autotracking.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/reselect/src/autotrackMemoize/autotracking.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,159 @@
+// Original autotracking implementation source:
+// - https://gist.github.com/pzuraq/79bf862e0f8cd9521b79c4b6eccdc4f9
+// Additional references:
+// - https://www.pzuraq.com/blog/how-autotracking-works
+// - https://v5.chriskrycho.com/journal/autotracking-elegant-dx-via-cutting-edge-cs/
+import type { EqualityFn } from '../types'
+import { assertIsFunction } from '../utils'
+
+// The global revision clock. Every time state changes, the clock increments.
+export let $REVISION = 0
+
+// The current dependency tracker. Whenever we compute a cache, we create a Set
+// to track any dependencies that are used while computing. If no cache is
+// computing, then the tracker is null.
+let CURRENT_TRACKER: Set<Cell<any> | TrackingCache> | null = null
+
+// Storage represents a root value in the system - the actual state of our app.
+export class Cell<T> {
+  revision = $REVISION
+
+  _value: T
+  _lastValue: T
+  _isEqual: EqualityFn = tripleEq
+
+  constructor(initialValue: T, isEqual: EqualityFn = tripleEq) {
+    this._value = this._lastValue = initialValue
+    this._isEqual = isEqual
+  }
+
+  // Whenever a storage value is read, it'll add itself to the current tracker if
+  // one exists, entangling its state with that cache.
+  get value() {
+    CURRENT_TRACKER?.add(this)
+
+    return this._value
+  }
+
+  // Whenever a storage value is updated, we bump the global revision clock,
+  // assign the revision for this storage to the new value, _and_ we schedule a
+  // rerender. This is important, and it's what makes autotracking  _pull_
+  // based. We don't actively tell the caches which depend on the storage that
+  // anything has happened. Instead, we recompute the caches when needed.
+  set value(newValue) {
+    if (this.value === newValue) return
+
+    this._value = newValue
+    this.revision = ++$REVISION
+  }
+}
+
+function tripleEq(a: unknown, b: unknown) {
+  return a === b
+}
+
+// Caches represent derived state in the system. They are ultimately functions
+// that are memoized based on what state they use to produce their output,
+// meaning they will only rerun IFF a storage value that could affect the output
+// has changed. Otherwise, they'll return the cached value.
+export class TrackingCache {
+  _cachedValue: any
+  _cachedRevision = -1
+  _deps: any[] = []
+  hits = 0
+
+  fn: () => any
+
+  constructor(fn: () => any) {
+    this.fn = fn
+  }
+
+  clear() {
+    this._cachedValue = undefined
+    this._cachedRevision = -1
+    this._deps = []
+    this.hits = 0
+  }
+
+  get value() {
+    // When getting the value for a Cache, first we check all the dependencies of
+    // the cache to see what their current revision is. If the current revision is
+    // greater than the cached revision, then something has changed.
+    if (this.revision > this._cachedRevision) {
+      const { fn } = this
+
+      // We create a new dependency tracker for this cache. As the cache runs
+      // its function, any Storage or Cache instances which are used while
+      // computing will be added to this tracker. In the end, it will be the
+      // full list of dependencies that this Cache depends on.
+      const currentTracker = new Set<Cell<any>>()
+      const prevTracker = CURRENT_TRACKER
+
+      CURRENT_TRACKER = currentTracker
+
+      // try {
+      this._cachedValue = fn()
+      // } finally {
+      CURRENT_TRACKER = prevTracker
+      this.hits++
+      this._deps = Array.from(currentTracker)
+
+      // Set the cached revision. This is the current clock count of all the
+      // dependencies. If any dependency changes, this number will be less
+      // than the new revision.
+      this._cachedRevision = this.revision
+      // }
+    }
+
+    // If there is a current tracker, it means another Cache is computing and
+    // using this one, so we add this one to the tracker.
+    CURRENT_TRACKER?.add(this)
+
+    // Always return the cached value.
+    return this._cachedValue
+  }
+
+  get revision() {
+    // The current revision is the max of all the dependencies' revisions.
+    return Math.max(...this._deps.map(d => d.revision), 0)
+  }
+}
+
+export function getValue<T>(cell: Cell<T>): T {
+  if (!(cell instanceof Cell)) {
+    console.warn('Not a valid cell! ', cell)
+  }
+
+  return cell.value
+}
+
+type CellValue<T extends Cell<unknown>> = T extends Cell<infer U> ? U : never
+
+export function setValue<T extends Cell<unknown>>(
+  storage: T,
+  value: CellValue<T>
+): void {
+  if (!(storage instanceof Cell)) {
+    throw new TypeError(
+      'setValue must be passed a tracked store created with `createStorage`.'
+    )
+  }
+
+  storage.value = storage._lastValue = value
+}
+
+export function createCell<T = unknown>(
+  initialValue: T,
+  isEqual: EqualityFn = tripleEq
+): Cell<T> {
+  return new Cell(initialValue, isEqual)
+}
+
+export function createCache<T = unknown>(fn: () => T): TrackingCache {
+  assertIsFunction(
+    fn,
+    'the first parameter to `createCache` must be a function'
+  )
+
+  return new TrackingCache(fn)
+}
Index: node_modules/reselect/src/autotrackMemoize/proxy.ts
===================================================================
--- node_modules/reselect/src/autotrackMemoize/proxy.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/reselect/src/autotrackMemoize/proxy.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,230 @@
+// Original source:
+// - https://github.com/simonihmig/tracked-redux/blob/master/packages/tracked-redux/src/-private/proxy.ts
+
+import type { Node, Tag } from './tracking'
+import {
+  consumeCollection,
+  consumeTag,
+  createTag,
+  dirtyCollection,
+  dirtyTag
+} from './tracking'
+
+export const REDUX_PROXY_LABEL = Symbol()
+
+let nextId = 0
+
+const proto = Object.getPrototypeOf({})
+
+class ObjectTreeNode<T extends Record<string, unknown>> implements Node<T> {
+  proxy: T = new Proxy(this, objectProxyHandler) as unknown as T
+  tag = createTag()
+  tags = {} as Record<string, Tag>
+  children = {} as Record<string, Node>
+  collectionTag = null
+  id = nextId++
+
+  constructor(public value: T) {
+    this.value = value
+    this.tag.value = value
+  }
+}
+
+const objectProxyHandler = {
+  get(node: Node, key: string | symbol): unknown {
+    function calculateResult() {
+      const { value } = node
+
+      const childValue = Reflect.get(value, key)
+
+      if (typeof key === 'symbol') {
+        return childValue
+      }
+
+      if (key in proto) {
+        return childValue
+      }
+
+      if (typeof childValue === 'object' && childValue !== null) {
+        let childNode = node.children[key]
+
+        if (childNode === undefined) {
+          childNode = node.children[key] = createNode(childValue)
+        }
+
+        if (childNode.tag) {
+          consumeTag(childNode.tag)
+        }
+
+        return childNode.proxy
+      } else {
+        let tag = node.tags[key]
+
+        if (tag === undefined) {
+          tag = node.tags[key] = createTag()
+          tag.value = childValue
+        }
+
+        consumeTag(tag)
+
+        return childValue
+      }
+    }
+    const res = calculateResult()
+    return res
+  },
+
+  ownKeys(node: Node): ArrayLike<string | symbol> {
+    consumeCollection(node)
+    return Reflect.ownKeys(node.value)
+  },
+
+  getOwnPropertyDescriptor(
+    node: Node,
+    prop: string | symbol
+  ): PropertyDescriptor | undefined {
+    return Reflect.getOwnPropertyDescriptor(node.value, prop)
+  },
+
+  has(node: Node, prop: string | symbol): boolean {
+    return Reflect.has(node.value, prop)
+  }
+}
+
+class ArrayTreeNode<T extends Array<unknown>> implements Node<T> {
+  proxy: T = new Proxy([this], arrayProxyHandler) as unknown as T
+  tag = createTag()
+  tags = {}
+  children = {}
+  collectionTag = null
+  id = nextId++
+
+  constructor(public value: T) {
+    this.value = value
+    this.tag.value = value
+  }
+}
+
+const arrayProxyHandler = {
+  get([node]: [Node], key: string | symbol): unknown {
+    if (key === 'length') {
+      consumeCollection(node)
+    }
+
+    return objectProxyHandler.get(node, key)
+  },
+
+  ownKeys([node]: [Node]): ArrayLike<string | symbol> {
+    return objectProxyHandler.ownKeys(node)
+  },
+
+  getOwnPropertyDescriptor(
+    [node]: [Node],
+    prop: string | symbol
+  ): PropertyDescriptor | undefined {
+    return objectProxyHandler.getOwnPropertyDescriptor(node, prop)
+  },
+
+  has([node]: [Node], prop: string | symbol): boolean {
+    return objectProxyHandler.has(node, prop)
+  }
+}
+
+export function createNode<T extends Array<unknown> | Record<string, unknown>>(
+  value: T
+): Node<T> {
+  if (Array.isArray(value)) {
+    return new ArrayTreeNode(value)
+  }
+
+  return new ObjectTreeNode(value) as Node<T>
+}
+
+const keysMap = new WeakMap<
+  Array<unknown> | Record<string, unknown>,
+  Set<string>
+>()
+
+export function updateNode<T extends Array<unknown> | Record<string, unknown>>(
+  node: Node<T>,
+  newValue: T
+): void {
+  const { value, tags, children } = node
+
+  node.value = newValue
+
+  if (
+    Array.isArray(value) &&
+    Array.isArray(newValue) &&
+    value.length !== newValue.length
+  ) {
+    dirtyCollection(node)
+  } else {
+    if (value !== newValue) {
+      let oldKeysSize = 0
+      let newKeysSize = 0
+      let anyKeysAdded = false
+
+      for (const _key in value) {
+        oldKeysSize++
+      }
+
+      for (const key in newValue) {
+        newKeysSize++
+        if (!(key in value)) {
+          anyKeysAdded = true
+          break
+        }
+      }
+
+      const isDifferent = anyKeysAdded || oldKeysSize !== newKeysSize
+
+      if (isDifferent) {
+        dirtyCollection(node)
+      }
+    }
+  }
+
+  for (const key in tags) {
+    const childValue = (value as Record<string, unknown>)[key]
+    const newChildValue = (newValue as Record<string, unknown>)[key]
+
+    if (childValue !== newChildValue) {
+      dirtyCollection(node)
+      dirtyTag(tags[key], newChildValue)
+    }
+
+    if (typeof newChildValue === 'object' && newChildValue !== null) {
+      delete tags[key]
+    }
+  }
+
+  for (const key in children) {
+    const childNode = children[key]
+    const newChildValue = (newValue as Record<string, unknown>)[key]
+
+    const childValue = childNode.value
+
+    if (childValue === newChildValue) {
+      continue
+    } else if (typeof newChildValue === 'object' && newChildValue !== null) {
+      updateNode(childNode, newChildValue as Record<string, unknown>)
+    } else {
+      deleteNode(childNode)
+      delete children[key]
+    }
+  }
+}
+
+function deleteNode(node: Node): void {
+  if (node.tag) {
+    dirtyTag(node.tag, null)
+  }
+  dirtyCollection(node)
+  for (const key in node.tags) {
+    dirtyTag(node.tags[key], null)
+  }
+  for (const key in node.children) {
+    deleteNode(node.children[key])
+  }
+}
Index: node_modules/reselect/src/autotrackMemoize/tracking.ts
===================================================================
--- node_modules/reselect/src/autotrackMemoize/tracking.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/reselect/src/autotrackMemoize/tracking.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,50 @@
+import type { Cell } from './autotracking'
+import {
+  getValue as consumeTag,
+  createCell as createStorage,
+  setValue
+} from './autotracking'
+
+export type Tag = Cell<unknown>
+
+const neverEq = (a: any, b: any): boolean => false
+
+export function createTag(): Tag {
+  return createStorage(null, neverEq)
+}
+export { consumeTag }
+export function dirtyTag(tag: Tag, value: any): void {
+  setValue(tag, value)
+}
+
+export interface Node<
+  T extends Array<unknown> | Record<string, unknown> =
+    | Array<unknown>
+    | Record<string, unknown>
+> {
+  collectionTag: Tag | null
+  tag: Tag | null
+  tags: Record<string, Tag>
+  children: Record<string, Node>
+  proxy: T
+  value: T
+  id: number
+}
+
+export const consumeCollection = (node: Node): void => {
+  let tag = node.collectionTag
+
+  if (tag === null) {
+    tag = node.collectionTag = createTag()
+  }
+
+  consumeTag(tag)
+}
+
+export const dirtyCollection = (node: Node): void => {
+  const tag = node.collectionTag
+
+  if (tag !== null) {
+    dirtyTag(tag, null)
+  }
+}
Index: node_modules/reselect/src/autotrackMemoize/utils.ts
===================================================================
--- node_modules/reselect/src/autotrackMemoize/utils.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
+++ node_modules/reselect/src/autotrackMemoize/utils.ts	(revision a762898ecd37a452c782821d4c2c4955c6ed2521)
@@ -0,0 +1,9 @@
+export function assert(
+  condition: any,
+  msg = 'Assertion failed!'
+): asserts condition {
+  if (!condition) {
+    console.error(msg)
+    throw new Error(msg)
+  }
+}