@crowdin/app-project-module 2.6.0 → 2.6.1

package/out/static/ui/form.bundle.js

@@ -1,4 +1,4 @@
-(function (emStyled, react$1) {
+(function () {
 	'use strict';
 
 	function _mergeNamespaces(n, m) {
@@ -193,6 +193,1395 @@
 
 	var THEME_ID = '$$material';
 
+	function _extends() {
+	  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+	    for (var e = 1; e < arguments.length; e++) {
+	      var t = arguments[e];
+	      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+	    }
+	    return n;
+	  }, _extends.apply(null, arguments);
+	}
+
+	var reactExports = requireReact();
+	var We = /*@__PURE__*/getDefaultExportFromCjs(reactExports);
+
+	var React2 = /*#__PURE__*/_mergeNamespaces({
+		__proto__: null,
+		default: We
+	}, [reactExports]);
+
+	/*
+
+	Based off glamor's StyleSheet, thanks Sunil ❤️
+
+	high performance StyleSheet for css-in-js systems
+
+	- uses multiple style tags behind the scenes for millions of rules
+	- uses `insertRule` for appending in production for *much* faster performance
+
+	// usage
+
+	import { StyleSheet } from '@emotion/sheet'
+
+	let styleSheet = new StyleSheet({ key: '', container: document.head })
+
+	styleSheet.insert('#box { border: 1px solid red; }')
+	- appends a css rule into the stylesheet
+
+	styleSheet.flush()
+	- empties the stylesheet of all its contents
+
+	*/
+
+	function sheetForTag(tag) {
+	  if (tag.sheet) {
+	    return tag.sheet;
+	  } // this weirdness brought to you by firefox
+
+	  /* istanbul ignore next */
+
+
+	  for (var i = 0; i < document.styleSheets.length; i++) {
+	    if (document.styleSheets[i].ownerNode === tag) {
+	      return document.styleSheets[i];
+	    }
+	  } // this function should always return with a value
+	  // TS can't understand it though so we make it stop complaining here
+
+
+	  return undefined;
+	}
+
+	function createStyleElement(options) {
+	  var tag = document.createElement('style');
+	  tag.setAttribute('data-emotion', options.key);
+
+	  if (options.nonce !== undefined) {
+	    tag.setAttribute('nonce', options.nonce);
+	  }
+
+	  tag.appendChild(document.createTextNode(''));
+	  tag.setAttribute('data-s', '');
+	  return tag;
+	}
+
+	var StyleSheet = /*#__PURE__*/function () {
+	  // Using Node instead of HTMLElement since container may be a ShadowRoot
+	  function StyleSheet(options) {
+	    var _this = this;
+
+	    this._insertTag = function (tag) {
+	      var before;
+
+	      if (_this.tags.length === 0) {
+	        if (_this.insertionPoint) {
+	          before = _this.insertionPoint.nextSibling;
+	        } else if (_this.prepend) {
+	          before = _this.container.firstChild;
+	        } else {
+	          before = _this.before;
+	        }
+	      } else {
+	        before = _this.tags[_this.tags.length - 1].nextSibling;
+	      }
+
+	      _this.container.insertBefore(tag, before);
+
+	      _this.tags.push(tag);
+	    };
+
+	    this.isSpeedy = options.speedy === undefined ? true : options.speedy;
+	    this.tags = [];
+	    this.ctr = 0;
+	    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
+
+	    this.key = options.key;
+	    this.container = options.container;
+	    this.prepend = options.prepend;
+	    this.insertionPoint = options.insertionPoint;
+	    this.before = null;
+	  }
+
+	  var _proto = StyleSheet.prototype;
+
+	  _proto.hydrate = function hydrate(nodes) {
+	    nodes.forEach(this._insertTag);
+	  };
+
+	  _proto.insert = function insert(rule) {
+	    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
+	    // it's 1 in dev because we insert source maps that map a single rule to a location
+	    // and you can only have one source map per style tag
+	    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
+	      this._insertTag(createStyleElement(this));
+	    }
+
+	    var tag = this.tags[this.tags.length - 1];
+
+	    if (this.isSpeedy) {
+	      var sheet = sheetForTag(tag);
+
+	      try {
+	        // this is the ultrafast version, works across browsers
+	        // the big drawback is that the css won't be editable in devtools
+	        sheet.insertRule(rule, sheet.cssRules.length);
+	      } catch (e) {
+	      }
+	    } else {
+	      tag.appendChild(document.createTextNode(rule));
+	    }
+
+	    this.ctr++;
+	  };
+
+	  _proto.flush = function flush() {
+	    this.tags.forEach(function (tag) {
+	      var _tag$parentNode;
+
+	      return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
+	    });
+	    this.tags = [];
+	    this.ctr = 0;
+	  };
+
+	  return StyleSheet;
+	}();
+
+	var MS = '-ms-';
+	var MOZ = '-moz-';
+	var WEBKIT = '-webkit-';
+
+	var COMMENT = 'comm';
+	var RULESET = 'rule';
+	var DECLARATION = 'decl';
+	var IMPORT = '@import';
+	var KEYFRAMES = '@keyframes';
+	var LAYER = '@layer';
+
+	/**
+	 * @param {number}
+	 * @return {number}
+	 */
+	var abs = Math.abs;
+
+	/**
+	 * @param {number}
+	 * @return {string}
+	 */
+	var from = String.fromCharCode;
+
+	/**
+	 * @param {object}
+	 * @return {object}
+	 */
+	var assign = Object.assign;
+
+	/**
+	 * @param {string} value
+	 * @param {number} length
+	 * @return {number}
+	 */
+	function hash (value, length) {
+		return charat(value, 0) ^ 45 ? (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3) : 0
+	}
+
+	/**
+	 * @param {string} value
+	 * @return {string}
+	 */
+	function trim (value) {
+		return value.trim()
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {RegExp} pattern
+	 * @return {string?}
+	 */
+	function match (value, pattern) {
+		return (value = pattern.exec(value)) ? value[0] : value
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {(string|RegExp)} pattern
+	 * @param {string} replacement
+	 * @return {string}
+	 */
+	function replace (value, pattern, replacement) {
+		return value.replace(pattern, replacement)
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {string} search
+	 * @return {number}
+	 */
+	function indexof (value, search) {
+		return value.indexOf(search)
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {number} index
+	 * @return {number}
+	 */
+	function charat (value, index) {
+		return value.charCodeAt(index) | 0
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {number} begin
+	 * @param {number} end
+	 * @return {string}
+	 */
+	function substr (value, begin, end) {
+		return value.slice(begin, end)
+	}
+
+	/**
+	 * @param {string} value
+	 * @return {number}
+	 */
+	function strlen (value) {
+		return value.length
+	}
+
+	/**
+	 * @param {any[]} value
+	 * @return {number}
+	 */
+	function sizeof (value) {
+		return value.length
+	}
+
+	/**
+	 * @param {any} value
+	 * @param {any[]} array
+	 * @return {any}
+	 */
+	function append (value, array) {
+		return array.push(value), value
+	}
+
+	/**
+	 * @param {string[]} array
+	 * @param {function} callback
+	 * @return {string}
+	 */
+	function combine (array, callback) {
+		return array.map(callback).join('')
+	}
+
+	var line = 1;
+	var column = 1;
+	var length = 0;
+	var position = 0;
+	var character = 0;
+	var characters = '';
+
+	/**
+	 * @param {string} value
+	 * @param {object | null} root
+	 * @param {object | null} parent
+	 * @param {string} type
+	 * @param {string[] | string} props
+	 * @param {object[] | string} children
+	 * @param {number} length
+	 */
+	function node (value, root, parent, type, props, children, length) {
+		return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
+	}
+
+	/**
+	 * @param {object} root
+	 * @param {object} props
+	 * @return {object}
+	 */
+	function copy (root, props) {
+		return assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
+	}
+
+	/**
+	 * @return {number}
+	 */
+	function char () {
+		return character
+	}
+
+	/**
+	 * @return {number}
+	 */
+	function prev () {
+		character = position > 0 ? charat(characters, --position) : 0;
+
+		if (column--, character === 10)
+			column = 1, line--;
+
+		return character
+	}
+
+	/**
+	 * @return {number}
+	 */
+	function next () {
+		character = position < length ? charat(characters, position++) : 0;
+
+		if (column++, character === 10)
+			column = 1, line++;
+
+		return character
+	}
+
+	/**
+	 * @return {number}
+	 */
+	function peek () {
+		return charat(characters, position)
+	}
+
+	/**
+	 * @return {number}
+	 */
+	function caret () {
+		return position
+	}
+
+	/**
+	 * @param {number} begin
+	 * @param {number} end
+	 * @return {string}
+	 */
+	function slice (begin, end) {
+		return substr(characters, begin, end)
+	}
+
+	/**
+	 * @param {number} type
+	 * @return {number}
+	 */
+	function token (type) {
+		switch (type) {
+			// \0 \t \n \r \s whitespace token
+			case 0: case 9: case 10: case 13: case 32:
+				return 5
+			// ! + , / > @ ~ isolate token
+			case 33: case 43: case 44: case 47: case 62: case 64: case 126:
+			// ; { } breakpoint token
+			case 59: case 123: case 125:
+				return 4
+			// : accompanied token
+			case 58:
+				return 3
+			// " ' ( [ opening delimit token
+			case 34: case 39: case 40: case 91:
+				return 2
+			// ) ] closing delimit token
+			case 41: case 93:
+				return 1
+		}
+
+		return 0
+	}
+
+	/**
+	 * @param {string} value
+	 * @return {any[]}
+	 */
+	function alloc (value) {
+		return line = column = 1, length = strlen(characters = value), position = 0, []
+	}
+
+	/**
+	 * @param {any} value
+	 * @return {any}
+	 */
+	function dealloc (value) {
+		return characters = '', value
+	}
+
+	/**
+	 * @param {number} type
+	 * @return {string}
+	 */
+	function delimit (type) {
+		return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
+	}
+
+	/**
+	 * @param {number} type
+	 * @return {string}
+	 */
+	function whitespace (type) {
+		while (character = peek())
+			if (character < 33)
+				next();
+			else
+				break
+
+		return token(type) > 2 || token(character) > 3 ? '' : ' '
+	}
+
+	/**
+	 * @param {number} index
+	 * @param {number} count
+	 * @return {string}
+	 */
+	function escaping (index, count) {
+		while (--count && next())
+			// not 0-9 A-F a-f
+			if (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))
+				break
+
+		return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
+	}
+
+	/**
+	 * @param {number} type
+	 * @return {number}
+	 */
+	function delimiter (type) {
+		while (next())
+			switch (character) {
+				// ] ) " '
+				case type:
+					return position
+				// " '
+				case 34: case 39:
+					if (type !== 34 && type !== 39)
+						delimiter(character);
+					break
+				// (
+				case 40:
+					if (type === 41)
+						delimiter(type);
+					break
+				// \
+				case 92:
+					next();
+					break
+			}
+
+		return position
+	}
+
+	/**
+	 * @param {number} type
+	 * @param {number} index
+	 * @return {number}
+	 */
+	function commenter (type, index) {
+		while (next())
+			// //
+			if (type + character === 47 + 10)
+				break
+			// /*
+			else if (type + character === 42 + 42 && peek() === 47)
+				break
+
+		return '/*' + slice(index, position - 1) + '*' + from(type === 47 ? type : next())
+	}
+
+	/**
+	 * @param {number} index
+	 * @return {string}
+	 */
+	function identifier (index) {
+		while (!token(peek()))
+			next();
+
+		return slice(index, position)
+	}
+
+	/**
+	 * @param {string} value
+	 * @return {object[]}
+	 */
+	function compile$1 (value) {
+		return dealloc(parse$1('', null, null, null, [''], value = alloc(value), 0, [0], value))
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {object} root
+	 * @param {object?} parent
+	 * @param {string[]} rule
+	 * @param {string[]} rules
+	 * @param {string[]} rulesets
+	 * @param {number[]} pseudo
+	 * @param {number[]} points
+	 * @param {string[]} declarations
+	 * @return {object}
+	 */
+	function parse$1 (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+		var index = 0;
+		var offset = 0;
+		var length = pseudo;
+		var atrule = 0;
+		var property = 0;
+		var previous = 0;
+		var variable = 1;
+		var scanning = 1;
+		var ampersand = 1;
+		var character = 0;
+		var type = '';
+		var props = rules;
+		var children = rulesets;
+		var reference = rule;
+		var characters = type;
+
+		while (scanning)
+			switch (previous = character, character = next()) {
+				// (
+				case 40:
+					if (previous != 108 && charat(characters, length - 1) == 58) {
+						if (indexof(characters += replace(delimit(character), '&', '&\f'), '&\f') != -1)
+							ampersand = -1;
+						break
+					}
+				// " ' [
+				case 34: case 39: case 91:
+					characters += delimit(character);
+					break
+				// \t \n \r \s
+				case 9: case 10: case 13: case 32:
+					characters += whitespace(previous);
+					break
+				// \
+				case 92:
+					characters += escaping(caret() - 1, 7);
+					continue
+				// /
+				case 47:
+					switch (peek()) {
+						case 42: case 47:
+							append(comment(commenter(next(), caret()), root, parent), declarations);
+							break
+						default:
+							characters += '/';
+					}
+					break
+				// {
+				case 123 * variable:
+					points[index++] = strlen(characters) * ampersand;
+				// } ; \0
+				case 125 * variable: case 59: case 0:
+					switch (character) {
+						// \0 }
+						case 0: case 125: scanning = 0;
+						// ;
+						case 59 + offset: if (ampersand == -1) characters = replace(characters, /\f/g, '');
+							if (property > 0 && (strlen(characters) - length))
+								append(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations);
+							break
+						// @ ;
+						case 59: characters += ';';
+						// { rule/at-rule
+						default:
+							append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets);
+
+							if (character === 123)
+								if (offset === 0)
+									parse$1(characters, root, reference, reference, props, rulesets, length, points, children);
+								else
+									switch (atrule === 99 && charat(characters, 3) === 110 ? 100 : atrule) {
+										// d l m s
+										case 100: case 108: case 109: case 115:
+											parse$1(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children);
+											break
+										default:
+											parse$1(characters, reference, reference, reference, [''], children, 0, points, children);
+									}
+					}
+
+					index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo;
+					break
+				// :
+				case 58:
+					length = 1 + strlen(characters), property = previous;
+				default:
+					if (variable < 1)
+						if (character == 123)
+							--variable;
+						else if (character == 125 && variable++ == 0 && prev() == 125)
+							continue
+
+					switch (characters += from(character), character * variable) {
+						// &
+						case 38:
+							ampersand = offset > 0 ? 1 : (characters += '\f', -1);
+							break
+						// ,
+						case 44:
+							points[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1;
+							break
+						// @
+						case 64:
+							// -
+							if (peek() === 45)
+								characters += delimit(next());
+
+							atrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++;
+							break
+						// -
+						case 45:
+							if (previous === 45 && strlen(characters) == 2)
+								variable = 0;
+					}
+			}
+
+		return rulesets
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {object} root
+	 * @param {object?} parent
+	 * @param {number} index
+	 * @param {number} offset
+	 * @param {string[]} rules
+	 * @param {number[]} points
+	 * @param {string} type
+	 * @param {string[]} props
+	 * @param {string[]} children
+	 * @param {number} length
+	 * @return {object}
+	 */
+	function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
+		var post = offset - 1;
+		var rule = offset === 0 ? rules : [''];
+		var size = sizeof(rule);
+
+		for (var i = 0, j = 0, k = 0; i < index; ++i)
+			for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
+				if (z = trim(j > 0 ? rule[x] + ' ' + y : replace(y, /&\f/g, rule[x])))
+					props[k++] = z;
+
+		return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length)
+	}
+
+	/**
+	 * @param {number} value
+	 * @param {object} root
+	 * @param {object?} parent
+	 * @return {object}
+	 */
+	function comment (value, root, parent) {
+		return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0)
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {object} root
+	 * @param {object?} parent
+	 * @param {number} length
+	 * @return {object}
+	 */
+	function declaration (value, root, parent, length) {
+		return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length)
+	}
+
+	/**
+	 * @param {object[]} children
+	 * @param {function} callback
+	 * @return {string}
+	 */
+	function serialize (children, callback) {
+		var output = '';
+		var length = sizeof(children);
+
+		for (var i = 0; i < length; i++)
+			output += callback(children[i], i, children, callback) || '';
+
+		return output
+	}
+
+	/**
+	 * @param {object} element
+	 * @param {number} index
+	 * @param {object[]} children
+	 * @param {function} callback
+	 * @return {string}
+	 */
+	function stringify (element, index, children, callback) {
+		switch (element.type) {
+			case LAYER: if (element.children.length) break
+			case IMPORT: case DECLARATION: return element.return = element.return || element.value
+			case COMMENT: return ''
+			case KEYFRAMES: return element.return = element.value + '{' + serialize(element.children, callback) + '}'
+			case RULESET: element.value = element.props.join(',');
+		}
+
+		return strlen(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
+	}
+
+	/**
+	 * @param {function[]} collection
+	 * @return {function}
+	 */
+	function middleware (collection) {
+		var length = sizeof(collection);
+
+		return function (element, index, children, callback) {
+			var output = '';
+
+			for (var i = 0; i < length; i++)
+				output += collection[i](element, index, children, callback) || '';
+
+			return output
+		}
+	}
+
+	/**
+	 * @param {function} callback
+	 * @return {function}
+	 */
+	function rulesheet (callback) {
+		return function (element) {
+			if (!element.root)
+				if (element = element.return)
+					callback(element);
+		}
+	}
+
+	function memoize$3(fn) {
+	  var cache = Object.create(null);
+	  return function (arg) {
+	    if (cache[arg] === undefined) cache[arg] = fn(arg);
+	    return cache[arg];
+	  };
+	}
+
+	var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
+	  var previous = 0;
+	  var character = 0;
+
+	  while (true) {
+	    previous = character;
+	    character = peek(); // &\f
+
+	    if (previous === 38 && character === 12) {
+	      points[index] = 1;
+	    }
+
+	    if (token(character)) {
+	      break;
+	    }
+
+	    next();
+	  }
+
+	  return slice(begin, position);
+	};
+
+	var toRules = function toRules(parsed, points) {
+	  // pretend we've started with a comma
+	  var index = -1;
+	  var character = 44;
+
+	  do {
+	    switch (token(character)) {
+	      case 0:
+	        // &\f
+	        if (character === 38 && peek() === 12) {
+	          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
+	          // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
+	          // and when it should just concatenate the outer and inner selectors
+	          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
+	          points[index] = 1;
+	        }
+
+	        parsed[index] += identifierWithPointTracking(position - 1, points, index);
+	        break;
+
+	      case 2:
+	        parsed[index] += delimit(character);
+	        break;
+
+	      case 4:
+	        // comma
+	        if (character === 44) {
+	          // colon
+	          parsed[++index] = peek() === 58 ? '&\f' : '';
+	          points[index] = parsed[index].length;
+	          break;
+	        }
+
+	      // fallthrough
+
+	      default:
+	        parsed[index] += from(character);
+	    }
+	  } while (character = next());
+
+	  return parsed;
+	};
+
+	var getRules = function getRules(value, points) {
+	  return dealloc(toRules(alloc(value), points));
+	}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
+
+
+	var fixedElements = /* #__PURE__ */new WeakMap();
+	var compat = function compat(element) {
+	  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
+	  // negative .length indicates that this rule has been already prefixed
+	  element.length < 1) {
+	    return;
+	  }
+
+	  var value = element.value;
+	  var parent = element.parent;
+	  var isImplicitRule = element.column === parent.column && element.line === parent.line;
+
+	  while (parent.type !== 'rule') {
+	    parent = parent.parent;
+	    if (!parent) return;
+	  } // short-circuit for the simplest case
+
+
+	  if (element.props.length === 1 && value.charCodeAt(0) !== 58
+	  /* colon */
+	  && !fixedElements.get(parent)) {
+	    return;
+	  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
+	  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
+
+
+	  if (isImplicitRule) {
+	    return;
+	  }
+
+	  fixedElements.set(element, true);
+	  var points = [];
+	  var rules = getRules(value, points);
+	  var parentRules = parent.props;
+
+	  for (var i = 0, k = 0; i < rules.length; i++) {
+	    for (var j = 0; j < parentRules.length; j++, k++) {
+	      element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
+	    }
+	  }
+	};
+	var removeLabel = function removeLabel(element) {
+	  if (element.type === 'decl') {
+	    var value = element.value;
+
+	    if ( // charcode for l
+	    value.charCodeAt(0) === 108 && // charcode for b
+	    value.charCodeAt(2) === 98) {
+	      // this ignores label
+	      element["return"] = '';
+	      element.value = '';
+	    }
+	  }
+	};
+
+	/* eslint-disable no-fallthrough */
+
+	function prefix(value, length) {
+	  switch (hash(value, length)) {
+	    // color-adjust
+	    case 5103:
+	      return WEBKIT + 'print-' + value + value;
+	    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
+
+	    case 5737:
+	    case 4201:
+	    case 3177:
+	    case 3433:
+	    case 1641:
+	    case 4457:
+	    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
+
+	    case 5572:
+	    case 6356:
+	    case 5844:
+	    case 3191:
+	    case 6645:
+	    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
+
+	    case 6391:
+	    case 5879:
+	    case 5623:
+	    case 6135:
+	    case 4599:
+	    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
+
+	    case 4215:
+	    case 6389:
+	    case 5109:
+	    case 5365:
+	    case 5621:
+	    case 3829:
+	      return WEBKIT + value + value;
+	    // appearance, user-select, transform, hyphens, text-size-adjust
+
+	    case 5349:
+	    case 4246:
+	    case 4810:
+	    case 6968:
+	    case 2756:
+	      return WEBKIT + value + MOZ + value + MS + value + value;
+	    // flex, flex-direction
+
+	    case 6828:
+	    case 4268:
+	      return WEBKIT + value + MS + value + value;
+	    // order
+
+	    case 6165:
+	      return WEBKIT + value + MS + 'flex-' + value + value;
+	    // align-items
+
+	    case 5187:
+	      return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + 'box-$1$2' + MS + 'flex-$1$2') + value;
+	    // align-self
+
+	    case 5443:
+	      return WEBKIT + value + MS + 'flex-item-' + replace(value, /flex-|-self/, '') + value;
+	    // align-content
+
+	    case 4675:
+	      return WEBKIT + value + MS + 'flex-line-pack' + replace(value, /align-content|flex-|-self/, '') + value;
+	    // flex-shrink
+
+	    case 5548:
+	      return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value;
+	    // flex-basis
+
+	    case 5292:
+	      return WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value;
+	    // flex-grow
+
+	    case 6060:
+	      return WEBKIT + 'box-' + replace(value, '-grow', '') + WEBKIT + value + MS + replace(value, 'grow', 'positive') + value;
+	    // transition
+
+	    case 4554:
+	      return WEBKIT + replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') + value;
+	    // cursor
+
+	    case 6187:
+	      return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + '$1'), /(image-set)/, WEBKIT + '$1'), value, '') + value;
+	    // background, background-image
+
+	    case 5495:
+	    case 3959:
+	      return replace(value, /(image-set\([^]*)/, WEBKIT + '$1' + '$`$1');
+	    // justify-content
+
+	    case 4968:
+	      return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + WEBKIT + value + value;
+	    // (margin|padding)-inline-(start|end)
+
+	    case 4095:
+	    case 3583:
+	    case 4068:
+	    case 2532:
+	      return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value;
+	    // (min|max)?(width|height|inline-size|block-size)
+
+	    case 8116:
+	    case 7059:
+	    case 5753:
+	    case 5535:
+	    case 5445:
+	    case 5701:
+	    case 4933:
+	    case 4677:
+	    case 5533:
+	    case 5789:
+	    case 5021:
+	    case 4765:
+	      // stretch, max-content, min-content, fill-available
+	      if (strlen(value) - 1 - length > 6) switch (charat(value, length + 1)) {
+	        // (m)ax-content, (m)in-content
+	        case 109:
+	          // -
+	          if (charat(value, length + 4) !== 45) break;
+	        // (f)ill-available, (f)it-content
+
+	        case 102:
+	          return replace(value, /(.+:)(.+)-([^]+)/, '$1' + WEBKIT + '$2-$3' + '$1' + MOZ + (charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
+	        // (s)tretch
+
+	        case 115:
+	          return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;
+	      }
+	      break;
+	    // position: sticky
+
+	    case 4949:
+	      // (s)ticky?
+	      if (charat(value, length + 1) !== 115) break;
+	    // display: (flex|inline-flex)
+
+	    case 6444:
+	      switch (charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
+	        // stic(k)y
+	        case 107:
+	          return replace(value, ':', ':' + WEBKIT) + value;
+	        // (inline-)?fl(e)x
+
+	        case 101:
+	          return replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + WEBKIT + (charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + WEBKIT + '$2$3' + '$1' + MS + '$2box$3') + value;
+	      }
+
+	      break;
+	    // writing-mode
+
+	    case 5936:
+	      switch (charat(value, length + 11)) {
+	        // vertical-l(r)
+	        case 114:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
+	        // vertical-r(l)
+
+	        case 108:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
+	        // horizontal(-)tb
+
+	        case 45:
+	          return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
+	      }
+
+	      return WEBKIT + value + MS + value + value;
+	  }
+
+	  return value;
+	}
+
+	var prefixer = function prefixer(element, index, children, callback) {
+	  if (element.length > -1) if (!element["return"]) switch (element.type) {
+	    case DECLARATION:
+	      element["return"] = prefix(element.value, element.length);
+	      break;
+
+	    case KEYFRAMES:
+	      return serialize([copy(element, {
+	        value: replace(element.value, '@', '@' + WEBKIT)
+	      })], callback);
+
+	    case RULESET:
+	      if (element.length) return combine(element.props, function (value) {
+	        switch (match(value, /(::plac\w+|:read-\w+)/)) {
+	          // :read-(only|write)
+	          case ':read-only':
+	          case ':read-write':
+	            return serialize([copy(element, {
+	              props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]
+	            })], callback);
+	          // :placeholder
+
+	          case '::placeholder':
+	            return serialize([copy(element, {
+	              props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]
+	            }), copy(element, {
+	              props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]
+	            }), copy(element, {
+	              props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
+	            })], callback);
+	        }
+
+	        return '';
+	      });
+	  }
+	};
+
+	var defaultStylisPlugins = [prefixer];
+
+	var createCache = function createCache(options) {
+	  var key = options.key;
+
+	  if (key === 'css') {
+	    var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
+	    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
+	    // note this very very intentionally targets all style elements regardless of the key to ensure
+	    // that creating a cache works inside of render of a React component
+
+	    Array.prototype.forEach.call(ssrStyles, function (node) {
+	      // we want to only move elements which have a space in the data-emotion attribute value
+	      // because that indicates that it is an Emotion 11 server-side rendered style elements
+	      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
+	      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
+	      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
+	      // will not result in the Emotion 10 styles being destroyed
+	      var dataEmotionAttribute = node.getAttribute('data-emotion');
+
+	      if (dataEmotionAttribute.indexOf(' ') === -1) {
+	        return;
+	      }
+
+	      document.head.appendChild(node);
+	      node.setAttribute('data-s', '');
+	    });
+	  }
+
+	  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+
+	  var inserted = {};
+	  var container;
+	  var nodesToHydrate = [];
+
+	  {
+	    container = options.container || document.head;
+	    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
+	    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
+	    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
+	      var attrib = node.getAttribute("data-emotion").split(' ');
+
+	      for (var i = 1; i < attrib.length; i++) {
+	        inserted[attrib[i]] = true;
+	      }
+
+	      nodesToHydrate.push(node);
+	    });
+	  }
+
+	  var _insert;
+
+	  var omnipresentPlugins = [compat, removeLabel];
+
+	  {
+	    var currentSheet;
+	    var finalizingPlugins = [stringify, rulesheet(function (rule) {
+	      currentSheet.insert(rule);
+	    })];
+	    var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
+
+	    var stylis = function stylis(styles) {
+	      return serialize(compile$1(styles), serializer);
+	    };
+
+	    _insert = function insert(selector, serialized, sheet, shouldCache) {
+	      currentSheet = sheet;
+
+	      stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+
+	      if (shouldCache) {
+	        cache.inserted[serialized.name] = true;
+	      }
+	    };
+	  }
+
+	  var cache = {
+	    key: key,
+	    sheet: new StyleSheet({
+	      key: key,
+	      container: container,
+	      nonce: options.nonce,
+	      speedy: options.speedy,
+	      prepend: options.prepend,
+	      insertionPoint: options.insertionPoint
+	    }),
+	    nonce: options.nonce,
+	    inserted: inserted,
+	    registered: {},
+	    insert: _insert
+	  };
+	  cache.sheet.hydrate(nodesToHydrate);
+	  return cache;
+	};
+
+	var reactIs$2 = {exports: {}};
+
+	var reactIs_production_min$1 = {};
+
+	/** @license React v16.13.1
+	 * react-is.production.min.js
+	 *
+	 * Copyright (c) Facebook, Inc. and its affiliates.
+	 *
+	 * This source code is licensed under the MIT license found in the
+	 * LICENSE file in the root directory of this source tree.
+	 */
+
+	var hasRequiredReactIs_production_min$1;
+
+	function requireReactIs_production_min$1 () {
+		if (hasRequiredReactIs_production_min$1) return reactIs_production_min$1;
+		hasRequiredReactIs_production_min$1 = 1;
+	var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
+		Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
+		function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}reactIs_production_min$1.AsyncMode=l;reactIs_production_min$1.ConcurrentMode=m;reactIs_production_min$1.ContextConsumer=k;reactIs_production_min$1.ContextProvider=h;reactIs_production_min$1.Element=c;reactIs_production_min$1.ForwardRef=n;reactIs_production_min$1.Fragment=e;reactIs_production_min$1.Lazy=t;reactIs_production_min$1.Memo=r;reactIs_production_min$1.Portal=d;
+		reactIs_production_min$1.Profiler=g;reactIs_production_min$1.StrictMode=f;reactIs_production_min$1.Suspense=p;reactIs_production_min$1.isAsyncMode=function(a){return A(a)||z(a)===l};reactIs_production_min$1.isConcurrentMode=A;reactIs_production_min$1.isContextConsumer=function(a){return z(a)===k};reactIs_production_min$1.isContextProvider=function(a){return z(a)===h};reactIs_production_min$1.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min$1.isForwardRef=function(a){return z(a)===n};reactIs_production_min$1.isFragment=function(a){return z(a)===e};reactIs_production_min$1.isLazy=function(a){return z(a)===t};
+		reactIs_production_min$1.isMemo=function(a){return z(a)===r};reactIs_production_min$1.isPortal=function(a){return z(a)===d};reactIs_production_min$1.isProfiler=function(a){return z(a)===g};reactIs_production_min$1.isStrictMode=function(a){return z(a)===f};reactIs_production_min$1.isSuspense=function(a){return z(a)===p};
+		reactIs_production_min$1.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};reactIs_production_min$1.typeOf=z;
+		return reactIs_production_min$1;
+	}
+
+	var hasRequiredReactIs$2;
+
+	function requireReactIs$2 () {
+		if (hasRequiredReactIs$2) return reactIs$2.exports;
+		hasRequiredReactIs$2 = 1;
+
+		{
+		  reactIs$2.exports = requireReactIs_production_min$1();
+		}
+		return reactIs$2.exports;
+	}
+
+	var hoistNonReactStatics_cjs;
+	var hasRequiredHoistNonReactStatics_cjs;
+
+	function requireHoistNonReactStatics_cjs () {
+		if (hasRequiredHoistNonReactStatics_cjs) return hoistNonReactStatics_cjs;
+		hasRequiredHoistNonReactStatics_cjs = 1;
+
+		var reactIs = requireReactIs$2();
+
+		/**
+		 * Copyright 2015, Yahoo! Inc.
+		 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+		 */
+		var REACT_STATICS = {
+		  childContextTypes: true,
+		  contextType: true,
+		  contextTypes: true,
+		  defaultProps: true,
+		  displayName: true,
+		  getDefaultProps: true,
+		  getDerivedStateFromError: true,
+		  getDerivedStateFromProps: true,
+		  mixins: true,
+		  propTypes: true,
+		  type: true
+		};
+		var KNOWN_STATICS = {
+		  name: true,
+		  length: true,
+		  prototype: true,
+		  caller: true,
+		  callee: true,
+		  arguments: true,
+		  arity: true
+		};
+		var FORWARD_REF_STATICS = {
+		  '$$typeof': true,
+		  render: true,
+		  defaultProps: true,
+		  displayName: true,
+		  propTypes: true
+		};
+		var MEMO_STATICS = {
+		  '$$typeof': true,
+		  compare: true,
+		  defaultProps: true,
+		  displayName: true,
+		  propTypes: true,
+		  type: true
+		};
+		var TYPE_STATICS = {};
+		TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+		TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+
+		function getStatics(component) {
+		  // React v16.11 and below
+		  if (reactIs.isMemo(component)) {
+		    return MEMO_STATICS;
+		  } // React v16.12 and above
+
+
+		  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
+		}
+
+		var defineProperty = Object.defineProperty;
+		var getOwnPropertyNames = Object.getOwnPropertyNames;
+		var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+		var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+		var getPrototypeOf = Object.getPrototypeOf;
+		var objectPrototype = Object.prototype;
+		function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+		  if (typeof sourceComponent !== 'string') {
+		    // don't hoist over string (html) components
+		    if (objectPrototype) {
+		      var inheritedComponent = getPrototypeOf(sourceComponent);
+
+		      if (inheritedComponent && inheritedComponent !== objectPrototype) {
+		        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+		      }
+		    }
+
+		    var keys = getOwnPropertyNames(sourceComponent);
+
+		    if (getOwnPropertySymbols) {
+		      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+		    }
+
+		    var targetStatics = getStatics(targetComponent);
+		    var sourceStatics = getStatics(sourceComponent);
+
+		    for (var i = 0; i < keys.length; ++i) {
+		      var key = keys[i];
+
+		      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+		        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+
+		        try {
+		          // Avoid failures from read-only properties
+		          defineProperty(targetComponent, key, descriptor);
+		        } catch (e) {}
+		      }
+		    }
+		  }
+
+		  return targetComponent;
+		}
+
+		hoistNonReactStatics_cjs = hoistNonReactStatics;
+		return hoistNonReactStatics_cjs;
+	}
+
+	requireHoistNonReactStatics_cjs();
+
+	var isBrowser = true;
+
+	function getRegisteredStyles(registered, registeredStyles, classNames) {
+	  var rawClassName = '';
+	  classNames.split(' ').forEach(function (className) {
+	    if (registered[className] !== undefined) {
+	      registeredStyles.push(registered[className] + ";");
+	    } else if (className) {
+	      rawClassName += className + " ";
+	    }
+	  });
+	  return rawClassName;
+	}
+	var registerStyles = function registerStyles(cache, serialized, isStringTag) {
+	  var className = cache.key + "-" + serialized.name;
+
+	  if ( // we only need to add the styles to the registered cache if the
+	  // class name could be used further down
+	  // the tree but if it's a string tag, we know it won't
+	  // so we don't have to add it to registered cache.
+	  // this improves memory usage since we can avoid storing the whole style string
+	  (isStringTag === false || // we need to always store it if we're in compat mode and
+	  // in node since emotion-server relies on whether a style is in
+	  // the registered cache to know whether a style is global or not
+	  // also, note that this check will be dead code eliminated in the browser
+	  isBrowser === false ) && cache.registered[className] === undefined) {
+	    cache.registered[className] = serialized.styles;
+	  }
+	};
+	var insertStyles = function insertStyles(cache, serialized, isStringTag) {
+	  registerStyles(cache, serialized, isStringTag);
+	  var className = cache.key + "-" + serialized.name;
+
+	  if (cache.inserted[serialized.name] === undefined) {
+	    var current = serialized;
+
+	    do {
+	      cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
+
+	      current = current.next;
+	    } while (current !== undefined);
+	  }
+	};
+
 	/* eslint-disable */
 	// Inspired by https://github.com/garycourt/murmurhash-js
 	// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
