{"version":3,"file":"static/js/vendors-229eafb5.339fa179.js","mappings":"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IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,KACHC,EAAG,KACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,KACHC,EAAG,KACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,KACHC,EAAG,KACHC,EAAG,IACHC,EAAG,IACHC,EAAG,KACHC,EAAG,KACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,EAAG,IACHC,EAAG,IACHC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IACJC,GAAI,IAC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","sources":["../node_modules/tabbable/src/index.js","../node_modules/tiny-warning/dist/tiny-warning.esm.js","../node_modules/@tanstack/match-sorter-utils/src/remove-accents.ts","../node_modules/@tanstack/match-sorter-utils/src/index.ts","../node_modules/@tanstack/table-core/src/utils.ts","../node_modules/@tanstack/table-core/src/core/headers.ts","../node_modules/@tanstack/table-core/src/core/row.ts","../node_modules/@tanstack/table-core/src/core/cell.ts","../node_modules/@tanstack/table-core/src/features/ColumnFaceting.ts","../node_modules/@tanstack/table-core/src/filterFns.ts","../node_modules/@tanstack/table-core/src/features/ColumnFiltering.ts","../node_modules/@tanstack/table-core/src/aggregationFns.ts","../node_modules/@tanstack/table-core/src/features/ColumnGrouping.ts","../node_modules/@tanstack/table-core/src/features/ColumnOrdering.ts","../node_modules/@tanstack/table-core/src/features/ColumnPinning.ts","../node_modules/@tanstack/table-core/src/features/ColumnSizing.ts","../node_modules/@tanstack/table-core/src/features/ColumnVisibility.ts","../node_modules/@tanstack/table-core/src/features/GlobalFaceting.ts","../node_modules/@tanstack/table-core/src/features/RowSelection.ts","../node_modules/@tanstack/table-core/src/sortingFns.ts","../node_modules/@tanstack/table-core/src/core/table.ts","../node_modules/@tanstack/table-core/src/features/GlobalFiltering.ts","../node_modules/@tanstack/table-core/src/features/RowSorting.ts","../node_modules/@tanstack/table-core/src/features/RowExpanding.ts","../node_modules/@tanstack/table-core/src/features/RowPagination.ts","../node_modules/@tanstack/table-core/src/features/RowPinning.ts","../node_modules/@tanstack/table-core/src/core/column.ts","../node_modules/@tanstack/table-core/src/utils/getCoreRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getExpandedRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getFacetedMinMaxValues.ts","../node_modules/@tanstack/table-core/src/utils/filterRowsUtils.ts","../node_modules/@tanstack/table-core/src/utils/getFacetedRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getFacetedUniqueValues.ts","../node_modules/@tanstack/table-core/src/utils/getFilteredRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getGroupedRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getPaginationRowModel.ts","../node_modules/@tanstack/table-core/src/utils/getSortedRowModel.ts","../node_modules/@tanstack/react-table/src/index.tsx","../node_modules/@tanstack/virtual-core/src/utils.ts","../node_modules/@tanstack/virtual-core/src/index.ts","../node_modules/@tanstack/react-virtual/src/index.tsx","../node_modules/svg-pathdata/node_modules/tslib/tslib.es6.js","../node_modules/svg-pathdata/src/SVGPathDataEncoder.ts","../node_modules/svg-pathdata/src/mathUtils.ts","../node_modules/svg-pathdata/src/SVGPathDataTransformer.ts","../node_modules/svg-pathdata/src/TransformableSVG.ts","../node_modules/svg-pathdata/src/SVGPathDataParser.ts","../node_modules/svg-pathdata/src/SVGPathData.ts","../node_modules/tiny-invariant/dist/esm/tiny-invariant.js"],"sourcesContent":["// NOTE: separate `:not()` selectors has broader browser support than the newer\n//  `:not([inert], [inert] *)` (Feb 2023)\n// CAREFUL: JSDom does not support `:not([inert] *)` as a selector; using it causes\n//  the entire query to fail, resulting in no nodes found, which will break a lot\n//  of things... so we have to rely on JS to identify nodes inside an inert container\nconst candidateSelectors = [\n  'input:not([inert])',\n  'select:not([inert])',\n  'textarea:not([inert])',\n  'a[href]:not([inert])',\n  'button:not([inert])',\n  '[tabindex]:not(slot):not([inert])',\n  'audio[controls]:not([inert])',\n  'video[controls]:not([inert])',\n  '[contenteditable]:not([contenteditable=\"false\"]):not([inert])',\n  'details>summary:first-of-type:not([inert])',\n  'details:not([inert])',\n];\nconst candidateSelector = /* #__PURE__ */ candidateSelectors.join(',');\n\nconst NoElement = typeof Element === 'undefined';\n\nconst matches = NoElement\n  ? function () {}\n  : Element.prototype.matches ||\n    Element.prototype.msMatchesSelector ||\n    Element.prototype.webkitMatchesSelector;\n\nconst getRootNode =\n  !NoElement && Element.prototype.getRootNode\n    ? (element) => element?.getRootNode?.()\n    : (element) => element?.ownerDocument;\n\n/**\n * Determines if a node is inert or in an inert ancestor.\n * @param {Element} [node]\n * @param {boolean} [lookUp] If true and `node` is not inert, looks up at ancestors to\n *  see if any of them are inert. If false, only `node` itself is considered.\n * @returns {boolean} True if inert itself or by way of being in an inert ancestor.\n *  False if `node` is falsy.\n */\nconst isInert = function (node, lookUp = true) {\n  // CAREFUL: JSDom does not support inert at all, so we can't use the `HTMLElement.inert`\n  //  JS API property; we have to check the attribute, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's an active element\n  const inertAtt = node?.getAttribute?.('inert');\n  const inert = inertAtt === '' || inertAtt === 'true';\n\n  // NOTE: this could also be handled with `node.matches('[inert], :is([inert] *)')`\n  //  if it weren't for `matches()` not being a function on shadow roots; the following\n  //  code works for any kind of node\n  // CAREFUL: JSDom does not appear to support certain selectors like `:not([inert] *)`\n  //  so it likely would not support `:is([inert] *)` either...\n  const result = inert || (lookUp && node && isInert(node.parentNode)); // recursive\n\n  return result;\n};\n\n/**\n * Determines if a node's content is editable.\n * @param {Element} [node]\n * @returns True if it's content-editable; false if it's not or `node` is falsy.\n */\nconst isContentEditable = function (node) {\n  // CAREFUL: JSDom does not support the `HTMLElement.isContentEditable` API so we have\n  //  to use the attribute directly to check for this, which can either be empty or 'true';\n  //  if it's `null` (not specified) or 'false', it's a non-editable element\n  const attValue = node?.getAttribute?.('contenteditable');\n  return attValue === '' || attValue === 'true';\n};\n\n/**\n * @param {Element} el container to check in\n * @param {boolean} includeContainer add container to check\n * @param {(node: Element) => boolean} filter filter candidates\n * @returns {Element[]}\n */\nconst getCandidates = function (el, includeContainer, filter) {\n  // even if `includeContainer=false`, we still have to check it for inertness because\n  //  if it's inert, all its children are inert\n  if (isInert(el)) {\n    return [];\n  }\n\n  let candidates = Array.prototype.slice.apply(\n    el.querySelectorAll(candidateSelector)\n  );\n  if (includeContainer && matches.call(el, candidateSelector)) {\n    candidates.unshift(el);\n  }\n  candidates = candidates.filter(filter);\n  return candidates;\n};\n\n/**\n * @callback GetShadowRoot\n * @param {Element} element to check for shadow root\n * @returns {ShadowRoot|boolean} ShadowRoot if available or boolean indicating if a shadowRoot is attached but not available.\n */\n\n/**\n * @callback ShadowRootFilter\n * @param {Element} shadowHostNode the element which contains shadow content\n * @returns {boolean} true if a shadow root could potentially contain valid candidates.\n */\n\n/**\n * @typedef {Object} CandidateScope\n * @property {Element} scopeParent contains inner candidates\n * @property {Element[]} candidates list of candidates found in the scope parent\n */\n\n/**\n * @typedef {Object} IterativeOptions\n * @property {GetShadowRoot|boolean} getShadowRoot true if shadow support is enabled; falsy if not;\n *  if a function, implies shadow support is enabled and either returns the shadow root of an element\n *  or a boolean stating if it has an undisclosed shadow root\n * @property {(node: Element) => boolean} filter filter candidates\n * @property {boolean} flatten if true then result will flatten any CandidateScope into the returned list\n * @property {ShadowRootFilter} shadowRootFilter filter shadow roots;\n */\n\n/**\n * @param {Element[]} elements list of element containers to match candidates from\n * @param {boolean} includeContainer add container list to check\n * @param {IterativeOptions} options\n * @returns {Array.<Element|CandidateScope>}\n */\nconst getCandidatesIteratively = function (\n  elements,\n  includeContainer,\n  options\n) {\n  const candidates = [];\n  const elementsToCheck = Array.from(elements);\n  while (elementsToCheck.length) {\n    const element = elementsToCheck.shift();\n    if (isInert(element, false)) {\n      // no need to look up since we're drilling down\n      // anything inside this container will also be inert\n      continue;\n    }\n\n    if (element.tagName === 'SLOT') {\n      // add shadow dom slot scope (slot itself cannot be focusable)\n      const assigned = element.assignedElements();\n      const content = assigned.length ? assigned : element.children;\n      const nestedCandidates = getCandidatesIteratively(content, true, options);\n      if (options.flatten) {\n        candidates.push(...nestedCandidates);\n      } else {\n        candidates.push({\n          scopeParent: element,\n          candidates: nestedCandidates,\n        });\n      }\n    } else {\n      // check candidate element\n      const validCandidate = matches.call(element, candidateSelector);\n      if (\n        validCandidate &&\n        options.filter(element) &&\n        (includeContainer || !elements.includes(element))\n      ) {\n        candidates.push(element);\n      }\n\n      // iterate over shadow content if possible\n      const shadowRoot =\n        element.shadowRoot ||\n        // check for an undisclosed shadow\n        (typeof options.getShadowRoot === 'function' &&\n          options.getShadowRoot(element));\n\n      // no inert look up because we're already drilling down and checking for inertness\n      //  on the way down, so all containers to this root node should have already been\n      //  vetted as non-inert\n      const validShadowRoot =\n        !isInert(shadowRoot, false) &&\n        (!options.shadowRootFilter || options.shadowRootFilter(element));\n\n      if (shadowRoot && validShadowRoot) {\n        // add shadow dom scope IIF a shadow root node was given; otherwise, an undisclosed\n        //  shadow exists, so look at light dom children as fallback BUT create a scope for any\n        //  child candidates found because they're likely slotted elements (elements that are\n        //  children of the web component element (which has the shadow), in the light dom, but\n        //  slotted somewhere _inside_ the undisclosed shadow) -- the scope is created below,\n        //  _after_ we return from this recursive call\n        const nestedCandidates = getCandidatesIteratively(\n          shadowRoot === true ? element.children : shadowRoot.children,\n          true,\n          options\n        );\n\n        if (options.flatten) {\n          candidates.push(...nestedCandidates);\n        } else {\n          candidates.push({\n            scopeParent: element,\n            candidates: nestedCandidates,\n          });\n        }\n      } else {\n        // there's not shadow so just dig into the element's (light dom) children\n        //  __without__ giving the element special scope treatment\n        elementsToCheck.unshift(...element.children);\n      }\n    }\n  }\n  return candidates;\n};\n\n/**\n * @private\n * Determines if the node has an explicitly specified `tabindex` attribute.\n * @param {HTMLElement} node\n * @returns {boolean} True if so; false if not.\n */\nconst hasTabIndex = function (node) {\n  return !isNaN(parseInt(node.getAttribute('tabindex'), 10));\n};\n\n/**\n * Determine the tab index of a given node.\n * @param {HTMLElement} node\n * @returns {number} Tab order (negative, 0, or positive number).\n * @throws {Error} If `node` is falsy.\n */\nconst getTabIndex = function (node) {\n  if (!node) {\n    throw new Error('No node provided');\n  }\n\n  if (node.tabIndex < 0) {\n    // in Chrome, <details/>, <audio controls/> and <video controls/> elements get a default\n    // `tabIndex` of -1 when the 'tabindex' attribute isn't specified in the DOM,\n    // yet they are still part of the regular tab order; in FF, they get a default\n    // `tabIndex` of 0; since Chrome still puts those elements in the regular tab\n    // order, consider their tab index to be 0.\n    // Also browsers do not return `tabIndex` correctly for contentEditable nodes;\n    // so if they don't have a tabindex attribute specifically set, assume it's 0.\n    if (\n      (/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) ||\n        isContentEditable(node)) &&\n      !hasTabIndex(node)\n    ) {\n      return 0;\n    }\n  }\n\n  return node.tabIndex;\n};\n\n/**\n * Determine the tab index of a given node __for sort order purposes__.\n * @param {HTMLElement} node\n * @param {boolean} [isScope] True for a custom element with shadow root or slot that, by default,\n *  has tabIndex -1, but needs to be sorted by document order in order for its content to be\n *  inserted into the correct sort position.\n * @returns {number} Tab order (negative, 0, or positive number).\n */\nconst getSortOrderTabIndex = function (node, isScope) {\n  const tabIndex = getTabIndex(node);\n\n  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {\n    return 0;\n  }\n\n  return tabIndex;\n};\n\nconst sortOrderedTabbables = function (a, b) {\n  return a.tabIndex === b.tabIndex\n    ? a.documentOrder - b.documentOrder\n    : a.tabIndex - b.tabIndex;\n};\n\nconst isInput = function (node) {\n  return node.tagName === 'INPUT';\n};\n\nconst isHiddenInput = function (node) {\n  return isInput(node) && node.type === 'hidden';\n};\n\nconst isDetailsWithSummary = function (node) {\n  const r =\n    node.tagName === 'DETAILS' &&\n    Array.prototype.slice\n      .apply(node.children)\n      .some((child) => child.tagName === 'SUMMARY');\n  return r;\n};\n\nconst getCheckedRadio = function (nodes, form) {\n  for (let i = 0; i < nodes.length; i++) {\n    if (nodes[i].checked && nodes[i].form === form) {\n      return nodes[i];\n    }\n  }\n};\n\nconst isTabbableRadio = function (node) {\n  if (!node.name) {\n    return true;\n  }\n  const radioScope = node.form || getRootNode(node);\n  const queryRadios = function (name) {\n    return radioScope.querySelectorAll(\n      'input[type=\"radio\"][name=\"' + name + '\"]'\n    );\n  };\n\n  let radioSet;\n  if (\n    typeof window !== 'undefined' &&\n    typeof window.CSS !== 'undefined' &&\n    typeof window.CSS.escape === 'function'\n  ) {\n    radioSet = queryRadios(window.CSS.escape(node.name));\n  } else {\n    try {\n      radioSet = queryRadios(node.name);\n    } catch (err) {\n      // eslint-disable-next-line no-console\n      console.error(\n        'Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s',\n        err.message\n      );\n      return false;\n    }\n  }\n\n  const checked = getCheckedRadio(radioSet, node.form);\n  return !checked || checked === node;\n};\n\nconst isRadio = function (node) {\n  return isInput(node) && node.type === 'radio';\n};\n\nconst isNonTabbableRadio = function (node) {\n  return isRadio(node) && !isTabbableRadio(node);\n};\n\n// determines if a node is ultimately attached to the window's document\nconst isNodeAttached = function (node) {\n  // The root node is the shadow root if the node is in a shadow DOM; some document otherwise\n  //  (but NOT _the_ document; see second 'If' comment below for more).\n  // If rootNode is shadow root, it'll have a host, which is the element to which the shadow\n  //  is attached, and the one we need to check if it's in the document or not (because the\n  //  shadow, and all nodes it contains, is never considered in the document since shadows\n  //  behave like self-contained DOMs; but if the shadow's HOST, which is part of the document,\n  //  is hidden, or is not in the document itself but is detached, it will affect the shadow's\n  //  visibility, including all the nodes it contains). The host could be any normal node,\n  //  or a custom element (i.e. web component). Either way, that's the one that is considered\n  //  part of the document, not the shadow root, nor any of its children (i.e. the node being\n  //  tested).\n  // To further complicate things, we have to look all the way up until we find a shadow HOST\n  //  that is attached (or find none) because the node might be in nested shadows...\n  // If rootNode is not a shadow root, it won't have a host, and so rootNode should be the\n  //  document (per the docs) and while it's a Document-type object, that document does not\n  //  appear to be the same as the node's `ownerDocument` for some reason, so it's safer\n  //  to ignore the rootNode at this point, and use `node.ownerDocument`. Otherwise,\n  //  using `rootNode.contains(node)` will _always_ be true we'll get false-positives when\n  //  node is actually detached.\n  // NOTE: If `nodeRootHost` or `node` happens to be the `document` itself (which is possible\n  //  if a tabbable/focusable node was quickly added to the DOM, focused, and then removed\n  //  from the DOM as in https://github.com/focus-trap/focus-trap-react/issues/905), then\n  //  `ownerDocument` will be `null`, hence the optional chaining on it.\n  let nodeRoot = node && getRootNode(node);\n  let nodeRootHost = nodeRoot?.host;\n\n  // in some cases, a detached node will return itself as the root instead of a document or\n  //  shadow root object, in which case, we shouldn't try to look further up the host chain\n  let attached = false;\n  if (nodeRoot && nodeRoot !== node) {\n    attached = !!(\n      nodeRootHost?.ownerDocument?.contains(nodeRootHost) ||\n      node?.ownerDocument?.contains(node)\n    );\n\n    while (!attached && nodeRootHost) {\n      // since it's not attached and we have a root host, the node MUST be in a nested shadow DOM,\n      //  which means we need to get the host's host and check if that parent host is contained\n      //  in (i.e. attached to) the document\n      nodeRoot = getRootNode(nodeRootHost);\n      nodeRootHost = nodeRoot?.host;\n      attached = !!nodeRootHost?.ownerDocument?.contains(nodeRootHost);\n    }\n  }\n\n  return attached;\n};\n\nconst isZeroArea = function (node) {\n  const { width, height } = node.getBoundingClientRect();\n  return width === 0 && height === 0;\n};\nconst isHidden = function (node, { displayCheck, getShadowRoot }) {\n  // NOTE: visibility will be `undefined` if node is detached from the document\n  //  (see notes about this further down), which means we will consider it visible\n  //  (this is legacy behavior from a very long way back)\n  // NOTE: we check this regardless of `displayCheck=\"none\"` because this is a\n  //  _visibility_ check, not a _display_ check\n  if (getComputedStyle(node).visibility === 'hidden') {\n    return true;\n  }\n\n  const isDirectSummary = matches.call(node, 'details>summary:first-of-type');\n  const nodeUnderDetails = isDirectSummary ? node.parentElement : node;\n  if (matches.call(nodeUnderDetails, 'details:not([open]) *')) {\n    return true;\n  }\n\n  if (\n    !displayCheck ||\n    displayCheck === 'full' ||\n    displayCheck === 'legacy-full'\n  ) {\n    if (typeof getShadowRoot === 'function') {\n      // figure out if we should consider the node to be in an undisclosed shadow and use the\n      //  'non-zero-area' fallback\n      const originalNode = node;\n      while (node) {\n        const parentElement = node.parentElement;\n        const rootNode = getRootNode(node);\n        if (\n          parentElement &&\n          !parentElement.shadowRoot &&\n          getShadowRoot(parentElement) === true // check if there's an undisclosed shadow\n        ) {\n          // node has an undisclosed shadow which means we can only treat it as a black box, so we\n          //  fall back to a non-zero-area test\n          return isZeroArea(node);\n        } else if (node.assignedSlot) {\n          // iterate up slot\n          node = node.assignedSlot;\n        } else if (!parentElement && rootNode !== node.ownerDocument) {\n          // cross shadow boundary\n          node = rootNode.host;\n        } else {\n          // iterate up normal dom\n          node = parentElement;\n        }\n      }\n\n      node = originalNode;\n    }\n    // else, `getShadowRoot` might be true, but all that does is enable shadow DOM support\n    //  (i.e. it does not also presume that all nodes might have undisclosed shadows); or\n    //  it might be a falsy value, which means shadow DOM support is disabled\n\n    // Since we didn't find it sitting in an undisclosed shadow (or shadows are disabled)\n    //  now we can just test to see if it would normally be visible or not, provided it's\n    //  attached to the main document.\n    // NOTE: We must consider case where node is inside a shadow DOM and given directly to\n    //  `isTabbable()` or `isFocusable()` -- regardless of `getShadowRoot` option setting.\n\n    if (isNodeAttached(node)) {\n      // this works wherever the node is: if there's at least one client rect, it's\n      //  somehow displayed; it also covers the CSS 'display: contents' case where the\n      //  node itself is hidden in place of its contents; and there's no need to search\n      //  up the hierarchy either\n      return !node.getClientRects().length;\n    }\n\n    // Else, the node isn't attached to the document, which means the `getClientRects()`\n    //  API will __always__ return zero rects (this can happen, for example, if React\n    //  is used to render nodes onto a detached tree, as confirmed in this thread:\n    //  https://github.com/facebook/react/issues/9117#issuecomment-284228870)\n    //\n    // It also means that even window.getComputedStyle(node).display will return `undefined`\n    //  because styles are only computed for nodes that are in the document.\n    //\n    // NOTE: THIS HAS BEEN THE CASE FOR YEARS. It is not new, nor is it caused by tabbable\n    //  somehow. Though it was never stated officially, anyone who has ever used tabbable\n    //  APIs on nodes in detached containers has actually implicitly used tabbable in what\n    //  was later (as of v5.2.0 on Apr 9, 2021) called `displayCheck=\"none\"` mode -- essentially\n    //  considering __everything__ to be visible because of the innability to determine styles.\n    //\n    // v6.0.0: As of this major release, the default 'full' option __no longer treats detached\n    //  nodes as visible with the 'none' fallback.__\n    if (displayCheck !== 'legacy-full') {\n      return true; // hidden\n    }\n    // else, fallback to 'none' mode and consider the node visible\n  } else if (displayCheck === 'non-zero-area') {\n    // NOTE: Even though this tests that the node's client rect is non-zero to determine\n    //  whether it's displayed, and that a detached node will __always__ have a zero-area\n    //  client rect, we don't special-case for whether the node is attached or not. In\n    //  this mode, we do want to consider nodes that have a zero area to be hidden at all\n    //  times, and that includes attached or not.\n    return isZeroArea(node);\n  }\n\n  // visible, as far as we can tell, or per current `displayCheck=none` mode, we assume\n  //  it's visible\n  return false;\n};\n\n// form fields (nested) inside a disabled fieldset are not focusable/tabbable\n//  unless they are in the _first_ <legend> element of the top-most disabled\n//  fieldset\nconst isDisabledFromFieldset = function (node) {\n  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {\n    let parentNode = node.parentElement;\n    // check if `node` is contained in a disabled <fieldset>\n    while (parentNode) {\n      if (parentNode.tagName === 'FIELDSET' && parentNode.disabled) {\n        // look for the first <legend> among the children of the disabled <fieldset>\n        for (let i = 0; i < parentNode.children.length; i++) {\n          const child = parentNode.children.item(i);\n          // when the first <legend> (in document order) is found\n          if (child.tagName === 'LEGEND') {\n            // if its parent <fieldset> is not nested in another disabled <fieldset>,\n            // return whether `node` is a descendant of its first <legend>\n            return matches.call(parentNode, 'fieldset[disabled] *')\n              ? true\n              : !child.contains(node);\n          }\n        }\n        // the disabled <fieldset> containing `node` has no <legend>\n        return true;\n      }\n      parentNode = parentNode.parentElement;\n    }\n  }\n\n  // else, node's tabbable/focusable state should not be affected by a fieldset's\n  //  enabled/disabled state\n  return false;\n};\n\nconst isNodeMatchingSelectorFocusable = function (options, node) {\n  if (\n    node.disabled ||\n    // we must do an inert look up to filter out any elements inside an inert ancestor\n    //  because we're limited in the type of selectors we can use in JSDom (see related\n    //  note related to `candidateSelectors`)\n    isInert(node) ||\n    isHiddenInput(node) ||\n    isHidden(node, options) ||\n    // For a details element with a summary, the summary element gets the focus\n    isDetailsWithSummary(node) ||\n    isDisabledFromFieldset(node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isNodeMatchingSelectorTabbable = function (options, node) {\n  if (\n    isNonTabbableRadio(node) ||\n    getTabIndex(node) < 0 ||\n    !isNodeMatchingSelectorFocusable(options, node)\n  ) {\n    return false;\n  }\n  return true;\n};\n\nconst isValidShadowRootTabbable = function (shadowHostNode) {\n  const tabIndex = parseInt(shadowHostNode.getAttribute('tabindex'), 10);\n  if (isNaN(tabIndex) || tabIndex >= 0) {\n    return true;\n  }\n  // If a custom element has an explicit negative tabindex,\n  // browsers will not allow tab targeting said element's children.\n  return false;\n};\n\n/**\n * @param {Array.<Element|CandidateScope>} candidates\n * @returns Element[]\n */\nconst sortByOrder = function (candidates) {\n  const regularTabbables = [];\n  const orderedTabbables = [];\n  candidates.forEach(function (item, i) {\n    const isScope = !!item.scopeParent;\n    const element = isScope ? item.scopeParent : item;\n    const candidateTabindex = getSortOrderTabIndex(element, isScope);\n    const elements = isScope ? sortByOrder(item.candidates) : element;\n    if (candidateTabindex === 0) {\n      isScope\n        ? regularTabbables.push(...elements)\n        : regularTabbables.push(element);\n    } else {\n      orderedTabbables.push({\n        documentOrder: i,\n        tabIndex: candidateTabindex,\n        item: item,\n        isScope: isScope,\n        content: elements,\n      });\n    }\n  });\n\n  return orderedTabbables\n    .sort(sortOrderedTabbables)\n    .reduce((acc, sortable) => {\n      sortable.isScope\n        ? acc.push(...sortable.content)\n        : acc.push(sortable.content);\n      return acc;\n    }, [])\n    .concat(regularTabbables);\n};\n\nconst tabbable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorTabbable.bind(null, options),\n        flatten: false,\n        getShadowRoot: options.getShadowRoot,\n        shadowRootFilter: isValidShadowRootTabbable,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorTabbable.bind(null, options)\n    );\n  }\n  return sortByOrder(candidates);\n};\n\nconst focusable = function (container, options) {\n  options = options || {};\n\n  let candidates;\n  if (options.getShadowRoot) {\n    candidates = getCandidatesIteratively(\n      [container],\n      options.includeContainer,\n      {\n        filter: isNodeMatchingSelectorFocusable.bind(null, options),\n        flatten: true,\n        getShadowRoot: options.getShadowRoot,\n      }\n    );\n  } else {\n    candidates = getCandidates(\n      container,\n      options.includeContainer,\n      isNodeMatchingSelectorFocusable.bind(null, options)\n    );\n  }\n\n  return candidates;\n};\n\nconst isTabbable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, candidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorTabbable(options, node);\n};\n\nconst focusableCandidateSelector = /* #__PURE__ */ candidateSelectors\n  .concat('iframe')\n  .join(',');\n\nconst isFocusable = function (node, options) {\n  options = options || {};\n  if (!node) {\n    throw new Error('No node provided');\n  }\n  if (matches.call(node, focusableCandidateSelector) === false) {\n    return false;\n  }\n  return isNodeMatchingSelectorFocusable(options, node);\n};\n\nexport { tabbable, focusable, isTabbable, isFocusable, getTabIndex };\n","var isProduction = process.env.NODE_ENV === 'production';\nfunction warning(condition, message) {\n  if (!isProduction) {\n    if (condition) {\n      return;\n    }\n\n    var text = \"Warning: \" + message;\n\n    if (typeof console !== 'undefined') {\n      console.warn(text);\n    }\n\n    try {\n      throw Error(text);\n    } catch (x) {}\n  }\n}\n\nexport default warning;\n","const characterMap: Record<string, string> = {\n  À: 'A',\n  Á: 'A',\n  Â: 'A',\n  Ã: 'A',\n  Ä: 'A',\n  Å: 'A',\n  Ấ: 'A',\n  Ắ: 'A',\n  Ẳ: 'A',\n  Ẵ: 'A',\n  Ặ: 'A',\n  Æ: 'AE',\n  Ầ: 'A',\n  Ằ: 'A',\n  Ȃ: 'A',\n  Ç: 'C',\n  Ḉ: 'C',\n  È: 'E',\n  É: 'E',\n  Ê: 'E',\n  Ë: 'E',\n  Ế: 'E',\n  Ḗ: 'E',\n  Ề: 'E',\n  Ḕ: 'E',\n  Ḝ: 'E',\n  Ȇ: 'E',\n  Ì: 'I',\n  Í: 'I',\n  Î: 'I',\n  Ï: 'I',\n  Ḯ: 'I',\n  Ȋ: 'I',\n  Ð: 'D',\n  Ñ: 'N',\n  Ò: 'O',\n  Ó: 'O',\n  Ô: 'O',\n  Õ: 'O',\n  Ö: 'O',\n  Ø: 'O',\n  Ố: 'O',\n  Ṍ: 'O',\n  Ṓ: 'O',\n  Ȏ: 'O',\n  Ù: 'U',\n  Ú: 'U',\n  Û: 'U',\n  Ü: 'U',\n  Ý: 'Y',\n  à: 'a',\n  á: 'a',\n  â: 'a',\n  ã: 'a',\n  ä: 'a',\n  å: 'a',\n  ấ: 'a',\n  ắ: 'a',\n  ẳ: 'a',\n  ẵ: 'a',\n  ặ: 'a',\n  æ: 'ae',\n  ầ: 'a',\n  ằ: 'a',\n  ȃ: 'a',\n  ç: 'c',\n  ḉ: 'c',\n  è: 'e',\n  é: 'e',\n  ê: 'e',\n  ë: 'e',\n  ế: 'e',\n  ḗ: 'e',\n  ề: 'e',\n  ḕ: 'e',\n  ḝ: 'e',\n  ȇ: 'e',\n  ì: 'i',\n  í: 'i',\n  î: 'i',\n  ï: 'i',\n  ḯ: 'i',\n  ȋ: 'i',\n  ð: 'd',\n  ñ: 'n',\n  ò: 'o',\n  ó: 'o',\n  ô: 'o',\n  õ: 'o',\n  ö: 'o',\n  ø: 'o',\n  ố: 'o',\n  ṍ: 'o',\n  ṓ: 'o',\n  ȏ: 'o',\n  ù: 'u',\n  ú: 'u',\n  û: 'u',\n  ü: 'u',\n  ý: 'y',\n  ÿ: 'y',\n  Ā: 'A',\n  ā: 'a',\n  Ă: 'A',\n  ă: 'a',\n  Ą: 'A',\n  ą: 'a',\n  Ć: 'C',\n  ć: 'c',\n  Ĉ: 'C',\n  ĉ: 'c',\n  Ċ: 'C',\n  ċ: 'c',\n  Č: 'C',\n  č: 'c',\n  C̆: 'C',\n  c̆: 'c',\n  Ď: 'D',\n  ď: 'd',\n  Đ: 'D',\n  đ: 'd',\n  Ē: 'E',\n  ē: 'e',\n  Ĕ: 'E',\n  ĕ: 'e',\n  Ė: 'E',\n  ė: 'e',\n  Ę: 'E',\n  ę: 'e',\n  Ě: 'E',\n  ě: 'e',\n  Ĝ: 'G',\n  Ǵ: 'G',\n  ĝ: 'g',\n  ǵ: 'g',\n  Ğ: 'G',\n  ğ: 'g',\n  Ġ: 'G',\n  ġ: 'g',\n  Ģ: 'G',\n  ģ: 'g',\n  Ĥ: 'H',\n  ĥ: 'h',\n  Ħ: 'H',\n  ħ: 'h',\n  Ḫ: 'H',\n  ḫ: 'h',\n  Ĩ: 'I',\n  ĩ: 'i',\n  Ī: 'I',\n  ī: 'i',\n  Ĭ: 'I',\n  ĭ: 'i',\n  Į: 'I',\n  į: 'i',\n  İ: 'I',\n  ı: 'i',\n  IJ: 'IJ',\n  ij: 'ij',\n  Ĵ: 'J',\n  ĵ: 'j',\n  Ķ: 'K',\n  ķ: 'k',\n  Ḱ: 'K',\n  ḱ: 'k',\n  K̆: 'K',\n  k̆: 'k',\n  Ĺ: 'L',\n  ĺ: 'l',\n  Ļ: 'L',\n  ļ: 'l',\n  Ľ: 'L',\n  ľ: 'l',\n  Ŀ: 'L',\n  ŀ: 'l',\n  Ł: 'l',\n  ł: 'l',\n  Ḿ: 'M',\n  ḿ: 'm',\n  M̆: 'M',\n  m̆: 'm',\n  Ń: 'N',\n  ń: 'n',\n  Ņ: 'N',\n  ņ: 'n',\n  Ň: 'N',\n  ň: 'n',\n  ʼn: 'n',\n  N̆: 'N',\n  n̆: 'n',\n  Ō: 'O',\n  ō: 'o',\n  Ŏ: 'O',\n  ŏ: 'o',\n  Ő: 'O',\n  ő: 'o',\n  Œ: 'OE',\n  œ: 'oe',\n  P̆: 'P',\n  p̆: 'p',\n  Ŕ: 'R',\n  ŕ: 'r',\n  Ŗ: 'R',\n  ŗ: 'r',\n  Ř: 'R',\n  ř: 'r',\n  R̆: 'R',\n  r̆: 'r',\n  Ȓ: 'R',\n  ȓ: 'r',\n  Ś: 'S',\n  ś: 's',\n  Ŝ: 'S',\n  ŝ: 's',\n  Ş: 'S',\n  Ș: 'S',\n  ș: 's',\n  ş: 's',\n  Š: 'S',\n  š: 's',\n  Ţ: 'T',\n  ţ: 't',\n  ț: 't',\n  Ț: 'T',\n  Ť: 'T',\n  ť: 't',\n  Ŧ: 'T',\n  ŧ: 't',\n  T̆: 'T',\n  t̆: 't',\n  Ũ: 'U',\n  ũ: 'u',\n  Ū: 'U',\n  ū: 'u',\n  Ŭ: 'U',\n  ŭ: 'u',\n  Ů: 'U',\n  ů: 'u',\n  Ű: 'U',\n  ű: 'u',\n  Ų: 'U',\n  ų: 'u',\n  Ȗ: 'U',\n  ȗ: 'u',\n  V̆: 'V',\n  v̆: 'v',\n  Ŵ: 'W',\n  ŵ: 'w',\n  Ẃ: 'W',\n  ẃ: 'w',\n  X̆: 'X',\n  x̆: 'x',\n  Ŷ: 'Y',\n  ŷ: 'y',\n  Ÿ: 'Y',\n  Y̆: 'Y',\n  y̆: 'y',\n  Ź: 'Z',\n  ź: 'z',\n  Ż: 'Z',\n  ż: 'z',\n  Ž: 'Z',\n  ž: 'z',\n  ſ: 's',\n  ƒ: 'f',\n  Ơ: 'O',\n  ơ: 'o',\n  Ư: 'U',\n  ư: 'u',\n  Ǎ: 'A',\n  ǎ: 'a',\n  Ǐ: 'I',\n  ǐ: 'i',\n  Ǒ: 'O',\n  ǒ: 'o',\n  Ǔ: 'U',\n  ǔ: 'u',\n  Ǖ: 'U',\n  ǖ: 'u',\n  Ǘ: 'U',\n  ǘ: 'u',\n  Ǚ: 'U',\n  ǚ: 'u',\n  Ǜ: 'U',\n  ǜ: 'u',\n  Ứ: 'U',\n  ứ: 'u',\n  Ṹ: 'U',\n  ṹ: 'u',\n  Ǻ: 'A',\n  ǻ: 'a',\n  Ǽ: 'AE',\n  ǽ: 'ae',\n  Ǿ: 'O',\n  ǿ: 'o',\n  Þ: 'TH',\n  þ: 'th',\n  Ṕ: 'P',\n  ṕ: 'p',\n  Ṥ: 'S',\n  ṥ: 's',\n  X́: 'X',\n  x́: 'x',\n  Ѓ: 'Г',\n  ѓ: 'г',\n  Ќ: 'К',\n  ќ: 'к',\n  A̋: 'A',\n  a̋: 'a',\n  E̋: 'E',\n  e̋: 'e',\n  I̋: 'I',\n  i̋: 'i',\n  Ǹ: 'N',\n  ǹ: 'n',\n  Ồ: 'O',\n  ồ: 'o',\n  Ṑ: 'O',\n  ṑ: 'o',\n  Ừ: 'U',\n  ừ: 'u',\n  Ẁ: 'W',\n  ẁ: 'w',\n  Ỳ: 'Y',\n  ỳ: 'y',\n  Ȁ: 'A',\n  ȁ: 'a',\n  Ȅ: 'E',\n  ȅ: 'e',\n  Ȉ: 'I',\n  ȉ: 'i',\n  Ȍ: 'O',\n  ȍ: 'o',\n  Ȑ: 'R',\n  ȑ: 'r',\n  Ȕ: 'U',\n  ȕ: 'u',\n  B̌: 'B',\n  b̌: 'b',\n  Č̣: 'C',\n  č̣: 'c',\n  Ê̌: 'E',\n  ê̌: 'e',\n  F̌: 'F',\n  f̌: 'f',\n  Ǧ: 'G',\n  ǧ: 'g',\n  Ȟ: 'H',\n  ȟ: 'h',\n  J̌: 'J',\n  ǰ: 'j',\n  Ǩ: 'K',\n  ǩ: 'k',\n  M̌: 'M',\n  m̌: 'm',\n  P̌: 'P',\n  p̌: 'p',\n  Q̌: 'Q',\n  q̌: 'q',\n  Ř̩: 'R',\n  ř̩: 'r',\n  Ṧ: 'S',\n  ṧ: 's',\n  V̌: 'V',\n  v̌: 'v',\n  W̌: 'W',\n  w̌: 'w',\n  X̌: 'X',\n  x̌: 'x',\n  Y̌: 'Y',\n  y̌: 'y',\n  A̧: 'A',\n  a̧: 'a',\n  B̧: 'B',\n  b̧: 'b',\n  Ḑ: 'D',\n  ḑ: 'd',\n  Ȩ: 'E',\n  ȩ: 'e',\n  Ɛ̧: 'E',\n  ɛ̧: 'e',\n  Ḩ: 'H',\n  ḩ: 'h',\n  I̧: 'I',\n  i̧: 'i',\n  Ɨ̧: 'I',\n  ɨ̧: 'i',\n  M̧: 'M',\n  m̧: 'm',\n  O̧: 'O',\n  o̧: 'o',\n  Q̧: 'Q',\n  q̧: 'q',\n  U̧: 'U',\n  u̧: 'u',\n  X̧: 'X',\n  x̧: 'x',\n  Z̧: 'Z',\n  z̧: 'z',\n}\n\nconst chars = Object.keys(characterMap).join('|')\nconst allAccents = new RegExp(chars, 'g')\n\nexport function removeAccents(str: string) {\n  return str.replace(allAccents, match => {\n    return characterMap[match]!\n  })\n}\n","/**\n * @name match-sorter\n * @license MIT license.\n * @copyright (c) 2099 Kent C. Dodds\n * @author Kent C. Dodds <me@kentcdodds.com> (https://kentcdodds.com)\n */\n\n// This is a fork of match-sorter. Instead of offering\n// a unified API for filtering and sorting in a single pass,\n// match-sorter-utils provides the lower-level utilities of\n// ranking items and comparing ranks in a way that can\n// be incrementally applied to a system rather than\n// all-at-once.\n\n// 1. Use the rankItem function to rank an item\n// 2. Use the resulting rankingInfo.passed to filter\n// 3. Use the resulting rankingInfo.rank to sort\n\n// For bundling purposes (mainly remove-accents not being esm safe/ready),\n// we've also hard-coded remove-accents into this source.\n// The remove-accents package is still included as a dependency\n// for attribution purposes, but it will not be imported and bundled.\n\nimport { removeAccents } from './remove-accents'\n\nexport type AccessorAttributes = {\n  threshold?: Ranking\n  maxRanking: Ranking\n  minRanking: Ranking\n}\n\nexport interface RankingInfo {\n  rankedValue: any\n  rank: Ranking\n  accessorIndex: number\n  accessorThreshold: Ranking | undefined\n  passed: boolean\n}\n\nexport interface AccessorOptions<TItem> {\n  accessor: AccessorFn<TItem>\n  threshold?: Ranking\n  maxRanking?: Ranking\n  minRanking?: Ranking\n}\n\nexport type AccessorFn<TItem> = (item: TItem) => string | Array<string>\n\nexport type Accessor<TItem> = AccessorFn<TItem> | AccessorOptions<TItem>\n\nexport interface RankItemOptions<TItem = unknown> {\n  accessors?: ReadonlyArray<Accessor<TItem>>\n  threshold?: Ranking\n  keepDiacritics?: boolean\n}\n\nexport const rankings = {\n  CASE_SENSITIVE_EQUAL: 7,\n  EQUAL: 6,\n  STARTS_WITH: 5,\n  WORD_STARTS_WITH: 4,\n  CONTAINS: 3,\n  ACRONYM: 2,\n  MATCHES: 1,\n  NO_MATCH: 0,\n} as const\n\nexport type Ranking = (typeof rankings)[keyof typeof rankings]\n\n/**\n * Gets the highest ranking for value for the given item based on its values for the given keys\n * @param {*} item - the item to rank\n * @param {String} value - the value to rank against\n * @param {Object} options - options to control the ranking\n * @return {{rank: Number, accessorIndex: Number, accessorThreshold: Number}} - the highest ranking\n */\nexport function rankItem<TItem>(\n  item: TItem,\n  value: string,\n  options?: RankItemOptions<TItem>\n): RankingInfo {\n  options = options || {}\n\n  options.threshold = options.threshold ?? rankings.MATCHES\n\n  if (!options.accessors) {\n    // if keys is not specified, then we assume the item given is ready to be matched\n    const rank = getMatchRanking(item as unknown as string, value, options)\n    return {\n      // ends up being duplicate of 'item' in matches but consistent\n      rankedValue: item,\n      rank,\n      accessorIndex: -1,\n      accessorThreshold: options.threshold,\n      passed: rank >= options.threshold,\n    }\n  }\n\n  const valuesToRank = getAllValuesToRank(item, options.accessors)\n\n  const rankingInfo: RankingInfo = {\n    rankedValue: item,\n    rank: rankings.NO_MATCH as Ranking,\n    accessorIndex: -1,\n    accessorThreshold: options.threshold,\n    passed: false,\n  }\n\n  for (let i = 0; i < valuesToRank.length; i++) {\n    const rankValue = valuesToRank[i]!\n\n    let newRank = getMatchRanking(rankValue.itemValue, value, options)\n\n    const {\n      minRanking,\n      maxRanking,\n      threshold = options.threshold,\n    } = rankValue.attributes\n\n    if (newRank < minRanking && newRank >= rankings.MATCHES) {\n      newRank = minRanking\n    } else if (newRank > maxRanking) {\n      newRank = maxRanking\n    }\n\n    newRank = Math.min(newRank, maxRanking) as Ranking\n\n    if (newRank >= threshold && newRank > rankingInfo.rank) {\n      rankingInfo.rank = newRank\n      rankingInfo.passed = true\n      rankingInfo.accessorIndex = i\n      rankingInfo.accessorThreshold = threshold\n      rankingInfo.rankedValue = rankValue.itemValue\n    }\n  }\n\n  return rankingInfo\n}\n\n/**\n * Gives a rankings score based on how well the two strings match.\n * @param {String} testString - the string to test against\n * @param {String} stringToRank - the string to rank\n * @param {Object} options - options for the match (like keepDiacritics for comparison)\n * @returns {Number} the ranking for how well stringToRank matches testString\n */\nfunction getMatchRanking<TItem>(\n  testString: string,\n  stringToRank: string,\n  options: RankItemOptions<TItem>\n): Ranking {\n  testString = prepareValueForComparison(testString, options)\n  stringToRank = prepareValueForComparison(stringToRank, options)\n\n  // too long\n  if (stringToRank.length > testString.length) {\n    return rankings.NO_MATCH\n  }\n\n  // case sensitive equals\n  if (testString === stringToRank) {\n    return rankings.CASE_SENSITIVE_EQUAL\n  }\n\n  // Lower casing before further comparison\n  testString = testString.toLowerCase()\n  stringToRank = stringToRank.toLowerCase()\n\n  // case insensitive equals\n  if (testString === stringToRank) {\n    return rankings.EQUAL\n  }\n\n  // starts with\n  if (testString.startsWith(stringToRank)) {\n    return rankings.STARTS_WITH\n  }\n\n  // word starts with\n  if (testString.includes(` ${stringToRank}`)) {\n    return rankings.WORD_STARTS_WITH\n  }\n\n  // contains\n  if (testString.includes(stringToRank)) {\n    return rankings.CONTAINS\n  } else if (stringToRank.length === 1) {\n    // If the only character in the given stringToRank\n    //   isn't even contained in the testString, then\n    //   it's definitely not a match.\n    return rankings.NO_MATCH\n  }\n\n  // acronym\n  if (getAcronym(testString).includes(stringToRank)) {\n    return rankings.ACRONYM\n  }\n\n  // will return a number between rankings.MATCHES and\n  // rankings.MATCHES + 1 depending  on how close of a match it is.\n  return getClosenessRanking(testString, stringToRank)\n}\n\n/**\n * Generates an acronym for a string.\n *\n * @param {String} string the string for which to produce the acronym\n * @returns {String} the acronym\n */\nfunction getAcronym(string: string): string {\n  let acronym = ''\n  const wordsInString = string.split(' ')\n  wordsInString.forEach(wordInString => {\n    const splitByHyphenWords = wordInString.split('-')\n    splitByHyphenWords.forEach(splitByHyphenWord => {\n      acronym += splitByHyphenWord.substr(0, 1)\n    })\n  })\n  return acronym\n}\n\n/**\n * Returns a score based on how spread apart the\n * characters from the stringToRank are within the testString.\n * A number close to rankings.MATCHES represents a loose match. A number close\n * to rankings.MATCHES + 1 represents a tighter match.\n * @param {String} testString - the string to test against\n * @param {String} stringToRank - the string to rank\n * @returns {Number} the number between rankings.MATCHES and\n * rankings.MATCHES + 1 for how well stringToRank matches testString\n */\nfunction getClosenessRanking(\n  testString: string,\n  stringToRank: string\n): Ranking {\n  let matchingInOrderCharCount = 0\n  let charNumber = 0\n  function findMatchingCharacter(\n    matchChar: undefined | string,\n    string: string,\n    index: number\n  ) {\n    for (let j = index, J = string.length; j < J; j++) {\n      const stringChar = string[j]\n      if (stringChar === matchChar) {\n        matchingInOrderCharCount += 1\n        return j + 1\n      }\n    }\n    return -1\n  }\n  function getRanking(spread: number) {\n    const spreadPercentage = 1 / spread\n    const inOrderPercentage = matchingInOrderCharCount / stringToRank.length\n    const ranking = rankings.MATCHES + inOrderPercentage * spreadPercentage\n    return ranking as Ranking\n  }\n  const firstIndex = findMatchingCharacter(stringToRank[0], testString, 0)\n  if (firstIndex < 0) {\n    return rankings.NO_MATCH\n  }\n  charNumber = firstIndex\n  for (let i = 1, I = stringToRank.length; i < I; i++) {\n    const matchChar = stringToRank[i]\n    charNumber = findMatchingCharacter(matchChar, testString, charNumber)\n    const found = charNumber > -1\n    if (!found) {\n      return rankings.NO_MATCH\n    }\n  }\n\n  const spread = charNumber - firstIndex\n  return getRanking(spread)\n}\n\n/**\n * Sorts items that have a rank, index, and accessorIndex\n * @param {Object} a - the first item to sort\n * @param {Object} b - the second item to sort\n * @return {Number} -1 if a should come first, 1 if b should come first, 0 if equal\n */\nexport function compareItems<TItem>(a: RankingInfo, b: RankingInfo): number {\n  return a.rank === b.rank ? 0 : a.rank > b.rank ? -1 : 1\n}\n\n/**\n * Prepares value for comparison by stringifying it, removing diacritics (if specified)\n * @param {String} value - the value to clean\n * @param {Object} options - {keepDiacritics: whether to remove diacritics}\n * @return {String} the prepared value\n */\nfunction prepareValueForComparison<TItem>(\n  value: string,\n  { keepDiacritics }: RankItemOptions<TItem>\n): string {\n  // value might not actually be a string at this point (we don't get to choose)\n  // so part of preparing the value for comparison is ensure that it is a string\n  value = `${value}` // toString\n  if (!keepDiacritics) {\n    value = removeAccents(value)\n  }\n  return value\n}\n\n/**\n * Gets value for key in item at arbitrarily nested keypath\n * @param {Object} item - the item\n * @param {Object|Function} key - the potentially nested keypath or property callback\n * @return {Array} - an array containing the value(s) at the nested keypath\n */\nfunction getItemValues<TItem>(\n  item: TItem,\n  accessor: Accessor<TItem>\n): Array<string> {\n  let accessorFn = accessor as AccessorFn<TItem>\n\n  if (typeof accessor === 'object') {\n    accessorFn = accessor.accessor\n  }\n\n  const value = accessorFn(item)\n\n  // because `value` can also be undefined\n  if (value == null) {\n    return []\n  }\n\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  return [String(value)]\n}\n\n/**\n * Gets all the values for the given keys in the given item and returns an array of those values\n * @param item - the item from which the values will be retrieved\n * @param keys - the keys to use to retrieve the values\n * @return objects with {itemValue, attributes}\n */\nfunction getAllValuesToRank<TItem>(\n  item: TItem,\n  accessors: ReadonlyArray<Accessor<TItem>>\n) {\n  const allValues: Array<{\n    itemValue: string\n    attributes: AccessorAttributes\n  }> = []\n  for (let j = 0, J = accessors.length; j < J; j++) {\n    const accessor = accessors[j]!\n    const attributes = getAccessorAttributes(accessor)\n    const itemValues = getItemValues(item, accessor)\n    for (let i = 0, I = itemValues.length; i < I; i++) {\n      allValues.push({\n        itemValue: itemValues[i]!,\n        attributes,\n      })\n    }\n  }\n  return allValues\n}\n\nconst defaultKeyAttributes = {\n  maxRanking: Infinity as Ranking,\n  minRanking: -Infinity as Ranking,\n}\n/**\n * Gets all the attributes for the given accessor\n * @param accessor - the accessor from which the attributes will be retrieved\n * @return object containing the accessor's attributes\n */\nfunction getAccessorAttributes<TItem>(\n  accessor: Accessor<TItem>\n): AccessorAttributes {\n  if (typeof accessor === 'function') {\n    return defaultKeyAttributes\n  }\n  return { ...defaultKeyAttributes, ...accessor }\n}\n","import { TableOptionsResolved, TableState, Updater } from './types'\n\nexport type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>\nexport type RequiredKeys<T, K extends keyof T> = Omit<T, K> &\n  Required<Pick<T, K>>\nexport type Overwrite<T, U extends { [TKey in keyof T]?: any }> = Omit<\n  T,\n  keyof U\n> &\n  U\n\nexport type UnionToIntersection<T> = (\n  T extends any ? (x: T) => any : never\n) extends (x: infer R) => any\n  ? R\n  : never\n\nexport type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N\nexport type IsKnown<T, Y, N> = unknown extends T ? N : Y\n\ntype ComputeRange<\n  N extends number,\n  Result extends Array<unknown> = [],\n> = Result['length'] extends N\n  ? Result\n  : ComputeRange<N, [...Result, Result['length']]>\ntype Index40 = ComputeRange<40>[number]\n\n// Is this type a tuple?\ntype IsTuple<T> = T extends readonly any[] & { length: infer Length }\n  ? Length extends Index40\n    ? T\n    : never\n  : never\n\n// If this type is a tuple, what indices are allowed?\ntype AllowedIndexes<\n  Tuple extends ReadonlyArray<any>,\n  Keys extends number = never,\n> = Tuple extends readonly []\n  ? Keys\n  : Tuple extends readonly [infer _, ...infer Tail]\n    ? AllowedIndexes<Tail, Keys | Tail['length']>\n    : Keys\n\nexport type DeepKeys<T, TDepth extends any[] = []> = TDepth['length'] extends 5\n  ? never\n  : unknown extends T\n    ? string\n    : T extends readonly any[] & IsTuple<T>\n      ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth>\n      : T extends any[]\n        ? DeepKeys<T[number], [...TDepth, any]>\n        : T extends Date\n          ? never\n          : T extends object\n            ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth>\n            : never\n\ntype DeepKeysPrefix<\n  T,\n  TPrefix,\n  TDepth extends any[],\n> = TPrefix extends keyof T & (number | string)\n  ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}`\n  : never\n\nexport type DeepValue<T, TProp> =\n  T extends Record<string | number, any>\n    ? TProp extends `${infer TBranch}.${infer TDeepProp}`\n      ? DeepValue<T[TBranch], TDeepProp>\n      : T[TProp & string]\n    : never\n\nexport type NoInfer<T> = [T][T extends any ? 0 : never]\n\nexport type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>\n\n///\n\nexport function functionalUpdate<T>(updater: Updater<T>, input: T): T {\n  return typeof updater === 'function'\n    ? (updater as (input: T) => T)(input)\n    : updater\n}\n\nexport function noop() {\n  //\n}\n\nexport function makeStateUpdater<K extends keyof TableState>(\n  key: K,\n  instance: unknown\n) {\n  return (updater: Updater<TableState[K]>) => {\n    ;(instance as any).setState(<TTableState>(old: TTableState) => {\n      return {\n        ...old,\n        [key]: functionalUpdate(updater, (old as any)[key]),\n      }\n    })\n  }\n}\n\ntype AnyFunction = (...args: any) => any\n\nexport function isFunction<T extends AnyFunction>(d: any): d is T {\n  return d instanceof Function\n}\n\nexport function isNumberArray(d: any): d is number[] {\n  return Array.isArray(d) && d.every(val => typeof val === 'number')\n}\n\nexport function flattenBy<TNode>(\n  arr: TNode[],\n  getChildren: (item: TNode) => TNode[]\n) {\n  const flat: TNode[] = []\n\n  const recurse = (subArr: TNode[]) => {\n    subArr.forEach(item => {\n      flat.push(item)\n      const children = getChildren(item)\n      if (children?.length) {\n        recurse(children)\n      }\n    })\n  }\n\n  recurse(arr)\n\n  return flat\n}\n\nexport function memo<TDeps extends readonly any[], TDepArgs, TResult>(\n  getDeps: (depArgs?: TDepArgs) => [...TDeps],\n  fn: (...args: NoInfer<[...TDeps]>) => TResult,\n  opts: {\n    key: any\n    debug?: () => any\n    onChange?: (result: TResult) => void\n  }\n): (depArgs?: TDepArgs) => TResult {\n  let deps: any[] = []\n  let result: TResult | undefined\n\n  return depArgs => {\n    let depTime: number\n    if (opts.key && opts.debug) depTime = Date.now()\n\n    const newDeps = getDeps(depArgs)\n\n    const depsChanged =\n      newDeps.length !== deps.length ||\n      newDeps.some((dep: any, index: number) => deps[index] !== dep)\n\n    if (!depsChanged) {\n      return result!\n    }\n\n    deps = newDeps\n\n    let resultTime: number\n    if (opts.key && opts.debug) resultTime = Date.now()\n\n    result = fn(...newDeps)\n    opts?.onChange?.(result)\n\n    if (opts.key && opts.debug) {\n      if (opts?.debug()) {\n        const depEndTime = Math.round((Date.now() - depTime!) * 100) / 100\n        const resultEndTime = Math.round((Date.now() - resultTime!) * 100) / 100\n        const resultFpsPercentage = resultEndTime / 16\n\n        const pad = (str: number | string, num: number) => {\n          str = String(str)\n          while (str.length < num) {\n            str = ' ' + str\n          }\n          return str\n        }\n\n        console.info(\n          `%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`,\n          `\n            font-size: .6rem;\n            font-weight: bold;\n            color: hsl(${Math.max(\n              0,\n              Math.min(120 - 120 * resultFpsPercentage, 120)\n            )}deg 100% 31%);`,\n          opts?.key\n        )\n      }\n    }\n\n    return result!\n  }\n}\n\nexport function getMemoOptions(\n  tableOptions: Partial<TableOptionsResolved<any>>,\n  debugLevel:\n    | 'debugAll'\n    | 'debugCells'\n    | 'debugTable'\n    | 'debugColumns'\n    | 'debugRows'\n    | 'debugHeaders',\n  key: string,\n  onChange?: (result: any) => void\n) {\n  return {\n    debug: () => tableOptions?.debugAll ?? tableOptions[debugLevel],\n    key: process.env.NODE_ENV === 'development' && key,\n    onChange,\n  }\n}\n","import {\n  RowData,\n  Column,\n  Header,\n  HeaderGroup,\n  Table,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nconst debug = 'debugHeaders'\n\nexport interface CoreHeaderGroup<TData extends RowData> {\n  depth: number\n  headers: Header<TData, unknown>[]\n  id: string\n}\n\nexport interface HeaderContext<TData, TValue> {\n  /**\n   * An instance of a column.\n   */\n  column: Column<TData, TValue>\n  /**\n   * An instance of a header.\n   */\n  header: Header<TData, TValue>\n  /**\n   * The table instance.\n   */\n  table: Table<TData>\n}\n\nexport interface CoreHeader<TData extends RowData, TValue> {\n  /**\n   * The col-span for the header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#colspan)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  colSpan: number\n  /**\n   * The header's associated column object.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#column)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  column: Column<TData, TValue>\n  /**\n   * The depth of the header, zero-indexed based.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#depth)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  depth: number\n  /**\n   * Returns the rendering context (or props) for column-based components like headers, footers and filters.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#getcontext)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getContext: () => HeaderContext<TData, TValue>\n  /**\n   * Returns the leaf headers hierarchically nested under this header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#getleafheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeafHeaders: () => Header<TData, unknown>[]\n  /**\n   * The header's associated header group object.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#headergroup)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  headerGroup: HeaderGroup<TData>\n  /**\n   * The unique identifier for the header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#id)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  id: string\n  /**\n   * The index for the header within the header group.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#index)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  index: number\n  /**\n   * A boolean denoting if the header is a placeholder header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#isplaceholder)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  isPlaceholder: boolean\n  /**\n   * If the header is a placeholder header, this will be a unique header ID that does not conflict with any other headers across the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#placeholderid)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  placeholderId?: string\n  /**\n   * The row-span for the header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#rowspan)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  rowSpan: number\n  /**\n   * The header's hierarchical sub/child headers. Will be empty if the header's associated column is a leaf-column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/header#subheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  subHeaders: Header<TData, TValue>[]\n}\n\nexport interface HeadersInstance<TData extends RowData> {\n  /**\n   * Returns all header groups for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getheadergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getHeaderGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the header groups for the left pinned columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getleftheadergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeftHeaderGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the header groups for columns that are not pinned.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getcenterheadergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getCenterHeaderGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the header groups for the right pinned columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getrightheadergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getRightHeaderGroups: () => HeaderGroup<TData>[]\n\n  /**\n   * Returns the footer groups for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getfootergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getFooterGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the footer groups for the left pinned columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getleftfootergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeftFooterGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the footer groups for columns that are not pinned.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getcenterfootergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getCenterFooterGroups: () => HeaderGroup<TData>[]\n  /**\n   * If pinning, returns the footer groups for the right pinned columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getrightfootergroups)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getRightFooterGroups: () => HeaderGroup<TData>[]\n\n  /**\n   * Returns headers for all columns in the table, including parent headers.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getflatheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getFlatHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all left pinned columns in the table, including parent headers.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getleftflatheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeftFlatHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all columns that are not pinned, including parent headers.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getcenterflatheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getCenterFlatHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all right pinned columns in the table, including parent headers.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getrightflatheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getRightFlatHeaders: () => Header<TData, unknown>[]\n\n  /**\n   * Returns headers for all leaf columns in the table, (not including parent headers).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getleafheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeafHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all left pinned leaf columns in the table, (not including parent headers).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getleftleafheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getLeftLeafHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all columns that are not pinned, (not including parent headers).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getcenterleafheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getCenterLeafHeaders: () => Header<TData, unknown>[]\n  /**\n   * If pinning, returns headers for all right pinned leaf columns in the table, (not including parent headers).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/headers#getrightleafheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/headers)\n   */\n  getRightLeafHeaders: () => Header<TData, unknown>[]\n}\n\n//\n\nfunction createHeader<TData extends RowData, TValue>(\n  table: Table<TData>,\n  column: Column<TData, TValue>,\n  options: {\n    id?: string\n    isPlaceholder?: boolean\n    placeholderId?: string\n    index: number\n    depth: number\n  }\n): Header<TData, TValue> {\n  const id = options.id ?? column.id\n\n  let header: CoreHeader<TData, TValue> = {\n    id,\n    column,\n    index: options.index,\n    isPlaceholder: !!options.isPlaceholder,\n    placeholderId: options.placeholderId,\n    depth: options.depth,\n    subHeaders: [],\n    colSpan: 0,\n    rowSpan: 0,\n    headerGroup: null!,\n    getLeafHeaders: (): Header<TData, unknown>[] => {\n      const leafHeaders: Header<TData, unknown>[] = []\n\n      const recurseHeader = (h: CoreHeader<TData, any>) => {\n        if (h.subHeaders && h.subHeaders.length) {\n          h.subHeaders.map(recurseHeader)\n        }\n        leafHeaders.push(h as Header<TData, unknown>)\n      }\n\n      recurseHeader(header)\n\n      return leafHeaders\n    },\n    getContext: () => ({\n      table,\n      header: header as Header<TData, TValue>,\n      column,\n    }),\n  }\n\n  table._features.forEach(feature => {\n    feature.createHeader?.(header as Header<TData, TValue>, table)\n  })\n\n  return header as Header<TData, TValue>\n}\n\nexport const Headers: TableFeature = {\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    // Header Groups\n\n    table.getHeaderGroups = memo(\n      () => [\n        table.getAllColumns(),\n        table.getVisibleLeafColumns(),\n        table.getState().columnPinning.left,\n        table.getState().columnPinning.right,\n      ],\n      (allColumns, leafColumns, left, right) => {\n        const leftColumns =\n          left\n            ?.map(columnId => leafColumns.find(d => d.id === columnId)!)\n            .filter(Boolean) ?? []\n\n        const rightColumns =\n          right\n            ?.map(columnId => leafColumns.find(d => d.id === columnId)!)\n            .filter(Boolean) ?? []\n\n        const centerColumns = leafColumns.filter(\n          column => !left?.includes(column.id) && !right?.includes(column.id)\n        )\n\n        const headerGroups = buildHeaderGroups(\n          allColumns,\n          [...leftColumns, ...centerColumns, ...rightColumns],\n          table\n        )\n\n        return headerGroups\n      },\n      getMemoOptions(table.options, debug, 'getHeaderGroups')\n    )\n\n    table.getCenterHeaderGroups = memo(\n      () => [\n        table.getAllColumns(),\n        table.getVisibleLeafColumns(),\n        table.getState().columnPinning.left,\n        table.getState().columnPinning.right,\n      ],\n      (allColumns, leafColumns, left, right) => {\n        leafColumns = leafColumns.filter(\n          column => !left?.includes(column.id) && !right?.includes(column.id)\n        )\n        return buildHeaderGroups(allColumns, leafColumns, table, 'center')\n      },\n      getMemoOptions(table.options, debug, 'getCenterHeaderGroups')\n    )\n\n    table.getLeftHeaderGroups = memo(\n      () => [\n        table.getAllColumns(),\n        table.getVisibleLeafColumns(),\n        table.getState().columnPinning.left,\n      ],\n      (allColumns, leafColumns, left) => {\n        const orderedLeafColumns =\n          left\n            ?.map(columnId => leafColumns.find(d => d.id === columnId)!)\n            .filter(Boolean) ?? []\n\n        return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'left')\n      },\n      getMemoOptions(table.options, debug, 'getLeftHeaderGroups')\n    )\n\n    table.getRightHeaderGroups = memo(\n      () => [\n        table.getAllColumns(),\n        table.getVisibleLeafColumns(),\n        table.getState().columnPinning.right,\n      ],\n      (allColumns, leafColumns, right) => {\n        const orderedLeafColumns =\n          right\n            ?.map(columnId => leafColumns.find(d => d.id === columnId)!)\n            .filter(Boolean) ?? []\n\n        return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'right')\n      },\n      getMemoOptions(table.options, debug, 'getRightHeaderGroups')\n    )\n\n    // Footer Groups\n\n    table.getFooterGroups = memo(\n      () => [table.getHeaderGroups()],\n      headerGroups => {\n        return [...headerGroups].reverse()\n      },\n      getMemoOptions(table.options, debug, 'getFooterGroups')\n    )\n\n    table.getLeftFooterGroups = memo(\n      () => [table.getLeftHeaderGroups()],\n      headerGroups => {\n        return [...headerGroups].reverse()\n      },\n      getMemoOptions(table.options, debug, 'getLeftFooterGroups')\n    )\n\n    table.getCenterFooterGroups = memo(\n      () => [table.getCenterHeaderGroups()],\n      headerGroups => {\n        return [...headerGroups].reverse()\n      },\n      getMemoOptions(table.options, debug, 'getCenterFooterGroups')\n    )\n\n    table.getRightFooterGroups = memo(\n      () => [table.getRightHeaderGroups()],\n      headerGroups => {\n        return [...headerGroups].reverse()\n      },\n      getMemoOptions(table.options, debug, 'getRightFooterGroups')\n    )\n\n    // Flat Headers\n\n    table.getFlatHeaders = memo(\n      () => [table.getHeaderGroups()],\n      headerGroups => {\n        return headerGroups\n          .map(headerGroup => {\n            return headerGroup.headers\n          })\n          .flat()\n      },\n      getMemoOptions(table.options, debug, 'getFlatHeaders')\n    )\n\n    table.getLeftFlatHeaders = memo(\n      () => [table.getLeftHeaderGroups()],\n      left => {\n        return left\n          .map(headerGroup => {\n            return headerGroup.headers\n          })\n          .flat()\n      },\n      getMemoOptions(table.options, debug, 'getLeftFlatHeaders')\n    )\n\n    table.getCenterFlatHeaders = memo(\n      () => [table.getCenterHeaderGroups()],\n      left => {\n        return left\n          .map(headerGroup => {\n            return headerGroup.headers\n          })\n          .flat()\n      },\n      getMemoOptions(table.options, debug, 'getCenterFlatHeaders')\n    )\n\n    table.getRightFlatHeaders = memo(\n      () => [table.getRightHeaderGroups()],\n      left => {\n        return left\n          .map(headerGroup => {\n            return headerGroup.headers\n          })\n          .flat()\n      },\n      getMemoOptions(table.options, debug, 'getRightFlatHeaders')\n    )\n\n    // Leaf Headers\n\n    table.getCenterLeafHeaders = memo(\n      () => [table.getCenterFlatHeaders()],\n      flatHeaders => {\n        return flatHeaders.filter(header => !header.subHeaders?.length)\n      },\n      getMemoOptions(table.options, debug, 'getCenterLeafHeaders')\n    )\n\n    table.getLeftLeafHeaders = memo(\n      () => [table.getLeftFlatHeaders()],\n      flatHeaders => {\n        return flatHeaders.filter(header => !header.subHeaders?.length)\n      },\n      getMemoOptions(table.options, debug, 'getLeftLeafHeaders')\n    )\n\n    table.getRightLeafHeaders = memo(\n      () => [table.getRightFlatHeaders()],\n      flatHeaders => {\n        return flatHeaders.filter(header => !header.subHeaders?.length)\n      },\n      getMemoOptions(table.options, debug, 'getRightLeafHeaders')\n    )\n\n    table.getLeafHeaders = memo(\n      () => [\n        table.getLeftHeaderGroups(),\n        table.getCenterHeaderGroups(),\n        table.getRightHeaderGroups(),\n      ],\n      (left, center, right) => {\n        return [\n          ...(left[0]?.headers ?? []),\n          ...(center[0]?.headers ?? []),\n          ...(right[0]?.headers ?? []),\n        ]\n          .map(header => {\n            return header.getLeafHeaders()\n          })\n          .flat()\n      },\n      getMemoOptions(table.options, debug, 'getLeafHeaders')\n    )\n  },\n}\n\nexport function buildHeaderGroups<TData extends RowData>(\n  allColumns: Column<TData, unknown>[],\n  columnsToGroup: Column<TData, unknown>[],\n  table: Table<TData>,\n  headerFamily?: 'center' | 'left' | 'right'\n) {\n  // Find the max depth of the columns:\n  // build the leaf column row\n  // build each buffer row going up\n  //    placeholder for non-existent level\n  //    real column for existing level\n\n  let maxDepth = 0\n\n  const findMaxDepth = (columns: Column<TData, unknown>[], depth = 1) => {\n    maxDepth = Math.max(maxDepth, depth)\n\n    columns\n      .filter(column => column.getIsVisible())\n      .forEach(column => {\n        if (column.columns?.length) {\n          findMaxDepth(column.columns, depth + 1)\n        }\n      }, 0)\n  }\n\n  findMaxDepth(allColumns)\n\n  let headerGroups: HeaderGroup<TData>[] = []\n\n  const createHeaderGroup = (\n    headersToGroup: Header<TData, unknown>[],\n    depth: number\n  ) => {\n    // The header group we are creating\n    const headerGroup: HeaderGroup<TData> = {\n      depth,\n      id: [headerFamily, `${depth}`].filter(Boolean).join('_'),\n      headers: [],\n    }\n\n    // The parent columns we're going to scan next\n    const pendingParentHeaders: Header<TData, unknown>[] = []\n\n    // Scan each column for parents\n    headersToGroup.forEach(headerToGroup => {\n      // What is the latest (last) parent column?\n\n      const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0]\n\n      const isLeafHeader = headerToGroup.column.depth === headerGroup.depth\n\n      let column: Column<TData, unknown>\n      let isPlaceholder = false\n\n      if (isLeafHeader && headerToGroup.column.parent) {\n        // The parent header is new\n        column = headerToGroup.column.parent\n      } else {\n        // The parent header is repeated\n        column = headerToGroup.column\n        isPlaceholder = true\n      }\n\n      if (\n        latestPendingParentHeader &&\n        latestPendingParentHeader?.column === column\n      ) {\n        // This column is repeated. Add it as a sub header to the next batch\n        latestPendingParentHeader.subHeaders.push(headerToGroup)\n      } else {\n        // This is a new header. Let's create it\n        const header = createHeader(table, column, {\n          id: [headerFamily, depth, column.id, headerToGroup?.id]\n            .filter(Boolean)\n            .join('_'),\n          isPlaceholder,\n          placeholderId: isPlaceholder\n            ? `${pendingParentHeaders.filter(d => d.column === column).length}`\n            : undefined,\n          depth,\n          index: pendingParentHeaders.length,\n        })\n\n        // Add the headerToGroup as a subHeader of the new header\n        header.subHeaders.push(headerToGroup)\n        // Add the new header to the pendingParentHeaders to get grouped\n        // in the next batch\n        pendingParentHeaders.push(header)\n      }\n\n      headerGroup.headers.push(headerToGroup)\n      headerToGroup.headerGroup = headerGroup\n    })\n\n    headerGroups.push(headerGroup)\n\n    if (depth > 0) {\n      createHeaderGroup(pendingParentHeaders, depth - 1)\n    }\n  }\n\n  const bottomHeaders = columnsToGroup.map((column, index) =>\n    createHeader(table, column, {\n      depth: maxDepth,\n      index,\n    })\n  )\n\n  createHeaderGroup(bottomHeaders, maxDepth - 1)\n\n  headerGroups.reverse()\n\n  // headerGroups = headerGroups.filter(headerGroup => {\n  //   return !headerGroup.headers.every(header => header.isPlaceholder)\n  // })\n\n  const recurseHeadersForSpans = (\n    headers: Header<TData, unknown>[]\n  ): { colSpan: number; rowSpan: number }[] => {\n    const filteredHeaders = headers.filter(header =>\n      header.column.getIsVisible()\n    )\n\n    return filteredHeaders.map(header => {\n      let colSpan = 0\n      let rowSpan = 0\n      let childRowSpans = [0]\n\n      if (header.subHeaders && header.subHeaders.length) {\n        childRowSpans = []\n\n        recurseHeadersForSpans(header.subHeaders).forEach(\n          ({ colSpan: childColSpan, rowSpan: childRowSpan }) => {\n            colSpan += childColSpan\n            childRowSpans.push(childRowSpan)\n          }\n        )\n      } else {\n        colSpan = 1\n      }\n\n      const minChildRowSpan = Math.min(...childRowSpans)\n      rowSpan = rowSpan + minChildRowSpan\n\n      header.colSpan = colSpan\n      header.rowSpan = rowSpan\n\n      return { colSpan, rowSpan }\n    })\n  }\n\n  recurseHeadersForSpans(headerGroups[0]?.headers ?? [])\n\n  return headerGroups\n}\n","import { RowData, Cell, Row, Table } from '../types'\nimport { flattenBy, getMemoOptions, memo } from '../utils'\nimport { createCell } from './cell'\n\nexport interface CoreRow<TData extends RowData> {\n  _getAllCellsByColumnId: () => Record<string, Cell<TData, unknown>>\n  _uniqueValuesCache: Record<string, unknown>\n  _valuesCache: Record<string, unknown>\n  /**\n   * The depth of the row (if nested or grouped) relative to the root row array.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#depth)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  depth: number\n  /**\n   * Returns all of the cells for the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getallcells)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getAllCells: () => Cell<TData, unknown>[]\n  /**\n   * Returns the leaf rows for the row, not including any parent rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getleafrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getLeafRows: () => Row<TData>[]\n  /**\n   * Returns the parent row for the row, if it exists.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getparentrow)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getParentRow: () => Row<TData> | undefined\n  /**\n   * Returns the parent rows for the row, all the way up to a root row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getparentrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getParentRows: () => Row<TData>[]\n  /**\n   * Returns a unique array of values from the row for a given columnId.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getuniquevalues)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getUniqueValues: <TValue>(columnId: string) => TValue[]\n  /**\n   * Returns the value from the row for a given columnId.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#getvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  getValue: <TValue>(columnId: string) => TValue\n  /**\n   * The resolved unique identifier for the row resolved via the `options.getRowId` option. Defaults to the row's index (or relative index if it is a subRow).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#id)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  id: string\n  /**\n   * The index of the row within its parent array (or the root data array).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#index)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  index: number\n  /**\n   * The original row object provided to the table. If the row is a grouped row, the original row object will be the first original in the group.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#original)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  original: TData\n  /**\n   * An array of the original subRows as returned by the `options.getSubRows` option.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#originalsubrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  originalSubRows?: TData[]\n  /**\n   * If nested, this row's parent row id.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#parentid)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  parentId?: string\n  /**\n   * Renders the value for the row in a given columnId the same as `getValue`, but will return the `renderFallbackValue` if no value is found.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#rendervalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  renderValue: <TValue>(columnId: string) => TValue\n  /**\n   * An array of subRows for the row as returned and created by the `options.getSubRows` option.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/row#subrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/rows)\n   */\n  subRows: Row<TData>[]\n}\n\nexport const createRow = <TData extends RowData>(\n  table: Table<TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Row<TData>[],\n  parentId?: string\n): Row<TData> => {\n  let row: CoreRow<TData> = {\n    id,\n    index: rowIndex,\n    original,\n    depth,\n    parentId,\n    _valuesCache: {},\n    _uniqueValuesCache: {},\n    getValue: columnId => {\n      if (row._valuesCache.hasOwnProperty(columnId)) {\n        return row._valuesCache[columnId]\n      }\n\n      const column = table.getColumn(columnId)\n\n      if (!column?.accessorFn) {\n        return undefined\n      }\n\n      row._valuesCache[columnId] = column.accessorFn(\n        row.original as TData,\n        rowIndex\n      )\n\n      return row._valuesCache[columnId] as any\n    },\n    getUniqueValues: columnId => {\n      if (row._uniqueValuesCache.hasOwnProperty(columnId)) {\n        return row._uniqueValuesCache[columnId]\n      }\n\n      const column = table.getColumn(columnId)\n\n      if (!column?.accessorFn) {\n        return undefined\n      }\n\n      if (!column.columnDef.getUniqueValues) {\n        row._uniqueValuesCache[columnId] = [row.getValue(columnId)]\n        return row._uniqueValuesCache[columnId]\n      }\n\n      row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(\n        row.original as TData,\n        rowIndex\n      )\n\n      return row._uniqueValuesCache[columnId] as any\n    },\n    renderValue: columnId =>\n      row.getValue(columnId) ?? table.options.renderFallbackValue,\n    subRows: subRows ?? [],\n    getLeafRows: () => flattenBy(row.subRows, d => d.subRows),\n    getParentRow: () =>\n      row.parentId ? table.getRow(row.parentId, true) : undefined,\n    getParentRows: () => {\n      let parentRows: Row<TData>[] = []\n      let currentRow = row\n      while (true) {\n        const parentRow = currentRow.getParentRow()\n        if (!parentRow) break\n        parentRows.push(parentRow)\n        currentRow = parentRow\n      }\n      return parentRows.reverse()\n    },\n    getAllCells: memo(\n      () => [table.getAllLeafColumns()],\n      leafColumns => {\n        return leafColumns.map(column => {\n          return createCell(table, row as Row<TData>, column, column.id)\n        })\n      },\n      getMemoOptions(table.options, 'debugRows', 'getAllCells')\n    ),\n\n    _getAllCellsByColumnId: memo(\n      () => [row.getAllCells()],\n      allCells => {\n        return allCells.reduce(\n          (acc, cell) => {\n            acc[cell.column.id] = cell\n            return acc\n          },\n          {} as Record<string, Cell<TData, unknown>>\n        )\n      },\n      getMemoOptions(table.options, 'debugRows', 'getAllCellsByColumnId')\n    ),\n  }\n\n  for (let i = 0; i < table._features.length; i++) {\n    const feature = table._features[i]\n    feature?.createRow?.(row as Row<TData>, table)\n  }\n\n  return row as Row<TData>\n}\n","import { RowData, Cell, Column, Row, Table } from '../types'\nimport { Getter, getMemoOptions, memo } from '../utils'\n\nexport interface CellContext<TData extends RowData, TValue> {\n  cell: Cell<TData, TValue>\n  column: Column<TData, TValue>\n  getValue: Getter<TValue>\n  renderValue: Getter<TValue | null>\n  row: Row<TData>\n  table: Table<TData>\n}\n\nexport interface CoreCell<TData extends RowData, TValue> {\n  /**\n   * The associated Column object for the cell.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#column)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  column: Column<TData, TValue>\n  /**\n   * Returns the rendering context (or props) for cell-based components like cells and aggregated cells. Use these props with your framework's `flexRender` utility to render these using the template of your choice:\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#getcontext)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  getContext: () => CellContext<TData, TValue>\n  /**\n   * Returns the value for the cell, accessed via the associated column's accessor key or accessor function.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#getvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  getValue: CellContext<TData, TValue>['getValue']\n  /**\n   * The unique ID for the cell across the entire table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#id)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  id: string\n  /**\n   * Renders the value for a cell the same as `getValue`, but will return the `renderFallbackValue` if no value is found.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#rendervalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  renderValue: CellContext<TData, TValue>['renderValue']\n  /**\n   * The associated Row object for the cell.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/cell#row)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/cells)\n   */\n  row: Row<TData>\n}\n\nexport function createCell<TData extends RowData, TValue>(\n  table: Table<TData>,\n  row: Row<TData>,\n  column: Column<TData, TValue>,\n  columnId: string\n): Cell<TData, TValue> {\n  const getRenderValue = () =>\n    cell.getValue() ?? table.options.renderFallbackValue\n\n  const cell: CoreCell<TData, TValue> = {\n    id: `${row.id}_${column.id}`,\n    row,\n    column,\n    getValue: () => row.getValue(columnId),\n    renderValue: getRenderValue,\n    getContext: memo(\n      () => [table, column, row, cell],\n      (table, column, row, cell) => ({\n        table,\n        column,\n        row,\n        cell: cell as Cell<TData, TValue>,\n        getValue: cell.getValue,\n        renderValue: cell.renderValue,\n      }),\n      getMemoOptions(table.options, 'debugCells', 'cell.getContext')\n    ),\n  }\n\n  table._features.forEach(feature => {\n    feature.createCell?.(\n      cell as Cell<TData, TValue>,\n      column,\n      row as Row<TData>,\n      table\n    )\n  }, {})\n\n  return cell as Cell<TData, TValue>\n}\n","import { RowModel } from '..'\nimport { Column, RowData, Table, TableFeature } from '../types'\n\nexport interface FacetedColumn<TData extends RowData> {\n  _getFacetedMinMaxValues?: () => undefined | [number, number]\n  _getFacetedRowModel?: () => RowModel<TData>\n  _getFacetedUniqueValues?: () => Map<any, number>\n  /**\n   * A function that **computes and returns** a min/max tuple derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.\n   * > ⚠️ Requires that you pass a valid `getFacetedMinMaxValues` function to `options.getFacetedMinMaxValues`. A default implementation is provided via the exported `getFacetedMinMaxValues` function.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-faceting#getfacetedminmaxvalues)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-faceting)\n   */\n  getFacetedMinMaxValues: () => undefined | [number, number]\n  /**\n   * Returns the row model with all other column filters applied, excluding its own filter. Useful for displaying faceted result counts.\n   * > ⚠️ Requires that you pass a valid `getFacetedRowModel` function to `options.facetedRowModel`. A default implementation is provided via the exported `getFacetedRowModel` function.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-faceting#getfacetedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-faceting)\n   */\n  getFacetedRowModel: () => RowModel<TData>\n  /**\n   * A function that **computes and returns** a `Map` of unique values and their occurrences derived from `column.getFacetedRowModel`. Useful for displaying faceted result values.\n   * > ⚠️ Requires that you pass a valid `getFacetedUniqueValues` function to `options.getFacetedUniqueValues`. A default implementation is provided via the exported `getFacetedUniqueValues` function.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-faceting#getfaceteduniquevalues)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-faceting)\n   */\n  getFacetedUniqueValues: () => Map<any, number>\n}\n\nexport interface FacetedOptions<TData extends RowData> {\n  getFacetedMinMaxValues?: (\n    table: Table<TData>,\n    columnId: string\n  ) => () => undefined | [number, number]\n  getFacetedRowModel?: (\n    table: Table<TData>,\n    columnId: string\n  ) => () => RowModel<TData>\n  getFacetedUniqueValues?: (\n    table: Table<TData>,\n    columnId: string\n  ) => () => Map<any, number>\n}\n\n//\n\nexport const ColumnFaceting: TableFeature = {\n  createColumn: <TData extends RowData>(\n    column: Column<TData, unknown>,\n    table: Table<TData>\n  ): void => {\n    column._getFacetedRowModel =\n      table.options.getFacetedRowModel &&\n      table.options.getFacetedRowModel(table, column.id)\n    column.getFacetedRowModel = () => {\n      if (!column._getFacetedRowModel) {\n        return table.getPreFilteredRowModel()\n      }\n\n      return column._getFacetedRowModel()\n    }\n    column._getFacetedUniqueValues =\n      table.options.getFacetedUniqueValues &&\n      table.options.getFacetedUniqueValues(table, column.id)\n    column.getFacetedUniqueValues = () => {\n      if (!column._getFacetedUniqueValues) {\n        return new Map()\n      }\n\n      return column._getFacetedUniqueValues()\n    }\n    column._getFacetedMinMaxValues =\n      table.options.getFacetedMinMaxValues &&\n      table.options.getFacetedMinMaxValues(table, column.id)\n    column.getFacetedMinMaxValues = () => {\n      if (!column._getFacetedMinMaxValues) {\n        return undefined\n      }\n\n      return column._getFacetedMinMaxValues()\n    }\n  },\n}\n","import { FilterFn } from './features/ColumnFiltering'\n\nconst includesString: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: string\n) => {\n  const search = filterValue?.toString()?.toLowerCase()\n  return Boolean(\n    row\n      .getValue<string | null>(columnId)\n      ?.toString()\n      ?.toLowerCase()\n      ?.includes(search)\n  )\n}\n\nincludesString.autoRemove = (val: any) => testFalsey(val)\n\nconst includesStringSensitive: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: string\n) => {\n  return Boolean(\n    row.getValue<string | null>(columnId)?.toString()?.includes(filterValue)\n  )\n}\n\nincludesStringSensitive.autoRemove = (val: any) => testFalsey(val)\n\nconst equalsString: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: string\n) => {\n  return (\n    row.getValue<string | null>(columnId)?.toString()?.toLowerCase() ===\n    filterValue?.toLowerCase()\n  )\n}\n\nequalsString.autoRemove = (val: any) => testFalsey(val)\n\nconst arrIncludes: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: unknown\n) => {\n  return row.getValue<unknown[]>(columnId)?.includes(filterValue)\n}\n\narrIncludes.autoRemove = (val: any) => testFalsey(val) || !val?.length\n\nconst arrIncludesAll: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: unknown[]\n) => {\n  return !filterValue.some(\n    val => !row.getValue<unknown[]>(columnId)?.includes(val)\n  )\n}\n\narrIncludesAll.autoRemove = (val: any) => testFalsey(val) || !val?.length\n\nconst arrIncludesSome: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: unknown[]\n) => {\n  return filterValue.some(val =>\n    row.getValue<unknown[]>(columnId)?.includes(val)\n  )\n}\n\narrIncludesSome.autoRemove = (val: any) => testFalsey(val) || !val?.length\n\nconst equals: FilterFn<any> = (row, columnId: string, filterValue: unknown) => {\n  return row.getValue(columnId) === filterValue\n}\n\nequals.autoRemove = (val: any) => testFalsey(val)\n\nconst weakEquals: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: unknown\n) => {\n  return row.getValue(columnId) == filterValue\n}\n\nweakEquals.autoRemove = (val: any) => testFalsey(val)\n\nconst inNumberRange: FilterFn<any> = (\n  row,\n  columnId: string,\n  filterValue: [number, number]\n) => {\n  let [min, max] = filterValue\n\n  const rowValue = row.getValue<number>(columnId)\n  return rowValue >= min && rowValue <= max\n}\n\ninNumberRange.resolveFilterValue = (val: [any, any]) => {\n  let [unsafeMin, unsafeMax] = val\n\n  let parsedMin =\n    typeof unsafeMin !== 'number' ? parseFloat(unsafeMin as string) : unsafeMin\n  let parsedMax =\n    typeof unsafeMax !== 'number' ? parseFloat(unsafeMax as string) : unsafeMax\n\n  let min =\n    unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin\n  let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax\n\n  if (min > max) {\n    const temp = min\n    min = max\n    max = temp\n  }\n\n  return [min, max] as const\n}\n\ninNumberRange.autoRemove = (val: any) =>\n  testFalsey(val) || (testFalsey(val[0]) && testFalsey(val[1]))\n\n// Export\n\nexport const filterFns = {\n  includesString,\n  includesStringSensitive,\n  equalsString,\n  arrIncludes,\n  arrIncludesAll,\n  arrIncludesSome,\n  equals,\n  weakEquals,\n  inNumberRange,\n}\n\nexport type BuiltInFilterFn = keyof typeof filterFns\n\n// Utils\n\nfunction testFalsey(val: any) {\n  return val === undefined || val === null || val === ''\n}\n","import { RowModel } from '..'\nimport { BuiltInFilterFn, filterFns } from '../filterFns'\nimport {\n  Column,\n  FilterFns,\n  FilterMeta,\n  OnChangeFn,\n  Row,\n  RowData,\n  Table,\n  TableFeature,\n  Updater,\n} from '../types'\nimport { functionalUpdate, isFunction, makeStateUpdater } from '../utils'\n\nexport interface ColumnFiltersTableState {\n  columnFilters: ColumnFiltersState\n}\n\nexport type ColumnFiltersState = ColumnFilter[]\n\nexport interface ColumnFilter {\n  id: string\n  value: unknown\n}\n\nexport interface ResolvedColumnFilter<TData extends RowData> {\n  filterFn: FilterFn<TData>\n  id: string\n  resolvedValue: unknown\n}\n\nexport interface FilterFn<TData extends RowData> {\n  (\n    row: Row<TData>,\n    columnId: string,\n    filterValue: any,\n    addMeta: (meta: FilterMeta) => void\n  ): boolean\n  autoRemove?: ColumnFilterAutoRemoveTestFn<TData>\n  resolveFilterValue?: TransformFilterValueFn<TData>\n}\n\nexport type TransformFilterValueFn<TData extends RowData> = (\n  value: any,\n  column?: Column<TData, unknown>\n) => unknown\n\nexport type ColumnFilterAutoRemoveTestFn<TData extends RowData> = (\n  value: any,\n  column?: Column<TData, unknown>\n) => boolean\n\nexport type CustomFilterFns<TData extends RowData> = Record<\n  string,\n  FilterFn<TData>\n>\n\nexport type FilterFnOption<TData extends RowData> =\n  | 'auto'\n  | BuiltInFilterFn\n  | keyof FilterFns\n  | FilterFn<TData>\n\nexport interface ColumnFiltersColumnDef<TData extends RowData> {\n  /**\n   * Enables/disables the **column** filter for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#enablecolumnfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  enableColumnFilter?: boolean\n  /**\n   * The filter function to use with this column. Can be the name of a built-in filter function or a custom filter function.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#filterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  filterFn?: FilterFnOption<TData>\n}\n\nexport interface ColumnFiltersColumn<TData extends RowData> {\n  /**\n   * Returns an automatically calculated filter function for the column based off of the columns first known value.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getautofilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getAutoFilterFn: () => FilterFn<TData> | undefined\n  /**\n   * Returns whether or not the column can be **column** filtered.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getcanfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getCanFilter: () => boolean\n  /**\n   * Returns the filter function (either user-defined or automatic, depending on configuration) for the columnId specified.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getfilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getFilterFn: () => FilterFn<TData> | undefined\n  /**\n   * Returns the index (including `-1`) of the column filter in the table's `state.columnFilters` array.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getfilterindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getFilterIndex: () => number\n  /**\n   * Returns the current filter value for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getfiltervalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getFilterValue: () => unknown\n  /**\n   * Returns whether or not the column is currently filtered.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getisfiltered)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getIsFiltered: () => boolean\n  /**\n   * A function that sets the current filter value for the column. You can pass it a value or an updater function for immutability-safe operations on existing values.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#setfiltervalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  setFilterValue: (updater: Updater<any>) => void\n}\n\nexport interface ColumnFiltersRow<TData extends RowData> {\n  /**\n   * The column filters map for the row. This object tracks whether a row is passing/failing specific filters by their column ID.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#columnfilters)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  columnFilters: Record<string, boolean>\n  /**\n   * The column filters meta map for the row. This object tracks any filter meta for a row as optionally provided during the filtering process.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#columnfiltersmeta)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  columnFiltersMeta: Record<string, FilterMeta>\n}\n\ninterface ColumnFiltersOptionsBase<TData extends RowData> {\n  /**\n   * Enables/disables **column** filtering for all columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#enablecolumnfilters)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  enableColumnFilters?: boolean\n  /**\n   * Enables/disables all filtering for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#enablefilters)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  enableFilters?: boolean\n  /**\n   * By default, filtering is done from parent rows down (so if a parent row is filtered out, all of its children will be filtered out as well). Setting this option to `true` will cause filtering to be done from leaf rows up (which means parent rows will be included so long as one of their child or grand-child rows is also included).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#filterfromleafrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  filterFromLeafRows?: boolean\n  /**\n   * If provided, this function is called **once** per table and should return a **new function** which will calculate and return the row model for the table when it's filtered.\n   * - For server-side filtering, this function is unnecessary and can be ignored since the server should already return the filtered row model.\n   * - For client-side filtering, this function is required. A default implementation is provided via any table adapter's `{ getFilteredRowModel }` export.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getfilteredrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getFilteredRowModel?: (table: Table<any>) => () => RowModel<any>\n  /**\n   * Disables the `getFilteredRowModel` from being used to filter data. This may be useful if your table needs to dynamically support both client-side and server-side filtering.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#manualfiltering)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  manualFiltering?: boolean\n  /**\n   * By default, filtering is done for all rows (max depth of 100), no matter if they are root level parent rows or the child leaf rows of a parent row. Setting this option to `0` will cause filtering to only be applied to the root level parent rows, with all sub-rows remaining unfiltered. Similarly, setting this option to `1` will cause filtering to only be applied to child leaf rows 1 level deep, and so on.\n\n   * This is useful for situations where you want a row's entire child hierarchy to be visible regardless of the applied filter.\n    * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#maxleafrowfilterdepth)\n    * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  maxLeafRowFilterDepth?: number\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnFilters` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#oncolumnfilterschange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  onColumnFiltersChange?: OnChangeFn<ColumnFiltersState>\n}\n\ntype ResolvedFilterFns = keyof FilterFns extends never\n  ? {\n      filterFns?: Record<string, FilterFn<any>>\n    }\n  : {\n      filterFns: Record<keyof FilterFns, FilterFn<any>>\n    }\n\nexport interface ColumnFiltersOptions<TData extends RowData>\n  extends ColumnFiltersOptionsBase<TData>,\n    ResolvedFilterFns {}\n\nexport interface ColumnFiltersInstance<TData extends RowData> {\n  _getFilteredRowModel?: () => RowModel<TData>\n  /**\n   * Returns the row model for the table after **column** filtering has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getfilteredrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getFilteredRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model for the table before any **column** filtering has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#getprefilteredrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  getPreFilteredRowModel: () => RowModel<TData>\n  /**\n   * Resets the **columnFilters** state to `initialState.columnFilters`, or `true` can be passed to force a default blank state reset to `[]`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#resetcolumnfilters)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  resetColumnFilters: (defaultState?: boolean) => void\n  /**\n   * Resets the **globalFilter** state to `initialState.globalFilter`, or `true` can be passed to force a default blank state reset to `undefined`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#resetglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  resetGlobalFilter: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.columnFilters` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#setcolumnfilters)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  setColumnFilters: (updater: Updater<ColumnFiltersState>) => void\n  /**\n   * Sets or updates the `state.globalFilter` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-filtering#setglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-filtering)\n   */\n  setGlobalFilter: (updater: Updater<any>) => void\n}\n\n//\n\nexport const ColumnFiltering: TableFeature = {\n  getDefaultColumnDef: <\n    TData extends RowData,\n  >(): ColumnFiltersColumnDef<TData> => {\n    return {\n      filterFn: 'auto',\n    }\n  },\n\n  getInitialState: (state): ColumnFiltersTableState => {\n    return {\n      columnFilters: [],\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): ColumnFiltersOptions<TData> => {\n    return {\n      onColumnFiltersChange: makeStateUpdater('columnFilters', table),\n      filterFromLeafRows: false,\n      maxLeafRowFilterDepth: 100,\n    } as ColumnFiltersOptions<TData>\n  },\n\n  createColumn: <TData extends RowData>(\n    column: Column<TData, unknown>,\n    table: Table<TData>\n  ): void => {\n    column.getAutoFilterFn = () => {\n      const firstRow = table.getCoreRowModel().flatRows[0]\n\n      const value = firstRow?.getValue(column.id)\n\n      if (typeof value === 'string') {\n        return filterFns.includesString\n      }\n\n      if (typeof value === 'number') {\n        return filterFns.inNumberRange\n      }\n\n      if (typeof value === 'boolean') {\n        return filterFns.equals\n      }\n\n      if (value !== null && typeof value === 'object') {\n        return filterFns.equals\n      }\n\n      if (Array.isArray(value)) {\n        return filterFns.arrIncludes\n      }\n\n      return filterFns.weakEquals\n    }\n    column.getFilterFn = () => {\n      return isFunction(column.columnDef.filterFn)\n        ? column.columnDef.filterFn\n        : column.columnDef.filterFn === 'auto'\n          ? column.getAutoFilterFn()\n          : // @ts-ignore\n            table.options.filterFns?.[column.columnDef.filterFn as string] ??\n            filterFns[column.columnDef.filterFn as BuiltInFilterFn]\n    }\n    column.getCanFilter = () => {\n      return (\n        (column.columnDef.enableColumnFilter ?? true) &&\n        (table.options.enableColumnFilters ?? true) &&\n        (table.options.enableFilters ?? true) &&\n        !!column.accessorFn\n      )\n    }\n\n    column.getIsFiltered = () => column.getFilterIndex() > -1\n\n    column.getFilterValue = () =>\n      table.getState().columnFilters?.find(d => d.id === column.id)?.value\n\n    column.getFilterIndex = () =>\n      table.getState().columnFilters?.findIndex(d => d.id === column.id) ?? -1\n\n    column.setFilterValue = value => {\n      table.setColumnFilters(old => {\n        const filterFn = column.getFilterFn()\n        const previousFilter = old?.find(d => d.id === column.id)\n\n        const newFilter = functionalUpdate(\n          value,\n          previousFilter ? previousFilter.value : undefined\n        )\n\n        //\n        if (\n          shouldAutoRemoveFilter(filterFn as FilterFn<TData>, newFilter, column)\n        ) {\n          return old?.filter(d => d.id !== column.id) ?? []\n        }\n\n        const newFilterObj = { id: column.id, value: newFilter }\n\n        if (previousFilter) {\n          return (\n            old?.map(d => {\n              if (d.id === column.id) {\n                return newFilterObj\n              }\n              return d\n            }) ?? []\n          )\n        }\n\n        if (old?.length) {\n          return [...old, newFilterObj]\n        }\n\n        return [newFilterObj]\n      })\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    _table: Table<TData>\n  ): void => {\n    row.columnFilters = {}\n    row.columnFiltersMeta = {}\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setColumnFilters = (updater: Updater<ColumnFiltersState>) => {\n      const leafColumns = table.getAllLeafColumns()\n\n      const updateFn = (old: ColumnFiltersState) => {\n        return functionalUpdate(updater, old)?.filter(filter => {\n          const column = leafColumns.find(d => d.id === filter.id)\n\n          if (column) {\n            const filterFn = column.getFilterFn()\n\n            if (shouldAutoRemoveFilter(filterFn, filter.value, column)) {\n              return false\n            }\n          }\n\n          return true\n        })\n      }\n\n      table.options.onColumnFiltersChange?.(updateFn)\n    }\n\n    table.resetColumnFilters = defaultState => {\n      table.setColumnFilters(\n        defaultState ? [] : table.initialState?.columnFilters ?? []\n      )\n    }\n\n    table.getPreFilteredRowModel = () => table.getCoreRowModel()\n    table.getFilteredRowModel = () => {\n      if (!table._getFilteredRowModel && table.options.getFilteredRowModel) {\n        table._getFilteredRowModel = table.options.getFilteredRowModel(table)\n      }\n\n      if (table.options.manualFiltering || !table._getFilteredRowModel) {\n        return table.getPreFilteredRowModel()\n      }\n\n      return table._getFilteredRowModel()\n    }\n  },\n}\n\nexport function shouldAutoRemoveFilter<TData extends RowData>(\n  filterFn?: FilterFn<TData>,\n  value?: any,\n  column?: Column<TData, unknown>\n) {\n  return (\n    (filterFn && filterFn.autoRemove\n      ? filterFn.autoRemove(value, column)\n      : false) ||\n    typeof value === 'undefined' ||\n    (typeof value === 'string' && !value)\n  )\n}\n","import { AggregationFn } from './features/ColumnGrouping'\nimport { isNumberArray } from './utils'\n\nconst sum: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  // It's faster to just add the aggregations together instead of\n  // process leaf nodes individually\n  return childRows.reduce((sum, next) => {\n    const nextValue = next.getValue(columnId)\n    return sum + (typeof nextValue === 'number' ? nextValue : 0)\n  }, 0)\n}\n\nconst min: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let min: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n\n    if (\n      value != null &&\n      (min! > value || (min === undefined && value >= value))\n    ) {\n      min = value\n    }\n  })\n\n  return min\n}\n\nconst max: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let max: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n    if (\n      value != null &&\n      (max! < value || (max === undefined && value >= value))\n    ) {\n      max = value\n    }\n  })\n\n  return max\n}\n\nconst extent: AggregationFn<any> = (columnId, _leafRows, childRows) => {\n  let min: number | undefined\n  let max: number | undefined\n\n  childRows.forEach(row => {\n    const value = row.getValue<number>(columnId)\n    if (value != null) {\n      if (min === undefined) {\n        if (value >= value) min = max = value\n      } else {\n        if (min > value) min = value\n        if (max! < value) max = value\n      }\n    }\n  })\n\n  return [min, max]\n}\n\nconst mean: AggregationFn<any> = (columnId, leafRows) => {\n  let count = 0\n  let sum = 0\n\n  leafRows.forEach(row => {\n    let value = row.getValue<number>(columnId)\n    if (value != null && (value = +value) >= value) {\n      ++count, (sum += value)\n    }\n  })\n\n  if (count) return sum / count\n\n  return\n}\n\nconst median: AggregationFn<any> = (columnId, leafRows) => {\n  if (!leafRows.length) {\n    return\n  }\n\n  const values = leafRows.map(row => row.getValue(columnId))\n  if (!isNumberArray(values)) {\n    return\n  }\n  if (values.length === 1) {\n    return values[0]\n  }\n\n  const mid = Math.floor(values.length / 2)\n  const nums = values.sort((a, b) => a - b)\n  return values.length % 2 !== 0 ? nums[mid] : (nums[mid - 1]! + nums[mid]!) / 2\n}\n\nconst unique: AggregationFn<any> = (columnId, leafRows) => {\n  return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values())\n}\n\nconst uniqueCount: AggregationFn<any> = (columnId, leafRows) => {\n  return new Set(leafRows.map(d => d.getValue(columnId))).size\n}\n\nconst count: AggregationFn<any> = (_columnId, leafRows) => {\n  return leafRows.length\n}\n\nexport const aggregationFns = {\n  sum,\n  min,\n  max,\n  extent,\n  mean,\n  median,\n  unique,\n  uniqueCount,\n  count,\n}\n\nexport type BuiltInAggregationFn = keyof typeof aggregationFns\n","import { RowModel } from '..'\nimport { BuiltInAggregationFn, aggregationFns } from '../aggregationFns'\nimport {\n  AggregationFns,\n  Cell,\n  Column,\n  ColumnDefTemplate,\n  OnChangeFn,\n  Row,\n  RowData,\n  Table,\n  TableFeature,\n  Updater,\n} from '../types'\nimport { isFunction, makeStateUpdater } from '../utils'\n\nexport type GroupingState = string[]\n\nexport interface GroupingTableState {\n  grouping: GroupingState\n}\n\nexport type AggregationFn<TData extends RowData> = (\n  columnId: string,\n  leafRows: Row<TData>[],\n  childRows: Row<TData>[]\n) => any\n\nexport type CustomAggregationFns = Record<string, AggregationFn<any>>\n\nexport type AggregationFnOption<TData extends RowData> =\n  | 'auto'\n  | keyof AggregationFns\n  | BuiltInAggregationFn\n  | AggregationFn<TData>\n\nexport interface GroupingColumnDef<TData extends RowData, TValue> {\n  /**\n   * The cell to display each row for the column if the cell is an aggregate. If a function is passed, it will be passed a props object with the context of the cell and should return the property type for your adapter (the exact type depends on the adapter being used).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#aggregatedcell)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  aggregatedCell?: ColumnDefTemplate<\n    ReturnType<Cell<TData, TValue>['getContext']>\n  >\n  /**\n   * The resolved aggregation function for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#aggregationfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  aggregationFn?: AggregationFnOption<TData>\n  /**\n   * Enables/disables grouping for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#enablegrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  enableGrouping?: boolean\n  /**\n   * Specify a value to be used for grouping rows on this column. If this option is not specified, the value derived from `accessorKey` / `accessorFn` will be used instead.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getgroupingvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getGroupingValue?: (row: TData) => any\n}\n\nexport interface GroupingColumn<TData extends RowData> {\n  /**\n   * Returns the aggregation function for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getaggregationfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getAggregationFn: () => AggregationFn<TData> | undefined\n  /**\n   * Returns the automatically inferred aggregation function for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getautoaggregationfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getAutoAggregationFn: () => AggregationFn<TData> | undefined\n  /**\n   * Returns whether or not the column can be grouped.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getcangroup)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getCanGroup: () => boolean\n  /**\n   * Returns the index of the column in the grouping state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getgroupedindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getGroupedIndex: () => number\n  /**\n   * Returns whether or not the column is currently grouped.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getisgrouped)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getIsGrouped: () => boolean\n  /**\n   * Returns a function that toggles the grouping state of the column. This is useful for passing to the `onClick` prop of a button.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#gettogglegroupinghandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getToggleGroupingHandler: () => () => void\n  /**\n   * Toggles the grouping state of the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#togglegrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  toggleGrouping: () => void\n}\n\nexport interface GroupingRow {\n  _groupingValuesCache: Record<string, any>\n  /**\n   * Returns the grouping value for any row and column (including leaf rows).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getgroupingvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getGroupingValue: (columnId: string) => unknown\n  /**\n   * Returns whether or not the row is currently grouped.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getisgrouped)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getIsGrouped: () => boolean\n  /**\n   * If this row is grouped, this is the id of the column that this row is grouped by.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#groupingcolumnid)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  groupingColumnId?: string\n  /**\n   * If this row is grouped, this is the unique/shared value for the `groupingColumnId` for all of the rows in this group.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#groupingvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  groupingValue?: unknown\n}\n\nexport interface GroupingCell {\n  /**\n   * Returns whether or not the cell is currently aggregated.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getisaggregated)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getIsAggregated: () => boolean\n  /**\n   * Returns whether or not the cell is currently grouped.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getisgrouped)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getIsGrouped: () => boolean\n  /**\n   * Returns whether or not the cell is currently a placeholder cell.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getisplaceholder)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getIsPlaceholder: () => boolean\n}\n\nexport interface ColumnDefaultOptions {\n  enableGrouping: boolean\n  onGroupingChange: OnChangeFn<GroupingState>\n}\n\ninterface GroupingOptionsBase {\n  /**\n   * Enables/disables grouping for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#enablegrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  enableGrouping?: boolean\n  /**\n   * Returns the row model after grouping has taken place, but no further.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getgroupedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getGroupedRowModel?: (table: Table<any>) => () => RowModel<any>\n  /**\n   * Grouping columns are automatically reordered by default to the start of the columns list. If you would rather remove them or leave them as-is, set the appropriate mode here.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#groupedcolumnmode)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  groupedColumnMode?: false | 'reorder' | 'remove'\n  /**\n   * Enables manual grouping. If this option is set to `true`, the table will not automatically group rows using `getGroupedRowModel()` and instead will expect you to manually group the rows before passing them to the table. This is useful if you are doing server-side grouping and aggregation.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#manualgrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  manualGrouping?: boolean\n  /**\n   * If this function is provided, it will be called when the grouping state changes and you will be expected to manage the state yourself. You can pass the managed state back to the table via the `tableOptions.state.grouping` option.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#ongroupingchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  onGroupingChange?: OnChangeFn<GroupingState>\n}\n\ntype ResolvedAggregationFns = keyof AggregationFns extends never\n  ? {\n      aggregationFns?: Record<string, AggregationFn<any>>\n    }\n  : {\n      aggregationFns: Record<keyof AggregationFns, AggregationFn<any>>\n    }\n\nexport interface GroupingOptions\n  extends GroupingOptionsBase,\n    ResolvedAggregationFns {}\n\nexport type GroupingColumnMode = false | 'reorder' | 'remove'\n\nexport interface GroupingInstance<TData extends RowData> {\n  _getGroupedRowModel?: () => RowModel<TData>\n  /**\n   * Returns the row model for the table after grouping has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getgroupedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getGroupedRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model for the table before any grouping has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#getpregroupedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  getPreGroupedRowModel: () => RowModel<TData>\n  /**\n   * Resets the **grouping** state to `initialState.grouping`, or `true` can be passed to force a default blank state reset to `[]`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#resetgrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  resetGrouping: (defaultState?: boolean) => void\n  /**\n   * Updates the grouping state of the table via an update function or value.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/grouping#setgrouping)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/grouping)\n   */\n  setGrouping: (updater: Updater<GroupingState>) => void\n}\n\n//\n\nexport const ColumnGrouping: TableFeature = {\n  getDefaultColumnDef: <TData extends RowData>(): GroupingColumnDef<\n    TData,\n    unknown\n  > => {\n    return {\n      aggregatedCell: props => (props.getValue() as any)?.toString?.() ?? null,\n      aggregationFn: 'auto',\n    }\n  },\n\n  getInitialState: (state): GroupingTableState => {\n    return {\n      grouping: [],\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): GroupingOptions => {\n    return {\n      onGroupingChange: makeStateUpdater('grouping', table),\n      groupedColumnMode: 'reorder',\n    }\n  },\n\n  createColumn: <TData extends RowData, TValue>(\n    column: Column<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    column.toggleGrouping = () => {\n      table.setGrouping(old => {\n        // Find any existing grouping for this column\n        if (old?.includes(column.id)) {\n          return old.filter(d => d !== column.id)\n        }\n\n        return [...(old ?? []), column.id]\n      })\n    }\n\n    column.getCanGroup = () => {\n      return (\n        (column.columnDef.enableGrouping ?? true) &&\n        (table.options.enableGrouping ?? true) &&\n        (!!column.accessorFn || !!column.columnDef.getGroupingValue)\n      )\n    }\n\n    column.getIsGrouped = () => {\n      return table.getState().grouping?.includes(column.id)\n    }\n\n    column.getGroupedIndex = () => table.getState().grouping?.indexOf(column.id)\n\n    column.getToggleGroupingHandler = () => {\n      const canGroup = column.getCanGroup()\n\n      return () => {\n        if (!canGroup) return\n        column.toggleGrouping()\n      }\n    }\n    column.getAutoAggregationFn = () => {\n      const firstRow = table.getCoreRowModel().flatRows[0]\n\n      const value = firstRow?.getValue(column.id)\n\n      if (typeof value === 'number') {\n        return aggregationFns.sum\n      }\n\n      if (Object.prototype.toString.call(value) === '[object Date]') {\n        return aggregationFns.extent\n      }\n    }\n    column.getAggregationFn = () => {\n      if (!column) {\n        throw new Error()\n      }\n\n      return isFunction(column.columnDef.aggregationFn)\n        ? column.columnDef.aggregationFn\n        : column.columnDef.aggregationFn === 'auto'\n          ? column.getAutoAggregationFn()\n          : table.options.aggregationFns?.[\n              column.columnDef.aggregationFn as string\n            ] ??\n            aggregationFns[\n              column.columnDef.aggregationFn as BuiltInAggregationFn\n            ]\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setGrouping = updater => table.options.onGroupingChange?.(updater)\n\n    table.resetGrouping = defaultState => {\n      table.setGrouping(defaultState ? [] : table.initialState?.grouping ?? [])\n    }\n\n    table.getPreGroupedRowModel = () => table.getFilteredRowModel()\n    table.getGroupedRowModel = () => {\n      if (!table._getGroupedRowModel && table.options.getGroupedRowModel) {\n        table._getGroupedRowModel = table.options.getGroupedRowModel(table)\n      }\n\n      if (table.options.manualGrouping || !table._getGroupedRowModel) {\n        return table.getPreGroupedRowModel()\n      }\n\n      return table._getGroupedRowModel()\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row.getIsGrouped = () => !!row.groupingColumnId\n    row.getGroupingValue = columnId => {\n      if (row._groupingValuesCache.hasOwnProperty(columnId)) {\n        return row._groupingValuesCache[columnId]\n      }\n\n      const column = table.getColumn(columnId)\n\n      if (!column?.columnDef.getGroupingValue) {\n        return row.getValue(columnId)\n      }\n\n      row._groupingValuesCache[columnId] = column.columnDef.getGroupingValue(\n        row.original\n      )\n\n      return row._groupingValuesCache[columnId]\n    }\n    row._groupingValuesCache = {}\n  },\n\n  createCell: <TData extends RowData, TValue>(\n    cell: Cell<TData, TValue>,\n    column: Column<TData, TValue>,\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    const getRenderValue = () =>\n      cell.getValue() ?? table.options.renderFallbackValue\n\n    cell.getIsGrouped = () =>\n      column.getIsGrouped() && column.id === row.groupingColumnId\n    cell.getIsPlaceholder = () => !cell.getIsGrouped() && column.getIsGrouped()\n    cell.getIsAggregated = () =>\n      !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!row.subRows?.length\n  },\n}\n\nexport function orderColumns<TData extends RowData>(\n  leafColumns: Column<TData, unknown>[],\n  grouping: string[],\n  groupedColumnMode?: GroupingColumnMode\n) {\n  if (!grouping?.length || !groupedColumnMode) {\n    return leafColumns\n  }\n\n  const nonGroupingColumns = leafColumns.filter(\n    col => !grouping.includes(col.id)\n  )\n\n  if (groupedColumnMode === 'remove') {\n    return nonGroupingColumns\n  }\n\n  const groupingColumns = grouping\n    .map(g => leafColumns.find(col => col.id === g)!)\n    .filter(Boolean)\n\n  return [...groupingColumns, ...nonGroupingColumns]\n}\n","import { getMemoOptions, makeStateUpdater, memo } from '../utils'\n\nimport {\n  Column,\n  OnChangeFn,\n  RowData,\n  Table,\n  TableFeature,\n  Updater,\n} from '../types'\n\nimport { orderColumns } from './ColumnGrouping'\nimport { ColumnPinningPosition, _getVisibleLeafColumns } from '..'\n\nexport interface ColumnOrderTableState {\n  columnOrder: ColumnOrderState\n}\n\nexport type ColumnOrderState = string[]\n\nexport interface ColumnOrderOptions {\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnOrder` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#oncolumnorderchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  onColumnOrderChange?: OnChangeFn<ColumnOrderState>\n}\n\nexport interface ColumnOrderColumn {\n  /**\n   * Returns the index of the column in the order of the visible columns. Optionally pass a `position` parameter to get the index of the column in a sub-section of the table\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#getindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  getIndex: (position?: ColumnPinningPosition | 'center') => number\n  /**\n   * Returns `true` if the column is the first column in the order of the visible columns. Optionally pass a `position` parameter to check if the column is the first in a sub-section of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#getisfirstcolumn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  getIsFirstColumn: (position?: ColumnPinningPosition | 'center') => boolean\n  /**\n   * Returns `true` if the column is the last column in the order of the visible columns. Optionally pass a `position` parameter to check if the column is the last in a sub-section of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#getislastcolumn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  getIsLastColumn: (position?: ColumnPinningPosition | 'center') => boolean\n}\n\nexport interface ColumnOrderDefaultOptions {\n  onColumnOrderChange: OnChangeFn<ColumnOrderState>\n}\n\nexport interface ColumnOrderInstance<TData extends RowData> {\n  _getOrderColumnsFn: () => (\n    columns: Column<TData, unknown>[]\n  ) => Column<TData, unknown>[]\n  /**\n   * Resets the **columnOrder** state to `initialState.columnOrder`, or `true` can be passed to force a default blank state reset to `[]`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#resetcolumnorder)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  resetColumnOrder: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.columnOrder` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-ordering#setcolumnorder)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-ordering)\n   */\n  setColumnOrder: (updater: Updater<ColumnOrderState>) => void\n}\n\n//\n\nexport const ColumnOrdering: TableFeature = {\n  getInitialState: (state): ColumnOrderTableState => {\n    return {\n      columnOrder: [],\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): ColumnOrderDefaultOptions => {\n    return {\n      onColumnOrderChange: makeStateUpdater('columnOrder', table),\n    }\n  },\n\n  createColumn: <TData extends RowData>(\n    column: Column<TData, unknown>,\n    table: Table<TData>\n  ): void => {\n    column.getIndex = memo(\n      position => [_getVisibleLeafColumns(table, position)],\n      columns => columns.findIndex(d => d.id === column.id),\n      getMemoOptions(table.options, 'debugColumns', 'getIndex')\n    )\n    column.getIsFirstColumn = position => {\n      const columns = _getVisibleLeafColumns(table, position)\n      return columns[0]?.id === column.id\n    }\n    column.getIsLastColumn = position => {\n      const columns = _getVisibleLeafColumns(table, position)\n      return columns[columns.length - 1]?.id === column.id\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setColumnOrder = updater =>\n      table.options.onColumnOrderChange?.(updater)\n    table.resetColumnOrder = defaultState => {\n      table.setColumnOrder(\n        defaultState ? [] : table.initialState.columnOrder ?? []\n      )\n    }\n    table._getOrderColumnsFn = memo(\n      () => [\n        table.getState().columnOrder,\n        table.getState().grouping,\n        table.options.groupedColumnMode,\n      ],\n      (columnOrder, grouping, groupedColumnMode) =>\n        (columns: Column<TData, unknown>[]) => {\n          // Sort grouped columns to the start of the column list\n          // before the headers are built\n          let orderedColumns: Column<TData, unknown>[] = []\n\n          // If there is no order, return the normal columns\n          if (!columnOrder?.length) {\n            orderedColumns = columns\n          } else {\n            const columnOrderCopy = [...columnOrder]\n\n            // If there is an order, make a copy of the columns\n            const columnsCopy = [...columns]\n\n            // And make a new ordered array of the columns\n\n            // Loop over the columns and place them in order into the new array\n            while (columnsCopy.length && columnOrderCopy.length) {\n              const targetColumnId = columnOrderCopy.shift()\n              const foundIndex = columnsCopy.findIndex(\n                d => d.id === targetColumnId\n              )\n              if (foundIndex > -1) {\n                orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]!)\n              }\n            }\n\n            // If there are any columns left, add them to the end\n            orderedColumns = [...orderedColumns, ...columnsCopy]\n          }\n\n          return orderColumns(orderedColumns, grouping, groupedColumnMode)\n        },\n      getMemoOptions(table.options, 'debugTable', '_getOrderColumnsFn')\n    )\n  },\n}\n","import {\n  OnChangeFn,\n  Updater,\n  Table,\n  Column,\n  Row,\n  Cell,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, makeStateUpdater, memo } from '../utils'\n\nexport type ColumnPinningPosition = false | 'left' | 'right'\n\nexport interface ColumnPinningState {\n  left?: string[]\n  right?: string[]\n}\n\nexport interface ColumnPinningTableState {\n  columnPinning: ColumnPinningState\n}\n\nexport interface ColumnPinningOptions {\n  /**\n   * Enables/disables column pinning for the table. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablecolumnpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  enableColumnPinning?: boolean\n  /**\n   * @deprecated Use `enableColumnPinning` or `enableRowPinning` instead.\n   * Enables/disables all pinning for the table. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablepinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  enablePinning?: boolean\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnPinning` changes. This overrides the default internal state management, so you will also need to supply `state.columnPinning` from your own managed state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#oncolumnpinningchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/oncolumnpinningchange)\n   */\n  onColumnPinningChange?: OnChangeFn<ColumnPinningState>\n}\n\nexport interface ColumnPinningDefaultOptions {\n  onColumnPinningChange: OnChangeFn<ColumnPinningState>\n}\n\nexport interface ColumnPinningColumnDef {\n  /**\n   * Enables/disables column pinning for this column. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#enablepinning-1)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  enablePinning?: boolean\n}\n\nexport interface ColumnPinningColumn {\n  /**\n   * Returns whether or not the column can be pinned.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcanpin)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getCanPin: () => boolean\n  /**\n   * Returns the pinned position of the column. (`'left'`, `'right'` or `false`)\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getispinned)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getIsPinned: () => ColumnPinningPosition\n  /**\n   * Returns the numeric pinned index of the column within a pinned column group.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getpinnedindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getPinnedIndex: () => number\n  /**\n   * Pins a column to the `'left'` or `'right'`, or unpins the column to the center if `false` is passed.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#pin)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  pin: (position: ColumnPinningPosition) => void\n}\n\nexport interface ColumnPinningRow<TData extends RowData> {\n  /**\n   * Returns all center pinned (unpinned) leaf cells in the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcentervisiblecells)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getCenterVisibleCells: () => Cell<TData, unknown>[]\n  /**\n   * Returns all left pinned leaf cells in the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getleftvisiblecells)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getLeftVisibleCells: () => Cell<TData, unknown>[]\n  /**\n   * Returns all right pinned leaf cells in the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getrightvisiblecells)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getRightVisibleCells: () => Cell<TData, unknown>[]\n}\n\nexport interface ColumnPinningInstance<TData extends RowData> {\n  /**\n   * Returns all center pinned (unpinned) leaf columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getcenterleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getCenterLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns whether or not any columns are pinned. Optionally specify to only check for pinned columns in either the `left` or `right` position.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getissomecolumnspinned)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getIsSomeColumnsPinned: (position?: ColumnPinningPosition) => boolean\n  /**\n   * Returns all left pinned leaf columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getleftleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getLeftLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns all right pinned leaf columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#getrightleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  getRightLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Resets the **columnPinning** state to `initialState.columnPinning`, or `true` can be passed to force a default blank state reset to `{ left: [], right: [], }`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#resetcolumnpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  resetColumnPinning: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.columnPinning` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-pinning#setcolumnpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-pinning)\n   */\n  setColumnPinning: (updater: Updater<ColumnPinningState>) => void\n}\n\n//\n\nconst getDefaultColumnPinningState = (): ColumnPinningState => ({\n  left: [],\n  right: [],\n})\n\nexport const ColumnPinning: TableFeature = {\n  getInitialState: (state): ColumnPinningTableState => {\n    return {\n      columnPinning: getDefaultColumnPinningState(),\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): ColumnPinningDefaultOptions => {\n    return {\n      onColumnPinningChange: makeStateUpdater('columnPinning', table),\n    }\n  },\n\n  createColumn: <TData extends RowData, TValue>(\n    column: Column<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    column.pin = position => {\n      const columnIds = column\n        .getLeafColumns()\n        .map(d => d.id)\n        .filter(Boolean) as string[]\n\n      table.setColumnPinning(old => {\n        if (position === 'right') {\n          return {\n            left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),\n            right: [\n              ...(old?.right ?? []).filter(d => !columnIds?.includes(d)),\n              ...columnIds,\n            ],\n          }\n        }\n\n        if (position === 'left') {\n          return {\n            left: [\n              ...(old?.left ?? []).filter(d => !columnIds?.includes(d)),\n              ...columnIds,\n            ],\n            right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),\n          }\n        }\n\n        return {\n          left: (old?.left ?? []).filter(d => !columnIds?.includes(d)),\n          right: (old?.right ?? []).filter(d => !columnIds?.includes(d)),\n        }\n      })\n    }\n\n    column.getCanPin = () => {\n      const leafColumns = column.getLeafColumns()\n\n      return leafColumns.some(\n        d =>\n          (d.columnDef.enablePinning ?? true) &&\n          (table.options.enableColumnPinning ??\n            table.options.enablePinning ??\n            true)\n      )\n    }\n\n    column.getIsPinned = () => {\n      const leafColumnIds = column.getLeafColumns().map(d => d.id)\n\n      const { left, right } = table.getState().columnPinning\n\n      const isLeft = leafColumnIds.some(d => left?.includes(d))\n      const isRight = leafColumnIds.some(d => right?.includes(d))\n\n      return isLeft ? 'left' : isRight ? 'right' : false\n    }\n\n    column.getPinnedIndex = () => {\n      const position = column.getIsPinned()\n\n      return position\n        ? table.getState().columnPinning?.[position]?.indexOf(column.id) ?? -1\n        : 0\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row.getCenterVisibleCells = memo(\n      () => [\n        row._getAllVisibleCells(),\n        table.getState().columnPinning.left,\n        table.getState().columnPinning.right,\n      ],\n      (allCells, left, right) => {\n        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]\n\n        return allCells.filter(d => !leftAndRight.includes(d.column.id))\n      },\n      getMemoOptions(table.options, 'debugRows', 'getCenterVisibleCells')\n    )\n    row.getLeftVisibleCells = memo(\n      () => [row._getAllVisibleCells(), table.getState().columnPinning.left],\n      (allCells, left) => {\n        const cells = (left ?? [])\n          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)\n          .filter(Boolean)\n          .map(d => ({ ...d, position: 'left' }) as Cell<TData, unknown>)\n\n        return cells\n      },\n      getMemoOptions(table.options, 'debugRows', 'getLeftVisibleCells')\n    )\n    row.getRightVisibleCells = memo(\n      () => [row._getAllVisibleCells(), table.getState().columnPinning.right],\n      (allCells, right) => {\n        const cells = (right ?? [])\n          .map(columnId => allCells.find(cell => cell.column.id === columnId)!)\n          .filter(Boolean)\n          .map(d => ({ ...d, position: 'right' }) as Cell<TData, unknown>)\n\n        return cells\n      },\n      getMemoOptions(table.options, 'debugRows', 'getRightVisibleCells')\n    )\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setColumnPinning = updater =>\n      table.options.onColumnPinningChange?.(updater)\n\n    table.resetColumnPinning = defaultState =>\n      table.setColumnPinning(\n        defaultState\n          ? getDefaultColumnPinningState()\n          : table.initialState?.columnPinning ?? getDefaultColumnPinningState()\n      )\n\n    table.getIsSomeColumnsPinned = position => {\n      const pinningState = table.getState().columnPinning\n\n      if (!position) {\n        return Boolean(pinningState.left?.length || pinningState.right?.length)\n      }\n      return Boolean(pinningState[position]?.length)\n    }\n\n    table.getLeftLeafColumns = memo(\n      () => [table.getAllLeafColumns(), table.getState().columnPinning.left],\n      (allColumns, left) => {\n        return (left ?? [])\n          .map(columnId => allColumns.find(column => column.id === columnId)!)\n          .filter(Boolean)\n      },\n      getMemoOptions(table.options, 'debugColumns', 'getLeftLeafColumns')\n    )\n\n    table.getRightLeafColumns = memo(\n      () => [table.getAllLeafColumns(), table.getState().columnPinning.right],\n      (allColumns, right) => {\n        return (right ?? [])\n          .map(columnId => allColumns.find(column => column.id === columnId)!)\n          .filter(Boolean)\n      },\n      getMemoOptions(table.options, 'debugColumns', 'getRightLeafColumns')\n    )\n\n    table.getCenterLeafColumns = memo(\n      () => [\n        table.getAllLeafColumns(),\n        table.getState().columnPinning.left,\n        table.getState().columnPinning.right,\n      ],\n      (allColumns, left, right) => {\n        const leftAndRight: string[] = [...(left ?? []), ...(right ?? [])]\n\n        return allColumns.filter(d => !leftAndRight.includes(d.id))\n      },\n      getMemoOptions(table.options, 'debugColumns', 'getCenterLeafColumns')\n    )\n  },\n}\n","import { _getVisibleLeafColumns } from '..'\nimport {\n  RowData,\n  Column,\n  Header,\n  OnChangeFn,\n  Table,\n  Updater,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, makeStateUpdater, memo } from '../utils'\nimport { ColumnPinningPosition } from './ColumnPinning'\n\n//\n\nexport interface ColumnSizingTableState {\n  columnSizing: ColumnSizingState\n  columnSizingInfo: ColumnSizingInfoState\n}\n\nexport type ColumnSizingState = Record<string, number>\n\nexport interface ColumnSizingInfoState {\n  columnSizingStart: [string, number][]\n  deltaOffset: null | number\n  deltaPercentage: null | number\n  isResizingColumn: false | string\n  startOffset: null | number\n  startSize: null | number\n}\n\nexport type ColumnResizeMode = 'onChange' | 'onEnd'\n\nexport type ColumnResizeDirection = 'ltr' | 'rtl'\n\nexport interface ColumnSizingOptions {\n  /**\n   * Determines when the columnSizing state is updated. `onChange` updates the state when the user is dragging the resize handle. `onEnd` updates the state when the user releases the resize handle.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#columnresizemode)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  columnResizeMode?: ColumnResizeMode\n  /**\n   * Enables or disables column resizing for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#enablecolumnresizing)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  enableColumnResizing?: boolean\n  /**\n   * Enables or disables right-to-left support for resizing the column. defaults to 'ltr'.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#columnResizeDirection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  columnResizeDirection?: ColumnResizeDirection\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnSizing` changes. This overrides the default internal state management, so you will also need to supply `state.columnSizing` from your own managed state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#oncolumnsizingchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  onColumnSizingChange?: OnChangeFn<ColumnSizingState>\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnSizingInfo` changes. This overrides the default internal state management, so you will also need to supply `state.columnSizingInfo` from your own managed state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#oncolumnsizinginfochange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  onColumnSizingInfoChange?: OnChangeFn<ColumnSizingInfoState>\n}\n\nexport type ColumnSizingDefaultOptions = Pick<\n  ColumnSizingOptions,\n  | 'columnResizeMode'\n  | 'onColumnSizingChange'\n  | 'onColumnSizingInfoChange'\n  | 'columnResizeDirection'\n>\n\nexport interface ColumnSizingInstance {\n  /**\n   * If pinning, returns the total size of the center portion of the table by calculating the sum of the sizes of all unpinned/center leaf-columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getcentertotalsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getCenterTotalSize: () => number\n  /**\n   * Returns the total size of the left portion of the table by calculating the sum of the sizes of all left leaf-columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getlefttotalsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getLeftTotalSize: () => number\n  /**\n   * Returns the total size of the right portion of the table by calculating the sum of the sizes of all right leaf-columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getrighttotalsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getRightTotalSize: () => number\n  /**\n   * Returns the total size of the table by calculating the sum of the sizes of all leaf-columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#gettotalsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getTotalSize: () => number\n  /**\n   * Resets column sizing to its initial state. If `defaultState` is `true`, the default state for the table will be used instead of the initialValue provided to the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#resetcolumnsizing)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  resetColumnSizing: (defaultState?: boolean) => void\n  /**\n   * Resets column sizing info to its initial state. If `defaultState` is `true`, the default state for the table will be used instead of the initialValue provided to the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#resetheadersizeinfo)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  resetHeaderSizeInfo: (defaultState?: boolean) => void\n  /**\n   * Sets the column sizing state using an updater function or a value. This will trigger the underlying `onColumnSizingChange` function if one is passed to the table options, otherwise the state will be managed automatically by the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#setcolumnsizing)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  setColumnSizing: (updater: Updater<ColumnSizingState>) => void\n  /**\n   * Sets the column sizing info state using an updater function or a value. This will trigger the underlying `onColumnSizingInfoChange` function if one is passed to the table options, otherwise the state will be managed automatically by the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#setcolumnsizinginfo)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  setColumnSizingInfo: (updater: Updater<ColumnSizingInfoState>) => void\n}\n\nexport interface ColumnSizingColumnDef {\n  /**\n   * Enables or disables column resizing for the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#enableresizing)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  enableResizing?: boolean\n  /**\n   * The maximum allowed size for the column\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#maxsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  maxSize?: number\n  /**\n   * The minimum allowed size for the column\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#minsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  minSize?: number\n  /**\n   * The desired size for the column\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#size)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  size?: number\n}\n\nexport interface ColumnSizingColumn {\n  /**\n   * Returns `true` if the column can be resized.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getcanresize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getCanResize: () => boolean\n  /**\n   * Returns `true` if the column is currently being resized.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getisresizing)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getIsResizing: () => boolean\n  /**\n   * Returns the current size of the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getSize: () => number\n  /**\n   * Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all preceding (left) headers in relation to the current column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getstart)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getStart: (position?: ColumnPinningPosition | 'center') => number\n  /**\n   * Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all succeeding (right) headers in relation to the current column.\n   */\n  getAfter: (position?: ColumnPinningPosition | 'center') => number\n  /**\n   * Resets the column to its initial size.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#resetsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  resetSize: () => void\n}\n\nexport interface ColumnSizingHeader {\n  /**\n   * Returns an event handler function that can be used to resize the header. It can be used as an:\n   * - `onMouseDown` handler\n   * - `onTouchStart` handler\n   *\n   * The dragging and release events are automatically handled for you.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getresizehandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getResizeHandler: (context?: Document) => (event: unknown) => void\n  /**\n   * Returns the current size of the header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getsize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getSize: () => number\n  /**\n   * Returns the offset measurement along the row-axis (usually the x-axis for standard tables) for the header. This is effectively a sum of the offset measurements of all preceding headers.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-sizing#getstart)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-sizing)\n   */\n  getStart: (position?: ColumnPinningPosition) => number\n}\n\n//\n\nexport const defaultColumnSizing = {\n  size: 150,\n  minSize: 20,\n  maxSize: Number.MAX_SAFE_INTEGER,\n}\n\nconst getDefaultColumnSizingInfoState = (): ColumnSizingInfoState => ({\n  startOffset: null,\n  startSize: null,\n  deltaOffset: null,\n  deltaPercentage: null,\n  isResizingColumn: false,\n  columnSizingStart: [],\n})\n\nexport const ColumnSizing: TableFeature = {\n  getDefaultColumnDef: (): ColumnSizingColumnDef => {\n    return defaultColumnSizing\n  },\n  getInitialState: (state): ColumnSizingTableState => {\n    return {\n      columnSizing: {},\n      columnSizingInfo: getDefaultColumnSizingInfoState(),\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): ColumnSizingDefaultOptions => {\n    return {\n      columnResizeMode: 'onEnd',\n      columnResizeDirection: 'ltr',\n      onColumnSizingChange: makeStateUpdater('columnSizing', table),\n      onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table),\n    }\n  },\n\n  createColumn: <TData extends RowData, TValue>(\n    column: Column<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    column.getSize = () => {\n      const columnSize = table.getState().columnSizing[column.id]\n\n      return Math.min(\n        Math.max(\n          column.columnDef.minSize ?? defaultColumnSizing.minSize,\n          columnSize ?? column.columnDef.size ?? defaultColumnSizing.size\n        ),\n        column.columnDef.maxSize ?? defaultColumnSizing.maxSize\n      )\n    }\n\n    column.getStart = memo(\n      position => [\n        position,\n        _getVisibleLeafColumns(table, position),\n        table.getState().columnSizing,\n      ],\n      (position, columns) =>\n        columns\n          .slice(0, column.getIndex(position))\n          .reduce((sum, column) => sum + column.getSize(), 0),\n      getMemoOptions(table.options, 'debugColumns', 'getStart')\n    )\n\n    column.getAfter = memo(\n      position => [\n        position,\n        _getVisibleLeafColumns(table, position),\n        table.getState().columnSizing,\n      ],\n      (position, columns) =>\n        columns\n          .slice(column.getIndex(position) + 1)\n          .reduce((sum, column) => sum + column.getSize(), 0),\n      getMemoOptions(table.options, 'debugColumns', 'getAfter')\n    )\n\n    column.resetSize = () => {\n      table.setColumnSizing(({ [column.id]: _, ...rest }) => {\n        return rest\n      })\n    }\n    column.getCanResize = () => {\n      return (\n        (column.columnDef.enableResizing ?? true) &&\n        (table.options.enableColumnResizing ?? true)\n      )\n    }\n    column.getIsResizing = () => {\n      return table.getState().columnSizingInfo.isResizingColumn === column.id\n    }\n  },\n\n  createHeader: <TData extends RowData, TValue>(\n    header: Header<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    header.getSize = () => {\n      let sum = 0\n\n      const recurse = (header: Header<TData, TValue>) => {\n        if (header.subHeaders.length) {\n          header.subHeaders.forEach(recurse)\n        } else {\n          sum += header.column.getSize() ?? 0\n        }\n      }\n\n      recurse(header)\n\n      return sum\n    }\n    header.getStart = () => {\n      if (header.index > 0) {\n        const prevSiblingHeader = header.headerGroup.headers[header.index - 1]!\n        return prevSiblingHeader.getStart() + prevSiblingHeader.getSize()\n      }\n\n      return 0\n    }\n    header.getResizeHandler = _contextDocument => {\n      const column = table.getColumn(header.column.id)\n      const canResize = column?.getCanResize()\n\n      return (e: unknown) => {\n        if (!column || !canResize) {\n          return\n        }\n\n        ;(e as any).persist?.()\n\n        if (isTouchStartEvent(e)) {\n          // lets not respond to multiple touches (e.g. 2 or 3 fingers)\n          if (e.touches && e.touches.length > 1) {\n            return\n          }\n        }\n\n        const startSize = header.getSize()\n\n        const columnSizingStart: [string, number][] = header\n          ? header.getLeafHeaders().map(d => [d.column.id, d.column.getSize()])\n          : [[column.id, column.getSize()]]\n\n        const clientX = isTouchStartEvent(e)\n          ? Math.round(e.touches[0]!.clientX)\n          : (e as MouseEvent).clientX\n\n        const newColumnSizing: ColumnSizingState = {}\n\n        const updateOffset = (\n          eventType: 'move' | 'end',\n          clientXPos?: number\n        ) => {\n          if (typeof clientXPos !== 'number') {\n            return\n          }\n\n          table.setColumnSizingInfo(old => {\n            const deltaDirection =\n              table.options.columnResizeDirection === 'rtl' ? -1 : 1\n            const deltaOffset =\n              (clientXPos - (old?.startOffset ?? 0)) * deltaDirection\n            const deltaPercentage = Math.max(\n              deltaOffset / (old?.startSize ?? 0),\n              -0.999999\n            )\n\n            old.columnSizingStart.forEach(([columnId, headerSize]) => {\n              newColumnSizing[columnId] =\n                Math.round(\n                  Math.max(headerSize + headerSize * deltaPercentage, 0) * 100\n                ) / 100\n            })\n\n            return {\n              ...old,\n              deltaOffset,\n              deltaPercentage,\n            }\n          })\n\n          if (\n            table.options.columnResizeMode === 'onChange' ||\n            eventType === 'end'\n          ) {\n            table.setColumnSizing(old => ({\n              ...old,\n              ...newColumnSizing,\n            }))\n          }\n        }\n\n        const onMove = (clientXPos?: number) => updateOffset('move', clientXPos)\n\n        const onEnd = (clientXPos?: number) => {\n          updateOffset('end', clientXPos)\n\n          table.setColumnSizingInfo(old => ({\n            ...old,\n            isResizingColumn: false,\n            startOffset: null,\n            startSize: null,\n            deltaOffset: null,\n            deltaPercentage: null,\n            columnSizingStart: [],\n          }))\n        }\n\n        const contextDocument =\n          _contextDocument || typeof document !== 'undefined' ? document : null\n\n        const mouseEvents = {\n          moveHandler: (e: MouseEvent) => onMove(e.clientX),\n          upHandler: (e: MouseEvent) => {\n            contextDocument?.removeEventListener(\n              'mousemove',\n              mouseEvents.moveHandler\n            )\n            contextDocument?.removeEventListener(\n              'mouseup',\n              mouseEvents.upHandler\n            )\n            onEnd(e.clientX)\n          },\n        }\n\n        const touchEvents = {\n          moveHandler: (e: TouchEvent) => {\n            if (e.cancelable) {\n              e.preventDefault()\n              e.stopPropagation()\n            }\n            onMove(e.touches[0]!.clientX)\n            return false\n          },\n          upHandler: (e: TouchEvent) => {\n            contextDocument?.removeEventListener(\n              'touchmove',\n              touchEvents.moveHandler\n            )\n            contextDocument?.removeEventListener(\n              'touchend',\n              touchEvents.upHandler\n            )\n            if (e.cancelable) {\n              e.preventDefault()\n              e.stopPropagation()\n            }\n            onEnd(e.touches[0]?.clientX)\n          },\n        }\n\n        const passiveIfSupported = passiveEventSupported()\n          ? { passive: false }\n          : false\n\n        if (isTouchStartEvent(e)) {\n          contextDocument?.addEventListener(\n            'touchmove',\n            touchEvents.moveHandler,\n            passiveIfSupported\n          )\n          contextDocument?.addEventListener(\n            'touchend',\n            touchEvents.upHandler,\n            passiveIfSupported\n          )\n        } else {\n          contextDocument?.addEventListener(\n            'mousemove',\n            mouseEvents.moveHandler,\n            passiveIfSupported\n          )\n          contextDocument?.addEventListener(\n            'mouseup',\n            mouseEvents.upHandler,\n            passiveIfSupported\n          )\n        }\n\n        table.setColumnSizingInfo(old => ({\n          ...old,\n          startOffset: clientX,\n          startSize,\n          deltaOffset: 0,\n          deltaPercentage: 0,\n          columnSizingStart,\n          isResizingColumn: column.id,\n        }))\n      }\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setColumnSizing = updater =>\n      table.options.onColumnSizingChange?.(updater)\n    table.setColumnSizingInfo = updater =>\n      table.options.onColumnSizingInfoChange?.(updater)\n    table.resetColumnSizing = defaultState => {\n      table.setColumnSizing(\n        defaultState ? {} : table.initialState.columnSizing ?? {}\n      )\n    }\n    table.resetHeaderSizeInfo = defaultState => {\n      table.setColumnSizingInfo(\n        defaultState\n          ? getDefaultColumnSizingInfoState()\n          : table.initialState.columnSizingInfo ??\n              getDefaultColumnSizingInfoState()\n      )\n    }\n    table.getTotalSize = () =>\n      table.getHeaderGroups()[0]?.headers.reduce((sum, header) => {\n        return sum + header.getSize()\n      }, 0) ?? 0\n    table.getLeftTotalSize = () =>\n      table.getLeftHeaderGroups()[0]?.headers.reduce((sum, header) => {\n        return sum + header.getSize()\n      }, 0) ?? 0\n    table.getCenterTotalSize = () =>\n      table.getCenterHeaderGroups()[0]?.headers.reduce((sum, header) => {\n        return sum + header.getSize()\n      }, 0) ?? 0\n    table.getRightTotalSize = () =>\n      table.getRightHeaderGroups()[0]?.headers.reduce((sum, header) => {\n        return sum + header.getSize()\n      }, 0) ?? 0\n  },\n}\n\nlet passiveSupported: boolean | null = null\nexport function passiveEventSupported() {\n  if (typeof passiveSupported === 'boolean') return passiveSupported\n\n  let supported = false\n  try {\n    const options = {\n      get passive() {\n        supported = true\n        return false\n      },\n    }\n\n    const noop = () => {}\n\n    window.addEventListener('test', noop, options)\n    window.removeEventListener('test', noop)\n  } catch (err) {\n    supported = false\n  }\n  passiveSupported = supported\n  return passiveSupported\n}\n\nfunction isTouchStartEvent(e: unknown): e is TouchEvent {\n  return (e as TouchEvent).type === 'touchstart'\n}\n","import { ColumnPinningPosition } from '..'\nimport {\n  Cell,\n  Column,\n  OnChangeFn,\n  Table,\n  Updater,\n  Row,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, makeStateUpdater, memo } from '../utils'\n\nexport type VisibilityState = Record<string, boolean>\n\nexport interface VisibilityTableState {\n  columnVisibility: VisibilityState\n}\n\nexport interface VisibilityOptions {\n  /**\n   * Whether to enable column hiding. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#enablehiding)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  enableHiding?: boolean\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.columnVisibility` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#oncolumnvisibilitychange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  onColumnVisibilityChange?: OnChangeFn<VisibilityState>\n}\n\nexport type VisibilityDefaultOptions = Pick<\n  VisibilityOptions,\n  'onColumnVisibilityChange'\n>\n\nexport interface VisibilityInstance<TData extends RowData> {\n  /**\n   * If column pinning, returns a flat array of leaf-node columns that are visible in the unpinned/center portion of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getcentervisibleleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getCenterVisibleLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns whether all columns are visible\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getisallcolumnsvisible)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getIsAllColumnsVisible: () => boolean\n  /**\n   * Returns whether any columns are visible\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getissomecolumnsvisible)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getIsSomeColumnsVisible: () => boolean\n  /**\n   * If column pinning, returns a flat array of leaf-node columns that are visible in the left portion of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getleftvisibleleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getLeftVisibleLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * If column pinning, returns a flat array of leaf-node columns that are visible in the right portion of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getrightvisibleleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getRightVisibleLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns a handler for toggling the visibility of all columns, meant to be bound to a `input[type=checkbox]` element.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#gettoggleallcolumnsvisibilityhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getToggleAllColumnsVisibilityHandler: () => (event: unknown) => void\n  /**\n   * Returns a flat array of columns that are visible, including parent columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getvisibleflatcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getVisibleFlatColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns a flat array of leaf-node columns that are visible.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getvisibleleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getVisibleLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Resets the column visibility state to the initial state. If `defaultState` is provided, the state will be reset to `{}`\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#resetcolumnvisibility)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  resetColumnVisibility: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.columnVisibility` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#setcolumnvisibility)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  setColumnVisibility: (updater: Updater<VisibilityState>) => void\n  /**\n   * Toggles the visibility of all columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#toggleallcolumnsvisible)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  toggleAllColumnsVisible: (value?: boolean) => void\n}\n\nexport interface VisibilityColumnDef {\n  enableHiding?: boolean\n}\n\nexport interface VisibilityRow<TData extends RowData> {\n  _getAllVisibleCells: () => Cell<TData, unknown>[]\n  /**\n   * Returns an array of cells that account for column visibility for the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getvisiblecells)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getVisibleCells: () => Cell<TData, unknown>[]\n}\n\nexport interface VisibilityColumn {\n  /**\n   * Returns whether the column can be hidden\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getcanhide)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getCanHide: () => boolean\n  /**\n   * Returns whether the column is visible\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#getisvisible)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getIsVisible: () => boolean\n  /**\n   * Returns a function that can be used to toggle the column visibility. This function can be used to bind to an event handler to a checkbox.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#gettogglevisibilityhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  getToggleVisibilityHandler: () => (event: unknown) => void\n  /**\n   * Toggles the visibility of the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/column-visibility#togglevisibility)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-visibility)\n   */\n  toggleVisibility: (value?: boolean) => void\n}\n\n//\n\nexport const ColumnVisibility: TableFeature = {\n  getInitialState: (state): VisibilityTableState => {\n    return {\n      columnVisibility: {},\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): VisibilityDefaultOptions => {\n    return {\n      onColumnVisibilityChange: makeStateUpdater('columnVisibility', table),\n    }\n  },\n\n  createColumn: <TData extends RowData, TValue>(\n    column: Column<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    column.toggleVisibility = value => {\n      if (column.getCanHide()) {\n        table.setColumnVisibility(old => ({\n          ...old,\n          [column.id]: value ?? !column.getIsVisible(),\n        }))\n      }\n    }\n    column.getIsVisible = () => {\n      const childColumns = column.columns\n      return (\n        (childColumns.length\n          ? childColumns.some(c => c.getIsVisible())\n          : table.getState().columnVisibility?.[column.id]) ?? true\n      )\n    }\n\n    column.getCanHide = () => {\n      return (\n        (column.columnDef.enableHiding ?? true) &&\n        (table.options.enableHiding ?? true)\n      )\n    }\n    column.getToggleVisibilityHandler = () => {\n      return (e: unknown) => {\n        column.toggleVisibility?.(\n          ((e as MouseEvent).target as HTMLInputElement).checked\n        )\n      }\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row._getAllVisibleCells = memo(\n      () => [row.getAllCells(), table.getState().columnVisibility],\n      cells => {\n        return cells.filter(cell => cell.column.getIsVisible())\n      },\n      getMemoOptions(table.options, 'debugRows', '_getAllVisibleCells')\n    )\n    row.getVisibleCells = memo(\n      () => [\n        row.getLeftVisibleCells(),\n        row.getCenterVisibleCells(),\n        row.getRightVisibleCells(),\n      ],\n      (left, center, right) => [...left, ...center, ...right],\n      getMemoOptions(table.options, 'debugRows', 'getVisibleCells')\n    )\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    const makeVisibleColumnsMethod = (\n      key: string,\n      getColumns: () => Column<TData, unknown>[]\n    ): (() => Column<TData, unknown>[]) => {\n      return memo(\n        () => [\n          getColumns(),\n          getColumns()\n            .filter(d => d.getIsVisible())\n            .map(d => d.id)\n            .join('_'),\n        ],\n        columns => {\n          return columns.filter(d => d.getIsVisible?.())\n        },\n        getMemoOptions(table.options, 'debugColumns', key)\n      )\n    }\n\n    table.getVisibleFlatColumns = makeVisibleColumnsMethod(\n      'getVisibleFlatColumns',\n      () => table.getAllFlatColumns()\n    )\n    table.getVisibleLeafColumns = makeVisibleColumnsMethod(\n      'getVisibleLeafColumns',\n      () => table.getAllLeafColumns()\n    )\n    table.getLeftVisibleLeafColumns = makeVisibleColumnsMethod(\n      'getLeftVisibleLeafColumns',\n      () => table.getLeftLeafColumns()\n    )\n    table.getRightVisibleLeafColumns = makeVisibleColumnsMethod(\n      'getRightVisibleLeafColumns',\n      () => table.getRightLeafColumns()\n    )\n    table.getCenterVisibleLeafColumns = makeVisibleColumnsMethod(\n      'getCenterVisibleLeafColumns',\n      () => table.getCenterLeafColumns()\n    )\n\n    table.setColumnVisibility = updater =>\n      table.options.onColumnVisibilityChange?.(updater)\n\n    table.resetColumnVisibility = defaultState => {\n      table.setColumnVisibility(\n        defaultState ? {} : table.initialState.columnVisibility ?? {}\n      )\n    }\n\n    table.toggleAllColumnsVisible = value => {\n      value = value ?? !table.getIsAllColumnsVisible()\n\n      table.setColumnVisibility(\n        table.getAllLeafColumns().reduce(\n          (obj, column) => ({\n            ...obj,\n            [column.id]: !value ? !column.getCanHide?.() : value,\n          }),\n          {}\n        )\n      )\n    }\n\n    table.getIsAllColumnsVisible = () =>\n      !table.getAllLeafColumns().some(column => !column.getIsVisible?.())\n\n    table.getIsSomeColumnsVisible = () =>\n      table.getAllLeafColumns().some(column => column.getIsVisible?.())\n\n    table.getToggleAllColumnsVisibilityHandler = () => {\n      return (e: unknown) => {\n        table.toggleAllColumnsVisible(\n          ((e as MouseEvent).target as HTMLInputElement)?.checked\n        )\n      }\n    }\n  },\n}\n\nexport function _getVisibleLeafColumns<TData extends RowData>(\n  table: Table<TData>,\n  position?: ColumnPinningPosition | 'center'\n) {\n  return !position\n    ? table.getVisibleLeafColumns()\n    : position === 'center'\n      ? table.getCenterVisibleLeafColumns()\n      : position === 'left'\n        ? table.getLeftVisibleLeafColumns()\n        : table.getRightVisibleLeafColumns()\n}\n","import { RowModel } from '..'\nimport { Table, RowData, TableFeature } from '../types'\n\nexport interface GlobalFacetingInstance<TData extends RowData> {\n  _getGlobalFacetedMinMaxValues?: () => undefined | [number, number]\n  _getGlobalFacetedRowModel?: () => RowModel<TData>\n  _getGlobalFacetedUniqueValues?: () => Map<any, number>\n  /**\n   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalautofilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)\n   */\n  getGlobalFacetedMinMaxValues: () => undefined | [number, number]\n  /**\n   * Returns the row model for the table after **global** filtering has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalfacetedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)\n   */\n  getGlobalFacetedRowModel: () => RowModel<TData>\n  /**\n   * Returns the faceted unique values for the global filter.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-faceting#getglobalfaceteduniquevalues)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-faceting)\n   */\n  getGlobalFacetedUniqueValues: () => Map<any, number>\n}\n\n//\n\nexport const GlobalFaceting: TableFeature = {\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table._getGlobalFacetedRowModel =\n      table.options.getFacetedRowModel &&\n      table.options.getFacetedRowModel(table, '__global__')\n\n    table.getGlobalFacetedRowModel = () => {\n      if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) {\n        return table.getPreFilteredRowModel()\n      }\n\n      return table._getGlobalFacetedRowModel()\n    }\n\n    table._getGlobalFacetedUniqueValues =\n      table.options.getFacetedUniqueValues &&\n      table.options.getFacetedUniqueValues(table, '__global__')\n    table.getGlobalFacetedUniqueValues = () => {\n      if (!table._getGlobalFacetedUniqueValues) {\n        return new Map()\n      }\n\n      return table._getGlobalFacetedUniqueValues()\n    }\n\n    table._getGlobalFacetedMinMaxValues =\n      table.options.getFacetedMinMaxValues &&\n      table.options.getFacetedMinMaxValues(table, '__global__')\n    table.getGlobalFacetedMinMaxValues = () => {\n      if (!table._getGlobalFacetedMinMaxValues) {\n        return\n      }\n\n      return table._getGlobalFacetedMinMaxValues()\n    }\n  },\n}\n","import {\n  OnChangeFn,\n  Table,\n  Row,\n  RowModel,\n  Updater,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, makeStateUpdater, memo } from '../utils'\n\nexport type RowSelectionState = Record<string, boolean>\n\nexport interface RowSelectionTableState {\n  rowSelection: RowSelectionState\n}\n\nexport interface RowSelectionOptions<TData extends RowData> {\n  /**\n   * - Enables/disables multiple row selection for all rows in the table OR\n   * - A function that given a row, returns whether to enable/disable multiple row selection for that row's children/grandchildren\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#enablemultirowselection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  enableMultiRowSelection?: boolean | ((row: Row<TData>) => boolean)\n  /**\n   * - Enables/disables row selection for all rows in the table OR\n   * - A function that given a row, returns whether to enable/disable row selection for that row\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#enablerowselection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  enableRowSelection?: boolean | ((row: Row<TData>) => boolean)\n  /**\n   * Enables/disables automatic sub-row selection when a parent row is selected, or a function that enables/disables automatic sub-row selection for each row.\n   * (Use in combination with expanding or grouping features)\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#enablesubrowselection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  enableSubRowSelection?: boolean | ((row: Row<TData>) => boolean)\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.rowSelection` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#onrowselectionchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  onRowSelectionChange?: OnChangeFn<RowSelectionState>\n  // enableGroupingRowSelection?:\n  //   | boolean\n  //   | ((\n  //       row: Row<TData>\n  //     ) => boolean)\n  // isAdditiveSelectEvent?: (e: unknown) => boolean\n  // isInclusiveSelectEvent?: (e: unknown) => boolean\n  // selectRowsFn?: (\n  //   table: Table<TData>,\n  //   rowModel: RowModel<TData>\n  // ) => RowModel<TData>\n}\n\nexport interface RowSelectionRow {\n  /**\n   * Returns whether or not the row can multi-select.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getcanmultiselect)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getCanMultiSelect: () => boolean\n  /**\n   * Returns whether or not the row can be selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getcanselect)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getCanSelect: () => boolean\n  /**\n   * Returns whether or not the row can select sub rows automatically when the parent row is selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getcanselectsubrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getCanSelectSubRows: () => boolean\n  /**\n   * Returns whether or not all of the row's sub rows are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getisallsubrowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsAllSubRowsSelected: () => boolean\n  /**\n   * Returns whether or not the row is selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getisselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsSelected: () => boolean\n  /**\n   * Returns whether or not some of the row's sub rows are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getissomeselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsSomeSelected: () => boolean\n  /**\n   * Returns a handler that can be used to toggle the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#gettoggleselectedhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getToggleSelectedHandler: () => (event: unknown) => void\n  /**\n   * Selects/deselects the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#toggleselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  toggleSelected: (value?: boolean, opts?: { selectChildren?: boolean }) => void\n}\n\nexport interface RowSelectionInstance<TData extends RowData> {\n  /**\n   * Returns the row model of all rows that are selected after filtering has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getfilteredselectedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getFilteredSelectedRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model of all rows that are selected after grouping has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getgroupedselectedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getGroupedSelectedRowModel: () => RowModel<TData>\n  /**\n   * Returns whether or not all rows on the current page are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getisallpagerowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsAllPageRowsSelected: () => boolean\n  /**\n   * Returns whether or not all rows in the table are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getisallrowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsAllRowsSelected: () => boolean\n  /**\n   * Returns whether or not any rows on the current page are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getissomepagerowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsSomePageRowsSelected: () => boolean\n  /**\n   * Returns whether or not any rows in the table are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getissomerowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getIsSomeRowsSelected: () => boolean\n  /**\n   * Returns the core row model of all rows before row selection has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getpreselectedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getPreSelectedRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model of all rows that are selected.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#getselectedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getSelectedRowModel: () => RowModel<TData>\n  /**\n   * Returns a handler that can be used to toggle all rows on the current page.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#gettoggleallpagerowsselectedhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getToggleAllPageRowsSelectedHandler: () => (event: unknown) => void\n  /**\n   * Returns a handler that can be used to toggle all rows in the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#gettoggleallrowsselectedhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  getToggleAllRowsSelectedHandler: () => (event: unknown) => void\n  /**\n   * Resets the **rowSelection** state to the `initialState.rowSelection`, or `true` can be passed to force a default blank state reset to `{}`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#resetrowselection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  resetRowSelection: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.rowSelection` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#setrowselection)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  setRowSelection: (updater: Updater<RowSelectionState>) => void\n  /**\n   * Selects/deselects all rows on the current page.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#toggleallpagerowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  toggleAllPageRowsSelected: (value?: boolean) => void\n  /**\n   * Selects/deselects all rows in the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-selection#toggleallrowsselected)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-selection)\n   */\n  toggleAllRowsSelected: (value?: boolean) => void\n}\n\n//\n\nexport const RowSelection: TableFeature = {\n  getInitialState: (state): RowSelectionTableState => {\n    return {\n      rowSelection: {},\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): RowSelectionOptions<TData> => {\n    return {\n      onRowSelectionChange: makeStateUpdater('rowSelection', table),\n      enableRowSelection: true,\n      enableMultiRowSelection: true,\n      enableSubRowSelection: true,\n      // enableGroupingRowSelection: false,\n      // isAdditiveSelectEvent: (e: unknown) => !!e.metaKey,\n      // isInclusiveSelectEvent: (e: unknown) => !!e.shiftKey,\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setRowSelection = updater =>\n      table.options.onRowSelectionChange?.(updater)\n    table.resetRowSelection = defaultState =>\n      table.setRowSelection(\n        defaultState ? {} : table.initialState.rowSelection ?? {}\n      )\n    table.toggleAllRowsSelected = value => {\n      table.setRowSelection(old => {\n        value =\n          typeof value !== 'undefined' ? value : !table.getIsAllRowsSelected()\n\n        const rowSelection = { ...old }\n\n        const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows\n\n        // We don't use `mutateRowIsSelected` here for performance reasons.\n        // All of the rows are flat already, so it wouldn't be worth it\n        if (value) {\n          preGroupedFlatRows.forEach(row => {\n            if (!row.getCanSelect()) {\n              return\n            }\n            rowSelection[row.id] = true\n          })\n        } else {\n          preGroupedFlatRows.forEach(row => {\n            delete rowSelection[row.id]\n          })\n        }\n\n        return rowSelection\n      })\n    }\n    table.toggleAllPageRowsSelected = value =>\n      table.setRowSelection(old => {\n        const resolvedValue =\n          typeof value !== 'undefined'\n            ? value\n            : !table.getIsAllPageRowsSelected()\n\n        const rowSelection: RowSelectionState = { ...old }\n\n        table.getRowModel().rows.forEach(row => {\n          mutateRowIsSelected(rowSelection, row.id, resolvedValue, true, table)\n        })\n\n        return rowSelection\n      })\n\n    // addRowSelectionRange: rowId => {\n    //   const {\n    //     rows,\n    //     rowsById,\n    //     options: { selectGroupingRows, selectSubRows },\n    //   } = table\n\n    //   const findSelectedRow = (rows: Row[]) => {\n    //     let found\n    //     rows.find(d => {\n    //       if (d.getIsSelected()) {\n    //         found = d\n    //         return true\n    //       }\n    //       const subFound = findSelectedRow(d.subRows || [])\n    //       if (subFound) {\n    //         found = subFound\n    //         return true\n    //       }\n    //       return false\n    //     })\n    //     return found\n    //   }\n\n    //   const firstRow = findSelectedRow(rows) || rows[0]\n    //   const lastRow = rowsById[rowId]\n\n    //   let include = false\n    //   const selectedRowIds = {}\n\n    //   const addRow = (row: Row) => {\n    //     mutateRowIsSelected(selectedRowIds, row.id, true, {\n    //       rowsById,\n    //       selectGroupingRows: selectGroupingRows!,\n    //       selectSubRows: selectSubRows!,\n    //     })\n    //   }\n\n    //   table.rows.forEach(row => {\n    //     const isFirstRow = row.id === firstRow.id\n    //     const isLastRow = row.id === lastRow.id\n\n    //     if (isFirstRow || isLastRow) {\n    //       if (!include) {\n    //         include = true\n    //       } else if (include) {\n    //         addRow(row)\n    //         include = false\n    //       }\n    //     }\n\n    //     if (include) {\n    //       addRow(row)\n    //     }\n    //   })\n\n    //   table.setRowSelection(selectedRowIds)\n    // },\n    table.getPreSelectedRowModel = () => table.getCoreRowModel()\n    table.getSelectedRowModel = memo(\n      () => [table.getState().rowSelection, table.getCoreRowModel()],\n      (rowSelection, rowModel) => {\n        if (!Object.keys(rowSelection).length) {\n          return {\n            rows: [],\n            flatRows: [],\n            rowsById: {},\n          }\n        }\n\n        return selectRowsFn(table, rowModel)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getSelectedRowModel')\n    )\n\n    table.getFilteredSelectedRowModel = memo(\n      () => [table.getState().rowSelection, table.getFilteredRowModel()],\n      (rowSelection, rowModel) => {\n        if (!Object.keys(rowSelection).length) {\n          return {\n            rows: [],\n            flatRows: [],\n            rowsById: {},\n          }\n        }\n\n        return selectRowsFn(table, rowModel)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getFilteredSelectedRowModel')\n    )\n\n    table.getGroupedSelectedRowModel = memo(\n      () => [table.getState().rowSelection, table.getSortedRowModel()],\n      (rowSelection, rowModel) => {\n        if (!Object.keys(rowSelection).length) {\n          return {\n            rows: [],\n            flatRows: [],\n            rowsById: {},\n          }\n        }\n\n        return selectRowsFn(table, rowModel)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getGroupedSelectedRowModel')\n    )\n\n    ///\n\n    // getGroupingRowCanSelect: rowId => {\n    //   const row = table.getRow(rowId)\n\n    //   if (!row) {\n    //     throw new Error()\n    //   }\n\n    //   if (typeof table.options.enableGroupingRowSelection === 'function') {\n    //     return table.options.enableGroupingRowSelection(row)\n    //   }\n\n    //   return table.options.enableGroupingRowSelection ?? false\n    // },\n\n    table.getIsAllRowsSelected = () => {\n      const preGroupedFlatRows = table.getFilteredRowModel().flatRows\n      const { rowSelection } = table.getState()\n\n      let isAllRowsSelected = Boolean(\n        preGroupedFlatRows.length && Object.keys(rowSelection).length\n      )\n\n      if (isAllRowsSelected) {\n        if (\n          preGroupedFlatRows.some(\n            row => row.getCanSelect() && !rowSelection[row.id]\n          )\n        ) {\n          isAllRowsSelected = false\n        }\n      }\n\n      return isAllRowsSelected\n    }\n\n    table.getIsAllPageRowsSelected = () => {\n      const paginationFlatRows = table\n        .getPaginationRowModel()\n        .flatRows.filter(row => row.getCanSelect())\n      const { rowSelection } = table.getState()\n\n      let isAllPageRowsSelected = !!paginationFlatRows.length\n\n      if (\n        isAllPageRowsSelected &&\n        paginationFlatRows.some(row => !rowSelection[row.id])\n      ) {\n        isAllPageRowsSelected = false\n      }\n\n      return isAllPageRowsSelected\n    }\n\n    table.getIsSomeRowsSelected = () => {\n      const totalSelected = Object.keys(\n        table.getState().rowSelection ?? {}\n      ).length\n      return (\n        totalSelected > 0 &&\n        totalSelected < table.getFilteredRowModel().flatRows.length\n      )\n    }\n\n    table.getIsSomePageRowsSelected = () => {\n      const paginationFlatRows = table.getPaginationRowModel().flatRows\n      return table.getIsAllPageRowsSelected()\n        ? false\n        : paginationFlatRows\n            .filter(row => row.getCanSelect())\n            .some(d => d.getIsSelected() || d.getIsSomeSelected())\n    }\n\n    table.getToggleAllRowsSelectedHandler = () => {\n      return (e: unknown) => {\n        table.toggleAllRowsSelected(\n          ((e as MouseEvent).target as HTMLInputElement).checked\n        )\n      }\n    }\n\n    table.getToggleAllPageRowsSelectedHandler = () => {\n      return (e: unknown) => {\n        table.toggleAllPageRowsSelected(\n          ((e as MouseEvent).target as HTMLInputElement).checked\n        )\n      }\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row.toggleSelected = (value, opts) => {\n      const isSelected = row.getIsSelected()\n\n      table.setRowSelection(old => {\n        value = typeof value !== 'undefined' ? value : !isSelected\n\n        if (row.getCanSelect() && isSelected === value) {\n          return old\n        }\n\n        const selectedRowIds = { ...old }\n\n        mutateRowIsSelected(\n          selectedRowIds,\n          row.id,\n          value,\n          opts?.selectChildren ?? true,\n          table\n        )\n\n        return selectedRowIds\n      })\n    }\n    row.getIsSelected = () => {\n      const { rowSelection } = table.getState()\n      return isRowSelected(row, rowSelection)\n    }\n\n    row.getIsSomeSelected = () => {\n      const { rowSelection } = table.getState()\n      return isSubRowSelected(row, rowSelection, table) === 'some'\n    }\n\n    row.getIsAllSubRowsSelected = () => {\n      const { rowSelection } = table.getState()\n      return isSubRowSelected(row, rowSelection, table) === 'all'\n    }\n\n    row.getCanSelect = () => {\n      if (typeof table.options.enableRowSelection === 'function') {\n        return table.options.enableRowSelection(row)\n      }\n\n      return table.options.enableRowSelection ?? true\n    }\n\n    row.getCanSelectSubRows = () => {\n      if (typeof table.options.enableSubRowSelection === 'function') {\n        return table.options.enableSubRowSelection(row)\n      }\n\n      return table.options.enableSubRowSelection ?? true\n    }\n\n    row.getCanMultiSelect = () => {\n      if (typeof table.options.enableMultiRowSelection === 'function') {\n        return table.options.enableMultiRowSelection(row)\n      }\n\n      return table.options.enableMultiRowSelection ?? true\n    }\n    row.getToggleSelectedHandler = () => {\n      const canSelect = row.getCanSelect()\n\n      return (e: unknown) => {\n        if (!canSelect) return\n        row.toggleSelected(\n          ((e as MouseEvent).target as HTMLInputElement)?.checked\n        )\n      }\n    }\n  },\n}\n\nconst mutateRowIsSelected = <TData extends RowData>(\n  selectedRowIds: Record<string, boolean>,\n  id: string,\n  value: boolean,\n  includeChildren: boolean,\n  table: Table<TData>\n) => {\n  const row = table.getRow(id, true)\n\n  // const isGrouped = row.getIsGrouped()\n\n  // if ( // TODO: enforce grouping row selection rules\n  //   !isGrouped ||\n  //   (isGrouped && table.options.enableGroupingRowSelection)\n  // ) {\n  if (value) {\n    if (!row.getCanMultiSelect()) {\n      Object.keys(selectedRowIds).forEach(key => delete selectedRowIds[key])\n    }\n    if (row.getCanSelect()) {\n      selectedRowIds[id] = true\n    }\n  } else {\n    delete selectedRowIds[id]\n  }\n  // }\n\n  if (includeChildren && row.subRows?.length && row.getCanSelectSubRows()) {\n    row.subRows.forEach(row =>\n      mutateRowIsSelected(selectedRowIds, row.id, value, includeChildren, table)\n    )\n  }\n}\n\nexport function selectRowsFn<TData extends RowData>(\n  table: Table<TData>,\n  rowModel: RowModel<TData>\n): RowModel<TData> {\n  const rowSelection = table.getState().rowSelection\n\n  const newSelectedFlatRows: Row<TData>[] = []\n  const newSelectedRowsById: Record<string, Row<TData>> = {}\n\n  // Filters top level and nested rows\n  const recurseRows = (rows: Row<TData>[], depth = 0): Row<TData>[] => {\n    return rows\n      .map(row => {\n        const isSelected = isRowSelected(row, rowSelection)\n\n        if (isSelected) {\n          newSelectedFlatRows.push(row)\n          newSelectedRowsById[row.id] = row\n        }\n\n        if (row.subRows?.length) {\n          row = {\n            ...row,\n            subRows: recurseRows(row.subRows, depth + 1),\n          }\n        }\n\n        if (isSelected) {\n          return row\n        }\n      })\n      .filter(Boolean) as Row<TData>[]\n  }\n\n  return {\n    rows: recurseRows(rowModel.rows),\n    flatRows: newSelectedFlatRows,\n    rowsById: newSelectedRowsById,\n  }\n}\n\nexport function isRowSelected<TData extends RowData>(\n  row: Row<TData>,\n  selection: Record<string, boolean>\n): boolean {\n  return selection[row.id] ?? false\n}\n\nexport function isSubRowSelected<TData extends RowData>(\n  row: Row<TData>,\n  selection: Record<string, boolean>,\n  table: Table<TData>\n): boolean | 'some' | 'all' {\n  if (!row.subRows?.length) return false\n\n  let allChildrenSelected = true\n  let someSelected = false\n\n  row.subRows.forEach(subRow => {\n    // Bail out early if we know both of these\n    if (someSelected && !allChildrenSelected) {\n      return\n    }\n\n    if (subRow.getCanSelect()) {\n      if (isRowSelected(subRow, selection)) {\n        someSelected = true\n      } else {\n        allChildrenSelected = false\n      }\n    }\n\n    // Check row selection of nested subrows\n    if (subRow.subRows && subRow.subRows.length) {\n      const subRowChildrenSelected = isSubRowSelected(subRow, selection, table)\n      if (subRowChildrenSelected === 'all') {\n        someSelected = true\n      } else if (subRowChildrenSelected === 'some') {\n        someSelected = true\n        allChildrenSelected = false\n      } else {\n        allChildrenSelected = false\n      }\n    }\n  })\n\n  return allChildrenSelected ? 'all' : someSelected ? 'some' : false\n}\n","import { SortingFn } from './features/RowSorting'\n\nexport const reSplitAlphaNumeric = /([0-9]+)/gm\n\nconst alphanumeric: SortingFn<any> = (rowA, rowB, columnId) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase()\n  )\n}\n\nconst alphanumericCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {\n  return compareAlphanumeric(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId))\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\nconst text: SortingFn<any> = (rowA, rowB, columnId) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)).toLowerCase(),\n    toString(rowB.getValue(columnId)).toLowerCase()\n  )\n}\n\n// The text filter is more basic (less numeric support)\n// but is much faster\nconst textCaseSensitive: SortingFn<any> = (rowA, rowB, columnId) => {\n  return compareBasic(\n    toString(rowA.getValue(columnId)),\n    toString(rowB.getValue(columnId))\n  )\n}\n\nconst datetime: SortingFn<any> = (rowA, rowB, columnId) => {\n  const a = rowA.getValue<Date>(columnId)\n  const b = rowB.getValue<Date>(columnId)\n\n  // Can handle nullish values\n  // Use > and < because == (and ===) doesn't work with\n  // Date objects (would require calling getTime()).\n  return a > b ? 1 : a < b ? -1 : 0\n}\n\nconst basic: SortingFn<any> = (rowA, rowB, columnId) => {\n  return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId))\n}\n\n// Utils\n\nfunction compareBasic(a: any, b: any) {\n  return a === b ? 0 : a > b ? 1 : -1\n}\n\nfunction toString(a: any) {\n  if (typeof a === 'number') {\n    if (isNaN(a) || a === Infinity || a === -Infinity) {\n      return ''\n    }\n    return String(a)\n  }\n  if (typeof a === 'string') {\n    return a\n  }\n  return ''\n}\n\n// Mixed sorting is slow, but very inclusive of many edge cases.\n// It handles numbers, mixed alphanumeric combinations, and even\n// null, undefined, and Infinity\nfunction compareAlphanumeric(aStr: string, bStr: string) {\n  // Split on number groups, but keep the delimiter\n  // Then remove falsey split values\n  const a = aStr.split(reSplitAlphaNumeric).filter(Boolean)\n  const b = bStr.split(reSplitAlphaNumeric).filter(Boolean)\n\n  // While\n  while (a.length && b.length) {\n    const aa = a.shift()!\n    const bb = b.shift()!\n\n    const an = parseInt(aa, 10)\n    const bn = parseInt(bb, 10)\n\n    const combo = [an, bn].sort()\n\n    // Both are string\n    if (isNaN(combo[0]!)) {\n      if (aa > bb) {\n        return 1\n      }\n      if (bb > aa) {\n        return -1\n      }\n      continue\n    }\n\n    // One is a string, one is a number\n    if (isNaN(combo[1]!)) {\n      return isNaN(an) ? -1 : 1\n    }\n\n    // Both are numbers\n    if (an > bn) {\n      return 1\n    }\n    if (bn > an) {\n      return -1\n    }\n  }\n\n  return a.length - b.length\n}\n\n// Exports\n\nexport const sortingFns = {\n  alphanumeric,\n  alphanumericCaseSensitive,\n  text,\n  textCaseSensitive,\n  datetime,\n  basic,\n}\n\nexport type BuiltInSortingFn = keyof typeof sortingFns\n","import { functionalUpdate, getMemoOptions, memo, RequiredKeys } from '../utils'\n\nimport {\n  Updater,\n  TableOptionsResolved,\n  TableState,\n  Table,\n  InitialTableState,\n  Row,\n  Column,\n  RowModel,\n  ColumnDef,\n  TableOptions,\n  RowData,\n  TableMeta,\n  ColumnDefResolved,\n  GroupColumnDef,\n  TableFeature,\n} from '../types'\n\n//\nimport { createColumn } from './column'\nimport { Headers } from './headers'\n//\n\nimport { ColumnFaceting } from '../features/ColumnFaceting'\nimport { ColumnFiltering } from '../features/ColumnFiltering'\nimport { ColumnGrouping } from '../features/ColumnGrouping'\nimport { ColumnOrdering } from '../features/ColumnOrdering'\nimport { ColumnPinning } from '../features/ColumnPinning'\nimport { ColumnSizing } from '../features/ColumnSizing'\nimport { ColumnVisibility } from '../features/ColumnVisibility'\nimport { GlobalFaceting } from '../features/GlobalFaceting'\nimport { GlobalFiltering } from '../features/GlobalFiltering'\nimport { RowExpanding } from '../features/RowExpanding'\nimport { RowPagination } from '../features/RowPagination'\nimport { RowPinning } from '../features/RowPinning'\nimport { RowSelection } from '../features/RowSelection'\nimport { RowSorting } from '../features/RowSorting'\n\nconst builtInFeatures = [\n  Headers,\n  ColumnVisibility,\n  ColumnOrdering,\n  ColumnPinning,\n  ColumnFaceting,\n  ColumnFiltering,\n  GlobalFaceting, //depends on ColumnFaceting\n  GlobalFiltering, //depends on ColumnFiltering\n  RowSorting,\n  ColumnGrouping, //depends on RowSorting\n  RowExpanding,\n  RowPagination,\n  RowPinning,\n  RowSelection,\n  ColumnSizing,\n] as const\n\n//\n\nexport interface CoreTableState {}\n\nexport interface CoreOptions<TData extends RowData> {\n  /**\n   * An array of extra features that you can add to the table instance.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#_features)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  _features?: TableFeature[]\n  /**\n   * Set this option to override any of the `autoReset...` feature options.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#autoresetall)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  autoResetAll?: boolean\n  /**\n   * The array of column defs to use for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#columns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  columns: ColumnDef<TData, any>[]\n  /**\n   * The data for the table to display. This array should match the type you provided to `table.setRowType<...>`. Columns can access this data via string/index or a functional accessor. When the `data` option changes reference, the table will reprocess the data.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#data)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  data: TData[]\n  /**\n   * Set this option to `true` to output all debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugall)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugAll?: boolean\n  /**\n   * Set this option to `true` to output cell debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugcells]\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugCells?: boolean\n  /**\n   * Set this option to `true` to output column debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugColumns?: boolean\n  /**\n   * Set this option to `true` to output header debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugheaders)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugHeaders?: boolean\n  /**\n   * Set this option to `true` to output row debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugRows?: boolean\n  /**\n   * Set this option to `true` to output table debugging information to the console.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#debugtable)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  debugTable?: boolean\n  /**\n   * Default column options to use for all column defs supplied to the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#defaultcolumn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  defaultColumn?: Partial<ColumnDef<TData, unknown>>\n  /**\n   * This required option is a factory for a function that computes and returns the core row model for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getcorerowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getCoreRowModel: (table: Table<any>) => () => RowModel<any>\n  /**\n   * This optional function is used to derive a unique ID for any given row. If not provided the rows index is used (nested rows join together with `.` using their grandparents' index eg. `index.index.index`). If you need to identify individual rows that are originating from any server-side operations, it's suggested you use this function to return an ID that makes sense regardless of network IO/ambiguity eg. a userId, taskId, database ID field, etc.\n   * @example getRowId: row => row.userId\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getrowid)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string\n  /**\n   * This optional function is used to access the sub rows for any given row. If you are using nested rows, you will need to use this function to return the sub rows object (or undefined) from the row.\n   * @example getSubRows: row => row.subRows\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getsubrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getSubRows?: (originalRow: TData, index: number) => undefined | TData[]\n  /**\n   * Use this option to optionally pass initial state to the table. This state will be used when resetting various table states either automatically by the table (eg. `options.autoResetPageIndex`) or via functions like `table.resetRowSelection()`. Most reset function allow you optionally pass a flag to reset to a blank/default state instead of the initial state.\n   *\n   * Table state will not be reset when this object changes, which also means that the initial state object does not need to be stable.\n   *\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#initialstate)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  initialState?: InitialTableState\n  /**\n   * This option is used to optionally implement the merging of table options.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#mergeoptions)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  mergeOptions?: (\n    defaultOptions: TableOptions<TData>,\n    options: Partial<TableOptions<TData>>\n  ) => TableOptions<TData>\n  /**\n   * You can pass any object to `options.meta` and access it anywhere the `table` is available via `table.options.meta`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#meta)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  meta?: TableMeta<TData>\n  /**\n   * The `onStateChange` option can be used to optionally listen to state changes within the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#onstatechange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  onStateChange: (updater: Updater<TableState>) => void\n  /**\n   * Value used when the desired value is not found in the data.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#renderfallbackvalue)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  renderFallbackValue: any\n  /**\n   * The `state` option can be used to optionally _control_ part or all of the table state. The state you pass here will merge with and overwrite the internal automatically-managed state to produce the final state for the table. You can also listen to state changes via the `onStateChange` option.\n   * > Note: Any state passed in here will override both the internal state and any other `initialState` you provide.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#state)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  state: Partial<TableState>\n}\n\nexport interface CoreInstance<TData extends RowData> {\n  _features: readonly TableFeature[]\n  _getAllFlatColumnsById: () => Record<string, Column<TData, unknown>>\n  _getColumnDefs: () => ColumnDef<TData, unknown>[]\n  _getCoreRowModel?: () => RowModel<TData>\n  _getDefaultColumnDef: () => Partial<ColumnDef<TData, unknown>>\n  _getRowId: (_: TData, index: number, parent?: Row<TData>) => string\n  _queue: (cb: () => void) => void\n  /**\n   * Returns all columns in the table in their normalized and nested hierarchy.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getallcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getAllColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns all columns in the table flattened to a single level.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getallflatcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getAllFlatColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns all leaf-node columns in the table flattened to a single level. This does not include parent columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getallleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getAllLeafColumns: () => Column<TData, unknown>[]\n  /**\n   * Returns a single column by its ID.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getcolumn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getColumn: (columnId: string) => Column<TData, unknown> | undefined\n  /**\n   * Returns the core row model before any processing has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getcorerowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getCoreRowModel: () => RowModel<TData>\n  /**\n   * Returns the row with the given ID.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getrow)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getRow: (id: string, searchAll?: boolean) => Row<TData>\n  /**\n   * Returns the final model after all processing from other used features has been applied. This is the row model that is most commonly used for rendering.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getRowModel: () => RowModel<TData>\n  /**\n   * Call this function to get the table's current state. It's recommended to use this function and its state, especially when managing the table state manually. It is the exact same state used internally by the table for every feature and function it provides.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#getstate)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  getState: () => TableState\n  /**\n   * This is the resolved initial state of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#initialstate)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  initialState: TableState\n  /**\n   * A read-only reference to the table's current options.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#options)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  options: RequiredKeys<TableOptionsResolved<TData>, 'state'>\n  /**\n   * Call this function to reset the table state to the initial state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#reset)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  reset: () => void\n  /**\n   * This function can be used to update the table options.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#setoptions)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  setOptions: (newOptions: Updater<TableOptionsResolved<TData>>) => void\n  /**\n   * Call this function to update the table state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/table#setstate)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/tables)\n   */\n  setState: (updater: Updater<TableState>) => void\n}\n\nexport function createTable<TData extends RowData>(\n  options: TableOptionsResolved<TData>\n): Table<TData> {\n  if (\n    process.env.NODE_ENV !== 'production' &&\n    (options.debugAll || options.debugTable)\n  ) {\n    console.info('Creating Table Instance...')\n  }\n\n  const _features = [...builtInFeatures, ...(options._features ?? [])]\n\n  let table = { _features } as unknown as Table<TData>\n\n  const defaultOptions = table._features.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultOptions?.(table))\n  }, {}) as TableOptionsResolved<TData>\n\n  const mergeOptions = (options: TableOptionsResolved<TData>) => {\n    if (table.options.mergeOptions) {\n      return table.options.mergeOptions(defaultOptions, options)\n    }\n\n    return {\n      ...defaultOptions,\n      ...options,\n    }\n  }\n\n  const coreInitialState: CoreTableState = {}\n\n  let initialState = {\n    ...coreInitialState,\n    ...(options.initialState ?? {}),\n  } as TableState\n\n  table._features.forEach(feature => {\n    initialState = (feature.getInitialState?.(initialState) ??\n      initialState) as TableState\n  })\n\n  const queued: (() => void)[] = []\n  let queuedTimeout = false\n\n  const coreInstance: CoreInstance<TData> = {\n    _features,\n    options: {\n      ...defaultOptions,\n      ...options,\n    },\n    initialState,\n    _queue: cb => {\n      queued.push(cb)\n\n      if (!queuedTimeout) {\n        queuedTimeout = true\n\n        // Schedule a microtask to run the queued callbacks after\n        // the current call stack (render, etc) has finished.\n        Promise.resolve()\n          .then(() => {\n            while (queued.length) {\n              queued.shift()!()\n            }\n            queuedTimeout = false\n          })\n          .catch(error =>\n            setTimeout(() => {\n              throw error\n            })\n          )\n      }\n    },\n    reset: () => {\n      table.setState(table.initialState)\n    },\n    setOptions: updater => {\n      const newOptions = functionalUpdate(updater, table.options)\n      table.options = mergeOptions(newOptions) as RequiredKeys<\n        TableOptionsResolved<TData>,\n        'state'\n      >\n    },\n\n    getState: () => {\n      return table.options.state as TableState\n    },\n\n    setState: (updater: Updater<TableState>) => {\n      table.options.onStateChange?.(updater)\n    },\n\n    _getRowId: (row: TData, index: number, parent?: Row<TData>) =>\n      table.options.getRowId?.(row, index, parent) ??\n      `${parent ? [parent.id, index].join('.') : index}`,\n\n    getCoreRowModel: () => {\n      if (!table._getCoreRowModel) {\n        table._getCoreRowModel = table.options.getCoreRowModel(table)\n      }\n\n      return table._getCoreRowModel!()\n    },\n\n    // The final calls start at the bottom of the model,\n    // expanded rows, which then work their way up\n\n    getRowModel: () => {\n      return table.getPaginationRowModel()\n    },\n    //in next version, we should just pass in the row model as the optional 2nd arg\n    getRow: (id: string, searchAll?: boolean) => {\n      let row = (\n        searchAll ? table.getPrePaginationRowModel() : table.getRowModel()\n      ).rowsById[id]\n\n      if (!row) {\n        row = table.getCoreRowModel().rowsById[id]\n        if (!row) {\n          if (process.env.NODE_ENV !== 'production') {\n            throw new Error(`getRow could not find row with ID: ${id}`)\n          }\n          throw new Error()\n        }\n      }\n\n      return row\n    },\n    _getDefaultColumnDef: memo(\n      () => [table.options.defaultColumn],\n      defaultColumn => {\n        defaultColumn = (defaultColumn ?? {}) as Partial<\n          ColumnDef<TData, unknown>\n        >\n\n        return {\n          header: props => {\n            const resolvedColumnDef = props.header.column\n              .columnDef as ColumnDefResolved<TData>\n\n            if (resolvedColumnDef.accessorKey) {\n              return resolvedColumnDef.accessorKey\n            }\n\n            if (resolvedColumnDef.accessorFn) {\n              return resolvedColumnDef.id\n            }\n\n            return null\n          },\n          // footer: props => props.header.column.id,\n          cell: props => props.renderValue<any>()?.toString?.() ?? null,\n          ...table._features.reduce((obj, feature) => {\n            return Object.assign(obj, feature.getDefaultColumnDef?.())\n          }, {}),\n          ...defaultColumn,\n        } as Partial<ColumnDef<TData, unknown>>\n      },\n      getMemoOptions(options, 'debugColumns', '_getDefaultColumnDef')\n    ),\n\n    _getColumnDefs: () => table.options.columns,\n\n    getAllColumns: memo(\n      () => [table._getColumnDefs()],\n      columnDefs => {\n        const recurseColumns = (\n          columnDefs: ColumnDef<TData, unknown>[],\n          parent?: Column<TData, unknown>,\n          depth = 0\n        ): Column<TData, unknown>[] => {\n          return columnDefs.map(columnDef => {\n            const column = createColumn(table, columnDef, depth, parent)\n\n            const groupingColumnDef = columnDef as GroupColumnDef<\n              TData,\n              unknown\n            >\n\n            column.columns = groupingColumnDef.columns\n              ? recurseColumns(groupingColumnDef.columns, column, depth + 1)\n              : []\n\n            return column\n          })\n        }\n\n        return recurseColumns(columnDefs)\n      },\n      getMemoOptions(options, 'debugColumns', 'getAllColumns')\n    ),\n\n    getAllFlatColumns: memo(\n      () => [table.getAllColumns()],\n      allColumns => {\n        return allColumns.flatMap(column => {\n          return column.getFlatColumns()\n        })\n      },\n      getMemoOptions(options, 'debugColumns', 'getAllFlatColumns')\n    ),\n\n    _getAllFlatColumnsById: memo(\n      () => [table.getAllFlatColumns()],\n      flatColumns => {\n        return flatColumns.reduce(\n          (acc, column) => {\n            acc[column.id] = column\n            return acc\n          },\n          {} as Record<string, Column<TData, unknown>>\n        )\n      },\n      getMemoOptions(options, 'debugColumns', 'getAllFlatColumnsById')\n    ),\n\n    getAllLeafColumns: memo(\n      () => [table.getAllColumns(), table._getOrderColumnsFn()],\n      (allColumns, orderColumns) => {\n        let leafColumns = allColumns.flatMap(column => column.getLeafColumns())\n        return orderColumns(leafColumns)\n      },\n      getMemoOptions(options, 'debugColumns', 'getAllLeafColumns')\n    ),\n\n    getColumn: columnId => {\n      const column = table._getAllFlatColumnsById()[columnId]\n\n      if (process.env.NODE_ENV !== 'production' && !column) {\n        console.error(`[Table] Column with id '${columnId}' does not exist.`)\n      }\n\n      return column\n    },\n  }\n\n  Object.assign(table, coreInstance)\n\n  for (let index = 0; index < table._features.length; index++) {\n    const feature = table._features[index]\n    feature?.createTable?.(table)\n  }\n\n  return table\n}\n","import { FilterFn, FilterFnOption } from '..'\nimport { BuiltInFilterFn, filterFns } from '../filterFns'\nimport {\n  Column,\n  OnChangeFn,\n  Table,\n  Updater,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { isFunction, makeStateUpdater } from '../utils'\n\nexport interface GlobalFilterTableState {\n  globalFilter: any\n}\n\nexport interface GlobalFilterColumnDef {\n  /**\n   * Enables/disables the **global** filter for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#enableglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  enableGlobalFilter?: boolean\n}\n\nexport interface GlobalFilterColumn {\n  /**\n   * Returns whether or not the column can be **globally** filtered. Set to `false` to disable a column from being scanned during global filtering.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getcanglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  getCanGlobalFilter: () => boolean\n}\n\nexport interface GlobalFilterOptions<TData extends RowData> {\n  /**\n   * Enables/disables **global** filtering for all columns.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#enableglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  enableGlobalFilter?: boolean\n  /**\n   * If provided, this function will be called with the column and should return `true` or `false` to indicate whether this column should be used for global filtering.\n   *\n   * This is useful if the column can contain data that is not `string` or `number` (i.e. `undefined`).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getcolumncanglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  getColumnCanGlobalFilter?: (column: Column<TData, unknown>) => boolean\n  /**\n   * The filter function to use for global filtering.\n   * - A `string` referencing a built-in filter function\n   * - A `string` that references a custom filter functions provided via the `tableOptions.filterFns` option\n   * - A custom filter function\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#globalfilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  globalFilterFn?: FilterFnOption<TData>\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.globalFilter` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#onglobalfilterchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  onGlobalFilterChange?: OnChangeFn<any>\n}\n\nexport interface GlobalFilterInstance<TData extends RowData> {\n  /**\n   * Currently, this function returns the built-in `includesString` filter function. In future releases, it may return more dynamic filter functions based on the nature of the data provided.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getglobalautofilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  getGlobalAutoFilterFn: () => FilterFn<TData> | undefined\n  /**\n   * Returns the filter function (either user-defined or automatic, depending on configuration) for the global filter.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#getglobalfilterfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  getGlobalFilterFn: () => FilterFn<TData> | undefined\n  /**\n   * Resets the **globalFilter** state to `initialState.globalFilter`, or `true` can be passed to force a default blank state reset to `undefined`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#resetglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  resetGlobalFilter: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.globalFilter` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/global-filtering#setglobalfilter)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/global-filtering)\n   */\n  setGlobalFilter: (updater: Updater<any>) => void\n}\n\n//\n\nexport const GlobalFiltering: TableFeature = {\n  getInitialState: (state): GlobalFilterTableState => {\n    return {\n      globalFilter: undefined,\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): GlobalFilterOptions<TData> => {\n    return {\n      onGlobalFilterChange: makeStateUpdater('globalFilter', table),\n      globalFilterFn: 'auto',\n      getColumnCanGlobalFilter: column => {\n        const value = table\n          .getCoreRowModel()\n          .flatRows[0]?._getAllCellsByColumnId()\n          [column.id]?.getValue()\n\n        return typeof value === 'string' || typeof value === 'number'\n      },\n    } as GlobalFilterOptions<TData>\n  },\n\n  createColumn: <TData extends RowData>(\n    column: Column<TData, unknown>,\n    table: Table<TData>\n  ): void => {\n    column.getCanGlobalFilter = () => {\n      return (\n        (column.columnDef.enableGlobalFilter ?? true) &&\n        (table.options.enableGlobalFilter ?? true) &&\n        (table.options.enableFilters ?? true) &&\n        (table.options.getColumnCanGlobalFilter?.(column) ?? true) &&\n        !!column.accessorFn\n      )\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.getGlobalAutoFilterFn = () => {\n      return filterFns.includesString\n    }\n\n    table.getGlobalFilterFn = () => {\n      const { globalFilterFn: globalFilterFn } = table.options\n\n      return isFunction(globalFilterFn)\n        ? globalFilterFn\n        : globalFilterFn === 'auto'\n          ? table.getGlobalAutoFilterFn()\n          : table.options.filterFns?.[globalFilterFn as string] ??\n            filterFns[globalFilterFn as BuiltInFilterFn]\n    }\n\n    table.setGlobalFilter = updater => {\n      table.options.onGlobalFilterChange?.(updater)\n    }\n\n    table.resetGlobalFilter = defaultState => {\n      table.setGlobalFilter(\n        defaultState ? undefined : table.initialState.globalFilter\n      )\n    }\n  },\n}\n","import { RowModel } from '..'\nimport {\n  BuiltInSortingFn,\n  reSplitAlphaNumeric,\n  sortingFns,\n} from '../sortingFns'\n\nimport {\n  Column,\n  OnChangeFn,\n  Table,\n  Row,\n  Updater,\n  RowData,\n  SortingFns,\n  TableFeature,\n} from '../types'\n\nimport { isFunction, makeStateUpdater } from '../utils'\n\nexport type SortDirection = 'asc' | 'desc'\n\nexport interface ColumnSort {\n  desc: boolean\n  id: string\n}\n\nexport type SortingState = ColumnSort[]\n\nexport interface SortingTableState {\n  sorting: SortingState\n}\n\nexport interface SortingFn<TData extends RowData> {\n  (rowA: Row<TData>, rowB: Row<TData>, columnId: string): number\n}\n\nexport type CustomSortingFns<TData extends RowData> = Record<\n  string,\n  SortingFn<TData>\n>\n\nexport type SortingFnOption<TData extends RowData> =\n  | 'auto'\n  | keyof SortingFns\n  | BuiltInSortingFn\n  | SortingFn<TData>\n\nexport interface SortingColumnDef<TData extends RowData> {\n  /**\n   * Enables/Disables multi-sorting for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultisort)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableMultiSort?: boolean\n  /**\n   * Enables/Disables sorting for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableSorting?: boolean\n  /**\n   * Inverts the order of the sorting for this column. This is useful for values that have an inverted best/worst scale where lower numbers are better, eg. a ranking (1st, 2nd, 3rd) or golf-like scoring\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#invertsorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  invertSorting?: boolean\n  /**\n   * Set to `true` for sorting toggles on this column to start in the descending direction.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortdescfirst)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  sortDescFirst?: boolean\n  /**\n   * The sorting function to use with this column.\n   * - A `string` referencing a built-in sorting function\n   * - A custom sorting function\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortingfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  sortingFn?: SortingFnOption<TData>\n  /**\n   * The priority of undefined values when sorting this column.\n   * - `false`\n   *   - Undefined values will be considered tied and need to be sorted by the next column filter or original index (whichever applies)\n   * - `-1`\n   *   - Undefined values will be sorted with higher priority (ascending) (if ascending, undefined will appear on the beginning of the list)\n   * - `1`\n   *   - Undefined values will be sorted with lower priority (descending) (if ascending, undefined will appear on the end of the list)\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortundefined)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  sortUndefined?: false | -1 | 1 | 'first' | 'last'\n}\n\nexport interface SortingColumn<TData extends RowData> {\n  /**\n   * Removes this column from the table's sorting state\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#clearsorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  clearSorting: () => void\n  /**\n   * Returns a sort direction automatically inferred based on the columns values.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getautosortdir)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getAutoSortDir: () => SortDirection\n  /**\n   * Returns a sorting function automatically inferred based on the columns values.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getautosortingfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getAutoSortingFn: () => SortingFn<TData>\n  /**\n   * Returns whether this column can be multi-sorted.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getcanmultisort)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getCanMultiSort: () => boolean\n  /**\n   * Returns whether this column can be sorted.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getcansort)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getCanSort: () => boolean\n  /**\n   * Returns the first direction that should be used when sorting this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getfirstsortdir)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getFirstSortDir: () => SortDirection\n  /**\n   * Returns the current sort direction of this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getissorted)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getIsSorted: () => false | SortDirection\n  /**\n   * Returns the next sorting order.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getnextsortingorder)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getNextSortingOrder: () => SortDirection | false\n  /**\n   * Returns the index position of this column's sorting within the sorting state\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getSortIndex: () => number\n  /**\n   * Returns the resolved sorting function to be used for this column\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortingfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getSortingFn: () => SortingFn<TData>\n  /**\n   * Returns a function that can be used to toggle this column's sorting state. This is useful for attaching a click handler to the column header.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#gettogglesortinghandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getToggleSortingHandler: () => undefined | ((event: unknown) => void)\n  /**\n   * Toggles this columns sorting state. If `desc` is provided, it will force the sort direction to that value. If `isMulti` is provided, it will additivity multi-sort the column (or toggle it if it is already sorted).\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#togglesorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  toggleSorting: (desc?: boolean, isMulti?: boolean) => void\n}\n\ninterface SortingOptionsBase {\n  /**\n   * Enables/disables the ability to remove multi-sorts\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultiremove)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableMultiRemove?: boolean\n  /**\n   * Enables/Disables multi-sorting for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablemultisort)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableMultiSort?: boolean\n  /**\n   * Enables/Disables sorting for the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableSorting?: boolean\n  /**\n   * Enables/Disables the ability to remove sorting for the table.\n   * - If `true` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'none' -> ...\n   * - If `false` then changing sort order will circle like: 'none' -> 'desc' -> 'asc' -> 'desc' -> 'asc' -> ...\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#enablesortingremoval)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  enableSortingRemoval?: boolean\n  /**\n   * This function is used to retrieve the sorted row model. If using server-side sorting, this function is not required. To use client-side sorting, pass the exported `getSortedRowModel()` from your adapter to your table or implement your own.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getSortedRowModel?: (table: Table<any>) => () => RowModel<any>\n  /**\n   * Pass a custom function that will be used to determine if a multi-sort event should be triggered. It is passed the event from the sort toggle handler and should return `true` if the event should trigger a multi-sort.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#ismultisortevent)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  isMultiSortEvent?: (e: unknown) => boolean\n  /**\n   * Enables manual sorting for the table. If this is `true`, you will be expected to sort your data before it is passed to the table. This is useful if you are doing server-side sorting.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#manualsorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  manualSorting?: boolean\n  /**\n   * Set a maximum number of columns that can be multi-sorted.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#maxmultisortcolcount)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  maxMultiSortColCount?: number\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.sorting` changes. This overrides the default internal state management, so you will need to persist the state change either fully or partially outside of the table.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#onsortingchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  onSortingChange?: OnChangeFn<SortingState>\n  /**\n   * If `true`, all sorts will default to descending as their first toggle state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#sortdescfirst)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  sortDescFirst?: boolean\n}\n\ntype ResolvedSortingFns = keyof SortingFns extends never\n  ? {\n      sortingFns?: Record<string, SortingFn<any>>\n    }\n  : {\n      sortingFns: Record<keyof SortingFns, SortingFn<any>>\n    }\n\nexport interface SortingOptions<TData extends RowData>\n  extends SortingOptionsBase,\n    ResolvedSortingFns {}\n\nexport interface SortingInstance<TData extends RowData> {\n  _getSortedRowModel?: () => RowModel<TData>\n  /**\n   * Returns the row model for the table before any sorting has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getpresortedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getPreSortedRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model for the table after sorting has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#getsortedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  getSortedRowModel: () => RowModel<TData>\n  /**\n   * Resets the **sorting** state to `initialState.sorting`, or `true` can be passed to force a default blank state reset to `[]`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#resetsorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  resetSorting: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.sorting` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/sorting#setsorting)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/sorting)\n   */\n  setSorting: (updater: Updater<SortingState>) => void\n}\n\n//\n\nexport const RowSorting: TableFeature = {\n  getInitialState: (state): SortingTableState => {\n    return {\n      sorting: [],\n      ...state,\n    }\n  },\n\n  getDefaultColumnDef: <TData extends RowData>(): SortingColumnDef<TData> => {\n    return {\n      sortingFn: 'auto',\n      sortUndefined: 1,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): SortingOptions<TData> => {\n    return {\n      onSortingChange: makeStateUpdater('sorting', table),\n      isMultiSortEvent: (e: unknown) => {\n        return (e as MouseEvent).shiftKey\n      },\n    }\n  },\n\n  createColumn: <TData extends RowData, TValue>(\n    column: Column<TData, TValue>,\n    table: Table<TData>\n  ): void => {\n    column.getAutoSortingFn = () => {\n      const firstRows = table.getFilteredRowModel().flatRows.slice(10)\n\n      let isString = false\n\n      for (const row of firstRows) {\n        const value = row?.getValue(column.id)\n\n        if (Object.prototype.toString.call(value) === '[object Date]') {\n          return sortingFns.datetime\n        }\n\n        if (typeof value === 'string') {\n          isString = true\n\n          if (value.split(reSplitAlphaNumeric).length > 1) {\n            return sortingFns.alphanumeric\n          }\n        }\n      }\n\n      if (isString) {\n        return sortingFns.text\n      }\n\n      return sortingFns.basic\n    }\n    column.getAutoSortDir = () => {\n      const firstRow = table.getFilteredRowModel().flatRows[0]\n\n      const value = firstRow?.getValue(column.id)\n\n      if (typeof value === 'string') {\n        return 'asc'\n      }\n\n      return 'desc'\n    }\n    column.getSortingFn = () => {\n      if (!column) {\n        throw new Error()\n      }\n\n      return isFunction(column.columnDef.sortingFn)\n        ? column.columnDef.sortingFn\n        : column.columnDef.sortingFn === 'auto'\n          ? column.getAutoSortingFn()\n          : table.options.sortingFns?.[column.columnDef.sortingFn as string] ??\n            sortingFns[column.columnDef.sortingFn as BuiltInSortingFn]\n    }\n    column.toggleSorting = (desc, multi) => {\n      // if (column.columns.length) {\n      //   column.columns.forEach((c, i) => {\n      //     if (c.id) {\n      //       table.toggleColumnSorting(c.id, undefined, multi || !!i)\n      //     }\n      //   })\n      //   return\n      // }\n\n      // this needs to be outside of table.setSorting to be in sync with rerender\n      const nextSortingOrder = column.getNextSortingOrder()\n      const hasManualValue = typeof desc !== 'undefined' && desc !== null\n\n      table.setSorting(old => {\n        // Find any existing sorting for this column\n        const existingSorting = old?.find(d => d.id === column.id)\n        const existingIndex = old?.findIndex(d => d.id === column.id)\n\n        let newSorting: SortingState = []\n\n        // What should we do with this sort action?\n        let sortAction: 'add' | 'remove' | 'toggle' | 'replace'\n        let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc'\n\n        // Multi-mode\n        if (old?.length && column.getCanMultiSort() && multi) {\n          if (existingSorting) {\n            sortAction = 'toggle'\n          } else {\n            sortAction = 'add'\n          }\n        } else {\n          // Normal mode\n          if (old?.length && existingIndex !== old.length - 1) {\n            sortAction = 'replace'\n          } else if (existingSorting) {\n            sortAction = 'toggle'\n          } else {\n            sortAction = 'replace'\n          }\n        }\n\n        // Handle toggle states that will remove the sorting\n        if (sortAction === 'toggle') {\n          // If we are \"actually\" toggling (not a manual set value), should we remove the sorting?\n          if (!hasManualValue) {\n            // Is our intention to remove?\n            if (!nextSortingOrder) {\n              sortAction = 'remove'\n            }\n          }\n        }\n\n        if (sortAction === 'add') {\n          newSorting = [\n            ...old,\n            {\n              id: column.id,\n              desc: nextDesc,\n            },\n          ]\n          // Take latest n columns\n          newSorting.splice(\n            0,\n            newSorting.length -\n              (table.options.maxMultiSortColCount ?? Number.MAX_SAFE_INTEGER)\n          )\n        } else if (sortAction === 'toggle') {\n          // This flips (or sets) the\n          newSorting = old.map(d => {\n            if (d.id === column.id) {\n              return {\n                ...d,\n                desc: nextDesc,\n              }\n            }\n            return d\n          })\n        } else if (sortAction === 'remove') {\n          newSorting = old.filter(d => d.id !== column.id)\n        } else {\n          newSorting = [\n            {\n              id: column.id,\n              desc: nextDesc,\n            },\n          ]\n        }\n\n        return newSorting\n      })\n    }\n\n    column.getFirstSortDir = () => {\n      const sortDescFirst =\n        column.columnDef.sortDescFirst ??\n        table.options.sortDescFirst ??\n        column.getAutoSortDir() === 'desc'\n      return sortDescFirst ? 'desc' : 'asc'\n    }\n\n    column.getNextSortingOrder = (multi?: boolean) => {\n      const firstSortDirection = column.getFirstSortDir()\n      const isSorted = column.getIsSorted()\n\n      if (!isSorted) {\n        return firstSortDirection\n      }\n\n      if (\n        isSorted !== firstSortDirection &&\n        (table.options.enableSortingRemoval ?? true) && // If enableSortRemove, enable in general\n        (multi ? table.options.enableMultiRemove ?? true : true) // If multi, don't allow if enableMultiRemove))\n      ) {\n        return false\n      }\n      return isSorted === 'desc' ? 'asc' : 'desc'\n    }\n\n    column.getCanSort = () => {\n      return (\n        (column.columnDef.enableSorting ?? true) &&\n        (table.options.enableSorting ?? true) &&\n        !!column.accessorFn\n      )\n    }\n\n    column.getCanMultiSort = () => {\n      return (\n        column.columnDef.enableMultiSort ??\n        table.options.enableMultiSort ??\n        !!column.accessorFn\n      )\n    }\n\n    column.getIsSorted = () => {\n      const columnSort = table.getState().sorting?.find(d => d.id === column.id)\n\n      return !columnSort ? false : columnSort.desc ? 'desc' : 'asc'\n    }\n\n    column.getSortIndex = () =>\n      table.getState().sorting?.findIndex(d => d.id === column.id) ?? -1\n\n    column.clearSorting = () => {\n      //clear sorting for just 1 column\n      table.setSorting(old =>\n        old?.length ? old.filter(d => d.id !== column.id) : []\n      )\n    }\n\n    column.getToggleSortingHandler = () => {\n      const canSort = column.getCanSort()\n\n      return (e: unknown) => {\n        if (!canSort) return\n        ;(e as any).persist?.()\n        column.toggleSorting?.(\n          undefined,\n          column.getCanMultiSort() ? table.options.isMultiSortEvent?.(e) : false\n        )\n      }\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setSorting = updater => table.options.onSortingChange?.(updater)\n    table.resetSorting = defaultState => {\n      table.setSorting(defaultState ? [] : table.initialState?.sorting ?? [])\n    }\n    table.getPreSortedRowModel = () => table.getGroupedRowModel()\n    table.getSortedRowModel = () => {\n      if (!table._getSortedRowModel && table.options.getSortedRowModel) {\n        table._getSortedRowModel = table.options.getSortedRowModel(table)\n      }\n\n      if (table.options.manualSorting || !table._getSortedRowModel) {\n        return table.getPreSortedRowModel()\n      }\n\n      return table._getSortedRowModel()\n    }\n  },\n}\n","import { RowModel } from '..'\nimport {\n  OnChangeFn,\n  Table,\n  Row,\n  Updater,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { makeStateUpdater } from '../utils'\n\nexport type ExpandedStateList = Record<string, boolean>\nexport type ExpandedState = true | Record<string, boolean>\nexport interface ExpandedTableState {\n  expanded: ExpandedState\n}\n\nexport interface ExpandedRow {\n  /**\n   * Returns whether the row can be expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getcanexpand)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getCanExpand: () => boolean\n  /**\n   * Returns whether all parent rows of the row are expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getisallparentsexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getIsAllParentsExpanded: () => boolean\n  /**\n   * Returns whether the row is expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getisexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getIsExpanded: () => boolean\n  /**\n   * Returns a function that can be used to toggle the expanded state of the row. This function can be used to bind to an event handler to a button.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#gettoggleexpandedhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getToggleExpandedHandler: () => () => void\n  /**\n   * Toggles the expanded state (or sets it if `expanded` is provided) for the row.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#toggleexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  toggleExpanded: (expanded?: boolean) => void\n}\n\nexport interface ExpandedOptions<TData extends RowData> {\n  /**\n   * Enable this setting to automatically reset the expanded state of the table when expanding state changes.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#autoresetexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  autoResetExpanded?: boolean\n  /**\n   * Enable/disable expanding for all rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#enableexpanding)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  enableExpanding?: boolean\n  /**\n   * This function is responsible for returning the expanded row model. If this function is not provided, the table will not expand rows. You can use the default exported `getExpandedRowModel` function to get the expanded row model or implement your own.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getexpandedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getExpandedRowModel?: (table: Table<any>) => () => RowModel<any>\n  /**\n   * If provided, allows you to override the default behavior of determining whether a row is currently expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getisrowexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getIsRowExpanded?: (row: Row<TData>) => boolean\n  /**\n   * If provided, allows you to override the default behavior of determining whether a row can be expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getrowcanexpand)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getRowCanExpand?: (row: Row<TData>) => boolean\n  /**\n   * Enables manual row expansion. If this is set to `true`, `getExpandedRowModel` will not be used to expand rows and you would be expected to perform the expansion in your own data model. This is useful if you are doing server-side expansion.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#manualexpanding)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  manualExpanding?: boolean\n  /**\n   * This function is called when the `expanded` table state changes. If a function is provided, you will be responsible for managing this state on your own. To pass the managed state back to the table, use the `tableOptions.state.expanded` option.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#onexpandedchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  onExpandedChange?: OnChangeFn<ExpandedState>\n  /**\n   * If `true` expanded rows will be paginated along with the rest of the table (which means expanded rows may span multiple pages). If `false` expanded rows will not be considered for pagination (which means expanded rows will always render on their parents page. This also means more rows will be rendered than the set page size)\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#paginateexpandedrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  paginateExpandedRows?: boolean\n}\n\nexport interface ExpandedInstance<TData extends RowData> {\n  _autoResetExpanded: () => void\n  _getExpandedRowModel?: () => RowModel<TData>\n  /**\n   * Returns whether there are any rows that can be expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getcansomerowsexpand)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getCanSomeRowsExpand: () => boolean\n  /**\n   * Returns the maximum depth of the expanded rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getexpandeddepth)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getExpandedDepth: () => number\n  /**\n   * Returns the row model after expansion has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getexpandedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getExpandedRowModel: () => RowModel<TData>\n  /**\n   * Returns whether all rows are currently expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getisallrowsexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getIsAllRowsExpanded: () => boolean\n  /**\n   * Returns whether there are any rows that are currently expanded.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getissomerowsexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getIsSomeRowsExpanded: () => boolean\n  /**\n   * Returns the row model before expansion has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#getpreexpandedrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getPreExpandedRowModel: () => RowModel<TData>\n  /**\n   * Returns a handler that can be used to toggle the expanded state of all rows. This handler is meant to be used with an `input[type=checkbox]` element.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#gettoggleallrowsexpandedhandler)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  getToggleAllRowsExpandedHandler: () => (event: unknown) => void\n  /**\n   * Resets the expanded state of the table to the initial state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#resetexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  resetExpanded: (defaultState?: boolean) => void\n  /**\n   * Updates the expanded state of the table via an update function or value.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#setexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  setExpanded: (updater: Updater<ExpandedState>) => void\n  /**\n   * Toggles the expanded state for all rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/expanding#toggleallrowsexpanded)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/expanding)\n   */\n  toggleAllRowsExpanded: (expanded?: boolean) => void\n}\n\n//\n\nexport const RowExpanding: TableFeature = {\n  getInitialState: (state): ExpandedTableState => {\n    return {\n      expanded: {},\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): ExpandedOptions<TData> => {\n    return {\n      onExpandedChange: makeStateUpdater('expanded', table),\n      paginateExpandedRows: true,\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    let registered = false\n    let queued = false\n\n    table._autoResetExpanded = () => {\n      if (!registered) {\n        table._queue(() => {\n          registered = true\n        })\n        return\n      }\n\n      if (\n        table.options.autoResetAll ??\n        table.options.autoResetExpanded ??\n        !table.options.manualExpanding\n      ) {\n        if (queued) return\n        queued = true\n        table._queue(() => {\n          table.resetExpanded()\n          queued = false\n        })\n      }\n    }\n    table.setExpanded = updater => table.options.onExpandedChange?.(updater)\n    table.toggleAllRowsExpanded = expanded => {\n      if (expanded ?? !table.getIsAllRowsExpanded()) {\n        table.setExpanded(true)\n      } else {\n        table.setExpanded({})\n      }\n    }\n    table.resetExpanded = defaultState => {\n      table.setExpanded(defaultState ? {} : table.initialState?.expanded ?? {})\n    }\n    table.getCanSomeRowsExpand = () => {\n      return table\n        .getPrePaginationRowModel()\n        .flatRows.some(row => row.getCanExpand())\n    }\n    table.getToggleAllRowsExpandedHandler = () => {\n      return (e: unknown) => {\n        ;(e as any).persist?.()\n        table.toggleAllRowsExpanded()\n      }\n    }\n    table.getIsSomeRowsExpanded = () => {\n      const expanded = table.getState().expanded\n      return expanded === true || Object.values(expanded).some(Boolean)\n    }\n    table.getIsAllRowsExpanded = () => {\n      const expanded = table.getState().expanded\n\n      // If expanded is true, save some cycles and return true\n      if (typeof expanded === 'boolean') {\n        return expanded === true\n      }\n\n      if (!Object.keys(expanded).length) {\n        return false\n      }\n\n      // If any row is not expanded, return false\n      if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) {\n        return false\n      }\n\n      // They must all be expanded :shrug:\n      return true\n    }\n    table.getExpandedDepth = () => {\n      let maxDepth = 0\n\n      const rowIds =\n        table.getState().expanded === true\n          ? Object.keys(table.getRowModel().rowsById)\n          : Object.keys(table.getState().expanded)\n\n      rowIds.forEach(id => {\n        const splitId = id.split('.')\n        maxDepth = Math.max(maxDepth, splitId.length)\n      })\n\n      return maxDepth\n    }\n    table.getPreExpandedRowModel = () => table.getSortedRowModel()\n    table.getExpandedRowModel = () => {\n      if (!table._getExpandedRowModel && table.options.getExpandedRowModel) {\n        table._getExpandedRowModel = table.options.getExpandedRowModel(table)\n      }\n\n      if (table.options.manualExpanding || !table._getExpandedRowModel) {\n        return table.getPreExpandedRowModel()\n      }\n\n      return table._getExpandedRowModel()\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row.toggleExpanded = expanded => {\n      table.setExpanded(old => {\n        const exists = old === true ? true : !!old?.[row.id]\n\n        let oldExpanded: ExpandedStateList = {}\n\n        if (old === true) {\n          Object.keys(table.getRowModel().rowsById).forEach(rowId => {\n            oldExpanded[rowId] = true\n          })\n        } else {\n          oldExpanded = old\n        }\n\n        expanded = expanded ?? !exists\n\n        if (!exists && expanded) {\n          return {\n            ...oldExpanded,\n            [row.id]: true,\n          }\n        }\n\n        if (exists && !expanded) {\n          const { [row.id]: _, ...rest } = oldExpanded\n          return rest\n        }\n\n        return old\n      })\n    }\n    row.getIsExpanded = () => {\n      const expanded = table.getState().expanded\n\n      return !!(\n        table.options.getIsRowExpanded?.(row) ??\n        (expanded === true || expanded?.[row.id])\n      )\n    }\n    row.getCanExpand = () => {\n      return (\n        table.options.getRowCanExpand?.(row) ??\n        ((table.options.enableExpanding ?? true) && !!row.subRows?.length)\n      )\n    }\n    row.getIsAllParentsExpanded = () => {\n      let isFullyExpanded = true\n      let currentRow = row\n\n      while (isFullyExpanded && currentRow.parentId) {\n        currentRow = table.getRow(currentRow.parentId, true)\n        isFullyExpanded = currentRow.getIsExpanded()\n      }\n\n      return isFullyExpanded\n    }\n    row.getToggleExpandedHandler = () => {\n      const canExpand = row.getCanExpand()\n\n      return () => {\n        if (!canExpand) return\n        row.toggleExpanded()\n      }\n    }\n  },\n}\n","import {\n  OnChangeFn,\n  Table,\n  RowModel,\n  Updater,\n  RowData,\n  TableFeature,\n} from '../types'\nimport {\n  functionalUpdate,\n  getMemoOptions,\n  makeStateUpdater,\n  memo,\n} from '../utils'\n\nexport interface PaginationState {\n  pageIndex: number\n  pageSize: number\n}\n\nexport interface PaginationTableState {\n  pagination: PaginationState\n}\n\nexport interface PaginationInitialTableState {\n  pagination?: Partial<PaginationState>\n}\n\nexport interface PaginationOptions {\n  /**\n   * If set to `true`, pagination will be reset to the first page when page-altering state changes eg. `data` is updated, filters change, grouping changes, etc.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#autoresetpageindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  autoResetPageIndex?: boolean\n  /**\n   * Returns the row model after pagination has taken place, but no further.\n   *\n   * Pagination columns are automatically reordered by default to the start of the columns list. If you would rather remove them or leave them as-is, set the appropriate mode here.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getpaginationrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getPaginationRowModel?: (table: Table<any>) => () => RowModel<any>\n  /**\n   * Enables manual pagination. If this option is set to `true`, the table will not automatically paginate rows using `getPaginationRowModel()` and instead will expect you to manually paginate the rows before passing them to the table. This is useful if you are doing server-side pagination and aggregation.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#manualpagination)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  manualPagination?: boolean\n  /**\n   * If this function is provided, it will be called when the pagination state changes and you will be expected to manage the state yourself. You can pass the managed state back to the table via the `tableOptions.state.pagination` option.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#onpaginationchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  onPaginationChange?: OnChangeFn<PaginationState>\n  /**\n   * When manually controlling pagination, you can supply a total `pageCount` value to the table if you know it (Or supply a `rowCount` and `pageCount` will be calculated). If you do not know how many pages there are, you can set this to `-1`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#pagecount)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  pageCount?: number\n  /**\n   * When manually controlling pagination, you can supply a total `rowCount` value to the table if you know it. The `pageCount` can be calculated from this value and the `pageSize`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#rowcount)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  rowCount?: number\n}\n\nexport interface PaginationDefaultOptions {\n  onPaginationChange: OnChangeFn<PaginationState>\n}\n\nexport interface PaginationInstance<TData extends RowData> {\n  _autoResetPageIndex: () => void\n  _getPaginationRowModel?: () => RowModel<TData>\n  /**\n   * Returns whether the table can go to the next page.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getcannextpage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getCanNextPage: () => boolean\n  /**\n   * Returns whether the table can go to the previous page.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getcanpreviouspage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getCanPreviousPage: () => boolean\n  /**\n   * Returns the page count. If manually paginating or controlling the pagination state, this will come directly from the `options.pageCount` table option, otherwise it will be calculated from the table data using the total row count and current page size.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getpagecount)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getPageCount: () => number\n  /**\n   * Returns the row count. If manually paginating or controlling the pagination state, this will come directly from the `options.rowCount` table option, otherwise it will be calculated from the table data.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getrowcount)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getRowCount: () => number\n  /**\n   * Returns an array of page options (zero-index-based) for the current page size.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getpageoptions)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getPageOptions: () => number[]\n  /**\n   * Returns the row model for the table after pagination has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getpaginationrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getPaginationRowModel: () => RowModel<TData>\n  /**\n   * Returns the row model for the table before any pagination has been applied.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#getprepaginationrowmodel)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  getPrePaginationRowModel: () => RowModel<TData>\n  /**\n   * Increments the page index by one, if possible.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#nextpage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  nextPage: () => void\n  /**\n   * Decrements the page index by one, if possible.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#previouspage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  previousPage: () => void\n  /**\n   * Sets the page index to `0`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#firstpage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  firstPage: () => void\n  /**\n   * Sets the page index to the last page.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#lastpage)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  lastPage: () => void\n  /**\n   * Resets the page index to its initial state. If `defaultState` is `true`, the page index will be reset to `0` regardless of initial state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#resetpageindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  resetPageIndex: (defaultState?: boolean) => void\n  /**\n   * Resets the page size to its initial state. If `defaultState` is `true`, the page size will be reset to `10` regardless of initial state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#resetpagesize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  resetPageSize: (defaultState?: boolean) => void\n  /**\n   * Resets the **pagination** state to `initialState.pagination`, or `true` can be passed to force a default blank state reset to `[]`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#resetpagination)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  resetPagination: (defaultState?: boolean) => void\n  /**\n   * @deprecated The page count no longer exists in the pagination state. Just pass as a table option instead.\n   */\n  setPageCount: (updater: Updater<number>) => void\n  /**\n   * Updates the page index using the provided function or value in the `state.pagination.pageIndex` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#setpageindex)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  setPageIndex: (updater: Updater<number>) => void\n  /**\n   * Updates the page size using the provided function or value in the `state.pagination.pageSize` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#setpagesize)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  setPageSize: (updater: Updater<number>) => void\n  /**\n   * Sets or updates the `state.pagination` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/pagination#setpagination)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/pagination)\n   */\n  setPagination: (updater: Updater<PaginationState>) => void\n}\n\n//\n\nconst defaultPageIndex = 0\nconst defaultPageSize = 10\n\nconst getDefaultPaginationState = (): PaginationState => ({\n  pageIndex: defaultPageIndex,\n  pageSize: defaultPageSize,\n})\n\nexport const RowPagination: TableFeature = {\n  getInitialState: (state): PaginationTableState => {\n    return {\n      ...state,\n      pagination: {\n        ...getDefaultPaginationState(),\n        ...state?.pagination,\n      },\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): PaginationDefaultOptions => {\n    return {\n      onPaginationChange: makeStateUpdater('pagination', table),\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    let registered = false\n    let queued = false\n\n    table._autoResetPageIndex = () => {\n      if (!registered) {\n        table._queue(() => {\n          registered = true\n        })\n        return\n      }\n\n      if (\n        table.options.autoResetAll ??\n        table.options.autoResetPageIndex ??\n        !table.options.manualPagination\n      ) {\n        if (queued) return\n        queued = true\n        table._queue(() => {\n          table.resetPageIndex()\n          queued = false\n        })\n      }\n    }\n    table.setPagination = updater => {\n      const safeUpdater: Updater<PaginationState> = old => {\n        let newState = functionalUpdate(updater, old)\n\n        return newState\n      }\n\n      return table.options.onPaginationChange?.(safeUpdater)\n    }\n    table.resetPagination = defaultState => {\n      table.setPagination(\n        defaultState\n          ? getDefaultPaginationState()\n          : table.initialState.pagination ?? getDefaultPaginationState()\n      )\n    }\n    table.setPageIndex = updater => {\n      table.setPagination(old => {\n        let pageIndex = functionalUpdate(updater, old.pageIndex)\n\n        const maxPageIndex =\n          typeof table.options.pageCount === 'undefined' ||\n          table.options.pageCount === -1\n            ? Number.MAX_SAFE_INTEGER\n            : table.options.pageCount - 1\n\n        pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex))\n\n        return {\n          ...old,\n          pageIndex,\n        }\n      })\n    }\n    table.resetPageIndex = defaultState => {\n      table.setPageIndex(\n        defaultState\n          ? defaultPageIndex\n          : table.initialState?.pagination?.pageIndex ?? defaultPageIndex\n      )\n    }\n    table.resetPageSize = defaultState => {\n      table.setPageSize(\n        defaultState\n          ? defaultPageSize\n          : table.initialState?.pagination?.pageSize ?? defaultPageSize\n      )\n    }\n    table.setPageSize = updater => {\n      table.setPagination(old => {\n        const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize))\n        const topRowIndex = old.pageSize * old.pageIndex!\n        const pageIndex = Math.floor(topRowIndex / pageSize)\n\n        return {\n          ...old,\n          pageIndex,\n          pageSize,\n        }\n      })\n    }\n    //deprecated\n    table.setPageCount = updater =>\n      table.setPagination(old => {\n        let newPageCount = functionalUpdate(\n          updater,\n          table.options.pageCount ?? -1\n        )\n\n        if (typeof newPageCount === 'number') {\n          newPageCount = Math.max(-1, newPageCount)\n        }\n\n        return {\n          ...old,\n          pageCount: newPageCount,\n        }\n      })\n\n    table.getPageOptions = memo(\n      () => [table.getPageCount()],\n      pageCount => {\n        let pageOptions: number[] = []\n        if (pageCount && pageCount > 0) {\n          pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i)\n        }\n        return pageOptions\n      },\n      getMemoOptions(table.options, 'debugTable', 'getPageOptions')\n    )\n\n    table.getCanPreviousPage = () => table.getState().pagination.pageIndex > 0\n\n    table.getCanNextPage = () => {\n      const { pageIndex } = table.getState().pagination\n\n      const pageCount = table.getPageCount()\n\n      if (pageCount === -1) {\n        return true\n      }\n\n      if (pageCount === 0) {\n        return false\n      }\n\n      return pageIndex < pageCount - 1\n    }\n\n    table.previousPage = () => {\n      return table.setPageIndex(old => old - 1)\n    }\n\n    table.nextPage = () => {\n      return table.setPageIndex(old => {\n        return old + 1\n      })\n    }\n\n    table.firstPage = () => {\n      return table.setPageIndex(0)\n    }\n\n    table.lastPage = () => {\n      return table.setPageIndex(table.getPageCount() - 1)\n    }\n\n    table.getPrePaginationRowModel = () => table.getExpandedRowModel()\n    table.getPaginationRowModel = () => {\n      if (\n        !table._getPaginationRowModel &&\n        table.options.getPaginationRowModel\n      ) {\n        table._getPaginationRowModel =\n          table.options.getPaginationRowModel(table)\n      }\n\n      if (table.options.manualPagination || !table._getPaginationRowModel) {\n        return table.getPrePaginationRowModel()\n      }\n\n      return table._getPaginationRowModel()\n    }\n\n    table.getPageCount = () => {\n      return (\n        table.options.pageCount ??\n        Math.ceil(table.getRowCount() / table.getState().pagination.pageSize)\n      )\n    }\n\n    table.getRowCount = () => {\n      return (\n        table.options.rowCount ?? table.getPrePaginationRowModel().rows.length\n      )\n    }\n  },\n}\n","import {\n  OnChangeFn,\n  Updater,\n  Table,\n  Row,\n  RowData,\n  TableFeature,\n} from '../types'\nimport { getMemoOptions, makeStateUpdater, memo } from '../utils'\n\nexport type RowPinningPosition = false | 'top' | 'bottom'\n\nexport interface RowPinningState {\n  bottom?: string[]\n  top?: string[]\n}\n\nexport interface RowPinningTableState {\n  rowPinning: RowPinningState\n}\n\nexport interface RowPinningOptions<TData extends RowData> {\n  /**\n   * Enables/disables row pinning for the table. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#enablerowpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  enableRowPinning?: boolean | ((row: Row<TData>) => boolean)\n  /**\n   * When `false`, pinned rows will not be visible if they are filtered or paginated out of the table. When `true`, pinned rows will always be visible regardless of filtering or pagination. Defaults to `true`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#keeppinnedrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  keepPinnedRows?: boolean\n  /**\n   * If provided, this function will be called with an `updaterFn` when `state.rowPinning` changes. This overrides the default internal state management, so you will also need to supply `state.rowPinning` from your own managed state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#onrowpinningchange)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/onrowpinningchange)\n   */\n  onRowPinningChange?: OnChangeFn<RowPinningState>\n}\n\nexport interface RowPinningDefaultOptions {\n  onRowPinningChange: OnChangeFn<RowPinningState>\n}\n\nexport interface RowPinningRow {\n  /**\n   * Returns whether or not the row can be pinned.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getcanpin-1)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getCanPin: () => boolean\n  /**\n   * Returns the pinned position of the row. (`'top'`, `'bottom'` or `false`)\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getispinned-1)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getIsPinned: () => RowPinningPosition\n  /**\n   * Returns the numeric pinned index of the row within a pinned row group.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getpinnedindex-1)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getPinnedIndex: () => number\n  /**\n   * Pins a row to the `'top'` or `'bottom'`, or unpins the row to the center if `false` is passed.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#pin-1)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  pin: (\n    position: RowPinningPosition,\n    includeLeafRows?: boolean,\n    includeParentRows?: boolean\n  ) => void\n}\n\nexport interface RowPinningInstance<TData extends RowData> {\n  _getPinnedRows: (\n    visiblePinnedRows: Array<Row<TData>>,\n    pinnedRowIds: Array<string> | undefined,\n    position: 'top' | 'bottom'\n  ) => Row<TData>[]\n  /**\n   * Returns all bottom pinned rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getbottomrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getBottomRows: () => Row<TData>[]\n  /**\n   * Returns all rows that are not pinned to the top or bottom.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getcenterrows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getCenterRows: () => Row<TData>[]\n  /**\n   * Returns whether or not any rows are pinned. Optionally specify to only check for pinned rows in either the `top` or `bottom` position.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#getissomerowspinned)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getIsSomeRowsPinned: (position?: RowPinningPosition) => boolean\n  /**\n   * Returns all top pinned rows.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#gettoprows)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  getTopRows: () => Row<TData>[]\n  /**\n   * Resets the **rowPinning** state to `initialState.rowPinning`, or `true` can be passed to force a default blank state reset to `{ top: [], bottom: [], }`.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#resetrowpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  resetRowPinning: (defaultState?: boolean) => void\n  /**\n   * Sets or updates the `state.rowPinning` state.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/features/row-pinning#setrowpinning)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/row-pinning)\n   */\n  setRowPinning: (updater: Updater<RowPinningState>) => void\n}\n\n//\n\nconst getDefaultRowPinningState = (): RowPinningState => ({\n  top: [],\n  bottom: [],\n})\n\nexport const RowPinning: TableFeature = {\n  getInitialState: (state): RowPinningTableState => {\n    return {\n      rowPinning: getDefaultRowPinningState(),\n      ...state,\n    }\n  },\n\n  getDefaultOptions: <TData extends RowData>(\n    table: Table<TData>\n  ): RowPinningDefaultOptions => {\n    return {\n      onRowPinningChange: makeStateUpdater('rowPinning', table),\n    }\n  },\n\n  createRow: <TData extends RowData>(\n    row: Row<TData>,\n    table: Table<TData>\n  ): void => {\n    row.pin = (position, includeLeafRows, includeParentRows) => {\n      const leafRowIds = includeLeafRows\n        ? row.getLeafRows().map(({ id }) => id)\n        : []\n      const parentRowIds = includeParentRows\n        ? row.getParentRows().map(({ id }) => id)\n        : []\n      const rowIds = new Set([...parentRowIds, row.id, ...leafRowIds])\n\n      table.setRowPinning(old => {\n        if (position === 'bottom') {\n          return {\n            top: (old?.top ?? []).filter(d => !rowIds?.has(d)),\n            bottom: [\n              ...(old?.bottom ?? []).filter(d => !rowIds?.has(d)),\n              ...Array.from(rowIds),\n            ],\n          }\n        }\n\n        if (position === 'top') {\n          return {\n            top: [\n              ...(old?.top ?? []).filter(d => !rowIds?.has(d)),\n              ...Array.from(rowIds),\n            ],\n            bottom: (old?.bottom ?? []).filter(d => !rowIds?.has(d)),\n          }\n        }\n\n        return {\n          top: (old?.top ?? []).filter(d => !rowIds?.has(d)),\n          bottom: (old?.bottom ?? []).filter(d => !rowIds?.has(d)),\n        }\n      })\n    }\n    row.getCanPin = () => {\n      const { enableRowPinning, enablePinning } = table.options\n      if (typeof enableRowPinning === 'function') {\n        return enableRowPinning(row)\n      }\n      return enableRowPinning ?? enablePinning ?? true\n    }\n    row.getIsPinned = () => {\n      const rowIds = [row.id]\n\n      const { top, bottom } = table.getState().rowPinning\n\n      const isTop = rowIds.some(d => top?.includes(d))\n      const isBottom = rowIds.some(d => bottom?.includes(d))\n\n      return isTop ? 'top' : isBottom ? 'bottom' : false\n    }\n    row.getPinnedIndex = () => {\n      const position = row.getIsPinned()\n      if (!position) return -1\n\n      const visiblePinnedRowIds = (\n        position === 'top' ? table.getTopRows() : table.getBottomRows()\n      )?.map(({ id }) => id)\n\n      return visiblePinnedRowIds?.indexOf(row.id) ?? -1\n    }\n  },\n\n  createTable: <TData extends RowData>(table: Table<TData>): void => {\n    table.setRowPinning = updater => table.options.onRowPinningChange?.(updater)\n\n    table.resetRowPinning = defaultState =>\n      table.setRowPinning(\n        defaultState\n          ? getDefaultRowPinningState()\n          : table.initialState?.rowPinning ?? getDefaultRowPinningState()\n      )\n\n    table.getIsSomeRowsPinned = position => {\n      const pinningState = table.getState().rowPinning\n\n      if (!position) {\n        return Boolean(pinningState.top?.length || pinningState.bottom?.length)\n      }\n      return Boolean(pinningState[position]?.length)\n    }\n\n    table._getPinnedRows = (visibleRows, pinnedRowIds, position) => {\n      const rows =\n        table.options.keepPinnedRows ?? true\n          ? //get all rows that are pinned even if they would not be otherwise visible\n            //account for expanded parent rows, but not pagination or filtering\n            (pinnedRowIds ?? []).map(rowId => {\n              const row = table.getRow(rowId, true)\n              return row.getIsAllParentsExpanded() ? row : null\n            })\n          : //else get only visible rows that are pinned\n            (pinnedRowIds ?? []).map(\n              rowId => visibleRows.find(row => row.id === rowId)!\n            )\n\n      return rows.filter(Boolean).map(d => ({ ...d, position })) as Row<TData>[]\n    }\n\n    table.getTopRows = memo(\n      () => [table.getRowModel().rows, table.getState().rowPinning.top],\n      (allRows, topPinnedRowIds) =>\n        table._getPinnedRows(allRows, topPinnedRowIds, 'top'),\n      getMemoOptions(table.options, 'debugRows', 'getTopRows')\n    )\n\n    table.getBottomRows = memo(\n      () => [table.getRowModel().rows, table.getState().rowPinning.bottom],\n      (allRows, bottomPinnedRowIds) =>\n        table._getPinnedRows(allRows, bottomPinnedRowIds, 'bottom'),\n      getMemoOptions(table.options, 'debugRows', 'getBottomRows')\n    )\n\n    table.getCenterRows = memo(\n      () => [\n        table.getRowModel().rows,\n        table.getState().rowPinning.top,\n        table.getState().rowPinning.bottom,\n      ],\n      (allRows, top, bottom) => {\n        const topAndBottom = new Set([...(top ?? []), ...(bottom ?? [])])\n        return allRows.filter(d => !topAndBottom.has(d.id))\n      },\n      getMemoOptions(table.options, 'debugRows', 'getCenterRows')\n    )\n  },\n}\n","import {\n  Column,\n  Table,\n  AccessorFn,\n  ColumnDef,\n  RowData,\n  ColumnDefResolved,\n} from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nexport interface CoreColumn<TData extends RowData, TValue> {\n  /**\n   * The resolved accessor function to use when extracting the value for the column from each row. Will only be defined if the column def has a valid accessor key or function defined.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#accessorfn)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  accessorFn?: AccessorFn<TData, TValue>\n  /**\n   * The original column def used to create the column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#columndef)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  columnDef: ColumnDef<TData, TValue>\n  /**\n   * The child column (if the column is a group column). Will be an empty array if the column is not a group column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#columns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  columns: Column<TData, TValue>[]\n  /**\n   * The depth of the column (if grouped) relative to the root column def array.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#depth)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  depth: number\n  /**\n   * Returns the flattened array of this column and all child/grand-child columns for this column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#getflatcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  getFlatColumns: () => Column<TData, TValue>[]\n  /**\n   * Returns an array of all leaf-node columns for this column. If a column has no children, it is considered the only leaf-node column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#getleafcolumns)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  getLeafColumns: () => Column<TData, TValue>[]\n  /**\n   * The resolved unique identifier for the column resolved in this priority:\n      - A manual `id` property from the column def\n      - The accessor key from the column def\n      - The header string from the column def\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#id)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  id: string\n  /**\n   * The parent column for this column. Will be undefined if this is a root column.\n   * @link [API Docs](https://tanstack.com/table/v8/docs/api/core/column#parent)\n   * @link [Guide](https://tanstack.com/table/v8/docs/guide/column-defs)\n   */\n  parent?: Column<TData, TValue>\n}\n\nexport function createColumn<TData extends RowData, TValue>(\n  table: Table<TData>,\n  columnDef: ColumnDef<TData, TValue>,\n  depth: number,\n  parent?: Column<TData, TValue>\n): Column<TData, TValue> {\n  const defaultColumn = table._getDefaultColumnDef()\n\n  const resolvedColumnDef = {\n    ...defaultColumn,\n    ...columnDef,\n  } as ColumnDefResolved<TData>\n\n  const accessorKey = resolvedColumnDef.accessorKey\n\n  let id =\n    resolvedColumnDef.id ??\n    (accessorKey\n      ? typeof String.prototype.replaceAll === 'function'\n        ? accessorKey.replaceAll('.', '_')\n        : accessorKey.replace(/\\./g, '_')\n      : undefined) ??\n    (typeof resolvedColumnDef.header === 'string'\n      ? resolvedColumnDef.header\n      : undefined)\n\n  let accessorFn: AccessorFn<TData> | undefined\n\n  if (resolvedColumnDef.accessorFn) {\n    accessorFn = resolvedColumnDef.accessorFn\n  } else if (accessorKey) {\n    // Support deep accessor keys\n    if (accessorKey.includes('.')) {\n      accessorFn = (originalRow: TData) => {\n        let result = originalRow as Record<string, any>\n\n        for (const key of accessorKey.split('.')) {\n          result = result?.[key]\n          if (process.env.NODE_ENV !== 'production' && result === undefined) {\n            console.warn(\n              `\"${key}\" in deeply nested key \"${accessorKey}\" returned undefined.`\n            )\n          }\n        }\n\n        return result\n      }\n    } else {\n      accessorFn = (originalRow: TData) =>\n        (originalRow as any)[resolvedColumnDef.accessorKey]\n    }\n  }\n\n  if (!id) {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error(\n        resolvedColumnDef.accessorFn\n          ? `Columns require an id when using an accessorFn`\n          : `Columns require an id when using a non-string header`\n      )\n    }\n    throw new Error()\n  }\n\n  let column: CoreColumn<TData, any> = {\n    id: `${String(id)}`,\n    accessorFn,\n    parent: parent as any,\n    depth,\n    columnDef: resolvedColumnDef as ColumnDef<TData, any>,\n    columns: [],\n    getFlatColumns: memo(\n      () => [true],\n      () => {\n        return [\n          column as Column<TData, TValue>,\n          ...column.columns?.flatMap(d => d.getFlatColumns()),\n        ]\n      },\n      getMemoOptions(table.options, 'debugColumns', 'column.getFlatColumns')\n    ),\n    getLeafColumns: memo(\n      () => [table._getOrderColumnsFn()],\n      orderColumns => {\n        if (column.columns?.length) {\n          let leafColumns = column.columns.flatMap(column =>\n            column.getLeafColumns()\n          )\n\n          return orderColumns(leafColumns)\n        }\n\n        return [column as Column<TData, TValue>]\n      },\n      getMemoOptions(table.options, 'debugColumns', 'column.getLeafColumns')\n    ),\n  }\n\n  for (const feature of table._features) {\n    feature.createColumn?.(column as Column<TData, TValue>, table)\n  }\n\n  // Yes, we have to convert table to unknown, because we know more than the compiler here.\n  return column as Column<TData, TValue>\n}\n","import { createRow } from '../core/row'\nimport { Table, Row, RowModel, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nexport function getCoreRowModel<TData extends RowData>(): (\n  table: Table<TData>\n) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [table.options.data],\n      (\n        data\n      ): {\n        rows: Row<TData>[]\n        flatRows: Row<TData>[]\n        rowsById: Record<string, Row<TData>>\n      } => {\n        const rowModel: RowModel<TData> = {\n          rows: [],\n          flatRows: [],\n          rowsById: {},\n        }\n\n        const accessRows = (\n          originalRows: TData[],\n          depth = 0,\n          parentRow?: Row<TData>\n        ): Row<TData>[] => {\n          const rows = [] as Row<TData>[]\n\n          for (let i = 0; i < originalRows.length; i++) {\n            // This could be an expensive check at scale, so we should move it somewhere else, but where?\n            // if (!id) {\n            //   if (process.env.NODE_ENV !== 'production') {\n            //     throw new Error(`getRowId expected an ID, but got ${id}`)\n            //   }\n            // }\n\n            // Make the row\n            const row = createRow(\n              table,\n              table._getRowId(originalRows[i]!, i, parentRow),\n              originalRows[i]!,\n              i,\n              depth,\n              undefined,\n              parentRow?.id\n            )\n\n            // Keep track of every row in a flat array\n            rowModel.flatRows.push(row)\n            // Also keep track of every row by its ID\n            rowModel.rowsById[row.id] = row\n            // Push table row into parent\n            rows.push(row)\n\n            // Get the original subrows\n            if (table.options.getSubRows) {\n              row.originalSubRows = table.options.getSubRows(\n                originalRows[i]!,\n                i\n              )\n\n              // Then recursively access them\n              if (row.originalSubRows?.length) {\n                row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n              }\n            }\n          }\n\n          return rows\n        }\n\n        rowModel.rows = accessRows(data)\n\n        return rowModel\n      },\n      getMemoOptions(table.options, 'debugTable', 'getRowModel', () =>\n        table._autoResetPageIndex()\n      )\n    )\n}\n","import { Table, Row, RowModel, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nexport function getExpandedRowModel<TData extends RowData>(): (\n  table: Table<TData>\n) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [\n        table.getState().expanded,\n        table.getPreExpandedRowModel(),\n        table.options.paginateExpandedRows,\n      ],\n      (expanded, rowModel, paginateExpandedRows) => {\n        if (\n          !rowModel.rows.length ||\n          (expanded !== true && !Object.keys(expanded ?? {}).length)\n        ) {\n          return rowModel\n        }\n\n        if (!paginateExpandedRows) {\n          // Only expand rows at this point if they are being paginated\n          return rowModel\n        }\n\n        return expandRows(rowModel)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getExpandedRowModel')\n    )\n}\n\nexport function expandRows<TData extends RowData>(rowModel: RowModel<TData>) {\n  const expandedRows: Row<TData>[] = []\n\n  const handleRow = (row: Row<TData>) => {\n    expandedRows.push(row)\n\n    if (row.subRows?.length && row.getIsExpanded()) {\n      row.subRows.forEach(handleRow)\n    }\n  }\n\n  rowModel.rows.forEach(handleRow)\n\n  return {\n    rows: expandedRows,\n    flatRows: rowModel.flatRows,\n    rowsById: rowModel.rowsById,\n  }\n}\n","import { Table, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nexport function getFacetedMinMaxValues<TData extends RowData>(): (\n  table: Table<TData>,\n  columnId: string\n) => () => undefined | [number, number] {\n  return (table, columnId) =>\n    memo(\n      () => [table.getColumn(columnId)?.getFacetedRowModel()],\n      facetedRowModel => {\n        if (!facetedRowModel) return undefined\n\n        const uniqueValues = facetedRowModel.flatRows\n          .flatMap(flatRow => flatRow.getUniqueValues(columnId) ?? [])\n          .map(Number)\n          .filter(value => !Number.isNaN(value))\n\n        if (!uniqueValues.length) return\n\n        let facetedMinValue = uniqueValues[0]!\n        let facetedMaxValue = uniqueValues[uniqueValues.length - 1]!\n\n        for (const value of uniqueValues) {\n          if (value < facetedMinValue) facetedMinValue = value\n          else if (value > facetedMaxValue) facetedMaxValue = value\n        }\n\n        return [facetedMinValue, facetedMaxValue]\n      },\n      getMemoOptions(table.options, 'debugTable', 'getFacetedMinMaxValues')\n    )\n}\n","import { createRow } from '../core/row'\nimport { Row, RowModel, Table, RowData } from '../types'\n\nexport function filterRows<TData extends RowData>(\n  rows: Row<TData>[],\n  filterRowImpl: (row: Row<TData>) => any,\n  table: Table<TData>\n) {\n  if (table.options.filterFromLeafRows) {\n    return filterRowModelFromLeafs(rows, filterRowImpl, table)\n  }\n\n  return filterRowModelFromRoot(rows, filterRowImpl, table)\n}\n\nfunction filterRowModelFromLeafs<TData extends RowData>(\n  rowsToFilter: Row<TData>[],\n  filterRow: (row: Row<TData>) => Row<TData>[],\n  table: Table<TData>\n): RowModel<TData> {\n  const newFilteredFlatRows: Row<TData>[] = []\n  const newFilteredRowsById: Record<string, Row<TData>> = {}\n  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100\n\n  const recurseFilterRows = (rowsToFilter: Row<TData>[], depth = 0) => {\n    const rows: Row<TData>[] = []\n\n    // Filter from children up first\n    for (let i = 0; i < rowsToFilter.length; i++) {\n      let row = rowsToFilter[i]!\n\n      const newRow = createRow(\n        table,\n        row.id,\n        row.original,\n        row.index,\n        row.depth,\n        undefined,\n        row.parentId\n      )\n      newRow.columnFilters = row.columnFilters\n\n      if (row.subRows?.length && depth < maxDepth) {\n        newRow.subRows = recurseFilterRows(row.subRows, depth + 1)\n        row = newRow\n\n        if (filterRow(row) && !newRow.subRows.length) {\n          rows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n          continue\n        }\n\n        if (filterRow(row) || newRow.subRows.length) {\n          rows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n          continue\n        }\n      } else {\n        row = newRow\n        if (filterRow(row)) {\n          rows.push(row)\n          newFilteredRowsById[row.id] = row\n          newFilteredFlatRows.push(row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  return {\n    rows: recurseFilterRows(rowsToFilter),\n    flatRows: newFilteredFlatRows,\n    rowsById: newFilteredRowsById,\n  }\n}\n\nfunction filterRowModelFromRoot<TData extends RowData>(\n  rowsToFilter: Row<TData>[],\n  filterRow: (row: Row<TData>) => any,\n  table: Table<TData>\n): RowModel<TData> {\n  const newFilteredFlatRows: Row<TData>[] = []\n  const newFilteredRowsById: Record<string, Row<TData>> = {}\n  const maxDepth = table.options.maxLeafRowFilterDepth ?? 100\n\n  // Filters top level and nested rows\n  const recurseFilterRows = (rowsToFilter: Row<TData>[], depth = 0) => {\n    // Filter from parents downward first\n\n    const rows: Row<TData>[] = []\n\n    // Apply the filter to any subRows\n    for (let i = 0; i < rowsToFilter.length; i++) {\n      let row = rowsToFilter[i]!\n\n      const pass = filterRow(row)\n\n      if (pass) {\n        if (row.subRows?.length && depth < maxDepth) {\n          const newRow = createRow(\n            table,\n            row.id,\n            row.original,\n            row.index,\n            row.depth,\n            undefined,\n            row.parentId\n          )\n          newRow.subRows = recurseFilterRows(row.subRows, depth + 1)\n          row = newRow\n        }\n\n        rows.push(row)\n        newFilteredFlatRows.push(row)\n        newFilteredRowsById[row.id] = row\n      }\n    }\n\n    return rows\n  }\n\n  return {\n    rows: recurseFilterRows(rowsToFilter),\n    flatRows: newFilteredFlatRows,\n    rowsById: newFilteredRowsById,\n  }\n}\n","import { Table, RowModel, Row, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\nimport { filterRows } from './filterRowsUtils'\n\nexport function getFacetedRowModel<TData extends RowData>(): (\n  table: Table<TData>,\n  columnId: string\n) => () => RowModel<TData> {\n  return (table, columnId) =>\n    memo(\n      () => [\n        table.getPreFilteredRowModel(),\n        table.getState().columnFilters,\n        table.getState().globalFilter,\n        table.getFilteredRowModel(),\n      ],\n      (preRowModel, columnFilters, globalFilter) => {\n        if (\n          !preRowModel.rows.length ||\n          (!columnFilters?.length && !globalFilter)\n        ) {\n          return preRowModel\n        }\n\n        const filterableIds = [\n          ...columnFilters.map(d => d.id).filter(d => d !== columnId),\n          globalFilter ? '__global__' : undefined,\n        ].filter(Boolean) as string[]\n\n        const filterRowsImpl = (row: Row<TData>) => {\n          // Horizontally filter rows through each column\n          for (let i = 0; i < filterableIds.length; i++) {\n            if (row.columnFilters[filterableIds[i]!] === false) {\n              return false\n            }\n          }\n          return true\n        }\n\n        return filterRows(preRowModel.rows, filterRowsImpl, table)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getFacetedRowModel')\n    )\n}\n","import { Table, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\n\nexport function getFacetedUniqueValues<TData extends RowData>(): (\n  table: Table<TData>,\n  columnId: string\n) => () => Map<any, number> {\n  return (table, columnId) =>\n    memo(\n      () => [table.getColumn(columnId)?.getFacetedRowModel()],\n      facetedRowModel => {\n        if (!facetedRowModel) return new Map()\n\n        let facetedUniqueValues = new Map<any, number>()\n\n        for (let i = 0; i < facetedRowModel.flatRows.length; i++) {\n          const values =\n            facetedRowModel.flatRows[i]!.getUniqueValues<number>(columnId)\n\n          for (let j = 0; j < values.length; j++) {\n            const value = values[j]!\n\n            if (facetedUniqueValues.has(value)) {\n              facetedUniqueValues.set(\n                value,\n                (facetedUniqueValues.get(value) ?? 0) + 1\n              )\n            } else {\n              facetedUniqueValues.set(value, 1)\n            }\n          }\n        }\n\n        return facetedUniqueValues\n      },\n      getMemoOptions(\n        table.options,\n        'debugTable',\n        `getFacetedUniqueValues_${columnId}`\n      )\n    )\n}\n","import { ResolvedColumnFilter } from '../features/ColumnFiltering'\nimport { Table, RowModel, Row, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\nimport { filterRows } from './filterRowsUtils'\n\nexport function getFilteredRowModel<TData extends RowData>(): (\n  table: Table<TData>\n) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [\n        table.getPreFilteredRowModel(),\n        table.getState().columnFilters,\n        table.getState().globalFilter,\n      ],\n      (rowModel, columnFilters, globalFilter) => {\n        if (\n          !rowModel.rows.length ||\n          (!columnFilters?.length && !globalFilter)\n        ) {\n          for (let i = 0; i < rowModel.flatRows.length; i++) {\n            rowModel.flatRows[i]!.columnFilters = {}\n            rowModel.flatRows[i]!.columnFiltersMeta = {}\n          }\n          return rowModel\n        }\n\n        const resolvedColumnFilters: ResolvedColumnFilter<TData>[] = []\n        const resolvedGlobalFilters: ResolvedColumnFilter<TData>[] = []\n\n        ;(columnFilters ?? []).forEach(d => {\n          const column = table.getColumn(d.id)\n\n          if (!column) {\n            return\n          }\n\n          const filterFn = column.getFilterFn()\n\n          if (!filterFn) {\n            if (process.env.NODE_ENV !== 'production') {\n              console.warn(\n                `Could not find a valid 'column.filterFn' for column with the ID: ${column.id}.`\n              )\n            }\n            return\n          }\n\n          resolvedColumnFilters.push({\n            id: d.id,\n            filterFn,\n            resolvedValue: filterFn.resolveFilterValue?.(d.value) ?? d.value,\n          })\n        })\n\n        const filterableIds = (columnFilters ?? []).map(d => d.id)\n\n        const globalFilterFn = table.getGlobalFilterFn()\n\n        const globallyFilterableColumns = table\n          .getAllLeafColumns()\n          .filter(column => column.getCanGlobalFilter())\n\n        if (\n          globalFilter &&\n          globalFilterFn &&\n          globallyFilterableColumns.length\n        ) {\n          filterableIds.push('__global__')\n\n          globallyFilterableColumns.forEach(column => {\n            resolvedGlobalFilters.push({\n              id: column.id,\n              filterFn: globalFilterFn,\n              resolvedValue:\n                globalFilterFn.resolveFilterValue?.(globalFilter) ??\n                globalFilter,\n            })\n          })\n        }\n\n        let currentColumnFilter\n        let currentGlobalFilter\n\n        // Flag the prefiltered row model with each filter state\n        for (let j = 0; j < rowModel.flatRows.length; j++) {\n          const row = rowModel.flatRows[j]!\n\n          row.columnFilters = {}\n\n          if (resolvedColumnFilters.length) {\n            for (let i = 0; i < resolvedColumnFilters.length; i++) {\n              currentColumnFilter = resolvedColumnFilters[i]!\n              const id = currentColumnFilter.id\n\n              // Tag the row with the column filter state\n              row.columnFilters[id] = currentColumnFilter.filterFn(\n                row,\n                id,\n                currentColumnFilter.resolvedValue,\n                filterMeta => {\n                  row.columnFiltersMeta[id] = filterMeta\n                }\n              )\n            }\n          }\n\n          if (resolvedGlobalFilters.length) {\n            for (let i = 0; i < resolvedGlobalFilters.length; i++) {\n              currentGlobalFilter = resolvedGlobalFilters[i]!\n              const id = currentGlobalFilter.id\n              // Tag the row with the first truthy global filter state\n              if (\n                currentGlobalFilter.filterFn(\n                  row,\n                  id,\n                  currentGlobalFilter.resolvedValue,\n                  filterMeta => {\n                    row.columnFiltersMeta[id] = filterMeta\n                  }\n                )\n              ) {\n                row.columnFilters.__global__ = true\n                break\n              }\n            }\n\n            if (row.columnFilters.__global__ !== true) {\n              row.columnFilters.__global__ = false\n            }\n          }\n        }\n\n        const filterRowsImpl = (row: Row<TData>) => {\n          // Horizontally filter rows through each column\n          for (let i = 0; i < filterableIds.length; i++) {\n            if (row.columnFilters[filterableIds[i]!] === false) {\n              return false\n            }\n          }\n          return true\n        }\n\n        // Filter final rows using all of the active filters\n        return filterRows(rowModel.rows, filterRowsImpl, table)\n      },\n      getMemoOptions(table.options, 'debugTable', 'getFilteredRowModel', () =>\n        table._autoResetPageIndex()\n      )\n    )\n}\n","import { createRow } from '../core/row'\nimport { Row, RowData, RowModel, Table } from '../types'\nimport { flattenBy, getMemoOptions, memo } from '../utils'\nimport { GroupingState } from '../features/ColumnGrouping'\n\nexport function getGroupedRowModel<TData extends RowData>(): (\n  table: Table<TData>\n) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [table.getState().grouping, table.getPreGroupedRowModel()],\n      (grouping, rowModel) => {\n        if (!rowModel.rows.length || !grouping.length) {\n          rowModel.rows.forEach(row => {\n            row.depth = 0\n            row.parentId = undefined\n          })\n          return rowModel\n        }\n\n        // Filter the grouping list down to columns that exist\n        const existingGrouping = grouping.filter(columnId =>\n          table.getColumn(columnId)\n        )\n\n        const groupedFlatRows: Row<TData>[] = []\n        const groupedRowsById: Record<string, Row<TData>> = {}\n        // const onlyGroupedFlatRows: Row[] = [];\n        // const onlyGroupedRowsById: Record<RowId, Row> = {};\n        // const nonGroupedFlatRows: Row[] = [];\n        // const nonGroupedRowsById: Record<RowId, Row> = {};\n\n        // Recursively group the data\n        const groupUpRecursively = (\n          rows: Row<TData>[],\n          depth = 0,\n          parentId?: string\n        ) => {\n          // Grouping depth has been been met\n          // Stop grouping and simply rewrite thd depth and row relationships\n          if (depth >= existingGrouping.length) {\n            return rows.map(row => {\n              row.depth = depth\n\n              groupedFlatRows.push(row)\n              groupedRowsById[row.id] = row\n\n              if (row.subRows) {\n                row.subRows = groupUpRecursively(row.subRows, depth + 1, row.id)\n              }\n\n              return row\n            })\n          }\n\n          const columnId: string = existingGrouping[depth]!\n\n          // Group the rows together for this level\n          const rowGroupsMap = groupBy(rows, columnId)\n\n          // Perform aggregations for each group\n          const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map(\n            ([groupingValue, groupedRows], index) => {\n              let id = `${columnId}:${groupingValue}`\n              id = parentId ? `${parentId}>${id}` : id\n\n              // First, Recurse to group sub rows before aggregation\n              const subRows = groupUpRecursively(groupedRows, depth + 1, id)\n\n              subRows.forEach(subRow => {\n                subRow.parentId = id\n              })\n\n              // Flatten the leaf rows of the rows in this group\n              const leafRows = depth\n                ? flattenBy(groupedRows, row => row.subRows)\n                : groupedRows\n\n              const row = createRow(\n                table,\n                id,\n                leafRows[0]!.original,\n                index,\n                depth,\n                undefined,\n                parentId\n              )\n\n              Object.assign(row, {\n                groupingColumnId: columnId,\n                groupingValue,\n                subRows,\n                leafRows,\n                getValue: (columnId: string) => {\n                  // Don't aggregate columns that are in the grouping\n                  if (existingGrouping.includes(columnId)) {\n                    if (row._valuesCache.hasOwnProperty(columnId)) {\n                      return row._valuesCache[columnId]\n                    }\n\n                    if (groupedRows[0]) {\n                      row._valuesCache[columnId] =\n                        groupedRows[0].getValue(columnId) ?? undefined\n                    }\n\n                    return row._valuesCache[columnId]\n                  }\n\n                  if (row._groupingValuesCache.hasOwnProperty(columnId)) {\n                    return row._groupingValuesCache[columnId]\n                  }\n\n                  // Aggregate the values\n                  const column = table.getColumn(columnId)\n                  const aggregateFn = column?.getAggregationFn()\n\n                  if (aggregateFn) {\n                    row._groupingValuesCache[columnId] = aggregateFn(\n                      columnId,\n                      leafRows,\n                      groupedRows\n                    )\n\n                    return row._groupingValuesCache[columnId]\n                  }\n                },\n              })\n\n              subRows.forEach(subRow => {\n                groupedFlatRows.push(subRow)\n                groupedRowsById[subRow.id] = subRow\n                // if (subRow.getIsGrouped?.()) {\n                //   onlyGroupedFlatRows.push(subRow);\n                //   onlyGroupedRowsById[subRow.id] = subRow;\n                // } else {\n                //   nonGroupedFlatRows.push(subRow);\n                //   nonGroupedRowsById[subRow.id] = subRow;\n                // }\n              })\n\n              return row\n            }\n          )\n\n          return aggregatedGroupedRows\n        }\n\n        const groupedRows = groupUpRecursively(rowModel.rows, 0)\n\n        groupedRows.forEach(subRow => {\n          groupedFlatRows.push(subRow)\n          groupedRowsById[subRow.id] = subRow\n          // if (subRow.getIsGrouped?.()) {\n          //   onlyGroupedFlatRows.push(subRow);\n          //   onlyGroupedRowsById[subRow.id] = subRow;\n          // } else {\n          //   nonGroupedFlatRows.push(subRow);\n          //   nonGroupedRowsById[subRow.id] = subRow;\n          // }\n        })\n\n        return {\n          rows: groupedRows,\n          flatRows: groupedFlatRows,\n          rowsById: groupedRowsById,\n        }\n      },\n      getMemoOptions(table.options, 'debugTable', 'getGroupedRowModel', () => {\n        table._queue(() => {\n          table._autoResetExpanded()\n          table._autoResetPageIndex()\n        })\n      })\n    )\n}\n\nfunction groupBy<TData extends RowData>(rows: Row<TData>[], columnId: string) {\n  const groupMap = new Map<any, Row<TData>[]>()\n\n  return rows.reduce((map, row) => {\n    const resKey = `${row.getGroupingValue(columnId)}`\n    const previous = map.get(resKey)\n    if (!previous) {\n      map.set(resKey, [row])\n    } else {\n      previous.push(row)\n    }\n    return map\n  }, groupMap)\n}\n","import { Table, RowModel, Row, RowData } from '../types'\nimport { getMemoOptions, memo } from '../utils'\nimport { expandRows } from './getExpandedRowModel'\n\nexport function getPaginationRowModel<TData extends RowData>(opts?: {\n  initialSync: boolean\n}): (table: Table<TData>) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [\n        table.getState().pagination,\n        table.getPrePaginationRowModel(),\n        table.options.paginateExpandedRows\n          ? undefined\n          : table.getState().expanded,\n      ],\n      (pagination, rowModel) => {\n        if (!rowModel.rows.length) {\n          return rowModel\n        }\n\n        const { pageSize, pageIndex } = pagination\n        let { rows, flatRows, rowsById } = rowModel\n        const pageStart = pageSize * pageIndex\n        const pageEnd = pageStart + pageSize\n\n        rows = rows.slice(pageStart, pageEnd)\n\n        let paginatedRowModel: RowModel<TData>\n\n        if (!table.options.paginateExpandedRows) {\n          paginatedRowModel = expandRows({\n            rows,\n            flatRows,\n            rowsById,\n          })\n        } else {\n          paginatedRowModel = {\n            rows,\n            flatRows,\n            rowsById,\n          }\n        }\n\n        paginatedRowModel.flatRows = []\n\n        const handleRow = (row: Row<TData>) => {\n          paginatedRowModel.flatRows.push(row)\n          if (row.subRows.length) {\n            row.subRows.forEach(handleRow)\n          }\n        }\n\n        paginatedRowModel.rows.forEach(handleRow)\n\n        return paginatedRowModel\n      },\n      getMemoOptions(table.options, 'debugTable', 'getPaginationRowModel')\n    )\n}\n","import { Table, Row, RowModel, RowData } from '../types'\nimport { SortingFn } from '../features/RowSorting'\nimport { getMemoOptions, memo } from '../utils'\n\nexport function getSortedRowModel<TData extends RowData>(): (\n  table: Table<TData>\n) => () => RowModel<TData> {\n  return table =>\n    memo(\n      () => [table.getState().sorting, table.getPreSortedRowModel()],\n      (sorting, rowModel) => {\n        if (!rowModel.rows.length || !sorting?.length) {\n          return rowModel\n        }\n\n        const sortingState = table.getState().sorting\n\n        const sortedFlatRows: Row<TData>[] = []\n\n        // Filter out sortings that correspond to non existing columns\n        const availableSorting = sortingState.filter(sort =>\n          table.getColumn(sort.id)?.getCanSort()\n        )\n\n        const columnInfoById: Record<\n          string,\n          {\n            sortUndefined?: false | -1 | 1 | 'first' | 'last'\n            invertSorting?: boolean\n            sortingFn: SortingFn<TData>\n          }\n        > = {}\n\n        availableSorting.forEach(sortEntry => {\n          const column = table.getColumn(sortEntry.id)\n          if (!column) return\n\n          columnInfoById[sortEntry.id] = {\n            sortUndefined: column.columnDef.sortUndefined,\n            invertSorting: column.columnDef.invertSorting,\n            sortingFn: column.getSortingFn(),\n          }\n        })\n\n        const sortData = (rows: Row<TData>[]) => {\n          // This will also perform a stable sorting using the row index\n          // if needed.\n          const sortedData = rows.map(row => ({ ...row }))\n\n          sortedData.sort((rowA, rowB) => {\n            for (let i = 0; i < availableSorting.length; i += 1) {\n              const sortEntry = availableSorting[i]!\n              const columnInfo = columnInfoById[sortEntry.id]!\n              const sortUndefined = columnInfo.sortUndefined\n              const isDesc = sortEntry?.desc ?? false\n\n              let sortInt = 0\n\n              // All sorting ints should always return in ascending order\n              if (sortUndefined) {\n                const aValue = rowA.getValue(sortEntry.id)\n                const bValue = rowB.getValue(sortEntry.id)\n\n                const aUndefined = aValue === undefined\n                const bUndefined = bValue === undefined\n\n                if (aUndefined || bUndefined) {\n                  if (sortUndefined === 'first') return aUndefined ? -1 : 1\n                  if (sortUndefined === 'last') return aUndefined ? 1 : -1\n                  sortInt =\n                    aUndefined && bUndefined\n                      ? 0\n                      : aUndefined\n                        ? sortUndefined\n                        : -sortUndefined\n                }\n              }\n\n              if (sortInt === 0) {\n                sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id)\n              }\n\n              // If sorting is non-zero, take care of desc and inversion\n              if (sortInt !== 0) {\n                if (isDesc) {\n                  sortInt *= -1\n                }\n\n                if (columnInfo.invertSorting) {\n                  sortInt *= -1\n                }\n\n                return sortInt\n              }\n            }\n\n            return rowA.index - rowB.index\n          })\n\n          // If there are sub-rows, sort them\n          sortedData.forEach(row => {\n            sortedFlatRows.push(row)\n            if (row.subRows?.length) {\n              row.subRows = sortData(row.subRows)\n            }\n          })\n\n          return sortedData\n        }\n\n        return {\n          rows: sortData(rowModel.rows),\n          flatRows: sortedFlatRows,\n          rowsById: rowModel.rowsById,\n        }\n      },\n      getMemoOptions(table.options, 'debugTable', 'getSortedRowModel', () =>\n        table._autoResetPageIndex()\n      )\n    )\n}\n","import * as React from 'react'\nexport * from '@tanstack/table-core'\n\nimport {\n  TableOptions,\n  TableOptionsResolved,\n  RowData,\n  createTable,\n} from '@tanstack/table-core'\n\nexport type Renderable<TProps> = React.ReactNode | React.ComponentType<TProps>\n\n//\n\n/**\n * If rendering headers, cells, or footers with custom markup, use flexRender instead of `cell.getValue()` or `cell.renderValue()`.\n */\nexport function flexRender<TProps extends object>(\n  Comp: Renderable<TProps>,\n  props: TProps\n): React.ReactNode | JSX.Element {\n  return !Comp ? null : isReactComponent<TProps>(Comp) ? (\n    <Comp {...props} />\n  ) : (\n    Comp\n  )\n}\n\nfunction isReactComponent<TProps>(\n  component: unknown\n): component is React.ComponentType<TProps> {\n  return (\n    isClassComponent(component) ||\n    typeof component === 'function' ||\n    isExoticComponent(component)\n  )\n}\n\nfunction isClassComponent(component: any) {\n  return (\n    typeof component === 'function' &&\n    (() => {\n      const proto = Object.getPrototypeOf(component)\n      return proto.prototype && proto.prototype.isReactComponent\n    })()\n  )\n}\n\nfunction isExoticComponent(component: any) {\n  return (\n    typeof component === 'object' &&\n    typeof component.$$typeof === 'symbol' &&\n    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)\n  )\n}\n\nexport function useReactTable<TData extends RowData>(\n  options: TableOptions<TData>\n) {\n  // Compose in the generic options to the user options\n  const resolvedOptions: TableOptionsResolved<TData> = {\n    state: {}, // Dummy state\n    onStateChange: () => {}, // noop\n    renderFallbackValue: null,\n    ...options,\n  }\n\n  // Create a new table and store it in state\n  const [tableRef] = React.useState(() => ({\n    current: createTable<TData>(resolvedOptions),\n  }))\n\n  // By default, manage table state here using the table's initial state\n  const [state, setState] = React.useState(() => tableRef.current.initialState)\n\n  // Compose the default state above with any user state. This will allow the user\n  // to only control a subset of the state if desired.\n  tableRef.current.setOptions(prev => ({\n    ...prev,\n    ...options,\n    state: {\n      ...state,\n      ...options.state,\n    },\n    // Similarly, we'll maintain both our internal state and any user-provided\n    // state.\n    onStateChange: updater => {\n      setState(updater)\n      options.onStateChange?.(updater)\n    },\n  }))\n\n  return tableRef.current\n}\n","export type NoInfer<A extends any> = [A][A extends any ? 0 : never]\n\nexport type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>\n\nexport function memo<TDeps extends ReadonlyArray<any>, TResult>(\n  getDeps: () => [...TDeps],\n  fn: (...args: NoInfer<[...TDeps]>) => TResult,\n  opts: {\n    key: false | string\n    debug?: () => boolean\n    onChange?: (result: TResult) => void\n    initialDeps?: TDeps\n  },\n) {\n  let deps = opts.initialDeps ?? []\n  let result: TResult | undefined\n\n  return (): TResult => {\n    let depTime: number\n    if (opts.key && opts.debug?.()) depTime = Date.now()\n\n    const newDeps = getDeps()\n\n    const depsChanged =\n      newDeps.length !== deps.length ||\n      newDeps.some((dep: any, index: number) => deps[index] !== dep)\n\n    if (!depsChanged) {\n      return result!\n    }\n\n    deps = newDeps\n\n    let resultTime: number\n    if (opts.key && opts.debug?.()) resultTime = Date.now()\n\n    result = fn(...newDeps)\n\n    if (opts.key && opts.debug?.()) {\n      const depEndTime = Math.round((Date.now() - depTime!) * 100) / 100\n      const resultEndTime = Math.round((Date.now() - resultTime!) * 100) / 100\n      const resultFpsPercentage = resultEndTime / 16\n\n      const pad = (str: number | string, num: number) => {\n        str = String(str)\n        while (str.length < num) {\n          str = ' ' + str\n        }\n        return str\n      }\n\n      console.info(\n        `%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`,\n        `\n            font-size: .6rem;\n            font-weight: bold;\n            color: hsl(${Math.max(\n              0,\n              Math.min(120 - 120 * resultFpsPercentage, 120),\n            )}deg 100% 31%);`,\n        opts?.key,\n      )\n    }\n\n    opts?.onChange?.(result)\n\n    return result\n  }\n}\n\nexport function notUndefined<T>(value: T | undefined, msg?: string): T {\n  if (value === undefined) {\n    throw new Error(`Unexpected undefined${msg ? `: ${msg}` : ''}`)\n  } else {\n    return value\n  }\n}\n\nexport const approxEqual = (a: number, b: number) => Math.abs(a - b) < 1\n\nexport const debounce = (\n  targetWindow: Window & typeof globalThis,\n  fn: Function,\n  ms: number,\n) => {\n  let timeoutId: number\n  return function (this: any, ...args: Array<any>) {\n    targetWindow.clearTimeout(timeoutId)\n    timeoutId = targetWindow.setTimeout(() => fn.apply(this, args), ms)\n  }\n}\n","import { approxEqual, debounce, memo, notUndefined } from './utils'\n\nexport * from './utils'\n\n//\n\ntype ScrollDirection = 'forward' | 'backward'\n\ntype ScrollAlignment = 'start' | 'center' | 'end' | 'auto'\n\ntype ScrollBehavior = 'auto' | 'smooth'\n\nexport interface ScrollToOptions {\n  align?: ScrollAlignment\n  behavior?: ScrollBehavior\n}\n\ntype ScrollToOffsetOptions = ScrollToOptions\n\ntype ScrollToIndexOptions = ScrollToOptions\n\nexport interface Range {\n  startIndex: number\n  endIndex: number\n  overscan: number\n  count: number\n}\n\ntype Key = number | string | bigint\n\nexport interface VirtualItem {\n  key: Key\n  index: number\n  start: number\n  end: number\n  size: number\n  lane: number\n}\n\nexport interface Rect {\n  width: number\n  height: number\n}\n\n//\n\nexport const defaultKeyExtractor = (index: number) => index\n\nexport const defaultRangeExtractor = (range: Range) => {\n  const start = Math.max(range.startIndex - range.overscan, 0)\n  const end = Math.min(range.endIndex + range.overscan, range.count - 1)\n\n  const arr = []\n\n  for (let i = start; i <= end; i++) {\n    arr.push(i)\n  }\n\n  return arr\n}\n\nexport const observeElementRect = <T extends Element>(\n  instance: Virtualizer<T, any>,\n  cb: (rect: Rect) => void,\n) => {\n  const element = instance.scrollElement\n  if (!element) {\n    return\n  }\n  const targetWindow = instance.targetWindow\n  if (!targetWindow) {\n    return\n  }\n\n  const handler = (rect: Rect) => {\n    const { width, height } = rect\n    cb({ width: Math.round(width), height: Math.round(height) })\n  }\n\n  handler(element.getBoundingClientRect())\n\n  if (!targetWindow.ResizeObserver) {\n    return () => {}\n  }\n\n  const observer = new targetWindow.ResizeObserver((entries) => {\n    const entry = entries[0]\n    if (entry?.borderBoxSize) {\n      const box = entry.borderBoxSize[0]\n      if (box) {\n        handler({ width: box.inlineSize, height: box.blockSize })\n        return\n      }\n    }\n    handler(element.getBoundingClientRect())\n  })\n\n  observer.observe(element, { box: 'border-box' })\n\n  return () => {\n    observer.unobserve(element)\n  }\n}\n\nconst addEventListenerOptions = {\n  passive: true,\n}\n\nexport const observeWindowRect = (\n  instance: Virtualizer<Window, any>,\n  cb: (rect: Rect) => void,\n) => {\n  const element = instance.scrollElement\n  if (!element) {\n    return\n  }\n\n  const handler = () => {\n    cb({ width: element.innerWidth, height: element.innerHeight })\n  }\n  handler()\n\n  element.addEventListener('resize', handler, addEventListenerOptions)\n\n  return () => {\n    element.removeEventListener('resize', handler)\n  }\n}\n\nconst supportsScrollend =\n  typeof window == 'undefined' ? true : 'onscrollend' in window\n\nexport const observeElementOffset = <T extends Element>(\n  instance: Virtualizer<T, any>,\n  cb: (offset: number, isScrolling: boolean) => void,\n) => {\n  const element = instance.scrollElement\n  if (!element) {\n    return\n  }\n  const targetWindow = instance.targetWindow\n  if (!targetWindow) {\n    return\n  }\n\n  let offset = 0\n  const fallback = supportsScrollend\n    ? () => undefined\n    : debounce(\n        targetWindow,\n        () => {\n          cb(offset, false)\n        },\n        instance.options.isScrollingResetDelay,\n      )\n\n  const createHandler = (isScrolling: boolean) => () => {\n    const { horizontal, isRtl } = instance.options\n    offset = horizontal\n      ? element['scrollLeft'] * ((isRtl && -1) || 1)\n      : element['scrollTop']\n    fallback()\n    cb(offset, isScrolling)\n  }\n  const handler = createHandler(true)\n  const endHandler = createHandler(false)\n  endHandler()\n\n  element.addEventListener('scroll', handler, addEventListenerOptions)\n  element.addEventListener('scrollend', endHandler, addEventListenerOptions)\n\n  return () => {\n    element.removeEventListener('scroll', handler)\n    element.removeEventListener('scrollend', endHandler)\n  }\n}\n\nexport const observeWindowOffset = (\n  instance: Virtualizer<Window, any>,\n  cb: (offset: number, isScrolling: boolean) => void,\n) => {\n  const element = instance.scrollElement\n  if (!element) {\n    return\n  }\n  const targetWindow = instance.targetWindow\n  if (!targetWindow) {\n    return\n  }\n\n  let offset = 0\n  const fallback = supportsScrollend\n    ? () => undefined\n    : debounce(\n        targetWindow,\n        () => {\n          cb(offset, false)\n        },\n        instance.options.isScrollingResetDelay,\n      )\n\n  const createHandler = (isScrolling: boolean) => () => {\n    offset = element[instance.options.horizontal ? 'scrollX' : 'scrollY']\n    fallback()\n    cb(offset, isScrolling)\n  }\n  const handler = createHandler(true)\n  const endHandler = createHandler(false)\n  endHandler()\n\n  element.addEventListener('scroll', handler, addEventListenerOptions)\n  element.addEventListener('scrollend', endHandler, addEventListenerOptions)\n\n  return () => {\n    element.removeEventListener('scroll', handler)\n    element.removeEventListener('scrollend', endHandler)\n  }\n}\n\nexport const measureElement = <TItemElement extends Element>(\n  element: TItemElement,\n  entry: ResizeObserverEntry | undefined,\n  instance: Virtualizer<any, TItemElement>,\n) => {\n  if (entry?.borderBoxSize) {\n    const box = entry.borderBoxSize[0]\n    if (box) {\n      const size = Math.round(\n        box[instance.options.horizontal ? 'inlineSize' : 'blockSize'],\n      )\n      return size\n    }\n  }\n  return Math.round(\n    element.getBoundingClientRect()[\n      instance.options.horizontal ? 'width' : 'height'\n    ],\n  )\n}\n\nexport const windowScroll = <T extends Window>(\n  offset: number,\n  {\n    adjustments = 0,\n    behavior,\n  }: { adjustments?: number; behavior?: ScrollBehavior },\n  instance: Virtualizer<T, any>,\n) => {\n  const toOffset = offset + adjustments\n\n  instance.scrollElement?.scrollTo?.({\n    [instance.options.horizontal ? 'left' : 'top']: toOffset,\n    behavior,\n  })\n}\n\nexport const elementScroll = <T extends Element>(\n  offset: number,\n  {\n    adjustments = 0,\n    behavior,\n  }: { adjustments?: number; behavior?: ScrollBehavior },\n  instance: Virtualizer<T, any>,\n) => {\n  const toOffset = offset + adjustments\n\n  instance.scrollElement?.scrollTo?.({\n    [instance.options.horizontal ? 'left' : 'top']: toOffset,\n    behavior,\n  })\n}\n\nexport interface VirtualizerOptions<\n  TScrollElement extends Element | Window,\n  TItemElement extends Element,\n> {\n  // Required from the user\n  count: number\n  getScrollElement: () => TScrollElement | null\n  estimateSize: (index: number) => number\n\n  // Required from the framework adapter (but can be overridden)\n  scrollToFn: (\n    offset: number,\n    options: { adjustments?: number; behavior?: ScrollBehavior },\n    instance: Virtualizer<TScrollElement, TItemElement>,\n  ) => void\n  observeElementRect: (\n    instance: Virtualizer<TScrollElement, TItemElement>,\n    cb: (rect: Rect) => void,\n  ) => void | (() => void)\n  observeElementOffset: (\n    instance: Virtualizer<TScrollElement, TItemElement>,\n    cb: (offset: number, isScrolling: boolean) => void,\n  ) => void | (() => void)\n\n  // Optional\n  debug?: boolean\n  initialRect?: Rect\n  onChange?: (\n    instance: Virtualizer<TScrollElement, TItemElement>,\n    sync: boolean,\n  ) => void\n  measureElement?: (\n    element: TItemElement,\n    entry: ResizeObserverEntry | undefined,\n    instance: Virtualizer<TScrollElement, TItemElement>,\n  ) => number\n  overscan?: number\n  horizontal?: boolean\n  paddingStart?: number\n  paddingEnd?: number\n  scrollPaddingStart?: number\n  scrollPaddingEnd?: number\n  initialOffset?: number | (() => number)\n  getItemKey?: (index: number) => Key\n  rangeExtractor?: (range: Range) => Array<number>\n  scrollMargin?: number\n  gap?: number\n  indexAttribute?: string\n  initialMeasurementsCache?: Array<VirtualItem>\n  lanes?: number\n  isScrollingResetDelay?: number\n  enabled?: boolean\n  isRtl?: boolean\n}\n\nexport class Virtualizer<\n  TScrollElement extends Element | Window,\n  TItemElement extends Element,\n> {\n  private unsubs: Array<void | (() => void)> = []\n  options!: Required<VirtualizerOptions<TScrollElement, TItemElement>>\n  scrollElement: TScrollElement | null = null\n  targetWindow: (Window & typeof globalThis) | null = null\n  isScrolling = false\n  private scrollToIndexTimeoutId: number | null = null\n  measurementsCache: Array<VirtualItem> = []\n  private itemSizeCache = new Map<Key, number>()\n  private pendingMeasuredCacheIndexes: Array<number> = []\n  scrollRect: Rect | null = null\n  scrollOffset: number | null = null\n  scrollDirection: ScrollDirection | null = null\n  private scrollAdjustments = 0\n  shouldAdjustScrollPositionOnItemSizeChange:\n    | undefined\n    | ((\n        item: VirtualItem,\n        delta: number,\n        instance: Virtualizer<TScrollElement, TItemElement>,\n      ) => boolean)\n  elementsCache = new Map<Key, TItemElement>()\n  private observer = (() => {\n    let _ro: ResizeObserver | null = null\n\n    const get = () => {\n      if (_ro) {\n        return _ro\n      }\n\n      if (!this.targetWindow || !this.targetWindow.ResizeObserver) {\n        return null\n      }\n\n      return (_ro = new this.targetWindow.ResizeObserver((entries) => {\n        entries.forEach((entry) => {\n          this._measureElement(entry.target as TItemElement, entry)\n        })\n      }))\n    }\n\n    return {\n      disconnect: () => get()?.disconnect(),\n      observe: (target: Element) =>\n        get()?.observe(target, { box: 'border-box' }),\n      unobserve: (target: Element) => get()?.unobserve(target),\n    }\n  })()\n  range: { startIndex: number; endIndex: number } | null = null\n\n  constructor(opts: VirtualizerOptions<TScrollElement, TItemElement>) {\n    this.setOptions(opts)\n  }\n\n  setOptions = (opts: VirtualizerOptions<TScrollElement, TItemElement>) => {\n    Object.entries(opts).forEach(([key, value]) => {\n      if (typeof value === 'undefined') delete (opts as any)[key]\n    })\n\n    this.options = {\n      debug: false,\n      initialOffset: 0,\n      overscan: 1,\n      paddingStart: 0,\n      paddingEnd: 0,\n      scrollPaddingStart: 0,\n      scrollPaddingEnd: 0,\n      horizontal: false,\n      getItemKey: defaultKeyExtractor,\n      rangeExtractor: defaultRangeExtractor,\n      onChange: () => {},\n      measureElement,\n      initialRect: { width: 0, height: 0 },\n      scrollMargin: 0,\n      gap: 0,\n      indexAttribute: 'data-index',\n      initialMeasurementsCache: [],\n      lanes: 1,\n      isScrollingResetDelay: 150,\n      enabled: true,\n      isRtl: false,\n      ...opts,\n    }\n  }\n\n  private notify = (sync: boolean) => {\n    this.options.onChange?.(this, sync)\n  }\n\n  private maybeNotify = memo(\n    () => {\n      this.calculateRange()\n\n      return [\n        this.isScrolling,\n        this.range ? this.range.startIndex : null,\n        this.range ? this.range.endIndex : null,\n      ]\n    },\n    (isScrolling) => {\n      this.notify(isScrolling)\n    },\n    {\n      key: process.env.NODE_ENV !== 'production' && 'maybeNotify',\n      debug: () => this.options.debug,\n      initialDeps: [\n        this.isScrolling,\n        this.range ? this.range.startIndex : null,\n        this.range ? this.range.endIndex : null,\n      ] as [boolean, number | null, number | null],\n    },\n  )\n\n  private cleanup = () => {\n    this.unsubs.filter(Boolean).forEach((d) => d!())\n    this.unsubs = []\n    this.scrollElement = null\n    this.targetWindow = null\n    this.observer.disconnect()\n    this.elementsCache.clear()\n  }\n\n  _didMount = () => {\n    return () => {\n      this.cleanup()\n    }\n  }\n\n  _willUpdate = () => {\n    const scrollElement = this.options.enabled\n      ? this.options.getScrollElement()\n      : null\n\n    if (this.scrollElement !== scrollElement) {\n      this.cleanup()\n\n      if (!scrollElement) {\n        this.maybeNotify()\n        return\n      }\n\n      this.scrollElement = scrollElement\n\n      if (this.scrollElement && 'ownerDocument' in this.scrollElement) {\n        this.targetWindow = this.scrollElement.ownerDocument.defaultView\n      } else {\n        this.targetWindow = this.scrollElement?.window ?? null\n      }\n\n      this._scrollToOffset(this.getScrollOffset(), {\n        adjustments: undefined,\n        behavior: undefined,\n      })\n\n      this.unsubs.push(\n        this.options.observeElementRect(this, (rect) => {\n          this.scrollRect = rect\n          this.maybeNotify()\n        }),\n      )\n\n      this.unsubs.push(\n        this.options.observeElementOffset(this, (offset, isScrolling) => {\n          this.scrollAdjustments = 0\n          this.scrollDirection = isScrolling\n            ? this.getScrollOffset() < offset\n              ? 'forward'\n              : 'backward'\n            : null\n          this.scrollOffset = offset\n          this.isScrolling = isScrolling\n\n          this.maybeNotify()\n        }),\n      )\n    }\n  }\n\n  private getSize = () => {\n    if (!this.options.enabled) {\n      this.scrollRect = null\n      return 0\n    }\n\n    this.scrollRect = this.scrollRect ?? this.options.initialRect\n\n    return this.scrollRect[this.options.horizontal ? 'width' : 'height']\n  }\n\n  private getScrollOffset = () => {\n    if (!this.options.enabled) {\n      this.scrollOffset = null\n      return 0\n    }\n\n    this.scrollOffset =\n      this.scrollOffset ??\n      (typeof this.options.initialOffset === 'function'\n        ? this.options.initialOffset()\n        : this.options.initialOffset)\n\n    return this.scrollOffset\n  }\n\n  private getFurthestMeasurement = (\n    measurements: Array<VirtualItem>,\n    index: number,\n  ) => {\n    const furthestMeasurementsFound = new Map<number, true>()\n    const furthestMeasurements = new Map<number, VirtualItem>()\n    for (let m = index - 1; m >= 0; m--) {\n      const measurement = measurements[m]!\n\n      if (furthestMeasurementsFound.has(measurement.lane)) {\n        continue\n      }\n\n      const previousFurthestMeasurement = furthestMeasurements.get(\n        measurement.lane,\n      )\n      if (\n        previousFurthestMeasurement == null ||\n        measurement.end > previousFurthestMeasurement.end\n      ) {\n        furthestMeasurements.set(measurement.lane, measurement)\n      } else if (measurement.end < previousFurthestMeasurement.end) {\n        furthestMeasurementsFound.set(measurement.lane, true)\n      }\n\n      if (furthestMeasurementsFound.size === this.options.lanes) {\n        break\n      }\n    }\n\n    return furthestMeasurements.size === this.options.lanes\n      ? Array.from(furthestMeasurements.values()).sort((a, b) => {\n          if (a.end === b.end) {\n            return a.index - b.index\n          }\n\n          return a.end - b.end\n        })[0]\n      : undefined\n  }\n\n  private getMeasurementOptions = memo(\n    () => [\n      this.options.count,\n      this.options.paddingStart,\n      this.options.scrollMargin,\n      this.options.getItemKey,\n      this.options.enabled,\n    ],\n    (count, paddingStart, scrollMargin, getItemKey, enabled) => {\n      this.pendingMeasuredCacheIndexes = []\n      return {\n        count,\n        paddingStart,\n        scrollMargin,\n        getItemKey,\n        enabled,\n      }\n    },\n    {\n      key: false,\n    },\n  )\n\n  private getMeasurements = memo(\n    () => [this.getMeasurementOptions(), this.itemSizeCache],\n    (\n      { count, paddingStart, scrollMargin, getItemKey, enabled },\n      itemSizeCache,\n    ) => {\n      if (!enabled) {\n        this.measurementsCache = []\n        this.itemSizeCache.clear()\n        return []\n      }\n\n      if (this.measurementsCache.length === 0) {\n        this.measurementsCache = this.options.initialMeasurementsCache\n        this.measurementsCache.forEach((item) => {\n          this.itemSizeCache.set(item.key, item.size)\n        })\n      }\n\n      const min =\n        this.pendingMeasuredCacheIndexes.length > 0\n          ? Math.min(...this.pendingMeasuredCacheIndexes)\n          : 0\n      this.pendingMeasuredCacheIndexes = []\n\n      const measurements = this.measurementsCache.slice(0, min)\n\n      for (let i = min; i < count; i++) {\n        const key = getItemKey(i)\n\n        const furthestMeasurement =\n          this.options.lanes === 1\n            ? measurements[i - 1]\n            : this.getFurthestMeasurement(measurements, i)\n\n        const start = furthestMeasurement\n          ? furthestMeasurement.end + this.options.gap\n          : paddingStart + scrollMargin\n\n        const measuredSize = itemSizeCache.get(key)\n        const size =\n          typeof measuredSize === 'number'\n            ? measuredSize\n            : this.options.estimateSize(i)\n\n        const end = start + size\n\n        const lane = furthestMeasurement\n          ? furthestMeasurement.lane\n          : i % this.options.lanes\n\n        measurements[i] = {\n          index: i,\n          start,\n          size,\n          end,\n          key,\n          lane,\n        }\n      }\n\n      this.measurementsCache = measurements\n\n      return measurements\n    },\n    {\n      key: process.env.NODE_ENV !== 'production' && 'getMeasurements',\n      debug: () => this.options.debug,\n    },\n  )\n\n  calculateRange = memo(\n    () => [this.getMeasurements(), this.getSize(), this.getScrollOffset()],\n    (measurements, outerSize, scrollOffset) => {\n      return (this.range =\n        measurements.length > 0 && outerSize > 0\n          ? calculateRange({\n              measurements,\n              outerSize,\n              scrollOffset,\n            })\n          : null)\n    },\n    {\n      key: process.env.NODE_ENV !== 'production' && 'calculateRange',\n      debug: () => this.options.debug,\n    },\n  )\n\n  private getIndexes = memo(\n    () => [\n      this.options.rangeExtractor,\n      this.calculateRange(),\n      this.options.overscan,\n      this.options.count,\n    ],\n    (rangeExtractor, range, overscan, count) => {\n      return range === null\n        ? []\n        : rangeExtractor({\n            startIndex: range.startIndex,\n            endIndex: range.endIndex,\n            overscan,\n            count,\n          })\n    },\n    {\n      key: process.env.NODE_ENV !== 'production' && 'getIndexes',\n      debug: () => this.options.debug,\n    },\n  )\n\n  indexFromElement = (node: TItemElement) => {\n    const attributeName = this.options.indexAttribute\n    const indexStr = node.getAttribute(attributeName)\n\n    if (!indexStr) {\n      console.warn(\n        `Missing attribute name '${attributeName}={index}' on measured element.`,\n      )\n      return -1\n    }\n\n    return parseInt(indexStr, 10)\n  }\n\n  private _measureElement = (\n    node: TItemElement,\n    entry: ResizeObserverEntry | undefined,\n  ) => {\n    const index = this.indexFromElement(node)\n    const item = this.measurementsCache[index]\n    if (!item) {\n      return\n    }\n    const key = item.key\n    const prevNode = this.elementsCache.get(key)\n\n    if (prevNode !== node) {\n      if (prevNode) {\n        this.observer.unobserve(prevNode)\n      }\n      this.observer.observe(node)\n      this.elementsCache.set(key, node)\n    }\n\n    if (node.isConnected) {\n      this.resizeItem(index, this.options.measureElement(node, entry, this))\n    }\n  }\n\n  resizeItem = (index: number, size: number) => {\n    const item = this.measurementsCache[index]\n    if (!item) {\n      return\n    }\n    const itemSize = this.itemSizeCache.get(item.key) ?? item.size\n    const delta = size - itemSize\n\n    if (delta !== 0) {\n      if (\n        this.shouldAdjustScrollPositionOnItemSizeChange !== undefined\n          ? this.shouldAdjustScrollPositionOnItemSizeChange(item, delta, this)\n          : item.start < this.getScrollOffset() + this.scrollAdjustments\n      ) {\n        if (process.env.NODE_ENV !== 'production' && this.options.debug) {\n          console.info('correction', delta)\n        }\n\n        this._scrollToOffset(this.getScrollOffset(), {\n          adjustments: (this.scrollAdjustments += delta),\n          behavior: undefined,\n        })\n      }\n\n      this.pendingMeasuredCacheIndexes.push(item.index)\n      this.itemSizeCache = new Map(this.itemSizeCache.set(item.key, size))\n\n      this.notify(false)\n    }\n  }\n\n  measureElement = (node: TItemElement | null | undefined) => {\n    if (!node) {\n      this.elementsCache.forEach((cached, key) => {\n        if (!cached.isConnected) {\n          this.observer.unobserve(cached)\n          this.elementsCache.delete(key)\n        }\n      })\n      return\n    }\n\n    this._measureElement(node, undefined)\n  }\n\n  getVirtualItems = memo(\n    () => [this.getIndexes(), this.getMeasurements()],\n    (indexes, measurements) => {\n      const virtualItems: Array<VirtualItem> = []\n\n      for (let k = 0, len = indexes.length; k < len; k++) {\n        const i = indexes[k]!\n        const measurement = measurements[i]!\n\n        virtualItems.push(measurement)\n      }\n\n      return virtualItems\n    },\n    {\n      key: process.env.NODE_ENV !== 'production' && 'getVirtualItems',\n      debug: () => this.options.debug,\n    },\n  )\n\n  getVirtualItemForOffset = (offset: number) => {\n    const measurements = this.getMeasurements()\n    if (measurements.length === 0) {\n      return undefined\n    }\n    return notUndefined(\n      measurements[\n        findNearestBinarySearch(\n          0,\n          measurements.length - 1,\n          (index: number) => notUndefined(measurements[index]).start,\n          offset,\n        )\n      ],\n    )\n  }\n\n  getOffsetForAlignment = (toOffset: number, align: ScrollAlignment) => {\n    const size = this.getSize()\n    const scrollOffset = this.getScrollOffset()\n\n    if (align === 'auto') {\n      if (toOffset <= scrollOffset) {\n        align = 'start'\n      } else if (toOffset >= scrollOffset + size) {\n        align = 'end'\n      } else {\n        align = 'start'\n      }\n    }\n\n    if (align === 'start') {\n      toOffset = toOffset\n    } else if (align === 'end') {\n      toOffset = toOffset - size\n    } else if (align === 'center') {\n      toOffset = toOffset - size / 2\n    }\n\n    const scrollSizeProp = this.options.horizontal\n      ? 'scrollWidth'\n      : 'scrollHeight'\n    const scrollSize = this.scrollElement\n      ? 'document' in this.scrollElement\n        ? this.scrollElement.document.documentElement[scrollSizeProp]\n        : this.scrollElement[scrollSizeProp]\n      : 0\n\n    const maxOffset = scrollSize - size\n\n    return Math.max(Math.min(maxOffset, toOffset), 0)\n  }\n\n  getOffsetForIndex = (index: number, align: ScrollAlignment = 'auto') => {\n    index = Math.max(0, Math.min(index, this.options.count - 1))\n\n    const item = this.measurementsCache[index]\n    if (!item) {\n      return undefined\n    }\n\n    const size = this.getSize()\n    const scrollOffset = this.getScrollOffset()\n\n    if (align === 'auto') {\n      if (item.end >= scrollOffset + size - this.options.scrollPaddingEnd) {\n        align = 'end'\n      } else if (item.start <= scrollOffset + this.options.scrollPaddingStart) {\n        align = 'start'\n      } else {\n        return [scrollOffset, align] as const\n      }\n    }\n\n    const toOffset =\n      align === 'end'\n        ? item.end + this.options.scrollPaddingEnd\n        : item.start - this.options.scrollPaddingStart\n\n    return [this.getOffsetForAlignment(toOffset, align), align] as const\n  }\n\n  private isDynamicMode = () => this.elementsCache.size > 0\n\n  private cancelScrollToIndex = () => {\n    if (this.scrollToIndexTimeoutId !== null && this.targetWindow) {\n      this.targetWindow.clearTimeout(this.scrollToIndexTimeoutId)\n      this.scrollToIndexTimeoutId = null\n    }\n  }\n\n  scrollToOffset = (\n    toOffset: number,\n    { align = 'start', behavior }: ScrollToOffsetOptions = {},\n  ) => {\n    this.cancelScrollToIndex()\n\n    if (behavior === 'smooth' && this.isDynamicMode()) {\n      console.warn(\n        'The `smooth` scroll behavior is not fully supported with dynamic size.',\n      )\n    }\n\n    this._scrollToOffset(this.getOffsetForAlignment(toOffset, align), {\n      adjustments: undefined,\n      behavior,\n    })\n  }\n\n  scrollToIndex = (\n    index: number,\n    { align: initialAlign = 'auto', behavior }: ScrollToIndexOptions = {},\n  ) => {\n    index = Math.max(0, Math.min(index, this.options.count - 1))\n\n    this.cancelScrollToIndex()\n\n    if (behavior === 'smooth' && this.isDynamicMode()) {\n      console.warn(\n        'The `smooth` scroll behavior is not fully supported with dynamic size.',\n      )\n    }\n\n    const offsetAndAlign = this.getOffsetForIndex(index, initialAlign)\n    if (!offsetAndAlign) return\n\n    const [offset, align] = offsetAndAlign\n\n    this._scrollToOffset(offset, { adjustments: undefined, behavior })\n\n    if (behavior !== 'smooth' && this.isDynamicMode() && this.targetWindow) {\n      this.scrollToIndexTimeoutId = this.targetWindow.setTimeout(() => {\n        this.scrollToIndexTimeoutId = null\n\n        const elementInDOM = this.elementsCache.has(\n          this.options.getItemKey(index),\n        )\n\n        if (elementInDOM) {\n          const [latestOffset] = notUndefined(\n            this.getOffsetForIndex(index, align),\n          )\n\n          if (!approxEqual(latestOffset, this.getScrollOffset())) {\n            this.scrollToIndex(index, { align, behavior })\n          }\n        } else {\n          this.scrollToIndex(index, { align, behavior })\n        }\n      })\n    }\n  }\n\n  scrollBy = (delta: number, { behavior }: ScrollToOffsetOptions = {}) => {\n    this.cancelScrollToIndex()\n\n    if (behavior === 'smooth' && this.isDynamicMode()) {\n      console.warn(\n        'The `smooth` scroll behavior is not fully supported with dynamic size.',\n      )\n    }\n\n    this._scrollToOffset(this.getScrollOffset() + delta, {\n      adjustments: undefined,\n      behavior,\n    })\n  }\n\n  getTotalSize = () => {\n    const measurements = this.getMeasurements()\n\n    let end: number\n    // If there are no measurements, set the end to paddingStart\n    if (measurements.length === 0) {\n      end = this.options.paddingStart\n    } else {\n      // If lanes is 1, use the last measurement's end, otherwise find the maximum end value among all measurements\n      end =\n        this.options.lanes === 1\n          ? (measurements[measurements.length - 1]?.end ?? 0)\n          : Math.max(\n              ...measurements.slice(-this.options.lanes).map((m) => m.end),\n            )\n    }\n\n    return end - this.options.scrollMargin + this.options.paddingEnd\n  }\n\n  private _scrollToOffset = (\n    offset: number,\n    {\n      adjustments,\n      behavior,\n    }: {\n      adjustments: number | undefined\n      behavior: ScrollBehavior | undefined\n    },\n  ) => {\n    this.options.scrollToFn(offset, { behavior, adjustments }, this)\n  }\n\n  measure = () => {\n    this.itemSizeCache = new Map()\n    this.notify(false)\n  }\n}\n\nconst findNearestBinarySearch = (\n  low: number,\n  high: number,\n  getCurrentValue: (i: number) => number,\n  value: number,\n) => {\n  while (low <= high) {\n    const middle = ((low + high) / 2) | 0\n    const currentValue = getCurrentValue(middle)\n\n    if (currentValue < value) {\n      low = middle + 1\n    } else if (currentValue > value) {\n      high = middle - 1\n    } else {\n      return middle\n    }\n  }\n\n  if (low > 0) {\n    return low - 1\n  } else {\n    return 0\n  }\n}\n\nfunction calculateRange({\n  measurements,\n  outerSize,\n  scrollOffset,\n}: {\n  measurements: Array<VirtualItem>\n  outerSize: number\n  scrollOffset: number\n}) {\n  const count = measurements.length - 1\n  const getOffset = (index: number) => measurements[index]!.start\n\n  const startIndex = findNearestBinarySearch(0, count, getOffset, scrollOffset)\n  let endIndex = startIndex\n\n  while (\n    endIndex < count &&\n    measurements[endIndex]!.end < scrollOffset + outerSize\n  ) {\n    endIndex++\n  }\n\n  return { startIndex, endIndex }\n}\n","import * as React from 'react'\nimport { flushSync } from 'react-dom'\nimport {\n  Virtualizer,\n  elementScroll,\n  observeElementOffset,\n  observeElementRect,\n  observeWindowOffset,\n  observeWindowRect,\n  windowScroll,\n} from '@tanstack/virtual-core'\nimport type { PartialKeys, VirtualizerOptions } from '@tanstack/virtual-core'\n\nexport * from '@tanstack/virtual-core'\n\nconst useIsomorphicLayoutEffect =\n  typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect\n\nfunction useVirtualizerBase<\n  TScrollElement extends Element | Window,\n  TItemElement extends Element,\n>(\n  options: VirtualizerOptions<TScrollElement, TItemElement>,\n): Virtualizer<TScrollElement, TItemElement> {\n  const rerender = React.useReducer(() => ({}), {})[1]\n\n  const resolvedOptions: VirtualizerOptions<TScrollElement, TItemElement> = {\n    ...options,\n    onChange: (instance, sync) => {\n      if (sync) {\n        flushSync(rerender)\n      } else {\n        rerender()\n      }\n      options.onChange?.(instance, sync)\n    },\n  }\n\n  const [instance] = React.useState(\n    () => new Virtualizer<TScrollElement, TItemElement>(resolvedOptions),\n  )\n\n  instance.setOptions(resolvedOptions)\n\n  React.useEffect(() => {\n    return instance._didMount()\n  }, [])\n\n  useIsomorphicLayoutEffect(() => {\n    return instance._willUpdate()\n  })\n\n  return instance\n}\n\nexport function useVirtualizer<\n  TScrollElement extends Element,\n  TItemElement extends Element,\n>(\n  options: PartialKeys<\n    VirtualizerOptions<TScrollElement, TItemElement>,\n    'observeElementRect' | 'observeElementOffset' | 'scrollToFn'\n  >,\n): Virtualizer<TScrollElement, TItemElement> {\n  return useVirtualizerBase<TScrollElement, TItemElement>({\n    observeElementRect: observeElementRect,\n    observeElementOffset: observeElementOffset,\n    scrollToFn: elementScroll,\n    ...options,\n  })\n}\n\nexport function useWindowVirtualizer<TItemElement extends Element>(\n  options: PartialKeys<\n    VirtualizerOptions<Window, TItemElement>,\n    | 'getScrollElement'\n    | 'observeElementRect'\n    | 'observeElementOffset'\n    | 'scrollToFn'\n  >,\n): Virtualizer<Window, TItemElement> {\n  return useVirtualizerBase<Window, TItemElement>({\n    getScrollElement: () => (typeof document !== 'undefined' ? window : null),\n    observeElementRect: observeWindowRect,\n    observeElementOffset: observeWindowOffset,\n    scrollToFn: windowScroll,\n    initialOffset: () => (typeof document !== 'undefined' ? window.scrollY : 0),\n    ...options,\n  })\n}\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { SVGPathData } from \"./SVGPathData\";\nimport { SVGCommand } from \"./types\";\n\n// Encode SVG PathData\n// http://www.w3.org/TR/SVG/paths.html#PathDataBNF\n\n// Private consts : Char groups\nconst WSP = \" \";\n\nexport function encodeSVGPath(commands: SVGCommand | SVGCommand[]) {\n  let str = \"\";\n\n  if (!Array.isArray(commands)) {\n    commands = [commands];\n  }\n  for (let i = 0; i < commands.length; i++) {\n    const command = commands[i];\n    if (command.type === SVGPathData.CLOSE_PATH) {\n      str += \"z\";\n    } else if (command.type === SVGPathData.HORIZ_LINE_TO) {\n      str += (command.relative ? \"h\" : \"H\") +\n        command.x;\n    } else if (command.type === SVGPathData.VERT_LINE_TO) {\n      str += (command.relative ? \"v\" : \"V\") +\n        command.y;\n    } else if (command.type === SVGPathData.MOVE_TO) {\n      str += (command.relative ? \"m\" : \"M\") +\n        command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.LINE_TO) {\n      str += (command.relative ? \"l\" : \"L\") +\n        command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.CURVE_TO) {\n      str += (command.relative ? \"c\" : \"C\") +\n        command.x1 + WSP + command.y1 +\n        WSP + command.x2 + WSP + command.y2 +\n        WSP + command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.SMOOTH_CURVE_TO) {\n      str += (command.relative ? \"s\" : \"S\") +\n        command.x2 + WSP + command.y2 +\n        WSP + command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.QUAD_TO) {\n      str += (command.relative ? \"q\" : \"Q\") +\n        command.x1 + WSP + command.y1 +\n        WSP + command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.SMOOTH_QUAD_TO) {\n      str += (command.relative ? \"t\" : \"T\") +\n        command.x + WSP + command.y;\n    } else if (command.type === SVGPathData.ARC) {\n      str += (command.relative ? \"a\" : \"A\") +\n        command.rX + WSP + command.rY +\n        WSP + command.xRot +\n        WSP + (+command.lArcFlag) + WSP + (+command.sweepFlag) +\n        WSP + command.x + WSP + command.y;\n    } else {\n      // Unknown command\n      throw new Error(\n        `Unexpected command type \"${ (command as any).type}\" at index ${i}.`);\n    }\n  }\n\n  return str;\n}\n","import { SVGPathData } from \"./SVGPathData\";\nimport { CommandA, CommandC } from \"./types\";\n\nexport function rotate([x, y]: [number, number], rad: number) {\n  return [\n    x * Math.cos(rad) - y * Math.sin(rad),\n    x * Math.sin(rad) + y * Math.cos(rad),\n  ];\n}\n\nconst DEBUG_CHECK_NUMBERS = true;\nexport function assertNumbers(...numbers: number[]) {\n  if (DEBUG_CHECK_NUMBERS) {\n    for (let i = 0; i < numbers.length; i++) {\n      if (\"number\" !== typeof numbers[i]) {\n        throw new Error(\n          `assertNumbers arguments[${i}] is not a number. ${typeof numbers[i]} == typeof ${numbers[i]}`);\n      }\n    }\n  }\n  return true;\n}\n\nconst PI = Math.PI;\n\n/**\n * https://www.w3.org/TR/SVG/implnote.html#ArcImplementationNotes\n * Fixes rX and rY.\n * Ensures lArcFlag and sweepFlag are 0 or 1\n * Adds center coordinates: command.cX, command.cY (relative or absolute, depending on command.relative)\n * Adds start and end arc parameters (in degrees): command.phi1, command.phi2; phi1 < phi2 iff. c.sweepFlag == true\n */\nexport function annotateArcCommand(c: CommandA, x1: number, y1: number) {\n  c.lArcFlag = (0 === c.lArcFlag) ? 0 : 1;\n  c.sweepFlag = (0 === c.sweepFlag) ? 0 : 1;\n  // tslint:disable-next-line\n  let {rX, rY, x, y} = c;\n\n  rX = Math.abs(c.rX);\n  rY = Math.abs(c.rY);\n  const [x1_, y1_] = rotate([(x1 - x) / 2, (y1 - y) / 2], -c.xRot / 180 * PI);\n  const testValue = Math.pow(x1_, 2) / Math.pow(rX, 2) + Math.pow(y1_, 2) / Math.pow(rY, 2);\n\n  if (1 < testValue) {\n    rX *= Math.sqrt(testValue);\n    rY *= Math.sqrt(testValue);\n  }\n  c.rX = rX;\n  c.rY = rY;\n  const c_ScaleTemp = (Math.pow(rX, 2) * Math.pow(y1_, 2) + Math.pow(rY, 2) * Math.pow(x1_, 2));\n  const c_Scale = (c.lArcFlag !== c.sweepFlag ? 1 : -1) *\n    Math.sqrt(Math.max(0, (Math.pow(rX, 2) * Math.pow(rY, 2) - c_ScaleTemp) / c_ScaleTemp));\n  const cx_ = rX * y1_ / rY * c_Scale;\n  const cy_ = -rY * x1_ / rX * c_Scale;\n  const cRot = rotate([cx_, cy_], c.xRot / 180 * PI);\n\n  c.cX = cRot[0] + (x1 + x) / 2;\n  c.cY = cRot[1] + (y1 + y) / 2;\n  c.phi1 = Math.atan2((y1_ - cy_) / rY, (x1_ - cx_) / rX);\n  c.phi2 = Math.atan2((-y1_ - cy_) / rY, (-x1_ - cx_) / rX);\n  if (0 === c.sweepFlag && c.phi2 > c.phi1) {\n    c.phi2 -= 2 * PI;\n  }\n  if (1 === c.sweepFlag && c.phi2 < c.phi1) {\n    c.phi2 += 2 * PI;\n  }\n  c.phi1 *= 180 / PI;\n  c.phi2 *= 180 / PI;\n}\n\n/**\n * Solves a quadratic system of equations of the form\n *      a * x + b * y = c\n *      x² + y² = 1\n * This can be understood as the intersection of the unit circle with a line.\n *      => y = (c - a x) / b\n *      => x² + (c - a x)² / b² = 1\n *      => x² b² + c² - 2 c a x + a² x² = b²\n *      => (a² + b²) x² - 2 a c x + (c² - b²) = 0\n */\nexport function intersectionUnitCircleLine(a: number, b: number, c: number): [number, number][] {\n  assertNumbers(a, b, c);\n  // cf. pqFormula\n  const termSqr = a * a + b * b - c * c;\n\n  if (0 > termSqr) {\n    return [];\n  } else if (0 === termSqr) {\n    return [\n      [\n        (a * c) / (a * a + b * b),\n        (b * c) / (a * a + b * b)]];\n  }\n  const term = Math.sqrt(termSqr);\n\n  return [\n    [\n      (a * c + b * term) / (a * a + b * b),\n      (b * c - a * term) / (a * a + b * b)],\n    [\n      (a * c - b * term) / (a * a + b * b),\n      (b * c + a * term) / (a * a + b * b)]];\n\n}\n\nexport const DEG = Math.PI / 180;\n\nexport function lerp(a: number, b: number, t: number) {\n  return (1 - t) * a + t * b;\n}\n\nexport function arcAt(c: number, x1: number, x2: number, phiDeg: number) {\n  return c + Math.cos(phiDeg / 180 * PI) * x1 + Math.sin(phiDeg / 180 * PI) * x2;\n}\n\nexport function bezierRoot(x0: number, x1: number, x2: number, x3: number) {\n  const EPS = 1e-6;\n  const x01 = x1 - x0;\n  const x12 = x2 - x1;\n  const x23 = x3 - x2;\n  const a = 3 * x01 + 3 * x23 - 6 * x12;\n  const b = (x12 - x01) * 6;\n  const c = 3 * x01;\n  // solve a * t² + b * t + c = 0\n\n  if (Math.abs(a) < EPS) {\n    // equivalent to b * t + c =>\n    return [-c / b];\n  }\n  return pqFormula(b / a, c / a, EPS);\n\n}\n\nexport function bezierAt(x0: number, x1: number, x2: number, x3: number, t: number) {\n  // console.log(x0, y0, x1, y1, x2, y2, x3, y3, t)\n  const s = 1 - t;\n  const c0 = s * s * s;\n  const c1 = 3 * s * s * t;\n  const c2 = 3 * s * t * t;\n  const c3 = t * t * t;\n\n  return x0 * c0 + x1 * c1 + x2 * c2 + x3 * c3;\n}\n\nfunction pqFormula(p: number, q: number, PRECISION = 1e-6) {\n  // 4 times the discriminant:in\n  const discriminantX4 = p * p / 4 - q;\n\n  if (discriminantX4 < -PRECISION) {\n    return [];\n  } else if (discriminantX4 <= PRECISION) {\n    return [-p / 2];\n  }\n  const root = Math.sqrt(discriminantX4);\n\n  return [-(p / 2) - root, -(p / 2) + root];\n\n}\n\nexport function a2c(arc: CommandA, x0: number, y0: number): CommandC[] {\n  if (!arc.cX) {\n    annotateArcCommand(arc, x0, y0);\n  }\n\n  const phiMin = Math.min(arc.phi1!, arc.phi2!), phiMax = Math.max(arc.phi1!, arc.phi2!), deltaPhi = phiMax - phiMin;\n  const partCount = Math.ceil(deltaPhi / 90 );\n\n  const result: CommandC[] = new Array(partCount);\n  let prevX = x0, prevY = y0;\n  for (let i = 0; i < partCount; i++) {\n    const phiStart = lerp(arc.phi1!, arc.phi2!, i / partCount);\n    const phiEnd = lerp(arc.phi1!, arc.phi2!, (i + 1) / partCount);\n    const deltaPhi = phiEnd - phiStart;\n    const f = 4 / 3 * Math.tan(deltaPhi * DEG / 4);\n    // x1/y1, x2/y2 and x/y coordinates on the unit circle for phiStart/phiEnd\n    const [x1, y1] = [\n      Math.cos(phiStart * DEG) - f * Math.sin(phiStart * DEG),\n      Math.sin(phiStart * DEG) + f * Math.cos(phiStart * DEG)];\n    const [x, y] = [Math.cos(phiEnd * DEG), Math.sin(phiEnd * DEG)];\n    const [x2, y2] = [x + f * Math.sin(phiEnd * DEG), y - f * Math.cos(phiEnd * DEG)];\n    result[i] = {relative: arc.relative, type: SVGPathData.CURVE_TO } as any;\n    const transform = (x: number, y: number) => {\n      const [xTemp, yTemp] = rotate([x * arc.rX, y * arc.rY], arc.xRot);\n      return [arc.cX! + xTemp, arc.cY! + yTemp];\n    };\n    [result[i].x1, result[i].y1] = transform(x1, y1);\n    [result[i].x2, result[i].y2] = transform(x2, y2);\n    [result[i].x, result[i].y] = transform(x, y);\n    if (arc.relative) {\n      result[i].x1 -= prevX;\n      result[i].y1 -= prevY;\n      result[i].x2 -= prevX;\n      result[i].y2 -= prevY;\n      result[i].x -= prevX;\n      result[i].y -= prevY;\n    }\n    [prevX, prevY] = [result[i].x, result[i].y];\n  }\n  return result;\n}\n","// Transform SVG PathData\n// http://www.w3.org/TR/SVG/paths.html#PathDataBNF\n\nimport { a2c, annotateArcCommand, arcAt, assertNumbers, bezierAt, bezierRoot,\n  intersectionUnitCircleLine } from \"./mathUtils\";\nimport { SVGPathData } from \"./SVGPathData\";\nimport { SVGCommand, TransformFunction } from \"./types\";\n\nexport namespace SVGPathDataTransformer {\n  // Predefined transforming functions\n  // Rounds commands values\n  export function ROUND(roundVal = 1e13) {\n    assertNumbers(roundVal);\n    function rf(val: number) { return Math.round(val * roundVal) / roundVal; }\n    return function round(command: any) {\n      if (\"undefined\" !== typeof command.x1) {\n        command.x1 = rf(command.x1);\n      }\n      if (\"undefined\" !== typeof command.y1) {\n        command.y1 = rf(command.y1);\n      }\n\n      if (\"undefined\" !== typeof command.x2) {\n        command.x2 = rf(command.x2);\n      }\n      if (\"undefined\" !== typeof command.y2) {\n        command.y2 = rf(command.y2);\n      }\n\n      if (\"undefined\" !== typeof command.x) {\n        command.x = rf(command.x);\n      }\n      if (\"undefined\" !== typeof command.y) {\n        command.y = rf(command.y);\n      }\n\n      if (\"undefined\" !== typeof command.rX) {\n        command.rX = rf(command.rX);\n      }\n      if (\"undefined\" !== typeof command.rY) {\n        command.rY = rf(command.rY);\n      }\n\n      return command;\n    };\n  }\n  // Relative to absolute commands\n  export function TO_ABS() {\n    return INFO((command, prevX, prevY) => {\n      if (command.relative) {\n        // x1/y1 values\n        if (\"undefined\" !== typeof command.x1) {\n          command.x1 += prevX;\n        }\n        if (\"undefined\" !== typeof command.y1) {\n          command.y1 += prevY;\n        }\n        // x2/y2 values\n        if (\"undefined\" !== typeof command.x2) {\n          command.x2 += prevX;\n        }\n        if (\"undefined\" !== typeof command.y2) {\n          command.y2 += prevY;\n        }\n        // Finally x/y values\n        if (\"undefined\" !== typeof command.x) {\n          command.x += prevX;\n        }\n        if (\"undefined\" !== typeof command.y) {\n          command.y += prevY;\n        }\n        command.relative = false;\n      }\n      return command;\n    });\n  }\n  // Absolute to relative commands\n  export function TO_REL() {\n    return INFO((command, prevX, prevY) => {\n      if (!command.relative) {\n        // x1/y1 values\n        if (\"undefined\" !== typeof command.x1) {\n          command.x1 -= prevX;\n        }\n        if (\"undefined\" !== typeof command.y1) {\n          command.y1 -= prevY;\n        }\n        // x2/y2 values\n        if (\"undefined\" !== typeof command.x2) {\n          command.x2 -= prevX;\n        }\n        if (\"undefined\" !== typeof command.y2) {\n          command.y2 -= prevY;\n        }\n        // Finally x/y values\n        if (\"undefined\" !== typeof command.x) {\n          command.x -= prevX;\n        }\n        if (\"undefined\" !== typeof command.y) {\n          command.y -= prevY;\n        }\n        command.relative = true;\n      }\n      return command;\n    });\n  }\n  // Convert H, V, Z and A with rX = 0 to L\n  export function NORMALIZE_HVZ(normalizeZ = true, normalizeH = true, normalizeV = true) {\n    return INFO((command, prevX, prevY, pathStartX, pathStartY) => {\n      if (isNaN(pathStartX) && !(command.type & SVGPathData.MOVE_TO)) {\n        throw new Error(\"path must start with moveto\");\n      }\n      if (normalizeH && command.type & SVGPathData.HORIZ_LINE_TO) {\n        command.type = SVGPathData.LINE_TO;\n        command.y = command.relative ? 0 : prevY;\n      }\n      if (normalizeV && command.type & SVGPathData.VERT_LINE_TO) {\n        command.type = SVGPathData.LINE_TO;\n        command.x = command.relative ? 0 : prevX;\n      }\n      if (normalizeZ && command.type & SVGPathData.CLOSE_PATH) {\n        command.type = SVGPathData.LINE_TO;\n        command.x = command.relative ? pathStartX - prevX : pathStartX;\n        command.y = command.relative ? pathStartY - prevY : pathStartY;\n      }\n      if (command.type & SVGPathData.ARC && (0 === command.rX || 0 === command.rY)) {\n        command.type = SVGPathData.LINE_TO;\n        delete command.rX;\n        delete command.rY;\n        delete command.xRot;\n        delete command.lArcFlag;\n        delete command.sweepFlag;\n      }\n      return command;\n    });\n  }\n  /*\n   * Transforms smooth curves and quads to normal curves and quads (SsTt to CcQq)\n   */\n  export function NORMALIZE_ST() {\n    let prevCurveC2X = NaN;\n    let prevCurveC2Y = NaN;\n    let prevQuadCX = NaN;\n    let prevQuadCY = NaN;\n\n    return INFO((command, prevX, prevY) => {\n      if (command.type & SVGPathData.SMOOTH_CURVE_TO) {\n        command.type = SVGPathData.CURVE_TO;\n        prevCurveC2X = isNaN(prevCurveC2X) ? prevX : prevCurveC2X;\n        prevCurveC2Y = isNaN(prevCurveC2Y) ? prevY : prevCurveC2Y;\n        command.x1 = command.relative ? prevX - prevCurveC2X : 2 * prevX - prevCurveC2X;\n        command.y1 = command.relative ? prevY - prevCurveC2Y : 2 * prevY - prevCurveC2Y;\n      }\n      if (command.type & SVGPathData.CURVE_TO) {\n        prevCurveC2X = command.relative ? prevX + command.x2 : command.x2;\n        prevCurveC2Y = command.relative ? prevY + command.y2 : command.y2;\n      } else {\n        prevCurveC2X = NaN;\n        prevCurveC2Y = NaN;\n      }\n      if (command.type & SVGPathData.SMOOTH_QUAD_TO) {\n        command.type = SVGPathData.QUAD_TO;\n        prevQuadCX = isNaN(prevQuadCX) ? prevX : prevQuadCX;\n        prevQuadCY = isNaN(prevQuadCY) ? prevY : prevQuadCY;\n        command.x1 = command.relative ? prevX - prevQuadCX : 2 * prevX - prevQuadCX;\n        command.y1 = command.relative ? prevY - prevQuadCY : 2 * prevY - prevQuadCY;\n      }\n      if (command.type & SVGPathData.QUAD_TO) {\n        prevQuadCX = command.relative ? prevX + command.x1 : command.x1;\n        prevQuadCY = command.relative ? prevY + command.y1 : command.y1;\n      } else {\n        prevQuadCX = NaN;\n        prevQuadCY = NaN;\n      }\n\n      return command;\n    });\n  }\n  /*\n   * A quadratic bézier curve can be represented by a cubic bézier curve which has\n   * the same end points as the quadratic and both control points in place of the\n   * quadratic\"s one.\n   *\n   * This transformer replaces QqTt commands with Cc commands respectively.\n   * This is useful for reading path data into a system which only has a\n   * representation for cubic curves.\n   */\n  export function QT_TO_C() {\n    let prevQuadX1 = NaN;\n    let prevQuadY1 = NaN;\n\n    return INFO((command, prevX, prevY) => {\n      if (command.type & SVGPathData.SMOOTH_QUAD_TO) {\n        command.type = SVGPathData.QUAD_TO;\n        prevQuadX1 = isNaN(prevQuadX1) ? prevX : prevQuadX1;\n        prevQuadY1 = isNaN(prevQuadY1) ? prevY : prevQuadY1;\n        command.x1 = command.relative ? prevX - prevQuadX1 : 2 * prevX - prevQuadX1;\n        command.y1 = command.relative ? prevY - prevQuadY1 : 2 * prevY - prevQuadY1;\n      }\n      if (command.type & SVGPathData.QUAD_TO) {\n        prevQuadX1 = command.relative ? prevX + command.x1 : command.x1;\n        prevQuadY1 = command.relative ? prevY + command.y1 : command.y1;\n        const x1 = command.x1;\n        const y1 = command.y1;\n\n        command.type = SVGPathData.CURVE_TO;\n        command.x1 = ((command.relative ? 0 : prevX) + x1 * 2) / 3;\n        command.y1 = ((command.relative ? 0 : prevY) + y1 * 2) / 3;\n        command.x2 = (command.x + x1 * 2) / 3;\n        command.y2 = (command.y + y1 * 2) / 3;\n      } else {\n        prevQuadX1 = NaN;\n        prevQuadY1 = NaN;\n      }\n\n      return command;\n    });\n  }\n  export function INFO(\n    f: (command: any, prevXAbs: number, prevYAbs: number,\n        pathStartXAbs: number, pathStartYAbs: number) => any | any[]) {\n    let prevXAbs = 0;\n    let prevYAbs = 0;\n    let pathStartXAbs = NaN;\n    let pathStartYAbs = NaN;\n\n    return function transform(command: any) {\n      if (isNaN(pathStartXAbs) && !(command.type & SVGPathData.MOVE_TO)) {\n        throw new Error(\"path must start with moveto\");\n      }\n\n      const result = f(command, prevXAbs, prevYAbs, pathStartXAbs, pathStartYAbs);\n\n      if (command.type & SVGPathData.CLOSE_PATH) {\n        prevXAbs = pathStartXAbs;\n        prevYAbs = pathStartYAbs;\n      }\n\n      if (\"undefined\" !== typeof command.x) {\n        prevXAbs = (command.relative ? prevXAbs + command.x : command.x);\n      }\n      if (\"undefined\" !== typeof command.y) {\n        prevYAbs = (command.relative ? prevYAbs + command.y : command.y);\n      }\n\n      if (command.type & SVGPathData.MOVE_TO) {\n        pathStartXAbs = prevXAbs;\n        pathStartYAbs = prevYAbs;\n      }\n\n      return result;\n    };\n  }\n  /*\n   * remove 0-length segments\n   */\n  export function SANITIZE(EPS = 0) {\n    assertNumbers(EPS);\n    let prevCurveC2X = NaN;\n    let prevCurveC2Y = NaN;\n    let prevQuadCX = NaN;\n    let prevQuadCY = NaN;\n\n    return INFO((command, prevX, prevY, pathStartX, pathStartY) => {\n      const abs = Math.abs;\n      let skip = false;\n      let x1Rel = 0;\n      let y1Rel = 0;\n\n      if (command.type & SVGPathData.SMOOTH_CURVE_TO) {\n        x1Rel = isNaN(prevCurveC2X) ? 0 : prevX - prevCurveC2X;\n        y1Rel = isNaN(prevCurveC2Y) ? 0 : prevY - prevCurveC2Y;\n      }\n      if (command.type & (SVGPathData.CURVE_TO | SVGPathData.SMOOTH_CURVE_TO)) {\n        prevCurveC2X = command.relative ? prevX + command.x2 : command.x2;\n        prevCurveC2Y = command.relative ? prevY + command.y2 : command.y2;\n      } else {\n        prevCurveC2X = NaN;\n        prevCurveC2Y = NaN;\n      }\n      if (command.type & SVGPathData.SMOOTH_QUAD_TO) {\n        prevQuadCX = isNaN(prevQuadCX) ? prevX : 2 * prevX - prevQuadCX;\n        prevQuadCY = isNaN(prevQuadCY) ? prevY : 2 * prevY - prevQuadCY;\n      } else if (command.type & SVGPathData.QUAD_TO) {\n        prevQuadCX = command.relative ? prevX + command.x1 : command.x1;\n        prevQuadCY = command.relative ? prevY + command.y1 : command.y2;\n      } else {\n        prevQuadCX = NaN;\n        prevQuadCY = NaN;\n      }\n\n      if (command.type & SVGPathData.LINE_COMMANDS ||\n        command.type & SVGPathData.ARC && (0 === command.rX || 0 === command.rY || !command.lArcFlag) ||\n        command.type & SVGPathData.CURVE_TO || command.type & SVGPathData.SMOOTH_CURVE_TO ||\n        command.type & SVGPathData.QUAD_TO || command.type & SVGPathData.SMOOTH_QUAD_TO) {\n        const xRel = \"undefined\" === typeof command.x ? 0 :\n          (command.relative ? command.x : command.x - prevX);\n        const yRel = \"undefined\" === typeof command.y ? 0 :\n          (command.relative ? command.y : command.y - prevY);\n\n        x1Rel = !isNaN(prevQuadCX) ? prevQuadCX - prevX :\n          \"undefined\" === typeof command.x1 ? x1Rel :\n            command.relative ? command.x :\n              command.x1 - prevX;\n        y1Rel = !isNaN(prevQuadCY) ? prevQuadCY - prevY :\n          \"undefined\" === typeof command.y1 ? y1Rel :\n            command.relative ? command.y :\n              command.y1 - prevY;\n\n        const x2Rel = \"undefined\" === typeof command.x2 ? 0 :\n          (command.relative ? command.x : command.x2 - prevX);\n        const y2Rel = \"undefined\" === typeof command.y2 ? 0 :\n          (command.relative ? command.y : command.y2 - prevY);\n\n        if (abs(xRel) <= EPS && abs(yRel) <= EPS &&\n          abs(x1Rel) <= EPS && abs(y1Rel) <= EPS &&\n          abs(x2Rel) <= EPS && abs(y2Rel) <= EPS) {\n          skip = true;\n        }\n      }\n\n      if (command.type & SVGPathData.CLOSE_PATH) {\n        if (abs(prevX - pathStartX) <= EPS && abs(prevY - pathStartY) <= EPS) {\n          skip = true;\n        }\n      }\n\n      return skip ? [] : command;\n    });\n  }\n  // SVG Transforms : http://www.w3.org/TR/SVGTiny12/coords.html#TransformList\n  // Matrix : http://apike.ca/prog_svg_transform.html\n  // a c e\n  // b d f\n  export function MATRIX(a: number, b: number, c: number, d: number, e: number, f: number) {\n    assertNumbers(a, b, c, d, e, f);\n\n    return INFO((command, prevX, prevY, pathStartX) => {\n      const origX1 = command.x1;\n      const origX2 = command.x2;\n      // if isNaN(pathStartX), then this is the first command, which is ALWAYS an\n      // absolute MOVE_TO, regardless what the relative flag says\n      const comRel = command.relative && !isNaN(pathStartX);\n      const x = \"undefined\" !== typeof command.x ? command.x : (comRel ? 0 : prevX);\n      const y = \"undefined\" !== typeof command.y ? command.y : (comRel ? 0 : prevY);\n\n      if (command.type & SVGPathData.HORIZ_LINE_TO && 0 !== b) {\n        command.type = SVGPathData.LINE_TO;\n        command.y = command.relative ? 0 : prevY;\n      }\n      if (command.type & SVGPathData.VERT_LINE_TO && 0 !== c) {\n        command.type = SVGPathData.LINE_TO;\n        command.x = command.relative ? 0 : prevX;\n      }\n\n      if (\"undefined\" !== typeof command.x) {\n        command.x = (command.x * a) + (y * c) + (comRel ? 0 : e);\n      }\n      if (\"undefined\" !== typeof command.y) {\n        command.y = (x * b) + command.y * d + (comRel ? 0 : f);\n      }\n      if (\"undefined\" !== typeof command.x1) {\n        command.x1 = command.x1 * a + command.y1 * c + (comRel ? 0 : e);\n      }\n      if (\"undefined\" !== typeof command.y1) {\n        command.y1 = origX1 * b + command.y1 * d + (comRel ? 0 : f);\n      }\n      if (\"undefined\" !== typeof command.x2) {\n        command.x2 = command.x2 * a + command.y2 * c + (comRel ? 0 : e);\n      }\n      if (\"undefined\" !== typeof command.y2) {\n        command.y2 = origX2 * b + command.y2 * d + (comRel ? 0 : f);\n      }\n      function sqr(x: number) { return x * x; }\n      const det = a * d - b * c;\n\n      if (\"undefined\" !== typeof command.xRot) {\n        // Skip if this is a pure translation\n        if (1 !== a || 0 !== b || 0 !== c || 1 !== d) {\n          // Special case for singular matrix\n          if (0 === det) {\n            // In the singular case, the arc is compressed to a line. The actual geometric image of the original\n            // curve under this transform possibly extends beyond the starting and/or ending points of the segment, but\n            // for simplicity we ignore this detail and just replace this command with a single line segment.\n            delete command.rX;\n            delete command.rY;\n            delete command.xRot;\n            delete command.lArcFlag;\n            delete command.sweepFlag;\n            command.type = SVGPathData.LINE_TO;\n          } else {\n            // Convert to radians\n            const xRot = command.xRot * Math.PI / 180;\n\n            // Convert rotated ellipse to general conic form\n            // x0^2/rX^2 + y0^2/rY^2 - 1 = 0\n            // x0 = x*cos(xRot) + y*sin(xRot)\n            // y0 = -x*sin(xRot) + y*cos(xRot)\n            // --> A*x^2 + B*x*y + C*y^2 - 1 = 0, where\n            const sinRot = Math.sin(xRot);\n            const cosRot = Math.cos(xRot);\n            const xCurve = 1 / sqr(command.rX);\n            const yCurve = 1 / sqr(command.rY);\n            const A = sqr(cosRot) * xCurve + sqr(sinRot) * yCurve;\n            const B = 2 * sinRot * cosRot * (xCurve - yCurve);\n            const C = sqr(sinRot) * xCurve + sqr(cosRot) * yCurve;\n\n            // Apply matrix to A*x^2 + B*x*y + C*y^2 - 1 = 0\n            // x1 = a*x + c*y\n            // y1 = b*x + d*y\n            //      (we can ignore e and f, since pure translations don\"t affect the shape of the ellipse)\n            // --> A1*x1^2 + B1*x1*y1 + C1*y1^2 - det^2 = 0, where\n            const A1 = A * d * d - B * b * d + C * b * b;\n            const B1 = B * (a * d + b * c) - 2 * (A * c * d + C * a * b);\n            const C1 = A * c * c - B * a * c + C * a * a;\n\n            // Unapply newXRot to get back to axis-aligned ellipse equation\n            // x1 = x2*cos(newXRot) - y2*sin(newXRot)\n            // y1 = x2*sin(newXRot) + y2*cos(newXRot)\n            // A1*x1^2 + B1*x1*y1 + C1*y1^2 - det^2 =\n            //   x2^2*(A1*cos(newXRot)^2 + B1*sin(newXRot)*cos(newXRot) + C1*sin(newXRot)^2)\n            //   + x2*y2*(2*(C1 - A1)*sin(newXRot)*cos(newXRot) + B1*(cos(newXRot)^2 - sin(newXRot)^2))\n            //   + y2^2*(A1*sin(newXRot)^2 - B1*sin(newXRot)*cos(newXRot) + C1*cos(newXRot)^2)\n            //   (which must have the same zeroes as)\n            // x2^2/newRX^2 + y2^2/newRY^2 - 1\n            //   (so we have)\n            // 2*(C1 - A1)*sin(newXRot)*cos(newXRot) + B1*(cos(newXRot)^2 - sin(newXRot)^2) = 0\n            // (A1 - C1)*sin(2*newXRot) = B1*cos(2*newXRot)\n            // 2*newXRot = atan2(B1, A1 - C1)\n            const newXRot = ((Math.atan2(B1, A1 - C1) + Math.PI) % Math.PI) / 2;\n            // For any integer n, (atan2(B1, A1 - C1) + n*pi)/2 is a solution to the above; incrementing n just swaps\n            // the x and y radii computed below (since that\"s what rotating an ellipse by pi/2 does).  Choosing the\n            // rotation between 0 and pi/2 eliminates the ambiguity and leads to more predictable output.\n\n            // Finally, we get newRX and newRY from the same-zeroes relationship that gave us newXRot\n            const newSinRot = Math.sin(newXRot);\n            const newCosRot = Math.cos(newXRot);\n\n            command.rX = Math.abs(det) /\n              Math.sqrt(A1 * sqr(newCosRot) + B1 * newSinRot * newCosRot + C1 * sqr(newSinRot));\n            command.rY = Math.abs(det) /\n              Math.sqrt(A1 * sqr(newSinRot) - B1 * newSinRot * newCosRot + C1 * sqr(newCosRot));\n            command.xRot = newXRot * 180 / Math.PI;\n          }\n        }\n      }\n      // sweepFlag needs to be inverted when mirroring shapes\n      // see http://www.itk.ilstu.edu/faculty/javila/SVG/SVG_drawing1/elliptical_curve.htm\n      // m 65,10 a 50,25 0 1 0 50,25\n      // M 65,60 A 50,25 0 1 1 115,35\n      if (\"undefined\" !== typeof command.sweepFlag && 0 > det) {\n        command.sweepFlag = +!command.sweepFlag;\n      }\n      return command;\n    });\n  }\n  export function ROTATE(a: number, x = 0, y = 0) {\n    assertNumbers(a, x, y);\n    const sin = Math.sin(a);\n    const cos = Math.cos(a);\n\n    return MATRIX(cos, sin, -sin, cos, x - x * cos + y * sin, y - x * sin - y * cos);\n  }\n  export function TRANSLATE(dX: number, dY = 0) {\n    assertNumbers(dX, dY);\n    return MATRIX(1, 0, 0, 1, dX, dY);\n  }\n  export function SCALE(dX: number, dY = dX) {\n    assertNumbers(dX, dY);\n    return MATRIX(dX, 0, 0, dY, 0, 0);\n  }\n  export function SKEW_X(a: number) {\n    assertNumbers(a);\n    return MATRIX(1, 0, Math.atan(a), 1, 0, 0);\n  }\n  export function SKEW_Y(a: number) {\n    assertNumbers(a);\n    return MATRIX(1, Math.atan(a), 0, 1, 0, 0);\n  }\n  export function X_AXIS_SYMMETRY(xOffset = 0) {\n    assertNumbers(xOffset);\n    return MATRIX(-1, 0, 0, 1, xOffset, 0);\n  }\n  export function Y_AXIS_SYMMETRY(yOffset = 0) {\n    assertNumbers(yOffset);\n    return MATRIX(1, 0, 0, -1, 0, yOffset);\n  }\n  // Convert arc commands to curve commands\n  export function A_TO_C() {\n    return INFO((command, prevX, prevY) => {\n      if (SVGPathData.ARC === command.type) {\n        return a2c(command, command.relative ? 0 : prevX, command.relative ? 0 : prevY);\n      }\n      return command;\n    });\n  }\n  // @see annotateArcCommand\n  export function ANNOTATE_ARCS() {\n    return INFO((c, x1, y1) => {\n      if (c.relative) {\n        x1 = 0;\n        y1 = 0;\n      }\n      if (SVGPathData.ARC === c.type) {\n        annotateArcCommand(c, x1, y1);\n      }\n      return c;\n    });\n  }\n  export function CLONE() {\n    return (c: SVGCommand) => {\n      const result = {} as SVGCommand;\n      // tslint:disable-next-line\n      for (const key in c) {\n        result[key as keyof SVGCommand] = c[key as keyof SVGCommand];\n      }\n      return result;\n    };\n  }\n  // @see annotateArcCommand\n  export function CALCULATE_BOUNDS() {\n    const clone = CLONE();\n    const toAbs = TO_ABS();\n    const qtToC = QT_TO_C();\n    const normST = NORMALIZE_ST();\n    const f: TransformFunction & {minX: number, maxX: number, minY: number, maxY: number} =\n        INFO((command, prevXAbs, prevYAbs) => {\n      const c = normST(qtToC(toAbs(clone(command))));\n      function fixX(absX: number) {\n        if (absX > f.maxX) { f.maxX = absX; }\n        if (absX < f.minX) { f.minX = absX; }\n      }\n      function fixY(absY: number) {\n        if (absY > f.maxY) { f.maxY = absY; }\n        if (absY < f.minY) { f.minY = absY; }\n      }\n      if (c.type & SVGPathData.DRAWING_COMMANDS) {\n        fixX(prevXAbs);\n        fixY(prevYAbs);\n      }\n      if (c.type & SVGPathData.HORIZ_LINE_TO) {\n        fixX(c.x);\n      }\n      if (c.type & SVGPathData.VERT_LINE_TO) {\n        fixY(c.y);\n      }\n      if (c.type & SVGPathData.LINE_TO) {\n        fixX(c.x);\n        fixY(c.y);\n      }\n      if (c.type & SVGPathData.CURVE_TO) {\n        // add start and end points\n        fixX(c.x);\n        fixY(c.y);\n        const xDerivRoots = bezierRoot(prevXAbs, c.x1, c.x2, c.x);\n\n        for (const derivRoot of xDerivRoots) {\n          if (0 < derivRoot && 1 > derivRoot) {\n            fixX(bezierAt(prevXAbs, c.x1, c.x2, c.x, derivRoot));\n          }\n        }\n        const yDerivRoots = bezierRoot(prevYAbs, c.y1, c.y2, c.y);\n\n        for (const derivRoot of yDerivRoots) {\n          if (0 < derivRoot && 1 > derivRoot) {\n            fixY(bezierAt(prevYAbs, c.y1, c.y2, c.y, derivRoot));\n          }\n        }\n      }\n      if (c.type & SVGPathData.ARC) {\n        // add start and end points\n        fixX(c.x);\n        fixY(c.y);\n        annotateArcCommand(c, prevXAbs, prevYAbs);\n        // p = cos(phi) * xv + sin(phi) * yv\n        // dp = -sin(phi) * xv + cos(phi) * yv = 0\n        const xRotRad = c.xRot / 180 * Math.PI;\n        // points on ellipse for phi = 0° and phi = 90°\n        const x0 = Math.cos(xRotRad) * c.rX;\n        const y0 = Math.sin(xRotRad) * c.rX;\n        const x90 = -Math.sin(xRotRad) * c.rY;\n        const y90 = Math.cos(xRotRad) * c.rY;\n\n        // annotateArcCommand returns phi1 and phi2 such that -180° < phi1 < 180° and phi2 is smaller or greater\n        // depending on the sweep flag. Calculate phiMin, phiMax such that -180° < phiMin < 180° and phiMin < phiMax\n        const [phiMin, phiMax] = c.phi1 < c.phi2 ?\n          [c.phi1, c.phi2] :\n          (-180 > c.phi2 ? [c.phi2 + 360, c.phi1 + 360] : [c.phi2, c.phi1]);\n        const normalizeXiEta = ([xi, eta]: [number, number]) => {\n          const phiRad = Math.atan2(eta, xi);\n          const phi = phiRad * 180 / Math.PI;\n\n          return phi < phiMin ? phi + 360 : phi;\n        };\n        // xi = cos(phi), eta = sin(phi)\n\n        const xDerivRoots = intersectionUnitCircleLine(x90, -x0, 0).map(normalizeXiEta);\n        for (const derivRoot of xDerivRoots) {\n          if (derivRoot > phiMin && derivRoot < phiMax) {\n            fixX(arcAt(c.cX, x0, x90, derivRoot));\n          }\n        }\n\n        const yDerivRoots = intersectionUnitCircleLine(y90, -y0, 0).map(normalizeXiEta);\n        for (const derivRoot of yDerivRoots) {\n          if (derivRoot > phiMin && derivRoot < phiMax) {\n            fixY(arcAt(c.cY, y0, y90, derivRoot));\n          }\n        }\n      }\n      return command;\n    }) as any;\n\n    f.minX = Infinity;\n    f.maxX = -Infinity;\n    f.minY = Infinity;\n    f.maxY = -Infinity;\n    return f;\n  }\n}\n","import { SVGPathDataTransformer } from \"./SVGPathDataTransformer\";\nimport { TransformFunction } from \"./types\";\n\nexport abstract class TransformableSVG {\n  round(x?: number) {\n    return this.transform(SVGPathDataTransformer.ROUND(x));\n  }\n\n  toAbs() {\n    return this.transform(SVGPathDataTransformer.TO_ABS());\n  }\n\n  toRel() {\n    return this.transform(SVGPathDataTransformer.TO_REL());\n  }\n\n  normalizeHVZ(a?: boolean, b?: boolean, c?: boolean) {\n    return this.transform(SVGPathDataTransformer.NORMALIZE_HVZ(a, b, c));\n  }\n\n  normalizeST() {\n    return this.transform(SVGPathDataTransformer.NORMALIZE_ST());\n  }\n\n  qtToC() {\n    return this.transform(SVGPathDataTransformer.QT_TO_C());\n  }\n\n  aToC() {\n    return this.transform(SVGPathDataTransformer.A_TO_C());\n  }\n\n  sanitize(eps?: number) {\n    return this.transform(SVGPathDataTransformer.SANITIZE(eps));\n  }\n\n  translate(x: number, y?: number) {\n    return this.transform(SVGPathDataTransformer.TRANSLATE(x, y));\n  }\n\n  scale(x: number, y?: number) {\n    return this.transform(SVGPathDataTransformer.SCALE(x, y));\n  }\n\n  rotate(a: number, x?: number, y?: number) {\n    return this.transform(SVGPathDataTransformer.ROTATE(a, x, y));\n  }\n\n  matrix(a: number, b: number, c: number, d: number, e: number, f: number) {\n    return this.transform(SVGPathDataTransformer.MATRIX(a, b, c, d, e, f));\n  }\n\n  skewX(a: number) {\n    return this.transform(SVGPathDataTransformer.SKEW_X(a));\n  }\n\n  skewY(a: number) {\n    return this.transform(SVGPathDataTransformer.SKEW_Y(a));\n  }\n\n  xSymmetry(xOffset?: number) {\n    return this.transform(SVGPathDataTransformer.X_AXIS_SYMMETRY(xOffset));\n  }\n\n  ySymmetry(yOffset?: number) {\n    return this.transform(SVGPathDataTransformer.Y_AXIS_SYMMETRY(yOffset));\n  }\n\n  annotateArcs() {\n    return this.transform(SVGPathDataTransformer.ANNOTATE_ARCS());\n  }\n\n  abstract transform(transformFunction: TransformFunction): this;\n}\n","// Parse SVG PathData\n// http://www.w3.org/TR/SVG/paths.html#PathDataBNF\nimport { COMMAND_ARG_COUNTS, SVGPathData } from \"./SVGPathData\";\nimport { TransformableSVG } from \"./TransformableSVG\";\nimport { SVGCommand, TransformFunction } from \"./types\";\n// Private consts : Char groups\nconst isWhiteSpace = (c: string) =>\n  \" \" === c || \"\\t\" === c || \"\\r\" === c || \"\\n\" === c;\nconst isDigit = (c: string) =>\n  \"0\".charCodeAt(0) <= c.charCodeAt(0) && c.charCodeAt(0) <= \"9\".charCodeAt(0);\nconst COMMANDS = \"mMzZlLhHvVcCsSqQtTaA\";\n\nexport class SVGPathDataParser extends TransformableSVG {\n  private curNumber: string = \"\";\n  private curCommandType: SVGCommand[\"type\"] | -1 = -1;\n  private curCommandRelative = false;\n  private canParseCommandOrComma = true;\n  private curNumberHasExp = false;\n  private curNumberHasExpDigits = false;\n  private curNumberHasDecimal = false;\n  private curArgs: number[] = [];\n\n  constructor() {\n    super();\n  }\n\n  finish(commands: SVGCommand[] = []) {\n    this.parse(\" \", commands);\n    // Adding residual command\n    if (0 !== this.curArgs.length || !this.canParseCommandOrComma) {\n      throw new SyntaxError(\"Unterminated command at the path end.\");\n    }\n    return commands;\n  }\n\n  parse(str: string, commands: SVGCommand[] = []) {\n    const finishCommand = (command: SVGCommand) => {\n      commands.push(command);\n      this.curArgs.length = 0;\n      this.canParseCommandOrComma = true;\n    };\n\n    for (let i = 0; i < str.length; i++) {\n      const c = str[i];\n      // White spaces parsing\n      const isAArcFlag = this.curCommandType === SVGPathData.ARC &&\n        (this.curArgs.length === 3 || this.curArgs.length === 4) &&\n        this.curNumber.length === 1 &&\n        (this.curNumber === \"0\" || this.curNumber === \"1\");\n      const isEndingDigit = isDigit(c) && (\n        (this.curNumber === \"0\" && c === \"0\") ||\n        isAArcFlag\n      );\n\n      if (\n        isDigit(c) &&\n        !isEndingDigit\n      ) {\n        this.curNumber += c;\n        this.curNumberHasExpDigits = this.curNumberHasExp;\n        continue;\n      }\n      if (\"e\" === c || \"E\" === c) {\n        this.curNumber += c;\n        this.curNumberHasExp = true;\n        continue;\n      }\n      if (\n        (\"-\" === c || \"+\" === c) &&\n        this.curNumberHasExp &&\n        !this.curNumberHasExpDigits\n      ) {\n        this.curNumber += c;\n        continue;\n      }\n      // if we already have a \".\", it means we are starting a new number\n      if (\".\" === c && !this.curNumberHasExp && !this.curNumberHasDecimal && !isAArcFlag) {\n        this.curNumber += c;\n        this.curNumberHasDecimal = true;\n        continue;\n      }\n\n      // New number\n      if (this.curNumber && -1 !== this.curCommandType) {\n        const val = Number(this.curNumber);\n        if (isNaN(val)) {\n          throw new SyntaxError(`Invalid number ending at ${i}`);\n        }\n        if (this.curCommandType === SVGPathData.ARC) {\n          if (0 === this.curArgs.length || 1 === this.curArgs.length) {\n            if (0 > val) {\n              throw new SyntaxError(\n                `Expected positive number, got \"${val}\" at index \"${i}\"`,\n              );\n            }\n          } else if (3 === this.curArgs.length || 4 === this.curArgs.length) {\n            if (\"0\" !== this.curNumber && \"1\" !== this.curNumber) {\n              throw new SyntaxError(\n                `Expected a flag, got \"${this.curNumber}\" at index \"${i}\"`,\n              );\n            }\n          }\n        }\n        this.curArgs.push(val);\n        if (this.curArgs.length === COMMAND_ARG_COUNTS[this.curCommandType]) {\n          if (SVGPathData.HORIZ_LINE_TO === this.curCommandType) {\n            finishCommand({\n              type: SVGPathData.HORIZ_LINE_TO,\n              relative: this.curCommandRelative,\n              x: val,\n            });\n          } else if (SVGPathData.VERT_LINE_TO === this.curCommandType) {\n            finishCommand({\n              type: SVGPathData.VERT_LINE_TO,\n              relative: this.curCommandRelative,\n              y: val,\n            });\n            // Move to / line to / smooth quadratic curve to commands (x, y)\n          } else if (\n            this.curCommandType === SVGPathData.MOVE_TO ||\n            this.curCommandType === SVGPathData.LINE_TO ||\n            this.curCommandType === SVGPathData.SMOOTH_QUAD_TO\n          ) {\n            finishCommand({\n              type: this.curCommandType,\n              relative: this.curCommandRelative,\n              x: this.curArgs[0],\n              y: this.curArgs[1],\n            } as SVGCommand);\n            // Switch to line to state\n            if (SVGPathData.MOVE_TO === this.curCommandType) {\n              this.curCommandType = SVGPathData.LINE_TO;\n            }\n          } else if (this.curCommandType === SVGPathData.CURVE_TO) {\n            finishCommand({\n              type: SVGPathData.CURVE_TO,\n              relative: this.curCommandRelative,\n              x1: this.curArgs[0],\n              y1: this.curArgs[1],\n              x2: this.curArgs[2],\n              y2: this.curArgs[3],\n              x: this.curArgs[4],\n              y: this.curArgs[5],\n            });\n          } else if (this.curCommandType === SVGPathData.SMOOTH_CURVE_TO) {\n            finishCommand({\n              type: SVGPathData.SMOOTH_CURVE_TO,\n              relative: this.curCommandRelative,\n              x2: this.curArgs[0],\n              y2: this.curArgs[1],\n              x: this.curArgs[2],\n              y: this.curArgs[3],\n            });\n          } else if (this.curCommandType === SVGPathData.QUAD_TO) {\n            finishCommand({\n              type: SVGPathData.QUAD_TO,\n              relative: this.curCommandRelative,\n              x1: this.curArgs[0],\n              y1: this.curArgs[1],\n              x: this.curArgs[2],\n              y: this.curArgs[3],\n            });\n          } else if (this.curCommandType === SVGPathData.ARC) {\n            finishCommand({\n              type: SVGPathData.ARC,\n              relative: this.curCommandRelative,\n              rX: this.curArgs[0],\n              rY: this.curArgs[1],\n              xRot: this.curArgs[2],\n              lArcFlag: this.curArgs[3] as 0 | 1,\n              sweepFlag: this.curArgs[4] as 0 | 1,\n              x: this.curArgs[5],\n              y: this.curArgs[6],\n            });\n          }\n        }\n        this.curNumber = \"\";\n        this.curNumberHasExpDigits = false;\n        this.curNumberHasExp = false;\n        this.curNumberHasDecimal = false;\n        this.canParseCommandOrComma = true;\n      }\n      // Continue if a white space or a comma was detected\n      if (isWhiteSpace(c)) {\n        continue;\n      }\n      if (\",\" === c && this.canParseCommandOrComma) {\n        // L 0,0, H is not valid:\n        this.canParseCommandOrComma = false;\n        continue;\n      }\n      // if a sign is detected, then parse the new number\n      if (\"+\" === c || \"-\" === c || \".\" === c) {\n        this.curNumber = c;\n        this.curNumberHasDecimal = \".\" === c;\n        continue;\n      }\n      // if a 0 is detected, then parse the new number\n      if (isEndingDigit) {\n        this.curNumber = c;\n        this.curNumberHasDecimal = false;\n        continue;\n      }\n\n      // Adding residual command\n      if (0 !== this.curArgs.length) {\n        throw new SyntaxError(`Unterminated command at index ${i}.`);\n      }\n      if (!this.canParseCommandOrComma) {\n        throw new SyntaxError(\n          `Unexpected character \"${c}\" at index ${i}. Command cannot follow comma`,\n        );\n      }\n      this.canParseCommandOrComma = false;\n      // Detecting the next command\n      if (\"z\" === c || \"Z\" === c) {\n        commands.push({\n          type: SVGPathData.CLOSE_PATH,\n        });\n        this.canParseCommandOrComma = true;\n        this.curCommandType = -1;\n        continue;\n        // Horizontal move to command\n      } else if (\"h\" === c || \"H\" === c) {\n        this.curCommandType = SVGPathData.HORIZ_LINE_TO;\n        this.curCommandRelative = \"h\" === c;\n        // Vertical move to command\n      } else if (\"v\" === c || \"V\" === c) {\n        this.curCommandType = SVGPathData.VERT_LINE_TO;\n        this.curCommandRelative = \"v\" === c;\n        // Move to command\n      } else if (\"m\" === c || \"M\" === c) {\n        this.curCommandType = SVGPathData.MOVE_TO;\n        this.curCommandRelative = \"m\" === c;\n        // Line to command\n      } else if (\"l\" === c || \"L\" === c) {\n        this.curCommandType = SVGPathData.LINE_TO;\n        this.curCommandRelative = \"l\" === c;\n        // Curve to command\n      } else if (\"c\" === c || \"C\" === c) {\n        this.curCommandType = SVGPathData.CURVE_TO;\n        this.curCommandRelative = \"c\" === c;\n        // Smooth curve to command\n      } else if (\"s\" === c || \"S\" === c) {\n        this.curCommandType = SVGPathData.SMOOTH_CURVE_TO;\n        this.curCommandRelative = \"s\" === c;\n        // Quadratic bezier curve to command\n      } else if (\"q\" === c || \"Q\" === c) {\n        this.curCommandType = SVGPathData.QUAD_TO;\n        this.curCommandRelative = \"q\" === c;\n        // Smooth quadratic bezier curve to command\n      } else if (\"t\" === c || \"T\" === c) {\n        this.curCommandType = SVGPathData.SMOOTH_QUAD_TO;\n        this.curCommandRelative = \"t\" === c;\n        // Elliptic arc command\n      } else if (\"a\" === c || \"A\" === c) {\n        this.curCommandType = SVGPathData.ARC;\n        this.curCommandRelative = \"a\" === c;\n      } else {\n        throw new SyntaxError(`Unexpected character \"${c}\" at index ${i}.`);\n      }\n    }\n    return commands;\n  }\n  /**\n   * Return a wrapper around this parser which applies the transformation on parsed commands.\n   */\n  transform(transform: TransformFunction) {\n    const result = Object.create(this, {\n      parse: {\n        value(chunk: string, commands: SVGCommand[] = []) {\n          const parsedCommands = Object.getPrototypeOf(this).parse.call(\n            this,\n            chunk,\n          );\n          for (const c of parsedCommands) {\n            const cT = transform(c);\n            if (Array.isArray(cT)) {\n              commands.push(...cT);\n            } else {\n              commands.push(cT);\n            }\n          }\n          return commands;\n        },\n      },\n    });\n    return result as this;\n  }\n}\n","import { encodeSVGPath } from \"./SVGPathDataEncoder\";\nimport { SVGPathDataParser } from \"./SVGPathDataParser\";\nimport { SVGPathDataTransformer } from \"./SVGPathDataTransformer\";\nimport { TransformableSVG } from \"./TransformableSVG\";\nimport { SVGCommand } from \"./types\";\n\nexport class SVGPathData extends TransformableSVG {\n  commands: SVGCommand[];\n  constructor(content: string | SVGCommand[]) {\n    super();\n    if (\"string\" === typeof content) {\n      this.commands = SVGPathData.parse(content);\n    } else {\n      this.commands = content;\n    }\n  }\n\n  encode() {\n    return SVGPathData.encode(this.commands);\n  }\n\n  getBounds() {\n    const boundsTransform = SVGPathDataTransformer.CALCULATE_BOUNDS();\n\n    this.transform(boundsTransform);\n    return boundsTransform;\n  }\n\n  transform(\n    transformFunction: (input: SVGCommand) => SVGCommand | SVGCommand[],\n  ) {\n    const newCommands = [];\n\n    for (const command of this.commands) {\n      const transformedCommand = transformFunction(command);\n\n      if (Array.isArray(transformedCommand)) {\n        newCommands.push(...transformedCommand);\n      } else {\n        newCommands.push(transformedCommand);\n      }\n    }\n    this.commands = newCommands;\n    return this;\n  }\n\n  static encode(commands: SVGCommand[]) {\n    return encodeSVGPath(commands);\n      }\n\n  static parse(path: string) {\n    const parser = new SVGPathDataParser();\n    const commands: SVGCommand[] = [];\n    parser.parse(path, commands);\n    parser.finish(commands);\n    return commands;\n  }\n\n  static readonly CLOSE_PATH: 1 = 1;\n  static readonly MOVE_TO: 2 = 2;\n  static readonly HORIZ_LINE_TO: 4 = 4;\n  static readonly VERT_LINE_TO: 8 = 8;\n  static readonly LINE_TO: 16 = 16;\n  static readonly CURVE_TO: 32 = 32;\n  static readonly SMOOTH_CURVE_TO: 64 = 64;\n  static readonly QUAD_TO: 128 = 128;\n  static readonly SMOOTH_QUAD_TO: 256 = 256;\n  static readonly ARC: 512 = 512;\n  static readonly LINE_COMMANDS = SVGPathData.LINE_TO | SVGPathData.HORIZ_LINE_TO | SVGPathData.VERT_LINE_TO;\n  static readonly DRAWING_COMMANDS = SVGPathData.HORIZ_LINE_TO | SVGPathData.VERT_LINE_TO | SVGPathData.LINE_TO |\n  SVGPathData.CURVE_TO | SVGPathData.SMOOTH_CURVE_TO | SVGPathData.QUAD_TO |\n  SVGPathData.SMOOTH_QUAD_TO | SVGPathData.ARC;\n}\n\nexport const COMMAND_ARG_COUNTS = {\n    [SVGPathData.MOVE_TO]: 2,\n    [SVGPathData.LINE_TO]: 2,\n    [SVGPathData.HORIZ_LINE_TO]: 1,\n    [SVGPathData.VERT_LINE_TO]: 1,\n    [SVGPathData.CLOSE_PATH]: 0,\n    [SVGPathData.QUAD_TO]: 4,\n    [SVGPathData.SMOOTH_QUAD_TO]: 2,\n    [SVGPathData.CURVE_TO]: 6,\n    [SVGPathData.SMOOTH_CURVE_TO]: 4,\n    [SVGPathData.ARC]: 7,\n};\n\nexport {encodeSVGPath} from \"./SVGPathDataEncoder\";\nexport {SVGPathDataParser} from \"./SVGPathDataParser\";\nexport {SVGPathDataTransformer} from \"./SVGPathDataTransformer\";\n","var isProduction = process.env.NODE_ENV === 'production';\nvar prefix = 'Invariant failed';\nfunction invariant(condition, message) {\n    if (condition) {\n        return;\n    }\n    if (isProduction) {\n        throw new Error(prefix);\n    }\n    var provided = typeof message === 'function' ? message() : message;\n    var value = provided ? \"\".concat(prefix, \": \").concat(provided) : prefix;\n    throw new Error(value);\n}\n\nexport { invariant as default };\n"],"names":["candidateSelectors","candidateSelector","join","NoElement","Element","matches","prototype","msMatchesSelector","webkitMatchesSelector","getRootNode","element","_element$getRootNode","call","ownerDocument","isInert","node","lookUp","_node$getAttribute","inertAtt","getAttribute","parentNode","getCandidates","el","includeContainer","filter","candidates","Array","slice","apply","querySelectorAll","unshift","getCandidatesIteratively","elements","options","elementsToCheck","from","length","shift","tagName","assigned","assignedElements","nestedCandidates","children","flatten","push","scopeParent","includes","shadowRoot","getShadowRoot","validShadowRoot","shadowRootFilter","_nestedCandidates","hasTabIndex","isNaN","parseInt","getTabIndex","Error","tabIndex","test","_node$getAttribute2","attValue","isContentEditable","sortOrderedTabbables","a","b","documentOrder","isInput","isNonTabbableRadio","type","isRadio","name","radioSet","radioScope","form","queryRadios","window","CSS","escape","err","console","error","message","checked","nodes","i","getCheckedRadio","isTabbableRadio","isZeroArea","_node$getBoundingClie","getBoundingClientRect","width","height","isHidden","_ref","displayCheck","getComputedStyle","visibility","nodeUnderDetails","parentElement","originalNode","rootNode","assignedSlot","host","_nodeRoot","_nodeRootHost","_nodeRootHost$ownerDo","_node$ownerDocument","nodeRoot","nodeRootHost","attached","contains","_nodeRoot2","_nodeRootHost2","_nodeRootHost2$ownerD","isNodeAttached","getClientRects","isNodeMatchingSelectorFocusable","disabled","isHiddenInput","some","child","isDetailsWithSummary","item","isDisabledFromFieldset","isNodeMatchingSelectorTabbable","isValidShadowRootTabbable","shadowHostNode","sortByOrder","regularTabbables","orderedTabbables","forEach","isScope","candidateTabindex","getSortOrderTabIndex","content","sort","reduce","acc","sortable","concat","tabbable","container","bind","isTabbable","isProduction","process","warning","condition","text","warn","x","characterMap","À","Á","Â","Ã","Ä","Å","Ấ","Ắ","Ẳ","Ẵ","Ặ","Æ","Ầ","Ằ","Ȃ","Ç","Ḉ","È","É","Ê","Ë","Ế","Ḗ","Ề","Ḕ","Ḝ","Ȇ","Ì","Í","Î","Ï","Ḯ","Ȋ","Ð","Ñ","Ò","Ó","Ô","Õ","Ö","Ø","Ố","Ṍ","Ṓ","Ȏ","Ù","Ú","Û","Ü","Ý","à","á","â","ã","ä","å","ấ","ắ","ẳ","ẵ","ặ","æ","ầ","ằ","ȃ","ç","ḉ","è","é","ê","ë","ế","ḗ","ề","ḕ","ḝ","ȇ","ì","í","î","ï","ḯ","ȋ","ð","ñ","ò","ó","ô","õ","ö","ø","ố","ṍ","ṓ","ȏ","ù","ú","û","ü","ý","ÿ","Ā","ā","Ă","ă","Ą","ą","Ć","ć","Ĉ","ĉ","Ċ","ċ","Č","č","C̆","c̆","Ď","ď","Đ","đ","Ē","ē","Ĕ","ĕ","Ė","ė","Ę","ę","Ě","ě","Ĝ","Ǵ","ĝ","ǵ","Ğ","ğ","Ġ","ġ","Ģ","ģ","Ĥ","ĥ","Ħ","ħ","Ḫ","ḫ","Ĩ","ĩ","Ī","ī","Ĭ","ĭ","Į","į","İ","ı","IJ","ij","Ĵ","ĵ","Ķ","ķ","Ḱ","ḱ","K̆","k̆","Ĺ","ĺ","Ļ","ļ","Ľ","ľ","Ŀ","ŀ","Ł","ł","Ḿ","ḿ","M̆","m̆","Ń","ń","Ņ","ņ","Ň","ň","ʼn","N̆","n̆","Ō","ō","Ŏ","ŏ","Ő","ő","Œ","œ","P̆","p̆","Ŕ","ŕ","Ŗ","ŗ","Ř","ř","R̆","r̆","Ȓ","ȓ","Ś","ś","Ŝ","ŝ","Ş","Ș","ș","ş","Š","š","Ţ","ţ","ț","Ț","Ť","ť","Ŧ","ŧ","T̆","t̆","Ũ","ũ","Ū","ū","Ŭ","ŭ","Ů","ů","Ű","ű","Ų","ų","Ȗ","ȗ","V̆","v̆","Ŵ","ŵ","Ẃ","ẃ","X̆","x̆","Ŷ","ŷ","Ÿ","Y̆","y̆","Ź","ź","Ż","ż","Ž","ž","ſ","ƒ","Ơ","ơ","Ư","ư","Ǎ","ǎ","Ǐ","ǐ","Ǒ","ǒ","Ǔ","ǔ","Ǖ","ǖ","Ǘ","ǘ","Ǚ","ǚ","Ǜ","ǜ","Ứ","ứ","Ṹ","ṹ","Ǻ","ǻ","Ǽ","ǽ","Ǿ","ǿ","Þ","þ","Ṕ","ṕ","Ṥ","ṥ","X́","x́","Ѓ","ѓ","Ќ","ќ","A̋","a̋","E̋","e̋","I̋","i̋","Ǹ","ǹ","Ồ","ồ","Ṑ","ṑ","Ừ","ừ","Ẁ","ẁ","Ỳ","ỳ","Ȁ","ȁ","Ȅ","ȅ","Ȉ","ȉ","Ȍ","ȍ","Ȑ","ȑ","Ȕ","ȕ","B̌","b̌","Č̣","č̣","Ê̌","ê̌","F̌","f̌","Ǧ","ǧ","Ȟ","ȟ","J̌","ǰ","Ǩ","ǩ","M̌","m̌","P̌","p̌","Q̌","q̌","Ř̩","ř̩","Ṧ","ṧ","V̌","v̌","W̌","w̌","X̌","x̌","Y̌","y̌","A̧","a̧","B̧","b̧","Ḑ","ḑ","Ȩ","ȩ","Ɛ̧","ɛ̧","Ḩ","ḩ","I̧","i̧","Ɨ̧","ɨ̧","M̧","m̧","O̧","o̧","Q̧","q̧","U̧","u̧","X̧","x̧","Z̧","z̧","chars","Object","keys","allAccents","RegExp","rankings","CASE_SENSITIVE_EQUAL","EQUAL","STARTS_WITH","WORD_STARTS_WITH","CONTAINS","ACRONYM","MATCHES","NO_MATCH","rankItem","value","_options$threshold","threshold","accessors","rank","getMatchRanking","rankedValue","accessorIndex","accessorThreshold","passed","valuesToRank","allValues","j","J","accessor","attributes","getAccessorAttributes","itemValues","getItemValues","I","itemValue","getAllValuesToRank","rankingInfo","rankValue","newRank","minRanking","maxRanking","Math","min","testString","stringToRank","prepareValueForComparison","toLowerCase","startsWith","string","acronym","split","wordInString","splitByHyphenWord","substr","getAcronym","matchingInOrderCharCount","charNumber","findMatchingCharacter","matchChar","index","getRanking","spread","spreadPercentage","inOrderPercentage","firstIndex","getClosenessRanking","compareItems","keepDiacritics","replace","match","accessorFn","isArray","String","defaultKeyAttributes","Infinity","_objectSpread","functionalUpdate","updater","input","makeStateUpdater","key","instance","setState","old","isFunction","d","Function","flattenBy","arr","getChildren","flat","recurse","subArr","memo","getDeps","fn","opts","result","deps","depArgs","depTime","debug","Date","now","newDeps","dep","resultTime","onChange","depEndTime","round","resultEndTime","resultFpsPercentage","pad","str","num","info","max","getMemoOptions","tableOptions","debugLevel","_tableOptions$debugAl","debugAll","createHeader","table","column","_options$id","header","id","isPlaceholder","placeholderId","depth","subHeaders","colSpan","rowSpan","headerGroup","getLeafHeaders","leafHeaders","recurseHeader","h","map","getContext","_features","feature","Headers","createTable","getHeaderGroups","getAllColumns","getVisibleLeafColumns","getState","columnPinning","left","right","allColumns","leafColumns","_left$map$filter","_right$map$filter","leftColumns","columnId","find","Boolean","rightColumns","buildHeaderGroups","getCenterHeaderGroups","getLeftHeaderGroups","_left$map$filter2","getRightHeaderGroups","_right$map$filter2","getFooterGroups","headerGroups","reverse","getLeftFooterGroups","getCenterFooterGroups","getRightFooterGroups","getFlatHeaders","headers","getLeftFlatHeaders","getCenterFlatHeaders","getRightFlatHeaders","getCenterLeafHeaders","flatHeaders","_header$subHeaders","getLeftLeafHeaders","_header$subHeaders2","getRightLeafHeaders","_header$subHeaders3","center","_left$0$headers","_left$","_center$0$headers","_center$","_right$0$headers","_right$","columnsToGroup","headerFamily","_headerGroups$0$heade","_headerGroups$","maxDepth","findMaxDepth","columns","getIsVisible","_column$columns","createHeaderGroup","headersToGroup","pendingParentHeaders","headerToGroup","latestPendingParentHeader","parent","undefined","bottomHeaders","recurseHeadersForSpans","childRowSpans","childColSpan","childRowSpan","createRow","original","rowIndex","subRows","parentId","row","_valuesCache","_uniqueValuesCache","getValue","hasOwnProperty","getColumn","getUniqueValues","columnDef","renderValue","_row$getValue","renderFallbackValue","getLeafRows","getParentRow","getRow","getParentRows","parentRows","currentRow","parentRow","getAllCells","getAllLeafColumns","cell","getRenderValue","_cell$getValue","createCell","_getAllCellsByColumnId","allCells","ColumnFaceting","createColumn","_getFacetedRowModel","getFacetedRowModel","getPreFilteredRowModel","_getFacetedUniqueValues","getFacetedUniqueValues","Map","_getFacetedMinMaxValues","getFacetedMinMaxValues","includesString","filterValue","_filterValue$toString","search","toString","autoRemove","val","testFalsey","includesStringSensitive","_row$getValue2","equalsString","_row$getValue3","arrIncludes","_row$getValue4","arrIncludesAll","_row$getValue5","arrIncludesSome","_row$getValue6","equals","weakEquals","inNumberRange","rowValue","resolveFilterValue","unsafeMin","unsafeMax","parsedMin","parseFloat","parsedMax","Number","temp","filterFns","ColumnFiltering","getDefaultColumnDef","filterFn","getInitialState","state","columnFilters","getDefaultOptions","onColumnFiltersChange","filterFromLeafRows","maxLeafRowFilterDepth","getAutoFilterFn","firstRow","getCoreRowModel","flatRows","getFilterFn","_table$options$filter","_table$options$filter2","getCanFilter","_column$columnDef$ena","_table$options$enable","_table$options$enable2","enableColumnFilter","enableColumnFilters","enableFilters","getIsFiltered","getFilterIndex","getFilterValue","_table$getState$colum","_table$getState$colum2","_table$getState$colum3","findIndex","setFilterValue","setColumnFilters","previousFilter","newFilter","_old$filter","shouldAutoRemoveFilter","newFilterObj","_old$map","_table","columnFiltersMeta","_functionalUpdate","resetColumnFilters","defaultState","_table$initialState$c","_table$initialState","initialState","getFilteredRowModel","_getFilteredRowModel","manualFiltering","aggregationFns","sum","_leafRows","childRows","next","nextValue","extent","mean","leafRows","count","median","values","every","mid","floor","nums","unique","Set","uniqueCount","size","_columnId","ColumnGrouping","aggregatedCell","props","_toString","_props$getValue","aggregationFn","grouping","onGroupingChange","groupedColumnMode","toggleGrouping","setGrouping","getCanGroup","enableGrouping","getGroupingValue","getIsGrouped","_table$getState$group","getGroupedIndex","_table$getState$group2","indexOf","getToggleGroupingHandler","canGroup","getAutoAggregationFn","getAggregationFn","_table$options$aggreg","_table$options$aggreg2","resetGrouping","_table$initialState$g","getPreGroupedRowModel","getGroupedRowModel","_getGroupedRowModel","manualGrouping","groupingColumnId","_groupingValuesCache","getIsPlaceholder","getIsAggregated","_row$subRows","ColumnOrdering","columnOrder","onColumnOrderChange","getIndex","position","_getVisibleLeafColumns","getIsFirstColumn","_columns$","getIsLastColumn","_columns","setColumnOrder","resetColumnOrder","_getOrderColumnsFn","orderedColumns","columnOrderCopy","columnsCopy","targetColumnId","foundIndex","splice","nonGroupingColumns","col","g","orderColumns","ColumnPinning","onColumnPinningChange","pin","columnIds","getLeafColumns","setColumnPinning","_old$left3","_old$right3","_old$left","_old$right","_old$left2","_old$right2","getCanPin","_d$columnDef$enablePi","enablePinning","enableColumnPinning","getIsPinned","leafColumnIds","isLeft","isRight","getPinnedIndex","getCenterVisibleCells","_getAllVisibleCells","leftAndRight","getLeftVisibleCells","getRightVisibleCells","resetColumnPinning","getIsSomeColumnsPinned","_pinningState$positio","pinningState","_pinningState$left","_pinningState$right","getLeftLeafColumns","getRightLeafColumns","getCenterLeafColumns","defaultColumnSizing","minSize","maxSize","MAX_SAFE_INTEGER","ColumnSizing","columnSizing","columnSizingInfo","startOffset","startSize","deltaOffset","deltaPercentage","isResizingColumn","columnSizingStart","columnResizeMode","columnResizeDirection","onColumnSizingChange","onColumnSizingInfoChange","getSize","_column$columnDef$min","_column$columnDef$max","columnSize","getStart","getAfter","resetSize","setColumnSizing","_ref2","_column$id","_","_objectWithoutProperties","_toPropertyKey","getCanResize","enableResizing","enableColumnResizing","getIsResizing","_header$column$getSiz","prevSiblingHeader","getResizeHandler","_contextDocument","canResize","e","persist","isTouchStartEvent","touches","clientX","newColumnSizing","updateOffset","eventType","clientXPos","setColumnSizingInfo","_old$startOffset","_old$startSize","deltaDirection","_ref3","headerSize","onMove","onEnd","contextDocument","document","mouseEvents","moveHandler","upHandler","removeEventListener","touchEvents","cancelable","preventDefault","stopPropagation","_e$touches$","passiveIfSupported","passiveSupported","supported","passive","noop","addEventListener","passiveEventSupported","resetColumnSizing","resetHeaderSizeInfo","_table$initialState$c2","getTotalSize","_table$getHeaderGroup","_table$getHeaderGroup2","getLeftTotalSize","_table$getLeftHeaderG","_table$getLeftHeaderG2","getCenterTotalSize","_table$getCenterHeade","_table$getCenterHeade2","getRightTotalSize","_table$getRightHeader","_table$getRightHeader2","getCenterVisibleLeafColumns","getLeftVisibleLeafColumns","getRightVisibleLeafColumns","RowSelection","rowSelection","onRowSelectionChange","enableRowSelection","enableMultiRowSelection","enableSubRowSelection","setRowSelection","resetRowSelection","_table$initialState$r","toggleAllRowsSelected","getIsAllRowsSelected","preGroupedFlatRows","getCanSelect","toggleAllPageRowsSelected","resolvedValue","getIsAllPageRowsSelected","getRowModel","rows","mutateRowIsSelected","getPreSelectedRowModel","getSelectedRowModel","rowModel","selectRowsFn","rowsById","getFilteredSelectedRowModel","getGroupedSelectedRowModel","getSortedRowModel","isAllRowsSelected","paginationFlatRows","getPaginationRowModel","isAllPageRowsSelected","getIsSomeRowsSelected","_table$getState$rowSe","totalSelected","getIsSomePageRowsSelected","getIsSelected","getIsSomeSelected","getToggleAllRowsSelectedHandler","target","getToggleAllPageRowsSelectedHandler","toggleSelected","isSelected","_opts$selectChildren","selectedRowIds","selectChildren","isRowSelected","isSubRowSelected","getIsAllSubRowsSelected","getCanSelectSubRows","getCanMultiSelect","_table$options$enable3","getToggleSelectedHandler","canSelect","_target","includeChildren","newSelectedFlatRows","newSelectedRowsById","recurseRows","_row$subRows2","selection","_selection$row$id","_row$subRows3","allChildrenSelected","someSelected","subRow","subRowChildrenSelected","reSplitAlphaNumeric","compareBasic","compareAlphanumeric","aStr","bStr","aa","bb","an","bn","combo","sortingFns","alphanumeric","rowA","rowB","alphanumericCaseSensitive","textCaseSensitive","datetime","basic","builtInFeatures","columnVisibility","onColumnVisibilityChange","toggleVisibility","getCanHide","setColumnVisibility","childColumns","c","enableHiding","getToggleVisibilityHandler","cells","getVisibleCells","makeVisibleColumnsMethod","getColumns","getVisibleFlatColumns","getAllFlatColumns","resetColumnVisibility","toggleAllColumnsVisible","_value","getIsAllColumnsVisible","obj","getIsSomeColumnsVisible","getToggleAllColumnsVisibilityHandler","_getGlobalFacetedRowModel","getGlobalFacetedRowModel","_getGlobalFacetedUniqueValues","getGlobalFacetedUniqueValues","_getGlobalFacetedMinMaxValues","getGlobalFacetedMinMaxValues","globalFilter","onGlobalFilterChange","globalFilterFn","getColumnCanGlobalFilter","_table$getCoreRowMode","getCanGlobalFilter","_table$options$getCol","enableGlobalFilter","getGlobalAutoFilterFn","getGlobalFilterFn","setGlobalFilter","resetGlobalFilter","sorting","sortingFn","sortUndefined","onSortingChange","isMultiSortEvent","shiftKey","getAutoSortingFn","firstRows","isString","getAutoSortDir","getSortingFn","_table$options$sortin","_table$options$sortin2","toggleSorting","desc","multi","nextSortingOrder","getNextSortingOrder","hasManualValue","setSorting","existingSorting","existingIndex","sortAction","newSorting","nextDesc","_table$options$maxMul","getCanMultiSort","maxMultiSortColCount","getFirstSortDir","_column$columnDef$sor","sortDescFirst","firstSortDirection","isSorted","getIsSorted","enableSortingRemoval","enableMultiRemove","getCanSort","enableSorting","_column$columnDef$ena2","enableMultiSort","_table$getState$sorti","columnSort","getSortIndex","_table$getState$sorti2","_table$getState$sorti3","clearSorting","getToggleSortingHandler","canSort","resetSorting","_table$initialState$s","getPreSortedRowModel","_getSortedRowModel","manualSorting","expanded","onExpandedChange","paginateExpandedRows","registered","queued","_autoResetExpanded","_table$options$autoRe","autoResetAll","autoResetExpanded","manualExpanding","_queue","resetExpanded","setExpanded","toggleAllRowsExpanded","getIsAllRowsExpanded","_table$initialState$e","getCanSomeRowsExpand","getPrePaginationRowModel","getCanExpand","getToggleAllRowsExpandedHandler","getIsSomeRowsExpanded","getIsExpanded","getExpandedDepth","splitId","getPreExpandedRowModel","getExpandedRowModel","_getExpandedRowModel","toggleExpanded","_expanded","exists","oldExpanded","rowId","_row$id","_table$options$getIsR","getIsRowExpanded","_table$options$getRow","getRowCanExpand","enableExpanding","getIsAllParentsExpanded","isFullyExpanded","getToggleExpandedHandler","canExpand","pagination","pageIndex","pageSize","onPaginationChange","_autoResetPageIndex","autoResetPageIndex","manualPagination","resetPageIndex","setPagination","resetPagination","_table$initialState$p","setPageIndex","maxPageIndex","pageCount","_table$initialState$p2","resetPageSize","_table$initialState$p3","_table$initialState2","setPageSize","topRowIndex","setPageCount","_table$options$pageCo","newPageCount","getPageOptions","getPageCount","pageOptions","fill","getCanPreviousPage","getCanNextPage","previousPage","nextPage","firstPage","lastPage","_getPaginationRowModel","_table$options$pageCo2","ceil","getRowCount","_table$options$rowCou","rowCount","rowPinning","top","bottom","onRowPinningChange","includeLeafRows","includeParentRows","leafRowIds","parentRowIds","rowIds","setRowPinning","_old$top3","_old$bottom3","_old$top","_old$bottom","_old$top2","_old$bottom2","has","enableRowPinning","isTop","isBottom","_ref4","_visiblePinnedRowIds$","visiblePinnedRowIds","getTopRows","getBottomRows","_ref5","resetRowPinning","getIsSomeRowsPinned","_pinningState$top","_pinningState$bottom","_getPinnedRows","visibleRows","pinnedRowIds","_table$options$keepPi","keepPinnedRows","allRows","topPinnedRowIds","bottomPinnedRowIds","getCenterRows","topAndBottom","_options$_features","_options$initialState","defaultOptions","assign","_feature$getInitialSt","queuedTimeout","coreInstance","cb","Promise","resolve","then","catch","setTimeout","reset","setOptions","newOptions","mergeOptions","onStateChange","_getRowId","getRowId","_getCoreRowModel","searchAll","_getDefaultColumnDef","defaultColumn","_defaultColumn","resolvedColumnDef","accessorKey","_props$renderValue$to","_props$renderValue","_getColumnDefs","columnDefs","recurseColumns","_resolvedColumnDef$id","replaceAll","originalRow","_result","getFlatColumns","flatMap","_column$columns2","groupingColumnDef","_getAllFlatColumnsById","flatColumns","data","accessRows","originalRows","_row$originalSubRows","getSubRows","originalSubRows","expandRows","expandedRows","handleRow","_table$getColumn","facetedRowModel","uniqueValues","flatRow","_flatRow$getUniqueVal","facetedMinValue","facetedMaxValue","filterRows","filterRowImpl","rowsToFilter","filterRow","_table$options$maxLea","newFilteredFlatRows","newFilteredRowsById","recurseFilterRows","newRow","filterRowModelFromLeafs","_table$options$maxLea2","filterRowModelFromRoot","preRowModel","filterableIds","facetedUniqueValues","_facetedUniqueValues$","set","get","resolvedColumnFilters","resolvedGlobalFilters","_filterFn$resolveFilt","globallyFilterableColumns","currentColumnFilter","currentGlobalFilter","_globalFilterFn$resol","filterMeta","__global__","existingGrouping","groupedFlatRows","groupedRowsById","groupUpRecursively","rowGroupsMap","groupMap","resKey","previous","groupBy","aggregatedGroupedRows","entries","groupingValue","groupedRows","_groupedRows$0$getVal","aggregateFn","pageStart","pageEnd","paginatedRowModel","sortingState","sortedFlatRows","availableSorting","columnInfoById","sortEntry","invertSorting","sortData","sortedData","_sortEntry$desc","columnInfo","isDesc","sortInt","aUndefined","bUndefined","useReactTable","resolvedOptions","tableRef","React","current","prev","_opts$initialDeps","initialDeps","_a","_b","_c","_d","notUndefined","msg","debounce","targetWindow","ms","timeoutId","_len","arguments","args","_key","clearTimeout","this","defaultKeyExtractor","defaultRangeExtractor","range","start","startIndex","overscan","end","endIndex","observeElementRect","scrollElement","handler","rect","ResizeObserver","observer","entry","borderBoxSize","box","inlineSize","blockSize","observe","unobserve","addEventListenerOptions","supportsScrollend","observeElementOffset","offset","fallback","isScrollingResetDelay","createHandler","isScrolling","horizontal","isRtl","endHandler","measureElement","elementScroll","adjustments","behavior","toOffset","scrollTo","Virtualizer","constructor","_this","unsubs","scrollToIndexTimeoutId","measurementsCache","itemSizeCache","pendingMeasuredCacheIndexes","scrollRect","scrollOffset","scrollDirection","scrollAdjustments","elementsCache","_ro","_measureElement","disconnect","opts2","initialOffset","paddingStart","paddingEnd","scrollPaddingStart","scrollPaddingEnd","getItemKey","rangeExtractor","initialRect","scrollMargin","gap","indexAttribute","initialMeasurementsCache","lanes","enabled","notify","sync","maybeNotify","calculateRange","cleanup","clear","_didMount","_willUpdate","getScrollElement","defaultView","_scrollToOffset","getScrollOffset","_this$scrollRect","_this$scrollOffset","getFurthestMeasurement","measurements","furthestMeasurementsFound","furthestMeasurements","m","measurement","lane","previousFurthestMeasurement","getMeasurementOptions","getMeasurements","furthestMeasurement","measuredSize","estimateSize","outerSize","_ref8","getOffset","findNearestBinarySearch","getIndexes","indexFromElement","attributeName","indexStr","prevNode","isConnected","resizeItem","_this$itemSizeCache$g","delta","shouldAdjustScrollPositionOnItemSizeChange","cached","delete","getVirtualItems","indexes","virtualItems","k","len","getVirtualItemForOffset","getOffsetForAlignment","align","scrollSizeProp","maxOffset","documentElement","getOffsetForIndex","isDynamicMode","cancelScrollToIndex","scrollToOffset","scrollToIndex","initialAlign","offsetAndAlign","latestOffset","abs","approxEqual","scrollBy","_ref6","_ref7","scrollToFn","measure","low","high","getCurrentValue","middle","currentValue","useIsomorphicLayoutEffect","useVirtualizerBase","rerender","instance2","flushSync","useVirtualizer","t","r","setPrototypeOf","__proto__","TypeError","create","cos","sin","n","PI","o","lArcFlag","sweepFlag","rX","rY","s","u","y","xRot","p","pow","sqrt","O","l","T","v","cX","cY","phi1","atan2","phi2","relative","x1","y1","x2","y2","NaN","SMOOTH_CURVE_TO","CURVE_TO","SMOOTH_QUAD_TO","QUAD_TO","MOVE_TO","CLOSE_PATH","HORIZ_LINE_TO","LINE_TO","VERT_LINE_TO","f","N","E","A","C","M","R","S","L","ROUND","TO_ABS","TO_REL","NORMALIZE_HVZ","ARC","NORMALIZE_ST","QT_TO_C","INFO","SANITIZE","LINE_COMMANDS","MATRIX","ROTATE","TRANSLATE","SCALE","SKEW_X","atan","SKEW_Y","X_AXIS_SYMMETRY","Y_AXIS_SYMMETRY","A_TO_C","tan","H","ANNOTATE_ARCS","CLONE","CALCULATE_BOUNDS","maxX","minX","maxY","minY","DRAWING_COMMANDS","w","U","transform","toAbs","toRel","normalizeHVZ","normalizeST","qtToC","aToC","sanitize","translate","scale","rotate","matrix","skewX","skewY","xSymmetry","ySymmetry","annotateArcs","charCodeAt","curNumber","curCommandType","curCommandRelative","canParseCommandOrComma","curNumberHasExp","curNumberHasExpDigits","curNumberHasDecimal","curArgs","finish","parse","SyntaxError","getPrototypeOf","commands","encode","getBounds","prefix","invariant","provided"],"sourceRoot":""}