@class101/cdn-ui-system 0.0.12 → 0.0.13

package/chunk-EZJASZYR.js

@@ -0,0 +1,1668 @@
+import {
+  require_object_assign
+} from "./chunk-R4HM35UZ.js";
+import {
+  __commonJS,
+  __require,
+  init_react_shim
+} from "./chunk-VIIHQGZ3.js";
+
+// node_modules/fbjs/lib/ExecutionEnvironment.js
+var require_ExecutionEnvironment = __commonJS({
+  "node_modules/fbjs/lib/ExecutionEnvironment.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+    var ExecutionEnvironment = {
+      canUseDOM,
+      canUseWorkers: typeof Worker !== "undefined",
+      canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
+      canUseViewport: canUseDOM && !!window.screen,
+      isInWorker: !canUseDOM
+    };
+    module.exports = ExecutionEnvironment;
+  }
+});
+
+// node_modules/normalize-css-color/index.js
+var require_normalize_css_color = __commonJS({
+  "node_modules/normalize-css-color/index.js"(exports, module) {
+    init_react_shim();
+    function normalizeColor(color) {
+      var match;
+      if (typeof color === "number") {
+        if (color >>> 0 === color && color >= 0 && color <= 4294967295) {
+          return color;
+        }
+        return null;
+      }
+      if (match = matchers.hex6.exec(color)) {
+        return parseInt(match[1] + "ff", 16) >>> 0;
+      }
+      if (names.hasOwnProperty(color)) {
+        return names[color];
+      }
+      if (match = matchers.rgb.exec(color)) {
+        return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | 255) >>> 0;
+      }
+      if (match = matchers.rgba.exec(color)) {
+        return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | parse1(match[4])) >>> 0;
+      }
+      if (match = matchers.hex3.exec(color)) {
+        return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + "ff", 16) >>> 0;
+      }
+      if (match = matchers.hex8.exec(color)) {
+        return parseInt(match[1], 16) >>> 0;
+      }
+      if (match = matchers.hex4.exec(color)) {
+        return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + match[4] + match[4], 16) >>> 0;
+      }
+      if (match = matchers.hsl.exec(color)) {
+        return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | 255) >>> 0;
+      }
+      if (match = matchers.hsla.exec(color)) {
+        return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | parse1(match[4])) >>> 0;
+      }
+      return null;
+    }
+    function hue2rgb(p, q, t) {
+      if (t < 0) {
+        t += 1;
+      }
+      if (t > 1) {
+        t -= 1;
+      }
+      if (t < 1 / 6) {
+        return p + (q - p) * 6 * t;
+      }
+      if (t < 1 / 2) {
+        return q;
+      }
+      if (t < 2 / 3) {
+        return p + (q - p) * (2 / 3 - t) * 6;
+      }
+      return p;
+    }
+    function hslToRgb(h, s, l) {
+      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      var p = 2 * l - q;
+      var r = hue2rgb(p, q, h + 1 / 3);
+      var g = hue2rgb(p, q, h);
+      var b = hue2rgb(p, q, h - 1 / 3);
+      return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
+    }
+    var NUMBER = "[-+]?\\d*\\.?\\d+";
+    var PERCENTAGE = NUMBER + "%";
+    function toArray(arrayLike) {
+      return Array.prototype.slice.call(arrayLike, 0);
+    }
+    function call() {
+      return "\\(\\s*(" + toArray(arguments).join(")\\s*,\\s*(") + ")\\s*\\)";
+    }
+    var matchers = {
+      rgb: new RegExp("rgb" + call(NUMBER, NUMBER, NUMBER)),
+      rgba: new RegExp("rgba" + call(NUMBER, NUMBER, NUMBER, NUMBER)),
+      hsl: new RegExp("hsl" + call(NUMBER, PERCENTAGE, PERCENTAGE)),
+      hsla: new RegExp("hsla" + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)),
+      hex3: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+      hex4: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+      hex6: /^#([0-9a-fA-F]{6})$/,
+      hex8: /^#([0-9a-fA-F]{8})$/
+    };
+    function parse255(str) {
+      var int = parseInt(str, 10);
+      if (int < 0) {
+        return 0;
+      }
+      if (int > 255) {
+        return 255;
+      }
+      return int;
+    }
+    function parse360(str) {
+      var int = parseFloat(str);
+      return (int % 360 + 360) % 360 / 360;
+    }
+    function parse1(str) {
+      var num = parseFloat(str);
+      if (num < 0) {
+        return 0;
+      }
+      if (num > 1) {
+        return 255;
+      }
+      return Math.round(num * 255);
+    }
+    function parsePercentage(str) {
+      var int = parseFloat(str, 10);
+      if (int < 0) {
+        return 0;
+      }
+      if (int > 100) {
+        return 1;
+      }
+      return int / 100;
+    }
+    var names = {
+      transparent: 0,
+      aliceblue: 4042850303,
+      antiquewhite: 4209760255,
+      aqua: 16777215,
+      aquamarine: 2147472639,
+      azure: 4043309055,
+      beige: 4126530815,
+      bisque: 4293182719,
+      black: 255,
+      blanchedalmond: 4293643775,
+      blue: 65535,
+      blueviolet: 2318131967,
+      brown: 2771004159,
+      burlywood: 3736635391,
+      burntsienna: 3934150143,
+      cadetblue: 1604231423,
+      chartreuse: 2147418367,
+      chocolate: 3530104575,
+      coral: 4286533887,
+      cornflowerblue: 1687547391,
+      cornsilk: 4294499583,
+      crimson: 3692313855,
+      cyan: 16777215,
+      darkblue: 35839,
+      darkcyan: 9145343,
+      darkgoldenrod: 3095792639,
+      darkgray: 2846468607,
+      darkgreen: 6553855,
+      darkgrey: 2846468607,
+      darkkhaki: 3182914559,
+      darkmagenta: 2332068863,
+      darkolivegreen: 1433087999,
+      darkorange: 4287365375,
+      darkorchid: 2570243327,
+      darkred: 2332033279,
+      darksalmon: 3918953215,
+      darkseagreen: 2411499519,
+      darkslateblue: 1211993087,
+      darkslategray: 793726975,
+      darkslategrey: 793726975,
+      darkturquoise: 13554175,
+      darkviolet: 2483082239,
+      deeppink: 4279538687,
+      deepskyblue: 12582911,
+      dimgray: 1768516095,
+      dimgrey: 1768516095,
+      dodgerblue: 512819199,
+      firebrick: 2988581631,
+      floralwhite: 4294635775,
+      forestgreen: 579543807,
+      fuchsia: 4278255615,
+      gainsboro: 3705462015,
+      ghostwhite: 4177068031,
+      gold: 4292280575,
+      goldenrod: 3668254975,
+      gray: 2155905279,
+      green: 8388863,
+      greenyellow: 2919182335,
+      grey: 2155905279,
+      honeydew: 4043305215,
+      hotpink: 4285117695,
+      indianred: 3445382399,
+      indigo: 1258324735,
+      ivory: 4294963455,
+      khaki: 4041641215,
+      lavender: 3873897215,
+      lavenderblush: 4293981695,
+      lawngreen: 2096890111,
+      lemonchiffon: 4294626815,
+      lightblue: 2916673279,
+      lightcoral: 4034953471,
+      lightcyan: 3774873599,
+      lightgoldenrodyellow: 4210742015,
+      lightgray: 3553874943,
+      lightgreen: 2431553791,
+      lightgrey: 3553874943,
+      lightpink: 4290167295,
+      lightsalmon: 4288707327,
+      lightseagreen: 548580095,
+      lightskyblue: 2278488831,
+      lightslategray: 2005441023,
+      lightslategrey: 2005441023,
+      lightsteelblue: 2965692159,
+      lightyellow: 4294959359,
+      lime: 16711935,
+      limegreen: 852308735,
+      linen: 4210091775,
+      magenta: 4278255615,
+      maroon: 2147483903,
+      mediumaquamarine: 1724754687,
+      mediumblue: 52735,
+      mediumorchid: 3126187007,
+      mediumpurple: 2473647103,
+      mediumseagreen: 1018393087,
+      mediumslateblue: 2070474495,
+      mediumspringgreen: 16423679,
+      mediumturquoise: 1221709055,
+      mediumvioletred: 3340076543,
+      midnightblue: 421097727,
+      mintcream: 4127193855,
+      mistyrose: 4293190143,
+      moccasin: 4293178879,
+      navajowhite: 4292783615,
+      navy: 33023,
+      oldlace: 4260751103,
+      olive: 2155872511,
+      olivedrab: 1804477439,
+      orange: 4289003775,
+      orangered: 4282712319,
+      orchid: 3664828159,
+      palegoldenrod: 4008225535,
+      palegreen: 2566625535,
+      paleturquoise: 2951671551,
+      palevioletred: 3681588223,
+      papayawhip: 4293907967,
+      peachpuff: 4292524543,
+      peru: 3448061951,
+      pink: 4290825215,
+      plum: 3718307327,
+      powderblue: 2967529215,
+      purple: 2147516671,
+      rebeccapurple: 1714657791,
+      red: 4278190335,
+      rosybrown: 3163525119,
+      royalblue: 1097458175,
+      saddlebrown: 2336560127,
+      salmon: 4202722047,
+      sandybrown: 4104413439,
+      seagreen: 780883967,
+      seashell: 4294307583,
+      sienna: 2689740287,
+      silver: 3233857791,
+      skyblue: 2278484991,
+      slateblue: 1784335871,
+      slategray: 1887473919,
+      slategrey: 1887473919,
+      snow: 4294638335,
+      springgreen: 16744447,
+      steelblue: 1182971135,
+      tan: 3535047935,
+      teal: 8421631,
+      thistle: 3636451583,
+      tomato: 4284696575,
+      turquoise: 1088475391,
+      violet: 4001558271,
+      wheat: 4125012991,
+      white: 4294967295,
+      whitesmoke: 4126537215,
+      yellow: 4294902015,
+      yellowgreen: 2597139199
+    };
+    function rgba(colorInt) {
+      var r = Math.round((colorInt & 4278190080) >>> 24);
+      var g = Math.round((colorInt & 16711680) >>> 16);
+      var b = Math.round((colorInt & 65280) >>> 8);
+      var a = ((colorInt & 255) >>> 0) / 255;
+      return {
+        r,
+        g,
+        b,
+        a
+      };
+    }
+    normalizeColor.rgba = rgba;
+    module.exports = normalizeColor;
+  }
+});
+
+// node_modules/fbjs/lib/invariant.js
+var require_invariant = __commonJS({
+  "node_modules/fbjs/lib/invariant.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var validateFormat = true ? function(format) {
+      if (format === void 0) {
+        throw new Error("invariant(...): Second argument must be a string.");
+      }
+    } : function(format) {
+    };
+    function invariant(condition, format) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      validateFormat(format);
+      if (!condition) {
+        var error;
+        if (format === void 0) {
+          error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+        } else {
+          var argIndex = 0;
+          error = new Error(format.replace(/%s/g, function() {
+            return String(args[argIndex++]);
+          }));
+          error.name = "Invariant Violation";
+        }
+        error.framesToPop = 1;
+        throw error;
+      }
+    }
+    module.exports = invariant;
+  }
+});
+
+// node_modules/create-react-class/factory.js
+var require_factory = __commonJS({
+  "node_modules/create-react-class/factory.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var _assign = require_object_assign();
+    var emptyObject = {};
+    if (true) {
+      Object.freeze(emptyObject);
+    }
+    var validateFormat = function validateFormat2(format) {
+    };
+    if (true) {
+      validateFormat = function validateFormat2(format) {
+        if (format === void 0) {
+          throw new Error("invariant requires an error message argument");
+        }
+      };
+    }
+    function _invariant(condition, format, a, b, c, d, e, f) {
+      validateFormat(format);
+      if (!condition) {
+        var error;
+        if (format === void 0) {
+          error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");
+        } else {
+          var args = [a, b, c, d, e, f];
+          var argIndex = 0;
+          error = new Error(format.replace(/%s/g, function() {
+            return args[argIndex++];
+          }));
+          error.name = "Invariant Violation";
+        }
+        error.framesToPop = 1;
+        throw error;
+      }
+    }
+    var warning = function() {
+    };
+    if (true) {
+      printWarning = function printWarning2(format) {
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+        var argIndex = 0;
+        var message = "Warning: " + format.replace(/%s/g, function() {
+          return args[argIndex++];
+        });
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+      warning = function warning2(condition, format) {
+        if (format === void 0) {
+          throw new Error("`warning(condition, format, ...args)` requires a warning message argument");
+        }
+        if (format.indexOf("Failed Composite propType: ") === 0) {
+          return;
+        }
+        if (!condition) {
+          for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+            args[_key2 - 2] = arguments[_key2];
+          }
+          printWarning.apply(void 0, [format].concat(args));
+        }
+      };
+    }
+    var printWarning;
+    var MIXINS_KEY = "mixins";
+    function identity(fn) {
+      return fn;
+    }
+    var ReactPropTypeLocationNames;
+    if (true) {
+      ReactPropTypeLocationNames = {
+        prop: "prop",
+        context: "context",
+        childContext: "child context"
+      };
+    } else {
+      ReactPropTypeLocationNames = {};
+    }
+    function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
+      var injectedMixins = [];
+      var ReactClassInterface = {
+        mixins: "DEFINE_MANY",
+        statics: "DEFINE_MANY",
+        propTypes: "DEFINE_MANY",
+        contextTypes: "DEFINE_MANY",
+        childContextTypes: "DEFINE_MANY",
+        getDefaultProps: "DEFINE_MANY_MERGED",
+        getInitialState: "DEFINE_MANY_MERGED",
+        getChildContext: "DEFINE_MANY_MERGED",
+        render: "DEFINE_ONCE",
+        componentWillMount: "DEFINE_MANY",
+        componentDidMount: "DEFINE_MANY",
+        componentWillReceiveProps: "DEFINE_MANY",
+        shouldComponentUpdate: "DEFINE_ONCE",
+        componentWillUpdate: "DEFINE_MANY",
+        componentDidUpdate: "DEFINE_MANY",
+        componentWillUnmount: "DEFINE_MANY",
+        UNSAFE_componentWillMount: "DEFINE_MANY",
+        UNSAFE_componentWillReceiveProps: "DEFINE_MANY",
+        UNSAFE_componentWillUpdate: "DEFINE_MANY",
+        updateComponent: "OVERRIDE_BASE"
+      };
+      var ReactClassStaticInterface = {
+        getDerivedStateFromProps: "DEFINE_MANY_MERGED"
+      };
+      var RESERVED_SPEC_KEYS = {
+        displayName: function(Constructor, displayName) {
+          Constructor.displayName = displayName;
+        },
+        mixins: function(Constructor, mixins) {
+          if (mixins) {
+            for (var i = 0; i < mixins.length; i++) {
+              mixSpecIntoComponent(Constructor, mixins[i]);
+            }
+          }
+        },
+        childContextTypes: function(Constructor, childContextTypes) {
+          if (true) {
+            validateTypeDef(Constructor, childContextTypes, "childContext");
+          }
+          Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
+        },
+        contextTypes: function(Constructor, contextTypes) {
+          if (true) {
+            validateTypeDef(Constructor, contextTypes, "context");
+          }
+          Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
+        },
+        getDefaultProps: function(Constructor, getDefaultProps) {
+          if (Constructor.getDefaultProps) {
+            Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
+          } else {
+            Constructor.getDefaultProps = getDefaultProps;
+          }
+        },
+        propTypes: function(Constructor, propTypes) {
+          if (true) {
+            validateTypeDef(Constructor, propTypes, "prop");
+          }
+          Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
+        },
+        statics: function(Constructor, statics) {
+          mixStaticSpecIntoComponent(Constructor, statics);
+        },
+        autobind: function() {
+        }
+      };
+      function validateTypeDef(Constructor, typeDef, location) {
+        for (var propName in typeDef) {
+          if (typeDef.hasOwnProperty(propName)) {
+            if (true) {
+              warning(typeof typeDef[propName] === "function", "%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.", Constructor.displayName || "ReactClass", ReactPropTypeLocationNames[location], propName);
+            }
+          }
+        }
+      }
+      function validateMethodOverride(isAlreadyDefined, name) {
+        var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
+        if (ReactClassMixin.hasOwnProperty(name)) {
+          _invariant(specPolicy === "OVERRIDE_BASE", "ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.", name);
+        }
+        if (isAlreadyDefined) {
+          _invariant(specPolicy === "DEFINE_MANY" || specPolicy === "DEFINE_MANY_MERGED", "ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name);
+        }
+      }
+      function mixSpecIntoComponent(Constructor, spec) {
+        if (!spec) {
+          if (true) {
+            var typeofSpec = typeof spec;
+            var isMixinValid = typeofSpec === "object" && spec !== null;
+            if (true) {
+              warning(isMixinValid, "%s: You're attempting to include a mixin that is either null or not an object. Check the mixins included by the component, as well as any mixins they include themselves. Expected object but got %s.", Constructor.displayName || "ReactClass", spec === null ? null : typeofSpec);
+            }
+          }
+          return;
+        }
+        _invariant(typeof spec !== "function", "ReactClass: You're attempting to use a component class or function as a mixin. Instead, just use a regular object.");
+        _invariant(!isValidElement(spec), "ReactClass: You're attempting to use a component as a mixin. Instead, just use a regular object.");
+        var proto = Constructor.prototype;
+        var autoBindPairs = proto.__reactAutoBindPairs;
+        if (spec.hasOwnProperty(MIXINS_KEY)) {
+          RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
+        }
+        for (var name in spec) {
+          if (!spec.hasOwnProperty(name)) {
+            continue;
+          }
+          if (name === MIXINS_KEY) {
+            continue;
+          }
+          var property = spec[name];
+          var isAlreadyDefined = proto.hasOwnProperty(name);
+          validateMethodOverride(isAlreadyDefined, name);
+          if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
+            RESERVED_SPEC_KEYS[name](Constructor, property);
+          } else {
+            var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
+            var isFunction = typeof property === "function";
+            var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
+            if (shouldAutoBind) {
+              autoBindPairs.push(name, property);
+              proto[name] = property;
+            } else {
+              if (isAlreadyDefined) {
+                var specPolicy = ReactClassInterface[name];
+                _invariant(isReactClassMethod && (specPolicy === "DEFINE_MANY_MERGED" || specPolicy === "DEFINE_MANY"), "ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.", specPolicy, name);
+                if (specPolicy === "DEFINE_MANY_MERGED") {
+                  proto[name] = createMergedResultFunction(proto[name], property);
+                } else if (specPolicy === "DEFINE_MANY") {
+                  proto[name] = createChainedFunction(proto[name], property);
+                }
+              } else {
+                proto[name] = property;
+                if (true) {
+                  if (typeof property === "function" && spec.displayName) {
+                    proto[name].displayName = spec.displayName + "_" + name;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      function mixStaticSpecIntoComponent(Constructor, statics) {
+        if (!statics) {
+          return;
+        }
+        for (var name in statics) {
+          var property = statics[name];
+          if (!statics.hasOwnProperty(name)) {
+            continue;
+          }
+          var isReserved = name in RESERVED_SPEC_KEYS;
+          _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name);
+          var isAlreadyDefined = name in Constructor;
+          if (isAlreadyDefined) {
+            var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null;
+            _invariant(specPolicy === "DEFINE_MANY_MERGED", "ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.", name);
+            Constructor[name] = createMergedResultFunction(Constructor[name], property);
+            return;
+          }
+          Constructor[name] = property;
+        }
+      }
+      function mergeIntoWithNoDuplicateKeys(one, two) {
+        _invariant(one && two && typeof one === "object" && typeof two === "object", "mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.");
+        for (var key in two) {
+          if (two.hasOwnProperty(key)) {
+            _invariant(one[key] === void 0, "mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.", key);
+            one[key] = two[key];
+          }
+        }
+        return one;
+      }
+      function createMergedResultFunction(one, two) {
+        return function mergedResult() {
+          var a = one.apply(this, arguments);
+          var b = two.apply(this, arguments);
+          if (a == null) {
+            return b;
+          } else if (b == null) {
+            return a;
+          }
+          var c = {};
+          mergeIntoWithNoDuplicateKeys(c, a);
+          mergeIntoWithNoDuplicateKeys(c, b);
+          return c;
+        };
+      }
+      function createChainedFunction(one, two) {
+        return function chainedFunction() {
+          one.apply(this, arguments);
+          two.apply(this, arguments);
+        };
+      }
+      function bindAutoBindMethod(component, method) {
+        var boundMethod = method.bind(component);
+        if (true) {
+          boundMethod.__reactBoundContext = component;
+          boundMethod.__reactBoundMethod = method;
+          boundMethod.__reactBoundArguments = null;
+          var componentName = component.constructor.displayName;
+          var _bind = boundMethod.bind;
+          boundMethod.bind = function(newThis) {
+            for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+              args[_key - 1] = arguments[_key];
+            }
+            if (newThis !== component && newThis !== null) {
+              if (true) {
+                warning(false, "bind(): React component methods may only be bound to the component instance. See %s", componentName);
+              }
+            } else if (!args.length) {
+              if (true) {
+                warning(false, "bind(): You are binding a component method to the component. React does this for you automatically in a high-performance way, so you can safely remove this call. See %s", componentName);
+              }
+              return boundMethod;
+            }
+            var reboundMethod = _bind.apply(boundMethod, arguments);
+            reboundMethod.__reactBoundContext = component;
+            reboundMethod.__reactBoundMethod = method;
+            reboundMethod.__reactBoundArguments = args;
+            return reboundMethod;
+          };
+        }
+        return boundMethod;
+      }
+      function bindAutoBindMethods(component) {
+        var pairs = component.__reactAutoBindPairs;
+        for (var i = 0; i < pairs.length; i += 2) {
+          var autoBindKey = pairs[i];
+          var method = pairs[i + 1];
+          component[autoBindKey] = bindAutoBindMethod(component, method);
+        }
+      }
+      var IsMountedPreMixin = {
+        componentDidMount: function() {
+          this.__isMounted = true;
+        }
+      };
+      var IsMountedPostMixin = {
+        componentWillUnmount: function() {
+          this.__isMounted = false;
+        }
+      };
+      var ReactClassMixin = {
+        replaceState: function(newState, callback) {
+          this.updater.enqueueReplaceState(this, newState, callback);
+        },
+        isMounted: function() {
+          if (true) {
+            warning(this.__didWarnIsMounted, "%s: isMounted is deprecated. Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks.", this.constructor && this.constructor.displayName || this.name || "Component");
+            this.__didWarnIsMounted = true;
+          }
+          return !!this.__isMounted;
+        }
+      };
+      var ReactClassComponent = function() {
+      };
+      _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
+      function createClass(spec) {
+        var Constructor = identity(function(props, context, updater) {
+          if (true) {
+            warning(this instanceof Constructor, "Something is calling a React component directly. Use a factory or JSX instead. See: https://fb.me/react-legacyfactory");
+          }
+          if (this.__reactAutoBindPairs.length) {
+            bindAutoBindMethods(this);
+          }
+          this.props = props;
+          this.context = context;
+          this.refs = emptyObject;
+          this.updater = updater || ReactNoopUpdateQueue;
+          this.state = null;
+          var initialState = this.getInitialState ? this.getInitialState() : null;
+          if (true) {
+            if (initialState === void 0 && this.getInitialState._isMockFunction) {
+              initialState = null;
+            }
+          }
+          _invariant(typeof initialState === "object" && !Array.isArray(initialState), "%s.getInitialState(): must return an object or null", Constructor.displayName || "ReactCompositeComponent");
+          this.state = initialState;
+        });
+        Constructor.prototype = new ReactClassComponent();
+        Constructor.prototype.constructor = Constructor;
+        Constructor.prototype.__reactAutoBindPairs = [];
+        injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
+        mixSpecIntoComponent(Constructor, IsMountedPreMixin);
+        mixSpecIntoComponent(Constructor, spec);
+        mixSpecIntoComponent(Constructor, IsMountedPostMixin);
+        if (Constructor.getDefaultProps) {
+          Constructor.defaultProps = Constructor.getDefaultProps();
+        }
+        if (true) {
+          if (Constructor.getDefaultProps) {
+            Constructor.getDefaultProps.isReactClassApproved = {};
+          }
+          if (Constructor.prototype.getInitialState) {
+            Constructor.prototype.getInitialState.isReactClassApproved = {};
+          }
+        }
+        _invariant(Constructor.prototype.render, "createClass(...): Class specification must implement a `render` method.");
+        if (true) {
+          warning(!Constructor.prototype.componentShouldUpdate, "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.", spec.displayName || "A component");
+          warning(!Constructor.prototype.componentWillRecieveProps, "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", spec.displayName || "A component");
+          warning(!Constructor.prototype.UNSAFE_componentWillRecieveProps, "%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", spec.displayName || "A component");
+        }
+        for (var methodName in ReactClassInterface) {
+          if (!Constructor.prototype[methodName]) {
+            Constructor.prototype[methodName] = null;
+          }
+        }
+        return Constructor;
+      }
+      return createClass;
+    }
+    module.exports = factory;
+  }
+});
+
+// node_modules/create-react-class/index.js
+var require_create_react_class = __commonJS({
+  "node_modules/create-react-class/index.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var React = __require("react");
+    var factory = require_factory();
+    if (typeof React === "undefined") {
+      throw Error("create-react-class could not find the React object. If you are using script tags, make sure that React is being loaded before create-react-class.");
+    }
+    var ReactNoopUpdateQueue = new React.Component().updater;
+    module.exports = factory(React.Component, React.isValidElement, ReactNoopUpdateQueue);
+  }
+});
+
+// node_modules/fbjs/lib/emptyFunction.js
+var require_emptyFunction = __commonJS({
+  "node_modules/fbjs/lib/emptyFunction.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    function makeEmptyFunction(arg) {
+      return function() {
+        return arg;
+      };
+    }
+    var emptyFunction = function emptyFunction2() {
+    };
+    emptyFunction.thatReturns = makeEmptyFunction;
+    emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+    emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+    emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+    emptyFunction.thatReturnsThis = function() {
+      return this;
+    };
+    emptyFunction.thatReturnsArgument = function(arg) {
+      return arg;
+    };
+    module.exports = emptyFunction;
+  }
+});
+
+// node_modules/fbjs/lib/warning.js
+var require_warning = __commonJS({
+  "node_modules/fbjs/lib/warning.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var emptyFunction = require_emptyFunction();
+    function printWarning(format) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+      var argIndex = 0;
+      var message = "Warning: " + format.replace(/%s/g, function() {
+        return args[argIndex++];
+      });
+      if (typeof console !== "undefined") {
+        console.error(message);
+      }
+      try {
+        throw new Error(message);
+      } catch (x) {
+      }
+    }
+    var warning = true ? function(condition, format) {
+      if (format === void 0) {
+        throw new Error("`warning(condition, format, ...args)` requires a warning message argument");
+      }
+      if (!condition) {
+        for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+          args[_key2 - 2] = arguments[_key2];
+        }
+        printWarning.apply(void 0, [format].concat(args));
+      }
+    } : emptyFunction;
+    module.exports = warning;
+  }
+});
+
+// node_modules/hyphenate-style-name/index.cjs.js
+var require_index_cjs = __commonJS({
+  "node_modules/hyphenate-style-name/index.cjs.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    var uppercasePattern = /[A-Z]/g;
+    var msPattern = /^ms-/;
+    var cache = {};
+    function toHyphenLower(match) {
+      return "-" + match.toLowerCase();
+    }
+    function hyphenateStyleName(name) {
+      if (cache.hasOwnProperty(name)) {
+        return cache[name];
+      }
+      var hName = name.replace(uppercasePattern, toHyphenLower);
+      return cache[name] = msPattern.test(hName) ? "-" + hName : hName;
+    }
+    module.exports = hyphenateStyleName;
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/utils/capitalizeString.js
+var require_capitalizeString = __commonJS({
+  "node_modules/inline-style-prefixer/lib/utils/capitalizeString.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = capitalizeString;
+    function capitalizeString(str) {
+      return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/utils/prefixProperty.js
+var require_prefixProperty = __commonJS({
+  "node_modules/inline-style-prefixer/lib/utils/prefixProperty.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = prefixProperty;
+    var _capitalizeString = require_capitalizeString();
+    var _capitalizeString2 = _interopRequireDefault(_capitalizeString);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function prefixProperty(prefixProperties, property, style) {
+      if (prefixProperties.hasOwnProperty(property)) {
+        var newStyle = {};
+        var requiredPrefixes = prefixProperties[property];
+        var capitalizedProperty = (0, _capitalizeString2.default)(property);
+        var keys = Object.keys(style);
+        for (var i = 0; i < keys.length; i++) {
+          var styleProperty = keys[i];
+          if (styleProperty === property) {
+            for (var j = 0; j < requiredPrefixes.length; j++) {
+              newStyle[requiredPrefixes[j] + capitalizedProperty] = style[property];
+            }
+          }
+          newStyle[styleProperty] = style[styleProperty];
+        }
+        return newStyle;
+      }
+      return style;
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/utils/prefixValue.js
+var require_prefixValue = __commonJS({
+  "node_modules/inline-style-prefixer/lib/utils/prefixValue.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = prefixValue;
+    function prefixValue(plugins, property, value, style, metaData) {
+      for (var i = 0, len = plugins.length; i < len; ++i) {
+        var processedValue = plugins[i](property, value, style, metaData);
+        if (processedValue) {
+          return processedValue;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/utils/addNewValuesOnly.js
+var require_addNewValuesOnly = __commonJS({
+  "node_modules/inline-style-prefixer/lib/utils/addNewValuesOnly.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = addNewValuesOnly;
+    function addIfNew(list, value) {
+      if (list.indexOf(value) === -1) {
+        list.push(value);
+      }
+    }
+    function addNewValuesOnly(list, values) {
+      if (Array.isArray(values)) {
+        for (var i = 0, len = values.length; i < len; ++i) {
+          addIfNew(list, values[i]);
+        }
+      } else {
+        addIfNew(list, values);
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/utils/isObject.js
+var require_isObject = __commonJS({
+  "node_modules/inline-style-prefixer/lib/utils/isObject.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = isObject;
+    function isObject(value) {
+      return value instanceof Object && !Array.isArray(value);
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/createPrefixer.js
+var require_createPrefixer = __commonJS({
+  "node_modules/inline-style-prefixer/lib/createPrefixer.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = createPrefixer;
+    var _prefixProperty = require_prefixProperty();
+    var _prefixProperty2 = _interopRequireDefault(_prefixProperty);
+    var _prefixValue = require_prefixValue();
+    var _prefixValue2 = _interopRequireDefault(_prefixValue);
+    var _addNewValuesOnly = require_addNewValuesOnly();
+    var _addNewValuesOnly2 = _interopRequireDefault(_addNewValuesOnly);
+    var _isObject = require_isObject();
+    var _isObject2 = _interopRequireDefault(_isObject);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function createPrefixer(_ref) {
+      var prefixMap = _ref.prefixMap, plugins = _ref.plugins;
+      return function prefix(style) {
+        for (var property in style) {
+          var value = style[property];
+          if ((0, _isObject2.default)(value)) {
+            style[property] = prefix(value);
+          } else if (Array.isArray(value)) {
+            var combinedValue = [];
+            for (var i = 0, len = value.length; i < len; ++i) {
+              var processedValue = (0, _prefixValue2.default)(plugins, property, value[i], style, prefixMap);
+              (0, _addNewValuesOnly2.default)(combinedValue, processedValue || value[i]);
+            }
+            if (combinedValue.length > 0) {
+              style[property] = combinedValue;
+            }
+          } else {
+            var _processedValue = (0, _prefixValue2.default)(plugins, property, value, style, prefixMap);
+            if (_processedValue) {
+              style[property] = _processedValue;
+            }
+            style = (0, _prefixProperty2.default)(prefixMap, property, style);
+          }
+        }
+        return style;
+      };
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/backgroundClip.js
+var require_backgroundClip = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/backgroundClip.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = backgroundClip;
+    function backgroundClip(property, value) {
+      if (typeof value === "string" && value === "text") {
+        return ["-webkit-text", "text"];
+      }
+    }
+  }
+});
+
+// node_modules/css-in-js-utils/lib/isPrefixedValue.js
+var require_isPrefixedValue = __commonJS({
+  "node_modules/css-in-js-utils/lib/isPrefixedValue.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = isPrefixedValue;
+    var regex = /-webkit-|-moz-|-ms-/;
+    function isPrefixedValue(value) {
+      return typeof value === "string" && regex.test(value);
+    }
+    module.exports = exports["default"];
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/crossFade.js
+var require_crossFade = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/crossFade.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = crossFade;
+    var _isPrefixedValue = require_isPrefixedValue();
+    var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var prefixes = ["-webkit-", ""];
+    function crossFade(property, value) {
+      if (typeof value === "string" && !(0, _isPrefixedValue2.default)(value) && value.indexOf("cross-fade(") > -1) {
+        return prefixes.map(function(prefix) {
+          return value.replace(/cross-fade\(/g, prefix + "cross-fade(");
+        });
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/cursor.js
+var require_cursor = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/cursor.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = cursor;
+    var prefixes = ["-webkit-", "-moz-", ""];
+    var values = {
+      "zoom-in": true,
+      "zoom-out": true,
+      grab: true,
+      grabbing: true
+    };
+    function cursor(property, value) {
+      if (property === "cursor" && values.hasOwnProperty(value)) {
+        return prefixes.map(function(prefix) {
+          return prefix + value;
+        });
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/filter.js
+var require_filter = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/filter.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = filter;
+    var _isPrefixedValue = require_isPrefixedValue();
+    var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var prefixes = ["-webkit-", ""];
+    function filter(property, value) {
+      if (typeof value === "string" && !(0, _isPrefixedValue2.default)(value) && value.indexOf("filter(") > -1) {
+        return prefixes.map(function(prefix) {
+          return value.replace(/filter\(/g, prefix + "filter(");
+        });
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/flex.js
+var require_flex = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/flex.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = flex;
+    var values = {
+      flex: ["-webkit-box", "-moz-box", "-ms-flexbox", "-webkit-flex", "flex"],
+      "inline-flex": ["-webkit-inline-box", "-moz-inline-box", "-ms-inline-flexbox", "-webkit-inline-flex", "inline-flex"]
+    };
+    function flex(property, value) {
+      if (property === "display" && values.hasOwnProperty(value)) {
+        return values[value];
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/flexboxIE.js
+var require_flexboxIE = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/flexboxIE.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = flexboxIE;
+    var alternativeValues = {
+      "space-around": "distribute",
+      "space-between": "justify",
+      "flex-start": "start",
+      "flex-end": "end"
+    };
+    var alternativeProps = {
+      alignContent: "msFlexLinePack",
+      alignSelf: "msFlexItemAlign",
+      alignItems: "msFlexAlign",
+      justifyContent: "msFlexPack",
+      order: "msFlexOrder",
+      flexGrow: "msFlexPositive",
+      flexShrink: "msFlexNegative",
+      flexBasis: "msFlexPreferredSize"
+    };
+    var flexShorthandMappings = {
+      auto: "1 1 auto",
+      inherit: "inherit",
+      initial: "0 1 auto",
+      none: "0 0 auto",
+      unset: "unset"
+    };
+    var isUnitlessNumber = /^\d+(\.\d+)?$/;
+    function flexboxIE(property, value, style) {
+      if (Object.prototype.hasOwnProperty.call(alternativeProps, property)) {
+        style[alternativeProps[property]] = alternativeValues[value] || value;
+      }
+      if (property === "flex") {
+        if (Object.prototype.hasOwnProperty.call(flexShorthandMappings, value)) {
+          style.msFlex = flexShorthandMappings[value];
+          return;
+        }
+        if (isUnitlessNumber.test(value)) {
+          style.msFlex = value + " 1 0%";
+          return;
+        }
+        var flexValues = value.split(/\s/);
+        switch (flexValues.length) {
+          case 1:
+            style.msFlex = "1 1 " + value;
+            return;
+          case 2:
+            if (isUnitlessNumber.test(flexValues[1])) {
+              style.msFlex = flexValues[0] + " " + flexValues[1] + " 0%";
+            } else {
+              style.msFlex = flexValues[0] + " 1 " + flexValues[1];
+            }
+            return;
+          default:
+            style.msFlex = value;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/flexboxOld.js
+var require_flexboxOld = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/flexboxOld.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = flexboxOld;
+    var alternativeValues = {
+      "space-around": "justify",
+      "space-between": "justify",
+      "flex-start": "start",
+      "flex-end": "end",
+      "wrap-reverse": "multiple",
+      wrap: "multiple"
+    };
+    var alternativeProps = {
+      alignItems: "WebkitBoxAlign",
+      justifyContent: "WebkitBoxPack",
+      flexWrap: "WebkitBoxLines",
+      flexGrow: "WebkitBoxFlex"
+    };
+    function flexboxOld(property, value, style) {
+      if (property === "flexDirection" && typeof value === "string") {
+        if (value.indexOf("column") > -1) {
+          style.WebkitBoxOrient = "vertical";
+        } else {
+          style.WebkitBoxOrient = "horizontal";
+        }
+        if (value.indexOf("reverse") > -1) {
+          style.WebkitBoxDirection = "reverse";
+        } else {
+          style.WebkitBoxDirection = "normal";
+        }
+      }
+      if (alternativeProps.hasOwnProperty(property)) {
+        style[alternativeProps[property]] = alternativeValues[value] || value;
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/gradient.js
+var require_gradient = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/gradient.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = gradient;
+    var _isPrefixedValue = require_isPrefixedValue();
+    var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var prefixes = ["-webkit-", "-moz-", ""];
+    var values = /linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient/gi;
+    function gradient(property, value) {
+      if (typeof value === "string" && !(0, _isPrefixedValue2.default)(value) && values.test(value)) {
+        return prefixes.map(function(prefix) {
+          return value.replace(values, function(grad) {
+            return prefix + grad;
+          });
+        });
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/grid.js
+var require_grid = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/grid.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _slicedToArray = function() {
+      function sliceIterator(arr, i) {
+        var _arr = [];
+        var _n = true;
+        var _d = false;
+        var _e = void 0;
+        try {
+          for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+              break;
+          }
+        } catch (err) {
+          _d = true;
+          _e = err;
+        } finally {
+          try {
+            if (!_n && _i["return"])
+              _i["return"]();
+          } finally {
+            if (_d)
+              throw _e;
+          }
+        }
+        return _arr;
+      }
+      return function(arr, i) {
+        if (Array.isArray(arr)) {
+          return arr;
+        } else if (Symbol.iterator in Object(arr)) {
+          return sliceIterator(arr, i);
+        } else {
+          throw new TypeError("Invalid attempt to destructure non-iterable instance");
+        }
+      };
+    }();
+    exports.default = grid;
+    function isSimplePositionValue(value) {
+      return typeof value === "number" && !isNaN(value);
+    }
+    function isComplexSpanValue(value) {
+      return typeof value === "string" && value.includes("/");
+    }
+    var alignmentValues = ["center", "end", "start", "stretch"];
+    var displayValues = {
+      "inline-grid": ["-ms-inline-grid", "inline-grid"],
+      grid: ["-ms-grid", "grid"]
+    };
+    var propertyConverters = {
+      alignSelf: function alignSelf(value, style) {
+        if (alignmentValues.indexOf(value) > -1) {
+          style.msGridRowAlign = value;
+        }
+      },
+      gridColumn: function gridColumn(value, style) {
+        if (isSimplePositionValue(value)) {
+          style.msGridColumn = value;
+        } else if (isComplexSpanValue(value)) {
+          var _value$split = value.split("/"), _value$split2 = _slicedToArray(_value$split, 2), start = _value$split2[0], end = _value$split2[1];
+          propertyConverters.gridColumnStart(+start, style);
+          var _end$split = end.split(/ ?span /), _end$split2 = _slicedToArray(_end$split, 2), maybeSpan = _end$split2[0], maybeNumber = _end$split2[1];
+          if (maybeSpan === "") {
+            propertyConverters.gridColumnEnd(+start + +maybeNumber, style);
+          } else {
+            propertyConverters.gridColumnEnd(+end, style);
+          }
+        } else {
+          propertyConverters.gridColumnStart(value, style);
+        }
+      },
+      gridColumnEnd: function gridColumnEnd(value, style) {
+        var msGridColumn = style.msGridColumn;
+        if (isSimplePositionValue(value) && isSimplePositionValue(msGridColumn)) {
+          style.msGridColumnSpan = value - msGridColumn;
+        }
+      },
+      gridColumnStart: function gridColumnStart(value, style) {
+        if (isSimplePositionValue(value)) {
+          style.msGridColumn = value;
+        }
+      },
+      gridRow: function gridRow(value, style) {
+        if (isSimplePositionValue(value)) {
+          style.msGridRow = value;
+        } else if (isComplexSpanValue(value)) {
+          var _value$split3 = value.split("/"), _value$split4 = _slicedToArray(_value$split3, 2), start = _value$split4[0], end = _value$split4[1];
+          propertyConverters.gridRowStart(+start, style);
+          var _end$split3 = end.split(/ ?span /), _end$split4 = _slicedToArray(_end$split3, 2), maybeSpan = _end$split4[0], maybeNumber = _end$split4[1];
+          if (maybeSpan === "") {
+            propertyConverters.gridRowEnd(+start + +maybeNumber, style);
+          } else {
+            propertyConverters.gridRowEnd(+end, style);
+          }
+        } else {
+          propertyConverters.gridRowStart(value, style);
+        }
+      },
+      gridRowEnd: function gridRowEnd(value, style) {
+        var msGridRow = style.msGridRow;
+        if (isSimplePositionValue(value) && isSimplePositionValue(msGridRow)) {
+          style.msGridRowSpan = value - msGridRow;
+        }
+      },
+      gridRowStart: function gridRowStart(value, style) {
+        if (isSimplePositionValue(value)) {
+          style.msGridRow = value;
+        }
+      },
+      gridTemplateColumns: function gridTemplateColumns(value, style) {
+        style.msGridColumns = value;
+      },
+      gridTemplateRows: function gridTemplateRows(value, style) {
+        style.msGridRows = value;
+      },
+      justifySelf: function justifySelf(value, style) {
+        if (alignmentValues.indexOf(value) > -1) {
+          style.msGridColumnAlign = value;
+        }
+      }
+    };
+    function grid(property, value, style) {
+      if (property === "display" && value in displayValues) {
+        return displayValues[value];
+      }
+      if (property in propertyConverters) {
+        var propertyConverter = propertyConverters[property];
+        propertyConverter(value, style);
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/imageSet.js
+var require_imageSet = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/imageSet.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = imageSet;
+    var _isPrefixedValue = require_isPrefixedValue();
+    var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var prefixes = ["-webkit-", ""];
+    function imageSet(property, value) {
+      if (typeof value === "string" && !(0, _isPrefixedValue2.default)(value) && value.indexOf("image-set(") > -1) {
+        return prefixes.map(function(prefix) {
+          return value.replace(/image-set\(/g, prefix + "image-set(");
+        });
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/logical.js
+var require_logical = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/logical.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = logical;
+    var alternativeProps = {
+      marginBlockStart: ["WebkitMarginBefore"],
+      marginBlockEnd: ["WebkitMarginAfter"],
+      marginInlineStart: ["WebkitMarginStart", "MozMarginStart"],
+      marginInlineEnd: ["WebkitMarginEnd", "MozMarginEnd"],
+      paddingBlockStart: ["WebkitPaddingBefore"],
+      paddingBlockEnd: ["WebkitPaddingAfter"],
+      paddingInlineStart: ["WebkitPaddingStart", "MozPaddingStart"],
+      paddingInlineEnd: ["WebkitPaddingEnd", "MozPaddingEnd"],
+      borderBlockStart: ["WebkitBorderBefore"],
+      borderBlockStartColor: ["WebkitBorderBeforeColor"],
+      borderBlockStartStyle: ["WebkitBorderBeforeStyle"],
+      borderBlockStartWidth: ["WebkitBorderBeforeWidth"],
+      borderBlockEnd: ["WebkitBorderAfter"],
+      borderBlockEndColor: ["WebkitBorderAfterColor"],
+      borderBlockEndStyle: ["WebkitBorderAfterStyle"],
+      borderBlockEndWidth: ["WebkitBorderAfterWidth"],
+      borderInlineStart: ["WebkitBorderStart", "MozBorderStart"],
+      borderInlineStartColor: ["WebkitBorderStartColor", "MozBorderStartColor"],
+      borderInlineStartStyle: ["WebkitBorderStartStyle", "MozBorderStartStyle"],
+      borderInlineStartWidth: ["WebkitBorderStartWidth", "MozBorderStartWidth"],
+      borderInlineEnd: ["WebkitBorderEnd", "MozBorderEnd"],
+      borderInlineEndColor: ["WebkitBorderEndColor", "MozBorderEndColor"],
+      borderInlineEndStyle: ["WebkitBorderEndStyle", "MozBorderEndStyle"],
+      borderInlineEndWidth: ["WebkitBorderEndWidth", "MozBorderEndWidth"]
+    };
+    function logical(property, value, style) {
+      if (Object.prototype.hasOwnProperty.call(alternativeProps, property)) {
+        var alternativePropList = alternativeProps[property];
+        for (var i = 0, len = alternativePropList.length; i < len; ++i) {
+          style[alternativePropList[i]] = value;
+        }
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/position.js
+var require_position = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/position.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = position;
+    function position(property, value) {
+      if (property === "position" && value === "sticky") {
+        return ["-webkit-sticky", "sticky"];
+      }
+    }
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/sizing.js
+var require_sizing = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/sizing.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = sizing;
+    var prefixes = ["-webkit-", "-moz-", ""];
+    var properties = {
+      maxHeight: true,
+      maxWidth: true,
+      width: true,
+      height: true,
+      columnWidth: true,
+      minWidth: true,
+      minHeight: true
+    };
+    var values = {
+      "min-content": true,
+      "max-content": true,
+      "fill-available": true,
+      "fit-content": true,
+      "contain-floats": true
+    };
+    function sizing(property, value) {
+      if (properties.hasOwnProperty(property) && values.hasOwnProperty(value)) {
+        return prefixes.map(function(prefix) {
+          return prefix + value;
+        });
+      }
+    }
+  }
+});
+
+// node_modules/css-in-js-utils/lib/hyphenateProperty.js
+var require_hyphenateProperty = __commonJS({
+  "node_modules/css-in-js-utils/lib/hyphenateProperty.js"(exports, module) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = hyphenateProperty;
+    var _hyphenateStyleName = require_index_cjs();
+    var _hyphenateStyleName2 = _interopRequireDefault(_hyphenateStyleName);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    function hyphenateProperty(property) {
+      return (0, _hyphenateStyleName2.default)(property);
+    }
+    module.exports = exports["default"];
+  }
+});
+
+// node_modules/inline-style-prefixer/lib/plugins/transition.js
+var require_transition = __commonJS({
+  "node_modules/inline-style-prefixer/lib/plugins/transition.js"(exports) {
+    init_react_shim();
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = transition;
+    var _hyphenateProperty = require_hyphenateProperty();
+    var _hyphenateProperty2 = _interopRequireDefault(_hyphenateProperty);
+    var _isPrefixedValue = require_isPrefixedValue();
+    var _isPrefixedValue2 = _interopRequireDefault(_isPrefixedValue);
+    var _capitalizeString = require_capitalizeString();
+    var _capitalizeString2 = _interopRequireDefault(_capitalizeString);
+    function _interopRequireDefault(obj) {
+      return obj && obj.__esModule ? obj : { default: obj };
+    }
+    var properties = {
+      transition: true,
+      transitionProperty: true,
+      WebkitTransition: true,
+      WebkitTransitionProperty: true,
+      MozTransition: true,
+      MozTransitionProperty: true
+    };
+    var prefixMapping = {
+      Webkit: "-webkit-",
+      Moz: "-moz-",
+      ms: "-ms-"
+    };
+    function prefixValue(value, propertyPrefixMap) {
+      if ((0, _isPrefixedValue2.default)(value)) {
+        return value;
+      }
+      var multipleValues = value.split(/,(?![^()]*(?:\([^()]*\))?\))/g);
+      for (var i = 0, len = multipleValues.length; i < len; ++i) {
+        var singleValue = multipleValues[i];
+        var values = [singleValue];
+        for (var property in propertyPrefixMap) {
+          var dashCaseProperty = (0, _hyphenateProperty2.default)(property);
+          if (singleValue.indexOf(dashCaseProperty) > -1 && dashCaseProperty !== "order") {
+            var prefixes = propertyPrefixMap[property];
+            for (var j = 0, pLen = prefixes.length; j < pLen; ++j) {
+              values.unshift(singleValue.replace(dashCaseProperty, prefixMapping[prefixes[j]] + dashCaseProperty));
+            }
+          }
+        }
+        multipleValues[i] = values.join(",");
+      }
+      return multipleValues.join(",");
+    }
+    function transition(property, value, style, propertyPrefixMap) {
+      if (typeof value === "string" && properties.hasOwnProperty(property)) {
+        var outputValue = prefixValue(value, propertyPrefixMap);
+        var webkitOutput = outputValue.split(/,(?![^()]*(?:\([^()]*\))?\))/g).filter(function(val) {
+          return !/-moz-|-ms-/.test(val);
+        }).join(",");
+        if (property.indexOf("Webkit") > -1) {
+          return webkitOutput;
+        }
+        var mozOutput = outputValue.split(/,(?![^()]*(?:\([^()]*\))?\))/g).filter(function(val) {
+          return !/-webkit-|-ms-/.test(val);
+        }).join(",");
+        if (property.indexOf("Moz") > -1) {
+          return mozOutput;
+        }
+        style["Webkit" + (0, _capitalizeString2.default)(property)] = webkitOutput;
+        style["Moz" + (0, _capitalizeString2.default)(property)] = mozOutput;
+        return outputValue;
+      }
+    }
+  }
+});
+
+export {
+  require_ExecutionEnvironment,
+  require_normalize_css_color,
+  require_invariant,
+  require_index_cjs,
+  require_createPrefixer,
+  require_backgroundClip,
+  require_crossFade,
+  require_cursor,
+  require_filter,
+  require_flex,
+  require_flexboxIE,
+  require_flexboxOld,
+  require_gradient,
+  require_grid,
+  require_imageSet,
+  require_logical,
+  require_position,
+  require_sizing,
+  require_transition,
+  require_warning,
+  require_create_react_class
+};