@pautena/react-design-system 2.0.0-alpha.1b → 2.0.0-alpha.5

package/dist/node_modules/reselect/dist/reselect.mjs

@@ -0,0 +1,325 @@
+var F = (e, n, t) => {
+  if (n.length === 1 && n[0] === t) {
+    let r = !1;
+    try {
+      const u = {};
+      e(u) === u && (r = !0);
+    } catch {
+    }
+    if (r) {
+      let u;
+      try {
+        throw new Error();
+      } catch (s) {
+        ({ stack: u } = s);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: u }
+      );
+    }
+  }
+}, x = (e, n, t) => {
+  const { memoize: r, memoizeOptions: u } = n, { inputSelectorResults: s, inputSelectorResultsCopy: l } = e, o = r(() => ({}), ...u);
+  if (!(o.apply(null, s) === o.apply(null, l))) {
+    let c;
+    try {
+      throw new Error();
+    } catch (i) {
+      ({ stack: c } = i);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: t,
+        firstInputs: s,
+        secondInputs: l,
+        stack: c
+      }
+    );
+  }
+}, A = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+}, g = /* @__PURE__ */ Symbol("NOT_FOUND");
+function D(e, n = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(n);
+}
+function q(e, n = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(n);
+}
+function $(e, n = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((t) => typeof t == "function")) {
+    const t = e.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${n}[${t}]`);
+  }
+}
+var E = (e) => Array.isArray(e) ? e : [e];
+function W(e) {
+  const n = Array.isArray(e[0]) ? e[0] : e;
+  return $(
+    n,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), n;
+}
+function I(e, n) {
+  const t = [], { length: r } = e;
+  for (let u = 0; u < r; u++)
+    t.push(e[u].apply(null, n));
+  return t;
+}
+var U = (e, n) => {
+  const { identityFunctionCheck: t, inputStabilityCheck: r } = {
+    ...A,
+    ...n
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: t === "always" || t === "once" && e,
+      run: F
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: x
+    }
+  };
+};
+function _(e) {
+  let n;
+  return {
+    get(t) {
+      return n && e(n.key, t) ? n.value : g;
+    },
+    put(t, r) {
+      n = { key: t, value: r };
+    },
+    getEntries() {
+      return n ? [n] : [];
+    },
+    clear() {
+      n = void 0;
+    }
+  };
+}
+function K(e, n) {
+  let t = [];
+  function r(o) {
+    const a = t.findIndex((c) => n(o, c.key));
+    if (a > -1) {
+      const c = t[a];
+      return a > 0 && (t.splice(a, 1), t.unshift(c)), c.value;
+    }
+    return g;
+  }
+  function u(o, a) {
+    r(o) === g && (t.unshift({ key: o, value: a }), t.length > e && t.pop());
+  }
+  function s() {
+    return t;
+  }
+  function l() {
+    t = [];
+  }
+  return { get: r, put: u, getEntries: s, clear: l };
+}
+var V = (e, n) => e === n;
+function L(e) {
+  return function(t, r) {
+    if (t === null || r === null || t.length !== r.length)
+      return !1;
+    const { length: u } = t;
+    for (let s = 0; s < u; s++)
+      if (!e(t[s], r[s]))
+        return !1;
+    return !0;
+  };
+}
+function X(e, n) {
+  const t = typeof n == "object" ? n : { equalityCheck: n }, {
+    equalityCheck: r = V,
+    maxSize: u = 1,
+    resultEqualityCheck: s
+  } = t, l = L(r);
+  let o = 0;
+  const a = u <= 1 ? _(l) : K(u, l);
+  function c() {
+    let i = a.get(arguments);
+    if (i === g) {
+      if (i = e.apply(null, arguments), o++, s) {
+        const y = a.getEntries().find(
+          (f) => s(f.value, i)
+        );
+        y && (i = y.value, o !== 0 && o--);
+      }
+      a.put(arguments, i);
+    }
+    return i;
+  }
+  return c.clearCache = () => {
+    a.clear(), c.resetResultsCount();
+  }, c.resultsCount = () => o, c.resetResultsCount = () => {
+    o = 0;
+  }, c;
+}
+var P = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, B = typeof WeakRef < "u" ? WeakRef : P, G = 0, z = 1;
+function m() {
+  return {
+    s: G,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function N(e, n = {}) {
+  let t = m();
+  const { resultEqualityCheck: r } = n;
+  let u, s = 0;
+  function l() {
+    let o = t;
+    const { length: a } = arguments;
+    for (let p = 0, y = a; p < y; p++) {
+      const f = arguments[p];
+      if (typeof f == "function" || typeof f == "object" && f !== null) {
+        let d = o.o;
+        d === null && (o.o = d = /* @__PURE__ */ new WeakMap());
+        const h = d.get(f);
+        h === void 0 ? (o = m(), d.set(f, o)) : o = h;
+      } else {
+        let d = o.p;
+        d === null && (o.p = d = /* @__PURE__ */ new Map());
+        const h = d.get(f);
+        h === void 0 ? (o = m(), d.set(f, o)) : o = h;
+      }
+    }
+    const c = o;
+    let i;
+    if (o.s === z)
+      i = o.v;
+    else if (i = e.apply(null, arguments), s++, r) {
+      const p = u?.deref?.() ?? u;
+      p != null && r(p, i) && (i = p, s !== 0 && s--), u = typeof i == "object" && i !== null || typeof i == "function" ? new B(i) : i;
+    }
+    return c.s = z, c.v = i, i;
+  }
+  return l.clearCache = () => {
+    t = m(), l.resetResultsCount();
+  }, l.resultsCount = () => s, l.resetResultsCount = () => {
+    s = 0;
+  }, l;
+}
+function H(e, ...n) {
+  const t = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: n
+  } : e, r = (...u) => {
+    let s = 0, l = 0, o, a = {}, c = u.pop();
+    typeof c == "object" && (a = c, c = u.pop()), D(
+      c,
+      `createSelector expects an output function after the inputs, but received: [${typeof c}]`
+    );
+    const i = {
+      ...t,
+      ...a
+    }, {
+      memoize: p,
+      memoizeOptions: y = [],
+      argsMemoize: f = N,
+      argsMemoizeOptions: d = [],
+      devModeChecks: h = {}
+    } = i, w = E(y), T = E(d), v = W(u), k = p(function() {
+      return s++, c.apply(
+        null,
+        arguments
+      );
+    }, ...w);
+    let C = !0;
+    const M = f(function() {
+      l++;
+      const R = I(
+        v,
+        arguments
+      );
+      if (o = k.apply(null, R), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: S, inputStabilityCheck: b } = U(C, h);
+        if (S.shouldRun && S.run(
+          c,
+          R,
+          o
+        ), b.shouldRun) {
+          const j = I(
+            v,
+            arguments
+          );
+          b.run(
+            { inputSelectorResults: R, inputSelectorResultsCopy: j },
+            { memoize: p, memoizeOptions: w },
+            arguments
+          );
+        }
+        C && (C = !1);
+      }
+      return o;
+    }, ...T);
+    return Object.assign(M, {
+      resultFunc: c,
+      memoizedResultFunc: k,
+      dependencies: v,
+      dependencyRecomputations: () => l,
+      resetDependencyRecomputations: () => {
+        l = 0;
+      },
+      lastResult: () => o,
+      recomputations: () => s,
+      resetRecomputations: () => {
+        s = 0;
+      },
+      memoize: p,
+      argsMemoize: f
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var J = /* @__PURE__ */ H(N), Q = Object.assign(
+  (e, n = J) => {
+    q(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const t = Object.keys(e), r = t.map(
+      (s) => e[s]
+    );
+    return n(
+      r,
+      (...s) => s.reduce((l, o, a) => (l[t[a]] = o, l), {})
+    );
+  },
+  { withTypes: () => Q }
+);
+export {
+  J as createSelector,
+  H as createSelectorCreator,
+  Q as createStructuredSelector,
+  X as lruMemoize,
+  V as referenceEqualityCheck,
+  N as weakMapMemoize
+};
+//# sourceMappingURL=reselect.mjs.map

package/dist/node_modules/reselect/dist/reselect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reselect.mjs","sources":["../../../../node_modules/reselect/dist/reselect.mjs"],"sourcesContent":["// src/devModeChecks/identityFunctionCheck.ts\nvar runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {\n  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {\n    let isInputSameAsOutput = false;\n    try {\n      const emptyObject = {};\n      if (resultFunc(emptyObject) === emptyObject)\n        isInputSameAsOutput = true;\n    } catch {\n    }\n    if (isInputSameAsOutput) {\n      let stack = void 0;\n      try {\n        throw new Error();\n      } catch (e) {\n        ;\n        ({ stack } = e);\n      }\n      console.warn(\n        \"The result function returned its own inputs without modification. e.g\\n`createSelector([state => state.todos], todos => todos)`\\nThis could lead to inefficient memoization and unnecessary re-renders.\\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.\",\n        { stack }\n      );\n    }\n  }\n};\n\n// src/devModeChecks/inputStabilityCheck.ts\nvar runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {\n  const { memoize, memoizeOptions } = options;\n  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;\n  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);\n  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);\n  if (!areInputSelectorResultsEqual) {\n    let stack = void 0;\n    try {\n      throw new Error();\n    } catch (e) {\n      ;\n      ({ stack } = e);\n    }\n    console.warn(\n      \"An input selector returned a different result when passed same arguments.\\nThis means your output selector will likely run more frequently than intended.\\nAvoid returning a new reference inside your input selector, e.g.\\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`\",\n      {\n        arguments: inputSelectorArgs,\n        firstInputs: inputSelectorResults,\n        secondInputs: inputSelectorResultsCopy,\n        stack\n      }\n    );\n  }\n};\n\n// src/devModeChecks/setGlobalDevModeChecks.ts\nvar globalDevModeChecks = {\n  inputStabilityCheck: \"once\",\n  identityFunctionCheck: \"once\"\n};\nvar setGlobalDevModeChecks = (devModeChecks) => {\n  Object.assign(globalDevModeChecks, devModeChecks);\n};\n\n// src/utils.ts\nvar NOT_FOUND = /* @__PURE__ */ Symbol(\"NOT_FOUND\");\nfunction assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {\n  if (typeof func !== \"function\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {\n  if (typeof object !== \"object\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {\n  if (!array.every((item) => typeof item === \"function\")) {\n    const itemTypes = array.map(\n      (item) => typeof item === \"function\" ? `function ${item.name || \"unnamed\"}()` : typeof item\n    ).join(\", \");\n    throw new TypeError(`${errorMessage}[${itemTypes}]`);\n  }\n}\nvar ensureIsArray = (item) => {\n  return Array.isArray(item) ? item : [item];\n};\nfunction getDependencies(createSelectorArgs) {\n  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;\n  assertIsArrayOfFunctions(\n    dependencies,\n    `createSelector expects all input-selectors to be functions, but received the following types: `\n  );\n  return dependencies;\n}\nfunction collectInputSelectorResults(dependencies, inputSelectorArgs) {\n  const inputSelectorResults = [];\n  const { length } = dependencies;\n  for (let i = 0; i < length; i++) {\n    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));\n  }\n  return inputSelectorResults;\n}\nvar getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {\n  const { identityFunctionCheck, inputStabilityCheck } = {\n    ...globalDevModeChecks,\n    ...devModeChecks\n  };\n  return {\n    identityFunctionCheck: {\n      shouldRun: identityFunctionCheck === \"always\" || identityFunctionCheck === \"once\" && firstRun,\n      run: runIdentityFunctionCheck\n    },\n    inputStabilityCheck: {\n      shouldRun: inputStabilityCheck === \"always\" || inputStabilityCheck === \"once\" && firstRun,\n      run: runInputStabilityCheck\n    }\n  };\n};\n\n// src/autotrackMemoize/autotracking.ts\nvar $REVISION = 0;\nvar CURRENT_TRACKER = null;\nvar Cell = class {\n  revision = $REVISION;\n  _value;\n  _lastValue;\n  _isEqual = tripleEq;\n  constructor(initialValue, isEqual = tripleEq) {\n    this._value = this._lastValue = initialValue;\n    this._isEqual = isEqual;\n  }\n  // Whenever a storage value is read, it'll add itself to the current tracker if\n  // one exists, entangling its state with that cache.\n  get value() {\n    CURRENT_TRACKER?.add(this);\n    return this._value;\n  }\n  // Whenever a storage value is updated, we bump the global revision clock,\n  // assign the revision for this storage to the new value, _and_ we schedule a\n  // rerender. This is important, and it's what makes autotracking  _pull_\n  // based. We don't actively tell the caches which depend on the storage that\n  // anything has happened. Instead, we recompute the caches when needed.\n  set value(newValue) {\n    if (this.value === newValue)\n      return;\n    this._value = newValue;\n    this.revision = ++$REVISION;\n  }\n};\nfunction tripleEq(a, b) {\n  return a === b;\n}\nvar TrackingCache = class {\n  _cachedValue;\n  _cachedRevision = -1;\n  _deps = [];\n  hits = 0;\n  fn;\n  constructor(fn) {\n    this.fn = fn;\n  }\n  clear() {\n    this._cachedValue = void 0;\n    this._cachedRevision = -1;\n    this._deps = [];\n    this.hits = 0;\n  }\n  get value() {\n    if (this.revision > this._cachedRevision) {\n      const { fn } = this;\n      const currentTracker = /* @__PURE__ */ new Set();\n      const prevTracker = CURRENT_TRACKER;\n      CURRENT_TRACKER = currentTracker;\n      this._cachedValue = fn();\n      CURRENT_TRACKER = prevTracker;\n      this.hits++;\n      this._deps = Array.from(currentTracker);\n      this._cachedRevision = this.revision;\n    }\n    CURRENT_TRACKER?.add(this);\n    return this._cachedValue;\n  }\n  get revision() {\n    return Math.max(...this._deps.map((d) => d.revision), 0);\n  }\n};\nfunction getValue(cell) {\n  if (!(cell instanceof Cell)) {\n    console.warn(\"Not a valid cell! \", cell);\n  }\n  return cell.value;\n}\nfunction setValue(storage, value) {\n  if (!(storage instanceof Cell)) {\n    throw new TypeError(\n      \"setValue must be passed a tracked store created with `createStorage`.\"\n    );\n  }\n  storage.value = storage._lastValue = value;\n}\nfunction createCell(initialValue, isEqual = tripleEq) {\n  return new Cell(initialValue, isEqual);\n}\nfunction createCache(fn) {\n  assertIsFunction(\n    fn,\n    \"the first parameter to `createCache` must be a function\"\n  );\n  return new TrackingCache(fn);\n}\n\n// src/autotrackMemoize/tracking.ts\nvar neverEq = (a, b) => false;\nfunction createTag() {\n  return createCell(null, neverEq);\n}\nfunction dirtyTag(tag, value) {\n  setValue(tag, value);\n}\nvar consumeCollection = (node) => {\n  let tag = node.collectionTag;\n  if (tag === null) {\n    tag = node.collectionTag = createTag();\n  }\n  getValue(tag);\n};\nvar dirtyCollection = (node) => {\n  const tag = node.collectionTag;\n  if (tag !== null) {\n    dirtyTag(tag, null);\n  }\n};\n\n// src/autotrackMemoize/proxy.ts\nvar REDUX_PROXY_LABEL = Symbol();\nvar nextId = 0;\nvar proto = Object.getPrototypeOf({});\nvar ObjectTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy(this, objectProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar objectProxyHandler = {\n  get(node, key) {\n    function calculateResult() {\n      const { value } = node;\n      const childValue = Reflect.get(value, key);\n      if (typeof key === \"symbol\") {\n        return childValue;\n      }\n      if (key in proto) {\n        return childValue;\n      }\n      if (typeof childValue === \"object\" && childValue !== null) {\n        let childNode = node.children[key];\n        if (childNode === void 0) {\n          childNode = node.children[key] = createNode(childValue);\n        }\n        if (childNode.tag) {\n          getValue(childNode.tag);\n        }\n        return childNode.proxy;\n      } else {\n        let tag = node.tags[key];\n        if (tag === void 0) {\n          tag = node.tags[key] = createTag();\n          tag.value = childValue;\n        }\n        getValue(tag);\n        return childValue;\n      }\n    }\n    const res = calculateResult();\n    return res;\n  },\n  ownKeys(node) {\n    consumeCollection(node);\n    return Reflect.ownKeys(node.value);\n  },\n  getOwnPropertyDescriptor(node, prop) {\n    return Reflect.getOwnPropertyDescriptor(node.value, prop);\n  },\n  has(node, prop) {\n    return Reflect.has(node.value, prop);\n  }\n};\nvar ArrayTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy([this], arrayProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar arrayProxyHandler = {\n  get([node], key) {\n    if (key === \"length\") {\n      consumeCollection(node);\n    }\n    return objectProxyHandler.get(node, key);\n  },\n  ownKeys([node]) {\n    return objectProxyHandler.ownKeys(node);\n  },\n  getOwnPropertyDescriptor([node], prop) {\n    return objectProxyHandler.getOwnPropertyDescriptor(node, prop);\n  },\n  has([node], prop) {\n    return objectProxyHandler.has(node, prop);\n  }\n};\nfunction createNode(value) {\n  if (Array.isArray(value)) {\n    return new ArrayTreeNode(value);\n  }\n  return new ObjectTreeNode(value);\n}\nfunction updateNode(node, newValue) {\n  const { value, tags, children } = node;\n  node.value = newValue;\n  if (Array.isArray(value) && Array.isArray(newValue) && value.length !== newValue.length) {\n    dirtyCollection(node);\n  } else {\n    if (value !== newValue) {\n      let oldKeysSize = 0;\n      let newKeysSize = 0;\n      let anyKeysAdded = false;\n      for (const _key in value) {\n        oldKeysSize++;\n      }\n      for (const key in newValue) {\n        newKeysSize++;\n        if (!(key in value)) {\n          anyKeysAdded = true;\n          break;\n        }\n      }\n      const isDifferent = anyKeysAdded || oldKeysSize !== newKeysSize;\n      if (isDifferent) {\n        dirtyCollection(node);\n      }\n    }\n  }\n  for (const key in tags) {\n    const childValue = value[key];\n    const newChildValue = newValue[key];\n    if (childValue !== newChildValue) {\n      dirtyCollection(node);\n      dirtyTag(tags[key], newChildValue);\n    }\n    if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      delete tags[key];\n    }\n  }\n  for (const key in children) {\n    const childNode = children[key];\n    const newChildValue = newValue[key];\n    const childValue = childNode.value;\n    if (childValue === newChildValue) {\n      continue;\n    } else if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      updateNode(childNode, newChildValue);\n    } else {\n      deleteNode(childNode);\n      delete children[key];\n    }\n  }\n}\nfunction deleteNode(node) {\n  if (node.tag) {\n    dirtyTag(node.tag, null);\n  }\n  dirtyCollection(node);\n  for (const key in node.tags) {\n    dirtyTag(node.tags[key], null);\n  }\n  for (const key in node.children) {\n    deleteNode(node.children[key]);\n  }\n}\n\n// src/lruMemoize.ts\nfunction createSingletonCache(equals) {\n  let entry;\n  return {\n    get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n      return NOT_FOUND;\n    },\n    put(key, value) {\n      entry = { key, value };\n    },\n    getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear() {\n      entry = void 0;\n    }\n  };\n}\nfunction createLruCache(maxSize, equals) {\n  let entries = [];\n  function get(key) {\n    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));\n    if (cacheIndex > -1) {\n      const entry = entries[cacheIndex];\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n      return entry.value;\n    }\n    return NOT_FOUND;\n  }\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      entries.unshift({ key, value });\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n  function getEntries() {\n    return entries;\n  }\n  function clear() {\n    entries = [];\n  }\n  return { get, put, getEntries, clear };\n}\nvar referenceEqualityCheck = (a, b) => a === b;\nfunction createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    }\n    const { length } = prev;\n    for (let i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n}\nfunction lruMemoize(func, equalityCheckOrOptions) {\n  const providedOptions = typeof equalityCheckOrOptions === \"object\" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };\n  const {\n    equalityCheck = referenceEqualityCheck,\n    maxSize = 1,\n    resultEqualityCheck\n  } = providedOptions;\n  const comparator = createCacheKeyComparator(equalityCheck);\n  let resultsCount = 0;\n  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);\n  function memoized() {\n    let value = cache.get(arguments);\n    if (value === NOT_FOUND) {\n      value = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const entries = cache.getEntries();\n        const matchingEntry = entries.find(\n          (entry) => resultEqualityCheck(entry.value, value)\n        );\n        if (matchingEntry) {\n          value = matchingEntry.value;\n          resultsCount !== 0 && resultsCount--;\n        }\n      }\n      cache.put(arguments, value);\n    }\n    return value;\n  }\n  memoized.clearCache = () => {\n    cache.clear();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/autotrackMemoize/autotrackMemoize.ts\nfunction autotrackMemoize(func) {\n  const node = createNode(\n    []\n  );\n  let lastArgs = null;\n  const shallowEqual = createCacheKeyComparator(referenceEqualityCheck);\n  const cache = createCache(() => {\n    const res = func.apply(null, node.proxy);\n    return res;\n  });\n  function memoized() {\n    if (!shallowEqual(lastArgs, arguments)) {\n      updateNode(node, arguments);\n      lastArgs = arguments;\n    }\n    return cache.value;\n  }\n  memoized.clearCache = () => {\n    return cache.clear();\n  };\n  return memoized;\n}\n\n// src/weakMapMemoize.ts\nvar StrongRef = class {\n  constructor(value) {\n    this.value = value;\n  }\n  deref() {\n    return this.value;\n  }\n};\nvar Ref = typeof WeakRef !== \"undefined\" ? WeakRef : StrongRef;\nvar UNTERMINATED = 0;\nvar TERMINATED = 1;\nfunction createCacheNode() {\n  return {\n    s: UNTERMINATED,\n    v: void 0,\n    o: null,\n    p: null\n  };\n}\nfunction weakMapMemoize(func, options = {}) {\n  let fnNode = createCacheNode();\n  const { resultEqualityCheck } = options;\n  let lastResult;\n  let resultsCount = 0;\n  function memoized() {\n    let cacheNode = fnNode;\n    const { length } = arguments;\n    for (let i = 0, l = length; i < l; i++) {\n      const arg = arguments[i];\n      if (typeof arg === \"function\" || typeof arg === \"object\" && arg !== null) {\n        let objectCache = cacheNode.o;\n        if (objectCache === null) {\n          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();\n        }\n        const objectNode = objectCache.get(arg);\n        if (objectNode === void 0) {\n          cacheNode = createCacheNode();\n          objectCache.set(arg, cacheNode);\n        } else {\n          cacheNode = objectNode;\n        }\n      } else {\n        let primitiveCache = cacheNode.p;\n        if (primitiveCache === null) {\n          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();\n        }\n        const primitiveNode = primitiveCache.get(arg);\n        if (primitiveNode === void 0) {\n          cacheNode = createCacheNode();\n          primitiveCache.set(arg, cacheNode);\n        } else {\n          cacheNode = primitiveNode;\n        }\n      }\n    }\n    const terminatedNode = cacheNode;\n    let result;\n    if (cacheNode.s === TERMINATED) {\n      result = cacheNode.v;\n    } else {\n      result = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const lastResultValue = lastResult?.deref?.() ?? lastResult;\n        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {\n          result = lastResultValue;\n          resultsCount !== 0 && resultsCount--;\n        }\n        const needsWeakRef = typeof result === \"object\" && result !== null || typeof result === \"function\";\n        lastResult = needsWeakRef ? new Ref(result) : result;\n      }\n    }\n    terminatedNode.s = TERMINATED;\n    terminatedNode.v = result;\n    return result;\n  }\n  memoized.clearCache = () => {\n    fnNode = createCacheNode();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/createSelectorCreator.ts\nfunction createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {\n  const createSelectorCreatorOptions = typeof memoizeOrOptions === \"function\" ? {\n    memoize: memoizeOrOptions,\n    memoizeOptions: memoizeOptionsFromArgs\n  } : memoizeOrOptions;\n  const createSelector2 = (...createSelectorArgs) => {\n    let recomputations = 0;\n    let dependencyRecomputations = 0;\n    let lastResult;\n    let directlyPassedOptions = {};\n    let resultFunc = createSelectorArgs.pop();\n    if (typeof resultFunc === \"object\") {\n      directlyPassedOptions = resultFunc;\n      resultFunc = createSelectorArgs.pop();\n    }\n    assertIsFunction(\n      resultFunc,\n      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`\n    );\n    const combinedOptions = {\n      ...createSelectorCreatorOptions,\n      ...directlyPassedOptions\n    };\n    const {\n      memoize,\n      memoizeOptions = [],\n      argsMemoize = weakMapMemoize,\n      argsMemoizeOptions = [],\n      devModeChecks = {}\n    } = combinedOptions;\n    const finalMemoizeOptions = ensureIsArray(memoizeOptions);\n    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);\n    const dependencies = getDependencies(createSelectorArgs);\n    const memoizedResultFunc = memoize(function recomputationWrapper() {\n      recomputations++;\n      return resultFunc.apply(\n        null,\n        arguments\n      );\n    }, ...finalMemoizeOptions);\n    let firstRun = true;\n    const selector = argsMemoize(function dependenciesChecker() {\n      dependencyRecomputations++;\n      const inputSelectorResults = collectInputSelectorResults(\n        dependencies,\n        arguments\n      );\n      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);\n      if (process.env.NODE_ENV !== \"production\") {\n        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);\n        if (identityFunctionCheck.shouldRun) {\n          identityFunctionCheck.run(\n            resultFunc,\n            inputSelectorResults,\n            lastResult\n          );\n        }\n        if (inputStabilityCheck.shouldRun) {\n          const inputSelectorResultsCopy = collectInputSelectorResults(\n            dependencies,\n            arguments\n          );\n          inputStabilityCheck.run(\n            { inputSelectorResults, inputSelectorResultsCopy },\n            { memoize, memoizeOptions: finalMemoizeOptions },\n            arguments\n          );\n        }\n        if (firstRun)\n          firstRun = false;\n      }\n      return lastResult;\n    }, ...finalArgsMemoizeOptions);\n    return Object.assign(selector, {\n      resultFunc,\n      memoizedResultFunc,\n      dependencies,\n      dependencyRecomputations: () => dependencyRecomputations,\n      resetDependencyRecomputations: () => {\n        dependencyRecomputations = 0;\n      },\n      lastResult: () => lastResult,\n      recomputations: () => recomputations,\n      resetRecomputations: () => {\n        recomputations = 0;\n      },\n      memoize,\n      argsMemoize\n    });\n  };\n  Object.assign(createSelector2, {\n    withTypes: () => createSelector2\n  });\n  return createSelector2;\n}\nvar createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);\n\n// src/createStructuredSelector.ts\nvar createStructuredSelector = Object.assign(\n  (inputSelectorsObject, selectorCreator = createSelector) => {\n    assertIsObject(\n      inputSelectorsObject,\n      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`\n    );\n    const inputSelectorKeys = Object.keys(inputSelectorsObject);\n    const dependencies = inputSelectorKeys.map(\n      (key) => inputSelectorsObject[key]\n    );\n    const structuredSelector = selectorCreator(\n      dependencies,\n      (...inputSelectorResults) => {\n        return inputSelectorResults.reduce((composition, value, index) => {\n          composition[inputSelectorKeys[index]] = value;\n          return composition;\n        }, {});\n      }\n    );\n    return structuredSelector;\n  },\n  { withTypes: () => createStructuredSelector }\n);\nexport {\n  createSelector,\n  createSelectorCreator,\n  createStructuredSelector,\n  lruMemoize,\n  referenceEqualityCheck,\n  setGlobalDevModeChecks,\n  autotrackMemoize as unstable_autotrackMemoize,\n  weakMapMemoize\n};\n//# sourceMappingURL=reselect.mjs.map"],"names":["runIdentityFunctionCheck","resultFunc","inputSelectorsResults","outputSelectorResult","isInputSameAsOutput","emptyObject","stack","e","runInputStabilityCheck","inputSelectorResultsObject","options","inputSelectorArgs","memoize","memoizeOptions","inputSelectorResults","inputSelectorResultsCopy","createAnEmptyObject","globalDevModeChecks","NOT_FOUND","assertIsFunction","func","errorMessage","assertIsObject","object","assertIsArrayOfFunctions","array","item","itemTypes","ensureIsArray","getDependencies","createSelectorArgs","dependencies","collectInputSelectorResults","length","i","getDevModeChecksExecutionInfo","firstRun","devModeChecks","identityFunctionCheck","inputStabilityCheck","createSingletonCache","equals","entry","key","value","createLruCache","maxSize","entries","get","cacheIndex","put","getEntries","clear","referenceEqualityCheck","a","b","createCacheKeyComparator","equalityCheck","prev","next","lruMemoize","equalityCheckOrOptions","providedOptions","resultEqualityCheck","comparator","resultsCount","cache","memoized","matchingEntry","StrongRef","Ref","UNTERMINATED","TERMINATED","createCacheNode","weakMapMemoize","fnNode","lastResult","cacheNode","l","arg","objectCache","objectNode","primitiveCache","primitiveNode","terminatedNode","result","lastResultValue","createSelectorCreator","memoizeOrOptions","memoizeOptionsFromArgs","createSelectorCreatorOptions","createSelector2","recomputations","dependencyRecomputations","directlyPassedOptions","combinedOptions","argsMemoize","argsMemoizeOptions","finalMemoizeOptions","finalArgsMemoizeOptions","memoizedResultFunc","selector","createSelector","createStructuredSelector","inputSelectorsObject","selectorCreator","inputSelectorKeys","composition","index"],"mappings":"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","x_google_ignoreList":[0]}