@@ -298,14 +1687,6 @@
 	  strokeWidth: 1
 	};
 
-	function memoize$3(fn) {
-	  var cache = Object.create(null);
-	  return function (arg) {
-	    if (cache[arg] === undefined) cache[arg] = fn(arg);
-	    return cache[arg];
-	  };
-	}
-
 	var hyphenateRegex = /[A-Z]|^ms/g;
 	var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
 
@@ -401,14 +1782,29 @@
 
 	        return createStringFromObject(mergedProps, registered, interpolation);
 	      }
+
+	    case 'function':
+	      {
+	        if (mergedProps !== undefined) {
+	          var previousCursor = cursor;
+	          var result = interpolation(mergedProps);
+	          cursor = previousCursor;
+	          return handleInterpolation(mergedProps, registered, result);
+	        }
+
+	        break;
+	      }
 	  } // finalize string values (regular strings and functions interpolated into css calls)
 
 
 	  var asString = interpolation;
 
-	  {
+	  if (registered == null) {
 	    return asString;
 	  }
+
+	  var cached = registered[asString];
+	  return cached !== undefined ? cached : asString;
 	}
 
 	function createStringFromObject(mergedProps, registered, obj) {
@@ -425,12 +1821,14 @@
 	      if (typeof value !== 'object') {
 	        var asString = value;
 
-	        if (isProcessableValue(asString)) {
+	        if (registered != null && registered[asString] !== undefined) {
+	          string += key + "{" + registered[asString] + "}";
+	        } else if (isProcessableValue(asString)) {
 	          string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
 	        }
 	      } else {
 
-	        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null)) {
+	        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
 	          for (var _i = 0; _i < value.length; _i++) {
 	            if (isProcessableValue(value[_i])) {
 	              string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
@@ -513,13 +1911,383 @@
 	  };
 	}
 
-	var reactExports = requireReact();
-	var We = /*@__PURE__*/getDefaultExportFromCjs(reactExports);
+	var syncFallback = function syncFallback(create) {
+	  return create();
+	};
 
-	var React2 = /*#__PURE__*/_mergeNamespaces({
-		__proto__: null,
-		default: We
-	}, [reactExports]);
+	var useInsertionEffect$1 = React2['useInsertion' + 'Effect'] ? React2['useInsertion' + 'Effect'] : false;
+	var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect$1 || syncFallback;
+	var useInsertionEffectWithLayoutFallback = useInsertionEffect$1 || reactExports.useLayoutEffect;
+
+	var EmotionCacheContext = /* #__PURE__ */reactExports.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
+	// because this module is primarily intended for the browser and node
+	// but it's also required in react native and similar environments sometimes
+	// and we could have a special build just for that
+	// but this is much easier and the native packages
+	// might use a different theme context in the future anyway
+	typeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({
+	  key: 'css'
+	}) : null);
+
+	EmotionCacheContext.Provider;
+
+	var withEmotionCache = function withEmotionCache(func) {
+	  return /*#__PURE__*/reactExports.forwardRef(function (props, ref) {
+	    // the cache will never be null in the browser
+	    var cache = reactExports.useContext(EmotionCacheContext);
+	    return func(props, cache, ref);
+	  });
+	};
+
+	var ThemeContext$1 = /* #__PURE__ */reactExports.createContext({});
+
+	var hasOwn$1 = {}.hasOwnProperty;
+
+	var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
+	var createEmotionProps = function createEmotionProps(type, props) {
+
+	  var newProps = {};
+
+	  for (var _key in props) {
+	    if (hasOwn$1.call(props, _key)) {
+	      newProps[_key] = props[_key];
+	    }
+	  }
+
+	  newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:
+
+	  return newProps;
+	};
+
+	var Insertion$1 = function Insertion(_ref) {
+	  var cache = _ref.cache,
+	      serialized = _ref.serialized,
+	      isStringTag = _ref.isStringTag;
+	  registerStyles(cache, serialized, isStringTag);
+	  useInsertionEffectAlwaysWithSyncFallback(function () {
+	    return insertStyles(cache, serialized, isStringTag);
+	  });
+
+	  return null;
+	};
+
+	var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
+	  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
+	  // not passing the registered cache to serializeStyles because it would
+	  // make certain babel optimisations not possible
+
+	  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
+	    cssProp = cache.registered[cssProp];
+	  }
+
+	  var WrappedComponent = props[typePropName];
+	  var registeredStyles = [cssProp];
+	  var className = '';
+
+	  if (typeof props.className === 'string') {
+	    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
+	  } else if (props.className != null) {
+	    className = props.className + " ";
+	  }
+
+	  var serialized = serializeStyles(registeredStyles, undefined, reactExports.useContext(ThemeContext$1));
+
+	  className += cache.key + "-" + serialized.name;
+	  var newProps = {};
+
+	  for (var _key2 in props) {
+	    if (hasOwn$1.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && (true )) {
+	      newProps[_key2] = props[_key2];
+	    }
+	  }
+
+	  newProps.className = className;
+
+	  if (ref) {
+	    newProps.ref = ref;
+	  }
+
+	  return /*#__PURE__*/reactExports.createElement(reactExports.Fragment, null, /*#__PURE__*/reactExports.createElement(Insertion$1, {
+	    cache: cache,
+	    serialized: serialized,
+	    isStringTag: typeof WrappedComponent === 'string'
+	  }), /*#__PURE__*/reactExports.createElement(WrappedComponent, newProps));
+	});
+
+	var Emotion$1 = Emotion;
+
+	var jsx = function jsx(type, props) {
+	  // eslint-disable-next-line prefer-rest-params
+	  var args = arguments;
+
+	  if (props == null || !hasOwn$1.call(props, 'css')) {
+	    return reactExports.createElement.apply(undefined, args);
+	  }
+
+	  var argsLength = args.length;
+	  var createElementArgArray = new Array(argsLength);
+	  createElementArgArray[0] = Emotion$1;
+	  createElementArgArray[1] = createEmotionProps(type, props);
+
+	  for (var i = 2; i < argsLength; i++) {
+	    createElementArgArray[i] = args[i];
+	  }
+
+	  return reactExports.createElement.apply(null, createElementArgArray);
+	};
+
+	(function (_jsx) {
+	  var JSX;
+
+	  (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
+	})(jsx || (jsx = {}));
+
+	// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
+	// initial client-side render from SSR, use place of hydrating tag
+
+	var Global = /* #__PURE__ */withEmotionCache(function (props, cache) {
+
+	  var styles = props.styles;
+	  var serialized = serializeStyles([styles], undefined, reactExports.useContext(ThemeContext$1));
+	  // but it is based on a constant that will never change at runtime
+	  // it's effectively like having two implementations and switching them out
+	  // so it's not actually breaking anything
+
+
+	  var sheetRef = reactExports.useRef();
+	  useInsertionEffectWithLayoutFallback(function () {
+	    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
+
+	    var sheet = new cache.sheet.constructor({
+	      key: key,
+	      nonce: cache.sheet.nonce,
+	      container: cache.sheet.container,
+	      speedy: cache.sheet.isSpeedy
+	    });
+	    var rehydrating = false;
+	    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
+
+	    if (cache.sheet.tags.length) {
+	      sheet.before = cache.sheet.tags[0];
+	    }
+
+	    if (node !== null) {
+	      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
+
+	      node.setAttribute('data-emotion', key);
+	      sheet.hydrate([node]);
+	    }
+
+	    sheetRef.current = [sheet, rehydrating];
+	    return function () {
+	      sheet.flush();
+	    };
+	  }, [cache]);
+	  useInsertionEffectWithLayoutFallback(function () {
+	    var sheetRefCurrent = sheetRef.current;
+	    var sheet = sheetRefCurrent[0],
+	        rehydrating = sheetRefCurrent[1];
+
+	    if (rehydrating) {
+	      sheetRefCurrent[1] = false;
+	      return;
+	    }
+
+	    if (serialized.next !== undefined) {
+	      // insert keyframes
+	      insertStyles(cache, serialized.next, true);
+	    }
+
+	    if (sheet.tags.length) {
+	      // if this doesn't exist then it will be null so the style element will be appended
+	      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
+	      sheet.before = element;
+	      sheet.flush();
+	    }
+
+	    cache.insert("", serialized, sheet, false);
+	  }, [cache, serialized.name]);
+	  return null;
+	});
+
+	// eslint-disable-next-line no-undef
+	var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|popover|popoverTarget|popoverTargetAction|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
+
+	var isPropValid = /* #__PURE__ */memoize$3(function (prop) {
+	  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
+	  /* o */
+	  && prop.charCodeAt(1) === 110
+	  /* n */
+	  && prop.charCodeAt(2) < 91;
+	}
+	/* Z+1 */
+	);
+
+	var testOmitPropsOnStringTag = isPropValid;
+
+	var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
+	  return key !== 'theme';
+	};
+
+	var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
+	  return typeof tag === 'string' && // 96 is one less than the char code
+	  // for "a" so this is checking that
+	  // it's a lowercase character
+	  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
+	};
+	var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
+	  var shouldForwardProp;
+
+	  if (options) {
+	    var optionsShouldForwardProp = options.shouldForwardProp;
+	    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
+	      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
+	    } : optionsShouldForwardProp;
+	  }
+
+	  if (typeof shouldForwardProp !== 'function' && isReal) {
+	    shouldForwardProp = tag.__emotion_forwardProp;
+	  }
+
+	  return shouldForwardProp;
+	};
+
+	var Insertion = function Insertion(_ref) {
+	  var cache = _ref.cache,
+	      serialized = _ref.serialized,
+	      isStringTag = _ref.isStringTag;
+	  registerStyles(cache, serialized, isStringTag);
+	  useInsertionEffectAlwaysWithSyncFallback(function () {
+	    return insertStyles(cache, serialized, isStringTag);
+	  });
+
+	  return null;
+	};
+
+	var createStyled$1 = function createStyled(tag, options) {
+
+	  var isReal = tag.__emotion_real === tag;
+	  var baseTag = isReal && tag.__emotion_base || tag;
+	  var identifierName;
+	  var targetClassName;
+
+	  if (options !== undefined) {
+	    identifierName = options.label;
+	    targetClassName = options.target;
+	  }
+
+	  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
+	  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
+	  var shouldUseAs = !defaultShouldForwardProp('as');
+	  return function () {
+	    // eslint-disable-next-line prefer-rest-params
+	    var args = arguments;
+	    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
+
+	    if (identifierName !== undefined) {
+	      styles.push("label:" + identifierName + ";");
+	    }
+
+	    if (args[0] == null || args[0].raw === undefined) {
+	      // eslint-disable-next-line prefer-spread
+	      styles.push.apply(styles, args);
+	    } else {
+	      var templateStringsArr = args[0];
+
+	      styles.push(templateStringsArr[0]);
+	      var len = args.length;
+	      var i = 1;
+
+	      for (; i < len; i++) {
+
+	        styles.push(args[i], templateStringsArr[i]);
+	      }
+	    }
+
+	    var Styled = withEmotionCache(function (props, cache, ref) {
+	      var FinalTag = shouldUseAs && props.as || baseTag;
+	      var className = '';
+	      var classInterpolations = [];
+	      var mergedProps = props;
+
+	      if (props.theme == null) {
+	        mergedProps = {};
+
+	        for (var key in props) {
+	          mergedProps[key] = props[key];
+	        }
+
+	        mergedProps.theme = reactExports.useContext(ThemeContext$1);
+	      }
+
+	      if (typeof props.className === 'string') {
+	        className = getRegisteredStyles(cache.registered, classInterpolations, props.className);
+	      } else if (props.className != null) {
+	        className = props.className + " ";
+	      }
+
+	      var serialized = serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
+	      className += cache.key + "-" + serialized.name;
+
+	      if (targetClassName !== undefined) {
+	        className += " " + targetClassName;
+	      }
+
+	      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
+	      var newProps = {};
+
+	      for (var _key in props) {
+	        if (shouldUseAs && _key === 'as') continue;
+
+	        if (finalShouldForwardProp(_key)) {
+	          newProps[_key] = props[_key];
+	        }
+	      }
+
+	      newProps.className = className;
+
+	      if (ref) {
+	        newProps.ref = ref;
+	      }
+
+	      return /*#__PURE__*/reactExports.createElement(reactExports.Fragment, null, /*#__PURE__*/reactExports.createElement(Insertion, {
+	        cache: cache,
+	        serialized: serialized,
+	        isStringTag: typeof FinalTag === 'string'
+	      }), /*#__PURE__*/reactExports.createElement(FinalTag, newProps));
+	    });
+	    Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
+	    Styled.defaultProps = tag.defaultProps;
+	    Styled.__emotion_real = Styled;
+	    Styled.__emotion_base = baseTag;
+	    Styled.__emotion_styles = styles;
+	    Styled.__emotion_forwardProp = shouldForwardProp;
+	    Object.defineProperty(Styled, 'toString', {
+	      value: function value() {
+
+	        return "." + targetClassName;
+	      }
+	    });
+
+	    Styled.withComponent = function (nextTag, nextOptions) {
+	      var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {
+	        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
+	      }));
+	      return newStyled.apply(void 0, styles);
+	    };
+
+	    return Styled;
+	  };
+	};
+
+	var tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
+	'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];
+
+	// bind it to avoid mutating the original function
+	var styled$2 = createStyled$1.bind(null);
+	tags.forEach(function (tagName) {
+	  styled$2[tagName] = styled$2(tagName);
+	});
 
 	function isEmpty$4(obj) {
 	  return obj === undefined || obj === null || Object.keys(obj).length === 0;
@@ -530,7 +2298,7 @@
 	    defaultTheme = {}
 	  } = props;
 	  const globalStyles = typeof styles === 'function' ? themeInput => styles(isEmpty$4(themeInput) ? defaultTheme : themeInput) : styles;
