flipper-plugin-shopify-react-native-performance/dist/bundle.js

Flipper desktop plugin with tools for measuring lists performance, TTI, and more.

var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now(),__DEV__=true,process=this.process||{},__METRO_GLOBAL_PREFIX__='';process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"development";
(function (global) {
  "use strict";

  global.__r = metroRequire;
  global[`${__METRO_GLOBAL_PREFIX__}__d`] = define;
  global.__c = clear;
  global.__registerSegment = registerSegment;
  var modules = clear();
  const EMPTY = {};
  const {
    hasOwnProperty
  } = {};

  if (__DEV__) {
    global.$RefreshReg$ = () => {};

    global.$RefreshSig$ = () => type => type;
  }

  function clear() {
    modules = Object.create(null);
    return modules;
  }

  if (__DEV__) {
    var verboseNamesToModuleIds = Object.create(null);
    var initializingModuleIds = [];
  }

  function define(factory, moduleId, dependencyMap) {
    if (modules[moduleId] != null) {
      if (__DEV__) {
        const inverseDependencies = arguments[4];

        if (inverseDependencies) {
          global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
        }
      }

      return;
    }

    const mod = {
      dependencyMap,
      factory,
      hasError: false,
      importedAll: EMPTY,
      importedDefault: EMPTY,
      isInitialized: false,
      publicModule: {
        exports: {}
      }
    };
    modules[moduleId] = mod;

    if (__DEV__) {
      mod.hot = createHotReloadingObject();
      const verboseName = arguments[3];

      if (verboseName) {
        mod.verboseName = verboseName;
        verboseNamesToModuleIds[verboseName] = moduleId;
      }
    }
  }

  function metroRequire(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];

      if (moduleId == null) {
        throw new Error(`Unknown named module: "${verboseName}"`);
      } else {
        console.warn(`Requiring module "${verboseName}" by name is only supported for ` + "debugging purposes and will BREAK IN PRODUCTION!");
      }
    }

    const moduleIdReallyIsNumber = moduleId;

    if (__DEV__) {
      const initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);

      if (initializingIndex !== -1) {
        const cycle = initializingModuleIds.slice(initializingIndex).map(id => modules[id] ? modules[id].verboseName : "[unknown]");
        cycle.push(cycle[0]);
        console.warn(`Require cycle: ${cycle.join(" -> ")}\n\n` + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
      }
    }

    const module = modules[moduleIdReallyIsNumber];
    return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
  }

  function metroImportDefault(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    const moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedDefault !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedDefault;
    }

    const exports = metroRequire(moduleIdReallyIsNumber);
    const importedDefault = exports && exports.__esModule ? exports.default : exports;
    return modules[moduleIdReallyIsNumber].importedDefault = importedDefault;
  }

  metroRequire.importDefault = metroImportDefault;

  function metroImportAll(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      const verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    const moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedAll !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedAll;
    }

    const exports = metroRequire(moduleIdReallyIsNumber);
    let importedAll;

    if (exports && exports.__esModule) {
      importedAll = exports;
    } else {
      importedAll = {};

      if (exports) {
        for (const key in exports) {
          if (hasOwnProperty.call(exports, key)) {
            importedAll[key] = exports[key];
          }
        }
      }

      importedAll.default = exports;
    }

    return modules[moduleIdReallyIsNumber].importedAll = importedAll;
  }

  metroRequire.importAll = metroImportAll;
  let inGuard = false;

  function guardedLoadModule(moduleId, module) {
    if (!inGuard && global.ErrorUtils) {
      inGuard = true;
      let returnValue;

      try {
        returnValue = loadModuleImplementation(moduleId, module);
      } catch (e) {
        global.ErrorUtils.reportFatalError(e);
      }

      inGuard = false;
      return returnValue;
    } else {
      return loadModuleImplementation(moduleId, module);
    }
  }

  const ID_MASK_SHIFT = 16;
  const LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;

  function unpackModuleId(moduleId) {
    const segmentId = moduleId >>> ID_MASK_SHIFT;
    const localId = moduleId & LOCAL_ID_MASK;
    return {
      segmentId,
      localId
    };
  }

  metroRequire.unpackModuleId = unpackModuleId;

  function packModuleId(value) {
    return (value.segmentId << ID_MASK_SHIFT) + value.localId;
  }

  metroRequire.packModuleId = packModuleId;
  const moduleDefinersBySegmentID = [];
  const definingSegmentByModuleID = new Map();

  function registerSegment(segmentId, moduleDefiner, moduleIds) {
    moduleDefinersBySegmentID[segmentId] = moduleDefiner;

    if (__DEV__) {
      if (segmentId === 0 && moduleIds) {
        throw new Error("registerSegment: Expected moduleIds to be null for main segment");
      }

      if (segmentId !== 0 && !moduleIds) {
        throw new Error("registerSegment: Expected moduleIds to be passed for segment #" + segmentId);
      }
    }

    if (moduleIds) {
      moduleIds.forEach(moduleId => {
        if (!modules[moduleId] && !definingSegmentByModuleID.has(moduleId)) {
          definingSegmentByModuleID.set(moduleId, segmentId);
        }
      });
    }
  }

  function loadModuleImplementation(moduleId, module) {
    if (!module && moduleDefinersBySegmentID.length > 0) {
      var _definingSegmentByMod;

      const segmentId = (_definingSegmentByMod = definingSegmentByModuleID.get(moduleId)) !== null && _definingSegmentByMod !== void 0 ? _definingSegmentByMod : 0;
      const definer = moduleDefinersBySegmentID[segmentId];

      if (definer != null) {
        definer(moduleId);
        module = modules[moduleId];
        definingSegmentByModuleID.delete(moduleId);
      }
    }

    const nativeRequire = global.nativeRequire;

    if (!module && nativeRequire) {
      const {
        segmentId,
        localId
      } = unpackModuleId(moduleId);
      nativeRequire(localId, segmentId);
      module = modules[moduleId];
    }

    if (!module) {
      throw unknownModuleError(moduleId);
    }

    if (module.hasError) {
      throw moduleThrewError(moduleId, module.error);
    }

    if (__DEV__) {
      var Systrace = requireSystrace();
      var Refresh = requireRefresh();
    }

    module.isInitialized = true;
    const {
      factory,
      dependencyMap
    } = module;

    if (__DEV__) {
      initializingModuleIds.push(moduleId);
    }

    try {
      if (__DEV__) {
        Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
      }

      const moduleObject = module.publicModule;

      if (__DEV__) {
        moduleObject.hot = module.hot;
        var prevRefreshReg = global.$RefreshReg$;
        var prevRefreshSig = global.$RefreshSig$;

        if (Refresh != null) {
          const RefreshRuntime = Refresh;

          global.$RefreshReg$ = (type, id) => {
            RefreshRuntime.register(type, moduleId + " " + id);
          };

          global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
        }
      }

      moduleObject.id = moduleId;
      factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);

      if (!__DEV__) {
        module.factory = undefined;
        module.dependencyMap = undefined;
      }

      if (__DEV__) {
        Systrace.endEvent();

        if (Refresh != null) {
          registerExportsForReactRefresh(Refresh, moduleObject.exports, moduleId);
        }
      }

      return moduleObject.exports;
    } catch (e) {
      module.hasError = true;
      module.error = e;
      module.isInitialized = false;
      module.publicModule.exports = undefined;
      throw e;
    } finally {
      if (__DEV__) {
        if (initializingModuleIds.pop() !== moduleId) {
          throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
        }

        global.$RefreshReg$ = prevRefreshReg;
        global.$RefreshSig$ = prevRefreshSig;
      }
    }
  }

  function unknownModuleError(id) {
    let message = 'Requiring unknown module "' + id + '".';

    if (__DEV__) {
      message += " If you are sure the module exists, try restarting Metro. " + "You may also want to run `yarn` or `npm install`.";
    }

    return Error(message);
  }

  function moduleThrewError(id, error) {
    const displayName = __DEV__ && modules[id] && modules[id].verboseName || id;
    return Error('Requiring module "' + displayName + '", which threw an exception: ' + error);
  }

  if (__DEV__) {
    metroRequire.Systrace = {
      beginEvent: () => {},
      endEvent: () => {}
    };

    metroRequire.getModules = () => {
      return modules;
    };

    var createHotReloadingObject = function () {
      const hot = {
        _acceptCallback: null,
        _disposeCallback: null,
        _didAccept: false,
        accept: callback => {
          hot._didAccept = true;
          hot._acceptCallback = callback;
        },
        dispose: callback => {
          hot._disposeCallback = callback;
        }
      };
      return hot;
    };

    let reactRefreshTimeout = null;

    const metroHotUpdateModule = function (id, factory, dependencyMap, inverseDependencies) {
      const mod = modules[id];

      if (!mod) {
        if (factory) {
          return;
        }

        throw unknownModuleError(id);
      }

      if (!mod.hasError && !mod.isInitialized) {
        mod.factory = factory;
        mod.dependencyMap = dependencyMap;
        return;
      }

      const Refresh = requireRefresh();
      const refreshBoundaryIDs = new Set();
      let didBailOut = false;
      const updatedModuleIDs = topologicalSort([id], pendingID => {
        const pendingModule = modules[pendingID];

        if (pendingModule == null) {
          return [];
        }

        const pendingHot = pendingModule.hot;

        if (pendingHot == null) {
          throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
        }

        let canAccept = pendingHot._didAccept;

        if (!canAccept && Refresh != null) {
          const isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);

          if (isBoundary) {
            canAccept = true;
            refreshBoundaryIDs.add(pendingID);
          }
        }

        if (canAccept) {
          return [];
        }

        const parentIDs = inverseDependencies[pendingID];

        if (parentIDs.length === 0) {
          performFullRefresh("No root boundary", {
            source: mod,
            failed: pendingModule
          });
          didBailOut = true;
          return [];
        }

        return parentIDs;
      }, () => didBailOut).reverse();

      if (didBailOut) {
        return;
      }

      const seenModuleIDs = new Set();

      for (let i = 0; i < updatedModuleIDs.length; i++) {
        const updatedID = updatedModuleIDs[i];

        if (seenModuleIDs.has(updatedID)) {
          continue;
        }

        seenModuleIDs.add(updatedID);
        const updatedMod = modules[updatedID];

        if (updatedMod == null) {
          throw new Error("[Refresh] Expected to find the updated module.");
        }

        const prevExports = updatedMod.publicModule.exports;
        const didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
        const nextExports = updatedMod.publicModule.exports;

        if (didError) {
          return;
        }

        if (refreshBoundaryIDs.has(updatedID)) {
          const isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
          const didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);

          if (isNoLongerABoundary || didInvalidate) {
            const parentIDs = inverseDependencies[updatedID];

            if (parentIDs.length === 0) {
              performFullRefresh(isNoLongerABoundary ? "No longer a boundary" : "Invalidated boundary", {
                source: mod,
                failed: updatedMod
              });
              return;
            }

            for (let j = 0; j < parentIDs.length; j++) {
              const parentID = parentIDs[j];
              const parentMod = modules[parentID];

              if (parentMod == null) {
                throw new Error("[Refresh] Expected to find parent module.");
              }

              const canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);

              if (canAcceptParent) {
                refreshBoundaryIDs.add(parentID);
                updatedModuleIDs.push(parentID);
              } else {
                performFullRefresh("Invalidated boundary", {
                  source: mod,
                  failed: parentMod
                });
                return;
              }
            }
          }
        }
      }

      if (Refresh != null) {
        if (reactRefreshTimeout == null) {
          reactRefreshTimeout = setTimeout(() => {
            reactRefreshTimeout = null;
            Refresh.performReactRefresh();
          }, 30);
        }
      }
    };

    const topologicalSort = function (roots, getEdges, earlyStop) {
      const result = [];
      const visited = new Set();

      function traverseDependentNodes(node) {
        visited.add(node);
        const dependentNodes = getEdges(node);

        if (earlyStop(node)) {
          return;
        }

        dependentNodes.forEach(dependent => {
          if (visited.has(dependent)) {
            return;
          }

          traverseDependentNodes(dependent);
        });
        result.push(node);
      }

      roots.forEach(root => {
        if (!visited.has(root)) {
          traverseDependentNodes(root);
        }
      });
      return result;
    };

    const runUpdatedModule = function (id, factory, dependencyMap) {
      const mod = modules[id];

      if (mod == null) {
        throw new Error("[Refresh] Expected to find the module.");
      }

      const {
        hot
      } = mod;

      if (!hot) {
        throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
      }

      if (hot._disposeCallback) {
        try {
          hot._disposeCallback();
        } catch (error) {
          console.error(`Error while calling dispose handler for module ${id}: `, error);
        }
      }

      if (factory) {
        mod.factory = factory;
      }

      if (dependencyMap) {
        mod.dependencyMap = dependencyMap;
      }

      mod.hasError = false;
      mod.error = undefined;
      mod.importedAll = EMPTY;
      mod.importedDefault = EMPTY;
      mod.isInitialized = false;
      const prevExports = mod.publicModule.exports;
      mod.publicModule.exports = {};
      hot._didAccept = false;
      hot._acceptCallback = null;
      hot._disposeCallback = null;
      metroRequire(id);

      if (mod.hasError) {
        mod.hasError = false;
        mod.isInitialized = true;
        mod.error = null;
        mod.publicModule.exports = prevExports;
        return true;
      }

      if (hot._acceptCallback) {
        try {
          hot._acceptCallback();
        } catch (error) {
          console.error(`Error while calling accept handler for module ${id}: `, error);
        }
      }

      return false;
    };

    const performFullRefresh = (reason, modules) => {
      if (typeof window !== "undefined" && window.location != null && typeof window.location.reload === "function") {
        window.location.reload();
      } else {
        const Refresh = requireRefresh();

        if (Refresh != null) {
          var _modules$source$verbo, _modules$source, _modules$failed$verbo, _modules$failed;

          const sourceName = (_modules$source$verbo = (_modules$source = modules.source) === null || _modules$source === void 0 ? void 0 : _modules$source.verboseName) !== null && _modules$source$verbo !== void 0 ? _modules$source$verbo : "unknown";
          const failedName = (_modules$failed$verbo = (_modules$failed = modules.failed) === null || _modules$failed === void 0 ? void 0 : _modules$failed.verboseName) !== null && _modules$failed$verbo !== void 0 ? _modules$failed$verbo : "unknown";
          Refresh.performFullRefresh(`Fast Refresh - ${reason} <${sourceName}> <${failedName}>`);
        } else {
          console.warn("Could not reload the application after an edit.");
        }
      }
    };

    var isReactRefreshBoundary = function (Refresh, moduleExports) {
      if (Refresh.isLikelyComponentType(moduleExports)) {
        return true;
      }

      if (moduleExports == null || typeof moduleExports !== "object") {
        return false;
      }

      let hasExports = false;
      let areAllExportsComponents = true;

      for (const key in moduleExports) {
        hasExports = true;

        if (key === "__esModule") {
          continue;
        }

        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          return false;
        }

        const exportValue = moduleExports[key];

        if (!Refresh.isLikelyComponentType(exportValue)) {
          areAllExportsComponents = false;
        }
      }

      return hasExports && areAllExportsComponents;
    };

    var shouldInvalidateReactRefreshBoundary = (Refresh, prevExports, nextExports) => {
      const prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
      const nextSignature = getRefreshBoundarySignature(Refresh, nextExports);

      if (prevSignature.length !== nextSignature.length) {
        return true;
      }

      for (let i = 0; i < nextSignature.length; i++) {
        if (prevSignature[i] !== nextSignature[i]) {
          return true;
        }
      }

      return false;
    };

    var getRefreshBoundarySignature = (Refresh, moduleExports) => {
      const signature = [];
      signature.push(Refresh.getFamilyByType(moduleExports));

      if (moduleExports == null || typeof moduleExports !== "object") {
        return signature;
      }

      for (const key in moduleExports) {
        if (key === "__esModule") {
          continue;
        }

        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        const exportValue = moduleExports[key];
        signature.push(key);
        signature.push(Refresh.getFamilyByType(exportValue));
      }

      return signature;
    };

    var registerExportsForReactRefresh = (Refresh, moduleExports, moduleID) => {
      Refresh.register(moduleExports, moduleID + " %exports%");

      if (moduleExports == null || typeof moduleExports !== "object") {
        return;
      }

      for (const key in moduleExports) {
        const desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        const exportValue = moduleExports[key];
        const typeID = moduleID + " %exports% " + key;
        Refresh.register(exportValue, typeID);
      }
    };

    global.__accept = metroHotUpdateModule;
  }

  if (__DEV__) {
    var requireSystrace = function requireSystrace() {
      return global[__METRO_GLOBAL_PREFIX__ + "__SYSTRACE"] || metroRequire.Systrace;
    };

    var requireRefresh = function requireRefresh() {
      return global[__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] || metroRequire.Refresh;
    };
  }
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.plugin = exports.Component = void 0;

  var _react = _interopRequireWildcard(global.React);

  var _flipperPlugin = global.FlipperPlugin;
  var _antd = global.antd;

  var _ListTTIChart = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "./ListTTIChart"));

  var _BlankAreaChart = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./BlankAreaChart"));

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

  const plugin = client => {
    const blankData = (0, _flipperPlugin.createState)(new Map(), {
      persist: 'newBlankData'
    });
    const listTTIData = (0, _flipperPlugin.createState)(new Map(), {
      persist: 'newListTTIData'
    });
    client.onMessage('newBlankData', newData => {
      blankData.update(currentData => {
        var _currentData$get;

        const currentListData = (_currentData$get = currentData.get(newData.listName)) !== null && _currentData$get !== void 0 ? _currentData$get : [];
        currentData.set(newData.listName, [...currentListData, newData]);
      });
    });
    client.onMessage('newListTTIData', newListTTIData => {
      listTTIData.update(currentData => {
        var _currentData$get2;

        const currentListData = (_currentData$get2 = currentData.get(newListTTIData.listName)) !== null && _currentData$get2 !== void 0 ? _currentData$get2 : [];
        currentData.set(newListTTIData.listName, [...currentListData, newListTTIData]);
      });
    });
    return {
      blankData,
      listTTIData
    };
  };

  exports.plugin = plugin;

  const randomColor = () => {
    let color = '#';

    for (let i = 0; i < 6; i++) {
      const random = Math.random();
      const bit = random * 16 | 0;
      color += bit.toString(16);
    }

    return color;
  };

  const Component = () => {
    const instance = (0, _flipperPlugin.usePlugin)(plugin);
    const [colors, setColors] = (0, _react.useState)(new Map());
    const listTTIData = (0, _flipperPlugin.useValue)(instance.listTTIData);
    const listNames = Array.from(listTTIData.keys());
    listNames.forEach(listNames => {
      if (colors.has(listNames)) {
        return;
      }

      setColors(colors.set(listNames, randomColor()));
    });
    const blankData = (0, _flipperPlugin.useValue)(instance.blankData);
    return _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_flipperPlugin.Layout.ScrollContainer, null, _react.default.createElement(_BlankAreaChart.default, {
      colors: colors,
      blankData: blankData
    }), _react.default.createElement(_ListTTIChart.default, {
      listColors: colors,
      listTTIData: listTTIData
    })), _react.default.createElement("div", {
      style: {
        display: 'inline-block',
        margin: 'auto'
      }
    }, _react.default.createElement(_antd.Button, {
      style: {
        marginBottom: '10px'
      },
      onClick: () => {
        instance.blankData.set(new Map());
        instance.listTTIData.set(new Map());
      }
    }, "Reset data")));
  };

  exports.Component = Component;
},0,[1,578],"src/index.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _react = _interopRequireDefault(global.React);

  var _recharts = _$$_REQUIRE(_dependencyMap[0], "recharts");

  var _Header = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./Header"));

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  const ListTTIChart = ({
    listColors,
    listTTIData
  }) => {
    const listNames = Array.from(listTTIData.keys());
    const averageData = listNames.map(listName => {
      var _listTTIData$get;

      const ttiData = (_listTTIData$get = listTTIData.get(listName)) !== null && _listTTIData$get !== void 0 ? _listTTIData$get : [];
      const sum = ttiData.reduce((sum, {
        TTI
      }) => {
        return sum + TTI;
      }, 0);
      const average = {
        listName
      };
      average[listName] = sum / ttiData.length;
      return average;
    });
    const ttiMetricData = Array.from(listTTIData.values()).flat();
    return _react.default.createElement(_react.default.Fragment, null, _react.default.createElement(_Header.default, null, "TTI Metric Averages"), _react.default.createElement(_recharts.BarChart, {
      width: 400,
      height: 400,
      data: averageData
    }, _react.default.createElement(_recharts.XAxis, {
      dataKey: "listName"
    }), _react.default.createElement(_recharts.YAxis, {
      tickFormatter: millis => {
        return `${millis} ms`;
      }
    }), _react.default.createElement(_recharts.Tooltip, null), listNames.map(listName => {
      return _react.default.createElement(_recharts.Bar, {
        dataKey: listName,
        key: listName,
        stackId: "a",
        fill: listColors.get(listName)
      });
    })), _react.default.createElement(_Header.default, null, "TTI Metric"), _react.default.createElement(_recharts.BarChart, {
      width: 400,
      height: 400,
      data: ttiMetricData
    }, _react.default.createElement(_recharts.XAxis, {
      dataKey: "listName"
    }), _react.default.createElement(_recharts.YAxis, {
      tickFormatter: millis => {
        return `${millis} ms`;
      }
    }), _react.default.createElement(_recharts.Tooltip, null), _react.default.createElement(_recharts.Bar, {
      dataKey: "TTI"
    }, ttiMetricData.map(data => {
      return _react.default.createElement(_recharts.Cell, {
        key: data.listName,
        fill: listColors.get(data.listName)
      });
    }))));
  };

  var _default = ListTTIChart;
  exports.default = _default;
},1,[2,577],"src/ListTTIChart.tsx");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "Area", {
    enumerable: true,
    get: function () {
      return _Area.Area;
    }
  });
  Object.defineProperty(exports, "AreaChart", {
    enumerable: true,
    get: function () {
      return _AreaChart.AreaChart;
    }
  });
  Object.defineProperty(exports, "Bar", {
    enumerable: true,
    get: function () {
      return _Bar.Bar;
    }
  });
  Object.defineProperty(exports, "BarChart", {
    enumerable: true,
    get: function () {
      return _BarChart.BarChart;
    }
  });
  Object.defineProperty(exports, "Brush", {
    enumerable: true,
    get: function () {
      return _Brush.Brush;
    }
  });
  Object.defineProperty(exports, "CartesianAxis", {
    enumerable: true,
    get: function () {
      return _CartesianAxis.CartesianAxis;
    }
  });
  Object.defineProperty(exports, "CartesianGrid", {
    enumerable: true,
    get: function () {
      return _CartesianGrid.CartesianGrid;
    }
  });
  Object.defineProperty(exports, "Cell", {
    enumerable: true,
    get: function () {
      return _Cell.Cell;
    }
  });
  Object.defineProperty(exports, "ComposedChart", {
    enumerable: true,
    get: function () {
      return _ComposedChart.ComposedChart;
    }
  });
  Object.defineProperty(exports, "Cross", {
    enumerable: true,
    get: function () {
      return _Cross.Cross;
    }
  });
  Object.defineProperty(exports, "Curve", {
    enumerable: true,
    get: function () {
      return _Curve.Curve;
    }
  });
  Object.defineProperty(exports, "Customized", {
    enumerable: true,
    get: function () {
      return _Customized.Customized;
    }
  });
  Object.defineProperty(exports, "Dot", {
    enumerable: true,
    get: function () {
      return _Dot.Dot;
    }
  });
  Object.defineProperty(exports, "ErrorBar", {
    enumerable: true,
    get: function () {
      return _ErrorBar.ErrorBar;
    }
  });
  Object.defineProperty(exports, "Funnel", {
    enumerable: true,
    get: function () {
      return _Funnel.Funnel;
    }
  });
  Object.defineProperty(exports, "FunnelChart", {
    enumerable: true,
    get: function () {
      return _FunnelChart.FunnelChart;
    }
  });
  Object.defineProperty(exports, "Global", {
    enumerable: true,
    get: function () {
      return _Global.Global;
    }
  });
  Object.defineProperty(exports, "Label", {
    enumerable: true,
    get: function () {
      return _Label.Label;
    }
  });
  Object.defineProperty(exports, "LabelList", {
    enumerable: true,
    get: function () {
      return _LabelList.LabelList;
    }
  });
  Object.defineProperty(exports, "Layer", {
    enumerable: true,
    get: function () {
      return _Layer.Layer;
    }
  });
  Object.defineProperty(exports, "Legend", {
    enumerable: true,
    get: function () {
      return _Legend.Legend;
    }
  });
  Object.defineProperty(exports, "Line", {
    enumerable: true,
    get: function () {
      return _Line.Line;
    }
  });
  Object.defineProperty(exports, "LineChart", {
    enumerable: true,
    get: function () {
      return _LineChart.LineChart;
    }
  });
  Object.defineProperty(exports, "Pie", {
    enumerable: true,
    get: function () {
      return _Pie.Pie;
    }
  });
  Object.defineProperty(exports, "PieChart", {
    enumerable: true,
    get: function () {
      return _PieChart.PieChart;
    }
  });
  Object.defineProperty(exports, "PolarAngleAxis", {
    enumerable: true,
    get: function () {
      return _PolarAngleAxis.PolarAngleAxis;
    }
  });
  Object.defineProperty(exports, "PolarGrid", {
    enumerable: true,
    get: function () {
      return _PolarGrid.PolarGrid;
    }
  });
  Object.defineProperty(exports, "PolarRadiusAxis", {
    enumerable: true,
    get: function () {
      return _PolarRadiusAxis.PolarRadiusAxis;
    }
  });
  Object.defineProperty(exports, "Polygon", {
    enumerable: true,
    get: function () {
      return _Polygon.Polygon;
    }
  });
  Object.defineProperty(exports, "Radar", {
    enumerable: true,
    get: function () {
      return _Radar.Radar;
    }
  });
  Object.defineProperty(exports, "RadarChart", {
    enumerable: true,
    get: function () {
      return _RadarChart.RadarChart;
    }
  });
  Object.defineProperty(exports, "RadialBar", {
    enumerable: true,
    get: function () {
      return _RadialBar.RadialBar;
    }
  });
  Object.defineProperty(exports, "RadialBarChart", {
    enumerable: true,
    get: function () {
      return _RadialBarChart.RadialBarChart;
    }
  });
  Object.defineProperty(exports, "Rectangle", {
    enumerable: true,
    get: function () {
      return _Rectangle.Rectangle;
    }
  });
  Object.defineProperty(exports, "ReferenceArea", {
    enumerable: true,
    get: function () {
      return _ReferenceArea.ReferenceArea;
    }
  });
  Object.defineProperty(exports, "ReferenceDot", {
    enumerable: true,
    get: function () {
      return _ReferenceDot.ReferenceDot;
    }
  });
  Object.defineProperty(exports, "ReferenceLine", {
    enumerable: true,
    get: function () {
      return _ReferenceLine.ReferenceLine;
    }
  });
  Object.defineProperty(exports, "ResponsiveContainer", {
    enumerable: true,
    get: function () {
      return _ResponsiveContainer.ResponsiveContainer;
    }
  });
  Object.defineProperty(exports, "Sankey", {
    enumerable: true,
    get: function () {
      return _Sankey.Sankey;
    }
  });
  Object.defineProperty(exports, "Scatter", {
    enumerable: true,
    get: function () {
      return _Scatter.Scatter;
    }
  });
  Object.defineProperty(exports, "ScatterChart", {
    enumerable: true,
    get: function () {
      return _ScatterChart.ScatterChart;
    }
  });
  Object.defineProperty(exports, "Sector", {
    enumerable: true,
    get: function () {
      return _Sector.Sector;
    }
  });
  Object.defineProperty(exports, "Surface", {
    enumerable: true,
    get: function () {
      return _Surface.Surface;
    }
  });
  Object.defineProperty(exports, "Symbols", {
    enumerable: true,
    get: function () {
      return _Symbols.Symbols;
    }
  });
  Object.defineProperty(exports, "Text", {
    enumerable: true,
    get: function () {
      return _Text.Text;
    }
  });
  Object.defineProperty(exports, "Tooltip", {
    enumerable: true,
    get: function () {
      return _Tooltip.Tooltip;
    }
  });
  Object.defineProperty(exports, "Trapezoid", {
    enumerable: true,
    get: function () {
      return _Trapezoid.Trapezoid;
    }
  });
  Object.defineProperty(exports, "Treemap", {
    enumerable: true,
    get: function () {
      return _Treemap.Treemap;
    }
  });
  Object.defineProperty(exports, "XAxis", {
    enumerable: true,
    get: function () {
      return _XAxis.XAxis;
    }
  });
  Object.defineProperty(exports, "YAxis", {
    enumerable: true,
    get: function () {
      return _YAxis.YAxis;
    }
  });
  Object.defineProperty(exports, "ZAxis", {
    enumerable: true,
    get: function () {
      return _ZAxis.ZAxis;
    }
  });

  var _Surface = _$$_REQUIRE(_dependencyMap[0], "./container/Surface");

  var _Layer = _$$_REQUIRE(_dependencyMap[1], "./container/Layer");

  var _Legend = _$$_REQUIRE(_dependencyMap[2], "./component/Legend");

  var _Tooltip = _$$_REQUIRE(_dependencyMap[3], "./component/Tooltip");

  var _ResponsiveContainer = _$$_REQUIRE(_dependencyMap[4], "./component/ResponsiveContainer");

  var _Cell = _$$_REQUIRE(_dependencyMap[5], "./component/Cell");

  var _Text = _$$_REQUIRE(_dependencyMap[6], "./component/Text");

  var _Label = _$$_REQUIRE(_dependencyMap[7], "./component/Label");

  var _LabelList = _$$_REQUIRE(_dependencyMap[8], "./component/LabelList");

  var _Customized = _$$_REQUIRE(_dependencyMap[9], "./component/Customized");

  var _Sector = _$$_REQUIRE(_dependencyMap[10], "./shape/Sector");

  var _Curve = _$$_REQUIRE(_dependencyMap[11], "./shape/Curve");

  var _Rectangle = _$$_REQUIRE(_dependencyMap[12], "./shape/Rectangle");

  var _Polygon = _$$_REQUIRE(_dependencyMap[13], "./shape/Polygon");

  var _Dot = _$$_REQUIRE(_dependencyMap[14], "./shape/Dot");

  var _Cross = _$$_REQUIRE(_dependencyMap[15], "./shape/Cross");

  var _Symbols = _$$_REQUIRE(_dependencyMap[16], "./shape/Symbols");

  var _PolarGrid = _$$_REQUIRE(_dependencyMap[17], "./polar/PolarGrid");

  var _PolarRadiusAxis = _$$_REQUIRE(_dependencyMap[18], "./polar/PolarRadiusAxis");

  var _PolarAngleAxis = _$$_REQUIRE(_dependencyMap[19], "./polar/PolarAngleAxis");

  var _Pie = _$$_REQUIRE(_dependencyMap[20], "./polar/Pie");

  var _Radar = _$$_REQUIRE(_dependencyMap[21], "./polar/Radar");

  var _RadialBar = _$$_REQUIRE(_dependencyMap[22], "./polar/RadialBar");

  var _Brush = _$$_REQUIRE(_dependencyMap[23], "./cartesian/Brush");

  var _ReferenceLine = _$$_REQUIRE(_dependencyMap[24], "./cartesian/ReferenceLine");

  var _ReferenceDot = _$$_REQUIRE(_dependencyMap[25], "./cartesian/ReferenceDot");

  var _ReferenceArea = _$$_REQUIRE(_dependencyMap[26], "./cartesian/ReferenceArea");

  var _CartesianAxis = _$$_REQUIRE(_dependencyMap[27], "./cartesian/CartesianAxis");

  var _CartesianGrid = _$$_REQUIRE(_dependencyMap[28], "./cartesian/CartesianGrid");

  var _Line = _$$_REQUIRE(_dependencyMap[29], "./cartesian/Line");

  var _Area = _$$_REQUIRE(_dependencyMap[30], "./cartesian/Area");

  var _Bar = _$$_REQUIRE(_dependencyMap[31], "./cartesian/Bar");

  var _Scatter = _$$_REQUIRE(_dependencyMap[32], "./cartesian/Scatter");

  var _XAxis = _$$_REQUIRE(_dependencyMap[33], "./cartesian/XAxis");

  var _YAxis = _$$_REQUIRE(_dependencyMap[34], "./cartesian/YAxis");

  var _ZAxis = _$$_REQUIRE(_dependencyMap[35], "./cartesian/ZAxis");

  var _ErrorBar = _$$_REQUIRE(_dependencyMap[36], "./cartesian/ErrorBar");

  var _LineChart = _$$_REQUIRE(_dependencyMap[37], "./chart/LineChart");

  var _BarChart = _$$_REQUIRE(_dependencyMap[38], "./chart/BarChart");

  var _PieChart = _$$_REQUIRE(_dependencyMap[39], "./chart/PieChart");

  var _Treemap = _$$_REQUIRE(_dependencyMap[40], "./chart/Treemap");

  var _Sankey = _$$_REQUIRE(_dependencyMap[41], "./chart/Sankey");

  var _RadarChart = _$$_REQUIRE(_dependencyMap[42], "./chart/RadarChart");

  var _ScatterChart = _$$_REQUIRE(_dependencyMap[43], "./chart/ScatterChart");

  var _AreaChart = _$$_REQUIRE(_dependencyMap[44], "./chart/AreaChart");

  var _RadialBarChart = _$$_REQUIRE(_dependencyMap[45], "./chart/RadialBarChart");

  var _ComposedChart = _$$_REQUIRE(_dependencyMap[46], "./chart/ComposedChart");

  var _Funnel = _$$_REQUIRE(_dependencyMap[47], "./numberAxis/Funnel");

  var _FunnelChart = _$$_REQUIRE(_dependencyMap[48], "./chart/FunnelChart");

  var _Trapezoid = _$$_REQUIRE(_dependencyMap[49], "./shape/Trapezoid");

  var _Global = _$$_REQUIRE(_dependencyMap[50], "./util/Global");
},2,[3,11,12,205,273,282,283,296,468,470,471,472,473,474,475,476,137,477,478,481,482,485,488,489,495,505,506,507,508,509,511,512,513,515,516,514,510,517,528,529,530,566,569,570,571,572,573,574,576,575,272],"../../node_modules/recharts/es6/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Surface = Surface;

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react"));

  var _classnames = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "classnames"));

  var _types = _$$_REQUIRE(_dependencyMap[2], "../util/types");

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};

    var target = _objectWithoutPropertiesLoose(source, excluded);

    var key, i;

    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }

    return target;
  }

  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }

  function Surface(props) {
    var children = props.children,
        width = props.width,
        height = props.height,
        viewBox = props.viewBox,
        className = props.className,
        style = props.style,
        others = _objectWithoutProperties(props, ["children", "width", "height", "viewBox", "className", "style"]);

    var svgView = viewBox || {
      width: width,
      height: height,
      x: 0,
      y: 0
    };
    var layerClass = (0, _classnames.default)('recharts-surface', className);
    return _react.default.createElement("svg", _extends({}, (0, _types.filterProps)(others, true, true), {
      className: layerClass,
      width: width,
      height: height,
      style: style,
      viewBox: "".concat(svgView.x, " ").concat(svgView.y, " ").concat(svgView.width, " ").concat(svgView.height),
      version: "1.1"
    }), children);
  }
},3,[4,8,9],"../../node_modules/recharts/es6/container/Surface.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react.development.js");
  }
},4,[5,7],"../../node_modules/react/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v17.0.2
   * react.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.
   */
  'use strict';

  var l = _$$_REQUIRE(_dependencyMap[0], "object-assign"),
      n = 60103,
      p = 60106;

  exports.Fragment = 60107;
  exports.StrictMode = 60108;
  exports.Profiler = 60114;
  var q = 60109,
      r = 60110,
      t = 60112;
  exports.Suspense = 60113;
  var u = 60115,
      v = 60116;

  if ("function" === typeof Symbol && Symbol.for) {
    var w = Symbol.for;
    n = w("react.element");
    p = w("react.portal");
    exports.Fragment = w("react.fragment");
    exports.StrictMode = w("react.strict_mode");
    exports.Profiler = w("react.profiler");
    q = w("react.provider");
    r = w("react.context");
    t = w("react.forward_ref");
    exports.Suspense = w("react.suspense");
    u = w("react.memo");
    v = w("react.lazy");
  }

  var x = "function" === typeof Symbol && Symbol.iterator;

  function y(a) {
    if (null === a || "object" !== typeof a) return null;
    a = x && a[x] || a["@@iterator"];
    return "function" === typeof a ? a : null;
  }

  function z(a) {
    for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length; c++) b += "&args[]=" + encodeURIComponent(arguments[c]);

    return "Minified React error #" + a + "; visit " + b + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
  }

  var A = {
    isMounted: function () {
      return !1;
    },
    enqueueForceUpdate: function () {},
    enqueueReplaceState: function () {},
    enqueueSetState: function () {}
  },
      B = {};

  function C(a, b, c) {
    this.props = a;
    this.context = b;
    this.refs = B;
    this.updater = c || A;
  }

  C.prototype.isReactComponent = {};

  C.prototype.setState = function (a, b) {
    if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error(z(85));
    this.updater.enqueueSetState(this, a, b, "setState");
  };

  C.prototype.forceUpdate = function (a) {
    this.updater.enqueueForceUpdate(this, a, "forceUpdate");
  };

  function D() {}

  D.prototype = C.prototype;

  function E(a, b, c) {
    this.props = a;
    this.context = b;
    this.refs = B;
    this.updater = c || A;
  }

  var F = E.prototype = new D();
  F.constructor = E;
  l(F, C.prototype);
  F.isPureReactComponent = !0;
  var G = {
    current: null
  },
      H = Object.prototype.hasOwnProperty,
      I = {
    key: !0,
    ref: !0,
    __self: !0,
    __source: !0
  };

  function J(a, b, c) {
    var e,
        d = {},
        k = null,
        h = null;
    if (null != b) for (e in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) H.call(b, e) && !I.hasOwnProperty(e) && (d[e] = b[e]);
    var g = arguments.length - 2;
    if (1 === g) d.children = c;else if (1 < g) {
      for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];

      d.children = f;
    }
    if (a && a.defaultProps) for (e in g = a.defaultProps, g) void 0 === d[e] && (d[e] = g[e]);
    return {
      $$typeof: n,
      type: a,
      key: k,
      ref: h,
      props: d,
      _owner: G.current
    };
  }

  function K(a, b) {
    return {
      $$typeof: n,
      type: a.type,
      key: b,
      ref: a.ref,
      props: a.props,
      _owner: a._owner
    };
  }

  function L(a) {
    return "object" === typeof a && null !== a && a.$$typeof === n;
  }

  function escape(a) {
    var b = {
      "=": "=0",
      ":": "=2"
    };
    return "$" + a.replace(/[=:]/g, function (a) {
      return b[a];
    });
  }

  var M = /\/+/g;

  function N(a, b) {
    return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
  }

  function O(a, b, c, e, d) {
    var k = typeof a;
    if ("undefined" === k || "boolean" === k) a = null;
    var h = !1;
    if (null === a) h = !0;else switch (k) {
      case "string":
      case "number":
        h = !0;
        break;

      case "object":
        switch (a.$$typeof) {
          case n:
          case p:
            h = !0;
        }

    }
    if (h) return h = a, d = d(h), a = "" === e ? "." + N(h, 0) : e, Array.isArray(d) ? (c = "", null != a && (c = a.replace(M, "$&/") + "/"), O(d, b, c, "", function (a) {
      return a;
    })) : null != d && (L(d) && (d = K(d, c + (!d.key || h && h.key === d.key ? "" : ("" + d.key).replace(M, "$&/") + "/") + a)), b.push(d)), 1;
    h = 0;
    e = "" === e ? "." : e + ":";
    if (Array.isArray(a)) for (var g = 0; g < a.length; g++) {
      k = a[g];
      var f = e + N(k, g);
      h += O(k, b, c, f, d);
    } else if (f = y(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = e + N(k, g++), h += O(k, b, c, f, d);else if ("object" === k) throw b = "" + a, Error(z(31, "[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b));
    return h;
  }

  function P(a, b, c) {
    if (null == a) return a;
    var e = [],
        d = 0;
    O(a, e, "", "", function (a) {
      return b.call(c, a, d++);
    });
    return e;
  }

  function Q(a) {
    if (-1 === a._status) {
      var b = a._result;
      b = b();
      a._status = 0;
      a._result = b;
      b.then(function (b) {
        0 === a._status && (b = b.default, a._status = 1, a._result = b);
      }, function (b) {
        0 === a._status && (a._status = 2, a._result = b);
      });
    }

    if (1 === a._status) return a._result;
    throw a._result;
  }

  var R = {
    current: null
  };

  function S() {
    var a = R.current;
    if (null === a) throw Error(z(321));
    return a;
  }

  var T = {
    ReactCurrentDispatcher: R,
    ReactCurrentBatchConfig: {
      transition: 0
    },
    ReactCurrentOwner: G,
    IsSomeRendererActing: {
      current: !1
    },
    assign: l
  };
  exports.Children = {
    map: P,
    forEach: function (a, b, c) {
      P(a, function () {
        b.apply(this, arguments);
      }, c);
    },
    count: function (a) {
      var b = 0;
      P(a, function () {
        b++;
      });
      return b;
    },
    toArray: function (a) {
      return P(a, function (a) {
        return a;
      }) || [];
    },
    only: function (a) {
      if (!L(a)) throw Error(z(143));
      return a;
    }
  };
  exports.Component = C;
  exports.PureComponent = E;
  exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = T;

  exports.cloneElement = function (a, b, c) {
    if (null === a || void 0 === a) throw Error(z(267, a));
    var e = l({}, a.props),
        d = a.key,
        k = a.ref,
        h = a._owner;

    if (null != b) {
      void 0 !== b.ref && (k = b.ref, h = G.current);
      void 0 !== b.key && (d = "" + b.key);
      if (a.type && a.type.defaultProps) var g = a.type.defaultProps;

      for (f in b) H.call(b, f) && !I.hasOwnProperty(f) && (e[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
    }

    var f = arguments.length - 2;
    if (1 === f) e.children = c;else if (1 < f) {
      g = Array(f);

      for (var m = 0; m < f; m++) g[m] = arguments[m + 2];

      e.children = g;
    }
    return {
      $$typeof: n,
      type: a.type,
      key: d,
      ref: k,
      props: e,
      _owner: h
    };
  };

  exports.createContext = function (a, b) {
    void 0 === b && (b = null);
    a = {
      $$typeof: r,
      _calculateChangedBits: b,
      _currentValue: a,
      _currentValue2: a,
      _threadCount: 0,
      Provider: null,
      Consumer: null
    };
    a.Provider = {
      $$typeof: q,
      _context: a
    };
    return a.Consumer = a;
  };

  exports.createElement = J;

  expo