@hrforte/react-pivottable 1.0.1 → 2.0.0

package/dist/pivot-worker.js

@@ -0,0 +1,3387 @@
+/******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, {
+/******/ 				configurable: false,
+/******/ 				enumerable: true,
+/******/ 				get: getter
+/******/ 			});
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 4);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+module.exports = ReactPropTypesSecret;
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = __webpack_require__(8);
+} else {
+  module.exports = __webpack_require__(9);
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports) {
+
+module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+
+
+/***/ }),
+/* 4 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__pivotCompute__ = __webpack_require__(5);
+/* eslint-disable valid-jsdoc */
+/*
+ * Web Worker entry point for off-main-thread pivot computation.
+ *
+ * Message protocol (plain, structured-cloneable objects):
+ *   main -> worker   {type: 'pivot:setData',  id, dataKey, data}
+ *   main -> worker   {type: 'pivot:compute',  id, dataKey, config}
+ *   worker -> main   {type: 'pivot:progress', id, processed, total, phase}
+ *   worker -> main   {type: 'pivot:result',   id, result}
+ *   worker -> main   {type: 'pivot:error',    id, message}
+ *
+ * The materialized dataset is cached per dataKey, so repeated computations on
+ * the same data (e.g. dragging fields around) do not pay the cost of
+ * re-scanning the raw records.
+ */
+
+
+var MAX_CACHED_DATASETS = 4;
+
+var datasetCache = new Map();
+
+var cacheDataset = function cacheDataset(dataKey, dataset) {
+  datasetCache.delete(dataKey);
+  datasetCache.set(dataKey, dataset);
+  while (datasetCache.size > MAX_CACHED_DATASETS) {
+    var oldestKey = datasetCache.keys().next().value;
+    datasetCache.delete(oldestKey);
+  }
+  return dataset;
+};
+
+var postToMain = function postToMain(message) {
+  self.postMessage(message);
+};
+
+var toErrorMessage = function toErrorMessage(error) {
+  return String(error && error.message || error);
+};
+
+self.addEventListener('message', function (event) {
+  var message = event.data || {};
+
+  if (message.type === 'pivot:setData') {
+    try {
+      cacheDataset(message.dataKey, Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["b" /* materializeData */])(message.data, {}, function (processed, total) {
+        postToMain({
+          type: 'pivot:progress',
+          id: message.id,
+          processed: processed,
+          total: total,
+          phase: 'materialize'
+        });
+      }));
+    } catch (error) {
+      postToMain({
+        type: 'pivot:error',
+        id: message.id,
+        message: toErrorMessage(error)
+      });
+    }
+    return;
+  }
+
+  if (message.type === 'pivot:compute') {
+    try {
+      var dataset = datasetCache.get(message.dataKey);
+      if (!dataset) {
+        throw new Error('no dataset staged for key ' + message.dataKey);
+      }
+      var result = Object(__WEBPACK_IMPORTED_MODULE_0__pivotCompute__["a" /* computePivotState */])(dataset, message.config, function (processed, total, phase) {
+        postToMain({
+          type: 'pivot:progress',
+          id: message.id,
+          processed: processed,
+          total: total,
+          phase: phase
+        });
+      });
+      postToMain({ type: 'pivot:result', id: message.id, result: result });
+    } catch (error) {
+      postToMain({
+        type: 'pivot:error',
+        id: message.id,
+        message: toErrorMessage(error)
+      });
+    }
+  }
+});
+
+/***/ }),
+/* 5 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* unused harmony export PROGRESS_BATCH_SIZE */
+/* unused harmony export DEFAULT_WORKER_THRESHOLD */
+/* unused harmony export WORKER_DEBOUNCE_MS */
+/* harmony export (immutable) */ __webpack_exports__["b"] = materializeData;
+/* harmony export (immutable) */ __webpack_exports__["a"] = computePivotState;
+/* unused harmony export serializePivotData */
+/* unused harmony export sortersHaveFunctions */
+/* unused harmony export sanitizeSorters */
+/* unused harmony export createWorkerConfig */
+/* unused harmony export createComputeSignature */
+/* unused harmony export canComputeInWorker */
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__Utilities__ = __webpack_require__(6);
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+/* eslint-disable valid-jsdoc */
+/*
+ * Shared pivot-computation logic.
+ *
+ * This module contains the pure, DOM-free parts of the pivot computation so
+ * that the exact same code paths can run:
+ *   - on the main thread (classic synchronous rendering path), and
+ *   - inside a Web Worker (src/pivotWorker.js) for large datasets.
+ *
+ * It must stay free of React and of any `window`/`document` references.
+ */
+
+
+// A progress callback fires every N processed records so the UI can render
+// progress without adding measurable overhead to the per-record loop.
+var PROGRESS_BATCH_SIZE = 20000;
+
+// Datasets smaller than this are computed synchronously on the main thread;
+// larger ones are handed off to the Web Worker.
+var DEFAULT_WORKER_THRESHOLD = 10000;
+
+// Trailing debounce before a worker computation is dispatched, so rapid
+// interactions do not queue one full computation per single change.
+var WORKER_DEBOUNCE_MS = 200;
+
+/*
+ * Walks the raw input once and computes the attribute-value inventory plus a
+ * "materialized" copy of the records (with derived attributes applied).
+ * This is an exact extraction of the historical PivotTableUI behavior.
+ *
+ * onProgress receives (processed, total, phase); total is null when it is
+ * unknown upfront (function-based data sources).
+ */
+function materializeData(data, derivedAttributes, onProgress) {
+  var attrValues = {};
+  var materializedInput = [];
+  var total = Array.isArray(data) ? data.length : null;
+  var recordsProcessed = 0;
+  __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */].forEachRecord(data, derivedAttributes || {}, function (record) {
+    materializedInput.push(record);
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = Object.keys(record)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var attr = _step.value;
+
+        if (!(attr in attrValues)) {
+          attrValues[attr] = {};
+          if (recordsProcessed > 0) {
+            attrValues[attr].null = recordsProcessed;
+          }
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    for (var _attr in attrValues) {
+      var value = _attr in record ? record[_attr] : 'null';
+      if (!(value in attrValues[_attr])) {
+        attrValues[_attr][value] = 0;
+      }
+      attrValues[_attr][value]++;
+    }
+    recordsProcessed++;
+    if (onProgress && recordsProcessed % PROGRESS_BATCH_SIZE === 0) {
+      onProgress(recordsProcessed, total, 'materialize');
+    }
+  });
+  return { attrValues: attrValues, materializedInput: materializedInput, totalRecords: recordsProcessed };
+}
+
+/*
+ * Aggregates an already-materialized dataset into a PivotData instance and
+ * serializes the result into a plain (structured-cloneable) object that can
+ * cross the worker boundary and later hydrate PivotData on the main thread.
+ */
+function computePivotState(materialized, config, onProgress) {
+  var total = materialized.totalRecords;
+  var pivotData = new __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */](Object.assign({}, config, {
+    data: materialized.materializedInput,
+    derivedAttributes: {},
+    onRecordProcessed: function onRecordProcessed(processed) {
+      if (onProgress) {
+        onProgress(processed, total, 'aggregate');
+      }
+    }
+  }));
+  // Force key sorting to happen while we are (possibly) inside the worker.
+  pivotData.getRowKeys();
+  pivotData.getColKeys();
+  return serializePivotData(pivotData, materialized);
+}
+
+/*
+ * Serializes a fully-built PivotData instance into plain data. Only the final
+ * aggregated value of every cell is kept; `value()` and `format()` behavior
+ * are reconstructed on the main thread by the PivotData hydration step.
+ */
+function serializePivotData(pivotData, materialized) {
+  var serializeCell = function serializeCell(cell) {
+    var values = {};
+    pivotData.aggregations.forEach(function (agg) {
+      var instance = cell.getInstance(agg.key);
+      if (instance) {
+        values[agg.key] = instance.value();
+      }
+    });
+    return { values: values };
+  };
+
+  var tree = {};
+  Object.keys(pivotData.tree).forEach(function (flatRowKey) {
+    var rowBranch = pivotData.tree[flatRowKey];
+    var serializedRow = {};
+    Object.keys(rowBranch).forEach(function (flatColKey) {
+      serializedRow[flatColKey] = serializeCell(rowBranch[flatColKey]);
+    });
+    tree[flatRowKey] = serializedRow;
+  });
+
+  var serializeTotals = function serializeTotals(totals) {
+    var serialized = {};
+    Object.keys(totals).forEach(function (flatKey) {
+      serialized[flatKey] = serializeCell(totals[flatKey]);
+    });
+    return serialized;
+  };
+
+  return {
+    rowKeys: pivotData.rowKeys.map(function (key) {
+      return key.slice();
+    }),
+    colKeys: pivotData.colKeys.map(function (key) {
+      return key.slice();
+    }),
+    tree: tree,
+    rowTotals: serializeTotals(pivotData.rowTotals),
+    colTotals: serializeTotals(pivotData.colTotals),
+    allTotal: serializeCell(pivotData.allTotal),
+    aggregations: pivotData.aggregations.map(function (agg) {
+      return Object.assign({}, agg);
+    }),
+    attrValues: materialized.attrValues,
+    materializedInput: materialized.materializedInput,
+    totalRecords: materialized.totalRecords
+  };
+}
+
+/*
+ * Sorters containing functions cannot be structured-cloned into a worker.
+ * Returns true when the sorters prop itself, or any of its entries, is a
+ * function. In that case PivotData re-sorts on the main thread after
+ * hydration (distinct keys are few, so this stays cheap).
+ */
+function sortersHaveFunctions(sorters) {
+  if (typeof sorters === 'function') {
+    return true;
+  }
+  if (!sorters || (typeof sorters === 'undefined' ? 'undefined' : _typeof(sorters)) !== 'object') {
+    return false;
+  }
+  return Object.keys(sorters).some(function (attr) {
+    return typeof sorters[attr] === 'function';
+  });
+}
+
+/*
+ * Returns a structured-cloneable subset of the sorters prop: data-type names
+ * and sample-value arrays survive the worker boundary, functions do not.
+ */
+function sanitizeSorters(sorters) {
+  if (!sorters || (typeof sorters === 'undefined' ? 'undefined' : _typeof(sorters)) !== 'object' || typeof sorters === 'function') {
+    return {};
+  }
+  var clean = {};
+  Object.keys(sorters).forEach(function (attr) {
+    var sorter = sorters[attr];
+    if (typeof sorter === 'string' || Array.isArray(sorter)) {
+      clean[attr] = sorter;
+    }
+  });
+  return clean;
+}
+
+/*
+ * Extracts exactly the props PivotData needs to compute results, with
+ * everything non-serializable stripped, so the object can be posted to the
+ * worker and fed straight into PivotData.
+ */
+function createWorkerConfig(props) {
+  return {
+    rows: props.rows,
+    cols: props.cols,
+    aggregatorName: props.aggregatorName,
+    aggregations: props.aggregations,
+    vals: props.vals,
+    valueFilter: props.valueFilter,
+    sorters: sanitizeSorters(props.sorters),
+    rowOrder: props.rowOrder,
+    colOrder: props.colOrder,
+    rowSorts: props.rowSorts,
+    colSorts: props.colSorts
+  };
+}
+
+/*
+ * Stable string signature of everything that influences a worker computation.
+ * Data identity is NOT part of it; callers append their own data version.
+ */
+function createComputeSignature(props) {
+  return JSON.stringify(createWorkerConfig(props));
+}
+
+/*
+ * Decides whether the current props can be computed inside the Web Worker.
+ * Anything that cannot be structured-cloned (function data sources, custom
+ * derivedAttributes, custom aggregator maps) forces the classic path.
+ * Function-based sorters are allowed: they are re-applied on the main thread.
+ */
+function canComputeInWorker(props) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (options.enabled === false) {
+    return false;
+  }
+  if (typeof Worker === 'undefined') {
+    return false;
+  }
+  var threshold = typeof options.threshold === 'number' ? options.threshold : DEFAULT_WORKER_THRESHOLD;
+  var data = props.data;
+  if (!Array.isArray(data) || data.length < threshold) {
+    return false;
+  }
+  if (props.derivedAttributes && Object.keys(props.derivedAttributes).length > 0) {
+    return false;
+  }
+  if (props.aggregators !== __WEBPACK_IMPORTED_MODULE_0__Utilities__["a" /* PivotData */].defaultProps.aggregators) {
+    return false;
+  }
+  return true;
+}
+
+/***/ }),
+/* 6 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* unused harmony export aggregatorTemplates */
+/* unused harmony export aggregators */
+/* unused harmony export derivers */
+/* unused harmony export locales */
+/* unused harmony export naturalSort */
+/* unused harmony export numberFormat */
+/* unused harmony export getSort */
+/* unused harmony export sortAs */
+/* unused harmony export builtInSorters */
+/* unused harmony export detectDataType */
+/* unused harmony export createSorterByType */
+/* unused harmony export sortersHaveFunctions */
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return PivotData; });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types__ = __webpack_require__(7);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_prop_types__);
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+/* eslint-disable no-undefined */
+
+
+/*
+ * decaffeinate suggestions:
+ * DS101: Remove unnecessary use of Array.from
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS104: Avoid inline assignments
+ * DS201: Simplify complex destructure assignments
+ * DS203: Remove `|| {}` from converted for-own loops
+ * DS205: Consider reworking code to avoid use of IIFEs
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
+ */
+
+var addSeparators = function addSeparators(nStr, thousandsSep, decimalSep) {
+  var x = String(nStr).split('.');
+  var x1 = x[0];
+  var x2 = x.length > 1 ? decimalSep + x[1] : '';
+  var rgx = /(\d+)(\d{3})/;
+  while (rgx.test(x1)) {
+    x1 = x1.replace(rgx, '$1' + thousandsSep + '$2');
+  }
+  return x1 + x2;
+};
+
+var numberFormat = function numberFormat(opts_in) {
+  var defaults = {
+    digitsAfterDecimal: 2,
+    scaler: 1,
+    thousandsSep: ',',
+    decimalSep: '.',
+    prefix: '',
+    suffix: '',
+    showOriginal: false
+  };
+  var opts = Object.assign({}, defaults, opts_in);
+  return function (x) {
+    if (isNaN(x) || !isFinite(x)) {
+      return '';
+    }
+    // Show completely original value if showOriginal is true
+    if (opts.showOriginal) {
+      return String(opts.scaler * x);
+    }
+    // When thousandsSep is empty, apply decimal formatting but skip thousand separator
+    if (opts.thousandsSep === '') {
+      var scaledValue = opts.scaler * x;
+      var fixedValue = scaledValue.toFixed(opts.digitsAfterDecimal);
+      // Apply decimal separator if needed
+      var _result = fixedValue.replace('.', opts.decimalSep);
+      return '' + opts.prefix + _result + opts.suffix;
+    }
+    // Normal formatting with thousand separator
+    var result = addSeparators((opts.scaler * x).toFixed(opts.digitsAfterDecimal), opts.thousandsSep, opts.decimalSep);
+    return '' + opts.prefix + result + opts.suffix;
+  };
+};
+
+var rx = /(\d+)|(\D+)/g;
+var rd = /\d/;
+var rz = /^0/;
+var naturalSort = function naturalSort(as, bs) {
+  // nulls first
+  if (bs !== null && as === null) {
+    return -1;
+  }
+  if (as !== null && bs === null) {
+    return 1;
+  }
+
+  // then raw NaNs
+  if (typeof as === 'number' && isNaN(as)) {
+    return -1;
+  }
+  if (typeof bs === 'number' && isNaN(bs)) {
+    return 1;
+  }
+
+  // numbers and numbery strings group together
+  var nas = Number(as);
+  var nbs = Number(bs);
+  if (nas < nbs) {
+    return -1;
+  }
+  if (nas > nbs) {
+    return 1;
+  }
+
+  // within that, true numbers before numbery strings
+  if (typeof as === 'number' && typeof bs !== 'number') {
+    return -1;
+  }
+  if (typeof bs === 'number' && typeof as !== 'number') {
+    return 1;
+  }
+  if (typeof as === 'number' && typeof bs === 'number') {
+    return 0;
+  }
+
+  // 'Infinity' is a textual number, so less than 'A'
+  if (isNaN(nbs) && !isNaN(nas)) {
+    return -1;
+  }
+  if (isNaN(nas) && !isNaN(nbs)) {
+    return 1;
+  }
+
+  // finally, "smart" string sorting per http://stackoverflow.com/a/4373421/112871
+  var a = String(as);
+  var b = String(bs);
+  if (a === b) {
+    return 0;
+  }
+  if (!rd.test(a) || !rd.test(b)) {
+    return a > b ? 1 : -1;
+  }
+
+  // special treatment for strings containing digits
+  a = a.match(rx);
+  b = b.match(rx);
+  while (a.length && b.length) {
+    var a1 = a.shift();
+    var b1 = b.shift();
+    if (a1 !== b1) {
+      if (rd.test(a1) && rd.test(b1)) {
+        return a1.replace(rz, '.0') - b1.replace(rz, '.0');
+      }
+      return a1 > b1 ? 1 : -1;
+    }
+  }
+  return a.length - b.length;
+};
+
+var sortAs = function sortAs(order) {
+  var mapping = {};
+
+  // sort lowercased keys similarly
+  var l_mapping = {};
+  for (var i in order) {
+    var x = order[i];
+    mapping[x] = i;
+    if (typeof x === 'string') {
+      l_mapping[x.toLowerCase()] = i;
+    }
+  }
+  return function (a, b) {
+    if (a in mapping && b in mapping) {
+      return mapping[a] - mapping[b];
+    } else if (a in mapping) {
+      return -1;
+    } else if (b in mapping) {
+      return 1;
+    } else if (a in l_mapping && b in l_mapping) {
+      return l_mapping[a] - l_mapping[b];
+    } else if (a in l_mapping) {
+      return -1;
+    } else if (b in l_mapping) {
+      return 1;
+    }
+    return naturalSort(a, b);
+  };
+};
+
+// Built-in sort functions for different data types
+var builtInSorters = {
+  // Number sorter - handles numeric values
+  number: function number(a, b) {
+    if (a === null || a === undefined || a === '') {
+      return b === null || b === undefined || b === '' ? 0 : -1;
+    }
+    if (b === null || b === undefined || b === '') {
+      return 1;
+    }
+    var numA = typeof a === 'number' ? a : parseFloat(a);
+    var numB = typeof b === 'number' ? b : parseFloat(b);
+    if (isNaN(numA) && isNaN(numB)) {
+      return 0;
+    }
+    if (isNaN(numA)) {
+      return -1;
+    }
+    if (isNaN(numB)) {
+      return 1;
+    }
+    return numA - numB;
+  },
+
+  // Date sorter - handles date values
+  date: function date(a, b) {
+    if (a === null || a === undefined || a === '') {
+      return b === null || b === undefined || b === '' ? 0 : -1;
+    }
+    if (b === null || b === undefined || b === '') {
+      return 1;
+    }
+    var dateA = a instanceof Date ? a : new Date(a);
+    var dateB = b instanceof Date ? b : new Date(b);
+    if (isNaN(dateA.getTime()) && isNaN(dateB.getTime())) {
+      return 0;
+    }
+    if (isNaN(dateA.getTime())) {
+      return -1;
+    }
+    if (isNaN(dateB.getTime())) {
+      return 1;
+    }
+    return dateA.getTime() - dateB.getTime();
+  },
+
+  // String sorter - case-sensitive
+  string: function string(a, b) {
+    if (a === null || a === undefined || a === '') {
+      return b === null || b === undefined || b === '' ? 0 : -1;
+    }
+    if (b === null || b === undefined || b === '') {
+      return 1;
+    }
+    var strA = String(a);
+    var strB = String(b);
+    return strA > strB ? 1 : strA < strB ? -1 : 0;
+  },
+
+  // String sorter - case-insensitive
+  stringCaseInsensitive: function stringCaseInsensitive(a, b) {
+    if (a === null || a === undefined || a === '') {
+      return b === null || b === undefined || b === '' ? 0 : -1;
+    }
+    if (b === null || b === undefined || b === '') {
+      return 1;
+    }
+    var strA = String(a).toLowerCase();
+    var strB = String(b).toLowerCase();
+    return strA > strB ? 1 : strA < strB ? -1 : 0;
+  },
+
+  // Natural sort (default)
+  natural: naturalSort
+};
+
+// Alias for backward compatibility
+// const sorters = builtInSorters;
+
+// Auto-detect data type from sample values
+var detectDataType = function detectDataType(values) {
+  if (!values || values.length === 0) {
+    return 'natural';
+  }
+
+  var sampleSize = Math.min(10, values.length);
+  var samples = values.slice(0, sampleSize);
+
+  var numberCount = 0;
+  var dateCount = 0;
+  var stringCount = 0;
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = samples[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var val = _step.value;
+
+      if (val === null || val === undefined || val === '') {
+        continue;
+      }
+
+      // Check if it's a number
+      if (typeof val === 'number' || !isNaN(parseFloat(val)) && isFinite(val)) {
+        numberCount++;
+      }
+      // Check if it's a date
+      else if (val instanceof Date || !isNaN(Date.parse(val)) && String(val).match(/^\d{4}-\d{2}-\d{2}/)) {
+          dateCount++;
+        }
+        // Otherwise it's a string
+        else {
+            stringCount++;
+          }
+    }
+
+    // Determine the most common type
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  if (numberCount > dateCount && numberCount > stringCount) {
+    return 'number';
+  } else if (dateCount > stringCount) {
+    return 'date';
+  } else if (stringCount > 0) {
+    return 'string';
+  }
+
+  return 'natural';
+};
+
+// Create a sorter based on data type
+var createSorterByType = function createSorterByType(dataType) {
+  if (typeof dataType === 'function') {
+    return dataType;
+  }
+
+  if (typeof dataType === 'string' && dataType in builtInSorters) {
+    return builtInSorters[dataType];
+  }
+
+  // Auto-detect if dataType is an array of values
+  if (Array.isArray(dataType)) {
+    var detectedType = detectDataType(dataType);
+    return builtInSorters[detectedType] || naturalSort;
+  }
+
+  return naturalSort;
+};
+
+// Get sorter for an attribute, with auto-detection support
+var getSort = function getSort(sorters, attr) {
+  var attrValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+  if (sorters) {
+    if (typeof sorters === 'function') {
+      var sort = sorters(attr);
+      if (typeof sort === 'function') {
+        return sort;
+      }
+    } else if (attr in sorters) {
+      var sorter = sorters[attr];
+      // If it's a string (data type name) or array (sample values), create appropriate sorter
+      if (typeof sorter === 'string' || Array.isArray(sorter)) {
+        return createSorterByType(sorter);
+      }
+      // If it's already a function, use it
+      if (typeof sorter === 'function') {
+        return sorter;
+      }
+    }
+  }
+
+  // Auto-detect if attrValues are provided
+  if (attrValues && (typeof attrValues === 'undefined' ? 'undefined' : _typeof(attrValues)) === 'object') {
+    var values = Object.keys(attrValues);
+    if (values.length > 0) {
+      var detectedType = detectDataType(values);
+      return builtInSorters[detectedType] || naturalSort;
+    }
+  }
+
+  return naturalSort;
+};
+
+// aggregator templates default to US number formatting but this is overrideable
+var usFmt = numberFormat();
+var usFmtInt = numberFormat({ digitsAfterDecimal: 0 });
+var usFmtPct = numberFormat({
+  digitsAfterDecimal: 1,
+  scaler: 100,
+  suffix: '%'
+});
+
+// Emit a progress callback every N processed records without adding
+// measurable overhead to the per-record loop.
+var RECORD_PROGRESS_BATCH_SIZE = 25000;
+
+// Returns true when the sorters prop itself, or any of its entries, is a
+// function. Function-based sorters cannot be transferred to a Web Worker, so
+// PivotData re-applies them on the main thread after worker hydration.
+var sortersHaveFunctions = function sortersHaveFunctions(sorters) {
+  if (typeof sorters === 'function') {
+    return true;
+  }
+  if (!sorters || (typeof sorters === 'undefined' ? 'undefined' : _typeof(sorters)) !== 'object') {
+    return false;
+  }
+  return Object.keys(sorters).some(function (attr) {
+    return typeof sorters[attr] === 'function';
+  });
+};
+
+var aggregatorTemplates = {
+  count: function count() {
+    var formatter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : usFmtInt;
+
+    return function () {
+      return function () {
+        return {
+          count: 0,
+          push: function push() {
+            this.count++;
+          },
+          value: function value() {
+            return this.count;
+          },
+
+          format: formatter
+        };
+      };
+    };
+  },
+  uniques: function uniques(fn) {
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : usFmtInt;
+
+    return function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 1),
+          attr = _ref2[0];
+
+      return function () {
+        return {
+          uniq: [],
+          push: function push(record) {
+            if (!Array.from(this.uniq).includes(record[attr])) {
+              this.uniq.push(record[attr]);
+            }
+          },
+          value: function value() {
+            return fn(this.uniq);
+          },
+
+          format: formatter,
+          numInputs: typeof attr !== 'undefined' ? 0 : 1
+        };
+      };
+    };
+  },
+  sum: function sum() {
+    var formatter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : usFmt;
+
+    return function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 1),
+          attr = _ref4[0];
+
+      return function () {
+        return {
+          sum: 0,
+          push: function push(record) {
+            if (!isNaN(parseFloat(record[attr]))) {
+              this.sum += parseFloat(record[attr]);
+            }
+          },
+          value: function value() {
+            return this.sum;
+          },
+
+          format: formatter,
+          numInputs: typeof attr !== 'undefined' ? 0 : 1
+        };
+      };
+    };
+  },
+  extremes: function extremes(mode) {
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : usFmt;
+
+    return function (_ref5) {
+      var _ref6 = _slicedToArray(_ref5, 1),
+          attr = _ref6[0];
+
+      return function (data) {
+        return {
+          val: null,
+          sorter: getSort(typeof data !== 'undefined' ? data.sorters : null, attr),
+          push: function push(record) {
+            var x = record[attr];
+            if (['min', 'max'].includes(mode)) {
+              x = parseFloat(x);
+              if (!isNaN(x)) {
+                this.val = Math[mode](x, this.val !== null ? this.val : x);
+              }
+            }
+            if (mode === 'first' && this.sorter(x, this.val !== null ? this.val : x) <= 0) {
+              this.val = x;
+            }
+            if (mode === 'last' && this.sorter(x, this.val !== null ? this.val : x) >= 0) {
+              this.val = x;
+            }
+          },
+          value: function value() {
+            return this.val;
+          },
+          format: function format(x) {
+            if (isNaN(x)) {
+              return x;
+            }
+            return formatter(x);
+          },
+
+          numInputs: typeof attr !== 'undefined' ? 0 : 1
+        };
+      };
+    };
+  },
+  quantile: function quantile(q) {
+    var formatter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : usFmt;
+
+    return function (_ref7) {
+      var _ref8 = _slicedToArray(_ref7, 1),
+          attr = _ref8[0];
+
+      return function () {
+        return {
+          vals: [],
+          push: function push(record) {
+            var x = parseFloat(record[attr]);
+            if (!isNaN(x)) {
+              this.vals.push(x);
+            }
+          },
+          value: function value() {
+            if (this.vals.length === 0) {
+              return null;
+            }
+            this.vals.sort(function (a, b) {
+              return a - b;
+            });
+            var i = (this.vals.length - 1) * q;
+            return (this.vals[Math.floor(i)] + this.vals[Math.ceil(i)]) / 2.0;
+          },
+
+          format: formatter,
+          numInputs: typeof attr !== 'undefined' ? 0 : 1
+        };
+      };
+    };
+  },
+  runningStat: function runningStat() {
+    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'mean';
+    var ddof = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+    var formatter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : usFmt;
+
+    return function (_ref9) {
+      var _ref10 = _slicedToArray(_ref9, 1),
+          attr = _ref10[0];
+
+      return function () {
+        return {
+          n: 0.0,
+          m: 0.0,
+          s: 0.0,
+          push: function push(record) {
+            var x = parseFloat(record[attr]);
+            if (isNaN(x)) {
+              return;
+            }
+            this.n += 1.0;
+            if (this.n === 1.0) {
+              this.m = x;
+            }
+            var m_new = this.m + (x - this.m) / this.n;
+            this.s = this.s + (x - this.m) * (x - m_new);
+            this.m = m_new;
+          },
+          value: function value() {
+            if (mode === 'mean') {
+              if (this.n === 0) {
+                return 0 / 0;
+              }
+              return this.m;
+            }
+            if (this.n <= ddof) {
+              return 0;
+            }
+            switch (mode) {
+              case 'var':
+                return this.s / (this.n - ddof);
+              case 'stdev':
+                return Math.sqrt(this.s / (this.n - ddof));
+              default:
+                throw new Error('unknown mode for runningStat');
+            }
+          },
+
+          format: formatter,
+          numInputs: typeof attr !== 'undefined' ? 0 : 1
+        };
+      };
+    };
+  },
+  sumOverSum: function sumOverSum() {
+    var formatter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : usFmt;
+
+    return function (_ref11) {
+      var _ref12 = _slicedToArray(_ref11, 2),
+          num = _ref12[0],
+          denom = _ref12[1];
+
+      return function () {
+        return {
+          sumNum: 0,
+          sumDenom: 0,
+          push: function push(record) {
+            if (!isNaN(parseFloat(record[num]))) {
+              this.sumNum += parseFloat(record[num]);
+            }
+            if (!isNaN(parseFloat(record[denom]))) {
+              this.sumDenom += parseFloat(record[denom]);
+            }
+          },
+          value: function value() {
+            return this.sumNum / this.sumDenom;
+          },
+
+          format: formatter,
+          numInputs: typeof num !== 'undefined' && typeof denom !== 'undefined' ? 0 : 2
+        };
+      };
+    };
+  },
+  fractionOf: function fractionOf(wrapped) {
+    var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'total';
+    var formatter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : usFmtPct;
+
+    return function () {
+      for (var _len = arguments.length, x = Array(_len), _key = 0; _key < _len; _key++) {
+        x[_key] = arguments[_key];
+      }
+
+      return function (data, rowKey, colKey) {
+        return {
+          selector: { total: [[], []], row: [rowKey, []], col: [[], colKey] }[type],
+          inner: wrapped.apply(undefined, _toConsumableArray(Array.from(x || [])))(data, rowKey, colKey),
+          push: function push(record) {
+            this.inner.push(record);
+          },
+
+          format: formatter,
+          value: function value() {
+            var aggregator = data.getAggregator.apply(data, _toConsumableArray(Array.from(this.selector || [])));
+
+            return this.inner.value() / (aggregator.inner && aggregator.inner.value() || 0);
+          },
+
+          numInputs: wrapped.apply(undefined, _toConsumableArray(Array.from(x || [])))().numInputs
+        };
+      };
+    };
+  }
+};
+
+aggregatorTemplates.countUnique = function (f) {
+  return aggregatorTemplates.uniques(function (x) {
+    return x.length;
+  }, f);
+};
+aggregatorTemplates.listUnique = function (s) {
+  return aggregatorTemplates.uniques(function (x) {
+    return x.join(s);
+  }, function (x) {
+    return x;
+  });
+};
+aggregatorTemplates.max = function (f) {
+  return aggregatorTemplates.extremes('max', f);
+};
+aggregatorTemplates.min = function (f) {
+  return aggregatorTemplates.extremes('min', f);
+};
+aggregatorTemplates.first = function (f) {
+  return aggregatorTemplates.extremes('first', f);
+};
+aggregatorTemplates.last = function (f) {
+  return aggregatorTemplates.extremes('last', f);
+};
+aggregatorTemplates.median = function (f) {
+  return aggregatorTemplates.quantile(0.5, f);
+};
+aggregatorTemplates.average = function (f) {
+  return aggregatorTemplates.runningStat('mean', 1, f);
+};
+aggregatorTemplates.var = function (ddof, f) {
+  return aggregatorTemplates.runningStat('var', ddof, f);
+};
+aggregatorTemplates.stdev = function (ddof, f) {
+  return aggregatorTemplates.runningStat('stdev', ddof, f);
+};
+
+var AggregatorCell = function () {
+  function AggregatorCell(instances, primaryKey) {
+    _classCallCheck(this, AggregatorCell);
+
+    this.instances = instances;
+    this.primaryKey = primaryKey;
+  }
+
+  _createClass(AggregatorCell, [{
+    key: 'push',
+    value: function push(record) {
+      var _this = this;
+
+      Object.keys(this.instances).forEach(function (key) {
+        _this.instances[key].push(record);
+      });
+    }
+  }, {
+    key: 'getInstance',
+    value: function getInstance(key) {
+      var targetKey = key || this.primaryKey;
+      if (targetKey && this.instances[targetKey]) {
+        return this.instances[targetKey];
+      }
+      var first = this.instances[this.primaryKey] || this.instances[Object.keys(this.instances)[0]];
+      return first || null;
+    }
+  }]);
+
+  return AggregatorCell;
+}();
+
+// default aggregators & renderers use US naming and number formatting
+
+
+var aggregators = function (tpl) {
+  return {
+    Count: tpl.count(usFmtInt),
+    'Count Unique Values': tpl.countUnique(usFmtInt),
+    'List Unique Values': tpl.listUnique(', '),
+    Sum: tpl.sum(usFmt),
+    'Integer Sum': tpl.sum(usFmtInt),
+    Average: tpl.average(usFmt),
+    Median: tpl.median(usFmt),
+    'Sample Variance': tpl.var(1, usFmt),
+    'Sample Standard Deviation': tpl.stdev(1, usFmt),
+    Minimum: tpl.min(usFmt),
+    Maximum: tpl.max(usFmt),
+    First: tpl.first(usFmt),
+    Last: tpl.last(usFmt),
+    'Sum over Sum': tpl.sumOverSum(usFmt),
+    'Sum as Fraction of Total': tpl.fractionOf(tpl.sum(), 'total', usFmtPct),
+    'Sum as Fraction of Rows': tpl.fractionOf(tpl.sum(), 'row', usFmtPct),
+    'Sum as Fraction of Columns': tpl.fractionOf(tpl.sum(), 'col', usFmtPct),
+    'Count as Fraction of Total': tpl.fractionOf(tpl.count(), 'total', usFmtPct),
+    'Count as Fraction of Rows': tpl.fractionOf(tpl.count(), 'row', usFmtPct),
+    'Count as Fraction of Columns': tpl.fractionOf(tpl.count(), 'col', usFmtPct)
+  };
+}(aggregatorTemplates);
+
+var locales = {
+  en: {
+    aggregators: aggregators,
+    localeStrings: {
+      renderError: 'An error occurred rendering the PivotTable results.',
+      computeError: 'An error occurred computing the PivotTable results.',
+      uiRenderError: 'An error occurred rendering the PivotTable UI.',
+      selectAll: 'Select All',
+      selectNone: 'Select None',
+      tooMany: '(too many to list)',
+      filterResults: 'Filter values',
+      apply: 'Apply',
+      cancel: 'Cancel',
+      totals: 'Totals',
+      vs: 'vs',
+      by: 'by'
+    }
+  }
+};
+
+// dateFormat deriver l10n requires month and day names to be passed in directly
+var mthNamesEn = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+var dayNamesEn = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+var zeroPad = function zeroPad(number) {
+  return ('0' + number).substr(-2, 2);
+}; // eslint-disable-line no-magic-numbers
+
+var derivers = {
+  bin: function bin(col, binWidth) {
+    return function (record) {
+      return record[col] - record[col] % binWidth;
+    };
+  },
+  dateFormat: function dateFormat(col, formatString) {
+    var utcOutput = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var mthNames = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : mthNamesEn;
+    var dayNames = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : dayNamesEn;
+
+    var utc = utcOutput ? 'UTC' : '';
+    return function (record) {
+      var date = new Date(Date.parse(record[col]));
+      if (isNaN(date)) {
+        return '';
+      }
+      return formatString.replace(/%(.)/g, function (m, p) {
+        switch (p) {
+          case 'y':
+            return date['get' + utc + 'FullYear']();
+          case 'm':
+            return zeroPad(date['get' + utc + 'Month']() + 1);
+          case 'n':
+            return mthNames[date['get' + utc + 'Month']()];
+          case 'd':
+            return zeroPad(date['get' + utc + 'Date']());
+          case 'w':
+            return dayNames[date['get' + utc + 'Day']()];
+          case 'x':
+            return date['get' + utc + 'Day']();
+          case 'H':
+            return zeroPad(date['get' + utc + 'Hours']());
+          case 'M':
+            return zeroPad(date['get' + utc + 'Minutes']());
+          case 'S':
+            return zeroPad(date['get' + utc + 'Seconds']());
+          default:
+            return '%' + p;
+        }
+      });
+    };
+  }
+};
+
+/*
+Data Model class
+*/
+
+var PivotData = function () {
+  function PivotData() {
+    var _this2 = this;
+
+    var inputProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, PivotData);
+
+    this.props = Object.assign({}, PivotData.defaultProps, inputProps);
+    __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.checkPropTypes(PivotData.propTypes, this.props, 'prop', 'PivotData');
+
+    this.aggregations = this.normalizeAggregations();
+    this.aggregationKeyLookup = {};
+    this.aggregations.forEach(function (agg) {
+      if (!(agg.aggregatorName in _this2.aggregationKeyLookup)) {
+        _this2.aggregationKeyLookup[agg.aggregatorName] = agg.key;
+      }
+    });
+    if (this.aggregations.length === 0) {
+      throw new Error('PivotData requires at least one aggregation');
+    }
+    this.primaryAggregation = this.aggregations[0];
+    this.primaryAggregatorName = this.primaryAggregation.aggregatorName;
+
+    this.aggregatorFactories = this.buildAggregatorFactories();
+    this.tree = {};
+    this.rowKeys = [];
+    this.colKeys = [];
+    this.rowTotals = {};
+    this.colTotals = {};
+    this.allTotal = this.createAggregatorCell([], []);
+    this.sorted = false;
+
+    if (this.props.precomputedData) {
+      // Results computed by the Web Worker (or any previous pass) are
+      // hydrated instead of re-scanning every record on the main thread.
+      this.hydrateFromPrecomputed(this.props.precomputedData);
+      return;
+    }
+
+    var progressHook = this.props.onRecordProcessed;
+    var recordHandler = function recordHandler(record) {
+      if (_this2.filter(record)) {
+        _this2.processRecord(record);
+      }
+    };
+    if (typeof progressHook === 'function') {
+      var recordsProcessed = 0;
+      PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
+        recordHandler(record);
+        recordsProcessed++;
+        if (recordsProcessed % RECORD_PROGRESS_BATCH_SIZE === 0) {
+          progressHook(recordsProcessed);
+        }
+      });
+    } else {
+      PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, recordHandler);
+    }
+  }
+
+  /*
+   * Rebuilds tree/totals from a serialized PivotData payload (as produced by
+   * `serializePivotData` inside the worker). Aggregated values are final, so
+   * only lightweight stub aggregators with the correct `value()` and
+   * `format()` behavior are created per cell.
+   */
+
+
+  _createClass(PivotData, [{
+    key: 'hydrateFromPrecomputed',
+    value: function hydrateFromPrecomputed(precomputed) {
+      var _this3 = this;
+
+      // One real aggregator instance per aggregation provides `format()` and
+      // `numInputs` for every hydrated stub cell.
+      var formatSources = {};
+      this.aggregations.forEach(function (agg) {
+        formatSources[agg.key] = _this3.aggregatorFactories[agg.key](_this3, [], []);
+      });
+
+      var makeCell = function makeCell(serializedCell) {
+        var values = serializedCell && serializedCell.values || {};
+        var instances = {};
+        _this3.aggregations.forEach(function (agg) {
+          var source = formatSources[agg.key];
+          var _value = values[agg.key];
+          instances[agg.key] = {
+            push: function push() {},
+            value: function value() {
+              return _value;
+            },
+            format: function format(x) {
+              return source.format(x);
+            },
+
+            numInputs: source.numInputs,
+            outlet: source.outlet
+          };
+        });
+        return new AggregatorCell(instances, _this3.primaryAggregation.key);
+      };
+
+      var hydrateTotals = function hydrateTotals(source, target) {
+        Object.keys(source || {}).forEach(function (flatKey) {
+          target[flatKey] = makeCell(source[flatKey]);
+        });
+      };
+
+      this.rowKeys = (precomputed.rowKeys || []).map(function (key) {
+        return key.slice();
+      });
+      this.colKeys = (precomputed.colKeys || []).map(function (key) {
+        return key.slice();
+      });
+      this.rowTotals = {};
+      hydrateTotals(precomputed.rowTotals, this.rowTotals);
+      this.colTotals = {};
+      hydrateTotals(precomputed.colTotals, this.colTotals);
+      this.tree = {};
+      Object.keys(precomputed.tree || {}).forEach(function (flatRowKey) {
+        _this3.tree[flatRowKey] = {};
+        hydrateTotals(precomputed.tree[flatRowKey], _this3.tree[flatRowKey]);
+      });
+      this.allTotal = makeCell(precomputed.allTotal);
+
+      // Keys were already sorted inside the worker; only re-sort on the main
+      // thread when a sorter could not cross the worker boundary (functions).
+      this.sorted = !sortersHaveFunctions(this.props.sorters);
+    }
+  }, {
+    key: 'filter',
+    value: function filter(record) {
+      for (var k in this.props.valueFilter) {
+        if (record[k] in this.props.valueFilter[k]) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }, {
+    key: 'forEachMatchingRecord',
+    value: function forEachMatchingRecord(criteria, callback) {
+      var _this4 = this;
+
+      return PivotData.forEachRecord(this.props.data, this.props.derivedAttributes, function (record) {
+        if (!_this4.filter(record)) {
+          return;
+        }
+        for (var k in criteria) {
+          var v = criteria[k];
+          if (v !== (k in record ? record[k] : 'null')) {
+            return;
+          }
+        }
+        callback(record);
+      });
+    }
+  }, {
+    key: 'arrSort',
+    value: function arrSort(attrs) {
+      var _this5 = this;
+
+      var a = void 0;
+      var sortersArr = function () {
+        var result = [];
+        var _iteratorNormalCompletion2 = true;
+        var _didIteratorError2 = false;
+        var _iteratorError2 = undefined;
+
+        try {
+          for (var _iterator2 = Array.from(attrs)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+            a = _step2.value;
+
+            result.push(getSort(_this5.props.sorters, a));
+          }
+        } catch (err) {
+          _didIteratorError2 = true;
+          _iteratorError2 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion2 && _iterator2.return) {
+              _iterator2.return();
+            }
+          } finally {
+            if (_didIteratorError2) {
+              throw _iteratorError2;
+            }
+          }
+        }
+
+        return result;
+      }();
+      return function (a, b) {
+        var _iteratorNormalCompletion3 = true;
+        var _didIteratorError3 = false;
+        var _iteratorError3 = undefined;
+
+        try {
+          for (var _iterator3 = Object.keys(sortersArr || {})[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+            var i = _step3.value;
+
+            var sorter = sortersArr[i];
+            var comparison = sorter(a[i], b[i]);
+            if (comparison !== 0) {
+              return comparison;
+            }
+          }
+        } catch (err) {
+          _didIteratorError3 = true;
+          _iteratorError3 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion3 && _iterator3.return) {
+              _iterator3.return();
+            }
+          } finally {
+            if (_didIteratorError3) {
+              throw _iteratorError3;
+            }
+          }
+        }
+
+        return 0;
+      };
+    }
+  }, {
+    key: 'sortKeys',
+    value: function sortKeys() {
+      var _this6 = this;
+
+      if (!this.sorted) {
+        this.sorted = true;
+        var v = function v(r, c) {
+          return _this6.getAggregator(r, c).value();
+        };
+
+        // Handle per-row sorting
+        if (this.props.rowSorts && Object.keys(this.props.rowSorts).length > 0) {
+          var rowSorts = this.props.rowSorts;
+          this.rowKeys.sort(function (a, b) {
+            // First, check if any sorted attribute has a difference
+            for (var i = 0; i < _this6.props.rows.length; i++) {
+              var attr = _this6.props.rows[i];
+              if (attr && rowSorts[attr]) {
+                var sortDir = rowSorts[attr] === 'ASC' ? 1 : -1;
+                var sorter = getSort(_this6.props.sorters, attr);
+                var comparison = sorter(a[i] || '', b[i] || '');
+                if (comparison !== 0) {
+                  return sortDir * comparison;
+                }
+              }
+            }
+            // If sorted attributes are equal, use default sorting for remaining attributes
+            return _this6.arrSort(_this6.props.rows)(a, b);
+          });
+        } else {
+          // Use global row order
+          switch (this.props.rowOrder) {
+            case 'value_a_to_z':
+              this.rowKeys.sort(function (a, b) {
+                return naturalSort(v(a, []), v(b, []));
+              });
+              break;
+            case 'value_z_to_a':
+              this.rowKeys.sort(function (a, b) {
+                return -naturalSort(v(a, []), v(b, []));
+              });
+              break;
+            default:
+              this.rowKeys.sort(this.arrSort(this.props.rows));
+          }
+        }
+
+        // Handle per-column sorting
+        if (this.props.colSorts && Object.keys(this.props.colSorts).length > 0) {
+          var colSorts = this.props.colSorts;
+          this.colKeys.sort(function (a, b) {
+            // First, check if any sorted attribute has a difference
+            for (var i = 0; i < _this6.props.cols.length; i++) {
+              var attr = _this6.props.cols[i];
+              if (attr && colSorts[attr]) {
+                var sortDir = colSorts[attr] === 'ASC' ? 1 : -1;
+                var sorter = getSort(_this6.props.sorters, attr);
+                var comparison = sorter(a[i] || '', b[i] || '');
+                if (comparison !== 0) {
+                  return sortDir * comparison;
+                }
+              }
+            }
+            // If sorted attributes are equal, use default sorting for remaining attributes
+            return _this6.arrSort(_this6.props.cols)(a, b);
+          });
+        } else {
+          // Use global col order
+          switch (this.props.colOrder) {
+            case 'value_a_to_z':
+              this.colKeys.sort(function (a, b) {
+                return naturalSort(v([], a), v([], b));
+              });
+              break;
+            case 'value_z_to_a':
+              this.colKeys.sort(function (a, b) {
+                return -naturalSort(v([], a), v([], b));
+              });
+              break;
+            default:
+              this.colKeys.sort(this.arrSort(this.props.cols));
+          }
+        }
+      }
+    }
+  }, {
+    key: 'getColKeys',
+    value: function getColKeys() {
+      this.sortKeys();
+      return this.colKeys;
+    }
+  }, {
+    key: 'getRowKeys',
+    value: function getRowKeys() {
+      this.sortKeys();
+      return this.rowKeys;
+    }
+  }, {
+    key: 'processRecord',
+    value: function processRecord(record) {
+      // this code is called in a tight loop
+      var colKey = [];
+      var rowKey = [];
+      var _iteratorNormalCompletion4 = true;
+      var _didIteratorError4 = false;
+      var _iteratorError4 = undefined;
+
+      try {
+        for (var _iterator4 = Array.from(this.props.cols)[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
+          var x = _step4.value;
+
+          colKey.push(x in record ? record[x] : 'null');
+        }
+      } catch (err) {
+        _didIteratorError4 = true;
+        _iteratorError4 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion4 && _iterator4.return) {
+            _iterator4.return();
+          }
+        } finally {
+          if (_didIteratorError4) {
+            throw _iteratorError4;
+          }
+        }
+      }
+
+      var _iteratorNormalCompletion5 = true;
+      var _didIteratorError5 = false;
+      var _iteratorError5 = undefined;
+
+      try {
+        for (var _iterator5 = Array.from(this.props.rows)[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
+          var _x17 = _step5.value;
+
+          rowKey.push(_x17 in record ? record[_x17] : 'null');
+        }
+      } catch (err) {
+        _didIteratorError5 = true;
+        _iteratorError5 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion5 && _iterator5.return) {
+            _iterator5.return();
+          }
+        } finally {
+          if (_didIteratorError5) {
+            throw _iteratorError5;
+          }
+        }
+      }
+
+      var flatRowKey = rowKey.join(String.fromCharCode(0));
+      var flatColKey = colKey.join(String.fromCharCode(0));
+
+      this.allTotal.push(record);
+
+      if (rowKey.length !== 0) {
+        if (!this.rowTotals[flatRowKey]) {
+          this.rowKeys.push(rowKey);
+          this.rowTotals[flatRowKey] = this.createAggregatorCell(rowKey, []);
+        }
+        this.rowTotals[flatRowKey].push(record);
+      }
+
+      if (colKey.length !== 0) {
+        if (!this.colTotals[flatColKey]) {
+          this.colKeys.push(colKey);
+          this.colTotals[flatColKey] = this.createAggregatorCell([], colKey);
+        }
+        this.colTotals[flatColKey].push(record);
+      }
+
+      if (colKey.length !== 0 && rowKey.length !== 0) {
+        if (!this.tree[flatRowKey]) {
+          this.tree[flatRowKey] = {};
+        }
+        if (!this.tree[flatRowKey][flatColKey]) {
+          this.tree[flatRowKey][flatColKey] = this.createAggregatorCell(rowKey, colKey);
+        }
+        this.tree[flatRowKey][flatColKey].push(record);
+      }
+    }
+  }, {
+    key: 'getAggregator',
+    value: function getAggregator(rowKey, colKey) {
+      var aggregationKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.primaryAggregation.key;
+
+      var resolvedKey = aggregationKey;
+      if (resolvedKey && !(resolvedKey in this.aggregatorFactories) && this.aggregationKeyLookup[resolvedKey]) {
+        resolvedKey = this.aggregationKeyLookup[resolvedKey];
+      }
+      var cell = this.getAggregatorCell(rowKey, colKey);
+      if (!cell) {
+        return PivotData.emptyAggregator;
+      }
+      return cell.getInstance(resolvedKey) || PivotData.emptyAggregator;
+    }
+  }, {
+    key: 'getAggregatorCell',
+    value: function getAggregatorCell(rowKey, colKey) {
+      var cell = void 0;
+      var flatRowKey = rowKey.join(String.fromCharCode(0));
+      var flatColKey = colKey.join(String.fromCharCode(0));
+      if (rowKey.length === 0 && colKey.length === 0) {
+        cell = this.allTotal;
+      } else if (rowKey.length === 0) {
+        cell = this.colTotals[flatColKey];
+      } else if (colKey.length === 0) {
+        cell = this.rowTotals[flatRowKey];
+      } else {
+        cell = this.tree[flatRowKey] && this.tree[flatRowKey][flatColKey] ? this.tree[flatRowKey][flatColKey] : null;
+      }
+      return cell || null;
+    }
+  }, {
+    key: 'getAggregatorNames',
+    value: function getAggregatorNames() {
+      return this.aggregations.map(function (agg) {
+        return agg.aggregatorName;
+      });
+    }
+  }, {
+    key: 'getAggregations',
+    value: function getAggregations() {
+      return this.aggregations.map(function (agg) {
+        return Object.assign({}, agg);
+      });
+    }
+  }, {
+    key: 'getPrimaryAggregatorName',
+    value: function getPrimaryAggregatorName() {
+      return this.primaryAggregatorName;
+    }
+  }, {
+    key: 'getPrimaryAggregation',
+    value: function getPrimaryAggregation() {
+      return Object.assign({}, this.primaryAggregation);
+    }
+
+    /**
+     * Groups aggregations by their aggregatorName
+     * @returns {Object} Object mapping aggregator names to arrays of aggregations
+     * Example: { 'Count': [agg1, agg2], 'Sum': [agg3] }
+     */
+
+  }, {
+    key: 'groupAggregationsByType',
+    value: function groupAggregationsByType() {
+      var grouped = {};
+      this.aggregations.forEach(function (agg) {
+        var aggName = agg.aggregatorName;
+        if (!grouped[aggName]) {
+          grouped[aggName] = [];
+        }
+        grouped[aggName].push(agg);
+      });
+      return grouped;
+    }
+
+    /**
+     * Gets aggregations for a specific aggregator type
+     * @param {string} aggregatorName - The aggregator name (e.g., 'Count', 'Sum')
+     * @returns {Array} Array of aggregation configurations
+     */
+
+  }, {
+    key: 'getAggregationsByType',
+    value: function getAggregationsByType(aggregatorName) {
+      return this.aggregations.filter(function (agg) {
+        return agg.aggregatorName === aggregatorName;
+      });
+    }
+  }, {
+    key: 'normalizeAggregations',
+    value: function normalizeAggregations() {
+      var defaultAggregatorName = Object.keys(this.props.aggregators)[0];
+      var aggregationsProvided = Array.isArray(this.props.aggregations) && this.props.aggregations.length > 0;
+      var legacyAggregatorName = typeof this.props.aggregatorName === 'string' ? this.props.aggregatorName : null;
+      var fallbackAggregatorName = legacyAggregatorName || defaultAggregatorName;
+      var fallbackVals = Array.isArray(this.props.vals) ? this.props.vals : [];
+      var aggregations = [];
+      if (aggregationsProvided) {
+        aggregations = this.props.aggregations;
+      } else {
+        aggregations = [{
+          aggregatorName: fallbackAggregatorName,
+          vals: fallbackVals
+        }];
+      }
+      return aggregations.map(function (agg, idx) {
+        var aggregatorName = agg.aggregatorName || (aggregationsProvided ? defaultAggregatorName : fallbackAggregatorName);
+        var vals = typeof agg.vals !== 'undefined' ? agg.vals : aggregationsProvided ? [] : fallbackVals.slice();
+        var normalizedVals = Array.isArray(vals) ? vals : [];
+        var key = agg.key || (aggregatorName || 'agg') + '-' + (normalizedVals.length ? normalizedVals.join('|') : '') + '-' + idx;
+        var label = agg.label || (normalizedVals.length ? aggregatorName + ' of ' + normalizedVals.join(', ') : aggregatorName);
+        return {
+          key: key,
+          aggregatorName: aggregatorName,
+          vals: normalizedVals,
+          label: label
+        };
+      });
+    }
+  }, {
+    key: 'buildAggregatorFactories',
+    value: function buildAggregatorFactories() {
+      var _this7 = this;
+
+      var factories = {};
+      this.aggregations.forEach(function (agg) {
+        if (!(agg.aggregatorName in _this7.props.aggregators)) {
+          throw new Error('unknown aggregator ' + agg.aggregatorName);
+        }
+        factories[agg.key] = _this7.props.aggregators[agg.aggregatorName](agg.vals);
+      });
+      return factories;
+    }
+  }, {
+    key: 'createAggregatorCell',
+    value: function createAggregatorCell(rowKey, colKey) {
+      var _this8 = this;
+
+      var instances = {};
+      this.aggregations.forEach(function (agg) {
+        instances[agg.key] = _this8.aggregatorFactories[agg.key](_this8, rowKey, colKey);
+      });
+      return new AggregatorCell(instances, this.primaryAggregation.key);
+    }
+  }]);
+
+  return PivotData;
+}();
+
+PivotData.emptyAggregator = {
+  push: function push() {},
+  value: function value() {
+    return null;
+  },
+  format: function format() {
+    return '';
+  }
+};
+
+// can handle arrays or jQuery selections of tables
+PivotData.forEachRecord = function (input, derivedAttributes, f) {
+  var addRecord = void 0,
+      record = void 0;
+  if (Object.getOwnPropertyNames(derivedAttributes).length === 0) {
+    addRecord = f;
+  } else {
+    addRecord = function addRecord(record) {
+      for (var k in derivedAttributes) {
+        var derived = derivedAttributes[k](record);
+        if (derived !== null) {
+          record[k] = derived;
+        }
+      }
+      return f(record);
+    };
+  }
+
+  // if it's a function, have it call us back
+  if (typeof input === 'function') {
+    return input(addRecord);
+  } else if (Array.isArray(input)) {
+    if (Array.isArray(input[0])) {
+      // array of arrays
+      return function () {
+        var result = [];
+        var _iteratorNormalCompletion6 = true;
+        var _didIteratorError6 = false;
+        var _iteratorError6 = undefined;
+
+        try {
+          for (var _iterator6 = Object.keys(input || {})[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
+            var i = _step6.value;
+
+            var compactRecord = input[i];
+            if (i > 0) {
+              record = {};
+              var _iteratorNormalCompletion7 = true;
+              var _didIteratorError7 = false;
+              var _iteratorError7 = undefined;
+
+              try {
+                for (var _iterator7 = Object.keys(input[0] || {})[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
+                  var j = _step7.value;
+
+                  var k = input[0][j];
+                  record[k] = compactRecord[j];
+                }
+              } catch (err) {
+                _didIteratorError7 = true;
+                _iteratorError7 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion7 && _iterator7.return) {
+                    _iterator7.return();
+                  }
+                } finally {
+                  if (_didIteratorError7) {
+                    throw _iteratorError7;
+                  }
+                }
+              }
+
+              result.push(addRecord(record));
+            }
+          }
+        } catch (err) {
+          _didIteratorError6 = true;
+          _iteratorError6 = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion6 && _iterator6.return) {
+              _iterator6.return();
+            }
+          } finally {
+            if (_didIteratorError6) {
+              throw _iteratorError6;
+            }
+          }
+        }
+
+        return result;
+      }();
+    }
+
+    // array of objects
+    return function () {
+      var result1 = [];
+      var _iteratorNormalCompletion8 = true;
+      var _didIteratorError8 = false;
+      var _iteratorError8 = undefined;
+
+      try {
+        for (var _iterator8 = Array.from(input)[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
+          record = _step8.value;
+
+          result1.push(addRecord(record));
+        }
+      } catch (err) {
+        _didIteratorError8 = true;
+        _iteratorError8 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion8 && _iterator8.return) {
+            _iterator8.return();
+          }
+        } finally {
+          if (_didIteratorError8) {
+            throw _iteratorError8;
+          }
+        }
+      }
+
+      return result1;
+    }();
+  }
+  throw new Error('unknown input format');
+};
+
+PivotData.defaultProps = {
+  aggregators: aggregators,
+  cols: [],
+  rows: [],
+  vals: [],
+  aggregatorName: Object.keys(aggregators)[0],
+  aggregations: [],
+  sorters: {},
+  valueFilter: {},
+  rowOrder: 'key_a_to_z',
+  colOrder: 'key_a_to_z',
+  rowSorts: {},
+  colSorts: {},
+  derivedAttributes: {}
+};
+
+PivotData.propTypes = {
+  data: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.array, __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.func]).isRequired,
+  aggregatorName: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string,
+  aggregations: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.shape({
+    key: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string,
+    aggregatorName: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string,
+    vals: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string),
+    label: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string
+  })),
+  cols: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string),
+  rows: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string),
+  vals: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string),
+  valueFilter: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.bool)),
+  sorters: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOfType([__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.array]))]),
+  derivedAttributes: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.func),
+  precomputedData: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.object,
+  onRecordProcessed: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.func,
+  rowOrder: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOf(['key_a_to_z', 'value_a_to_z', 'value_z_to_a']),
+  colOrder: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOf(['key_a_to_z', 'value_a_to_z', 'value_z_to_a']),
+  rowSorts: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOf(['ASC', 'DESC'])),
+  colSorts: __WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.objectOf(__WEBPACK_IMPORTED_MODULE_0_prop_types___default.a.oneOf(['ASC', 'DESC']))
+};
+
+
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/* WEBPACK VAR INJECTION */(function(process) {/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== 'production') {
+  var ReactIs = __webpack_require__(2);
+
+  // By explicitly using `prop-types` you are opting into new development behavior.
+  // http://fb.me/prop-types-in-prod
+  var throwOnDirectAccess = true;
+  module.exports = __webpack_require__(10)(ReactIs.isElement, throwOnDirectAccess);
+} else {
+  // By explicitly using `prop-types` you are opting into new production behavior.
+  // http://fb.me/prop-types-in-prod
+  module.exports = __webpack_require__(13)();
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/** @license React v16.13.1
+ * react-is.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.
+ */
+
+var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;
+exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};
+exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};
+exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;
+
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {/** @license React v16.13.1
+ * react-is.development.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.
+ */
+
+
+
+
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+'use strict';
+
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
+// (unstable) APIs that have been removed. Can we remove the symbols?
+
+var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
+var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
+var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
+var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
+
+function isValidElementType(type) {
+  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_ASYNC_MODE_TYPE:
+          case REACT_CONCURRENT_MODE_TYPE:
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+} // AsyncMode is deprecated along with isAsyncMode
+
+var AsyncMode = REACT_ASYNC_MODE_TYPE;
+var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+    }
+  }
+
+  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+}
+function isConcurrentMode(object) {
+  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+
+exports.AsyncMode = AsyncMode;
+exports.ConcurrentMode = ConcurrentMode;
+exports.ContextConsumer = ContextConsumer;
+exports.ContextProvider = ContextProvider;
+exports.Element = Element;
+exports.ForwardRef = ForwardRef;
+exports.Fragment = Fragment;
+exports.Lazy = Lazy;
+exports.Memo = Memo;
+exports.Portal = Portal;
+exports.Profiler = Profiler;
+exports.StrictMode = StrictMode;
+exports.Suspense = Suspense;
+exports.isAsyncMode = isAsyncMode;
+exports.isConcurrentMode = isConcurrentMode;
+exports.isContextConsumer = isContextConsumer;
+exports.isContextProvider = isContextProvider;
+exports.isElement = isElement;
+exports.isForwardRef = isForwardRef;
+exports.isFragment = isFragment;
+exports.isLazy = isLazy;
+exports.isMemo = isMemo;
+exports.isPortal = isPortal;
+exports.isProfiler = isProfiler;
+exports.isStrictMode = isStrictMode;
+exports.isSuspense = isSuspense;
+exports.isValidElementType = isValidElementType;
+exports.typeOf = typeOf;
+  })();
+}
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+var ReactIs = __webpack_require__(2);
+var assign = __webpack_require__(11);
+
+var ReactPropTypesSecret = __webpack_require__(1);
+var has = __webpack_require__(3);
+var checkPropTypes = __webpack_require__(12);
+
+var printWarning = function() {};
+
+if (process.env.NODE_ENV !== 'production') {
+  printWarning = function(text) {
+    var message = 'Warning: ' + text;
+    if (typeof console !== 'undefined') {
+      console.error(message);
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      throw new Error(message);
+    } catch (x) {}
+  };
+}
+
+function emptyFunctionThatReturnsNull() {
+  return null;
+}
+
+module.exports = function(isValidElement, throwOnDirectAccess) {
+  /* global Symbol */
+  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+  /**
+   * Returns the iterator method function contained on the iterable object.
+   *
+   * Be sure to invoke the function with the iterable as context:
+   *
+   *     var iteratorFn = getIteratorFn(myIterable);
+   *     if (iteratorFn) {
+   *       var iterator = iteratorFn.call(myIterable);
+   *       ...
+   *     }
+   *
+   * @param {?object} maybeIterable
+   * @return {?function}
+   */
+  function getIteratorFn(maybeIterable) {
+    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+    if (typeof iteratorFn === 'function') {
+      return iteratorFn;
+    }
+  }
+
+  /**
+   * Collection of methods that allow declaration and validation of props that are
+   * supplied to React components. Example usage:
+   *
+   *   var Props = require('ReactPropTypes');
+   *   var MyArticle = React.createClass({
+   *     propTypes: {
+   *       // An optional string prop named "description".
+   *       description: Props.string,
+   *
+   *       // A required enum prop named "category".
+   *       category: Props.oneOf(['News','Photos']).isRequired,
+   *
+   *       // A prop named "dialog" that requires an instance of Dialog.
+   *       dialog: Props.instanceOf(Dialog).isRequired
+   *     },
+   *     render: function() { ... }
+   *   });
+   *
+   * A more formal specification of how these methods are used:
+   *
+   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+   *   decl := ReactPropTypes.{type}(.isRequired)?
+   *
+   * Each and every declaration produces a function with the same signature. This
+   * allows the creation of custom validation functions. For example:
+   *
+   *  var MyLink = React.createClass({
+   *    propTypes: {
+   *      // An optional string or URI prop named "href".
+   *      href: function(props, propName, componentName) {
+   *        var propValue = props[propName];
+   *        if (propValue != null && typeof propValue !== 'string' &&
+   *            !(propValue instanceof URI)) {
+   *          return new Error(
+   *            'Expected a string or an URI for ' + propName + ' in ' +
+   *            componentName
+   *          );
+   *        }
+   *      }
+   *    },
+   *    render: function() {...}
+   *  });
+   *
+   * @internal
+   */
+
+  var ANONYMOUS = '<<anonymous>>';
+
+  // Important!
+  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+  var ReactPropTypes = {
+    array: createPrimitiveTypeChecker('array'),
+    bigint: createPrimitiveTypeChecker('bigint'),
+    bool: createPrimitiveTypeChecker('boolean'),
+    func: createPrimitiveTypeChecker('function'),
+    number: createPrimitiveTypeChecker('number'),
+    object: createPrimitiveTypeChecker('object'),
+    string: createPrimitiveTypeChecker('string'),
+    symbol: createPrimitiveTypeChecker('symbol'),
+
+    any: createAnyTypeChecker(),
+    arrayOf: createArrayOfTypeChecker,
+    element: createElementTypeChecker(),
+    elementType: createElementTypeTypeChecker(),
+    instanceOf: createInstanceTypeChecker,
+    node: createNodeChecker(),
+    objectOf: createObjectOfTypeChecker,
+    oneOf: createEnumTypeChecker,
+    oneOfType: createUnionTypeChecker,
+    shape: createShapeTypeChecker,
+    exact: createStrictShapeTypeChecker,
+  };
+
+  /**
+   * inlined Object.is polyfill to avoid requiring consumers ship their own
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+   */
+  /*eslint-disable no-self-compare*/
+  function is(x, y) {
+    // SameValue algorithm
+    if (x === y) {
+      // Steps 1-5, 7-10
+      // Steps 6.b-6.e: +0 != -0
+      return x !== 0 || 1 / x === 1 / y;
+    } else {
+      // Step 6.a: NaN == NaN
+      return x !== x && y !== y;
+    }
+  }
+  /*eslint-enable no-self-compare*/
+
+  /**
+   * We use an Error-like object for backward compatibility as people may call
+   * PropTypes directly and inspect their output. However, we don't use real
+   * Errors anymore. We don't inspect their stack anyway, and creating them
+   * is prohibitively expensive if they are created too often, such as what
+   * happens in oneOfType() for any type before the one that matched.
+   */
+  function PropTypeError(message, data) {
+    this.message = message;
+    this.data = data && typeof data === 'object' ? data: {};
+    this.stack = '';
+  }
+  // Make `instanceof Error` still work for returned errors.
+  PropTypeError.prototype = Error.prototype;
+
+  function createChainableTypeChecker(validate) {
+    if (process.env.NODE_ENV !== 'production') {
+      var manualPropTypeCallCache = {};
+      var manualPropTypeWarningCount = 0;
+    }
+    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+      componentName = componentName || ANONYMOUS;
+      propFullName = propFullName || propName;
+
+      if (secret !== ReactPropTypesSecret) {
+        if (throwOnDirectAccess) {
+          // New behavior only for users of `prop-types` package
+          var err = new Error(
+            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+            'Use `PropTypes.checkPropTypes()` to call them. ' +
+            'Read more at http://fb.me/use-check-prop-types'
+          );
+          err.name = 'Invariant Violation';
+          throw err;
+        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+          // Old behavior for people using React.PropTypes
+          var cacheKey = componentName + ':' + propName;
+          if (
+            !manualPropTypeCallCache[cacheKey] &&
+            // Avoid spamming the console because they are often not actionable except for lib authors
+            manualPropTypeWarningCount < 3
+          ) {
+            printWarning(
+              'You are manually calling a React.PropTypes validation ' +
+              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
+              'and will throw in the standalone `prop-types` package. ' +
+              'You may be seeing this warning due to a third-party PropTypes ' +
+              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
+            );
+            manualPropTypeCallCache[cacheKey] = true;
+            manualPropTypeWarningCount++;
+          }
+        }
+      }
+      if (props[propName] == null) {
+        if (isRequired) {
+          if (props[propName] === null) {
+            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+          }
+          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+        }
+        return null;
+      } else {
+        return validate(props, propName, componentName, location, propFullName);
+      }
+    }
+
+    var chainedCheckType = checkType.bind(null, false);
+    chainedCheckType.isRequired = checkType.bind(null, true);
+
+    return chainedCheckType;
+  }
+
+  function createPrimitiveTypeChecker(expectedType) {
+    function validate(props, propName, componentName, location, propFullName, secret) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== expectedType) {
+        // `propValue` being instance of, say, date/regexp, pass the 'object'
+        // check, but we can offer a more precise error message here rather than
+        // 'of type `object`'.
+        var preciseType = getPreciseType(propValue);
+
+        return new PropTypeError(
+          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
+          {expectedType: expectedType}
+        );
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createAnyTypeChecker() {
+    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+  }
+
+  function createArrayOfTypeChecker(typeChecker) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (typeof typeChecker !== 'function') {
+        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+      }
+      var propValue = props[propName];
+      if (!Array.isArray(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+      }
+      for (var i = 0; i < propValue.length; i++) {
+        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+        if (error instanceof Error) {
+          return error;
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createElementTypeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (!isValidElement(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createElementTypeTypeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      if (!ReactIs.isValidElementType(propValue)) {
+        var propType = getPropType(propValue);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createInstanceTypeChecker(expectedClass) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (!(props[propName] instanceof expectedClass)) {
+        var expectedClassName = expectedClass.name || ANONYMOUS;
+        var actualClassName = getClassName(props[propName]);
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createEnumTypeChecker(expectedValues) {
+    if (!Array.isArray(expectedValues)) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (arguments.length > 1) {
+          printWarning(
+            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
+            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
+          );
+        } else {
+          printWarning('Invalid argument supplied to oneOf, expected an array.');
+        }
+      }
+      return emptyFunctionThatReturnsNull;
+    }
+
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      for (var i = 0; i < expectedValues.length; i++) {
+        if (is(propValue, expectedValues[i])) {
+          return null;
+        }
+      }
+
+      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+        var type = getPreciseType(value);
+        if (type === 'symbol') {
+          return String(value);
+        }
+        return value;
+      });
+      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createObjectOfTypeChecker(typeChecker) {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (typeof typeChecker !== 'function') {
+        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+      }
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+      }
+      for (var key in propValue) {
+        if (has(propValue, key)) {
+          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+          if (error instanceof Error) {
+            return error;
+          }
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createUnionTypeChecker(arrayOfTypeCheckers) {
+    if (!Array.isArray(arrayOfTypeCheckers)) {
+      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+      return emptyFunctionThatReturnsNull;
+    }
+
+    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+      var checker = arrayOfTypeCheckers[i];
+      if (typeof checker !== 'function') {
+        printWarning(
+          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
+          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
+        );
+        return emptyFunctionThatReturnsNull;
+      }
+    }
+
+    function validate(props, propName, componentName, location, propFullName) {
+      var expectedTypes = [];
+      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+        var checker = arrayOfTypeCheckers[i];
+        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+        if (checkerResult == null) {
+          return null;
+        }
+        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
+          expectedTypes.push(checkerResult.data.expectedType);
+        }
+      }
+      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
+      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createNodeChecker() {
+    function validate(props, propName, componentName, location, propFullName) {
+      if (!isNode(props[propName])) {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function invalidValidatorError(componentName, location, propFullName, key, type) {
+    return new PropTypeError(
+      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
+      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
+    );
+  }
+
+  function createShapeTypeChecker(shapeTypes) {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+      }
+      for (var key in shapeTypes) {
+        var checker = shapeTypes[key];
+        if (typeof checker !== 'function') {
+          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+        }
+        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+        if (error) {
+          return error;
+        }
+      }
+      return null;
+    }
+    return createChainableTypeChecker(validate);
+  }
+
+  function createStrictShapeTypeChecker(shapeTypes) {
+    function validate(props, propName, componentName, location, propFullName) {
+      var propValue = props[propName];
+      var propType = getPropType(propValue);
+      if (propType !== 'object') {
+        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+      }
+      // We need to check all keys in case some are required but missing from props.
+      var allKeys = assign({}, props[propName], shapeTypes);
+      for (var key in allKeys) {
+        var checker = shapeTypes[key];
+        if (has(shapeTypes, key) && typeof checker !== 'function') {
+          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+        }
+        if (!checker) {
+          return new PropTypeError(
+            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
+            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
+            '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')
+          );
+        }
+        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+        if (error) {
+          return error;
+        }
+      }
+      return null;
+    }
+
+    return createChainableTypeChecker(validate);
+  }
+
+  function isNode(propValue) {
+    switch (typeof propValue) {
+      case 'number':
+      case 'string':
+      case 'undefined':
+        return true;
+      case 'boolean':
+        return !propValue;
+      case 'object':
+        if (Array.isArray(propValue)) {
+          return propValue.every(isNode);
+        }
+        if (propValue === null || isValidElement(propValue)) {
+          return true;
+        }
+
+        var iteratorFn = getIteratorFn(propValue);
+        if (iteratorFn) {
+          var iterator = iteratorFn.call(propValue);
+          var step;
+          if (iteratorFn !== propValue.entries) {
+            while (!(step = iterator.next()).done) {
+              if (!isNode(step.value)) {
+                return false;
+              }
+            }
+          } else {
+            // Iterator will provide entry [k,v] tuples rather than values.
+            while (!(step = iterator.next()).done) {
+              var entry = step.value;
+              if (entry) {
+                if (!isNode(entry[1])) {
+                  return false;
+                }
+              }
+            }
+          }
+        } else {
+          return false;
+        }
+
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  function isSymbol(propType, propValue) {
+    // Native Symbol.
+    if (propType === 'symbol') {
+      return true;
+    }
+
+    // falsy value can't be a Symbol
+    if (!propValue) {
+      return false;
+    }
+
+    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+    if (propValue['@@toStringTag'] === 'Symbol') {
+      return true;
+    }
+
+    // Fallback for non-spec compliant Symbols which are polyfilled.
+    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // Equivalent of `typeof` but with special handling for array and regexp.
+  function getPropType(propValue) {
+    var propType = typeof propValue;
+    if (Array.isArray(propValue)) {
+      return 'array';
+    }
+    if (propValue instanceof RegExp) {
+      // Old webkits (at least until Android 4.0) return 'function' rather than
+      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+      // passes PropTypes.object.
+      return 'object';
+    }
+    if (isSymbol(propType, propValue)) {
+      return 'symbol';
+    }
+    return propType;
+  }
+
+  // This handles more types than `getPropType`. Only used for error messages.
+  // See `createPrimitiveTypeChecker`.
+  function getPreciseType(propValue) {
+    if (typeof propValue === 'undefined' || propValue === null) {
+      return '' + propValue;
+    }
+    var propType = getPropType(propValue);
+    if (propType === 'object') {
+      if (propValue instanceof Date) {
+        return 'date';
+      } else if (propValue instanceof RegExp) {
+        return 'regexp';
+      }
+    }
+    return propType;
+  }
+
+  // Returns a string that is postfixed to a warning about an invalid type.
+  // For example, "undefined" or "of type array"
+  function getPostfixForTypeWarning(value) {
+    var type = getPreciseType(value);
+    switch (type) {
+      case 'array':
+      case 'object':
+        return 'an ' + type;
+      case 'boolean':
+      case 'date':
+      case 'regexp':
+        return 'a ' + type;
+      default:
+        return type;
+    }
+  }
+
+  // Returns class name of the object, if any.
+  function getClassName(propValue) {
+    if (!propValue.constructor || !propValue.constructor.name) {
+      return ANONYMOUS;
+    }
+    return propValue.constructor.name;
+  }
+
+  ReactPropTypes.checkPropTypes = checkPropTypes;
+  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+  ReactPropTypes.PropTypes = ReactPropTypes;
+
+  return ReactPropTypes;
+};
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+function toObject(val) {
+	if (val === null || val === undefined) {
+		throw new TypeError('Object.assign cannot be called with null or undefined');
+	}
+
+	return Object(val);
+}
+
+function shouldUseNative() {
+	try {
+		if (!Object.assign) {
+			return false;
+		}
+
+		// Detect buggy property enumeration order in older V8 versions.
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+		test1[5] = 'de';
+		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test2 = {};
+		for (var i = 0; i < 10; i++) {
+			test2['_' + String.fromCharCode(i)] = i;
+		}
+		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+			return test2[n];
+		});
+		if (order2.join('') !== '0123456789') {
+			return false;
+		}
+
+		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+		var test3 = {};
+		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+			test3[letter] = letter;
+		});
+		if (Object.keys(Object.assign({}, test3)).join('') !==
+				'abcdefghijklmnopqrst') {
+			return false;
+		}
+
+		return true;
+	} catch (err) {
+		// We don't expect any of the above to throw, but better to be safe.
+		return false;
+	}
+}
+
+module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+	var from;
+	var to = toObject(target);
+	var symbols;
+
+	for (var s = 1; s < arguments.length; s++) {
+		from = Object(arguments[s]);
+
+		for (var key in from) {
+			if (hasOwnProperty.call(from, key)) {
+				to[key] = from[key];
+			}
+		}
+
+		if (getOwnPropertySymbols) {
+			symbols = getOwnPropertySymbols(from);
+			for (var i = 0; i < symbols.length; i++) {
+				if (propIsEnumerable.call(from, symbols[i])) {
+					to[symbols[i]] = from[symbols[i]];
+				}
+			}
+		}
+	}
+
+	return to;
+};
+
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(process) {/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+var printWarning = function() {};
+
+if (process.env.NODE_ENV !== 'production') {
+  var ReactPropTypesSecret = __webpack_require__(1);
+  var loggedTypeFailures = {};
+  var has = __webpack_require__(3);
+
+  printWarning = function(text) {
+    var message = 'Warning: ' + text;
+    if (typeof console !== 'undefined') {
+      console.error(message);
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      throw new Error(message);
+    } catch (x) { /**/ }
+  };
+}
+
+/**
+ * Assert that the values match with the type specs.
+ * Error messages are memorized and will only be shown once.
+ *
+ * @param {object} typeSpecs Map of name to a ReactPropType
+ * @param {object} values Runtime values that need to be type-checked
+ * @param {string} location e.g. "prop", "context", "child context"
+ * @param {string} componentName Name of the component for error messages.
+ * @param {?Function} getStack Returns the component stack.
+ * @private
+ */
+function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+  if (process.env.NODE_ENV !== 'production') {
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error;
+        // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
+        try {
+          // This is intentionally an invariant that gets caught. It's the same
+          // behavior as without this statement except with a better message.
+          if (typeof typeSpecs[typeSpecName] !== 'function') {
+            var err = Error(
+              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
+              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
+            );
+            err.name = 'Invariant Violation';
+            throw err;
+          }
+          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+        } catch (ex) {
+          error = ex;
+        }
+        if (error && !(error instanceof Error)) {
+          printWarning(
+            (componentName || 'React class') + ': type specification of ' +
+            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+            'You may have forgotten to pass an argument to the type checker ' +
+            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+            'shape all require an argument).'
+          );
+        }
+        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error.message] = true;
+
+          var stack = getStack ? getStack() : '';
+
+          printWarning(
+            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Resets warning cache when testing.
+ *
+ * @private
+ */
+checkPropTypes.resetWarningCache = function() {
+  if (process.env.NODE_ENV !== 'production') {
+    loggedTypeFailures = {};
+  }
+}
+
+module.exports = checkPropTypes;
+
+/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+
+var ReactPropTypesSecret = __webpack_require__(1);
+
+function emptyFunction() {}
+function emptyFunctionWithReset() {}
+emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+module.exports = function() {
+  function shim(props, propName, componentName, location, propFullName, secret) {
+    if (secret === ReactPropTypesSecret) {
+      // It is still safe when called from React.
+      return;
+    }
+    var err = new Error(
+      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+      'Use PropTypes.checkPropTypes() to call them. ' +
+      'Read more at http://fb.me/use-check-prop-types'
+    );
+    err.name = 'Invariant Violation';
+    throw err;
+  };
+  shim.isRequired = shim;
+  function getShim() {
+    return shim;
+  };
+  // Important!
+  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+  var ReactPropTypes = {
+    array: shim,
+    bigint: shim,
+    bool: shim,
+    func: shim,
+    number: shim,
+    object: shim,
+    string: shim,
+    symbol: shim,
+
+    any: shim,
+    arrayOf: getShim,
+    element: shim,
+    elementType: shim,
+    instanceOf: getShim,
+    node: shim,
+    objectOf: getShim,
+    oneOf: getShim,
+    oneOfType: getShim,
+    shape: getShim,
+    exact: getShim,
+
+    checkPropTypes: emptyFunctionWithReset,
+    resetWarningCache: emptyFunction
+  };
+
+  ReactPropTypes.PropTypes = ReactPropTypes;
+
+  return ReactPropTypes;
+};
+
+
+/***/ })
+/******/ ]);