@hero-design/rn 7.6.1-alpha → 7.7.0

package/es/index.js

@@ -1,9 +1,7 @@
-import * as reactNative from 'react-native';
-import { Dimensions, StyleSheet as StyleSheet$1, Text as Text$1, View, TouchableOpacity, Image, Animated, Platform, TouchableWithoutFeedback, Pressable, Easing, Modal, TouchableHighlight, TextInput as TextInput$1, FlatList } from 'react-native';
-import React, { createContext, useContext, createElement, forwardRef, useRef, useEffect, useState, useCallback } from 'react';
-import { createIconSetFromIcoMoon } from 'react-native-vector-icons';
+import * as ReactNative from 'react-native';
+import ReactNative__default, { Dimensions, StyleSheet as StyleSheet$1, Text as Text$1, View, TouchableOpacity, Image, Animated, Platform, TouchableWithoutFeedback, Pressable, Easing, Modal, TouchableHighlight, TextInput as TextInput$1, requireNativeComponent, UIManager, I18nManager, Keyboard, FlatList, LayoutAnimation } from 'react-native';
+import React, { createContext, useContext, createElement, forwardRef, useRef, useEffect, useState, useCallback, Children, useLayoutEffect, useImperativeHandle, useMemo } from 'react';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
-import PagerView from 'react-native-pager-view';
 
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
@@ -22,7 +20,7 @@ function _objectSpread2(target) {
   for (var i = 1; i < arguments.length; i++) {
     var source = null != arguments[i] ? arguments[i] : {};
     i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
-      _defineProperty(target, key, source[key]);
+      _defineProperty$2(target, key, source[key]);
     }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
       Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
     });
@@ -31,17 +29,42 @@ function _objectSpread2(target) {
   return target;
 }
 
-function _typeof(obj) {
+function _typeof$2(obj) {
   "@babel/helpers - typeof";
 
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+  return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
     return typeof obj;
   } : function (obj) {
     return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-  }, _typeof(obj);
+  }, _typeof$2(obj);
 }
 