-	  return /*#__PURE__*/jsxRuntimeExports.jsx(react$1.Global, {
+	  return /*#__PURE__*/jsxRuntimeExports.jsx(Global, {
 	    styles: globalStyles
 	  });
 	}
@@ -543,7 +2311,7 @@
 	 * LICENSE file in the root directory of this source tree.
 	 */
 	function styled$1(tag, options) {
-	  const stylesFactory = emStyled(tag, options);
+	  const stylesFactory = styled$2(tag, options);
 	  return stylesFactory;
 	}
 
@@ -2033,7 +3801,7 @@
 	  return Object.keys(obj).length === 0;
 	}
 	function useTheme$3(defaultTheme = null) {
-	  const contextTheme = reactExports.useContext(react$1.ThemeContext);
+	  const contextTheme = reactExports.useContext(ThemeContext$1);
 	  return !contextTheme || isObjectEmpty$2(contextTheme) ? defaultTheme : contextTheme;
 	}
 
@@ -3081,7 +4849,7 @@
 	  const layerOrder = useLayerOrder(engineTheme);
 	  return /*#__PURE__*/jsxRuntimeExports.jsx(ThemeProvider$2, {
 	    theme: privateTheme,
-	    children: /*#__PURE__*/jsxRuntimeExports.jsx(react$1.ThemeContext.Provider, {
+	    children: /*#__PURE__*/jsxRuntimeExports.jsx(ThemeContext$1.Provider, {
 	      value: engineTheme,
 	      children: /*#__PURE__*/jsxRuntimeExports.jsx(RtlProvider, {
 	        value: rtlValue,
@@ -48371,5 +50139,5 @@ export default theme;`;
 	}
 	window.renderForm = renderForm;
 
-})(emStyled, react$1);
+})();
 //# sourceMappingURL=form.bundle.js.map