From 7c284957081f59659e5a443fc26c00fbd59b931d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 13 Dec 2022 19:18:44 +0900 Subject: [PATCH 01/27] Add tests --- .../server/middleware-build-manifest/input.js | 1 + .../input.js | 1 + .../_buildManifest/input.js | 1 + .../_ssgManifest/input.js | 1 + .../chunks/94-cfb59e87e57b535d/input.js | 3638 +++++++++++ .../framework-6d1b27d161789b4d/input.js | 496 ++ .../chunks/main-238559e1edeaaf10/input.js | 5784 +++++++++++++++++ .../pages/_app-4e4fc8868b6ba5bc/input.js | 55 + .../pages/_error-1c679e8edaa37665/input.js | 25 + .../pages/index-ddba972a3aa5ce15/input.js | 155 + .../chunks/webpack-d8d0d5dfdfeffdbf/input.js | 177 + 11 files changed, 10334 insertions(+) create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-build-manifest/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-react-loadable-manifest/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_buildManifest/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_ssgManifest/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/94-cfb59e87e57b535d/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/framework-6d1b27d161789b4d/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/main-238559e1edeaaf10/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/pages/_app-4e4fc8868b6ba5bc/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/pages/_error-1c679e8edaa37665/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/pages/index-ddba972a3aa5ce15/input.js create mode 100644 crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/webpack-d8d0d5dfdfeffdbf/input.js diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-build-manifest/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-build-manifest/input.js new file mode 100644 index 000000000000..6b2e49e949a9 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-build-manifest/input.js @@ -0,0 +1 @@ +self.__BUILD_MANIFEST={"polyfillFiles":["static/chunks/polyfills-c67a75d1b6f99dc8.js"],"devFiles":[],"ampDevFiles":[],"lowPriorityFiles":["static/Potx212XSyctRKKUwQJin/_buildManifest.js","static/Potx212XSyctRKKUwQJin/_ssgManifest.js"],"rootMainFiles":[],"pages":{"/":["static/chunks/webpack-d8d0d5dfdfeffdbf.js","static/chunks/framework-6d1b27d161789b4d.js","static/chunks/main-238559e1edeaaf10.js","static/chunks/94-cfb59e87e57b535d.js","static/chunks/pages/index-ddba972a3aa5ce15.js"],"/_app":["static/chunks/webpack-d8d0d5dfdfeffdbf.js","static/chunks/framework-6d1b27d161789b4d.js","static/chunks/main-238559e1edeaaf10.js","static/css/e642fefc6f19f6c3.css","static/chunks/pages/_app-4e4fc8868b6ba5bc.js"],"/_error":["static/chunks/webpack-d8d0d5dfdfeffdbf.js","static/chunks/framework-6d1b27d161789b4d.js","static/chunks/main-238559e1edeaaf10.js","static/chunks/pages/_error-1c679e8edaa37665.js"]},"ampFirstPages":[]} \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-react-loadable-manifest/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-react-loadable-manifest/input.js new file mode 100644 index 000000000000..7f1b4e589ecc --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/server/middleware-react-loadable-manifest/input.js @@ -0,0 +1 @@ +self.__REACT_LOADABLE_MANIFEST={} \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_buildManifest/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_buildManifest/input.js new file mode 100644 index 000000000000..29d9bb7745a9 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_buildManifest/input.js @@ -0,0 +1 @@ +self.__BUILD_MANIFEST = {__rewrites:{beforeFiles:[],afterFiles:[],fallback:[]},"/":["static\u002Fchunks\u002F94-cfb59e87e57b535d.js","static\u002Fchunks\u002Fpages\u002Findex-ddba972a3aa5ce15.js"],"/_error":["static\u002Fchunks\u002Fpages\u002F_error-1c679e8edaa37665.js"],sortedPages:["\u002F","\u002F_app","\u002F_error"]};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB() \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_ssgManifest/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_ssgManifest/input.js new file mode 100644 index 000000000000..2260768dc5ed --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/Potx212XSyctRKKUwQJin/_ssgManifest/input.js @@ -0,0 +1 @@ +self.__SSG_MANIFEST=new Set;self.__SSG_MANIFEST_CB&&self.__SSG_MANIFEST_CB() \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/94-cfb59e87e57b535d/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/94-cfb59e87e57b535d/input.js new file mode 100644 index 000000000000..c57204af76b1 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/94-cfb59e87e57b535d/input.js @@ -0,0 +1,3638 @@ +"use strict"; +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[94],{ + +/***/ 4094: +/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { + +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "b7": function() { return /* binding */ useReactTable; }, +/* harmony export */ "ie": function() { return /* binding */ flexRender; } +/* harmony export */ }); +/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7294); +/* harmony import */ var _tanstack_table_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7060); +/** + * react-table + * + * Copyright (c) TanStack + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */ + + + + +// + +function flexRender(Comp, props) { + return !Comp ? null : isReactComponent(Comp) ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Comp, props) : Comp; +} +function isReactComponent(component) { + return isClassComponent(component) || typeof component === 'function' || isExoticComponent(component); +} +function isClassComponent(component) { + return typeof component === 'function' && (() => { + const proto = Object.getPrototypeOf(component); + return proto.prototype && proto.prototype.isReactComponent; + })(); +} +function isExoticComponent(component) { + return typeof component === 'object' && typeof component.$$typeof === 'symbol' && ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description); +} +function useReactTable(options) { + // Compose in the generic options to the user options + const resolvedOptions = { + state: {}, + // Dummy state + onStateChange: () => {}, + // noop + renderFallbackValue: null, + ...options + }; + + // Create a new table and store it in state + const [tableRef] = react__WEBPACK_IMPORTED_MODULE_0__.useState(() => ({ + current: (0,_tanstack_table_core__WEBPACK_IMPORTED_MODULE_1__/* .createTable */ .W_)(resolvedOptions) + })); + + // By default, manage table state here using the table's initial state + const [state, setState] = react__WEBPACK_IMPORTED_MODULE_0__.useState(() => tableRef.current.initialState); + + // Compose the default state above with any user state. This will allow the user + // to only control a subset of the state if desired. + tableRef.current.setOptions(prev => ({ + ...prev, + ...options, + state: { + ...state, + ...options.state + }, + // Similarly, we'll maintain both our internal state and any user-provided + // state. + onStateChange: updater => { + setState(updater); + options.onStateChange?.(updater); + } + })); + return tableRef.current; +} + + +//# sourceMappingURL=index.mjs.map + + +/***/ }), + +/***/ 7060: +/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { + +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "Cl": function() { return /* binding */ createColumnHelper; }, +/* harmony export */ "W_": function() { return /* binding */ createTable; }, +/* harmony export */ "sC": function() { return /* binding */ getCoreRowModel; } +/* harmony export */ }); +/* unused harmony exports ColumnSizing, Expanding, Filters, Grouping, Headers, Ordering, Pagination, Pinning, RowSelection, Sorting, Visibility, aggregationFns, buildHeaderGroups, createCell, createColumn, createRow, defaultColumnSizing, expandRows, filterFns, flattenBy, functionalUpdate, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getPaginationRowModel, getSortedRowModel, isFunction, isRowSelected, isSubRowSelected, makeStateUpdater, memo, noop, orderColumns, passiveEventSupported, reSplitAlphaNumeric, selectRowsFn, shouldAutoRemoveFilter, sortingFns */ +/** + * table-core + * + * Copyright (c) TanStack + * + * This source code is licensed under the MIT license found in the + * LICENSE.md file in the root directory of this source tree. + * + * @license MIT + */ +// Is this type a tuple? + +// If this type is a tuple, what indices are allowed? + +/// + +function functionalUpdate(updater, input) { + return typeof updater === 'function' ? updater(input) : updater; +} +function noop() { + // +} +function makeStateUpdater(key, instance) { + return updater => { + instance.setState(old => { + return { + ...old, + [key]: functionalUpdate(updater, old[key]) + }; + }); + }; +} +function isFunction(d) { + return d instanceof Function; +} +function flattenBy(arr, getChildren) { + const flat = []; + const recurse = subArr => { + subArr.forEach(item => { + flat.push(item); + const children = getChildren(item); + if (children?.length) { + recurse(children); + } + }); + }; + recurse(arr); + return flat; +} +function memo(getDeps, fn, opts) { + let deps = []; + let result; + return () => { + let depTime; + if (opts.key && opts.debug) depTime = Date.now(); + const newDeps = getDeps(); + const depsChanged = newDeps.length !== deps.length || newDeps.some((dep, index) => deps[index] !== dep); + if (!depsChanged) { + return result; + } + deps = newDeps; + let resultTime; + if (opts.key && opts.debug) resultTime = Date.now(); + result = fn(...newDeps); + opts?.onChange?.(result); + if (opts.key && opts.debug) { + if (opts?.debug()) { + const depEndTime = Math.round((Date.now() - depTime) * 100) / 100; + const resultEndTime = Math.round((Date.now() - resultTime) * 100) / 100; + const resultFpsPercentage = resultEndTime / 16; + const pad = (str, num) => { + str = String(str); + while (str.length < num) { + str = ' ' + str; + } + return str; + }; + console.info(`%c⏱ ${pad(resultEndTime, 5)} /${pad(depEndTime, 5)} ms`, ` + font-size: .6rem; + font-weight: bold; + color: hsl(${Math.max(0, Math.min(120 - 120 * resultFpsPercentage, 120))}deg 100% 31%);`, opts?.key); + } + } + return result; + }; +} + +function createColumn(table, columnDef, depth, parent) { + var _ref, _resolvedColumnDef$id; + const defaultColumn = table._getDefaultColumnDef(); + const resolvedColumnDef = { + ...defaultColumn, + ...columnDef + }; + const accessorKey = resolvedColumnDef.accessorKey; + let id = (_ref = (_resolvedColumnDef$id = resolvedColumnDef.id) != null ? _resolvedColumnDef$id : accessorKey ? accessorKey.replace('.', '_') : undefined) != null ? _ref : typeof resolvedColumnDef.header === 'string' ? resolvedColumnDef.header : undefined; + let accessorFn; + if (resolvedColumnDef.accessorFn) { + accessorFn = resolvedColumnDef.accessorFn; + } else if (accessorKey) { + // Support deep accessor keys + if (accessorKey.includes('.')) { + accessorFn = originalRow => { + let result = originalRow; + for (const key of accessorKey.split('.')) { + result = result[key]; + if (false) {} + } + return result; + }; + } else { + accessorFn = originalRow => originalRow[resolvedColumnDef.accessorKey]; + } + } + if (!id) { + if (false) {} + throw new Error(); + } + let column = { + id: `${String(id)}`, + accessorFn, + parent: parent, + depth, + columnDef: resolvedColumnDef, + columns: [], + getFlatColumns: memo(() => [true], () => { + return [column, ...column.columns?.flatMap(d => d.getFlatColumns())]; + }, { + key: true && 'column.getFlatColumns', + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugColumns; + } + }), + getLeafColumns: memo(() => [table._getOrderColumnsFn()], orderColumns => { + if (column.columns?.length) { + let leafColumns = column.columns.flatMap(column => column.getLeafColumns()); + return orderColumns(leafColumns); + } + return [column]; + }, { + key: true && 'column.getLeafColumns', + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugColumns; + } + }) + }; + column = table._features.reduce((obj, feature) => { + return Object.assign(obj, feature.createColumn?.(column, table)); + }, column); + + // Yes, we have to convert table to uknown, because we know more than the compiler here. + return column; +} + +// + +function createHeader(table, column, options) { + var _options$id; + const id = (_options$id = options.id) != null ? _options$id : column.id; + let header = { + id, + column, + index: options.index, + isPlaceholder: !!options.isPlaceholder, + placeholderId: options.placeholderId, + depth: options.depth, + subHeaders: [], + colSpan: 0, + rowSpan: 0, + headerGroup: null, + getLeafHeaders: () => { + const leafHeaders = []; + const recurseHeader = h => { + if (h.subHeaders && h.subHeaders.length) { + h.subHeaders.map(recurseHeader); + } + leafHeaders.push(h); + }; + recurseHeader(header); + return leafHeaders; + }, + getContext: () => ({ + table, + header: header, + column + }) + }; + table._features.forEach(feature => { + Object.assign(header, feature.createHeader?.(header, table)); + }); + return header; +} +const Headers = { + createTable: table => { + return { + // Header Groups + + getHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => { + var _left$map$filter, _right$map$filter; + const leftColumns = (_left$map$filter = left?.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter : []; + const rightColumns = (_right$map$filter = right?.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter : []; + const centerColumns = leafColumns.filter(column => !left?.includes(column.id) && !right?.includes(column.id)); + const headerGroups = buildHeaderGroups(allColumns, [...leftColumns, ...centerColumns, ...rightColumns], table); + return headerGroups; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugHeaders; + } + }), + getCenterHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, leafColumns, left, right) => { + leafColumns = leafColumns.filter(column => !left?.includes(column.id) && !right?.includes(column.id)); + return buildHeaderGroups(allColumns, leafColumns, table, 'center'); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugHeaders; + } + }), + getLeftHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.left], (allColumns, leafColumns, left) => { + var _left$map$filter2; + const orderedLeafColumns = (_left$map$filter2 = left?.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _left$map$filter2 : []; + return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'left'); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA3; + return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugHeaders; + } + }), + getRightHeaderGroups: memo(() => [table.getAllColumns(), table.getVisibleLeafColumns(), table.getState().columnPinning.right], (allColumns, leafColumns, right) => { + var _right$map$filter2; + const orderedLeafColumns = (_right$map$filter2 = right?.map(columnId => leafColumns.find(d => d.id === columnId)).filter(Boolean)) != null ? _right$map$filter2 : []; + return buildHeaderGroups(allColumns, orderedLeafColumns, table, 'right'); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA4; + return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugHeaders; + } + }), + // Footer Groups + + getFooterGroups: memo(() => [table.getHeaderGroups()], headerGroups => { + return [...headerGroups].reverse(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA5; + return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugHeaders; + } + }), + getLeftFooterGroups: memo(() => [table.getLeftHeaderGroups()], headerGroups => { + return [...headerGroups].reverse(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA6; + return (_table$options$debugA6 = table.options.debugAll) != null ? _table$options$debugA6 : table.options.debugHeaders; + } + }), + getCenterFooterGroups: memo(() => [table.getCenterHeaderGroups()], headerGroups => { + return [...headerGroups].reverse(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA7; + return (_table$options$debugA7 = table.options.debugAll) != null ? _table$options$debugA7 : table.options.debugHeaders; + } + }), + getRightFooterGroups: memo(() => [table.getRightHeaderGroups()], headerGroups => { + return [...headerGroups].reverse(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA8; + return (_table$options$debugA8 = table.options.debugAll) != null ? _table$options$debugA8 : table.options.debugHeaders; + } + }), + // Flat Headers + + getFlatHeaders: memo(() => [table.getHeaderGroups()], headerGroups => { + return headerGroups.map(headerGroup => { + return headerGroup.headers; + }).flat(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA9; + return (_table$options$debugA9 = table.options.debugAll) != null ? _table$options$debugA9 : table.options.debugHeaders; + } + }), + getLeftFlatHeaders: memo(() => [table.getLeftHeaderGroups()], left => { + return left.map(headerGroup => { + return headerGroup.headers; + }).flat(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA10; + return (_table$options$debugA10 = table.options.debugAll) != null ? _table$options$debugA10 : table.options.debugHeaders; + } + }), + getCenterFlatHeaders: memo(() => [table.getCenterHeaderGroups()], left => { + return left.map(headerGroup => { + return headerGroup.headers; + }).flat(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA11; + return (_table$options$debugA11 = table.options.debugAll) != null ? _table$options$debugA11 : table.options.debugHeaders; + } + }), + getRightFlatHeaders: memo(() => [table.getRightHeaderGroups()], left => { + return left.map(headerGroup => { + return headerGroup.headers; + }).flat(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA12; + return (_table$options$debugA12 = table.options.debugAll) != null ? _table$options$debugA12 : table.options.debugHeaders; + } + }), + // Leaf Headers + + getCenterLeafHeaders: memo(() => [table.getCenterFlatHeaders()], flatHeaders => { + return flatHeaders.filter(header => !header.subHeaders?.length); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA13; + return (_table$options$debugA13 = table.options.debugAll) != null ? _table$options$debugA13 : table.options.debugHeaders; + } + }), + getLeftLeafHeaders: memo(() => [table.getLeftFlatHeaders()], flatHeaders => { + return flatHeaders.filter(header => !header.subHeaders?.length); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA14; + return (_table$options$debugA14 = table.options.debugAll) != null ? _table$options$debugA14 : table.options.debugHeaders; + } + }), + getRightLeafHeaders: memo(() => [table.getRightFlatHeaders()], flatHeaders => { + return flatHeaders.filter(header => !header.subHeaders?.length); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA15; + return (_table$options$debugA15 = table.options.debugAll) != null ? _table$options$debugA15 : table.options.debugHeaders; + } + }), + getLeafHeaders: memo(() => [table.getLeftHeaderGroups(), table.getCenterHeaderGroups(), table.getRightHeaderGroups()], (left, center, right) => { + var _left$0$headers, _center$0$headers, _right$0$headers; + return [...((_left$0$headers = left[0]?.headers) != null ? _left$0$headers : []), ...((_center$0$headers = center[0]?.headers) != null ? _center$0$headers : []), ...((_right$0$headers = right[0]?.headers) != null ? _right$0$headers : [])].map(header => { + return header.getLeafHeaders(); + }).flat(); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA16; + return (_table$options$debugA16 = table.options.debugAll) != null ? _table$options$debugA16 : table.options.debugHeaders; + } + }) + }; + } +}; +function buildHeaderGroups(allColumns, columnsToGroup, table, headerFamily) { + var _headerGroups$0$heade; + // Find the max depth of the columns: + // build the leaf column row + // build each buffer row going up + // placeholder for non-existent level + // real column for existing level + + let maxDepth = 0; + const findMaxDepth = function (columns, depth) { + if (depth === void 0) { + depth = 1; + } + maxDepth = Math.max(maxDepth, depth); + columns.filter(column => column.getIsVisible()).forEach(column => { + if (column.columns?.length) { + findMaxDepth(column.columns, depth + 1); + } + }, 0); + }; + findMaxDepth(allColumns); + let headerGroups = []; + const createHeaderGroup = (headersToGroup, depth) => { + // The header group we are creating + const headerGroup = { + depth, + id: [headerFamily, `${depth}`].filter(Boolean).join('_'), + headers: [] + }; + + // The parent columns we're going to scan next + const pendingParentHeaders = []; + + // Scan each column for parents + headersToGroup.forEach(headerToGroup => { + // What is the latest (last) parent column? + + const latestPendingParentHeader = [...pendingParentHeaders].reverse()[0]; + const isLeafHeader = headerToGroup.column.depth === headerGroup.depth; + let column; + let isPlaceholder = false; + if (isLeafHeader && headerToGroup.column.parent) { + // The parent header is new + column = headerToGroup.column.parent; + } else { + // The parent header is repeated + column = headerToGroup.column; + isPlaceholder = true; + } + if (latestPendingParentHeader && latestPendingParentHeader?.column === column) { + // This column is repeated. Add it as a sub header to the next batch + latestPendingParentHeader.subHeaders.push(headerToGroup); + } else { + // This is a new header. Let's create it + const header = createHeader(table, column, { + id: [headerFamily, depth, column.id, headerToGroup?.id].filter(Boolean).join('_'), + isPlaceholder, + placeholderId: isPlaceholder ? `${pendingParentHeaders.filter(d => d.column === column).length}` : undefined, + depth, + index: pendingParentHeaders.length + }); + + // Add the headerToGroup as a subHeader of the new header + header.subHeaders.push(headerToGroup); + // Add the new header to the pendingParentHeaders to get grouped + // in the next batch + pendingParentHeaders.push(header); + } + headerGroup.headers.push(headerToGroup); + headerToGroup.headerGroup = headerGroup; + }); + headerGroups.push(headerGroup); + if (depth > 0) { + createHeaderGroup(pendingParentHeaders, depth - 1); + } + }; + const bottomHeaders = columnsToGroup.map((column, index) => createHeader(table, column, { + depth: maxDepth, + index + })); + createHeaderGroup(bottomHeaders, maxDepth - 1); + headerGroups.reverse(); + + // headerGroups = headerGroups.filter(headerGroup => { + // return !headerGroup.headers.every(header => header.isPlaceholder) + // }) + + const recurseHeadersForSpans = headers => { + const filteredHeaders = headers.filter(header => header.column.getIsVisible()); + return filteredHeaders.map(header => { + let colSpan = 0; + let rowSpan = 0; + let childRowSpans = [0]; + if (header.subHeaders && header.subHeaders.length) { + childRowSpans = []; + recurseHeadersForSpans(header.subHeaders).forEach(_ref => { + let { + colSpan: childColSpan, + rowSpan: childRowSpan + } = _ref; + colSpan += childColSpan; + childRowSpans.push(childRowSpan); + }); + } else { + colSpan = 1; + } + const minChildRowSpan = Math.min(...childRowSpans); + rowSpan = rowSpan + minChildRowSpan; + header.colSpan = colSpan; + header.rowSpan = rowSpan; + return { + colSpan, + rowSpan + }; + }); + }; + recurseHeadersForSpans((_headerGroups$0$heade = headerGroups[0]?.headers) != null ? _headerGroups$0$heade : []); + return headerGroups; +} + +// + +const defaultColumnSizing = { + size: 150, + minSize: 20, + maxSize: Number.MAX_SAFE_INTEGER +}; +const getDefaultColumnSizingInfoState = () => ({ + startOffset: null, + startSize: null, + deltaOffset: null, + deltaPercentage: null, + isResizingColumn: false, + columnSizingStart: [] +}); +const ColumnSizing = { + getDefaultColumnDef: () => { + return defaultColumnSizing; + }, + getInitialState: state => { + return { + columnSizing: {}, + columnSizingInfo: getDefaultColumnSizingInfoState(), + ...state + }; + }, + getDefaultOptions: table => { + return { + columnResizeMode: 'onEnd', + onColumnSizingChange: makeStateUpdater('columnSizing', table), + onColumnSizingInfoChange: makeStateUpdater('columnSizingInfo', table) + }; + }, + createColumn: (column, table) => { + return { + getSize: () => { + var _column$columnDef$min, _ref, _column$columnDef$max; + const columnSize = table.getState().columnSizing[column.id]; + return Math.min(Math.max((_column$columnDef$min = column.columnDef.minSize) != null ? _column$columnDef$min : defaultColumnSizing.minSize, (_ref = columnSize != null ? columnSize : column.columnDef.size) != null ? _ref : defaultColumnSizing.size), (_column$columnDef$max = column.columnDef.maxSize) != null ? _column$columnDef$max : defaultColumnSizing.maxSize); + }, + getStart: position => { + const columns = !position ? table.getVisibleLeafColumns() : position === 'left' ? table.getLeftVisibleLeafColumns() : table.getRightVisibleLeafColumns(); + const index = columns.findIndex(d => d.id === column.id); + if (index > 0) { + const prevSiblingColumn = columns[index - 1]; + return prevSiblingColumn.getStart(position) + prevSiblingColumn.getSize(); + } + return 0; + }, + resetSize: () => { + table.setColumnSizing(_ref2 => { + let { + [column.id]: _, + ...rest + } = _ref2; + return rest; + }); + }, + getCanResize: () => { + var _column$columnDef$ena, _table$options$enable; + return ((_column$columnDef$ena = column.columnDef.enableResizing) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnResizing) != null ? _table$options$enable : true); + }, + getIsResizing: () => { + return table.getState().columnSizingInfo.isResizingColumn === column.id; + } + }; + }, + createHeader: (header, table) => { + return { + getSize: () => { + let sum = 0; + const recurse = header => { + if (header.subHeaders.length) { + header.subHeaders.forEach(recurse); + } else { + var _header$column$getSiz; + sum += (_header$column$getSiz = header.column.getSize()) != null ? _header$column$getSiz : 0; + } + }; + recurse(header); + return sum; + }, + getStart: () => { + if (header.index > 0) { + const prevSiblingHeader = header.headerGroup.headers[header.index - 1]; + return prevSiblingHeader.getStart() + prevSiblingHeader.getSize(); + } + return 0; + }, + getResizeHandler: () => { + const column = table.getColumn(header.column.id); + const canResize = column.getCanResize(); + return e => { + if (!canResize) { + return; + } + e.persist?.(); + if (isTouchStartEvent(e)) { + // lets not respond to multiple touches (e.g. 2 or 3 fingers) + if (e.touches && e.touches.length > 1) { + return; + } + } + const startSize = header.getSize(); + const columnSizingStart = header ? header.getLeafHeaders().map(d => [d.column.id, d.column.getSize()]) : [[column.id, column.getSize()]]; + const clientX = isTouchStartEvent(e) ? Math.round(e.touches[0].clientX) : e.clientX; + const newColumnSizing = {}; + const updateOffset = (eventType, clientXPos) => { + if (typeof clientXPos !== 'number') { + return; + } + table.setColumnSizingInfo(old => { + var _old$startOffset, _old$startSize; + const deltaOffset = clientXPos - ((_old$startOffset = old?.startOffset) != null ? _old$startOffset : 0); + const deltaPercentage = Math.max(deltaOffset / ((_old$startSize = old?.startSize) != null ? _old$startSize : 0), -0.999999); + old.columnSizingStart.forEach(_ref3 => { + let [columnId, headerSize] = _ref3; + newColumnSizing[columnId] = Math.round(Math.max(headerSize + headerSize * deltaPercentage, 0) * 100) / 100; + }); + return { + ...old, + deltaOffset, + deltaPercentage + }; + }); + if (table.options.columnResizeMode === 'onChange' || eventType === 'end') { + table.setColumnSizing(old => ({ + ...old, + ...newColumnSizing + })); + } + }; + const onMove = clientXPos => updateOffset('move', clientXPos); + const onEnd = clientXPos => { + updateOffset('end', clientXPos); + table.setColumnSizingInfo(old => ({ + ...old, + isResizingColumn: false, + startOffset: null, + startSize: null, + deltaOffset: null, + deltaPercentage: null, + columnSizingStart: [] + })); + }; + const mouseEvents = { + moveHandler: e => onMove(e.clientX), + upHandler: e => { + document.removeEventListener('mousemove', mouseEvents.moveHandler); + document.removeEventListener('mouseup', mouseEvents.upHandler); + onEnd(e.clientX); + } + }; + const touchEvents = { + moveHandler: e => { + if (e.cancelable) { + e.preventDefault(); + e.stopPropagation(); + } + onMove(e.touches[0].clientX); + return false; + }, + upHandler: e => { + document.removeEventListener('touchmove', touchEvents.moveHandler); + document.removeEventListener('touchend', touchEvents.upHandler); + if (e.cancelable) { + e.preventDefault(); + e.stopPropagation(); + } + onEnd(e.touches[0]?.clientX); + } + }; + const passiveIfSupported = passiveEventSupported() ? { + passive: false + } : false; + if (isTouchStartEvent(e)) { + document.addEventListener('touchmove', touchEvents.moveHandler, passiveIfSupported); + document.addEventListener('touchend', touchEvents.upHandler, passiveIfSupported); + } else { + document.addEventListener('mousemove', mouseEvents.moveHandler, passiveIfSupported); + document.addEventListener('mouseup', mouseEvents.upHandler, passiveIfSupported); + } + table.setColumnSizingInfo(old => ({ + ...old, + startOffset: clientX, + startSize, + deltaOffset: 0, + deltaPercentage: 0, + columnSizingStart, + isResizingColumn: column.id + })); + }; + } + }; + }, + createTable: table => { + return { + setColumnSizing: updater => table.options.onColumnSizingChange?.(updater), + setColumnSizingInfo: updater => table.options.onColumnSizingInfoChange?.(updater), + resetColumnSizing: defaultState => { + var _table$initialState$c; + table.setColumnSizing(defaultState ? {} : (_table$initialState$c = table.initialState.columnSizing) != null ? _table$initialState$c : {}); + }, + resetHeaderSizeInfo: defaultState => { + var _table$initialState$c2; + table.setColumnSizingInfo(defaultState ? getDefaultColumnSizingInfoState() : (_table$initialState$c2 = table.initialState.columnSizingInfo) != null ? _table$initialState$c2 : getDefaultColumnSizingInfoState()); + }, + getTotalSize: () => { + var _table$getHeaderGroup; + return (_table$getHeaderGroup = table.getHeaderGroups()[0]?.headers.reduce((sum, header) => { + return sum + header.getSize(); + }, 0)) != null ? _table$getHeaderGroup : 0; + }, + getLeftTotalSize: () => { + var _table$getLeftHeaderG; + return (_table$getLeftHeaderG = table.getLeftHeaderGroups()[0]?.headers.reduce((sum, header) => { + return sum + header.getSize(); + }, 0)) != null ? _table$getLeftHeaderG : 0; + }, + getCenterTotalSize: () => { + var _table$getCenterHeade; + return (_table$getCenterHeade = table.getCenterHeaderGroups()[0]?.headers.reduce((sum, header) => { + return sum + header.getSize(); + }, 0)) != null ? _table$getCenterHeade : 0; + }, + getRightTotalSize: () => { + var _table$getRightHeader; + return (_table$getRightHeader = table.getRightHeaderGroups()[0]?.headers.reduce((sum, header) => { + return sum + header.getSize(); + }, 0)) != null ? _table$getRightHeader : 0; + } + }; + } +}; +let passiveSupported = null; +function passiveEventSupported() { + if (typeof passiveSupported === 'boolean') return passiveSupported; + let supported = false; + try { + const options = { + get passive() { + supported = true; + return false; + } + }; + const noop = () => {}; + window.addEventListener('test', noop, options); + window.removeEventListener('test', noop); + } catch (err) { + supported = false; + } + passiveSupported = supported; + return passiveSupported; +} +function isTouchStartEvent(e) { + return e.type === 'touchstart'; +} + +// + +const Expanding = { + getInitialState: state => { + return { + expanded: {}, + ...state + }; + }, + getDefaultOptions: table => { + return { + onExpandedChange: makeStateUpdater('expanded', table), + paginateExpandedRows: true + }; + }, + createTable: table => { + let registered = false; + let queued = false; + return { + _autoResetExpanded: () => { + var _ref, _table$options$autoRe; + if (!registered) { + table._queue(() => { + registered = true; + }); + return; + } + if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetExpanded) != null ? _ref : !table.options.manualExpanding) { + if (queued) return; + queued = true; + table._queue(() => { + table.resetExpanded(); + queued = false; + }); + } + }, + setExpanded: updater => table.options.onExpandedChange?.(updater), + toggleAllRowsExpanded: expanded => { + if (expanded != null ? expanded : !table.getIsAllRowsExpanded()) { + table.setExpanded(true); + } else { + table.setExpanded({}); + } + }, + resetExpanded: defaultState => { + var _table$initialState$e; + table.setExpanded(defaultState ? {} : (_table$initialState$e = table.initialState?.expanded) != null ? _table$initialState$e : {}); + }, + getCanSomeRowsExpand: () => { + return table.getRowModel().flatRows.some(row => row.getCanExpand()); + }, + getToggleAllRowsExpandedHandler: () => { + return e => { + e.persist?.(); + table.toggleAllRowsExpanded(); + }; + }, + getIsSomeRowsExpanded: () => { + const expanded = table.getState().expanded; + return expanded === true || Object.values(expanded).some(Boolean); + }, + getIsAllRowsExpanded: () => { + const expanded = table.getState().expanded; + + // If expanded is true, save some cycles and return true + if (typeof expanded === 'boolean') { + return expanded === true; + } + if (!Object.keys(expanded).length) { + return false; + } + + // If any row is not expanded, return false + if (table.getRowModel().flatRows.some(row => !row.getIsExpanded())) { + return false; + } + + // They must all be expanded :shrug: + return true; + }, + getExpandedDepth: () => { + let maxDepth = 0; + const rowIds = table.getState().expanded === true ? Object.keys(table.getRowModel().rowsById) : Object.keys(table.getState().expanded); + rowIds.forEach(id => { + const splitId = id.split('.'); + maxDepth = Math.max(maxDepth, splitId.length); + }); + return maxDepth; + }, + getPreExpandedRowModel: () => table.getSortedRowModel(), + getExpandedRowModel: () => { + if (!table._getExpandedRowModel && table.options.getExpandedRowModel) { + table._getExpandedRowModel = table.options.getExpandedRowModel(table); + } + if (table.options.manualExpanding || !table._getExpandedRowModel) { + return table.getPreExpandedRowModel(); + } + return table._getExpandedRowModel(); + } + }; + }, + createRow: (row, table) => { + return { + toggleExpanded: expanded => { + table.setExpanded(old => { + var _expanded; + const exists = old === true ? true : !!old?.[row.id]; + let oldExpanded = {}; + if (old === true) { + Object.keys(table.getRowModel().rowsById).forEach(rowId => { + oldExpanded[rowId] = true; + }); + } else { + oldExpanded = old; + } + expanded = (_expanded = expanded) != null ? _expanded : !exists; + if (!exists && expanded) { + return { + ...oldExpanded, + [row.id]: true + }; + } + if (exists && !expanded) { + const { + [row.id]: _, + ...rest + } = oldExpanded; + return rest; + } + return old; + }); + }, + getIsExpanded: () => { + var _table$options$getIsR; + const expanded = table.getState().expanded; + return !!((_table$options$getIsR = table.options.getIsRowExpanded?.(row)) != null ? _table$options$getIsR : expanded === true || expanded?.[row.id]); + }, + getCanExpand: () => { + var _table$options$getRow, _table$options$enable; + return (_table$options$getRow = table.options.getRowCanExpand?.(row)) != null ? _table$options$getRow : ((_table$options$enable = table.options.enableExpanding) != null ? _table$options$enable : true) && !!row.subRows?.length; + }, + getToggleExpandedHandler: () => { + const canExpand = row.getCanExpand(); + return () => { + if (!canExpand) return; + row.toggleExpanded(); + }; + } + }; + } +}; + +const includesString = (row, columnId, filterValue) => { + const search = filterValue.toLowerCase(); + return Boolean(row.getValue(columnId)?.toLowerCase().includes(search)); +}; +includesString.autoRemove = val => testFalsey(val); +const includesStringSensitive = (row, columnId, filterValue) => { + return Boolean(row.getValue(columnId)?.includes(filterValue)); +}; +includesStringSensitive.autoRemove = val => testFalsey(val); +const equalsString = (row, columnId, filterValue) => { + return row.getValue(columnId)?.toLowerCase() === filterValue.toLowerCase(); +}; +equalsString.autoRemove = val => testFalsey(val); +const arrIncludes = (row, columnId, filterValue) => { + return row.getValue(columnId)?.includes(filterValue); +}; +arrIncludes.autoRemove = val => testFalsey(val) || !val?.length; +const arrIncludesAll = (row, columnId, filterValue) => { + return !filterValue.some(val => !row.getValue(columnId)?.includes(val)); +}; +arrIncludesAll.autoRemove = val => testFalsey(val) || !val?.length; +const arrIncludesSome = (row, columnId, filterValue) => { + return filterValue.some(val => row.getValue(columnId)?.includes(val)); +}; +arrIncludesSome.autoRemove = val => testFalsey(val) || !val?.length; +const equals = (row, columnId, filterValue) => { + return row.getValue(columnId) === filterValue; +}; +equals.autoRemove = val => testFalsey(val); +const weakEquals = (row, columnId, filterValue) => { + return row.getValue(columnId) == filterValue; +}; +weakEquals.autoRemove = val => testFalsey(val); +const inNumberRange = (row, columnId, filterValue) => { + let [min, max] = filterValue; + const rowValue = row.getValue(columnId); + return rowValue >= min && rowValue <= max; +}; +inNumberRange.resolveFilterValue = val => { + let [unsafeMin, unsafeMax] = val; + let parsedMin = typeof unsafeMin !== 'number' ? parseFloat(unsafeMin) : unsafeMin; + let parsedMax = typeof unsafeMax !== 'number' ? parseFloat(unsafeMax) : unsafeMax; + let min = unsafeMin === null || Number.isNaN(parsedMin) ? -Infinity : parsedMin; + let max = unsafeMax === null || Number.isNaN(parsedMax) ? Infinity : parsedMax; + if (min > max) { + const temp = min; + min = max; + max = temp; + } + return [min, max]; +}; +inNumberRange.autoRemove = val => testFalsey(val) || testFalsey(val[0]) && testFalsey(val[1]); + +// Export + +const filterFns = { + includesString, + includesStringSensitive, + equalsString, + arrIncludes, + arrIncludesAll, + arrIncludesSome, + equals, + weakEquals, + inNumberRange +}; +// Utils + +function testFalsey(val) { + return val === undefined || val === null || val === ''; +} + +// + +const Filters = { + getDefaultColumnDef: () => { + return { + filterFn: 'auto' + }; + }, + getInitialState: state => { + return { + columnFilters: [], + globalFilter: undefined, + // filtersProgress: 1, + // facetProgress: {}, + ...state + }; + }, + getDefaultOptions: table => { + return { + onColumnFiltersChange: makeStateUpdater('columnFilters', table), + onGlobalFilterChange: makeStateUpdater('globalFilter', table), + filterFromLeafRows: false, + maxLeafRowFilterDepth: 100, + globalFilterFn: 'auto', + getColumnCanGlobalFilter: column => { + const value = table.getCoreRowModel().flatRows[0]?._getAllCellsByColumnId()[column.id]?.getValue(); + return typeof value === 'string' || typeof value === 'number'; + } + }; + }, + createColumn: (column, table) => { + return { + getAutoFilterFn: () => { + const firstRow = table.getCoreRowModel().flatRows[0]; + const value = firstRow?.getValue(column.id); + if (typeof value === 'string') { + return filterFns.includesString; + } + if (typeof value === 'number') { + return filterFns.inNumberRange; + } + if (typeof value === 'boolean') { + return filterFns.equals; + } + if (value !== null && typeof value === 'object') { + return filterFns.equals; + } + if (Array.isArray(value)) { + return filterFns.arrIncludes; + } + return filterFns.weakEquals; + }, + getFilterFn: () => { + var _table$options$filter; + return isFunction(column.columnDef.filterFn) ? column.columnDef.filterFn : column.columnDef.filterFn === 'auto' ? column.getAutoFilterFn() : // @ts-ignore + (_table$options$filter = table.options.filterFns?.[column.columnDef.filterFn]) != null ? _table$options$filter : filterFns[column.columnDef.filterFn]; + }, + getCanFilter: () => { + var _column$columnDef$ena, _table$options$enable, _table$options$enable2; + return ((_column$columnDef$ena = column.columnDef.enableColumnFilter) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableColumnFilters) != null ? _table$options$enable : true) && ((_table$options$enable2 = table.options.enableFilters) != null ? _table$options$enable2 : true) && !!column.accessorFn; + }, + getCanGlobalFilter: () => { + var _column$columnDef$ena2, _table$options$enable3, _table$options$enable4, _table$options$getCol; + return ((_column$columnDef$ena2 = column.columnDef.enableGlobalFilter) != null ? _column$columnDef$ena2 : true) && ((_table$options$enable3 = table.options.enableGlobalFilter) != null ? _table$options$enable3 : true) && ((_table$options$enable4 = table.options.enableFilters) != null ? _table$options$enable4 : true) && ((_table$options$getCol = table.options.getColumnCanGlobalFilter?.(column)) != null ? _table$options$getCol : true) && !!column.accessorFn; + }, + getIsFiltered: () => column.getFilterIndex() > -1, + getFilterValue: () => table.getState().columnFilters?.find(d => d.id === column.id)?.value, + getFilterIndex: () => { + var _table$getState$colum; + return (_table$getState$colum = table.getState().columnFilters?.findIndex(d => d.id === column.id)) != null ? _table$getState$colum : -1; + }, + setFilterValue: value => { + table.setColumnFilters(old => { + const filterFn = column.getFilterFn(); + const previousfilter = old?.find(d => d.id === column.id); + const newFilter = functionalUpdate(value, previousfilter ? previousfilter.value : undefined); + + // + if (shouldAutoRemoveFilter(filterFn, newFilter, column)) { + var _old$filter; + return (_old$filter = old?.filter(d => d.id !== column.id)) != null ? _old$filter : []; + } + const newFilterObj = { + id: column.id, + value: newFilter + }; + if (previousfilter) { + var _old$map; + return (_old$map = old?.map(d => { + if (d.id === column.id) { + return newFilterObj; + } + return d; + })) != null ? _old$map : []; + } + if (old?.length) { + return [...old, newFilterObj]; + } + return [newFilterObj]; + }); + }, + _getFacetedRowModel: table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, column.id), + getFacetedRowModel: () => { + if (!column._getFacetedRowModel) { + return table.getPreFilteredRowModel(); + } + return column._getFacetedRowModel(); + }, + _getFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, column.id), + getFacetedUniqueValues: () => { + if (!column._getFacetedUniqueValues) { + return new Map(); + } + return column._getFacetedUniqueValues(); + }, + _getFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, column.id), + getFacetedMinMaxValues: () => { + if (!column._getFacetedMinMaxValues) { + return undefined; + } + return column._getFacetedMinMaxValues(); + } + // () => [column.getFacetedRowModel()], + // facetedRowModel => getRowModelMinMaxValues(facetedRowModel, column.id), + }; + }, + + createRow: (row, table) => { + return { + columnFilters: {}, + columnFiltersMeta: {} + }; + }, + createTable: table => { + return { + getGlobalAutoFilterFn: () => { + return filterFns.includesString; + }, + getGlobalFilterFn: () => { + var _table$options$filter2; + const { + globalFilterFn: globalFilterFn + } = table.options; + return isFunction(globalFilterFn) ? globalFilterFn : globalFilterFn === 'auto' ? table.getGlobalAutoFilterFn() : // @ts-ignore + (_table$options$filter2 = table.options.filterFns?.[globalFilterFn]) != null ? _table$options$filter2 : filterFns[globalFilterFn]; + }, + setColumnFilters: updater => { + const leafColumns = table.getAllLeafColumns(); + const updateFn = old => { + return functionalUpdate(updater, old)?.filter(filter => { + const column = leafColumns.find(d => d.id === filter.id); + if (column) { + const filterFn = column.getFilterFn(); + if (shouldAutoRemoveFilter(filterFn, filter.value, column)) { + return false; + } + } + return true; + }); + }; + table.options.onColumnFiltersChange?.(updateFn); + }, + setGlobalFilter: updater => { + table.options.onGlobalFilterChange?.(updater); + }, + resetGlobalFilter: defaultState => { + table.setGlobalFilter(defaultState ? undefined : table.initialState.globalFilter); + }, + resetColumnFilters: defaultState => { + var _table$initialState$c; + table.setColumnFilters(defaultState ? [] : (_table$initialState$c = table.initialState?.columnFilters) != null ? _table$initialState$c : []); + }, + getPreFilteredRowModel: () => table.getCoreRowModel(), + getFilteredRowModel: () => { + if (!table._getFilteredRowModel && table.options.getFilteredRowModel) { + table._getFilteredRowModel = table.options.getFilteredRowModel(table); + } + if (table.options.manualFiltering || !table._getFilteredRowModel) { + return table.getPreFilteredRowModel(); + } + return table._getFilteredRowModel(); + }, + _getGlobalFacetedRowModel: table.options.getFacetedRowModel && table.options.getFacetedRowModel(table, '__global__'), + getGlobalFacetedRowModel: () => { + if (table.options.manualFiltering || !table._getGlobalFacetedRowModel) { + return table.getPreFilteredRowModel(); + } + return table._getGlobalFacetedRowModel(); + }, + _getGlobalFacetedUniqueValues: table.options.getFacetedUniqueValues && table.options.getFacetedUniqueValues(table, '__global__'), + getGlobalFacetedUniqueValues: () => { + if (!table._getGlobalFacetedUniqueValues) { + return new Map(); + } + return table._getGlobalFacetedUniqueValues(); + }, + _getGlobalFacetedMinMaxValues: table.options.getFacetedMinMaxValues && table.options.getFacetedMinMaxValues(table, '__global__'), + getGlobalFacetedMinMaxValues: () => { + if (!table._getGlobalFacetedMinMaxValues) { + return; + } + return table._getGlobalFacetedMinMaxValues(); + } + }; + } +}; +function shouldAutoRemoveFilter(filterFn, value, column) { + return (filterFn && filterFn.autoRemove ? filterFn.autoRemove(value, column) : false) || typeof value === 'undefined' || typeof value === 'string' && !value; +} + +const sum = (columnId, _leafRows, childRows) => { + // It's faster to just add the aggregations together instead of + // process leaf nodes individually + return childRows.reduce((sum, next) => { + const nextValue = next.getValue(columnId); + return sum + (typeof nextValue === 'number' ? nextValue : 0); + }, 0); +}; +const min = (columnId, _leafRows, childRows) => { + let min; + childRows.forEach(row => { + const value = row.getValue(columnId); + if (value != null && (min > value || min === undefined && value >= value)) { + min = value; + } + }); + return min; +}; +const max = (columnId, _leafRows, childRows) => { + let max; + childRows.forEach(row => { + const value = row.getValue(columnId); + if (value != null && (max < value || max === undefined && value >= value)) { + max = value; + } + }); + return max; +}; +const extent = (columnId, _leafRows, childRows) => { + let min; + let max; + childRows.forEach(row => { + const value = row.getValue(columnId); + if (value != null) { + if (min === undefined) { + if (value >= value) min = max = value; + } else { + if (min > value) min = value; + if (max < value) max = value; + } + } + }); + return [min, max]; +}; +const mean = (columnId, leafRows) => { + let count = 0; + let sum = 0; + leafRows.forEach(row => { + let value = row.getValue(columnId); + if (value != null && (value = +value) >= value) { + ++count, sum += value; + } + }); + if (count) return sum / count; + return; +}; +const median = (columnId, leafRows) => { + if (!leafRows.length) { + return; + } + let min = 0; + let max = 0; + leafRows.forEach(row => { + let value = row.getValue(columnId); + if (typeof value === 'number') { + min = Math.min(min, value); + max = Math.max(max, value); + } + }); + return (min + max) / 2; +}; +const unique = (columnId, leafRows) => { + return Array.from(new Set(leafRows.map(d => d.getValue(columnId))).values()); +}; +const uniqueCount = (columnId, leafRows) => { + return new Set(leafRows.map(d => d.getValue(columnId))).size; +}; +const count = (_columnId, leafRows) => { + return leafRows.length; +}; +const aggregationFns = { + sum, + min, + max, + extent, + mean, + median, + unique, + uniqueCount, + count +}; + +// + +const Grouping = { + getDefaultColumnDef: () => { + return { + aggregatedCell: props => { + var _toString; + return (_toString = props.getValue()?.toString?.()) != null ? _toString : null; + }, + aggregationFn: 'auto' + }; + }, + getInitialState: state => { + return { + grouping: [], + ...state + }; + }, + getDefaultOptions: table => { + return { + onGroupingChange: makeStateUpdater('grouping', table), + groupedColumnMode: 'reorder' + }; + }, + createColumn: (column, table) => { + return { + toggleGrouping: () => { + table.setGrouping(old => { + // Find any existing grouping for this column + if (old?.includes(column.id)) { + return old.filter(d => d !== column.id); + } + return [...(old != null ? old : []), column.id]; + }); + }, + getCanGroup: () => { + var _ref, _ref2, _ref3, _column$columnDef$ena; + return (_ref = (_ref2 = (_ref3 = (_column$columnDef$ena = column.columnDef.enableGrouping) != null ? _column$columnDef$ena : true) != null ? _ref3 : table.options.enableGrouping) != null ? _ref2 : true) != null ? _ref : !!column.accessorFn; + }, + getIsGrouped: () => { + return table.getState().grouping?.includes(column.id); + }, + getGroupedIndex: () => table.getState().grouping?.indexOf(column.id), + getToggleGroupingHandler: () => { + const canGroup = column.getCanGroup(); + return () => { + if (!canGroup) return; + column.toggleGrouping(); + }; + }, + getAutoAggregationFn: () => { + const firstRow = table.getCoreRowModel().flatRows[0]; + const value = firstRow?.getValue(column.id); + if (typeof value === 'number') { + return aggregationFns.sum; + } + if (Object.prototype.toString.call(value) === '[object Date]') { + return aggregationFns.extent; + } + }, + getAggregationFn: () => { + var _table$options$aggreg; + if (!column) { + throw new Error(); + } + return isFunction(column.columnDef.aggregationFn) ? column.columnDef.aggregationFn : column.columnDef.aggregationFn === 'auto' ? column.getAutoAggregationFn() : (_table$options$aggreg = table.options.aggregationFns?.[column.columnDef.aggregationFn]) != null ? _table$options$aggreg : aggregationFns[column.columnDef.aggregationFn]; + } + }; + }, + createTable: table => { + return { + setGrouping: updater => table.options.onGroupingChange?.(updater), + resetGrouping: defaultState => { + var _table$initialState$g; + table.setGrouping(defaultState ? [] : (_table$initialState$g = table.initialState?.grouping) != null ? _table$initialState$g : []); + }, + getPreGroupedRowModel: () => table.getFilteredRowModel(), + getGroupedRowModel: () => { + if (!table._getGroupedRowModel && table.options.getGroupedRowModel) { + table._getGroupedRowModel = table.options.getGroupedRowModel(table); + } + if (table.options.manualGrouping || !table._getGroupedRowModel) { + return table.getPreGroupedRowModel(); + } + return table._getGroupedRowModel(); + } + }; + }, + createRow: row => { + return { + getIsGrouped: () => !!row.groupingColumnId, + _groupingValuesCache: {} + }; + }, + createCell: (cell, column, row, table) => { + return { + getIsGrouped: () => column.getIsGrouped() && column.id === row.groupingColumnId, + getIsPlaceholder: () => !cell.getIsGrouped() && column.getIsGrouped(), + getIsAggregated: () => !cell.getIsGrouped() && !cell.getIsPlaceholder() && !!row.subRows?.length + }; + } +}; +function orderColumns(leafColumns, grouping, groupedColumnMode) { + if (!grouping?.length || !groupedColumnMode) { + return leafColumns; + } + const nonGroupingColumns = leafColumns.filter(col => !grouping.includes(col.id)); + if (groupedColumnMode === 'remove') { + return nonGroupingColumns; + } + const groupingColumns = grouping.map(g => leafColumns.find(col => col.id === g)).filter(Boolean); + return [...groupingColumns, ...nonGroupingColumns]; +} + +// + +const Ordering = { + getInitialState: state => { + return { + columnOrder: [], + ...state + }; + }, + getDefaultOptions: table => { + return { + onColumnOrderChange: makeStateUpdater('columnOrder', table) + }; + }, + createTable: table => { + return { + setColumnOrder: updater => table.options.onColumnOrderChange?.(updater), + resetColumnOrder: defaultState => { + var _table$initialState$c; + table.setColumnOrder(defaultState ? [] : (_table$initialState$c = table.initialState.columnOrder) != null ? _table$initialState$c : []); + }, + _getOrderColumnsFn: memo(() => [table.getState().columnOrder, table.getState().grouping, table.options.groupedColumnMode], (columnOrder, grouping, groupedColumnMode) => columns => { + // Sort grouped columns to the start of the column list + // before the headers are built + let orderedColumns = []; + + // If there is no order, return the normal columns + if (!columnOrder?.length) { + orderedColumns = columns; + } else { + const columnOrderCopy = [...columnOrder]; + + // If there is an order, make a copy of the columns + const columnsCopy = [...columns]; + + // And make a new ordered array of the columns + + // Loop over the columns and place them in order into the new array + while (columnsCopy.length && columnOrderCopy.length) { + const targetColumnId = columnOrderCopy.shift(); + const foundIndex = columnsCopy.findIndex(d => d.id === targetColumnId); + if (foundIndex > -1) { + orderedColumns.push(columnsCopy.splice(foundIndex, 1)[0]); + } + } + + // If there are any columns left, add them to the end + orderedColumns = [...orderedColumns, ...columnsCopy]; + } + return orderColumns(orderedColumns, grouping, groupedColumnMode); + }, { + key: false && 0 + // debug: () => table.options.debugAll ?? table.options.debugTable, + }) + }; + } +}; + +// + +const defaultPageIndex = 0; +const defaultPageSize = 10; +const getDefaultPaginationState = () => ({ + pageIndex: defaultPageIndex, + pageSize: defaultPageSize +}); +const Pagination = { + getInitialState: state => { + return { + ...state, + pagination: { + ...getDefaultPaginationState(), + ...state?.pagination + } + }; + }, + getDefaultOptions: table => { + return { + onPaginationChange: makeStateUpdater('pagination', table) + }; + }, + createTable: table => { + let registered = false; + let queued = false; + return { + _autoResetPageIndex: () => { + var _ref, _table$options$autoRe; + if (!registered) { + table._queue(() => { + registered = true; + }); + return; + } + if ((_ref = (_table$options$autoRe = table.options.autoResetAll) != null ? _table$options$autoRe : table.options.autoResetPageIndex) != null ? _ref : !table.options.manualPagination) { + if (queued) return; + queued = true; + table._queue(() => { + table.resetPageIndex(); + queued = false; + }); + } + }, + setPagination: updater => { + const safeUpdater = old => { + let newState = functionalUpdate(updater, old); + return newState; + }; + return table.options.onPaginationChange?.(safeUpdater); + }, + resetPagination: defaultState => { + var _table$initialState$p; + table.setPagination(defaultState ? getDefaultPaginationState() : (_table$initialState$p = table.initialState.pagination) != null ? _table$initialState$p : getDefaultPaginationState()); + }, + setPageIndex: updater => { + table.setPagination(old => { + let pageIndex = functionalUpdate(updater, old.pageIndex); + const maxPageIndex = typeof table.options.pageCount === 'undefined' || table.options.pageCount === -1 ? Number.MAX_SAFE_INTEGER : table.options.pageCount - 1; + pageIndex = Math.max(0, Math.min(pageIndex, maxPageIndex)); + return { + ...old, + pageIndex + }; + }); + }, + resetPageIndex: defaultState => { + var _table$initialState$p2; + table.setPageIndex(defaultState ? defaultPageIndex : (_table$initialState$p2 = table.initialState?.pagination?.pageIndex) != null ? _table$initialState$p2 : defaultPageIndex); + }, + resetPageSize: defaultState => { + var _table$initialState$p3; + table.setPageSize(defaultState ? defaultPageSize : (_table$initialState$p3 = table.initialState?.pagination?.pageSize) != null ? _table$initialState$p3 : defaultPageSize); + }, + setPageSize: updater => { + table.setPagination(old => { + const pageSize = Math.max(1, functionalUpdate(updater, old.pageSize)); + const topRowIndex = old.pageSize * old.pageIndex; + const pageIndex = Math.floor(topRowIndex / pageSize); + return { + ...old, + pageIndex, + pageSize + }; + }); + }, + setPageCount: updater => table.setPagination(old => { + var _table$options$pageCo; + let newPageCount = functionalUpdate(updater, (_table$options$pageCo = table.options.pageCount) != null ? _table$options$pageCo : -1); + if (typeof newPageCount === 'number') { + newPageCount = Math.max(-1, newPageCount); + } + return { + ...old, + pageCount: newPageCount + }; + }), + getPageOptions: memo(() => [table.getPageCount()], pageCount => { + let pageOptions = []; + if (pageCount && pageCount > 0) { + pageOptions = [...new Array(pageCount)].fill(null).map((_, i) => i); + } + return pageOptions; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + } + }), + getCanPreviousPage: () => table.getState().pagination.pageIndex > 0, + getCanNextPage: () => { + const { + pageIndex + } = table.getState().pagination; + const pageCount = table.getPageCount(); + if (pageCount === -1) { + return true; + } + if (pageCount === 0) { + return false; + } + return pageIndex < pageCount - 1; + }, + previousPage: () => { + return table.setPageIndex(old => old - 1); + }, + nextPage: () => { + return table.setPageIndex(old => { + return old + 1; + }); + }, + getPrePaginationRowModel: () => table.getExpandedRowModel(), + getPaginationRowModel: () => { + if (!table._getPaginationRowModel && table.options.getPaginationRowModel) { + table._getPaginationRowModel = table.options.getPaginationRowModel(table); + } + if (table.options.manualPagination || !table._getPaginationRowModel) { + return table.getPrePaginationRowModel(); + } + return table._getPaginationRowModel(); + }, + getPageCount: () => { + var _table$options$pageCo2; + return (_table$options$pageCo2 = table.options.pageCount) != null ? _table$options$pageCo2 : Math.ceil(table.getPrePaginationRowModel().rows.length / table.getState().pagination.pageSize); + } + }; + } +}; + +// + +const getDefaultPinningState = () => ({ + left: [], + right: [] +}); +const Pinning = { + getInitialState: state => { + return { + columnPinning: getDefaultPinningState(), + ...state + }; + }, + getDefaultOptions: table => { + return { + onColumnPinningChange: makeStateUpdater('columnPinning', table) + }; + }, + createColumn: (column, table) => { + return { + pin: position => { + const columnIds = column.getLeafColumns().map(d => d.id).filter(Boolean); + table.setColumnPinning(old => { + var _old$left3, _old$right3; + if (position === 'right') { + var _old$left, _old$right; + return { + left: ((_old$left = old?.left) != null ? _old$left : []).filter(d => !columnIds?.includes(d)), + right: [...((_old$right = old?.right) != null ? _old$right : []).filter(d => !columnIds?.includes(d)), ...columnIds] + }; + } + if (position === 'left') { + var _old$left2, _old$right2; + return { + left: [...((_old$left2 = old?.left) != null ? _old$left2 : []).filter(d => !columnIds?.includes(d)), ...columnIds], + right: ((_old$right2 = old?.right) != null ? _old$right2 : []).filter(d => !columnIds?.includes(d)) + }; + } + return { + left: ((_old$left3 = old?.left) != null ? _old$left3 : []).filter(d => !columnIds?.includes(d)), + right: ((_old$right3 = old?.right) != null ? _old$right3 : []).filter(d => !columnIds?.includes(d)) + }; + }); + }, + getCanPin: () => { + const leafColumns = column.getLeafColumns(); + return leafColumns.some(d => { + var _d$columnDef$enablePi, _table$options$enable; + return ((_d$columnDef$enablePi = d.columnDef.enablePinning) != null ? _d$columnDef$enablePi : true) && ((_table$options$enable = table.options.enablePinning) != null ? _table$options$enable : true); + }); + }, + getIsPinned: () => { + const leafColumnIds = column.getLeafColumns().map(d => d.id); + const { + left, + right + } = table.getState().columnPinning; + const isLeft = leafColumnIds.some(d => left?.includes(d)); + const isRight = leafColumnIds.some(d => right?.includes(d)); + return isLeft ? 'left' : isRight ? 'right' : false; + }, + getPinnedIndex: () => { + var _table$getState$colum; + const position = column.getIsPinned(); + return position ? (_table$getState$colum = table.getState().columnPinning?.[position]?.indexOf(column.id)) != null ? _table$getState$colum : -1 : 0; + } + }; + }, + createRow: (row, table) => { + return { + getCenterVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allCells, left, right) => { + const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])]; + return allCells.filter(d => !leftAndRight.includes(d.column.id)); + }, { + key: true && 'row.getCenterVisibleCells', + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows; + } + }), + getLeftVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.left,,], (allCells, left) => { + const cells = (left != null ? left : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({ + ...d, + position: 'left' + })); + return cells; + }, { + key: true && 'row.getLeftVisibleCells', + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows; + } + }), + getRightVisibleCells: memo(() => [row._getAllVisibleCells(), table.getState().columnPinning.right], (allCells, right) => { + const cells = (right != null ? right : []).map(columnId => allCells.find(cell => cell.column.id === columnId)).filter(Boolean).map(d => ({ + ...d, + position: 'right' + })); + return cells; + }, { + key: true && 'row.getRightVisibleCells', + debug: () => { + var _table$options$debugA3; + return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugRows; + } + }) + }; + }, + createTable: table => { + return { + setColumnPinning: updater => table.options.onColumnPinningChange?.(updater), + resetColumnPinning: defaultState => { + var _table$initialState$c; + return table.setColumnPinning(defaultState ? getDefaultPinningState() : (_table$initialState$c = table.initialState?.columnPinning) != null ? _table$initialState$c : getDefaultPinningState()); + }, + getIsSomeColumnsPinned: position => { + const pinningState = table.getState().columnPinning; + if (!position) { + return Boolean(pinningState.left?.length || pinningState.right?.length); + } + return Boolean(pinningState[position]?.length); + }, + getLeftLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left], (allColumns, left) => { + return (left != null ? left : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA4; + return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugColumns; + } + }), + getRightLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.right], (allColumns, right) => { + return (right != null ? right : []).map(columnId => allColumns.find(column => column.id === columnId)).filter(Boolean); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA5; + return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugColumns; + } + }), + getCenterLeafColumns: memo(() => [table.getAllLeafColumns(), table.getState().columnPinning.left, table.getState().columnPinning.right], (allColumns, left, right) => { + const leftAndRight = [...(left != null ? left : []), ...(right != null ? right : [])]; + return allColumns.filter(d => !leftAndRight.includes(d.id)); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA6; + return (_table$options$debugA6 = table.options.debugAll) != null ? _table$options$debugA6 : table.options.debugColumns; + } + }) + }; + } +}; + +// + +const RowSelection = { + getInitialState: state => { + return { + rowSelection: {}, + ...state + }; + }, + getDefaultOptions: table => { + return { + onRowSelectionChange: makeStateUpdater('rowSelection', table), + enableRowSelection: true, + enableMultiRowSelection: true, + enableSubRowSelection: true + // enableGroupingRowSelection: false, + // isAdditiveSelectEvent: (e: unknown) => !!e.metaKey, + // isInclusiveSelectEvent: (e: unknown) => !!e.shiftKey, + }; + }, + + createTable: table => { + return { + setRowSelection: updater => table.options.onRowSelectionChange?.(updater), + resetRowSelection: defaultState => { + var _table$initialState$r; + return table.setRowSelection(defaultState ? {} : (_table$initialState$r = table.initialState.rowSelection) != null ? _table$initialState$r : {}); + }, + toggleAllRowsSelected: value => { + table.setRowSelection(old => { + value = typeof value !== 'undefined' ? value : !table.getIsAllRowsSelected(); + const rowSelection = { + ...old + }; + const preGroupedFlatRows = table.getPreGroupedRowModel().flatRows; + + // We don't use `mutateRowIsSelected` here for performance reasons. + // All of the rows are flat already, so it wouldn't be worth it + if (value) { + preGroupedFlatRows.forEach(row => { + if (!row.getCanSelect()) { + return; + } + rowSelection[row.id] = true; + }); + } else { + preGroupedFlatRows.forEach(row => { + delete rowSelection[row.id]; + }); + } + return rowSelection; + }); + }, + toggleAllPageRowsSelected: value => table.setRowSelection(old => { + const resolvedValue = typeof value !== 'undefined' ? value : !table.getIsAllPageRowsSelected(); + const rowSelection = { + ...old + }; + table.getRowModel().rows.forEach(row => { + mutateRowIsSelected(rowSelection, row.id, resolvedValue, table); + }); + return rowSelection; + }), + // addRowSelectionRange: rowId => { + // const { + // rows, + // rowsById, + // options: { selectGroupingRows, selectSubRows }, + // } = table + + // const findSelectedRow = (rows: Row[]) => { + // let found + // rows.find(d => { + // if (d.getIsSelected()) { + // found = d + // return true + // } + // const subFound = findSelectedRow(d.subRows || []) + // if (subFound) { + // found = subFound + // return true + // } + // return false + // }) + // return found + // } + + // const firstRow = findSelectedRow(rows) || rows[0] + // const lastRow = rowsById[rowId] + + // let include = false + // const selectedRowIds = {} + + // const addRow = (row: Row) => { + // mutateRowIsSelected(selectedRowIds, row.id, true, { + // rowsById, + // selectGroupingRows: selectGroupingRows!, + // selectSubRows: selectSubRows!, + // }) + // } + + // table.rows.forEach(row => { + // const isFirstRow = row.id === firstRow.id + // const isLastRow = row.id === lastRow.id + + // if (isFirstRow || isLastRow) { + // if (!include) { + // include = true + // } else if (include) { + // addRow(row) + // include = false + // } + // } + + // if (include) { + // addRow(row) + // } + // }) + + // table.setRowSelection(selectedRowIds) + // }, + getPreSelectedRowModel: () => table.getCoreRowModel(), + getSelectedRowModel: memo(() => [table.getState().rowSelection, table.getCoreRowModel()], (rowSelection, rowModel) => { + if (!Object.keys(rowSelection).length) { + return { + rows: [], + flatRows: [], + rowsById: {} + }; + } + return selectRowsFn(table, rowModel); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + } + }), + getFilteredSelectedRowModel: memo(() => [table.getState().rowSelection, table.getFilteredRowModel()], (rowSelection, rowModel) => { + if (!Object.keys(rowSelection).length) { + return { + rows: [], + flatRows: [], + rowsById: {} + }; + } + return selectRowsFn(table, rowModel); + }, { + key: true && 'getFilteredSelectedRowModel', + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugTable; + } + }), + getGroupedSelectedRowModel: memo(() => [table.getState().rowSelection, table.getSortedRowModel()], (rowSelection, rowModel) => { + if (!Object.keys(rowSelection).length) { + return { + rows: [], + flatRows: [], + rowsById: {} + }; + } + return selectRowsFn(table, rowModel); + }, { + key: true && 'getGroupedSelectedRowModel', + debug: () => { + var _table$options$debugA3; + return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugTable; + } + }), + /// + + // getGroupingRowCanSelect: rowId => { + // const row = table.getRow(rowId) + + // if (!row) { + // throw new Error() + // } + + // if (typeof table.options.enableGroupingRowSelection === 'function') { + // return table.options.enableGroupingRowSelection(row) + // } + + // return table.options.enableGroupingRowSelection ?? false + // }, + + getIsAllRowsSelected: () => { + const preGroupedFlatRows = table.getFilteredRowModel().flatRows; + const { + rowSelection + } = table.getState(); + let isAllRowsSelected = Boolean(preGroupedFlatRows.length && Object.keys(rowSelection).length); + if (isAllRowsSelected) { + if (preGroupedFlatRows.some(row => row.getCanSelect() && !rowSelection[row.id])) { + isAllRowsSelected = false; + } + } + return isAllRowsSelected; + }, + getIsAllPageRowsSelected: () => { + const paginationFlatRows = table.getPaginationRowModel().flatRows; + const { + rowSelection + } = table.getState(); + let isAllPageRowsSelected = !!paginationFlatRows.length; + if (isAllPageRowsSelected && paginationFlatRows.some(row => !rowSelection[row.id])) { + isAllPageRowsSelected = false; + } + return isAllPageRowsSelected; + }, + getIsSomeRowsSelected: () => { + var _table$getState$rowSe; + const totalSelected = Object.keys((_table$getState$rowSe = table.getState().rowSelection) != null ? _table$getState$rowSe : {}).length; + return totalSelected > 0 && totalSelected < table.getFilteredRowModel().flatRows.length; + }, + getIsSomePageRowsSelected: () => { + const paginationFlatRows = table.getPaginationRowModel().flatRows; + return table.getIsAllPageRowsSelected() ? false : paginationFlatRows.some(d => d.getIsSelected() || d.getIsSomeSelected()); + }, + getToggleAllRowsSelectedHandler: () => { + return e => { + table.toggleAllRowsSelected(e.target.checked); + }; + }, + getToggleAllPageRowsSelectedHandler: () => { + return e => { + table.toggleAllPageRowsSelected(e.target.checked); + }; + } + }; + }, + createRow: (row, table) => { + return { + toggleSelected: value => { + const isSelected = row.getIsSelected(); + table.setRowSelection(old => { + value = typeof value !== 'undefined' ? value : !isSelected; + if (isSelected === value) { + return old; + } + const selectedRowIds = { + ...old + }; + mutateRowIsSelected(selectedRowIds, row.id, value, table); + return selectedRowIds; + }); + }, + getIsSelected: () => { + const { + rowSelection + } = table.getState(); + return isRowSelected(row, rowSelection); + }, + getIsSomeSelected: () => { + const { + rowSelection + } = table.getState(); + return isSubRowSelected(row, rowSelection) === 'some'; + }, + getIsAllSubRowsSelected: () => { + const { + rowSelection + } = table.getState(); + return isSubRowSelected(row, rowSelection) === 'all'; + }, + getCanSelect: () => { + var _table$options$enable; + if (typeof table.options.enableRowSelection === 'function') { + return table.options.enableRowSelection(row); + } + return (_table$options$enable = table.options.enableRowSelection) != null ? _table$options$enable : true; + }, + getCanSelectSubRows: () => { + var _table$options$enable2; + if (typeof table.options.enableSubRowSelection === 'function') { + return table.options.enableSubRowSelection(row); + } + return (_table$options$enable2 = table.options.enableSubRowSelection) != null ? _table$options$enable2 : true; + }, + getCanMultiSelect: () => { + var _table$options$enable3; + if (typeof table.options.enableMultiRowSelection === 'function') { + return table.options.enableMultiRowSelection(row); + } + return (_table$options$enable3 = table.options.enableMultiRowSelection) != null ? _table$options$enable3 : true; + }, + getToggleSelectedHandler: () => { + const canSelect = row.getCanSelect(); + return e => { + if (!canSelect) return; + row.toggleSelected(e.target?.checked); + }; + } + }; + } +}; +const mutateRowIsSelected = (selectedRowIds, id, value, table) => { + const row = table.getRow(id); + + // const isGrouped = row.getIsGrouped() + + // if ( // TODO: enforce grouping row selection rules + // !isGrouped || + // (isGrouped && table.options.enableGroupingRowSelection) + // ) { + if (value) { + if (!row.getCanMultiSelect()) { + Object.keys(selectedRowIds).forEach(key => delete selectedRowIds[key]); + } + if (row.getCanSelect()) { + selectedRowIds[id] = true; + } + } else { + delete selectedRowIds[id]; + } + // } + + if (row.subRows?.length && row.getCanSelectSubRows()) { + row.subRows.forEach(row => mutateRowIsSelected(selectedRowIds, row.id, value, table)); + } +}; +function selectRowsFn(table, rowModel) { + const rowSelection = table.getState().rowSelection; + const newSelectedFlatRows = []; + const newSelectedRowsById = {}; + + // Filters top level and nested rows + const recurseRows = function (rows, depth) { + return rows.map(row => { + const isSelected = isRowSelected(row, rowSelection); + if (isSelected) { + newSelectedFlatRows.push(row); + newSelectedRowsById[row.id] = row; + } + if (row.subRows?.length) { + row = { + ...row, + subRows: recurseRows(row.subRows) + }; + } + if (isSelected) { + return row; + } + }).filter(Boolean); + }; + return { + rows: recurseRows(rowModel.rows), + flatRows: newSelectedFlatRows, + rowsById: newSelectedRowsById + }; +} +function isRowSelected(row, selection) { + var _selection$row$id; + return (_selection$row$id = selection[row.id]) != null ? _selection$row$id : false; +} +function isSubRowSelected(row, selection, table) { + if (row.subRows && row.subRows.length) { + let allChildrenSelected = true; + let someSelected = false; + row.subRows.forEach(subRow => { + // Bail out early if we know both of these + if (someSelected && !allChildrenSelected) { + return; + } + if (isRowSelected(subRow, selection)) { + someSelected = true; + } else { + allChildrenSelected = false; + } + }); + return allChildrenSelected ? 'all' : someSelected ? 'some' : false; + } + return false; +} + +const reSplitAlphaNumeric = /([0-9]+)/gm; +const alphanumeric = (rowA, rowB, columnId) => { + return compareAlphanumeric(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase()); +}; +const alphanumericCaseSensitive = (rowA, rowB, columnId) => { + return compareAlphanumeric(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId))); +}; + +// The text filter is more basic (less numeric support) +// but is much faster +const text = (rowA, rowB, columnId) => { + return compareBasic(toString(rowA.getValue(columnId)).toLowerCase(), toString(rowB.getValue(columnId)).toLowerCase()); +}; + +// The text filter is more basic (less numeric support) +// but is much faster +const textCaseSensitive = (rowA, rowB, columnId) => { + return compareBasic(toString(rowA.getValue(columnId)), toString(rowB.getValue(columnId))); +}; +const datetime = (rowA, rowB, columnId) => { + const a = rowA.getValue(columnId); + const b = rowB.getValue(columnId); + + // Can handle nullish values + // Use > and < because == (and ===) doesn't work with + // Date objects (would require calling getTime()). + return a > b ? 1 : a < b ? -1 : 0; +}; +const basic = (rowA, rowB, columnId) => { + return compareBasic(rowA.getValue(columnId), rowB.getValue(columnId)); +}; + +// Utils + +function compareBasic(a, b) { + return a === b ? 0 : a > b ? 1 : -1; +} +function toString(a) { + if (typeof a === 'number') { + if (isNaN(a) || a === Infinity || a === -Infinity) { + return ''; + } + return String(a); + } + if (typeof a === 'string') { + return a; + } + return ''; +} + +// Mixed sorting is slow, but very inclusive of many edge cases. +// It handles numbers, mixed alphanumeric combinations, and even +// null, undefined, and Infinity +function compareAlphanumeric(aStr, bStr) { + // Split on number groups, but keep the delimiter + // Then remove falsey split values + const a = aStr.split(reSplitAlphaNumeric).filter(Boolean); + const b = bStr.split(reSplitAlphaNumeric).filter(Boolean); + + // While + while (a.length && b.length) { + const aa = a.shift(); + const bb = b.shift(); + const an = parseInt(aa, 10); + const bn = parseInt(bb, 10); + const combo = [an, bn].sort(); + + // Both are string + if (isNaN(combo[0])) { + if (aa > bb) { + return 1; + } + if (bb > aa) { + return -1; + } + continue; + } + + // One is a string, one is a number + if (isNaN(combo[1])) { + return isNaN(an) ? -1 : 1; + } + + // Both are numbers + if (an > bn) { + return 1; + } + if (bn > an) { + return -1; + } + } + return a.length - b.length; +} + +// Exports + +const sortingFns = { + alphanumeric, + alphanumericCaseSensitive, + text, + textCaseSensitive, + datetime, + basic +}; + +// + +const Sorting = { + getInitialState: state => { + return { + sorting: [], + ...state + }; + }, + getDefaultColumnDef: () => { + return { + sortingFn: 'auto' + }; + }, + getDefaultOptions: table => { + return { + onSortingChange: makeStateUpdater('sorting', table), + isMultiSortEvent: e => { + return e.shiftKey; + } + }; + }, + createColumn: (column, table) => { + return { + getAutoSortingFn: () => { + const firstRows = table.getFilteredRowModel().flatRows.slice(10); + let isString = false; + for (const row of firstRows) { + const value = row?.getValue(column.id); + if (Object.prototype.toString.call(value) === '[object Date]') { + return sortingFns.datetime; + } + if (typeof value === 'string') { + isString = true; + if (value.split(reSplitAlphaNumeric).length > 1) { + return sortingFns.alphanumeric; + } + } + } + if (isString) { + return sortingFns.text; + } + return sortingFns.basic; + }, + getAutoSortDir: () => { + const firstRow = table.getFilteredRowModel().flatRows[0]; + const value = firstRow?.getValue(column.id); + if (typeof value === 'string') { + return 'asc'; + } + return 'desc'; + }, + getSortingFn: () => { + var _table$options$sortin; + if (!column) { + throw new Error(); + } + return isFunction(column.columnDef.sortingFn) ? column.columnDef.sortingFn : column.columnDef.sortingFn === 'auto' ? column.getAutoSortingFn() : (_table$options$sortin = table.options.sortingFns?.[column.columnDef.sortingFn]) != null ? _table$options$sortin : sortingFns[column.columnDef.sortingFn]; + }, + toggleSorting: (desc, multi) => { + // if (column.columns.length) { + // column.columns.forEach((c, i) => { + // if (c.id) { + // table.toggleColumnSorting(c.id, undefined, multi || !!i) + // } + // }) + // return + // } + + // this needs to be outside of table.setSorting to be in sync with rerender + const nextSortingOrder = column.getNextSortingOrder(); + const hasManualValue = typeof desc !== 'undefined' && desc !== null; + table.setSorting(old => { + // Find any existing sorting for this column + const existingSorting = old?.find(d => d.id === column.id); + const existingIndex = old?.findIndex(d => d.id === column.id); + let newSorting = []; + + // What should we do with this sort action? + let sortAction; + let nextDesc = hasManualValue ? desc : nextSortingOrder === 'desc'; + + // Multi-mode + if (old?.length && column.getCanMultiSort() && multi) { + if (existingSorting) { + sortAction = 'toggle'; + } else { + sortAction = 'add'; + } + } else { + // Normal mode + if (old?.length && existingIndex !== old.length - 1) { + sortAction = 'replace'; + } else if (existingSorting) { + sortAction = 'toggle'; + } else { + sortAction = 'replace'; + } + } + + // Handle toggle states that will remove the sorting + if (sortAction === 'toggle') { + // If we are "actually" toggling (not a manual set value), should we remove the sorting? + if (!hasManualValue) { + // Is our intention to remove? + if (!nextSortingOrder) { + sortAction = 'remove'; + } + } + } + if (sortAction === 'add') { + var _table$options$maxMul; + newSorting = [...old, { + id: column.id, + desc: nextDesc + }]; + // Take latest n columns + newSorting.splice(0, newSorting.length - ((_table$options$maxMul = table.options.maxMultiSortColCount) != null ? _table$options$maxMul : Number.MAX_SAFE_INTEGER)); + } else if (sortAction === 'toggle') { + // This flips (or sets) the + newSorting = old.map(d => { + if (d.id === column.id) { + return { + ...d, + desc: nextDesc + }; + } + return d; + }); + } else if (sortAction === 'remove') { + newSorting = old.filter(d => d.id !== column.id); + } else { + newSorting = [{ + id: column.id, + desc: nextDesc + }]; + } + return newSorting; + }); + }, + getFirstSortDir: () => { + var _ref, _column$columnDef$sor; + const sortDescFirst = (_ref = (_column$columnDef$sor = column.columnDef.sortDescFirst) != null ? _column$columnDef$sor : table.options.sortDescFirst) != null ? _ref : column.getAutoSortDir() === 'desc'; + return sortDescFirst ? 'desc' : 'asc'; + }, + getNextSortingOrder: multi => { + var _table$options$enable, _table$options$enable2; + const firstSortDirection = column.getFirstSortDir(); + const isSorted = column.getIsSorted(); + if (!isSorted) { + return firstSortDirection; + } + if (isSorted !== firstSortDirection && ((_table$options$enable = table.options.enableSortingRemoval) != null ? _table$options$enable : true) && ( + // If enableSortRemove, enable in general + multi ? (_table$options$enable2 = table.options.enableMultiRemove) != null ? _table$options$enable2 : true : true) // If multi, don't allow if enableMultiRemove)) + ) { + return false; + } + return isSorted === 'desc' ? 'asc' : 'desc'; + }, + getCanSort: () => { + var _column$columnDef$ena, _table$options$enable3; + return ((_column$columnDef$ena = column.columnDef.enableSorting) != null ? _column$columnDef$ena : true) && ((_table$options$enable3 = table.options.enableSorting) != null ? _table$options$enable3 : true) && !!column.accessorFn; + }, + getCanMultiSort: () => { + var _ref2, _column$columnDef$ena2; + return (_ref2 = (_column$columnDef$ena2 = column.columnDef.enableMultiSort) != null ? _column$columnDef$ena2 : table.options.enableMultiSort) != null ? _ref2 : !!column.accessorFn; + }, + getIsSorted: () => { + const columnSort = table.getState().sorting?.find(d => d.id === column.id); + return !columnSort ? false : columnSort.desc ? 'desc' : 'asc'; + }, + getSortIndex: () => { + var _table$getState$sorti; + return (_table$getState$sorti = table.getState().sorting?.findIndex(d => d.id === column.id)) != null ? _table$getState$sorti : -1; + }, + clearSorting: () => { + //clear sorting for just 1 column + table.setSorting(old => old?.length ? old.filter(d => d.id !== column.id) : []); + }, + getToggleSortingHandler: () => { + const canSort = column.getCanSort(); + return e => { + if (!canSort) return; + e.persist?.(); + column.toggleSorting?.(undefined, column.getCanMultiSort() ? table.options.isMultiSortEvent?.(e) : false); + }; + } + }; + }, + createTable: table => { + return { + setSorting: updater => table.options.onSortingChange?.(updater), + resetSorting: defaultState => { + var _table$initialState$s; + table.setSorting(defaultState ? [] : (_table$initialState$s = table.initialState?.sorting) != null ? _table$initialState$s : []); + }, + getPreSortedRowModel: () => table.getGroupedRowModel(), + getSortedRowModel: () => { + if (!table._getSortedRowModel && table.options.getSortedRowModel) { + table._getSortedRowModel = table.options.getSortedRowModel(table); + } + if (table.options.manualSorting || !table._getSortedRowModel) { + return table.getPreSortedRowModel(); + } + return table._getSortedRowModel(); + } + }; + } +}; + +// + +const Visibility = { + getInitialState: state => { + return { + columnVisibility: {}, + ...state + }; + }, + getDefaultOptions: table => { + return { + onColumnVisibilityChange: makeStateUpdater('columnVisibility', table) + }; + }, + createColumn: (column, table) => { + return { + toggleVisibility: value => { + if (column.getCanHide()) { + table.setColumnVisibility(old => ({ + ...old, + [column.id]: value != null ? value : !column.getIsVisible() + })); + } + }, + getIsVisible: () => { + var _table$getState$colum; + return (_table$getState$colum = table.getState().columnVisibility?.[column.id]) != null ? _table$getState$colum : true; + }, + getCanHide: () => { + var _column$columnDef$ena, _table$options$enable; + return ((_column$columnDef$ena = column.columnDef.enableHiding) != null ? _column$columnDef$ena : true) && ((_table$options$enable = table.options.enableHiding) != null ? _table$options$enable : true); + }, + getToggleVisibilityHandler: () => { + return e => { + column.toggleVisibility?.(e.target.checked); + }; + } + }; + }, + createRow: (row, table) => { + return { + _getAllVisibleCells: memo(() => [row.getAllCells(), table.getState().columnVisibility], cells => { + return cells.filter(cell => cell.column.getIsVisible()); + }, { + key: true && 'row._getAllVisibleCells', + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows; + } + }), + getVisibleCells: memo(() => [row.getLeftVisibleCells(), row.getCenterVisibleCells(), row.getRightVisibleCells()], (left, center, right) => [...left, ...center, ...right], { + key: false && 0, + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows; + } + }) + }; + }, + createTable: table => { + const makeVisibleColumnsMethod = (key, getColumns) => { + return memo(() => [getColumns(), getColumns().filter(d => d.getIsVisible()).map(d => d.id).join('_')], columns => { + return columns.filter(d => d.getIsVisible?.()); + }, { + key, + debug: () => { + var _table$options$debugA3; + return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugColumns; + } + }); + }; + return { + getVisibleFlatColumns: makeVisibleColumnsMethod('getVisibleFlatColumns', () => table.getAllFlatColumns()), + getVisibleLeafColumns: makeVisibleColumnsMethod('getVisibleLeafColumns', () => table.getAllLeafColumns()), + getLeftVisibleLeafColumns: makeVisibleColumnsMethod('getLeftVisibleLeafColumns', () => table.getLeftLeafColumns()), + getRightVisibleLeafColumns: makeVisibleColumnsMethod('getRightVisibleLeafColumns', () => table.getRightLeafColumns()), + getCenterVisibleLeafColumns: makeVisibleColumnsMethod('getCenterVisibleLeafColumns', () => table.getCenterLeafColumns()), + setColumnVisibility: updater => table.options.onColumnVisibilityChange?.(updater), + resetColumnVisibility: defaultState => { + var _table$initialState$c; + table.setColumnVisibility(defaultState ? {} : (_table$initialState$c = table.initialState.columnVisibility) != null ? _table$initialState$c : {}); + }, + toggleAllColumnsVisible: value => { + var _value; + value = (_value = value) != null ? _value : !table.getIsAllColumnsVisible(); + table.setColumnVisibility(table.getAllLeafColumns().reduce((obj, column) => ({ + ...obj, + [column.id]: !value ? !column.getCanHide?.() : value + }), {})); + }, + getIsAllColumnsVisible: () => !table.getAllLeafColumns().some(column => !column.getIsVisible?.()), + getIsSomeColumnsVisible: () => table.getAllLeafColumns().some(column => column.getIsVisible?.()), + getToggleAllColumnsVisibilityHandler: () => { + return e => { + table.toggleAllColumnsVisible(e.target?.checked); + }; + } + }; + } +}; + +const features = [Headers, Visibility, Ordering, Pinning, Filters, Sorting, Grouping, Expanding, Pagination, RowSelection, ColumnSizing]; + +// + +function createTable(options) { + var _options$initialState; + if (options.debugAll || options.debugTable) { + console.info('Creating Table Instance...'); + } + let table = { + _features: features + }; + const defaultOptions = table._features.reduce((obj, feature) => { + return Object.assign(obj, feature.getDefaultOptions?.(table)); + }, {}); + const mergeOptions = options => { + if (table.options.mergeOptions) { + return table.options.mergeOptions(defaultOptions, options); + } + return { + ...defaultOptions, + ...options + }; + }; + const coreInitialState = {}; + let initialState = { + ...coreInitialState, + ...((_options$initialState = options.initialState) != null ? _options$initialState : {}) + }; + table._features.forEach(feature => { + var _feature$getInitialSt; + initialState = (_feature$getInitialSt = feature.getInitialState?.(initialState)) != null ? _feature$getInitialSt : initialState; + }); + const queued = []; + let queuedTimeout = false; + const coreInstance = { + _features: features, + options: { + ...defaultOptions, + ...options + }, + initialState, + _queue: cb => { + queued.push(cb); + if (!queuedTimeout) { + queuedTimeout = true; + + // Schedule a microtask to run the queued callbacks after + // the current call stack (render, etc) has finished. + Promise.resolve().then(() => { + while (queued.length) { + queued.shift()(); + } + queuedTimeout = false; + }).catch(error => setTimeout(() => { + throw error; + })); + } + }, + reset: () => { + table.setState(table.initialState); + }, + setOptions: updater => { + const newOptions = functionalUpdate(updater, table.options); + table.options = mergeOptions(newOptions); + }, + getState: () => { + return table.options.state; + }, + setState: updater => { + table.options.onStateChange?.(updater); + }, + _getRowId: (row, index, parent) => { + var _table$options$getRow; + return (_table$options$getRow = table.options.getRowId?.(row, index, parent)) != null ? _table$options$getRow : `${parent ? [parent.id, index].join('.') : index}`; + }, + getCoreRowModel: () => { + if (!table._getCoreRowModel) { + table._getCoreRowModel = table.options.getCoreRowModel(table); + } + return table._getCoreRowModel(); + }, + // The final calls start at the bottom of the model, + // expanded rows, which then work their way up + + getRowModel: () => { + return table.getPaginationRowModel(); + }, + getRow: id => { + const row = table.getRowModel().rowsById[id]; + if (!row) { + if (false) {} + throw new Error(); + } + return row; + }, + _getDefaultColumnDef: memo(() => [table.options.defaultColumn], defaultColumn => { + var _defaultColumn; + defaultColumn = (_defaultColumn = defaultColumn) != null ? _defaultColumn : {}; + return { + header: props => { + const resolvedColumnDef = props.header.column.columnDef; + if (resolvedColumnDef.accessorKey) { + return resolvedColumnDef.accessorKey; + } + if (resolvedColumnDef.accessorFn) { + return resolvedColumnDef.id; + } + return null; + }, + // footer: props => props.header.column.id, + cell: props => { + var _props$renderValue$to; + return (_props$renderValue$to = props.renderValue()?.toString?.()) != null ? _props$renderValue$to : null; + }, + ...table._features.reduce((obj, feature) => { + return Object.assign(obj, feature.getDefaultColumnDef?.()); + }, {}), + ...defaultColumn + }; + }, { + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugColumns; + }, + key: false && 0 + }), + _getColumnDefs: () => table.options.columns, + getAllColumns: memo(() => [table._getColumnDefs()], columnDefs => { + const recurseColumns = function (columnDefs, parent, depth) { + if (depth === void 0) { + depth = 0; + } + return columnDefs.map(columnDef => { + const column = createColumn(table, columnDef, depth, parent); + const groupingColumnDef = columnDef; + column.columns = groupingColumnDef.columns ? recurseColumns(groupingColumnDef.columns, column, depth + 1) : []; + return column; + }); + }; + return recurseColumns(columnDefs); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugColumns; + } + }), + getAllFlatColumns: memo(() => [table.getAllColumns()], allColumns => { + return allColumns.flatMap(column => { + return column.getFlatColumns(); + }); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA3; + return (_table$options$debugA3 = table.options.debugAll) != null ? _table$options$debugA3 : table.options.debugColumns; + } + }), + _getAllFlatColumnsById: memo(() => [table.getAllFlatColumns()], flatColumns => { + return flatColumns.reduce((acc, column) => { + acc[column.id] = column; + return acc; + }, {}); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA4; + return (_table$options$debugA4 = table.options.debugAll) != null ? _table$options$debugA4 : table.options.debugColumns; + } + }), + getAllLeafColumns: memo(() => [table.getAllColumns(), table._getOrderColumnsFn()], (allColumns, orderColumns) => { + let leafColumns = allColumns.flatMap(column => column.getLeafColumns()); + return orderColumns(leafColumns); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA5; + return (_table$options$debugA5 = table.options.debugAll) != null ? _table$options$debugA5 : table.options.debugColumns; + } + }), + getColumn: columnId => { + const column = table._getAllFlatColumnsById()[columnId]; + if (!column) { + if (false) {} + throw new Error(); + } + return column; + } + }; + Object.assign(table, coreInstance); + table._features.forEach(feature => { + return Object.assign(table, feature.createTable?.(table)); + }); + return table; +} + +function createCell(table, row, column, columnId) { + const getRenderValue = () => { + var _cell$getValue; + return (_cell$getValue = cell.getValue()) != null ? _cell$getValue : table.options.renderFallbackValue; + }; + const cell = { + id: `${row.id}_${column.id}`, + row, + column, + getValue: () => row.getValue(columnId), + renderValue: getRenderValue, + getContext: memo(() => [table, column, row, cell], (table, column, row, cell) => ({ + table, + column, + row, + cell: cell, + getValue: cell.getValue, + renderValue: cell.renderValue + }), { + key: false && 0, + debug: () => table.options.debugAll + }) + }; + table._features.forEach(feature => { + Object.assign(cell, feature.createCell?.(cell, column, row, table)); + }, {}); + return cell; +} + +const createRow = (table, id, original, rowIndex, depth, subRows) => { + let row = { + id, + index: rowIndex, + original, + depth, + _valuesCache: {}, + _uniqueValuesCache: {}, + getValue: columnId => { + if (row._valuesCache.hasOwnProperty(columnId)) { + return row._valuesCache[columnId]; + } + const column = table.getColumn(columnId); + if (!column.accessorFn) { + return undefined; + } + row._valuesCache[columnId] = column.accessorFn(row.original, rowIndex); + return row._valuesCache[columnId]; + }, + getUniqueValues: columnId => { + if (row._uniqueValuesCache.hasOwnProperty(columnId)) { + return row._uniqueValuesCache[columnId]; + } + const column = table.getColumn(columnId); + if (!column.accessorFn) { + return undefined; + } + if (!column.columnDef.getUniqueValues) { + row._uniqueValuesCache[columnId] = [row.getValue(columnId)]; + return row._uniqueValuesCache[columnId]; + } + row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(row.original, rowIndex); + return row._uniqueValuesCache[columnId]; + }, + renderValue: columnId => { + var _row$getValue; + return (_row$getValue = row.getValue(columnId)) != null ? _row$getValue : table.options.renderFallbackValue; + }, + subRows: subRows != null ? subRows : [], + getLeafRows: () => flattenBy(row.subRows, d => d.subRows), + getAllCells: memo(() => [table.getAllLeafColumns()], leafColumns => { + return leafColumns.map(column => { + return createCell(table, row, column, column.id); + }); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugRows; + } + }), + _getAllCellsByColumnId: memo(() => [row.getAllCells()], allCells => { + return allCells.reduce((acc, cell) => { + acc[cell.column.id] = cell; + return acc; + }, {}); + }, { + key: true && 'row.getAllCellsByColumnId', + debug: () => { + var _table$options$debugA2; + return (_table$options$debugA2 = table.options.debugAll) != null ? _table$options$debugA2 : table.options.debugRows; + } + }) + }; + for (let i = 0; i < table._features.length; i++) { + const feature = table._features[i]; + Object.assign(row, feature?.createRow?.(row, table)); + } + return row; +}; + +// type Person = { +// firstName: string +// lastName: string +// age: number +// visits: number +// status: string +// progress: number +// createdAt: Date +// nested: { +// foo: [ +// { +// bar: 'bar' +// } +// ] +// bar: { subBar: boolean }[] +// baz: { +// foo: 'foo' +// bar: { +// baz: 'baz' +// } +// } +// } +// } + +// const test: DeepKeys = 'nested.foo.0.bar' +// const test2: DeepKeys = 'nested.bar' + +// const helper = createColumnHelper() + +// helper.accessor('nested.foo', { +// cell: info => info.getValue(), +// }) + +// helper.accessor('nested.foo.0.bar', { +// cell: info => info.getValue(), +// }) + +// helper.accessor('nested.bar', { +// cell: info => info.getValue(), +// }) + +function createColumnHelper() { + return { + accessor: (accessor, column) => { + return typeof accessor === 'function' ? { + ...column, + accessorFn: accessor + } : { + ...column, + accessorKey: accessor + }; + }, + display: column => column, + group: column => column + }; +} + +function getCoreRowModel() { + return table => memo(() => [table.options.data], data => { + const rowModel = { + rows: [], + flatRows: [], + rowsById: {} + }; + const accessRows = function (originalRows, depth, parent) { + if (depth === void 0) { + depth = 0; + } + const rows = []; + for (let i = 0; i < originalRows.length; i++) { + // This could be an expensive check at scale, so we should move it somewhere else, but where? + // if (!id) { + // if (process.env.NODE_ENV !== 'production') { + // throw new Error(`getRowId expected an ID, but got ${id}`) + // } + // } + + // Make the row + const row = createRow(table, table._getRowId(originalRows[i], i, parent), originalRows[i], i, depth); + + // Keep track of every row in a flat array + rowModel.flatRows.push(row); + // Also keep track of every row by its ID + rowModel.rowsById[row.id] = row; + // Push table row into parent + rows.push(row); + + // Get the original subrows + if (table.options.getSubRows) { + row.originalSubRows = table.options.getSubRows(originalRows[i], i); + + // Then recursively access them + if (row.originalSubRows?.length) { + row.subRows = accessRows(row.originalSubRows, depth + 1, row); + } + } + } + return rows; + }; + rowModel.rows = accessRows(data); + return rowModel; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => { + table._autoResetPageIndex(); + } + }); +} + +function filterRows(rows, filterRowImpl, table) { + if (table.options.filterFromLeafRows) { + return filterRowModelFromLeafs(rows, filterRowImpl, table); + } + return filterRowModelFromRoot(rows, filterRowImpl, table); +} +function filterRowModelFromLeafs(rowsToFilter, filterRow, table) { + var _table$options$maxLea; + const newFilteredFlatRows = []; + const newFilteredRowsById = {}; + const maxDepth = (_table$options$maxLea = table.options.maxLeafRowFilterDepth) != null ? _table$options$maxLea : 100; + const recurseFilterRows = function (rowsToFilter, depth) { + if (depth === void 0) { + depth = 0; + } + const rows = []; + + // Filter from children up first + for (let i = 0; i < rowsToFilter.length; i++) { + let row = rowsToFilter[i]; + const newRow = createRow(table, row.id, row.original, row.index, row.depth); + newRow.columnFilters = row.columnFilters; + if (row.subRows?.length && depth < maxDepth) { + newRow.subRows = recurseFilterRows(row.subRows, depth + 1); + row = newRow; + if (filterRow(row) && !newRow.subRows.length) { + rows.push(row); + newFilteredRowsById[row.id] = row; + newFilteredRowsById[i] = row; + continue; + } + if (filterRow(row) || newRow.subRows.length) { + rows.push(row); + newFilteredRowsById[row.id] = row; + newFilteredRowsById[i] = row; + continue; + } + } else { + row = newRow; + if (filterRow(row)) { + rows.push(row); + newFilteredRowsById[row.id] = row; + newFilteredRowsById[i] = row; + } + } + } + return rows; + }; + return { + rows: recurseFilterRows(rowsToFilter), + flatRows: newFilteredFlatRows, + rowsById: newFilteredRowsById + }; +} +function filterRowModelFromRoot(rowsToFilter, filterRow, table) { + var _table$options$maxLea2; + const newFilteredFlatRows = []; + const newFilteredRowsById = {}; + const maxDepth = (_table$options$maxLea2 = table.options.maxLeafRowFilterDepth) != null ? _table$options$maxLea2 : 100; + + // Filters top level and nested rows + const recurseFilterRows = function (rowsToFilter, depth) { + if (depth === void 0) { + depth = 0; + } + // Filter from parents downward first + + const rows = []; + + // Apply the filter to any subRows + for (let i = 0; i < rowsToFilter.length; i++) { + let row = rowsToFilter[i]; + const pass = filterRow(row); + if (pass) { + if (row.subRows?.length && depth < maxDepth) { + const newRow = createRow(table, row.id, row.original, row.index, row.depth); + newRow.subRows = recurseFilterRows(row.subRows, depth + 1); + row = newRow; + } + rows.push(row); + newFilteredFlatRows.push(row); + newFilteredRowsById[row.id] = row; + } + } + return rows; + }; + return { + rows: recurseFilterRows(rowsToFilter), + flatRows: newFilteredFlatRows, + rowsById: newFilteredRowsById + }; +} + +function getFilteredRowModel() { + return table => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter], (rowModel, columnFilters, globalFilter) => { + if (!rowModel.rows.length || !columnFilters?.length && !globalFilter) { + for (let i = 0; i < rowModel.flatRows.length; i++) { + rowModel.flatRows[i].columnFilters = {}; + rowModel.flatRows[i].columnFiltersMeta = {}; + } + return rowModel; + } + const resolvedColumnFilters = []; + const resolvedGlobalFilters = []; + (columnFilters != null ? columnFilters : []).forEach(d => { + var _filterFn$resolveFilt; + const column = table.getColumn(d.id); + if (!column) { + if (false) {} + } + const filterFn = column.getFilterFn(); + if (!filterFn) { + if (false) {} + return; + } + resolvedColumnFilters.push({ + id: d.id, + filterFn, + resolvedValue: (_filterFn$resolveFilt = filterFn.resolveFilterValue?.(d.value)) != null ? _filterFn$resolveFilt : d.value + }); + }); + const filterableIds = columnFilters.map(d => d.id); + const globalFilterFn = table.getGlobalFilterFn(); + const globallyFilterableColumns = table.getAllLeafColumns().filter(column => column.getCanGlobalFilter()); + if (globalFilter && globalFilterFn && globallyFilterableColumns.length) { + filterableIds.push('__global__'); + globallyFilterableColumns.forEach(column => { + var _globalFilterFn$resol; + resolvedGlobalFilters.push({ + id: column.id, + filterFn: globalFilterFn, + resolvedValue: (_globalFilterFn$resol = globalFilterFn.resolveFilterValue?.(globalFilter)) != null ? _globalFilterFn$resol : globalFilter + }); + }); + } + let currentColumnFilter; + let currentGlobalFilter; + + // Flag the prefiltered row model with each filter state + for (let j = 0; j < rowModel.flatRows.length; j++) { + const row = rowModel.flatRows[j]; + row.columnFilters = {}; + if (resolvedColumnFilters.length) { + for (let i = 0; i < resolvedColumnFilters.length; i++) { + currentColumnFilter = resolvedColumnFilters[i]; + const id = currentColumnFilter.id; + + // Tag the row with the column filter state + row.columnFilters[id] = currentColumnFilter.filterFn(row, id, currentColumnFilter.resolvedValue, filterMeta => { + row.columnFiltersMeta[id] = filterMeta; + }); + } + } + if (resolvedGlobalFilters.length) { + for (let i = 0; i < resolvedGlobalFilters.length; i++) { + currentGlobalFilter = resolvedGlobalFilters[i]; + const id = currentGlobalFilter.id; + // Tag the row with the first truthy global filter state + if (currentGlobalFilter.filterFn(row, id, currentGlobalFilter.resolvedValue, filterMeta => { + row.columnFiltersMeta[id] = filterMeta; + })) { + row.columnFilters.__global__ = true; + break; + } + } + if (row.columnFilters.__global__ !== true) { + row.columnFilters.__global__ = false; + } + } + } + const filterRowsImpl = row => { + // Horizontally filter rows through each column + for (let i = 0; i < filterableIds.length; i++) { + if (row.columnFilters[filterableIds[i]] === false) { + return false; + } + } + return true; + }; + + // Filter final rows using all of the active filters + return filterRows(rowModel.rows, filterRowsImpl, table); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => { + table._autoResetPageIndex(); + } + }); +} + +function getFacetedRowModel() { + return (table, columnId) => memo(() => [table.getPreFilteredRowModel(), table.getState().columnFilters, table.getState().globalFilter, table.getFilteredRowModel()], (preRowModel, columnFilters, globalFilter) => { + if (!preRowModel.rows.length || !columnFilters?.length && !globalFilter) { + return preRowModel; + } + const filterableIds = [...columnFilters.map(d => d.id).filter(d => d !== columnId), globalFilter ? '__global__' : undefined].filter(Boolean); + const filterRowsImpl = row => { + // Horizontally filter rows through each column + for (let i = 0; i < filterableIds.length; i++) { + if (row.columnFilters[filterableIds[i]] === false) { + return false; + } + } + return true; + }; + return filterRows(preRowModel.rows, filterRowsImpl, table); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => {} + }); +} + +function getFacetedUniqueValues() { + return (table, columnId) => memo(() => [table.getColumn(columnId).getFacetedRowModel()], facetedRowModel => { + let facetedUniqueValues = new Map(); + for (let i = 0; i < facetedRowModel.flatRows.length; i++) { + const values = facetedRowModel.flatRows[i].getUniqueValues(columnId); + for (let j = 0; j < values.length; j++) { + const value = values[j]; + if (facetedUniqueValues.has(value)) { + var _facetedUniqueValues$; + facetedUniqueValues.set(value, ((_facetedUniqueValues$ = facetedUniqueValues.get(value)) != null ? _facetedUniqueValues$ : 0) + 1); + } else { + facetedUniqueValues.set(value, 1); + } + } + } + return facetedUniqueValues; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => {} + }); +} + +function getFacetedMinMaxValues() { + return (table, columnId) => memo(() => [table.getColumn(columnId).getFacetedRowModel()], facetedRowModel => { + const firstValue = facetedRowModel.flatRows[0]?.getUniqueValues(columnId); + if (typeof firstValue === 'undefined') { + return undefined; + } + let facetedMinMaxValues = [firstValue, firstValue]; + for (let i = 0; i < facetedRowModel.flatRows.length; i++) { + const values = facetedRowModel.flatRows[i].getUniqueValues(columnId); + for (let j = 0; j < values.length; j++) { + const value = values[j]; + if (value < facetedMinMaxValues[0]) { + facetedMinMaxValues[0] = value; + } else if (value > facetedMinMaxValues[1]) { + facetedMinMaxValues[1] = value; + } + } + } + return facetedMinMaxValues; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => {} + }); +} + +function getSortedRowModel() { + return table => memo(() => [table.getState().sorting, table.getPreSortedRowModel()], (sorting, rowModel) => { + if (!rowModel.rows.length || !sorting?.length) { + return rowModel; + } + const sortingState = table.getState().sorting; + const sortedFlatRows = []; + + // Filter out sortings that correspond to non existing columns + const availableSorting = sortingState.filter(sort => table.getColumn(sort.id).getCanSort()); + const columnInfoById = {}; + availableSorting.forEach(sortEntry => { + const column = table.getColumn(sortEntry.id); + columnInfoById[sortEntry.id] = { + sortUndefined: column.columnDef.sortUndefined, + invertSorting: column.columnDef.invertSorting, + sortingFn: column.getSortingFn() + }; + }); + const sortData = rows => { + // This will also perform a stable sorting using the row index + // if needed. + const sortedData = [...rows]; + sortedData.sort((rowA, rowB) => { + for (let i = 0; i < availableSorting.length; i += 1) { + var _sortEntry$desc; + const sortEntry = availableSorting[i]; + const columnInfo = columnInfoById[sortEntry.id]; + const isDesc = (_sortEntry$desc = sortEntry?.desc) != null ? _sortEntry$desc : false; + if (columnInfo.sortUndefined) { + const aValue = rowA.getValue(sortEntry.id); + const bValue = rowB.getValue(sortEntry.id); + const aUndefined = typeof aValue === 'undefined'; + const bUndefined = typeof bValue === 'undefined'; + if (aUndefined || bUndefined) { + return aUndefined && bUndefined ? 0 : aUndefined ? columnInfo.sortUndefined : -columnInfo.sortUndefined; + } + } + + // This function should always return in ascending order + let sortInt = columnInfo.sortingFn(rowA, rowB, sortEntry.id); + if (sortInt !== 0) { + if (isDesc) { + sortInt *= -1; + } + if (columnInfo.invertSorting) { + sortInt *= -1; + } + return sortInt; + } + } + return rowA.index - rowB.index; + }); + + // If there are sub-rows, sort them + sortedData.forEach(row => { + sortedFlatRows.push(row); + if (row.subRows?.length) { + row.subRows = sortData(row.subRows); + } + }); + return sortedData; + }; + return { + rows: sortData(rowModel.rows), + flatRows: sortedFlatRows, + rowsById: rowModel.rowsById + }; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => { + table._autoResetPageIndex(); + } + }); +} + +function getGroupedRowModel() { + return table => memo(() => [table.getState().grouping, table.getPreGroupedRowModel()], (grouping, rowModel) => { + if (!rowModel.rows.length || !grouping.length) { + return rowModel; + } + + // Filter the grouping list down to columns that exist + const existingGrouping = grouping.filter(columnId => table.getColumn(columnId)); + const groupedFlatRows = []; + const groupedRowsById = {}; + // const onlyGroupedFlatRows: Row[] = []; + // const onlyGroupedRowsById: Record = {}; + // const nonGroupedFlatRows: Row[] = []; + // const nonGroupedRowsById: Record = {}; + + // Recursively group the data + const groupUpRecursively = function (rows, depth, parentId) { + if (depth === void 0) { + depth = 0; + } + // Grouping depth has been been met + // Stop grouping and simply rewrite thd depth and row relationships + if (depth >= existingGrouping.length) { + return rows.map(row => { + row.depth = depth; + groupedFlatRows.push(row); + groupedRowsById[row.id] = row; + if (row.subRows) { + row.subRows = groupUpRecursively(row.subRows, depth + 1); + } + return row; + }); + } + const columnId = existingGrouping[depth]; + + // Group the rows together for this level + const rowGroupsMap = groupBy(rows, columnId); + + // Peform aggregations for each group + const aggregatedGroupedRows = Array.from(rowGroupsMap.entries()).map((_ref, index) => { + let [groupingValue, groupedRows] = _ref; + let id = `${columnId}:${groupingValue}`; + id = parentId ? `${parentId}>${id}` : id; + + // First, Recurse to group sub rows before aggregation + const subRows = groupUpRecursively(groupedRows, depth + 1, id); + + // Flatten the leaf rows of the rows in this group + const leafRows = depth ? flattenBy(groupedRows, row => row.subRows) : groupedRows; + const row = createRow(table, id, leafRows[0].original, index, depth); + Object.assign(row, { + groupingColumnId: columnId, + groupingValue, + subRows, + leafRows, + getValue: columnId => { + // Don't aggregate columns that are in the grouping + if (existingGrouping.includes(columnId)) { + if (row._valuesCache.hasOwnProperty(columnId)) { + return row._valuesCache[columnId]; + } + if (groupedRows[0]) { + var _groupedRows$0$getVal; + row._valuesCache[columnId] = (_groupedRows$0$getVal = groupedRows[0].getValue(columnId)) != null ? _groupedRows$0$getVal : undefined; + } + return row._valuesCache[columnId]; + } + if (row._groupingValuesCache.hasOwnProperty(columnId)) { + return row._groupingValuesCache[columnId]; + } + + // Aggregate the values + const column = table.getColumn(columnId); + const aggregateFn = column.getAggregationFn(); + if (aggregateFn) { + row._groupingValuesCache[columnId] = aggregateFn(columnId, leafRows, groupedRows); + return row._groupingValuesCache[columnId]; + } + } + }); + subRows.forEach(subRow => { + groupedFlatRows.push(subRow); + groupedRowsById[subRow.id] = subRow; + // if (subRow.getIsGrouped?.()) { + // onlyGroupedFlatRows.push(subRow); + // onlyGroupedRowsById[subRow.id] = subRow; + // } else { + // nonGroupedFlatRows.push(subRow); + // nonGroupedRowsById[subRow.id] = subRow; + // } + }); + + return row; + }); + return aggregatedGroupedRows; + }; + const groupedRows = groupUpRecursively(rowModel.rows, 0, ''); + groupedRows.forEach(subRow => { + groupedFlatRows.push(subRow); + groupedRowsById[subRow.id] = subRow; + // if (subRow.getIsGrouped?.()) { + // onlyGroupedFlatRows.push(subRow); + // onlyGroupedRowsById[subRow.id] = subRow; + // } else { + // nonGroupedFlatRows.push(subRow); + // nonGroupedRowsById[subRow.id] = subRow; + // } + }); + + return { + rows: groupedRows, + flatRows: groupedFlatRows, + rowsById: groupedRowsById + }; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + }, + onChange: () => { + table._queue(() => { + table._autoResetExpanded(); + table._autoResetPageIndex(); + }); + } + }); +} +function groupBy(rows, columnId) { + const groupMap = new Map(); + return rows.reduce((map, row) => { + const resKey = `${row.getValue(columnId)}`; + const previous = map.get(resKey); + if (!previous) { + map.set(resKey, [row]); + } else { + previous.push(row); + } + return map; + }, groupMap); +} + +function getExpandedRowModel() { + return table => memo(() => [table.getState().expanded, table.getPreExpandedRowModel(), table.options.paginateExpandedRows], (expanded, rowModel, paginateExpandedRows) => { + if (!rowModel.rows.length || expanded !== true && !Object.keys(expanded != null ? expanded : {}).length) { + return rowModel; + } + if (!paginateExpandedRows) { + // Only expand rows at this point if they are being paginated + return rowModel; + } + return expandRows(rowModel); + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + } + }); +} +function expandRows(rowModel) { + const expandedRows = []; + const handleRow = row => { + expandedRows.push(row); + if (row.subRows?.length && row.getIsExpanded()) { + row.subRows.forEach(handleRow); + } + }; + rowModel.rows.forEach(handleRow); + return { + rows: expandedRows, + flatRows: rowModel.flatRows, + rowsById: rowModel.rowsById + }; +} + +function getPaginationRowModel(opts) { + return table => memo(() => [table.getState().pagination, table.getPrePaginationRowModel(), table.options.paginateExpandedRows ? undefined : table.getState().expanded], (pagination, rowModel) => { + if (!rowModel.rows.length) { + return rowModel; + } + const { + pageSize, + pageIndex + } = pagination; + let { + rows, + flatRows, + rowsById + } = rowModel; + const pageStart = pageSize * pageIndex; + const pageEnd = pageStart + pageSize; + rows = rows.slice(pageStart, pageEnd); + let paginatedRowModel; + if (!table.options.paginateExpandedRows) { + paginatedRowModel = expandRows({ + rows, + flatRows, + rowsById + }); + } else { + paginatedRowModel = { + rows, + flatRows, + rowsById + }; + } + paginatedRowModel.flatRows = []; + const handleRow = row => { + paginatedRowModel.flatRows.push(row); + if (row.subRows.length) { + row.subRows.forEach(handleRow); + } + }; + paginatedRowModel.rows.forEach(handleRow); + return paginatedRowModel; + }, { + key: false && 0, + debug: () => { + var _table$options$debugA; + return (_table$options$debugA = table.options.debugAll) != null ? _table$options$debugA : table.options.debugTable; + } + }); +} + + +//# sourceMappingURL=index.mjs.map + + +/***/ }) + +}]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/framework-6d1b27d161789b4d/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/framework-6d1b27d161789b4d/input.js new file mode 100644 index 000000000000..f709628236dd --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/framework-6d1b27d161789b4d/input.js @@ -0,0 +1,496 @@ +"use strict"; +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[774],{ + +/***/ 4448: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +/** + * @license React + * react-dom.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/* + Modernizr 3.0.0pre (Custom Build) | MIT +*/ +var aa=__webpack_require__(7294),ca=__webpack_require__(3840);function p(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;cb}return!1}function v(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g}var z={}; +"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){z[a]=new v(a,0,!1,a,null,!1,!1)});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];z[b]=new v(b,1,!1,a[1],null,!1,!1)});["contentEditable","draggable","spellCheck","value"].forEach(function(a){z[a]=new v(a,2,!1,a.toLowerCase(),null,!1,!1)}); +["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){z[a]=new v(a,2,!1,a,null,!1,!1)});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){z[a]=new v(a,3,!1,a.toLowerCase(),null,!1,!1)}); +["checked","multiple","muted","selected"].forEach(function(a){z[a]=new v(a,3,!0,a,null,!1,!1)});["capture","download"].forEach(function(a){z[a]=new v(a,4,!1,a,null,!1,!1)});["cols","rows","size","span"].forEach(function(a){z[a]=new v(a,6,!1,a,null,!1,!1)});["rowSpan","start"].forEach(function(a){z[a]=new v(a,5,!1,a.toLowerCase(),null,!1,!1)});var ra=/[\-:]([a-z])/g;function sa(a){return a[1].toUpperCase()} +"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(ra, +sa);z[b]=new v(b,1,!1,a,null,!1,!1)});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1)});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(ra,sa);z[b]=new v(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1)});["tabIndex","crossOrigin"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!1,!1)}); +z.xlinkHref=new v("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){z[a]=new v(a,1,!1,a.toLowerCase(),null,!0,!0)}); +function ta(a,b,c,d){var e=z.hasOwnProperty(b)?z[b]:null;if(null!==e?0!==e.type:d||!(2h||e[g]!==f[h]){var k="\n"+e[g].replace(" at new "," at ");a.displayName&&k.includes("")&&(k=k.replace("",a.displayName));return k}while(1<=g&&0<=h)}break}}}finally{Na=!1,Error.prepareStackTrace=c}return(a=a?a.displayName||a.name:"")?Ma(a):""} +function Pa(a){switch(a.tag){case 5:return Ma(a.type);case 16:return Ma("Lazy");case 13:return Ma("Suspense");case 19:return Ma("SuspenseList");case 0:case 2:case 15:return a=Oa(a.type,!1),a;case 11:return a=Oa(a.type.render,!1),a;case 1:return a=Oa(a.type,!0),a;default:return""}} +function Qa(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case ya:return"Fragment";case wa:return"Portal";case Aa:return"Profiler";case za:return"StrictMode";case Ea:return"Suspense";case Fa:return"SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case Ca:return(a.displayName||"Context")+".Consumer";case Ba:return(a._context.displayName||"Context")+".Provider";case Da:var b=a.render;a=a.displayName;a||(a=b.displayName|| +b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case Ga:return b=a.displayName||null,null!==b?b:Qa(a.type)||"Memo";case Ha:b=a._payload;a=a._init;try{return Qa(a(b))}catch(c){}}return null} +function Ra(a){var b=a.type;switch(a.tag){case 24:return"Cache";case 9:return(b.displayName||"Context")+".Consumer";case 10:return(b._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return a=b.render,a=a.displayName||a.name||"",b.displayName||(""!==a?"ForwardRef("+a+")":"ForwardRef");case 7:return"Fragment";case 5:return b;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return Qa(b);case 8:return b===za?"StrictMode":"Mode";case 22:return"Offscreen"; +case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if("function"===typeof b)return b.displayName||b.name||null;if("string"===typeof b)return b}return null}function Sa(a){switch(typeof a){case "boolean":case "number":case "string":case "undefined":return a;case "object":return a;default:return""}} +function Ta(a){var b=a.type;return(a=a.nodeName)&&"input"===a.toLowerCase()&&("checkbox"===b||"radio"===b)} +function Ua(a){var b=Ta(a)?"checked":"value",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=""+a[b];if(!a.hasOwnProperty(b)&&"undefined"!==typeof c&&"function"===typeof c.get&&"function"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=""+a;f.call(this,a)}});Object.defineProperty(a,b,{enumerable:c.enumerable});return{getValue:function(){return d},setValue:function(a){d=""+a},stopTracking:function(){a._valueTracker= +null;delete a[b]}}}}function Va(a){a._valueTracker||(a._valueTracker=Ua(a))}function Wa(a){if(!a)return!1;var b=a._valueTracker;if(!b)return!0;var c=b.getValue();var d="";a&&(d=Ta(a)?a.checked?"true":"false":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Xa(a){a=a||("undefined"!==typeof document?document:void 0);if("undefined"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}} +function Ya(a,b){var c=b.checked;return A({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Za(a,b){var c=null==b.defaultValue?"":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Sa(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:"checkbox"===b.type||"radio"===b.type?null!=b.checked:null!=b.value}}function ab(a,b){b=b.checked;null!=b&&ta(a,"checked",b,!1)} +function bb(a,b){ab(a,b);var c=Sa(b.value),d=b.type;if(null!=c)if("number"===d){if(0===c&&""===a.value||a.value!=c)a.value=""+c}else a.value!==""+c&&(a.value=""+c);else if("submit"===d||"reset"===d){a.removeAttribute("value");return}b.hasOwnProperty("value")?cb(a,b.type,c):b.hasOwnProperty("defaultValue")&&cb(a,b.type,Sa(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked)} +function db(a,b,c){if(b.hasOwnProperty("value")||b.hasOwnProperty("defaultValue")){var d=b.type;if(!("submit"!==d&&"reset"!==d||void 0!==b.value&&null!==b.value))return;b=""+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b}c=a.name;""!==c&&(a.name="");a.defaultChecked=!!a._wrapperState.initialChecked;""!==c&&(a.name=c)} +function cb(a,b,c){if("number"!==b||Xa(a.ownerDocument)!==a)null==c?a.defaultValue=""+a._wrapperState.initialValue:a.defaultValue!==""+c&&(a.defaultValue=""+c)}var eb=Array.isArray; +function fb(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e"+b.valueOf().toString()+"";for(b=mb.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild)}}); +function ob(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b} +var pb={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0, +zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},qb=["Webkit","ms","Moz","O"];Object.keys(pb).forEach(function(a){qb.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);pb[b]=pb[a]})});function rb(a,b,c){return null==b||"boolean"===typeof b||""===b?"":c||"number"!==typeof b||0===b||pb.hasOwnProperty(a)&&pb[a]?(""+b).trim():b+"px"} +function sb(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf("--"),e=rb(c,b[c],d);"float"===c&&(c="cssFloat");d?a.setProperty(c,e):a[c]=e}}var tb=A({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0}); +function ub(a,b){if(b){if(tb[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(p(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(p(60));if("object"!==typeof b.dangerouslySetInnerHTML||!("__html"in b.dangerouslySetInnerHTML))throw Error(p(61));}if(null!=b.style&&"object"!==typeof b.style)throw Error(p(62));}} +function vb(a,b){if(-1===a.indexOf("-"))return"string"===typeof b.is;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return!1;default:return!0}}var wb=null;function xb(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var yb=null,zb=null,Ab=null; +function Bb(a){if(a=Cb(a)){if("function"!==typeof yb)throw Error(p(280));var b=a.stateNode;b&&(b=Db(b),yb(a.stateNode,a.type,b))}}function Eb(a){zb?Ab?Ab.push(a):Ab=[a]:zb=a}function Fb(){if(zb){var a=zb,b=Ab;Ab=zb=null;Bb(a);if(b)for(a=0;a>>=0;return 0===a?32:31-(pc(a)/qc|0)|0}var rc=64,sc=4194304; +function tc(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return a&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return a&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824; +default:return a}}function uc(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes,f=a.pingedLanes,g=c&268435455;if(0!==g){var h=g&~e;0!==h?d=tc(h):(f&=g,0!==f&&(d=tc(f)))}else g=c&~e,0!==g?d=tc(g):0!==f&&(d=tc(f));if(0===d)return 0;if(0!==b&&b!==d&&0===(b&e)&&(e=d&-d,f=b&-b,e>=f||16===e&&0!==(f&4194240)))return b;0!==(d&4)&&(d|=c&16);b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0c;c++)b.push(a);return b} +function Ac(a,b,c){a.pendingLanes|=b;536870912!==b&&(a.suspendedLanes=0,a.pingedLanes=0);a=a.eventTimes;b=31-oc(b);a[b]=c}function Bc(a,b){var c=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.mutableReadLanes&=b;a.entangledLanes&=b;b=a.entanglements;var d=a.eventTimes;for(a=a.expirationTimes;0=be),ee=String.fromCharCode(32),fe=!1; +function ge(a,b){switch(a){case "keyup":return-1!==$d.indexOf(b.keyCode);case "keydown":return 229!==b.keyCode;case "keypress":case "mousedown":case "focusout":return!0;default:return!1}}function he(a){a=a.detail;return"object"===typeof a&&"data"in a?a.data:null}var ie=!1;function je(a,b){switch(a){case "compositionend":return he(b);case "keypress":if(32!==b.which)return null;fe=!0;return ee;case "textInput":return a=b.data,a===ee&&fe?null:a;default:return null}} +function ke(a,b){if(ie)return"compositionend"===a||!ae&&ge(a,b)?(a=nd(),md=ld=kd=null,ie=!1,a):null;switch(a){case "paste":return null;case "keypress":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1=b)return{node:c,offset:b-a};a=d}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode}c=void 0}c=Je(c)}}function Le(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Le(a,b.parentNode):"contains"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1} +function Me(){for(var a=window,b=Xa();b instanceof a.HTMLIFrameElement;){try{var c="string"===typeof b.contentWindow.location.href}catch(d){c=!1}if(c)a=b.contentWindow;else break;b=Xa(a.document)}return b}function Ne(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&("input"===b&&("text"===a.type||"search"===a.type||"tel"===a.type||"url"===a.type||"password"===a.type)||"textarea"===b||"true"===a.contentEditable)} +function Oe(a){var b=Me(),c=a.focusedElem,d=a.selectionRange;if(b!==c&&c&&c.ownerDocument&&Le(c.ownerDocument.documentElement,c)){if(null!==d&&Ne(c))if(b=d.start,a=d.end,void 0===a&&(a=b),"selectionStart"in c)c.selectionStart=b,c.selectionEnd=Math.min(a,c.value.length);else if(a=(b=c.ownerDocument||document)&&b.defaultView||window,a.getSelection){a=a.getSelection();var e=c.textContent.length,f=Math.min(d.start,e);d=void 0===d.end?f:Math.min(d.end,e);!a.extend&&f>d&&(e=d,d=f,f=e);e=Ke(c,f);var g=Ke(c, +d);e&&g&&(1!==a.rangeCount||a.anchorNode!==e.node||a.anchorOffset!==e.offset||a.focusNode!==g.node||a.focusOffset!==g.offset)&&(b=b.createRange(),b.setStart(e.node,e.offset),a.removeAllRanges(),f>d?(a.addRange(b),a.extend(g.node,g.offset)):(b.setEnd(g.node,g.offset),a.addRange(b)))}b=[];for(a=c;a=a.parentNode;)1===a.nodeType&&b.push({element:a,left:a.scrollLeft,top:a.scrollTop});"function"===typeof c.focus&&c.focus();for(c=0;c=document.documentMode,Qe=null,Re=null,Se=null,Te=!1; +function Ue(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Te||null==Qe||Qe!==Xa(d)||(d=Qe,"selectionStart"in d&&Ne(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Se&&Ie(Se,d)||(Se=d,d=oe(Re,"onSelect"),0Tf||(a.current=Sf[Tf],Sf[Tf]=null,Tf--)}function G(a,b){Tf++;Sf[Tf]=a.current;a.current=b}var Vf={},H=Uf(Vf),Wf=Uf(!1),Xf=Vf;function Yf(a,b){var c=a.type.contextTypes;if(!c)return Vf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e} +function Zf(a){a=a.childContextTypes;return null!==a&&void 0!==a}function $f(){E(Wf);E(H)}function ag(a,b,c){if(H.current!==Vf)throw Error(p(168));G(H,b);G(Wf,c)}function bg(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(p(108,Ra(a)||"Unknown",e));return A({},c,d)} +function cg(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Vf;Xf=H.current;G(H,a);G(Wf,Wf.current);return!0}function dg(a,b,c){var d=a.stateNode;if(!d)throw Error(p(169));c?(a=bg(a,b,Xf),d.__reactInternalMemoizedMergedChildContext=a,E(Wf),E(H),G(H,a)):E(Wf);G(Wf,c)}var eg=null,fg=!1,gg=!1;function hg(a){null===eg?eg=[a]:eg.push(a)}function ig(a){fg=!0;hg(a)} +function jg(){if(!gg&&null!==eg){gg=!0;var a=0,b=C;try{var c=eg;for(C=1;a>=g;e-=g;rg=1<<32-oc(b)+e|c<w?(x=u,u=null):x=u.sibling;var n=r(e,u,h[w],k);if(null===n){null===u&&(u=x);break}a&&u&&null===n.alternate&&b(e,u);g=f(n,g,w);null===m?l=n:m.sibling=n;m=n;u=x}if(w===h.length)return c(e,u),I&&tg(e,w),l;if(null===u){for(;ww?(x=m,m=null):x=m.sibling;var t=r(e,m,n.value,k);if(null===t){null===m&&(m=x);break}a&&m&&null===t.alternate&&b(e,m);g=f(t,g,w);null===u?l=t:u.sibling=t;u=t;m=x}if(n.done)return c(e, +m),I&&tg(e,w),l;if(null===m){for(;!n.done;w++,n=h.next())n=q(e,n.value,k),null!==n&&(g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);I&&tg(e,w);return l}for(m=d(e,m);!n.done;w++,n=h.next())n=y(m,e,w,n.value,k),null!==n&&(a&&null!==n.alternate&&m.delete(null===n.key?w:n.key),g=f(n,g,w),null===u?l=n:u.sibling=n,u=n);a&&m.forEach(function(a){return b(e,a)});I&&tg(e,w);return l}function J(a,d,f,h){"object"===typeof f&&null!==f&&f.type===ya&&null===f.key&&(f=f.props.children);if("object"===typeof f&&null!==f){switch(f.$$typeof){case va:a:{for(var k= +f.key,l=d;null!==l;){if(l.key===k){k=f.type;if(k===ya){if(7===l.tag){c(a,l.sibling);d=e(l,f.props.children);d.return=a;a=d;break a}}else if(l.elementType===k||"object"===typeof k&&null!==k&&k.$$typeof===Ha&&uh(k)===l.type){c(a,l.sibling);d=e(l,f.props);d.ref=sh(a,l,f);d.return=a;a=d;break a}c(a,l);break}else b(a,l);l=l.sibling}f.type===ya?(d=Ah(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=yh(f.type,f.key,f.props,null,a.mode,h),h.ref=sh(a,d,f),h.return=a,a=h)}return g(a);case wa:a:{for(l=f.key;null!== +d;){if(d.key===l)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else{c(a,d);break}else b(a,d);d=d.sibling}d=zh(f,a.mode,h);d.return=a;a=d}return g(a);case Ha:return l=f._init,J(a,d,l(f._payload),h)}if(eb(f))return n(a,d,f,h);if(Ka(f))return t(a,d,f,h);th(a,f)}return"string"===typeof f&&""!==f||"number"===typeof f?(f=""+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d): +(c(a,d),d=xh(f,a.mode,h),d.return=a,a=d),g(a)):c(a,d)}return J}var Bh=vh(!0),Ch=vh(!1),Dh={},Eh=Uf(Dh),Fh=Uf(Dh),Gh=Uf(Dh);function Hh(a){if(a===Dh)throw Error(p(174));return a}function Ih(a,b){G(Gh,b);G(Fh,a);G(Eh,Dh);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:lb(null,"");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=lb(b,a)}E(Eh);G(Eh,b)}function Jh(){E(Eh);E(Fh);E(Gh)} +function Kh(a){Hh(Gh.current);var b=Hh(Eh.current);var c=lb(b,a.type);b!==c&&(G(Fh,a),G(Eh,c))}function Lh(a){Fh.current===a&&(E(Eh),E(Fh))}var M=Uf(0); +function Mh(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return}b.sibling.return=b.return;b=b.sibling}return null}var Nh=[]; +function Oh(){for(var a=0;ac?c:4;a(!0);var d=Qh.transition;Qh.transition={};try{a(!1),b()}finally{C=c,Qh.transition=d}}function Fi(){return di().memoizedState} +function Gi(a,b,c){var d=lh(a);c={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(Hi(a))Ii(b,c);else if(c=Yg(a,b,c,d),null!==c){var e=L();mh(c,a,d,e);Ji(c,b,d)}} +function ri(a,b,c){var d=lh(a),e={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(Hi(a))Ii(b,e);else{var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(He(h,g)){var k=b.interleaved;null===k?(e.next=e,Xg(b)):(e.next=k.next,k.next=e);b.interleaved=e;return}}catch(l){}finally{}c=Yg(a,b,e,d);null!==c&&(e=L(),mh(c,a,d,e),Ji(c,b,d))}} +function Hi(a){var b=a.alternate;return a===N||null!==b&&b===N}function Ii(a,b){Th=Sh=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b}function Ji(a,b,c){if(0!==(c&4194240)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;Cc(a,c)}} +var ai={readContext:Vg,useCallback:Q,useContext:Q,useEffect:Q,useImperativeHandle:Q,useInsertionEffect:Q,useLayoutEffect:Q,useMemo:Q,useReducer:Q,useRef:Q,useState:Q,useDebugValue:Q,useDeferredValue:Q,useTransition:Q,useMutableSource:Q,useSyncExternalStore:Q,useId:Q,unstable_isNewReconciler:!1},Yh={readContext:Vg,useCallback:function(a,b){ci().memoizedState=[a,void 0===b?null:b];return a},useContext:Vg,useEffect:vi,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return ti(4194308, +4,yi.bind(null,b,a),c)},useLayoutEffect:function(a,b){return ti(4194308,4,a,b)},useInsertionEffect:function(a,b){return ti(4,2,a,b)},useMemo:function(a,b){var c=ci();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=ci();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=Gi.bind(null,N,a);return[d.memoizedState,a]},useRef:function(a){var b= +ci();a={current:a};return b.memoizedState=a},useState:qi,useDebugValue:Ai,useDeferredValue:function(a){return ci().memoizedState=a},useTransition:function(){var a=qi(!1),b=a[0];a=Ei.bind(null,a[1]);ci().memoizedState=a;return[b,a]},useMutableSource:function(){},useSyncExternalStore:function(a,b,c){var d=N,e=ci();if(I){if(void 0===c)throw Error(p(407));c=c()}else{c=b();if(null===R)throw Error(p(349));0!==(Rh&30)||ni(d,b,c)}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;vi(ki.bind(null,d, +f,a),[a]);d.flags|=2048;li(9,mi.bind(null,d,f,c,b),void 0,null);return c},useId:function(){var a=ci(),b=R.identifierPrefix;if(I){var c=sg;var d=rg;c=(d&~(1<<32-oc(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Uh++;0\x3c/script>",a=a.removeChild(a.firstChild)): +"string"===typeof d.is?a=g.createElement(c,{is:d.is}):(a=g.createElement(c),"select"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[Of]=b;a[Pf]=d;Aj(a,b,!1,!1);b.stateNode=a;a:{g=vb(c,d);switch(c){case "dialog":D("cancel",a);D("close",a);e=d;break;case "iframe":case "object":case "embed":D("load",a);e=d;break;case "video":case "audio":for(e=0;eHj&&(b.flags|=128,d=!0,Ej(f,!1),b.lanes=4194304)}else{if(!d)if(a=Mh(g),null!==a){if(b.flags|=128,d=!0,c=a.updateQueue,null!==c&&(b.updateQueue=c,b.flags|=4),Ej(f,!0),null===f.tail&&"hidden"===f.tailMode&&!g.alternate&&!I)return S(b),null}else 2*B()-f.renderingStartTime>Hj&&1073741824!==c&&(b.flags|=128,d=!0,Ej(f,!1),b.lanes=4194304);f.isBackwards?(g.sibling=b.child,b.child=g):(c=f.last,null!==c?c.sibling=g:b.child=g,f.last=g)}if(null!==f.tail)return b=f.tail,f.rendering= +b,f.tail=b.sibling,f.renderingStartTime=B(),b.sibling=null,c=M.current,G(M,d?c&1|2:c&1),b;S(b);return null;case 22:case 23:return Ij(),d=null!==b.memoizedState,null!==a&&null!==a.memoizedState!==d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(gj&1073741824)&&(S(b),b.subtreeFlags&6&&(b.flags|=8192)):S(b),null;case 24:return null;case 25:return null}throw Error(p(156,b.tag));} +function Jj(a,b){wg(b);switch(b.tag){case 1:return Zf(b.type)&&$f(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return Jh(),E(Wf),E(H),Oh(),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 5:return Lh(b),null;case 13:E(M);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(p(340));Ig()}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return E(M),null;case 4:return Jh(),null;case 10:return Rg(b.type._context),null;case 22:case 23:return Ij(), +null;case 24:return null;default:return null}}var Kj=!1,U=!1,Lj="function"===typeof WeakSet?WeakSet:Set,V=null;function Mj(a,b){var c=a.ref;if(null!==c)if("function"===typeof c)try{c(null)}catch(d){W(a,b,d)}else c.current=null}function Nj(a,b,c){try{c()}catch(d){W(a,b,d)}}var Oj=!1; +function Pj(a,b){Cf=dd;a=Me();if(Ne(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType}catch(F){c=null;break a}var g=0,h=-1,k=-1,l=0,m=0,q=a,r=null;b:for(;;){for(var y;;){q!==c||0!==e&&3!==q.nodeType||(h=g+e);q!==f||0!==d&&3!==q.nodeType||(k=g+d);3===q.nodeType&&(g+= +q.nodeValue.length);if(null===(y=q.firstChild))break;r=q;q=y}for(;;){if(q===a)break b;r===c&&++l===e&&(h=g);r===f&&++m===d&&(k=g);if(null!==(y=q.nextSibling))break;q=r;r=q.parentNode}q=y}c=-1===h||-1===k?null:{start:h,end:k}}else c=null}c=c||{start:0,end:0}}else c=null;Df={focusedElem:a,selectionRange:c};dd=!1;for(V=b;null!==V;)if(b=V,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,V=a;else for(;null!==V;){b=V;try{var n=b.alternate;if(0!==(b.flags&1024))switch(b.tag){case 0:case 11:case 15:break; +case 1:if(null!==n){var t=n.memoizedProps,J=n.memoizedState,x=b.stateNode,w=x.getSnapshotBeforeUpdate(b.elementType===b.type?t:Lg(b.type,t),J);x.__reactInternalSnapshotBeforeUpdate=w}break;case 3:var u=b.stateNode.containerInfo;1===u.nodeType?u.textContent="":9===u.nodeType&&u.documentElement&&u.removeChild(u.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(p(163));}}catch(F){W(b,b.return,F)}a=b.sibling;if(null!==a){a.return=b.return;V=a;break}V=b.return}n=Oj;Oj=!1;return n} +function Qj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.destroy;e.destroy=void 0;void 0!==f&&Nj(b,c,f)}e=e.next}while(e!==d)}}function Rj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create;c.destroy=d()}c=c.next}while(c!==b)}}function Sj(a){var b=a.ref;if(null!==b){var c=a.stateNode;switch(a.tag){case 5:a=c;break;default:a=c}"function"===typeof b?b(a):b.current=a}} +function Tj(a){var b=a.alternate;null!==b&&(a.alternate=null,Tj(b));a.child=null;a.deletions=null;a.sibling=null;5===a.tag&&(b=a.stateNode,null!==b&&(delete b[Of],delete b[Pf],delete b[of],delete b[Qf],delete b[Rf]));a.stateNode=null;a.return=null;a.dependencies=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.stateNode=null;a.updateQueue=null}function Uj(a){return 5===a.tag||3===a.tag||4===a.tag} +function Vj(a){a:for(;;){for(;null===a.sibling;){if(null===a.return||Uj(a.return))return null;a=a.return}a.sibling.return=a.return;for(a=a.sibling;5!==a.tag&&6!==a.tag&&18!==a.tag;){if(a.flags&2)continue a;if(null===a.child||4===a.tag)continue a;else a.child.return=a,a=a.child}if(!(a.flags&2))return a.stateNode}} +function Wj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=Bf));else if(4!==d&&(a=a.child,null!==a))for(Wj(a,b,c),a=a.sibling;null!==a;)Wj(a,b,c),a=a.sibling} +function Xj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(Xj(a,b,c),a=a.sibling;null!==a;)Xj(a,b,c),a=a.sibling}var X=null,Yj=!1;function Zj(a,b,c){for(c=c.child;null!==c;)ak(a,b,c),c=c.sibling} +function ak(a,b,c){if(lc&&"function"===typeof lc.onCommitFiberUnmount)try{lc.onCommitFiberUnmount(kc,c)}catch(h){}switch(c.tag){case 5:U||Mj(c,b);case 6:var d=X,e=Yj;X=null;Zj(a,b,c);X=d;Yj=e;null!==X&&(Yj?(a=X,c=c.stateNode,8===a.nodeType?a.parentNode.removeChild(c):a.removeChild(c)):X.removeChild(c.stateNode));break;case 18:null!==X&&(Yj?(a=X,c=c.stateNode,8===a.nodeType?Kf(a.parentNode,c):1===a.nodeType&&Kf(a,c),bd(a)):Kf(X,c.stateNode));break;case 4:d=X;e=Yj;X=c.stateNode.containerInfo;Yj=!0; +Zj(a,b,c);X=d;Yj=e;break;case 0:case 11:case 14:case 15:if(!U&&(d=c.updateQueue,null!==d&&(d=d.lastEffect,null!==d))){e=d=d.next;do{var f=e,g=f.destroy;f=f.tag;void 0!==g&&(0!==(f&2)?Nj(c,b,g):0!==(f&4)&&Nj(c,b,g));e=e.next}while(e!==d)}Zj(a,b,c);break;case 1:if(!U&&(Mj(c,b),d=c.stateNode,"function"===typeof d.componentWillUnmount))try{d.props=c.memoizedProps,d.state=c.memoizedState,d.componentWillUnmount()}catch(h){W(c,b,h)}Zj(a,b,c);break;case 21:Zj(a,b,c);break;case 22:c.mode&1?(U=(d=U)||null!== +c.memoizedState,Zj(a,b,c),U=d):Zj(a,b,c);break;default:Zj(a,b,c)}}function bk(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Lj);b.forEach(function(b){var d=ck.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d))})}} +function dk(a,b){var c=b.deletions;if(null!==c)for(var d=0;de&&(e=g);d&=~f}d=e;d=B()-d;d=(120>d?120:480>d?480:1080>d?1080:1920>d?1920:3E3>d?3E3:4320>d?4320:1960*mk(d/1960))-d;if(10a?16:a;if(null===xk)var d=!1;else{a=xk;xk=null;yk=0;if(0!==(K&6))throw Error(p(331));var e=K;K|=4;for(V=a.current;null!==V;){var f=V,g=f.child;if(0!==(V.flags&16)){var h=f.deletions;if(null!==h){for(var k=0;kB()-gk?Lk(a,0):sk|=c);Ek(a,b)}function Zk(a,b){0===b&&(0===(a.mode&1)?b=1:(b=sc,sc<<=1,0===(sc&130023424)&&(sc=4194304)));var c=L();a=Zg(a,b);null!==a&&(Ac(a,b,c),Ek(a,c))}function vj(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Zk(a,c)} +function ck(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;default:throw Error(p(314));}null!==d&&d.delete(b);Zk(a,c)}var Wk; +Wk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Wf.current)Ug=!0;else{if(0===(a.lanes&c)&&0===(b.flags&128))return Ug=!1,zj(a,b,c);Ug=0!==(a.flags&131072)?!0:!1}else Ug=!1,I&&0!==(b.flags&1048576)&&ug(b,ng,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;jj(a,b);a=b.pendingProps;var e=Yf(b,H.current);Tg(b,c);e=Xh(null,b,d,a,e,c);var f=bi();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?(b.tag=1,b.memoizedState=null,b.updateQueue= +null,Zf(d)?(f=!0,cg(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,ah(b),e.updater=nh,b.stateNode=e,e._reactInternals=b,rh(b,d,a,c),b=kj(null,b,d,!0,f,c)):(b.tag=0,I&&f&&vg(b),Yi(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{jj(a,b);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=$k(d);a=Lg(d,a);switch(e){case 0:b=dj(null,b,d,a,c);break a;case 1:b=ij(null,b,d,a,c);break a;case 11:b=Zi(null,b,d,a,c);break a;case 14:b=aj(null,b,d,Lg(d.type,a),c);break a}throw Error(p(306, +d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Lg(d,e),dj(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Lg(d,e),ij(a,b,d,e,c);case 3:a:{lj(b);if(null===a)throw Error(p(387));d=b.pendingProps;f=b.memoizedState;e=f.element;bh(a,b);gh(b,d,null,c);var g=b.memoizedState;d=g.element;if(f.isDehydrated)if(f={element:d,isDehydrated:!1,cache:g.cache,pendingSuspenseBoundaries:g.pendingSuspenseBoundaries,transitions:g.transitions},b.updateQueue.baseState= +f,b.memoizedState=f,b.flags&256){e=Ki(Error(p(423)),b);b=mj(a,b,d,c,e);break a}else if(d!==e){e=Ki(Error(p(424)),b);b=mj(a,b,d,c,e);break a}else for(yg=Lf(b.stateNode.containerInfo.firstChild),xg=b,I=!0,zg=null,c=Ch(b,null,d,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else{Ig();if(d===e){b=$i(a,b,c);break a}Yi(a,b,d,c)}b=b.child}return b;case 5:return Kh(b),null===a&&Eg(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,Ef(d,e)?g=null:null!==f&&Ef(d,f)&&(b.flags|=32), +hj(a,b),Yi(a,b,g,c),b.child;case 6:return null===a&&Eg(b),null;case 13:return pj(a,b,c);case 4:return Ih(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=Bh(b,null,d,c):Yi(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Lg(d,e),Zi(a,b,d,e,c);case 7:return Yi(a,b,b.pendingProps,c),b.child;case 8:return Yi(a,b,b.pendingProps.children,c),b.child;case 12:return Yi(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=b.type._context;e=b.pendingProps;f=b.memoizedProps; +g=e.value;G(Mg,d._currentValue);d._currentValue=g;if(null!==f)if(He(f.value,g)){if(f.children===e.children&&!Wf.current){b=$i(a,b,c);break a}}else for(f=b.child,null!==f&&(f.return=b);null!==f;){var h=f.dependencies;if(null!==h){g=f.child;for(var k=h.firstContext;null!==k;){if(k.context===d){if(1===f.tag){k=ch(-1,c&-c);k.tag=2;var l=f.updateQueue;if(null!==l){l=l.shared;var m=l.pending;null===m?k.next=k:(k.next=m.next,m.next=k);l.pending=k}}f.lanes|=c;k=f.alternate;null!==k&&(k.lanes|=c);Sg(f.return, +c,b);h.lanes|=c;break}k=k.next}}else if(10===f.tag)g=f.type===b.type?null:f.child;else if(18===f.tag){g=f.return;if(null===g)throw Error(p(341));g.lanes|=c;h=g.alternate;null!==h&&(h.lanes|=c);Sg(g,c,b);g=f.sibling}else g=f.child;if(null!==g)g.return=f;else for(g=f;null!==g;){if(g===b){g=null;break}f=g.sibling;if(null!==f){f.return=g.return;g=f;break}g=g.return}f=g}Yi(a,b,e.children,c);b=b.child}return b;case 9:return e=b.type,d=b.pendingProps.children,Tg(b,c),e=Vg(e),d=d(e),b.flags|=1,Yi(a,b,d,c), +b.child;case 14:return d=b.type,e=Lg(d,b.pendingProps),e=Lg(d.type,e),aj(a,b,d,e,c);case 15:return cj(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:Lg(d,e),jj(a,b),b.tag=1,Zf(d)?(a=!0,cg(b)):a=!1,Tg(b,c),ph(b,d,e),rh(b,d,e,c),kj(null,b,d,!0,a,c);case 19:return yj(a,b,c);case 22:return ej(a,b,c)}throw Error(p(156,b.tag));};function Gk(a,b){return ac(a,b)} +function al(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null}function Bg(a,b,c,d){return new al(a,b,c,d)}function bj(a){a=a.prototype;return!(!a||!a.isReactComponent)} +function $k(a){if("function"===typeof a)return bj(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Da)return 11;if(a===Ga)return 14}return 2} +function wh(a,b){var c=a.alternate;null===c?(c=Bg(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&14680064;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext}; +c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c} +function yh(a,b,c,d,e,f){var g=2;d=a;if("function"===typeof a)bj(a)&&(g=1);else if("string"===typeof a)g=5;else a:switch(a){case ya:return Ah(c.children,e,f,b);case za:g=8;e|=8;break;case Aa:return a=Bg(12,c,b,e|2),a.elementType=Aa,a.lanes=f,a;case Ea:return a=Bg(13,c,b,e),a.elementType=Ea,a.lanes=f,a;case Fa:return a=Bg(19,c,b,e),a.elementType=Fa,a.lanes=f,a;case Ia:return qj(c,e,f,b);default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case Ba:g=10;break a;case Ca:g=9;break a;case Da:g=11; +break a;case Ga:g=14;break a;case Ha:g=16;d=null;break a}throw Error(p(130,null==a?a:typeof a,""));}b=Bg(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function Ah(a,b,c,d){a=Bg(7,a,d,b);a.lanes=c;return a}function qj(a,b,c,d){a=Bg(22,a,d,b);a.elementType=Ia;a.lanes=c;a.stateNode={isHidden:!1};return a}function xh(a,b,c){a=Bg(6,a,null,b);a.lanes=c;return a} +function zh(a,b,c){b=Bg(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b} +function bl(a,b,c,d,e){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.pendingContext=this.context=null;this.callbackPriority=0;this.eventTimes=zc(0);this.expirationTimes=zc(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=zc(0);this.identifierPrefix=d;this.onRecoverableError=e;this.mutableSourceEagerHydrationData= +null}function cl(a,b,c,d,e,f,g,h,k){a=new bl(a,b,c,h,k);1===b?(b=1,!0===f&&(b|=8)):b=0;f=Bg(3,null,null,b);a.current=f;f.stateNode=a;f.memoizedState={element:d,isDehydrated:c,cache:null,transitions:null,pendingSuspenseBoundaries:null};ah(f);return a}function dl(a,b,c){var d=3>>1,e=a[d];if(0>>1;dg(C,c))ng(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(ng(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b} +function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()}}else{var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q}}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null; +"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t)}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else{var b=h(t);null!==b&&K(H,b.startTime-a)}} +function J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if("function"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?v.callback=e:v===h(r)&&k(r);G(b)}else k(r);v=h(r)}if(null!==v)var w=!0;else{var m=h(t);null!==m&&K(H,m.startTime-b);w=!1}return w}finally{v=null,y=c,z=!1}}var N=!1,O=null,L=-1,P=5,Q=-1; +function M(){return exports.unstable_now()-Qa||125d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a}; +exports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c}}}; + + +/***/ }), + +/***/ 3840: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + + + +if (true) { + module.exports = __webpack_require__(53); +} else {} + + +/***/ }) + +}]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/main-238559e1edeaaf10/input.js b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/main-238559e1edeaaf10/input.js new file mode 100644 index 000000000000..7c55f6e7af80 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/fixture/issues/6636/static/chunks/main-238559e1edeaaf10/input.js @@ -0,0 +1,5784 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[179],{ + +/***/ 932: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ + value: true +}); +Object.defineProperty(exports, "Z", ({ + enumerable: true, + get: function() { + return _asyncToGenerator; + } +})); +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} +function _asyncToGenerator(fn) { + return function() { + var self = this, args = arguments; + return new Promise(function(resolve, reject) { + var gen = fn.apply(self, args); + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + _next(undefined); + }); + }; +} + + +/***/ }), + +/***/ 6495: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ + value: true +}); +Object.defineProperty(exports, "Z", ({ + enumerable: true, + get: function() { + return _extends; + } +})); +function extends_() { + extends_ = Object.assign || function(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i]; + for(var key in source){ + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + return target; + }; + return extends_.apply(this, arguments); +} +function _extends() { + return extends_.apply(this, arguments); +} + + +/***/ }), + +/***/ 2648: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ + value: true +}); +Object.defineProperty(exports, "Z", ({ + enumerable: true, + get: function() { + return _interopRequireDefault; + } +})); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + + +/***/ }), + +/***/ 1598: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ + value: true +}); +Object.defineProperty(exports, "Z", ({ + enumerable: true, + get: function() { + return _interopRequireWildcard; + } +})); +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== "function") return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + for(var key in obj){ + if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + + +/***/ }), + +/***/ 7273: +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; +var __webpack_unused_export__; + +__webpack_unused_export__ = ({ + value: true +}); +Object.defineProperty(exports, "Z", ({ + enumerable: true, + get: function() { + return _objectWithoutPropertiesLoose; + } +})); +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + for(i = 0; i < sourceKeys.length; i++){ + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + return target; +} + + +/***/ }), + +/***/ 37: +/***/ (function() { + +"trimStart"in String.prototype||(String.prototype.trimStart=String.prototype.trimLeft),"trimEnd"in String.prototype||(String.prototype.trimEnd=String.prototype.trimRight),"description"in Symbol.prototype||Object.defineProperty(Symbol.prototype,"description",{configurable:!0,get:function(){var t=/\((.*)\)/.exec(this.toString());return t?t[1]:void 0}}),Array.prototype.flat||(Array.prototype.flat=function(t,r){return r=this.concat.apply([],this),t>1&&r.some(Array.isArray)?r.flat(t-1):r},Array.prototype.flatMap=function(t,r){return this.map(t,r).flat()}),Promise.prototype.finally||(Promise.prototype.finally=function(t){if("function"!=typeof t)return this.then(t,t);var r=this.constructor||Promise;return this.then(function(o){return r.resolve(t()).then(function(){return o})},function(o){return r.resolve(t()).then(function(){throw o})})}),Object.fromEntries||(Object.fromEntries=function(t){return Array.from(t).reduce(function(t,r){return t[r[0]]=r[1],t},{})}); + + +/***/ }), + +/***/ 3468: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.addBasePath = addBasePath; +var _addPathPrefix = __webpack_require__(4135); +var _normalizeTrailingSlash = __webpack_require__(2700); +const basePath = false || ""; +function addBasePath(path, required) { + if (false) {} + return (0, _normalizeTrailingSlash).normalizePathTrailingSlash((0, _addPathPrefix).addPathPrefix(path, basePath)); +} +if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") { + Object.defineProperty(exports.default, "__esModule", { + value: true + }); + Object.assign(exports.default, exports); + module.exports = exports.default; +} //# sourceMappingURL=add-base-path.js.map + + +/***/ }), + +/***/ 4465: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.addLocale = void 0; +var _normalizeTrailingSlash = __webpack_require__(2700); +const addLocale = function(path) { + for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){ + args[_key - 1] = arguments[_key]; + } + if (false) {} + return path; +}; +exports.addLocale = addLocale; +if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") { + Object.defineProperty(exports.default, "__esModule", { + value: true + }); + Object.assign(exports.default, exports); + module.exports = exports.default; +} //# sourceMappingURL=add-locale.js.map + + +/***/ }), + +/***/ 4643: +/***/ (function(module, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.detectDomainLocale = void 0; +const detectDomainLocale = function() { + for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){ + args[_key] = arguments[_key]; + } + if (false) {} +}; +exports.detectDomainLocale = detectDomainLocale; +if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") { + Object.defineProperty(exports.default, "__esModule", { + value: true + }); + Object.assign(exports.default, exports); + module.exports = exports.default; +} //# sourceMappingURL=detect-domain-locale.js.map + + +/***/ }), + +/***/ 928: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.hasBasePath = hasBasePath; +var _pathHasPrefix = __webpack_require__(3210); +const basePath = false || ""; +function hasBasePath(path) { + return (0, _pathHasPrefix).pathHasPrefix(path, basePath); +} +if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") { + Object.defineProperty(exports.default, "__esModule", { + value: true + }); + Object.assign(exports.default, exports); + module.exports = exports.default; +} //# sourceMappingURL=has-base-path.js.map + + +/***/ }), + +/***/ 1831: +/***/ (function(module, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = initHeadManager; +exports.isEqualNode = isEqualNode; +exports.DOMAttributeNames = void 0; +function initHeadManager() { + return { + mountedInstances: new Set(), + updateHead: (head)=>{ + const tags = {}; + head.forEach((h)=>{ + if (// it won't be inlined. In this case revert to the original behavior + h.type === "link" && h.props["data-optimized-fonts"]) { + if (document.querySelector('style[data-href="'.concat(h.props["data-href"], '"]'))) { + return; + } else { + h.props.href = h.props["data-href"]; + h.props["data-href"] = undefined; + } + } + const components = tags[h.type] || []; + components.push(h); + tags[h.type] = components; + }); + const titleComponent = tags.title ? tags.title[0] : null; + let title = ""; + if (titleComponent) { + const { children } = titleComponent.props; + title = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : ""; + } + if (title !== document.title) document.title = title; + [ + "meta", + "base", + "link", + "style", + "script" + ].forEach((type)=>{ + updateElements(type, tags[type] || []); + }); + } + }; +} +const DOMAttributeNames = { + acceptCharset: "accept-charset", + className: "class", + htmlFor: "for", + httpEquiv: "http-equiv", + noModule: "noModule" +}; +exports.DOMAttributeNames = DOMAttributeNames; +function reactElementToDOM(param) { + let { type , props } = param; + const el = document.createElement(type); + for(const p in props){ + if (!props.hasOwnProperty(p)) continue; + if (p === "children" || p === "dangerouslySetInnerHTML") continue; + // we don't render undefined props to the DOM + if (props[p] === undefined) continue; + const attr = DOMAttributeNames[p] || p.toLowerCase(); + if (type === "script" && (attr === "async" || attr === "defer" || attr === "noModule")) { + el[attr] = !!props[p]; + } else { + el.setAttribute(attr, props[p]); + } + } + const { children , dangerouslySetInnerHTML } = props; + if (dangerouslySetInnerHTML) { + el.innerHTML = dangerouslySetInnerHTML.__html || ""; + } else if (children) { + el.textContent = typeof children === "string" ? children : Array.isArray(children) ? children.join("") : ""; + } + return el; +} +function isEqualNode(oldTag, newTag) { + if (oldTag instanceof HTMLElement && newTag instanceof HTMLElement) { + const nonce = newTag.getAttribute("nonce"); + // Only strip the nonce if `oldTag` has had it stripped. An element's nonce attribute will not + // be stripped if there is no content security policy response header that includes a nonce. + if (nonce && !oldTag.getAttribute("nonce")) { + const cloneTag = newTag.cloneNode(true); + cloneTag.setAttribute("nonce", ""); + cloneTag.nonce = nonce; + return nonce === oldTag.nonce && oldTag.isEqualNode(cloneTag); + } + } + return oldTag.isEqualNode(newTag); +} +function updateElements(type, components) { + const headEl = document.getElementsByTagName("head")[0]; + const headCountEl = headEl.querySelector("meta[name=next-head-count]"); + if (false) {} + const headCount = Number(headCountEl.content); + const oldTags = []; + for(let i = 0, j = headCountEl.previousElementSibling; i < headCount; i++, j = (j == null ? void 0 : j.previousElementSibling) || null){ + var ref; + if ((j == null ? void 0 : (ref = j.tagName) == null ? void 0 : ref.toLowerCase()) === type) { + oldTags.push(j); + } + } + const newTags = components.map(reactElementToDOM).filter((newTag)=>{ + for(let k = 0, len = oldTags.length; k < len; k++){ + const oldTag = oldTags[k]; + if (isEqualNode(oldTag, newTag)) { + oldTags.splice(k, 1); + return false; + } + } + return true; + }); + oldTags.forEach((t)=>{ + var ref; + return (ref = t.parentNode) == null ? void 0 : ref.removeChild(t); + }); + newTags.forEach((t)=>headEl.insertBefore(t, headCountEl)); + headCountEl.content = (headCount - oldTags.length + newTags.length).toString(); +} +if ((typeof exports.default === "function" || typeof exports.default === "object" && exports.default !== null) && typeof exports.default.__esModule === "undefined") { + Object.defineProperty(exports.default, "__esModule", { + value: true + }); + Object.assign(exports.default, exports); + module.exports = exports.default; +} //# sourceMappingURL=head-manager.js.map + + +/***/ }), + +/***/ 4534: +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +const _interopRequireWildcard = (__webpack_require__(1598)/* ["default"] */ .Z); +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.initialize = initialize; +exports.hydrate = hydrate; +exports.emitter = exports.router = exports.version = void 0; +var _async_to_generator = (__webpack_require__(932)/* ["default"] */ .Z); +var _extends = (__webpack_require__(6495)/* ["default"] */ .Z); +var _interop_require_default = (__webpack_require__(2648)/* ["default"] */ .Z); +var _interop_require_wildcard = (__webpack_require__(1598)/* ["default"] */ .Z); +__webpack_require__(37); +var _react = _interop_require_default(__webpack_require__(7294)); +var _client = _interop_require_default(__webpack_require__(745)); +var _headManagerContext = __webpack_require__(4664); +var _mitt = _interop_require_default(__webpack_require__(8550)); +var _routerContext = __webpack_require__(2692); +var _isDynamic = __webpack_require__(6238); +var _querystring = __webpack_require__(4919); +var _runtimeConfig = __webpack_require__(6949); +var _utils = __webpack_require__(670); +var _portal = __webpack_require__(7345); +var _headManager = _interop_require_default(__webpack_require__(1831)); +var _pageLoader = _interop_require_default(__webpack_require__(976)); +var _performanceRelayer = _interop_require_default(__webpack_require__(659)); +var _routeAnnouncer = __webpack_require__(8483); +var _router = __webpack_require__(880); +var _isError = __webpack_require__(676); +var _imageConfigContext = __webpack_require__(8730); +var _removeBasePath = __webpack_require__(2813); +var _hasBasePath = __webpack_require__(928); +var _appRouterContext = __webpack_require__(8245); +var _adapters = __webpack_require__(401); +var _hooksClientContext = __webpack_require__(8914); +var _noSsrError = __webpack_require__(2983); +const version = "13.0.7-canary.5"; +exports.version = version; +let router; +exports.router = router; +const emitter = (0, _mitt).default(); +exports.emitter = emitter; +const looseToArray = (input)=>[].slice.call(input); +let initialData; +let defaultLocale = undefined; +let asPath; +let pageLoader; +let appElement; +let headManager; +let initialMatchesMiddleware = false; +let lastAppProps; +let lastRenderReject; +let webpackHMR; +let CachedApp, onPerfEntry; +let CachedComponent; +self.__next_require__ = __webpack_require__; +class Container extends _react.default.Component { + componentDidCatch(componentErr, info) { + this.props.fn(componentErr, info); + } + componentDidMount() { + this.scrollToHash(); + // We need to replace the router state if: + // - the page was (auto) exported and has a query string or search (hash) + // - it was auto exported and is a dynamic route (to provide params) + // - if it is a client-side skeleton (fallback render) + // - if middleware matches the current page (may have rewrite params) + // - if rewrites in next.config.js match (may have rewrite params) + if (router.isSsr && (initialData.isFallback || initialData.nextExport && ((0, _isDynamic).isDynamicRoute(router.pathname) || location.search || false || initialMatchesMiddleware) || initialData.props && initialData.props.__N_SSG && (location.search || false || initialMatchesMiddleware))) { + // update query on mount for exported pages + router.replace(router.pathname + "?" + String((0, _querystring).assign((0, _querystring).urlQueryToSearchParams(router.query), new URLSearchParams(location.search))), asPath, { + // @ts-ignore + // WARNING: `_h` is an internal option for handing Next.js + // client-side hydration. Your app should _never_ use this property. + // It may change at any time without notice. + _h: 1, + // Fallback pages must trigger the data fetch, so the transition is + // not shallow. + // Other pages (strictly updating query) happens shallowly, as data + // requirements would already be present. + shallow: !initialData.isFallback && !initialMatchesMiddleware + }).catch((err)=>{ + if (!err.cancelled) throw err; + }); + } + } + componentDidUpdate() { + this.scrollToHash(); + } + scrollToHash() { + let { hash } = location; + hash = hash && hash.substring(1); + if (!hash) return; + const el = document.getElementById(hash); + if (!el) return; + // If we call scrollIntoView() in here without a setTimeout + // it won't scroll properly. + setTimeout(()=>el.scrollIntoView(), 0); + } + render() { + if (true) { + return this.props.children; + } else {} + } +} +function initialize() { + return _initialize.apply(this, arguments); +} +function _initialize() { + _initialize = _async_to_generator(function*() { + let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}; + // This makes sure this specific lines are removed in production + if (false) {} + initialData = JSON.parse(document.getElementById("__NEXT_DATA__").textContent); + window.__NEXT_DATA__ = initialData; + defaultLocale = initialData.defaultLocale; + const prefix = initialData.assetPrefix || ""; + // With dynamic assetPrefix it's no longer possible to set assetPrefix at the build time + // So, this is how we do it in the client side at runtime + __webpack_require__.p = "".concat(prefix, "/_next/") //eslint-disable-line + ; + // Initialize next/config with the environment configuration + (0, _runtimeConfig).setConfig({ + serverRuntimeConfig: {}, + publicRuntimeConfig: initialData.runtimeConfig || {} + }); + asPath = (0, _utils).getURL(); + // make sure not to attempt stripping basePath for 404s + if ((0, _hasBasePath).hasBasePath(asPath)) { + asPath = (0, _removeBasePath).removeBasePath(asPath); + } + if (false) {} + if (initialData.scriptLoader) { + const { initScriptLoader } = __webpack_require__(3573); + initScriptLoader(initialData.scriptLoader); + } + pageLoader = new _pageLoader.default(initialData.buildId, prefix); + const register = (param)=>{ + let [r, f] = param; + return pageLoader.routeLoader.onEntrypoint(r, f); + }; + if (window.__NEXT_P) { + // Defer page registration for another tick. This will increase the overall + // latency in hydrating the page, but reduce the total blocking time. + window.__NEXT_P.map((p)=>setTimeout(()=>register(p), 0)); + } + window.__NEXT_P = []; + window.__NEXT_P.push = register; + headManager = (0, _headManager).default(); + headManager.getIsSsr = ()=>{ + return router.isSsr; + }; + appElement = document.getElementById("__next"); + return { + assetPrefix: prefix + }; + }); + return _initialize.apply(this, arguments); +} +function renderApp(App, appProps) { + return /*#__PURE__*/ _react.default.createElement(App, Object.assign({}, appProps)); +} +function AppContainer(param) { + let { children } = param; + var _autoExport; + return /*#__PURE__*/ _react.default.createElement(Container, { + fn: (error)=>// eslint-disable-next-line @typescript-eslint/no-use-before-define + renderError({ + App: CachedApp, + err: error + }).catch((err)=>console.error("Error rendering page: ", err)) + }, /*#__PURE__*/ _react.default.createElement(_appRouterContext.AppRouterContext.Provider, { + value: (0, _adapters).adaptForAppRouterInstance(router) + }, /*#__PURE__*/ _react.default.createElement(_hooksClientContext.SearchParamsContext.Provider, { + value: (0, _adapters).adaptForSearchParams(router) + }, /*#__PURE__*/ _react.default.createElement(_adapters.PathnameContextProviderAdapter, { + router: router, + isAutoExport: (_autoExport = self.__NEXT_DATA__.autoExport) != null ? _autoExport : false + }, /*#__PURE__*/ _react.default.createElement(_routerContext.RouterContext.Provider, { + value: (0, _router).makePublicRouterInstance(router) + }, /*#__PURE__*/ _react.default.createElement(_headManagerContext.HeadManagerContext.Provider, { + value: headManager + }, /*#__PURE__*/ _react.default.createElement(_imageConfigContext.ImageConfigContext.Provider, { + value: {"deviceSizes":[640,750,828,1080,1200,1920,2048,3840],"imageSizes":[16,32,48,64,96,128,256,384],"path":"/_next/image","loader":"default","dangerouslyAllowSVG":false,"unoptimized":false} + }, children))))))); +} +const wrapApp = (App)=>(wrappedAppProps)=>{ + const appProps = _extends({}, wrappedAppProps, { + Component: CachedComponent, + err: initialData.err, + router + }); + return /*#__PURE__*/ _react.default.createElement(AppContainer, null, renderApp(App, appProps)); + }; +// This method handles all runtime and debug errors. +// 404 and 500 errors are special kind of errors +// and they are still handle via the main render method. +function renderError(renderErrorProps) { + let { App , err } = renderErrorProps; + // In development runtime errors are caught by our overlay + // In production we catch runtime errors using componentDidCatch which will trigger renderError + if (false) {} + // Make sure we log the error to the console, otherwise users can't track down issues. + console.error(err); + console.error("A client-side exception has occurred, see here for more info: https://nextjs.org/docs/messages/client-side-exception-occurred"); + return pageLoader.loadPage("/_error").then((param)=>{ + let { page: ErrorComponent , styleSheets } = param; + return (lastAppProps == null ? void 0 : lastAppProps.Component) === ErrorComponent ? Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(__webpack_require__(67))).then((errorModule)=>{ + return Promise.resolve().then(()=>/*#__PURE__*/ _interopRequireWildcard(__webpack_require__(4297))).then((appModule)=>{ + App = appModule.default; + renderErrorProps.App = App; + return errorModule; + }); + }).then((m)=>({ + ErrorComponent: m.default, + styleSheets: [] + })) : { + ErrorComponent, + styleSheets + }; + }).then((param)=>{ + let { ErrorComponent , styleSheets } = param; + var ref; + // In production we do a normal render with the `ErrorComponent` as component. + // If we've gotten here upon initial render, we can use the props from the server. + // Otherwise, we need to call `getInitialProps` on `App` before mounting. + const AppTree = wrapApp(App); + const appCtx = { + Component: ErrorComponent, + AppTree, + router, + ctx: { + err, + pathname: initialData.page, + query: initialData.query, + asPath, + AppTree + } + }; + return Promise.resolve(((ref = renderErrorProps.props) == null ? void 0 : ref.err) ? renderErrorProps.props : (0, _utils).loadGetInitialProps(App, appCtx)).then((initProps)=>// eslint-disable-next-line @typescript-eslint/no-use-before-define + doRender(_extends({}, renderErrorProps, { + err, + Component: ErrorComponent, + styleSheets, + props: initProps + }))); + }); +} +// Dummy component that we render as a child of Root so that we can +// toggle the correct styles before the page is rendered. +function Head(param) { + let { callback } = param; + // We use `useLayoutEffect` to guarantee the callback is executed + // as soon as React flushes the update. + _react.default.useLayoutEffect(()=>callback(), [ + callback + ]); + return null; +} +let reactRoot = null; +// On initial render a hydrate should always happen +let shouldHydrate = true; +function clearMarks() { + [ + "beforeRender", + "afterHydrate", + "afterRender", + "routeChange" + ].forEach((mark)=>performance.clearMarks(mark)); +} +function markHydrateComplete() { + if (!_utils.ST) return; + performance.mark("afterHydrate") // mark end of hydration + ; + performance.measure("Next.js-before-hydration", "navigationStart", "beforeRender"); + performance.measure("Next.js-hydration", "beforeRender", "afterHydrate"); + if (onPerfEntry) { + performance.getEntriesByName("Next.js-hydration").forEach(onPerfEntry); + } + clearMarks(); +} +function markRenderComplete() { + if (!_utils.ST) return; + performance.mark("afterRender") // mark end of render + ; + const navStartEntries = performance.getEntriesByName("routeChange", "mark"); + if (!navStartEntries.length) return; + performance.measure("Next.js-route-change-to-render", navStartEntries[0].name, "beforeRender"); + performance.measure("Next.js-render", "beforeRender", "afterRender"); + if (onPerfEntry) { + performance.getEntriesByName("Next.js-render").forEach(onPerfEntry); + performance.getEntriesByName("Next.js-route-change-to-render").forEach(onPerfEntry); + } + clearMarks(); + [ + "Next.js-route-change-to-render", + "Next.js-render" + ].forEach((measure)=>performance.clearMeasures(measure)); +} +function renderReactElement(domEl, fn) { + // mark start of hydrate/render + if (_utils.ST) { + performance.mark("beforeRender"); + } + const reactEl = fn(shouldHydrate ? markHydrateComplete : markRenderComplete); + if (!reactRoot) { + // Unlike with createRoot, you don't need a separate root.render() call here + reactRoot = _client.default.hydrateRoot(domEl, reactEl, { + onRecoverableError (err) { + // Skip certain custom errors which are not expected to throw on client + if (err.message === _noSsrError.NEXT_DYNAMIC_NO_SSR_CODE) return; + throw err; + } + }); + // TODO: Remove shouldHydrate variable when React 18 is stable as it can depend on `reactRoot` existing + shouldHydrate = false; + } else { + const startTransition = _react.default.startTransition; + startTransition(()=>{ + reactRoot.render(reactEl); + }); + } +} +function Root(param) { + let { callbacks , children } = param; + // We use `useLayoutEffect` to guarantee the callbacks are executed + // as soon as React flushes the update + _react.default.useLayoutEffect(()=>callbacks.forEach((callback)=>callback()), [ + callbacks + ]); + // We should ask to measure the Web Vitals after rendering completes so we + // don't cause any hydration delay: + _react.default.useEffect(()=>{ + (0, _performanceRelayer).default(onPerfEntry); + }, []); + if (false) {} + return children; +} +function doRender(input) { + let { App , Component , props , err } = input; + let styleSheets = "initial" in input ? undefined : input.styleSheets; + Component = Component || lastAppProps.Component; + props = props || lastAppProps.props; + const appProps = _extends({}, props, { + Component, + err, + router + }); + // lastAppProps has to be set before ReactDom.render to account for ReactDom throwing an error. + lastAppProps = appProps; + let canceled = false; + let resolvePromise; + const renderPromise = new Promise((resolve, reject)=>{ + if (lastRenderReject) { + lastRenderReject(); + } + resolvePromise = ()=>{ + lastRenderReject = null; + resolve(); + }; + lastRenderReject = ()=>{ + canceled = true; + lastRenderReject = null; + const error = new Error("Cancel rendering route"); + error.cancelled = true; + reject(error); + }; + }); + // This function has a return type to ensure it doesn't start returning a + // Promise. It should remain synchronous. + function onStart() { + if (!styleSheets || // We use `style-loader` in development, so we don't need to do anything + // unless we're in production: + "production" !== "production") { + return false; + } + const currentStyleTags = looseToArray(document.querySelectorAll("style[data-n-href]")); + const currentHrefs = new Set(currentStyleTags.map((tag)=>tag.getAttribute("data-n-href"))); + const noscript = document.querySelector("noscript[data-n-css]"); + const nonce = noscript == null ? void 0 : noscript.getAttribute("data-n-css"); + styleSheets.forEach((param)=>{ + let { href , text } = param; + if (!currentHrefs.has(href)) { + const styleTag = document.createElement("style"); + styleTag.setAttribute("data-n-href", href); + styleTag.setAttribute("media", "x"); + if (nonce) { + styleTag.setAttribute("nonce", nonce); + } + document.head.appendChild(styleTag); + styleTag.appendChild(document.createTextNode(text)); + } + }); + return true; + } + function onHeadCommit() { + if (// unless we're in production: + true && // We can skip this during hydration. Running it wont cause any harm, but + // we may as well save the CPU cycles: + styleSheets && // Ensure this render was not canceled + !canceled) { + const desiredHrefs = new Set(styleSheets.map((s)=>s.href)); + const currentStyleTags = looseToArray(document.querySelectorAll("style[data-n-href]")); + const currentHrefs = currentStyleTags.map((tag)=>tag.getAttribute("data-n-href")); + // Toggle `