-function _defineProperty(obj, key, value) {
+function _classCallCheck$1(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties$1(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);
+  }
+}
+
+function _createClass$1(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties$1(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _defineProperty$2(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value: value,
@@ -56,8 +79,8 @@ function _defineProperty(obj, key, value) {
   return obj;
 }
 
-function _extends$1() {
-  _extends$1 = Object.assign || function (target) {
+function _extends$3() {
+  _extends$3 = Object.assign || function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
 
@@ -71,10 +94,57 @@ function _extends$1() {
     return target;
   };
 
-  return _extends$1.apply(this, arguments);
+  return _extends$3.apply(this, arguments);
 }
 
-function _objectWithoutPropertiesLoose(source, excluded) {
+function _inherits$1(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
+  if (superClass) _setPrototypeOf$1(subClass, superClass);
+}
+
+function _getPrototypeOf$1(o) {
+  _getPrototypeOf$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf$1(o);
+}
+
+function _setPrototypeOf$1(o, p) {
+  _setPrototypeOf$1 = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf$1(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _objectWithoutPropertiesLoose$1(source, excluded) {
   if (source == null) return {};
   var target = {};
   var sourceKeys = Object.keys(source);
@@ -89,10 +159,10 @@ function _objectWithoutPropertiesLoose(source, excluded) {
   return target;
 }
 
-function _objectWithoutProperties(source, excluded) {
+function _objectWithoutProperties$1(source, excluded) {
   if (source == null) return {};
 
-  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var target = _objectWithoutPropertiesLoose$1(source, excluded);
 
   var key, i;
 
@@ -110,15 +180,52 @@ function _objectWithoutProperties(source, excluded) {
   return target;
 }
 
+function _assertThisInitialized$1(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _possibleConstructorReturn$1(self, call) {
+  if (call && (typeof call === "object" || typeof call === "function")) {
+    return call;
+  } else if (call !== void 0) {
+    throw new TypeError("Derived constructors may only return object or undefined");
+  }
+
+  return _assertThisInitialized$1(self);
+}
+
+function _createSuper(Derived) {
+  var hasNativeReflectConstruct = _isNativeReflectConstruct();
+
+  return function _createSuperInternal() {
+    var Super = _getPrototypeOf$1(Derived),
+        result;
+
+    if (hasNativeReflectConstruct) {
+      var NewTarget = _getPrototypeOf$1(this).constructor;
+
+      result = Reflect.construct(Super, arguments, NewTarget);
+    } else {
+      result = Super.apply(this, arguments);
+    }
+
+    return _possibleConstructorReturn$1(this, result);
+  };
+}
+
 function _slicedToArray(arr, i) {
   return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
 }
 
-function _toConsumableArray(arr) {
-  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+function _toConsumableArray$1(arr) {
+  return _arrayWithoutHoles$1(arr) || _iterableToArray$1(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread$1();
 }
 
-function _arrayWithoutHoles(arr) {
+function _arrayWithoutHoles$1(arr) {
   if (Array.isArray(arr)) return _arrayLikeToArray(arr);
 }
 
@@ -126,7 +233,7 @@ function _arrayWithHoles(arr) {
   if (Array.isArray(arr)) return arr;
 }
 
-function _iterableToArray(iter) {
+function _iterableToArray$1(iter) {
   if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 
@@ -177,7 +284,7 @@ function _arrayLikeToArray(arr, len) {
   return arr2;
 }
 
-function _nonIterableSpread() {
+function _nonIterableSpread$1() {
   throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
@@ -1424,8 +1531,8 @@ var createCache = function createCache(options) {
   return cache;
 };
 
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
+function _extends$2() {
+  _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
     for (var i = 1; i < arguments.length; i++) {
       var source = arguments[i];
 
@@ -1438,7 +1545,7 @@ function _extends() {
 
     return target;
   };
-  return _extends.apply(this, arguments);
+  return _extends$2.apply(this, arguments);
 }
 
 var EmotionCacheContext = /* #__PURE__ */createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
@@ -1466,7 +1573,7 @@ var getTheme$1 = function getTheme(outerTheme, theme) {
     return mergedTheme;
   }
 
-  return _extends({}, outerTheme, theme);
+  return _extends$2({}, outerTheme, theme);
 };
 
 var createCacheWithTheme = /* #__PURE__ */weakMemoize(function (outerTheme) {
@@ -1962,6 +2069,35 @@ var getCardTheme = function getCardTheme(theme) {
   };
 };
 
+var getCheckboxTheme = function getCheckboxTheme(theme) {
+  var colors = {
+    borderColor: theme.colors.primary,
+    text: theme.colors.invertedText,
+    disabled: theme.colors.inactiveBackground
+  };
+  var space = {
+    // to remove the empty space above the check icon
+    // and also to center the check mark
+    iconTop: -theme.space.xsmall
+  };
+  var sizes = {
+    base: theme.space.large
+  };
+  var radii = {
+    base: theme.radii.base
+  };
+  var borderWidths = {
+    "default": theme.borderWidths.medium
+  };
+  return {
+    colors: colors,
+    space: space,
+    sizes: sizes,
+    radii: radii,
+    borderWidths: borderWidths
+  };
+};
+
 var getContentNavigatorTheme = function getContentNavigatorTheme(theme) {
   var space = {
     valueHorizontalPadding: theme.space.small
@@ -2192,235 +2328,2230 @@ var getSelectTheme = function getSelectTheme(theme) {
   };
 };
 
-var getSpinnerTheme = function getSpinnerTheme(theme) {
-  var color = {
-    "default": theme.colors.primary
-  };
-  var space = {
-    spinnerDot: theme.space.medium,
-    spinnerDotPadding: theme.space.small,
-    spinnerTextPaddingTop: theme.space.small
-  };
-  var radii = {
-    "default": theme.radii.medium
-  };
-  return {
-    color: color,
-    space: space,
-    radii: radii
-  };
-};
+var getSpinnerTheme = function getSpinnerTheme(theme) {
+  var color = {
+    "default": theme.colors.primary
+  };
+  var space = {
+    spinnerDot: theme.space.medium,
+    spinnerDotPadding: theme.space.small,
+    spinnerTextPaddingTop: theme.space.small
+  };
+  var radii = {
+    "default": theme.radii.medium
+  };
+  return {
+    color: color,
+    space: space,
+    radii: radii
+  };
+};
+
+var getSwitchTheme = function getSwitchTheme(theme) {
+  var colors = {
+    thumb: theme.colors.platformBackground,
+    active: theme.colors.primary,
+    inactive: theme.colors.inactiveBackground
+  };
+  var thumbSizes = {
+    small: theme.space.medium,
+    medium: theme.space.medium * 1.3
+  };
+  var widths = {
+    small: theme.space.xxxlarge,
+    medium: theme.space.xxxxlarge
+  };
+  var heights = {
+    small: theme.space.large,
+    medium: theme.space.large * 1.2
+  };
+  var spaces = {
+    small: theme.space.xsmall,
+    medium: theme.space.xsmall,
+    inactive: 0
+  };
+  var radii = {
+    rounded: theme.radii.rounded
+  };
+  var borderWidths = {
+    "default": theme.borderWidths.base
+  };
+  return {
+    colors: colors,
+    thumbSizes: thumbSizes,
+    widths: widths,
+    heights: heights,
+    spaces: spaces,
+    radii: radii,
+    borderWidths: borderWidths
+  };
+};
+
+var getTabsTheme = function getTabsTheme(theme) {
+  var colors = {
+    active: theme.colors.primary,
+    inactive: theme.colors.text,
+    activeBackground: theme.colors.primaryBackground,
+    headerBottom: theme.colors.outline,
+    text: theme.colors.text
+  };
+  var space = {
+    flatListHorizontalPadding: theme.space.small,
+    itemHorizontalPadding: theme.space.small,
+    itemVerticalPadding: theme.space.small,
+    outlineHorizontalPadding: theme.space.small,
+    outlineVerticalPadding: theme.space.xsmall
+  };
+  var radii = {
+    outline: theme.radii.medium
+  };
+  var borderWidths = {
+    headerBottom: theme.borderWidths.base
+  };
+  var sizes = {
+    indicator: theme.space.xxsmall
+  };
+  return {
+    borderWidths: borderWidths,
+    colors: colors,
+    space: space,
+    radii: radii,
+    sizes: sizes
+  };
+};
+
+var getTagTheme = function getTagTheme(theme) {
+  var borderWidths = {
+    "default": theme.borderWidths.base
+  };
+  var colors = {
+    danger: theme.colors.danger,
+    dangerBackground: theme.colors.dangerBackground,
+    info: theme.colors.info,
+    infoBackground: theme.colors.infoBackground,
+    success: theme.colors.successDark,
+    successBackground: theme.colors.successBackground,
+    warning: theme.colors.warningDark,
+    warningBackground: theme.colors.warningBackground
+  };
+  var fonts = {
+    "default": theme.fonts.semiBold
+  };
+  var fontSizes = {
+    "default": theme.fontSizes.small
+  };
+  var space = {
+    horizontalPadding: theme.space.small,
+    verticalPadding: theme.space.xxsmall
+  };
+  var radii = {
+    "default": theme.radii.base
+  };
+  return {
+    borderWidths: borderWidths,
+    colors: colors,
+    fonts: fonts,
+    fontSizes: fontSizes,
+    space: space,
+    radii: radii
+  };
+};
+
+var getTextInputTheme = function getTextInputTheme(theme) {
+  var colors = {
+    labelBackground: theme.colors.platformBackground,
+    border: theme.colors.text
+  };
+  var space = {
+    containerPadding: theme.space.medium,
+    labelLeft: theme.space.medium,
+    labelTop: theme.lineHeights.small / -2,
+    labelHorizontalPadding: theme.space.xsmall,
+    inputHorizontalMargin: theme.space.small
+  };
+  var fontSizes = {
+    text: theme.fontSizes.large
+  };
+  var borderWidths = {
+    container: theme.borderWidths.base
+  };
+  var radii = {
+    container: theme.radii.medium
+  };
+  return {
+    colors: colors,
+    space: space,
+    fontSizes: fontSizes,
+    borderWidths: borderWidths,
+    radii: radii
+  };
+};
+
+var getToastTheme = function getToastTheme(theme) {
+  var colors = {
+    success: theme.colors.success,
+    warning: theme.colors.warning,
+    error: theme.colors.danger,
+    info: theme.colors.infoMediumLight,
+    divider: theme.colors.backgroundLight
+  };
+  var sizes = {
+    height: scale(48)
+  };
+  var space = {
+    mediumPadding: theme.space.medium,
+    largePadding: theme.space.large
+  };
+  var radii = {
+    "default": theme.radii.xlarge
+  };
+  var borderWidths = {
+    base: theme.borderWidths.base
+  };
+  return {
+    colors: colors,
+    radii: radii,
+    sizes: sizes,
+    space: space,
+    borderWidths: borderWidths
+  };
+};
+
+var getTypographyTheme = function getTypographyTheme(theme) {
+  var colors = {
+    body: theme.colors.text,
+    subdued: theme.colors.disabledText,
+    primary: theme.colors.primary
+  };
+  var fonts = {
+    light: theme.fonts.light,
+    regular: theme.fonts.regular,
+    semiBold: theme.fonts.semiBold
+  };
+  var fontSizes = {
+    small: theme.fontSizes.small,
+    medium: theme.fontSizes.medium,
+    large: theme.fontSizes.large,
+    xlarge: theme.fontSizes.xlarge
+  };
+  var lineHeights = {
+    small: theme.lineHeights.small,
+    medium: theme.lineHeights.medium,
+    large: theme.lineHeights.large,
+    xlarge: theme.lineHeights.xlarge
+  };
+  return {
+    colors: colors,
+    fonts: fonts,
+    fontSizes: fontSizes,
+    lineHeights: lineHeights
+  };
+};
+
+var getTheme = function getTheme() {
+  var scale = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scale$1;
+  var systemPallete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : systemPalette;
+  var globalTheme = getGlobalTheme(scale, systemPallete);
+  return _objectSpread2(_objectSpread2({}, globalTheme), {}, {
+    __hd__: {
+      avatar: getAvatarTheme(globalTheme),
+      alert: getAlertTheme(globalTheme),
+      badge: getBadgeTheme(globalTheme),
+      bottomNavigation: getBottomNavigationTheme(globalTheme),
+      bottomSheet: getBottomSheetTheme(globalTheme),
+      button: getButtonTheme(globalTheme),
+      card: getCardTheme(globalTheme),
+      checkbox: getCheckboxTheme(globalTheme),
+      contentNavigator: getContentNavigatorTheme(globalTheme),
+      divider: getDividerTheme(globalTheme),
+      drawer: getDrawerTheme(globalTheme),
+      fab: getFABTheme(globalTheme),
+      icon: getIconTheme(globalTheme),
+      progress: getProgressTheme(globalTheme),
+      radio: getRadioTheme(globalTheme),
+      sectionHeading: getSectionHeadingTheme(globalTheme),
+      select: getSelectTheme(globalTheme),
+      spinner: getSpinnerTheme(globalTheme),
+      "switch": getSwitchTheme(globalTheme),
+      tabs: getTabsTheme(globalTheme),
+      tag: getTagTheme(globalTheme),
+      textInput: getTextInputTheme(globalTheme),
+      toast: getToastTheme(globalTheme),
+      typography: getTypographyTheme(globalTheme)
+    }
+  });
+};
+
+var theme = getTheme();
+var ThemeProvider = ThemeProvider$1;
+var useTheme = useTheme$1;
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var dist = {};
+
+function _interopRequireDefault$5(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+
+var interopRequireDefault = _interopRequireDefault$5;
+
+var createIconSet$1 = {};
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+var arrayWithoutHoles$1 = _arrayWithoutHoles;
+
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+var iterableToArray$1 = _iterableToArray;
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+var nonIterableSpread$1 = _nonIterableSpread;
+
+var arrayWithoutHoles = arrayWithoutHoles$1;
+var iterableToArray = iterableToArray$1;
+var nonIterableSpread = nonIterableSpread$1;
+
+function _toConsumableArray(arr) {
+  return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
+}
+
+var toConsumableArray = _toConsumableArray;
+
+var runtime = {exports: {}};
+
+(function (module) {
+  var runtime = function (exports) {
+
+    var Op = Object.prototype;
+    var hasOwn = Op.hasOwnProperty;
+    var undefined$1; // More compressible than void 0.
+
+    var $Symbol = typeof Symbol === "function" ? Symbol : {};
+    var iteratorSymbol = $Symbol.iterator || "@@iterator";
+    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+    function wrap(innerFn, outerFn, self, tryLocsList) {
+      // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+      var generator = Object.create(protoGenerator.prototype);
+      var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,
+      // .throw, and .return methods.
+
+      generator._invoke = makeInvokeMethod(innerFn, self, context);
+      return generator;
+    }
+
+    exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion
+    // record like context.tryEntries[i].completion. This interface could
+    // have been (and was previously) designed to take a closure to be
+    // invoked without arguments, but in all the cases we care about we
+    // already have an existing method we want to call, so there's no need
+    // to create a new function object. We can even get away with assuming
+    // the method takes exactly one argument, since that happens to be true
+    // in every case, so we don't have to touch the arguments object. The
+    // only additional allocation required is the completion record, which
+    // has a stable shape and so hopefully should be cheap to allocate.
+
+    function tryCatch(fn, obj, arg) {
+      try {
+        return {
+          type: "normal",
+          arg: fn.call(obj, arg)
+        };
+      } catch (err) {
+        return {
+          type: "throw",
+          arg: err
+        };
+      }
+    }
+
+    var GenStateSuspendedStart = "suspendedStart";
+    var GenStateSuspendedYield = "suspendedYield";
+    var GenStateExecuting = "executing";
+    var GenStateCompleted = "completed"; // Returning this object from the innerFn has the same effect as
+    // breaking out of the dispatch switch statement.
+
+    var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and
+    // .constructor.prototype properties for functions that return Generator
+    // objects. For full spec compliance, you may wish to configure your
+    // minifier not to mangle the names of these two functions.
+
+    function Generator() {}
+
+    function GeneratorFunction() {}
+
+    function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that
+    // don't natively support it.
+
+
+    var IteratorPrototype = {};
+
+    IteratorPrototype[iteratorSymbol] = function () {
+      return this;
+    };
+
+    var getProto = Object.getPrototypeOf;
+    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+
+    if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+      // This environment has a native %IteratorPrototype%; use it instead
+      // of the polyfill.
+      IteratorPrototype = NativeIteratorPrototype;
+    }
+
+    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
+    GeneratorFunctionPrototype.constructor = GeneratorFunction;
+    GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction"; // Helper for defining the .next, .throw, and .return methods of the
+    // Iterator interface in terms of a single ._invoke method.
+
+    function defineIteratorMethods(prototype) {
+      ["next", "throw", "return"].forEach(function (method) {
+        prototype[method] = function (arg) {
+          return this._invoke(method, arg);
+        };
+      });
+    }
+
+    exports.isGeneratorFunction = function (genFun) {
+      var ctor = typeof genFun === "function" && genFun.constructor;
+      return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
+      // do is to check its .name property.
+      (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+    };
+
+    exports.mark = function (genFun) {
+      if (Object.setPrototypeOf) {
+        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+      } else {
+        genFun.__proto__ = GeneratorFunctionPrototype;
+
+        if (!(toStringTagSymbol in genFun)) {
+          genFun[toStringTagSymbol] = "GeneratorFunction";
+        }
+      }
+
+      genFun.prototype = Object.create(Gp);
+      return genFun;
+    }; // Within the body of any async function, `await x` is transformed to
+    // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+    // `hasOwn.call(value, "__await")` to determine if the yielded value is
+    // meant to be awaited.
+
+
+    exports.awrap = function (arg) {
+      return {
+        __await: arg
+      };
+    };
+
+    function AsyncIterator(generator) {
+      function invoke(method, arg, resolve, reject) {
+        var record = tryCatch(generator[method], generator, arg);
+
+        if (record.type === "throw") {
+          reject(record.arg);
+        } else {
+          var result = record.arg;
+          var value = result.value;
+
+          if (value && _typeof$2(value) === "object" && hasOwn.call(value, "__await")) {
+            return Promise.resolve(value.__await).then(function (value) {
+              invoke("next", value, resolve, reject);
+            }, function (err) {
+              invoke("throw", err, resolve, reject);
+            });
+          }
+
+          return Promise.resolve(value).then(function (unwrapped) {
+            // When a yielded Promise is resolved, its final value becomes
+            // the .value of the Promise<{value,done}> result for the
+            // current iteration.
+            result.value = unwrapped;
+            resolve(result);
+          }, function (error) {
+            // If a rejected Promise was yielded, throw the rejection back
+            // into the async generator function so it can be handled there.
+            return invoke("throw", error, resolve, reject);
+          });
+        }
+      }
+
+      var previousPromise;
+
+      function enqueue(method, arg) {
+        function callInvokeWithMethodAndArg() {
+          return new Promise(function (resolve, reject) {
+            invoke(method, arg, resolve, reject);
+          });
+        }
+
+        return previousPromise = // If enqueue has been called before, then we want to wait until
+        // all previous Promises have been resolved before calling invoke,
+        // so that results are always delivered in the correct order. If
+        // enqueue has not been called before, then it is important to
+        // call invoke immediately, without waiting on a callback to fire,
+        // so that the async generator function has the opportunity to do
+        // any necessary setup in a predictable way. This predictability
+        // is why the Promise constructor synchronously invokes its
+        // executor callback, and why async functions synchronously
+        // execute code before the first await. Since we implement simple
+        // async functions in terms of async generators, it is especially
+        // important to get this right, even though it requires care.
+        previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later
+        // invocations of the iterator.
+        callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      } // Define the unified helper method that is used to implement .next,
+      // .throw, and .return (see defineIteratorMethods).
+
+
+      this._invoke = enqueue;
+    }
+
+    defineIteratorMethods(AsyncIterator.prototype);
+
+    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
+      return this;
+    };
+
+    exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of
+    // AsyncIterator objects; they just return a Promise for the value of
+    // the final result produced by the iterator.
+
+    exports.async = function (innerFn, outerFn, self, tryLocsList) {
+      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
+      return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.
+      : iter.next().then(function (result) {
+        return result.done ? result.value : iter.next();
+      });
+    };
+
+    function makeInvokeMethod(innerFn, self, context) {
+      var state = GenStateSuspendedStart;
+      return function invoke(method, arg) {
+        if (state === GenStateExecuting) {
+          throw new Error("Generator is already running");
+        }
+
+        if (state === GenStateCompleted) {
+          if (method === "throw") {
+            throw arg;
+          } // Be forgiving, per 25.3.3.3.3 of the spec:
+          // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+
+
+          return doneResult();
+        }
+
+        context.method = method;
+        context.arg = arg;
+
+        while (true) {
+          var delegate = context.delegate;
+
+          if (delegate) {
+            var delegateResult = maybeInvokeDelegate(delegate, context);
+
+            if (delegateResult) {
+              if (delegateResult === ContinueSentinel) continue;
+              return delegateResult;
+            }
+          }
+
+          if (context.method === "next") {
+            // Setting context._sent for legacy support of Babel's
+            // function.sent implementation.
+            context.sent = context._sent = context.arg;
+          } else if (context.method === "throw") {
+            if (state === GenStateSuspendedStart) {
+              state = GenStateCompleted;
+              throw context.arg;
+            }
+
+            context.dispatchException(context.arg);
+          } else if (context.method === "return") {
+            context.abrupt("return", context.arg);
+          }
+
+          state = GenStateExecuting;
+          var record = tryCatch(innerFn, self, context);
+
+          if (record.type === "normal") {
+            // If an exception is thrown from innerFn, we leave state ===
+            // GenStateExecuting and loop back for another invocation.
+            state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+
+            if (record.arg === ContinueSentinel) {
+              continue;
+            }
+
+            return {
+              value: record.arg,
+              done: context.done
+            };
+          } else if (record.type === "throw") {
+            state = GenStateCompleted; // Dispatch the exception by looping back around to the
+            // context.dispatchException(context.arg) call above.
+
+            context.method = "throw";
+            context.arg = record.arg;
+          }
+        }
+      };
+    } // Call delegate.iterator[context.method](context.arg) and handle the
+    // result, either by returning a { value, done } result from the
+    // delegate iterator, or by modifying context.method and context.arg,
+    // setting context.delegate to null, and returning the ContinueSentinel.
+
+
+    function maybeInvokeDelegate(delegate, context) {
+      var method = delegate.iterator[context.method];
+
+      if (method === undefined$1) {
+        // A .throw or .return when the delegate iterator has no .throw
+        // method always terminates the yield* loop.
+        context.delegate = null;
+
+        if (context.method === "throw") {
+          // Note: ["return"] must be used for ES3 parsing compatibility.
+          if (delegate.iterator["return"]) {
+            // If the delegate iterator has a return method, give it a
+            // chance to clean up.
+            context.method = "return";
+            context.arg = undefined$1;
+            maybeInvokeDelegate(delegate, context);
+
+            if (context.method === "throw") {
+              // If maybeInvokeDelegate(context) changed context.method from
+              // "return" to "throw", let that override the TypeError below.
+              return ContinueSentinel;
+            }
+          }
+
+          context.method = "throw";
+          context.arg = new TypeError("The iterator does not provide a 'throw' method");
+        }
+
+        return ContinueSentinel;
+      }
+
+      var record = tryCatch(method, delegate.iterator, context.arg);
+
+      if (record.type === "throw") {
+        context.method = "throw";
+        context.arg = record.arg;
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+
+      var info = record.arg;
+
+      if (!info) {
+        context.method = "throw";
+        context.arg = new TypeError("iterator result is not an object");
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+
+      if (info.done) {
+        // Assign the result of the finished delegate to the temporary
+        // variable specified by delegate.resultName (see delegateYield).
+        context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).
+
+        context.next = delegate.nextLoc; // If context.method was "throw" but the delegate handled the
+        // exception, let the outer generator proceed normally. If
+        // context.method was "next", forget context.arg since it has been
+        // "consumed" by the delegate iterator. If context.method was
+        // "return", allow the original .return call to continue in the
+        // outer generator.
+
+        if (context.method !== "return") {
+          context.method = "next";
+          context.arg = undefined$1;
+        }
+      } else {
+        // Re-yield the result returned by the delegate method.
+        return info;
+      } // The delegate iterator is finished, so forget it and continue with
+      // the outer generator.
+
+
+      context.delegate = null;
+      return ContinueSentinel;
+    } // Define Generator.prototype.{next,throw,return} in terms of the
+    // unified ._invoke helper method.
+
+
+    defineIteratorMethods(Gp);
+    Gp[toStringTagSymbol] = "Generator"; // A Generator should always return itself as the iterator object when the
+    // @@iterator function is called on it. Some browsers' implementations of the
+    // iterator prototype chain incorrectly implement this, causing the Generator
+    // object to not be returned from this call. This ensures that doesn't happen.
+    // See https://github.com/facebook/regenerator/issues/274 for more details.
+
+    Gp[iteratorSymbol] = function () {
+      return this;
+    };
+
+    Gp.toString = function () {
+      return "[object Generator]";
+    };
+
+    function pushTryEntry(locs) {
+      var entry = {
+        tryLoc: locs[0]
+      };
+
+      if (1 in locs) {
+        entry.catchLoc = locs[1];
+      }
+
+      if (2 in locs) {
+        entry.finallyLoc = locs[2];
+        entry.afterLoc = locs[3];
+      }
+
+      this.tryEntries.push(entry);
+    }
+
+    function resetTryEntry(entry) {
+      var record = entry.completion || {};
+      record.type = "normal";
+      delete record.arg;
+      entry.completion = record;
+    }
+
+    function Context(tryLocsList) {
+      // The root entry object (effectively a try statement without a catch
+      // or a finally block) gives us a place to store values thrown from
+      // locations where there is no enclosing try statement.
+      this.tryEntries = [{
+        tryLoc: "root"
+      }];
+      tryLocsList.forEach(pushTryEntry, this);
+      this.reset(true);
+    }
+
+    exports.keys = function (object) {
+      var keys = [];
+
+      for (var key in object) {
+        keys.push(key);
+      }
+
+      keys.reverse(); // Rather than returning an object with a next method, we keep
+      // things simple and return the next function itself.
+
+      return function next() {
+        while (keys.length) {
+          var key = keys.pop();
+
+          if (key in object) {
+            next.value = key;
+            next.done = false;
+            return next;
+          }
+        } // To avoid creating an additional object, we just hang the .value
+        // and .done properties off the next function object itself. This
+        // also ensures that the minifier will not anonymize the function.
+
+
+        next.done = true;
+        return next;
+      };
+    };
+
+    function values(iterable) {
+      if (iterable) {
+        var iteratorMethod = iterable[iteratorSymbol];
+
+        if (iteratorMethod) {
+          return iteratorMethod.call(iterable);
+        }
+
+        if (typeof iterable.next === "function") {
+          return iterable;
+        }
+
+        if (!isNaN(iterable.length)) {
+          var i = -1,
+              next = function next() {
+            while (++i < iterable.length) {
+              if (hasOwn.call(iterable, i)) {
+                next.value = iterable[i];
+                next.done = false;
+                return next;
+              }
+            }
+
+            next.value = undefined$1;
+            next.done = true;
+            return next;
+          };
+
+          return next.next = next;
+        }
+      } // Return an iterator with no values.
+
+
+      return {
+        next: doneResult
+      };
+    }
+
+    exports.values = values;
+
+    function doneResult() {
+      return {
+        value: undefined$1,
+        done: true
+      };
+    }
+
+    Context.prototype = {
+      constructor: Context,
+      reset: function reset(skipTempReset) {
+        this.prev = 0;
+        this.next = 0; // Resetting context._sent for legacy support of Babel's
+        // function.sent implementation.
+
+        this.sent = this._sent = undefined$1;
+        this.done = false;
+        this.delegate = null;
+        this.method = "next";
+        this.arg = undefined$1;
+        this.tryEntries.forEach(resetTryEntry);
+
+        if (!skipTempReset) {
+          for (var name in this) {
+            // Not sure about the optimal order of these conditions:
+            if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+              this[name] = undefined$1;
+            }
+          }
+        }
+      },
+      stop: function stop() {
+        this.done = true;
+        var rootEntry = this.tryEntries[0];
+        var rootRecord = rootEntry.completion;
+
+        if (rootRecord.type === "throw") {
+          throw rootRecord.arg;
+        }
+
+        return this.rval;
+      },
+      dispatchException: function dispatchException(exception) {
+        if (this.done) {
+          throw exception;
+        }
+
+        var context = this;
+
+        function handle(loc, caught) {
+          record.type = "throw";
+          record.arg = exception;
+          context.next = loc;
+
+          if (caught) {
+            // If the dispatched exception was caught by a catch block,
+            // then let that catch block handle the exception normally.
+            context.method = "next";
+            context.arg = undefined$1;
+          }
+
+          return !!caught;
+        }
+
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+          var record = entry.completion;
+
+          if (entry.tryLoc === "root") {
+            // Exception thrown outside of any try block that could handle
+            // it, so set the completion value of the entire function to
+            // throw the exception.
+            return handle("end");
+          }
+
+          if (entry.tryLoc <= this.prev) {
+            var hasCatch = hasOwn.call(entry, "catchLoc");
+            var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+            if (hasCatch && hasFinally) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              } else if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else if (hasCatch) {
+              if (this.prev < entry.catchLoc) {
+                return handle(entry.catchLoc, true);
+              }
+            } else if (hasFinally) {
+              if (this.prev < entry.finallyLoc) {
+                return handle(entry.finallyLoc);
+              }
+            } else {
+              throw new Error("try statement without catch or finally");
+            }
+          }
+        }
+      },
+      abrupt: function abrupt(type, arg) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+
+          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+            var finallyEntry = entry;
+            break;
+          }
+        }
+
+        if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+          // Ignore the finally entry if control is not jumping to a
+          // location outside the try/catch block.
+          finallyEntry = null;
+        }
+
+        var record = finallyEntry ? finallyEntry.completion : {};
+        record.type = type;
+        record.arg = arg;
+
+        if (finallyEntry) {
+          this.method = "next";
+          this.next = finallyEntry.finallyLoc;
+          return ContinueSentinel;
+        }
+
+        return this.complete(record);
+      },
+      complete: function complete(record, afterLoc) {
+        if (record.type === "throw") {
+          throw record.arg;
+        }
+
+        if (record.type === "break" || record.type === "continue") {
+          this.next = record.arg;
+        } else if (record.type === "return") {
+          this.rval = this.arg = record.arg;
+          this.method = "return";
+          this.next = "end";
+        } else if (record.type === "normal" && afterLoc) {
+          this.next = afterLoc;
+        }
+
+        return ContinueSentinel;
+      },
+      finish: function finish(finallyLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+
+          if (entry.finallyLoc === finallyLoc) {
+            this.complete(entry.completion, entry.afterLoc);
+            resetTryEntry(entry);
+            return ContinueSentinel;
+          }
+        }
+      },
+      "catch": function _catch(tryLoc) {
+        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+          var entry = this.tryEntries[i];
+
+          if (entry.tryLoc === tryLoc) {
+            var record = entry.completion;
+
+            if (record.type === "throw") {
+              var thrown = record.arg;
+              resetTryEntry(entry);
+            }
+
+            return thrown;
+          }
+        } // The context.catch method must only be called with a location
+        // argument that corresponds to a known catch block.
+
+
+        throw new Error("illegal catch attempt");
+      },
+      delegateYield: function delegateYield(iterable, resultName, nextLoc) {
+        this.delegate = {
+          iterator: values(iterable),
+          resultName: resultName,
+          nextLoc: nextLoc
+        };
+
+        if (this.method === "next") {
+          // Deliberately forget the last sent value so that we don't
+          // accidentally pass it on to the delegate.
+          this.arg = undefined$1;
+        }
+
+        return ContinueSentinel;
+      }
+    }; // Regardless of whether this script is executing as a CommonJS module
+    // or not, return the runtime object so that we can declare the variable
+    // regeneratorRuntime in the outer scope, which allows this module to be
+    // injected easily by `bin/regenerator --include-runtime script.js`.
+
+    return exports;
+  }( // If this script is executing as a CommonJS module, use module.exports
+  // as the regeneratorRuntime namespace. Otherwise create a new empty
+  // object. Either way, the resulting object will be used to initialize
+  // the regeneratorRuntime variable at the top of this file.
+  module.exports );
+
+  try {
+    regeneratorRuntime = runtime;
+  } catch (accidentalStrictMode) {
+    // This module should not be running in strict mode, so the above
+    // assignment should always work unless something is misconfigured. Just
+    // in case runtime.js accidentally runs in strict mode, we can escape
+    // strict mode using a global Function call. This could conceivably fail
+    // if a Content Security Policy forbids using Function, but in that case
+    // the proper solution is to fix the accidental strict mode problem. If
+    // you've misconfigured your bundler to force strict mode and applied a
+    // CSP to forbid Function, and you're not willing to fix either of those
+    // problems, please detail your unique predicament in a GitHub issue.
+    Function("r", "regeneratorRuntime = r")(runtime);
+  }
+})(runtime);
+
+var regenerator = runtime.exports;
+
+function _extends$1() {
+  _extends_1 = _extends$1 = 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$1.apply(this, arguments);
+}
+
+var _extends_1 = _extends$1;
+
+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;
+}
+
+var objectWithoutPropertiesLoose$1 = _objectWithoutPropertiesLoose;
+
+var objectWithoutPropertiesLoose = objectWithoutPropertiesLoose$1;
+
+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;
+}
+
+var objectWithoutProperties = _objectWithoutProperties;
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+var classCallCheck = _classCallCheck;
+
+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);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+var createClass = _createClass;
+
+function _typeof2(obj) {
+  if (typeof Symbol === "function" && _typeof$2(Symbol.iterator) === "symbol") {
+    _typeof2 = function _typeof2(obj) {
+      return _typeof$2(obj);
+    };
+  } else {
+    _typeof2 = function _typeof2(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof$2(obj);
+    };
+  }
+
+  return _typeof2(obj);
+}
+
+function _typeof$1(obj) {
+  if (typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol") {
+    _typeof_1 = _typeof$1 = function _typeof(obj) {
+      return _typeof2(obj);
+    };
+  } else {
+    _typeof_1 = _typeof$1 = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
+    };
+  }
+
+  return _typeof$1(obj);
+}
+
+var _typeof_1 = _typeof$1;
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+var assertThisInitialized$1 = _assertThisInitialized;
+
+var _typeof = _typeof_1;
+var assertThisInitialized = assertThisInitialized$1;
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return assertThisInitialized(self);
+}
+
+var possibleConstructorReturn = _possibleConstructorReturn;
+
+function _getPrototypeOf(o) {
+  getPrototypeOf = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+var getPrototypeOf = _getPrototypeOf;
+
+function _setPrototypeOf(o, p) {
+  setPrototypeOf$1 = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+var setPrototypeOf$1 = _setPrototypeOf;
+
+var setPrototypeOf = setPrototypeOf$1;
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) setPrototypeOf(subClass, superClass);
+}
+
+var inherits = _inherits;
+
+var propTypes = {exports: {}};
+
+/**
+ * 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$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;
+
+/**
+ * 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 = ReactPropTypesSecret_1;
+
+function emptyFunction() {}
+
+function emptyFunctionWithReset() {}
+
+emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+var factoryWithThrowingShims = function factoryWithThrowingShims() {
+  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;
+  }
+  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+
+  var ReactPropTypes = {
+    array: 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;
+};
+
+/**
+ * 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.
+ */
+
+{
+  // By explicitly using `prop-types` you are opting into new production behavior.
+  // http://fb.me/prop-types-in-prod
+  propTypes.exports = factoryWithThrowingShims();
+}
+
+var ensureNativeModuleAvailable$1 = {};
+
+Object.defineProperty(ensureNativeModuleAvailable$1, "__esModule", {
+  value: true
+});
+
+ensureNativeModuleAvailable$1["default"] = ensureNativeModuleAvailable;
+
+var _reactNative$2 = ReactNative__default;
+var NativeIconAPI$1 = _reactNative$2.NativeModules.RNVectorIconsManager || _reactNative$2.NativeModules.RNVectorIconsModule;
+
+function ensureNativeModuleAvailable() {
+  if (!NativeIconAPI$1) {
+    if (_reactNative$2.Platform.OS === 'android') {
+      throw new Error('RNVectorIconsModule not available, did you properly integrate the module? Try running `react-native link react-native-vector-icons` and recompiling.');
+    }
+
+    throw new Error('RNVectorIconsManager not available, did you add the library to your project and link with libRNVectorIcons.a? Try running `react-native link react-native-vector-icons` and recompiling.');
+  }
+}
+
+var createIconSourceCache$1 = {};
+
+Object.defineProperty(createIconSourceCache$1, "__esModule", {
+  value: true
+});
+
+createIconSourceCache$1["default"] = createIconSourceCache;
+
+var TYPE_VALUE = 'value';
+var TYPE_ERROR = 'error';
+
+function createIconSourceCache() {
+  var cache = new Map();
+
+  var setValue = function setValue(key, value) {
+    return cache.set(key, {
+      type: TYPE_VALUE,
+      data: value
+    });
+  };
+
+  var setError = function setError(key, error) {
+    return cache.set(key, {
+      type: TYPE_ERROR,
+      data: error
+    });
+  };
+
+  var has = function has(key) {
+    return cache.has(key);
+  };
+
+  var get = function get(key) {
+    if (!cache.has(key)) {
+      return undefined;
+    }
+
+    var _cache$get = cache.get(key),
+        type = _cache$get.type,
+        data = _cache$get.data;
+
+    if (type === TYPE_ERROR) {
+      throw data;
+    }
+
+    return data;
+  };
+
+  return {
+    setValue: setValue,
+    setError: setError,
+    has: has,
+    get: get
+  };
+}
+
+var iconButton = {};
+
+var pick = function pick(obj) {
+  for (var _len = arguments.length, keys = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    keys[_key - 1] = arguments[_key];
+  }
+
+  return keys.flat().filter(function (key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+  }).reduce(function (acc, key) {
+    acc[key] = obj[key];
+    return acc;
+  }, {});
+};
+
+var omit = function omit(obj) {
+  for (var _len2 = arguments.length, keysToOmit = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    keysToOmit[_key2 - 1] = arguments[_key2];
+  }
+
+  var keysToOmitSet = new Set(keysToOmit.flat());
+  return Object.getOwnPropertyNames(obj).filter(function (key) {
+    return !keysToOmitSet.has(key);
+  }).reduce(function (acc, key) {
+    acc[key] = obj[key];
+    return acc;
+  }, {});
+};
+
+var objectUtils = {
+  pick: pick,
+  omit: omit
+};
+
+var _interopRequireDefault$4 = interopRequireDefault;
+Object.defineProperty(iconButton, "__esModule", {
+  value: true
+});
+
+iconButton["default"] = createIconButtonComponent;
+
+var _extends2$2 = _interopRequireDefault$4(_extends_1);
+
+var _objectWithoutProperties2$1 = _interopRequireDefault$4(objectWithoutProperties);
+
+var _classCallCheck2$2 = _interopRequireDefault$4(classCallCheck);
+
+var _createClass2$2 = _interopRequireDefault$4(createClass);
+
+var _possibleConstructorReturn2$2 = _interopRequireDefault$4(possibleConstructorReturn);
+
+var _getPrototypeOf2$1 = _interopRequireDefault$4(getPrototypeOf);
+
+var _inherits2$2 = _interopRequireDefault$4(inherits);
+
+var _react$2 = _interopRequireWildcard$2(React);
+
+var _propTypes$2 = _interopRequireDefault$4(propTypes.exports);
+
+var _reactNative$1 = ReactNative__default;
+var _objectUtils = objectUtils;
+var _jsxFileName$2 = "/home/runner/work/react-native-vector-icons/react-native-vector-icons/lib/icon-button.js";
+
+function _getRequireWildcardCache$2(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache$2 = function _getRequireWildcardCache(nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard$2(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || _typeof$2(obj) !== "object" && typeof obj !== "function") {
+    return {
+      "default": obj
+    };
+  }
+
+  var cache = _getRequireWildcardCache$2(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;
+}
+
+var styles$1 = _reactNative$1.StyleSheet.create({
+  container: {
+    flexDirection: 'row',
+    justifyContent: 'flex-start',
+    alignItems: 'center',
+    padding: 8
+  },
+  touchable: {
+    overflow: 'hidden'
+  },
+  icon: {
+    marginRight: 10
+  },
+  text: {
+    fontWeight: '600',
+    backgroundColor: 'transparent'
+  }
+});
+
+var IOS7_BLUE = '#007AFF';
+var TEXT_PROP_NAMES = ['ellipsizeMode', 'numberOfLines', 'textBreakStrategy', 'selectable', 'suppressHighlighting', 'allowFontScaling', 'adjustsFontSizeToFit', 'minimumFontScale'];
+var TOUCHABLE_PROP_NAMES = ['accessible', 'accessibilityLabel', 'accessibilityHint', 'accessibilityComponentType', 'accessibilityRole', 'accessibilityStates', 'accessibilityTraits', 'onFocus', 'onBlur', 'disabled', 'onPress', 'onPressIn', 'onPressOut', 'onLayout', 'onLongPress', 'nativeID', 'testID', 'delayPressIn', 'delayPressOut', 'delayLongPress', 'activeOpacity', 'underlayColor', 'selectionColor', 'onShowUnderlay', 'onHideUnderlay', 'hasTVPreferredFocus', 'tvParallaxProperties'];
+
+function createIconButtonComponent(Icon) {
+  var _class, _temp;
+
+  return _temp = _class = function (_PureComponent) {
+    (0, _inherits2$2["default"])(IconButton, _PureComponent);
+
+    function IconButton() {
+      (0, _classCallCheck2$2["default"])(this, IconButton);
+      return (0, _possibleConstructorReturn2$2["default"])(this, (0, _getPrototypeOf2$1["default"])(IconButton).apply(this, arguments));
+    }
+
+    (0, _createClass2$2["default"])(IconButton, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            style = _this$props.style,
+            iconStyle = _this$props.iconStyle,
+            children = _this$props.children,
+            restProps = (0, _objectWithoutProperties2$1["default"])(_this$props, ["style", "iconStyle", "children"]);
+        var iconProps = (0, _objectUtils.pick)(restProps, TEXT_PROP_NAMES, 'style', 'name', 'size', 'color');
+        var touchableProps = (0, _objectUtils.pick)(restProps, TOUCHABLE_PROP_NAMES);
+        var props = (0, _objectUtils.omit)(restProps, Object.keys(iconProps), Object.keys(touchableProps), 'iconStyle', 'borderRadius', 'backgroundColor');
+        iconProps.style = iconStyle ? [styles$1.icon, iconStyle] : styles$1.icon;
+        var colorStyle = (0, _objectUtils.pick)(this.props, 'color');
+        var blockStyle = (0, _objectUtils.pick)(this.props, 'backgroundColor', 'borderRadius');
+        return _react$2["default"].createElement(_reactNative$1.TouchableHighlight, (0, _extends2$2["default"])({
+          style: [styles$1.touchable, blockStyle]
+        }, touchableProps, {
+          __self: this,
+          __source: {
+            fileName: _jsxFileName$2,
+            lineNumber: 116
+          }
+        }), _react$2["default"].createElement(_reactNative$1.View, (0, _extends2$2["default"])({
+          style: [styles$1.container, blockStyle, style]
+        }, props, {
+          __self: this,
+          __source: {
+            fileName: _jsxFileName$2,
+            lineNumber: 120
+          }
+        }), _react$2["default"].createElement(Icon, (0, _extends2$2["default"])({}, iconProps, {
+          __self: this,
+          __source: {
+            fileName: _jsxFileName$2,
+            lineNumber: 121
+          }
+        })), typeof children === 'string' ? _react$2["default"].createElement(_reactNative$1.Text, {
+          style: [styles$1.text, colorStyle],
+          selectable: false,
+          __self: this,
+          __source: {
+            fileName: _jsxFileName$2,
+            lineNumber: 123
+          }
+        }, children) : children));
+      }
+    }]);
+    return IconButton;
+  }(_react$2.PureComponent), _class.propTypes = {
+    backgroundColor: _propTypes$2["default"].oneOfType([_propTypes$2["default"].string, _propTypes$2["default"].number]),
+    borderRadius: _propTypes$2["default"].number,
+    color: _propTypes$2["default"].any,
+    size: _propTypes$2["default"].number,
+    iconStyle: _propTypes$2["default"].any,
+    style: _propTypes$2["default"].any,
+    children: _propTypes$2["default"].node
+  }, _class.defaultProps = {
+    backgroundColor: IOS7_BLUE,
+    borderRadius: 5,
+    color: 'white',
+    size: 20
+  }, _temp;
+}
+
+var _interopRequireDefault$3 = interopRequireDefault;
+Object.defineProperty(createIconSet$1, "__esModule", {
+  value: true
+});
+createIconSet$1.NativeIconAPI = createIconSet$1.DEFAULT_ICON_SIZE = createIconSet$1.DEFAULT_ICON_COLOR = void 0;
+
+createIconSet$1["default"] = createIconSet;
+
+var _toConsumableArray2 = _interopRequireDefault$3(toConsumableArray);
+
+var _regenerator = _interopRequireDefault$3(regenerator);
+
+var _extends2$1 = _interopRequireDefault$3(_extends_1);
+
+var _objectWithoutProperties2 = _interopRequireDefault$3(objectWithoutProperties);
+
+var _classCallCheck2$1 = _interopRequireDefault$3(classCallCheck);
+
+var _createClass2$1 = _interopRequireDefault$3(createClass);
+
+var _possibleConstructorReturn2$1 = _interopRequireDefault$3(possibleConstructorReturn);
+
+var _getPrototypeOf3 = _interopRequireDefault$3(getPrototypeOf);
+
+var _inherits2$1 = _interopRequireDefault$3(inherits);
+
+var _react$1 = _interopRequireWildcard$1(React);
+
+var _propTypes$1 = _interopRequireDefault$3(propTypes.exports);
+
+var _reactNative = ReactNative__default;
+
+var _ensureNativeModuleAvailable = _interopRequireDefault$3(ensureNativeModuleAvailable$1);
+
+var _createIconSourceCache = _interopRequireDefault$3(createIconSourceCache$1);
+
+var _iconButton = _interopRequireDefault$3(iconButton);
+
+var _jsxFileName$1 = "/home/runner/work/react-native-vector-icons/react-native-vector-icons/lib/create-icon-set.js";
+
+function _getRequireWildcardCache$1(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache$1 = function _getRequireWildcardCache(nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard$1(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || _typeof$2(obj) !== "object" && typeof obj !== "function") {
+    return {
+      "default": obj
+    };
+  }
+
+  var cache = _getRequireWildcardCache$1(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;
+}
+
+var NativeIconAPI = _reactNative.NativeModules.RNVectorIconsManager || _reactNative.NativeModules.RNVectorIconsModule;
+createIconSet$1.NativeIconAPI = NativeIconAPI;
+var DEFAULT_ICON_SIZE = 12;
+createIconSet$1.DEFAULT_ICON_SIZE = DEFAULT_ICON_SIZE;
+var DEFAULT_ICON_COLOR = 'black';
+createIconSet$1.DEFAULT_ICON_COLOR = DEFAULT_ICON_COLOR;
+
+function createIconSet(glyphMap, fontFamily, fontFile, fontStyle) {
+  var fontBasename = fontFile ? fontFile.replace(/\.(otf|ttf)$/, '') : fontFamily;
+
+  var fontReference = _reactNative.Platform.select({
+    windows: "/Assets/" + fontFile + "#" + fontFamily,
+    android: fontBasename,
+    web: fontBasename,
+    "default": fontFamily
+  });
+
+  var IconNamePropType = _propTypes$1["default"].oneOf(Object.keys(glyphMap));
+
+  var Icon = function (_PureComponent) {
+    (0, _inherits2$1["default"])(Icon, _PureComponent);
+
+    function Icon() {
+      var _getPrototypeOf2;
+
+      var _this;
+
+      (0, _classCallCheck2$1["default"])(this, Icon);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = (0, _possibleConstructorReturn2$1["default"])(this, (_getPrototypeOf2 = (0, _getPrototypeOf3["default"])(Icon)).call.apply(_getPrototypeOf2, [this].concat(args)));
+      _this.root = null;
+
+      _this.handleRef = function (ref) {
+        _this.root = ref;
+      };
+
+      return _this;
+    }
+
+    (0, _createClass2$1["default"])(Icon, [{
+      key: "setNativeProps",
+      value: function setNativeProps(nativeProps) {
+        if (this.root) {
+          this.root.setNativeProps(nativeProps);
+        }
+      }
+    }, {
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+            name = _this$props.name,
+            size = _this$props.size,
+            color = _this$props.color,
+            style = _this$props.style,
+            children = _this$props.children,
+            props = (0, _objectWithoutProperties2["default"])(_this$props, ["name", "size", "color", "style", "children"]);
+        var glyph = name ? glyphMap[name] || '?' : '';
+
+        if (typeof glyph === 'number') {
+          glyph = String.fromCodePoint(glyph);
+        }
+
+        var styleDefaults = {
+          fontSize: size,
+          color: color
+        };
+        var styleOverrides = {
+          fontFamily: fontReference,
+          fontWeight: 'normal',
+          fontStyle: 'normal'
+        };
+        props.style = [styleDefaults, style, styleOverrides, fontStyle || {}];
+        props.ref = this.handleRef;
+        return _react$1["default"].createElement(_reactNative.Text, (0, _extends2$1["default"])({
+          selectable: false
+        }, props, {
+          __self: this,
+          __source: {
+            fileName: _jsxFileName$1,
+            lineNumber: 91
+          }
+        }), glyph, children);
+      }
+    }]);
+    return Icon;
+  }(_react$1.PureComponent);
+
+  Icon.propTypes = {
+    allowFontScaling: _propTypes$1["default"].bool,
+    name: IconNamePropType,
+    size: _propTypes$1["default"].number,
+    color: _propTypes$1["default"].any,
+    children: _propTypes$1["default"].node,
+    style: _propTypes$1["default"].any
+  };
+  Icon.defaultProps = {
+    size: DEFAULT_ICON_SIZE,
+    allowFontScaling: false
+  };
+  var imageSourceCache = (0, _createIconSourceCache["default"])();
+
+  function resolveGlyph(name) {
+    var glyph = glyphMap[name] || '?';
+
+    if (typeof glyph === 'number') {
+      return String.fromCodePoint(glyph);
+    }
+
+    return glyph;
+  }
+
+  function getImageSourceSync(name) {
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_ICON_SIZE;
+    var color = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_ICON_COLOR;
+    (0, _ensureNativeModuleAvailable["default"])();
+    var glyph = resolveGlyph(name);
+    var processedColor = (0, _reactNative.processColor)(color);
+    var cacheKey = glyph + ":" + size + ":" + processedColor;
+
+    if (imageSourceCache.has(cacheKey)) {
+      return imageSourceCache.get(cacheKey);
+    }
+
+    try {
+      var imagePath = NativeIconAPI.getImageForFontSync(fontReference, glyph, size, processedColor);
+      var value = {
+        uri: imagePath,
+        scale: _reactNative.PixelRatio.get()
+      };
+      imageSourceCache.setValue(cacheKey, value);
+      return value;
+    } catch (error) {
+      imageSourceCache.setError(cacheKey, error);
+      throw error;
+    }
+  }
+
+  function getImageSource(name) {
+    var size,
+        color,
+        glyph,
+        processedColor,
+        cacheKey,
+        imagePath,
+        value,
+        _args = arguments;
+    return _regenerator["default"].async(function getImageSource$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            size = _args.length > 1 && _args[1] !== undefined ? _args[1] : DEFAULT_ICON_SIZE;
+            color = _args.length > 2 && _args[2] !== undefined ? _args[2] : DEFAULT_ICON_COLOR;
+            (0, _ensureNativeModuleAvailable["default"])();
+            glyph = resolveGlyph(name);
+            processedColor = (0, _reactNative.processColor)(color);
+            cacheKey = glyph + ":" + size + ":" + processedColor;
+
+            if (!imageSourceCache.has(cacheKey)) {
+              _context.next = 8;
+              break;
+            }
+
+            return _context.abrupt("return", imageSourceCache.get(cacheKey));
+
+          case 8:
+            _context.prev = 8;
+            _context.next = 11;
+            return _regenerator["default"].awrap(NativeIconAPI.getImageForFont(fontReference, glyph, size, processedColor));
+
+          case 11:
+            imagePath = _context.sent;
+            value = {
+              uri: imagePath,
+              scale: _reactNative.PixelRatio.get()
+            };
+            imageSourceCache.setValue(cacheKey, value);
+            return _context.abrupt("return", value);
+
+          case 17:
+            _context.prev = 17;
+            _context.t0 = _context["catch"](8);
+            imageSourceCache.setError(cacheKey, _context.t0);
+            throw _context.t0;
+
+          case 21:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, null, null, [[8, 17]]);
+  }
+
+  function loadFont() {
+    var file,
+        _args2 = arguments;
+    return _regenerator["default"].async(function loadFont$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            file = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : fontFile;
+
+            if (!(_reactNative.Platform.OS === 'ios')) {
+              _context2.next = 7;
+              break;
+            }
+
+            (0, _ensureNativeModuleAvailable["default"])();
+
+            if (file) {
+              _context2.next = 5;
+              break;
+            }
+
+            throw new Error('Unable to load font, because no file was specified. ');
+
+          case 5:
+            _context2.next = 7;
+            return _regenerator["default"].awrap(NativeIconAPI.loadFontWithFileName.apply(NativeIconAPI, (0, _toConsumableArray2["default"])(file.split('.'))));
+
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    });
+  }
+
+  function hasIcon(name) {
+    return Object.prototype.hasOwnProperty.call(glyphMap, name);
+  }
+
+  function getRawGlyphMap() {
+    return glyphMap;
+  }
+
+  function getFontFamily() {
+    return fontReference;
+  }
+
+  Icon.Button = (0, _iconButton["default"])(Icon);
+  Icon.getImageSource = getImageSource;
+  Icon.getImageSourceSync = getImageSourceSync;
+  Icon.loadFont = loadFont;
+  Icon.hasIcon = hasIcon;
+  Icon.getRawGlyphMap = getRawGlyphMap;
+  Icon.getFontFamily = getFontFamily;
+  return Icon;
+}
+
+var createMultiStyleIconSet$1 = {};
+
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+var defineProperty = _defineProperty$1;
+
+var _interopRequireDefault$2 = interopRequireDefault;
+Object.defineProperty(createMultiStyleIconSet$1, "__esModule", {
+  value: true
+});
+
+createMultiStyleIconSet$1["default"] = createMultiStyleIconSet;
+
+var _classCallCheck2 = _interopRequireDefault$2(classCallCheck);
+
+var _createClass2 = _interopRequireDefault$2(createClass);
+
+var _possibleConstructorReturn2 = _interopRequireDefault$2(possibleConstructorReturn);
+
+var _getPrototypeOf2 = _interopRequireDefault$2(getPrototypeOf);
+
+var _inherits2 = _interopRequireDefault$2(inherits);
+
+var _defineProperty2 = _interopRequireDefault$2(defineProperty);
+
+var _extends2 = _interopRequireDefault$2(_extends_1);
+
+var _react = _interopRequireWildcard(React);
+
+var _propTypes = _interopRequireDefault$2(propTypes.exports);
+
+var _createIconSet$2 = _interopRequireWildcard(createIconSet$1);
+
+var _jsxFileName = "/home/runner/work/react-native-vector-icons/react-native-vector-icons/lib/create-multi-style-icon-set.js";
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function") return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+
+  if (obj === null || _typeof$2(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;
+}
+
+function createMultiStyleIconSet(styles) {
+  var optionsInput = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var styleNames = Object.keys(styles);
+
+  if (styleNames.length === 0) {
+    throw new Error('You need to add at least one style');
+  }
+
+  var options = (0, _extends2["default"])({
+    defaultStyle: styleNames[0],
+    fallbackFamily: function fallbackFamily() {
+      return styleNames[0];
+    },
+    glyphValidator: function glyphValidator() {
+      return true;
+    }
+  }, optionsInput);
+  var iconSets = styleNames.reduce(function (acc, name) {
+    var style = styles[name];
+    acc[name] = (0, _createIconSet$2["default"])(style.glyphMap || {}, style.fontFamily || '', style.fontFile || '', style.fontStyle || {});
+    return acc;
+  }, {});
+
+  function styleFromProps(props) {
+    return Object.keys(props).reduce(function (result, propName) {
+      return styleNames.indexOf(propName) !== -1 && props[propName] === true ? propName : result;
+    }, options.defaultStyle);
+  }
+
+  function getIconSetForProps(props) {
+    var name = props.name;
+    var style = styleFromProps(props);
+    if (options.glyphValidator(name, style)) return iconSets[style];
+    var family = options.fallbackFamily(name);
+
+    if (styleNames.indexOf(family) === -1) {
+      return options.defaultStyle;
+    }
+
+    return iconSets[family];
+  }
+
+  function selectIconClass(iconSet, iconClass) {
+    return iconClass.length > 0 ? iconSet[iconClass] : iconSet;
+  }
+
+  function reduceProps(props) {
+    return Object.keys(props).reduce(function (acc, prop) {
+      if (styleNames.indexOf(prop) === -1) {
+        acc[prop] = props[prop];
+      }
+
+      return acc;
+    }, {});
+  }
+
+  function getStyledIconSet(style) {
+    var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+
+    if (styleNames.indexOf(style) === -1) {
+      return iconSets[options.defaultStyle];
+    }
+
+    return !name ? iconSets[styleFromProps((0, _defineProperty2["default"])({}, style, true))] : getIconSetForProps((0, _defineProperty2["default"])({
+      name: name
+    }, style, true));
+  }
+
+  function getImageSource(name) {
+    var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _createIconSet$2.DEFAULT_ICON_SIZE;
+    var color = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _createIconSet$2.DEFAULT_ICON_COLOR;
+    var style = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : options.defaultStyle;
+    return getStyledIconSet(style, name).getImageSource(name, size, color);
+  }
+
+  function getFontFamily() {
+    var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : options.defaultStyle;
+    return getStyledIconSet(style).getFontFamily();
+  }
+
+  function getRawGlyphMap() {
+    var style = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : options.defaultStyle;
+    return getStyledIconSet(style).getRawGlyphMap();
+  }
+
+  function hasIcon(name) {
+    var style = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : options.defaultStyle;
+    return options.glyphValidator(name, style);
+  }
+
+  function createStyledIconClass() {
+    var selectClass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+
+    var IconClass = function (_PureComponent) {
+      (0, _inherits2["default"])(IconClass, _PureComponent);
+
+      function IconClass() {
+        (0, _classCallCheck2["default"])(this, IconClass);
+        return (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(IconClass).apply(this, arguments));
+      }
+
+      (0, _createClass2["default"])(IconClass, [{
+        key: "render",
+        value: function render() {
+          var selectedIconSet = getIconSetForProps(this.props);
+          var SelectedIconClass = selectIconClass(selectedIconSet, selectClass);
+          var props = reduceProps(this.props);
+          return _react["default"].createElement(SelectedIconClass, (0, _extends2["default"])({}, props, {
+            __self: this,
+            __source: {
+              fileName: _jsxFileName,
+              lineNumber: 123
+            }
+          }));
+        }
+      }]);
+      return IconClass;
+    }(_react.PureComponent);
+
+    IconClass.propTypes = styleNames.reduce(function (acc, name) {
+      acc[name] = _propTypes["default"].bool;
+      return acc;
+    }, {});
+    IconClass.defaultProps = styleNames.reduce(function (acc, name) {
+      acc[name] = false;
+      return acc;
+    }, {});
+    return IconClass;
+  }
+
+  var Icon = createStyledIconClass();
+  Icon.Button = createStyledIconClass('Button');
+  Icon.getStyledIconSet = getStyledIconSet;
+  Icon.getImageSource = getImageSource;
+  Icon.getFontFamily = getFontFamily;
+  Icon.getRawGlyphMap = getRawGlyphMap;
+  Icon.hasIcon = hasIcon;
+  return Icon;
+}
 
-var getSwitchTheme = function getSwitchTheme(theme) {
-  var colors = {
-    thumb: theme.colors.platformBackground,
-    active: theme.colors.primary,
-    inactive: theme.colors.inactiveBackground
-  };
-  var thumbSizes = {
-    small: theme.space.medium,
-    medium: theme.space.medium * 1.3
-  };
-  var widths = {
-    small: theme.space.xxxlarge,
-    medium: theme.space.xxxxlarge
-  };
-  var heights = {
-    small: theme.space.large,
-    medium: theme.space.large * 1.2
-  };
-  var spaces = {
-    small: theme.space.xsmall,
-    medium: theme.space.xsmall,
-    inactive: 0
-  };
-  var radii = {
-    rounded: theme.radii.rounded
-  };
-  var borderWidths = {
-    "default": theme.borderWidths.base
-  };
-  return {
-    colors: colors,
-    thumbSizes: thumbSizes,
-    widths: widths,
-    heights: heights,
-    spaces: spaces,
-    radii: radii,
-    borderWidths: borderWidths
-  };
-};
+var createIconSetFromFontello$1 = {};
 
-var getTabsTheme = function getTabsTheme(theme) {
-  var colors = {
-    active: theme.colors.primary,
-    inactive: theme.colors.text,
-    activeBackground: theme.colors.primaryBackground,
-    headerBottom: theme.colors.outline,
-    text: theme.colors.text
-  };
-  var space = {
-    flatListHorizontalPadding: theme.space.small,
-    itemHorizontalPadding: theme.space.small,
-    itemVerticalPadding: theme.space.small,
-    outlineHorizontalPadding: theme.space.small,
-    outlineVerticalPadding: theme.space.xsmall
-  };
-  var radii = {
-    outline: theme.radii.medium
-  };
-  var borderWidths = {
-    headerBottom: theme.borderWidths.base
-  };
-  var sizes = {
-    indicator: theme.space.xxsmall
-  };
-  return {
-    borderWidths: borderWidths,
-    colors: colors,
-    space: space,
-    radii: radii,
-    sizes: sizes
-  };
-};
+var _interopRequireDefault$1 = interopRequireDefault;
+Object.defineProperty(createIconSetFromFontello$1, "__esModule", {
+  value: true
+});
 
-var getTagTheme = function getTagTheme(theme) {
-  var borderWidths = {
-    "default": theme.borderWidths.base
-  };
-  var colors = {
-    danger: theme.colors.danger,
-    dangerBackground: theme.colors.dangerBackground,
-    info: theme.colors.info,
-    infoBackground: theme.colors.infoBackground,
-    success: theme.colors.successDark,
-    successBackground: theme.colors.successBackground,
-    warning: theme.colors.warningDark,
-    warningBackground: theme.colors.warningBackground
-  };
-  var fonts = {
-    "default": theme.fonts.semiBold
-  };
-  var fontSizes = {
-    "default": theme.fontSizes.small
-  };
-  var space = {
-    horizontalPadding: theme.space.small,
-    verticalPadding: theme.space.xxsmall
-  };
-  var radii = {
-    "default": theme.radii.base
-  };
-  return {
-    borderWidths: borderWidths,
-    colors: colors,
-    fonts: fonts,
-    fontSizes: fontSizes,
-    space: space,
-    radii: radii
-  };
-};
+createIconSetFromFontello$1["default"] = createIconSetFromFontello;
 
-var getTextInputTheme = function getTextInputTheme(theme) {
-  var colors = {
-    labelBackground: theme.colors.platformBackground,
-    border: theme.colors.text
-  };
-  var space = {
-    containerPadding: theme.space.medium,
-    labelLeft: theme.space.medium,
-    labelTop: theme.lineHeights.small / -2,
-    labelHorizontalPadding: theme.space.xsmall,
-    inputHorizontalMargin: theme.space.small
-  };
-  var fontSizes = {
-    text: theme.fontSizes.large
-  };
-  var borderWidths = {
-    container: theme.borderWidths.base
-  };
-  var radii = {
-    container: theme.radii.medium
-  };
-  return {
-    colors: colors,
-    space: space,
-    fontSizes: fontSizes,
-    borderWidths: borderWidths,
-    radii: radii
-  };
-};
+var _createIconSet$1 = _interopRequireDefault$1(createIconSet$1);
 
-var getTypographyTheme = function getTypographyTheme(theme) {
-  var colors = {
-    body: theme.colors.text,
-    subdued: theme.colors.disabledText,
-    primary: theme.colors.primary
-  };
-  var fonts = {
-    light: theme.fonts.light,
-    regular: theme.fonts.regular,
-    semiBold: theme.fonts.semiBold
-  };
-  var fontSizes = {
-    small: theme.fontSizes.small,
-    medium: theme.fontSizes.medium,
-    large: theme.fontSizes.large,
-    xlarge: theme.fontSizes.xlarge
-  };
-  var lineHeights = {
-    small: theme.lineHeights.small,
-    medium: theme.lineHeights.medium,
-    large: theme.lineHeights.large,
-    xlarge: theme.lineHeights.xlarge
-  };
-  return {
-    colors: colors,
-    fonts: fonts,
-    fontSizes: fontSizes,
-    lineHeights: lineHeights
-  };
-};
+function createIconSetFromFontello(config, fontFamilyArg, fontFile) {
+  var glyphMap = {};
+  config.glyphs.forEach(function (glyph) {
+    glyphMap[glyph.css] = glyph.code;
+  });
+  var fontFamily = fontFamilyArg || config.name || 'fontello';
+  return (0, _createIconSet$1["default"])(glyphMap, fontFamily, fontFile || fontFamily + ".ttf");
+}
 
-var getTheme = function getTheme() {
-  var scale = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : scale$1;
-  var systemPallete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : systemPalette;
-  var globalTheme = getGlobalTheme(scale, systemPallete);
-  return _objectSpread2(_objectSpread2({}, globalTheme), {}, {
-    __hd__: {
-      avatar: getAvatarTheme(globalTheme),
-      alert: getAlertTheme(globalTheme),
-      badge: getBadgeTheme(globalTheme),
-      bottomNavigation: getBottomNavigationTheme(globalTheme),
-      bottomSheet: getBottomSheetTheme(globalTheme),
-      button: getButtonTheme(globalTheme),
-      card: getCardTheme(globalTheme),
-      contentNavigator: getContentNavigatorTheme(globalTheme),
-      divider: getDividerTheme(globalTheme),
-      drawer: getDrawerTheme(globalTheme),
-      fab: getFABTheme(globalTheme),
-      icon: getIconTheme(globalTheme),
-      progress: getProgressTheme(globalTheme),
-      radio: getRadioTheme(globalTheme),
-      sectionHeading: getSectionHeadingTheme(globalTheme),
-      select: getSelectTheme(globalTheme),
-      spinner: getSpinnerTheme(globalTheme),
-      "switch": getSwitchTheme(globalTheme),
-      tabs: getTabsTheme(globalTheme),
-      tag: getTagTheme(globalTheme),
-      textInput: getTextInputTheme(globalTheme),
-      typography: getTypographyTheme(globalTheme)
+var createIconSetFromIcomoon = {};
+
+var _interopRequireDefault = interopRequireDefault;
+Object.defineProperty(createIconSetFromIcomoon, "__esModule", {
+  value: true
+});
+
+createIconSetFromIcomoon["default"] = createIconSetFromIcoMoon;
+
+var _createIconSet = _interopRequireDefault(createIconSet$1);
+
+function createIconSetFromIcoMoon(config, fontFamilyArg, fontFile) {
+  var glyphMap = {};
+  config.icons.forEach(function (icon) {
+    icon.properties.name.split(/\s*,\s*/g).forEach(function (name) {
+      glyphMap[name] = icon.properties.code;
+    });
+  });
+  var fontFamily = fontFamilyArg || config.preferences.fontPref.metadata.fontFamily;
+  return (0, _createIconSet["default"])(glyphMap, fontFamily, fontFile || fontFamily + ".ttf");
+}
+
+(function (exports) {
+  var _interopRequireDefault = interopRequireDefault;
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "createIconSet", {
+    enumerable: true,
+    get: function get() {
+      return _createIconSet["default"];
+    }
+  });
+  Object.defineProperty(exports, "createIconSetFromFontello", {
+    enumerable: true,
+    get: function get() {
+      return _createIconSetFromFontello["default"];
+    }
+  });
+  Object.defineProperty(exports, "createIconSetFromIcoMoon", {
+    enumerable: true,
+    get: function get() {
+      return _createIconSetFromIcomoon["default"];
+    }
+  });
+  Object.defineProperty(exports, "createMultiStyleIconSet", {
+    enumerable: true,
+    get: function get() {
+      return _createMultiStyleIconSet["default"];
     }
   });
-};
 
-var theme = getTheme();
-var ThemeProvider = ThemeProvider$1;
-var useTheme = useTheme$1;
+  var _createIconSet = _interopRequireDefault(createIconSet$1);
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
+  var _createMultiStyleIconSet = _interopRequireDefault(createMultiStyleIconSet$1);
+
+  var _createIconSetFromFontello = _interopRequireDefault(createIconSetFromFontello$1);
+
+  var _createIconSetFromIcomoon = _interopRequireDefault(createIconSetFromIcomoon);
+})(dist);
 
 var cssToReactNative = {};
 
@@ -2901,7 +5032,7 @@ var camelize = function camelize(obj) {
 };
 
 function walk(obj) {
-  if (!obj || _typeof(obj) !== 'object') return obj;
+  if (!obj || _typeof$2(obj) !== 'object') return obj;
   if (isDate(obj) || isRegex(obj)) return obj;
   if (isArray(obj)) return map(obj, walk);
   return reduce(objectKeys(obj), function (acc, key) {
@@ -3266,7 +5397,7 @@ var cssColorKeywords = require$$0;
   });
 
   function _interopDefault(ex) {
-    return ex && _typeof(ex) === 'object' && 'default' in ex ? ex['default'] : ex;
+    return ex && _typeof$2(ex) === 'object' && 'default' in ex ? ex['default'] : ex;
   }
 
   var parse = lib;
@@ -4121,7 +6252,7 @@ var buffer = '';
 var lastType;
 
 function handleInterpolation(interpolation, i, arr) {
-  var type = _typeof(interpolation);
+  var type = _typeof$2(interpolation);
 
   if (type === 'string') {
     // strip comments
@@ -4343,7 +6474,7 @@ var index$2 = components.reduce(function (acc, comp) {
     enumerable: true,
     configurable: false,
     get: function get() {
-      return styled(reactNative[comp]);
+      return styled(ReactNative[comp]);
     }
   });
 }, styled);
@@ -12267,7 +14398,7 @@ var heroIconConfig = {
 	preferences: preferences
 };
 
-var HeroIcon = createIconSetFromIcoMoon(heroIconConfig, 'hero-icons', 'hero-icons.ttf');
+var HeroIcon = dist.createIconSetFromIcoMoon(heroIconConfig, 'hero-icons', 'hero-icons.ttf');
 var COLOR_INTENTS = {
   text: 'text',
   primary: 'primary',
@@ -12335,9 +14466,9 @@ var Text = function Text(_ref) {
       fontWeight = _ref$fontWeight === void 0 ? 'regular' : _ref$fontWeight,
       _ref$intent = _ref.intent,
       intent = _ref$intent === void 0 ? 'body' : _ref$intent,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$c);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$c);
 
-  return /*#__PURE__*/React.createElement(StyledText$3, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledText$3, _extends$3({}, nativeProps, {
     themeFontSize: fontSize,
     themeFontWeight: fontWeight,
     themeIntent: intent
@@ -12348,7 +14479,7 @@ var Typography = {
   Text: Text
 };
 
-var Container$1 = index$2(View)(function (_ref) {
+var Container$2 = index$2(View)(function (_ref) {
   var theme = _ref.theme,
       _ref$themeVariant = _ref.themeVariant,
       themeVariant = _ref$themeVariant === void 0 ? 'default' : _ref$themeVariant,
@@ -12360,21 +14491,21 @@ var Container$1 = index$2(View)(function (_ref) {
     flexDirection: 'row'
   };
 });
-var IconContainer = index$2(View)(function (_ref2) {
+var IconContainer$1 = index$2(View)(function (_ref2) {
   var theme = _ref2.theme;
   return {
     alignItems: 'center',
     paddingLeft: theme.__hd__.alert.space.padding
   };
 });
-var TextContainer = index$2(View)(function (_ref3) {
+var TextContainer$1 = index$2(View)(function (_ref3) {
   var theme = _ref3.theme;
   return {
     paddingHorizontal: theme.__hd__.alert.space.padding,
     flex: 1
   };
 });
-var ContentContainer = index$2(View)(function (_ref4) {
+var ContentContainer$1 = index$2(View)(function (_ref4) {
   var theme = _ref4.theme,
       showDivider = _ref4.showDivider;
   return {
@@ -12385,7 +14516,7 @@ var ContentContainer = index$2(View)(function (_ref4) {
     flexDirection: 'row'
   };
 });
-var CTAWrapper = index$2(TouchableOpacity)(function (_ref5) {
+var CTAWrapper$1 = index$2(TouchableOpacity)(function (_ref5) {
   var theme = _ref5.theme;
   return {
     paddingHorizontal: theme.__hd__.alert.space.padding,
@@ -12393,7 +14524,7 @@ var CTAWrapper = index$2(TouchableOpacity)(function (_ref5) {
   };
 });
 
-var getIntentIcon = function getIntentIcon(intent) {
+var getIntentIcon$1 = function getIntentIcon(intent) {
   switch (intent) {
     case 'success':
       return 'circle-ok';
@@ -12420,21 +14551,21 @@ var Alert = function Alert(_ref) {
       variant = _ref$variant === void 0 ? 'default' : _ref$variant,
       style = _ref.style,
       testID = _ref.testID;
-  return /*#__PURE__*/React.createElement(Container$1, {
+  return /*#__PURE__*/React.createElement(Container$2, {
     themeVariant: variant,
     themeIntent: intent,
     style: style,
     testID: testID
-  }, /*#__PURE__*/React.createElement(ContentContainer, {
+  }, /*#__PURE__*/React.createElement(ContentContainer$1, {
     showDivider: !!onClose
-  }, icon !== null ? /*#__PURE__*/React.createElement(IconContainer, {
+  }, icon !== null ? /*#__PURE__*/React.createElement(IconContainer$1, {
     testID: "alert-left-icon"
   }, /*#__PURE__*/React.createElement(Icon, {
-    icon: icon || getIntentIcon(intent),
+    icon: icon || getIntentIcon$1(intent),
     size: "small"
-  })) : null, /*#__PURE__*/React.createElement(TextContainer, null, typeof title === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, {
+  })) : null, /*#__PURE__*/React.createElement(TextContainer$1, null, typeof title === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, {
     fontWeight: "semi-bold"
-  }, title) : title, typeof content === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, null, content) : content)), onClose ? /*#__PURE__*/React.createElement(CTAWrapper, {
+  }, title) : title, typeof content === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, null, content) : content)), onClose ? /*#__PURE__*/React.createElement(CTAWrapper$1, {
     onPress: onClose,
     testID: "alert-close-icon"
   }, /*#__PURE__*/React.createElement(Icon, {
@@ -12573,7 +14704,7 @@ var Status = function Status(_ref) {
       intent = _ref$intent === void 0 ? 'danger' : _ref$intent,
       style = _ref.style,
       testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$b);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$b);
 
   var _React$useRef = React.useRef(new Animated.Value(visible ? 1 : 0)),
       opacity = _React$useRef.current;
@@ -12592,7 +14723,7 @@ var Status = function Status(_ref) {
       useNativeDriver: true
     }).start();
   }, [visible, opacity]);
-  return /*#__PURE__*/React.createElement(View, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(View, _extends$3({}, nativeProps, {
     style: style,
     testID: testID
   }), children, /*#__PURE__*/React.createElement(StyledStatus, {
@@ -12626,7 +14757,7 @@ var Badge = function Badge(_ref) {
       intent = _ref$intent === void 0 ? 'danger' : _ref$intent,
       style = _ref.style,
       testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$a);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$a);
 
   var _React$useRef = React.useRef(new Animated.Value(visible ? 1 : 0)),
       opacity = _React$useRef.current;
@@ -12646,7 +14777,7 @@ var Badge = function Badge(_ref) {
     }).start();
   }, [visible, opacity]);
   var content = typeof originalContent === 'number' && originalContent > max ? "".concat(max, "+") : String(originalContent);
-  return /*#__PURE__*/React.createElement(StyledView$2, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledView$2, _extends$3({}, nativeProps, {
     themeIntent: intent,
     themePadding: getPaddingState(content),
     style: [{
@@ -12735,7 +14866,7 @@ var BottomNavigation = function BottomNavigation(_ref) {
       renderActiveTabOnly = _ref$renderActiveTabO === void 0 ? false : _ref$renderActiveTabO,
       selectedTabKey = _ref.selectedTabKey,
       tabs = _ref.tabs,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$9);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$9);
 
   var insets = useSafeAreaInsets();
   /**
@@ -12750,7 +14881,7 @@ var BottomNavigation = function BottomNavigation(_ref) {
   if (!loaded.includes(selectedTabKey)) {
     // Set the current tab to be loaded if it was not loaded before
     setLoaded(function (loadedState) {
-      return [].concat(_toConsumableArray(loadedState), [selectedTabKey]);
+      return [].concat(_toConsumableArray$1(loadedState), [selectedTabKey]);
     });
   }
 
@@ -12833,9 +14964,9 @@ var Divider = function Divider(_ref) {
       marginVertical = _ref.marginVertical,
       style = _ref.style,
       testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$8);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$8);
 
-  return /*#__PURE__*/React.createElement(StyledDivider, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledDivider, _extends$3({}, nativeProps, {
     themeMarginHorizontal: marginHorizontal,
     themeMarginVertical: marginVertical,
     style: style,
@@ -12844,7 +14975,7 @@ var Divider = function Divider(_ref) {
 };
 
 var AnimatedPressable$1 = Animated.createAnimatedComponent(Pressable);
-var StyledWrapper$4 = index$2(View)(_objectSpread2(_objectSpread2({}, StyleSheet$1.absoluteFillObject), {}, {
+var StyledWrapper$5 = index$2(View)(_objectSpread2(_objectSpread2({}, StyleSheet$1.absoluteFillObject), {}, {
   flexDirection: 'column-reverse'
 }));
 var StyledBottomSheet = index$2(Animated.View)(function (_ref) {
@@ -12995,7 +15126,7 @@ var LoadingIndicator = function LoadingIndicator(_ref2) {
       size = _ref2$size === void 0 ? 12 : _ref2$size,
       testID = _ref2.testID,
       themeVariant = _ref2.themeVariant,
-      nativeProps = _objectWithoutProperties(_ref2, _excluded$7);
+      nativeProps = _objectWithoutProperties$1(_ref2, _excluded$7);
 
   var progressAnimation = useRef(new Animated.Value(0));
   useEffect(function () {
@@ -13025,7 +15156,7 @@ var LoadingIndicator = function LoadingIndicator(_ref2) {
     return null;
   };
 
-  return /*#__PURE__*/React.createElement(AnimatedLoadingIndicatorWrapper, _extends$1({
+  return /*#__PURE__*/React.createElement(AnimatedLoadingIndicatorWrapper, _extends$3({
     testID: testID
   }, nativeProps), Array.from(new Array(count), renderLoadingDot, themeVariant));
 };
@@ -13461,7 +15592,7 @@ var BottomSheet = function BottomSheet(_ref) {
     transparent: true,
     testID: testID,
     onShow: onOpen
-  }, /*#__PURE__*/React.createElement(StyledWrapper$4, {
+  }, /*#__PURE__*/React.createElement(StyledWrapper$5, {
     pointerEvents: "box-none"
   }, /*#__PURE__*/React.createElement(StyledBackdrop$2, {
     style: {
@@ -13525,16 +15656,16 @@ var Card = function Card(_ref) {
   var _ref$variant = _ref.variant,
       variant = _ref$variant === void 0 ? 'basic' : _ref$variant,
       children = _ref.children,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$6);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$6);
 
-  return /*#__PURE__*/React.createElement(StyledCard, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledCard, _extends$3({}, nativeProps, {
     themeVariant: variant
   }), variant === 'data' && /*#__PURE__*/React.createElement(LeftDataCard, {
     testID: "data-card-indicator"
   }), children);
 };
 
-var StyledWrapper$3 = index$2(Animated.View)(function () {
+var StyledWrapper$4 = index$2(Animated.View)(function () {
   return {
     margin: 0,
     padding: 0,
@@ -13594,7 +15725,7 @@ var Collapse = function Collapse(_ref) {
     var height = _ref2.height;
     setContentHeight(height);
   }, [contentHeight]);
-  return /*#__PURE__*/React.createElement(StyledWrapper$3, {
+  return /*#__PURE__*/React.createElement(StyledWrapper$4, {
     style: [style, {
       height: collapseAnim
     }],
@@ -13606,6 +15737,46 @@ var Collapse = function Collapse(_ref) {
   }, children)));
 };
 
+var StyledWrapper$3 = index$2(TouchableOpacity)(function (_ref) {
+  var theme = _ref.theme,
+      disabled = _ref.disabled;
+  return {
+    display: 'flex',
+    flexDirection: 'row',
+    justifyContent: 'center',
+    height: theme.__hd__.checkbox.sizes.base,
+    width: theme.__hd__.checkbox.sizes.base,
+    borderRadius: theme.__hd__.checkbox.radii.base,
+    borderWidth: theme.__hd__.checkbox.borderWidths["default"],
+    borderColor: disabled ? theme.__hd__.checkbox.colors.disabled : theme.__hd__.checkbox.colors.borderColor,
+    overflow: 'hidden'
+  };
+});
+
+var CheckBox = function CheckBox(_ref) {
+  var checked = _ref.checked,
+      disabled = _ref.disabled,
+      onPress = _ref.onPress,
+      style = _ref.style,
+      testID = _ref.testID;
+  return /*#__PURE__*/React.createElement(StyledWrapper$3, {
+    onPress: onPress,
+    disabled: disabled,
+    style: style,
+    testID: testID
+  }, checked && /*#__PURE__*/React.createElement(Icon, {
+    icon: "circle-ok",
+    intent: "primary",
+    size: "large",
+    style: _objectSpread2({
+      position: 'absolute',
+      top: theme.__hd__.checkbox.space.iconTop
+    }, disabled ? {
+      color: theme.__hd__.checkbox.colors.disabled
+    } : {})
+  }));
+};
+
 var Wrapper$1 = index$2(View)(function () {
   return {
     flex: 1,
@@ -13779,7 +15950,7 @@ var AnimatedIcons = Animated.createAnimatedComponent(StyledFABIcon);
 
 var AnimatedFABIcon = function AnimatedFABIcon(_ref) {
   var active = _ref.active,
-      iconProps = _objectWithoutProperties(_ref, _excluded$5);
+      iconProps = _objectWithoutProperties$1(_ref, _excluded$5);
 
   var rotateAnimation = useRef(new Animated.Value(active ? 1 : 0));
   useEffect(function () {
@@ -13951,7 +16122,7 @@ var ActionItemsListComponent = function ActionItemsListComponent(_ref) {
   return /*#__PURE__*/React.createElement(View, {
     style: style
   }, items === null || items === void 0 ? void 0 : items.map(function (itemProp) {
-    return /*#__PURE__*/React.createElement(ActionItem, _extends$1({
+    return /*#__PURE__*/React.createElement(ActionItem, _extends$3({
       key: itemProp.icon
     }, itemProp));
   }));
@@ -14090,7 +16261,7 @@ var ProgressCircle = function ProgressCircle(_ref2) {
       intent = _ref2$intent === void 0 ? 'primary' : _ref2$intent,
       style = _ref2.style,
       testID = _ref2.testID,
-      nativeProps = _objectWithoutProperties(_ref2, _excluded$4);
+      nativeProps = _objectWithoutProperties$1(_ref2, _excluded$4);
 
   var theme = useTheme$1();
   var radius = theme.__hd__.progress.sizes.radius;
@@ -14128,7 +16299,7 @@ var ProgressCircle = function ProgressCircle(_ref2) {
     outputRange: ['0deg', '360deg'],
     extrapolate: 'clamp'
   });
-  return /*#__PURE__*/React.createElement(View, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(View, _extends$3({}, nativeProps, {
     testID: testID,
     style: style
   }), /*#__PURE__*/React.createElement(View, {
@@ -14216,7 +16387,7 @@ var ProgressBar = function ProgressBar(_ref) {
       intent = _ref$intent === void 0 ? 'primary' : _ref$intent,
       style = _ref.style,
       testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$3);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$3);
 
   var _useState = useState(0),
       _useState2 = _slicedToArray(_useState, 2),
@@ -14244,7 +16415,7 @@ var ProgressBar = function ProgressBar(_ref) {
     outputRange: [999, 0],
     extrapolate: 'clamp'
   });
-  return /*#__PURE__*/React.createElement(StyledWrapper$2, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledWrapper$2, _extends$3({}, nativeProps, {
     testID: testID,
     style: style
   }), /*#__PURE__*/React.createElement(StyledInner, {
@@ -14366,7 +16537,7 @@ var _excluded$2 = ["testID"];
 
 var Spinner = function Spinner(_ref) {
   var testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$2);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$2);
 
   return /*#__PURE__*/React.createElement(StyledView$1, nativeProps, /*#__PURE__*/React.createElement(StyledSpinnerContainer, {
     testID: testID
@@ -14544,7 +16715,7 @@ var SectionHeading = function SectionHeading(_ref) {
   }, text)), rightChildren);
 };
 
-var Container = index$2(View)(function (_ref) {
+var Container$1 = index$2(View)(function (_ref) {
   var theme = _ref.theme;
   return {
     position: 'relative',
@@ -14586,9 +16757,9 @@ var TextInput = function TextInput(_ref) {
       textStyle = _ref.textStyle,
       testID = _ref.testID,
       accessibilityLabelledBy = _ref.accessibilityLabelledBy,
-      nativeProps = _objectWithoutProperties(_ref, _excluded$1);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded$1);
 
-  return /*#__PURE__*/React.createElement(Container, {
+  return /*#__PURE__*/React.createElement(Container$1, {
     style: style,
     testID: testID
   }, label && /*#__PURE__*/React.createElement(Label, {
@@ -14599,7 +16770,7 @@ var TextInput = function TextInput(_ref) {
     testID: "input-prefix",
     icon: prefix,
     size: "xsmall"
-  }), /*#__PURE__*/React.createElement(StyledTextInput, _extends$1({
+  }), /*#__PURE__*/React.createElement(StyledTextInput, _extends$3({
     style: textStyle,
     testID: "text-input" // @ts-ignore
     ,
@@ -14703,7 +16874,7 @@ function OptionList(_ref2) {
             return val !== opt.value;
           }));
         } else {
-          _onPress([].concat(_toConsumableArray(value), [opt.value]));
+          _onPress([].concat(_toConsumableArray$1(value), [opt.value]));
         }
       }
     }));
@@ -14875,6 +17046,206 @@ var Switch = function Switch(_ref) {
   }))));
 };
 
+var childrenWithOverriddenStyle = function childrenWithOverriddenStyle(children) {
+  return Children.map(children, function (child) {
+    var element = child;
+    return (
+      /*#__PURE__*/
+      // Add a wrapper to ensure layout is calculated correctly
+      React.createElement(View, {
+        style: StyleSheet$1.absoluteFill,
+        collapsable: false
+      }, /*#__PURE__*/React.cloneElement(element, _objectSpread2(_objectSpread2({}, element.props), {}, {
+        // Override styles so that each page will fill the parent.
+        style: [element.props.style, StyleSheet$1.absoluteFill]
+      })))
+    );
+  });
+};
+
+var VIEW_MANAGER_NAME = 'RNCViewPager';
+var PagerViewViewManager = requireNativeComponent(VIEW_MANAGER_NAME);
+function getViewManagerConfig() {
+  var viewManagerName = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : VIEW_MANAGER_NAME;
+  return UIManager.getViewManagerConfig(viewManagerName);
+}
+
+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 _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+/**
+ * Container that allows to flip left and right between child views. Each
+ * child view of the `PagerView` will be treated as a separate page
+ * and will be stretched to fill the `PagerView`.
+ *
+ * It is important all children are `<View>`s and not composite components.
+ * You can set style properties like `padding` or `backgroundColor` for each
+ * child. It is also important that each child have a `key` prop.
+ *
+ * Example:
+ *
+ * ```
+ * render: function() {
+ *   return (
+ *     <PagerView
+ *       style={styles.PagerView}
+ *       initialPage={0}>
+ *       <View style={styles.pageStyle} key="1">
+ *         <Text>First page</Text>
+ *       </View>
+ *       <View style={styles.pageStyle} key="2">
+ *         <Text>Second page</Text>
+ *       </View>
+ *     </PagerView>
+ *   );
+ * }
+ *
+ * ...
+ *
+ * var styles = {
+ *   ...
+ *   PagerView: {
+ *     flex: 1
+ *   },
+ *   pageStyle: {
+ *     alignItems: 'center',
+ *     padding: 20,
+ *   }
+ * }
+ * ```
+ */
+
+var PagerView = /*#__PURE__*/function (_React$Component) {
+  _inherits$1(PagerView, _React$Component);
+
+  var _super = _createSuper(PagerView);
+
+  function PagerView() {
+    var _this;
+
+    _classCallCheck$1(this, PagerView);
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(args));
+
+    _defineProperty(_assertThisInitialized$1(_this), "isScrolling", false);
+
+    _defineProperty(_assertThisInitialized$1(_this), "PagerView", /*#__PURE__*/React.createRef());
+
+    _defineProperty(_assertThisInitialized$1(_this), "getInnerViewNode", function () {
+      return _this.PagerView.current.getInnerViewNode();
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "_onPageScroll", function (e) {
+      if (_this.props.onPageScroll) {
+        _this.props.onPageScroll(e);
+      } // Not implemented on iOS yet
+
+
+      if (Platform.OS === 'android') {
+        if (_this.props.keyboardDismissMode === 'on-drag') {
+          Keyboard.dismiss();
+        }
+      }
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "_onPageScrollStateChanged", function (e) {
+      if (_this.props.onPageScrollStateChanged) {
+        _this.props.onPageScrollStateChanged(e);
+      }
+
+      _this.isScrolling = e.nativeEvent.pageScrollState === 'dragging';
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "_onPageSelected", function (e) {
+      if (_this.props.onPageSelected) {
+        _this.props.onPageSelected(e);
+      }
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "setPage", function (selectedPage) {
+      UIManager.dispatchViewManagerCommand(ReactNative__default.findNodeHandle(_assertThisInitialized$1(_this)), getViewManagerConfig().Commands.setPage, [selectedPage]);
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "setPageWithoutAnimation", function (selectedPage) {
+      UIManager.dispatchViewManagerCommand(ReactNative__default.findNodeHandle(_assertThisInitialized$1(_this)), getViewManagerConfig().Commands.setPageWithoutAnimation, [selectedPage]);
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "setScrollEnabled", function (scrollEnabled) {
+      UIManager.dispatchViewManagerCommand(ReactNative__default.findNodeHandle(_assertThisInitialized$1(_this)), getViewManagerConfig().Commands.setScrollEnabled, [scrollEnabled]);
+    });
+
+    _defineProperty(_assertThisInitialized$1(_this), "_onMoveShouldSetResponderCapture", function () {
+      return _this.isScrolling;
+    });
+
+    return _this;
+  }
+
+  _createClass$1(PagerView, [{
+    key: "deducedLayoutDirection",
+    get: function get() {
+      var shouldUseDeviceRtlSetup = !this.props.layoutDirection || this.props.layoutDirection === 'locale';
+
+      if (shouldUseDeviceRtlSetup) {
+        return I18nManager.isRTL ? 'rtl' : 'ltr';
+      } else {
+        return this.props.layoutDirection;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(PagerViewViewManager, _extends({}, this.props, {
+        ref: this.PagerView
+        /** TODO: Fix ref type */
+        ,
+        style: this.props.style,
+        layoutDirection: this.deducedLayoutDirection,
+        onPageScroll: this._onPageScroll,
+        onPageScrollStateChanged: this._onPageScrollStateChanged,
+        onPageSelected: this._onPageSelected,
+        onMoveShouldSetResponderCapture: this._onMoveShouldSetResponderCapture,
+        children: childrenWithOverriddenStyle(this.props.children)
+      }));
+    }
+  }]);
+
+  return PagerView;
+}(React.Component);
+
 var AnimatedPagerView = Animated.createAnimatedComponent(PagerView);
 var TabContainer$1 = index$2(View)({
   flex: 1,
@@ -15058,7 +17429,7 @@ var ScrollableTab = function ScrollableTab(_ref2) {
       });
     }
 
-    var animation = Animated.parallel(_toConsumableArray(tabs.map(function (_, i) {
+    var animation = Animated.parallel(_toConsumableArray$1(tabs.map(function (_, i) {
       return Animated.timing(tabsAnims[i], {
         toValue: i === selectedTabIndex ? 1 : 0,
         duration: 150,
@@ -15334,9 +17705,9 @@ var Tag = function Tag(_ref) {
       intent = _ref$intent === void 0 ? 'info' : _ref$intent,
       style = _ref.style,
       testID = _ref.testID,
-      nativeProps = _objectWithoutProperties(_ref, _excluded);
+      nativeProps = _objectWithoutProperties$1(_ref, _excluded);
 
-  return /*#__PURE__*/React.createElement(StyledView, _extends$1({}, nativeProps, {
+  return /*#__PURE__*/React.createElement(StyledView, _extends$3({}, nativeProps, {
     themeIntent: intent,
     style: style,
     testID: testID
@@ -15345,4 +17716,291 @@ var Tag = function Tag(_ref) {
   }, content));
 };
 
-export { Alert, Avatar, Badge$1 as Badge, BottomNavigation, BottomSheet, CompoundButton as Button, Card, Collapse, ContentNavigator, Divider, Drawer, index$1 as FAB, Icon, Progress, CompoundRadio as Radio, SectionHeading, CompoundSelect as Select, Spinner, Switch, index as Tabs, Tag, TextInput, ThemeProvider, Typography, getTheme, scale, theme, useTheme };
+var ToastContainerWrapper = index$2(View)(function (_ref) {
+  var theme = _ref.theme,
+      position = _ref.position;
+  return _objectSpread2(_objectSpread2({}, StyleSheet$1.absoluteFillObject), {}, {
+    paddingHorizontal: theme.__hd__.toast.space.largePadding,
+    paddingVertical: theme.__hd__.toast.space.mediumPadding,
+    flexDirection: position === 'bottom' ? 'column-reverse' : 'column',
+    elevation: 9999
+  });
+});
+var Container = index$2(Animated.View)(function (_ref2) {
+  var theme = _ref2.theme,
+      themeVariant = _ref2.themeVariant,
+      themeIntent = _ref2.themeIntent;
+  return {
+    borderRadius: themeVariant === 'round' ? theme.__hd__.toast.radii["default"] : 0,
+    backgroundColor: theme.__hd__.toast.colors[themeIntent],
+    minHeight: theme.__hd__.toast.sizes.height,
+    flexDirection: 'row'
+  };
+});
+var IconContainer = index$2(View)(function (_ref3) {
+  var theme = _ref3.theme;
+  return {
+    alignItems: 'center',
+    paddingLeft: theme.__hd__.toast.space.mediumPadding
+  };
+});
+var TextContainer = index$2(View)(function (_ref4) {
+  var theme = _ref4.theme;
+  return {
+    paddingHorizontal: theme.__hd__.toast.space.mediumPadding,
+    flex: 1
+  };
+});
+var ContentContainer = index$2(View)(function (_ref5) {
+  var theme = _ref5.theme,
+      showDivider = _ref5.showDivider;
+  return {
+    paddingVertical: theme.__hd__.toast.space.mediumPadding,
+    flex: 1,
+    borderRightWidth: showDivider ? theme.__hd__.toast.borderWidths.base : 0,
+    borderColor: theme.__hd__.toast.colors.divider,
+    flexDirection: 'row'
+  };
+});
+var CTAWrapper = index$2(TouchableOpacity)(function (_ref6) {
+  var theme = _ref6.theme;
+  return {
+    paddingHorizontal: theme.__hd__.alert.space.padding,
+    justifyContent: 'center'
+  };
+});
+
+var ToastContext = /*#__PURE__*/createContext({});
+var ToastConfigContext = /*#__PURE__*/createContext({});
+var useToastConfig = function useToastConfig() {
+  return useContext(ToastConfigContext);
+};
+var useToast = function useToast() {
+  return useContext(ToastContext);
+};
+
+var getIntentIcon = function getIntentIcon(intent) {
+  switch (intent) {
+    case 'success':
+      return 'circle-ok';
+
+    case 'warning':
+      return 'warning';
+
+    case 'info':
+      return 'circle-info';
+
+    case 'error':
+      return 'circle-warning';
+  }
+};
+
+var Toast$1 = function Toast(_ref) {
+  var content = _ref.content,
+      icon = _ref.icon,
+      _ref$variant = _ref.variant,
+      variant = _ref$variant === void 0 ? 'default' : _ref$variant,
+      _ref$intent = _ref.intent,
+      intent = _ref$intent === void 0 ? 'info' : _ref$intent,
+      style = _ref.style,
+      _ref$duration = _ref.duration,
+      duration = _ref$duration === void 0 ? 2000 : _ref$duration,
+      _ref$autoDismiss = _ref.autoDismiss,
+      autoDismiss = _ref$autoDismiss === void 0 ? true : _ref$autoDismiss,
+      onAction = _ref.onAction,
+      actionLabel = _ref.actionLabel,
+      onDismiss = _ref.onDismiss;
+  var animatedValue = useRef(new Animated.Value(0)).current;
+  var toastConfig = useToastConfig();
+  useEffect(function () {
+    if (autoDismiss && duration >= 0) {
+      var id = setTimeout(function () {
+        return onDismiss === null || onDismiss === void 0 ? void 0 : onDismiss();
+      }, duration);
+      return function () {
+        return clearTimeout(id);
+      };
+    } // Consistent return
+
+
+    return function () {};
+  }, []);
+  useEffect(function () {
+    var animation = Animated.timing(animatedValue, {
+      toValue: 1,
+      useNativeDriver: true
+    });
+    animation.start();
+    return function () {
+      return animation.stop();
+    };
+  }, []);
+  useLayoutEffect(function () {
+    LayoutAnimation.configureNext(LayoutAnimation.Presets.easeInEaseOut);
+  });
+  var interpolateY = animatedValue.interpolate({
+    inputRange: [0, 1],
+    outputRange: [toastConfig.position === 'top' ? -20 : 20, 0]
+  });
+  return /*#__PURE__*/React.createElement(Container, {
+    themeVariant: variant,
+    themeIntent: intent,
+    style: [style, {
+      opacity: animatedValue,
+      transform: [{
+        translateY: interpolateY
+      }]
+    }]
+  }, /*#__PURE__*/React.createElement(ContentContainer, {
+    showDivider: !!actionLabel
+  }, icon !== null ? /*#__PURE__*/React.createElement(IconContainer, {
+    testID: "toast-left-icon"
+  }, /*#__PURE__*/React.createElement(Icon, {
+    icon: icon || getIntentIcon(intent),
+    size: "small"
+  })) : null, /*#__PURE__*/React.createElement(TextContainer, null, typeof content === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, null, content) : content)), actionLabel ? /*#__PURE__*/React.createElement(CTAWrapper, {
+    testID: "toast-action-button",
+    onPress: function onPress() {
+      onAction === null || onAction === void 0 ? void 0 : onAction();
+      onDismiss === null || onDismiss === void 0 ? void 0 : onDismiss();
+    }
+  }, typeof actionLabel === 'string' ? /*#__PURE__*/React.createElement(Typography.Text, {
+    fontWeight: "semi-bold"
+  }, actionLabel) : actionLabel) : null);
+};
+
+var generateID = function generateID() {
+  return (performance.now().toString(36) + Math.random().toString(36)).replace(/\./g, '');
+};
+
+var SingleToastDisplay = function SingleToastDisplay(_ref) {
+  var toastList = _ref.toastList,
+      setToastList = _ref.setToastList;
+  var theme = useTheme$1();
+  var toast = toastList[toastList.length - 1];
+  return toast ? /*#__PURE__*/React.createElement(Toast$1, _extends$3({}, toast.props, {
+    key: toast.id,
+    style: {
+      marginBottom: theme.space.small
+    },
+    onDismiss: function onDismiss() {
+      var _toast$props$onDismis, _toast$props;
+
+      setToastList(function (state) {
+        return state.filter(function (item) {
+          return item.id !== toast.id;
+        });
+      });
+      (_toast$props$onDismis = (_toast$props = toast.props).onDismiss) === null || _toast$props$onDismis === void 0 ? void 0 : _toast$props$onDismis.call(_toast$props);
+    }
+  })) : null;
+};
+
+var ToastContainer = /*#__PURE__*/React.forwardRef(function (_ref2, ref) {
+  var _ref2$displayType = _ref2.displayType,
+      displayType = _ref2$displayType === void 0 ? 'single' : _ref2$displayType,
+      _ref2$position = _ref2.position,
+      position = _ref2$position === void 0 ? 'top' : _ref2$position,
+      style = _ref2.style;
+  var theme = useTheme$1();
+
+  var _useState = useState([]),
+      _useState2 = _slicedToArray(_useState, 2),
+      toastList = _useState2[0],
+      setToastList = _useState2[1];
+
+  useImperativeHandle(ref, function () {
+    return {
+      show: function show(props) {
+        var item = {
+          id: generateID(),
+          props: props
+        };
+        setToastList(function (state) {
+          return [item].concat(_toConsumableArray$1(state));
+        });
+        return item.id;
+      },
+      hide: function hide(id) {
+        setToastList(function (state) {
+          return state.filter(function (item) {
+            return item.id !== id;
+          });
+        });
+      },
+      clearAll: function clearAll() {
+        setToastList([]);
+      }
+    };
+  });
+  return /*#__PURE__*/React.createElement(ToastContainerWrapper, {
+    pointerEvents: "box-none",
+    position: position,
+    style: style
+  }, displayType === 'single' ? /*#__PURE__*/React.createElement(SingleToastDisplay, {
+    toastList: toastList,
+    setToastList: setToastList
+  }) : toastList.map(function (_ref3) {
+    var id = _ref3.id,
+        props = _ref3.props;
+    return /*#__PURE__*/React.createElement(Toast$1, _extends$3({}, props, {
+      key: id,
+      style: {
+        marginBottom: theme.space.small
+      },
+      onDismiss: function onDismiss() {
+        var _props$onDismiss;
+
+        setToastList(function (state) {
+          return state.filter(function (item) {
+            return item.id !== id;
+          });
+        });
+        (_props$onDismiss = props.onDismiss) === null || _props$onDismiss === void 0 ? void 0 : _props$onDismiss.call(props);
+      }
+    }));
+  }));
+});
+
+var ToastProvider = function ToastProvider(_ref) {
+  var children = _ref.children,
+      _ref$displayType = _ref.displayType,
+      displayType = _ref$displayType === void 0 ? 'single' : _ref$displayType,
+      _ref$position = _ref.position,
+      position = _ref$position === void 0 ? 'top' : _ref$position;
+  var toastRef = useRef(null);
+
+  var _useState = useState({}),
+      _useState2 = _slicedToArray(_useState, 2),
+      refState = _useState2[0],
+      setRefState = _useState2[1];
+
+  useEffect(function () {
+    if (toastRef.current) {
+      setRefState(toastRef.current);
+    }
+  }, []);
+  var config = useMemo(function () {
+    return {
+      displayType: displayType,
+      position: position
+    };
+  }, [displayType, position]);
+  return /*#__PURE__*/React.createElement(ToastContext.Provider, {
+    value: refState
+  }, children, /*#__PURE__*/React.createElement(ToastConfigContext.Provider, {
+    value: config
+  }, /*#__PURE__*/React.createElement(ToastContainer, {
+    ref: toastRef,
+    displayType: displayType,
+    position: position
+  })));
+};
+
+var Toast = {
+  Provider: ToastProvider,
+  Container: ToastContainer,
+  useToast: useToast
+};
+
+export { Alert, Avatar, Badge$1 as Badge, BottomNavigation, BottomSheet, CompoundButton as Button, Card, CheckBox as Checkbox, Collapse, ContentNavigator, Divider, Drawer, index$1 as FAB, Icon, Progress, CompoundRadio as Radio, SectionHeading, CompoundSelect as Select, Spinner, Switch, index as Tabs, Tag, TextInput, ThemeProvider, Toast, Typography, getTheme, scale, theme, useTheme };