@tanstack/query-devtools 5.0.0-alpha.50 → 5.0.0-alpha.52

package/build/{esm/index.mjs → lib/index.js}

@@ -2,6 +2,7 @@ const sharedConfig = {};
 function setHydrateContext(context) {
   sharedConfig.context = context;
 }
+
 const equalFn = (a, b) => a === b;
 const $PROXY = Symbol("solid-proxy");
 const $TRACK = Symbol("solid-track");
@@ -407,6 +408,7 @@ function createProvider(id, options) {
     return res;
   };
 }
+
 const FALLBACK$1 = Symbol("fallback");
 function dispose$1(d) {
   for (let i = 0; i < d.length; i++) d[i]();
@@ -451,7 +453,8 @@ function mapArray(list, mapFn, options = {}) {
           });
           len = 1;
         }
-      } else if (len === 0) {
+      }
+      else if (len === 0) {
         mapped = new Array(newLen);
         for (j = 0; j < newLen; j++) {
           items[j] = newItems[j];
@@ -656,6 +659,7 @@ function mergeProps(...sources) {
   }
   return target;
 }
+
 function For(props) {
   const fallback = "fallback" in props && {
     fallback: () => props.fallback
@@ -737,6 +741,7 @@ const SVGNamespace = {
   xlink: "http://www.w3.org/1999/xlink",
   xml: "http://www.w3.org/XML/1998/namespace"
 };
+
 function reconcileArrays(parentNode, a, b) {
   let bLength = b.length,
     aEnd = a.length,
@@ -793,6 +798,7 @@ function reconcileArrays(parentNode, a, b) {
     }
   }
 }
+
 const $$EVENTS = "_$DX_DELEGATE";
 function render(code, element, init, options = {}) {
   let disposer;
@@ -1067,9 +1073,9 @@ function normalizeIncomingArray(normalized, array, current, unwrap) {
       prev = current && current[i];
     if (item instanceof Node) {
       normalized.push(item);
-    } else if (item == null || item === true || item === false) ;else if (Array.isArray(item)) {
+    } else if (item == null || item === true || item === false) ; else if (Array.isArray(item)) {
       dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
-    } else if (typeof item === "function") {
+    } else if ((typeof item) === "function") {
       if (unwrap) {
         while (typeof item === "function") item = item();
         dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item], Array.isArray(prev) ? prev : [prev]) || dynamic;
@@ -1835,6 +1841,7 @@ function sheetForTag(tag) {
 
   /* istanbul ignore next */
 
+
   for (var i = 0; i < document.styleSheets.length; i++) {
     if (document.styleSheets[i].ownerNode === tag) {
       // $FlowFixMe
@@ -1842,22 +1849,28 @@ function sheetForTag(tag) {
     }
   }
 }
+
 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;
@@ -1869,9 +1882,12 @@ var StyleSheet = /*#__PURE__*/function () {
       } else {
         before = _this.tags[_this.tags.length - 1].nextSibling;
       }
+
       _this.container.insertBefore(tag, before);
+
       _this.tags.push(tag);
     };
+
     this.isSpeedy = options.speedy === undefined ? process.env.NODE_ENV === 'production' : options.speedy;
     this.tags = [];
     this.ctr = 0;
@@ -1883,10 +1899,13 @@ var StyleSheet = /*#__PURE__*/function () {
     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
@@ -1894,9 +1913,12 @@ var StyleSheet = /*#__PURE__*/function () {
     if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
       this._insertTag(createStyleElement(this));
     }
+
     var tag = this.tags[this.tags.length - 1];
+
     if (process.env.NODE_ENV !== 'production') {
       var isImportRule = rule.charCodeAt(0) === 64 && rule.charCodeAt(1) === 105;
+
       if (isImportRule && this._alreadyInsertedOrderInsensitiveRule) {
         // this would only cause problem in speedy mode
         // but we don't want enabling speedy to affect the observable behavior
@@ -1905,8 +1927,10 @@ var StyleSheet = /*#__PURE__*/function () {
       }
       this._alreadyInsertedOrderInsensitiveRule = this._alreadyInsertedOrderInsensitiveRule || !isImportRule;
     }
+
     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
@@ -1919,8 +1943,10 @@ var StyleSheet = /*#__PURE__*/function () {
     } else {
       tag.appendChild(document.createTextNode(rule));
     }
+
     this.ctr++;
   };
+
   _proto.flush = function flush() {
     // $FlowFixMe
     this.tags.forEach(function (tag) {
@@ -1928,16 +1954,19 @@ var StyleSheet = /*#__PURE__*/function () {
     });
     this.tags = [];
     this.ctr = 0;
+
     if (process.env.NODE_ENV !== 'production') {
       this._alreadyInsertedOrderInsensitiveRule = false;
     }
   };
+
   return StyleSheet;
 }();
 
 var MS = '-ms-';
 var MOZ = '-moz-';
 var WEBKIT = '-webkit-';
+
 var COMMENT = 'comm';
 var RULESET = 'rule';
 var DECLARATION = 'decl';
@@ -1968,16 +1997,16 @@ var assign = Object.assign;
  * @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;
+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();
+function trim (value) {
+	return value.trim()
 }
 
 /**
@@ -1985,8 +2014,8 @@ function trim(value) {
  * @param {RegExp} pattern
  * @return {string?}
  */
-function match(value, pattern) {
-  return (value = pattern.exec(value)) ? value[0] : value;
+function match (value, pattern) {
+	return (value = pattern.exec(value)) ? value[0] : value
 }
 
 /**
@@ -1995,8 +2024,8 @@ function match(value, pattern) {
  * @param {string} replacement
  * @return {string}
  */
-function replace(value, pattern, replacement) {
-  return value.replace(pattern, replacement);
+function replace (value, pattern, replacement) {
+	return value.replace(pattern, replacement)
 }
 
 /**
@@ -2004,8 +2033,8 @@ function replace(value, pattern, replacement) {
  * @param {string} search
  * @return {number}
  */
-function indexof(value, search) {
-  return value.indexOf(search);
+function indexof (value, search) {
+	return value.indexOf(search)
 }
 
 /**
@@ -2013,8 +2042,8 @@ function indexof(value, search) {
  * @param {number} index
  * @return {number}
  */
-function charat(value, index) {
-  return value.charCodeAt(index) | 0;
+function charat (value, index) {
+	return value.charCodeAt(index) | 0
 }
 
 /**
@@ -2023,24 +2052,24 @@ function charat(value, index) {
  * @param {number} end
  * @return {string}
  */
-function substr(value, begin, end) {
-  return value.slice(begin, end);
+function substr (value, begin, end) {
+	return value.slice(begin, end)
 }
 
 /**
  * @param {string} value
  * @return {number}
  */
-function strlen(value) {
-  return value.length;
+function strlen (value) {
+	return value.length
 }
 
 /**
  * @param {any[]} value
  * @return {number}
  */
-function sizeof(value) {
-  return value.length;
+function sizeof (value) {
+	return value.length
 }
 
 /**
@@ -2048,8 +2077,8 @@ function sizeof(value) {
  * @param {any[]} array
  * @return {any}
  */
-function append(value, array) {
-  return array.push(value), value;
+function append (value, array) {
+	return array.push(value), value
 }
 
 /**
@@ -2057,8 +2086,8 @@ function append(value, array) {
  * @param {function} callback
  * @return {string}
  */
-function combine(array, callback) {
-  return array.map(callback).join('');
+function combine (array, callback) {
+	return array.map(callback).join('')
 }
 
 var line = 1;
@@ -2077,19 +2106,8 @@ var characters = '';
  * @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: ''
-  };
+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: ''}
 }
 
 /**
@@ -2097,49 +2115,53 @@ function node(value, root, parent, type, props, children, length) {
  * @param {object} props
  * @return {object}
  */
-function copy$1(root, props) {
-  return assign(node('', null, null, '', null, null, 0), root, {
-    length: -root.length
-  }, props);
+function copy$1 (root, props) {
+	return assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
 }
 
 /**
  * @return {number}
  */
-function char() {
-  return character;
+function char () {
+	return character
 }
 
 /**
  * @return {number}
  */
-function prev() {
-  character = position > 0 ? charat(characters, --position) : 0;
-  if (column--, character === 10) column = 1, line--;
-  return character;
+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;
+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);
+function peek () {
+	return charat(characters, position)
 }
 
 /**
  * @return {number}
  */
-function caret() {
-  return position;
+function caret () {
+	return position
 }
 
 /**
@@ -2147,84 +2169,74 @@ function caret() {
  * @param {number} end
  * @return {string}
  */
-function slice(begin, end) {
-  return substr(characters, begin, end);
+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;
+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, [];
+function alloc (value) {
+	return line = column = 1, length = strlen(characters = value), position = 0, []
 }
 
 /**
  * @param {any} value
  * @return {any}
  */
-function dealloc(value) {
-  return characters = '', value;
+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)));
+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 ? '' : ' ';
+function whitespace (type) {
+	while (character = peek())
+		if (character < 33)
+			next();
+		else
+			break
+
+	return token(type) > 2 || token(character) > 3 ? '' : ' '
 }
 
 /**
@@ -2232,37 +2244,42 @@ function whitespace(type) {
  * @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));
+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;
+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
 }
 
 /**
@@ -2270,30 +2287,35 @@ function delimiter(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());
+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);
+function identifier (index) {
+	while (!token(peek()))
+		next();
+
+	return slice(index, position)
 }
 
 /**
  * @param {string} value
  * @return {object[]}
  */
-function compile(value) {
-  return dealloc(parse('', null, null, null, [''], value = alloc(value), 0, [0], value));
+function compile (value) {
+	return dealloc(parse('', null, null, null, [''], value = alloc(value), 0, [0], value))
 }
 
 /**
@@ -2308,120 +2330,124 @@ function compile(value) {
  * @param {string[]} declarations
  * @return {object}
  */
-function parse(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(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(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(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;
+function parse (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(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(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(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
 }
 
 /**
@@ -2438,12 +2464,17 @@ function parse(value, root, parent, rule, rules, rulesets, pseudo, points, decla
  * @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);
+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)
 }
 
 /**
@@ -2452,8 +2483,8 @@ function ruleset(value, root, parent, index, offset, rules, points, type, props,
  * @param {object?} parent
  * @return {object}
  */
-function comment(value, root, parent) {
-  return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0);
+function comment (value, root, parent) {
+	return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0)
 }
 
 /**
@@ -2463,8 +2494,8 @@ function comment(value, root, 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);
+function declaration (value, root, parent, length) {
+	return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length)
 }
 
 /**
@@ -2472,11 +2503,14 @@ function declaration(value, root, parent, length) {
  * @param {function} callback
  * @return {string}
  */
-function serialize$1(children, callback) {
-  var output = '';
-  var length = sizeof(children);
-  for (var i = 0; i < length; i++) output += callback(children[i], i, children, callback) || '';
-  return output;
+function serialize$1 (children, callback) {
+	var output = '';
+	var length = sizeof(children);
+
+	for (var i = 0; i < length; i++)
+		output += callback(children[i], i, children, callback) || '';
+
+	return output
 }
 
 /**
@@ -2486,44 +2520,45 @@ function serialize$1(children, callback) {
  * @param {function} callback
  * @return {string}
  */
-function stringify$1(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$1(element.children, callback) + '}';
-    case RULESET:
-      element.value = element.props.join(',');
-  }
-  return strlen(children = serialize$1(element.children, callback)) ? element.return = element.value + '{' + children + '}' : '';
+function stringify$1 (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$1(element.children, callback) + '}'
+		case RULESET: element.value = element.props.join(',');
+	}
+
+	return strlen(children = serialize$1(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;
-  };
+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 rulesheet (callback) {
+	return function (element) {
+		if (!element.root)
+			if (element = element.return)
+				callback(element);
+	}
 }
 
 var weakMemoize = function weakMemoize(func) {
@@ -2534,6 +2569,7 @@ var weakMemoize = function weakMemoize(func) {
       // $FlowFixMe
       return cache.get(arg);
     }
+
     var ret = func(arg);
     cache.set(arg, ret);
     return ret;
@@ -2551,6 +2587,7 @@ function memoize(fn) {
 var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
   var previous = 0;
   var character = 0;
+
   while (true) {
     previous = character;
     character = peek(); // &\f
@@ -2558,17 +2595,22 @@ var identifierWithPointTracking = function identifierWithPointTracking(begin, po
     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:
@@ -2580,11 +2622,14 @@ var toRules = function toRules(parsed, points) {
           // 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) {
@@ -2600,41 +2645,50 @@ var toRules = function toRules(parsed, points) {
         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
+  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,
-    parent = element.parent;
+      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)) {
+  /* 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];
@@ -2644,10 +2698,9 @@ var compat = function compat(element) {
 var removeLabel = function removeLabel(element) {
   if (element.type === 'decl') {
     var value = element.value;
-    if (
-    // charcode for l
-    value.charCodeAt(0) === 108 &&
-    // charcode for b
+
+    if ( // charcode for l
+    value.charCodeAt(0) === 108 && // charcode for b
     value.charCodeAt(2) === 98) {
       // this ignores label
       element["return"] = '';
@@ -2656,13 +2709,16 @@ var removeLabel = function removeLabel(element) {
   }
 };
 var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';
+
 var isIgnoringComment = function isIgnoringComment(element) {
   return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1;
 };
+
 var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
   return function (element, index, children) {
     if (element.type !== 'rule' || cache.compat) return;
     var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);
+
     if (unsafePseudoClasses) {
       var isNested = !!element.parent; // in nested rules comments become children of the "auto-inserted" rule and that's always the `element.parent`
       //
@@ -2680,11 +2736,12 @@ var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
       //   .b {}
       // }
 
-      var commentContainer = isNested ? element.parent.children :
-      // global rule at the root level
+      var commentContainer = isNested ? element.parent.children : // global rule at the root level
       children;
+
       for (var i = commentContainer.length - 1; i >= 0; i--) {
         var node = commentContainer[i];
+
         if (node.line < element.line) {
           break;
         } // it is quite weird but comments are *usually* put at `column: element.column - 1`
@@ -2704,33 +2761,40 @@ var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
         // with such inputs we wouldn't have to search for the comment at all
         // TODO: consider changing this comment placement in the next major version
 
+
         if (node.column < element.column) {
           if (isIgnoringComment(node)) {
             return;
           }
+
           break;
         }
       }
+
       unsafePseudoClasses.forEach(function (unsafePseudoClass) {
         console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\".");
       });
     }
   };
 };
+
 var isImportRule = function isImportRule(element) {
   return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64;
 };
+
 var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
   for (var i = index - 1; i >= 0; i--) {
     if (!isImportRule(children[i])) {
       return true;
     }
   }
+
   return false;
 }; // use this to remove incorrect elements from further processing
 // so they don't get handed to the `sheet` (or anything else)
 // as that could potentially lead to additional logs which in turn could be overhelming to the user
 
+
 var nullifyElement = function nullifyElement(element) {
   element.type = '';
   element.value = '';
@@ -2738,10 +2802,12 @@ var nullifyElement = function nullifyElement(element) {
   element.children = '';
   element.props = '';
 };
+
 var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
   if (!isImportRule(element)) {
     return;
   }
+
   if (element.parent) {
     console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles.");
     nullifyElement(element);
@@ -2901,6 +2967,7 @@ function prefix(value, length) {
         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
 
@@ -2918,19 +2985,24 @@ function prefix(value, length) {
         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$1([copy$1(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+)/)) {
@@ -2951,10 +3023,12 @@ var prefixer = function prefixer(element, index, children, callback) {
               props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]
             })], callback);
         }
+
         return '';
       });
   }
 };
+
 var isBrowser$1 = typeof document !== 'undefined';
 var getServerStylisCache = isBrowser$1 ? undefined : weakMemoize(function () {
   return memoize(function () {
@@ -2965,11 +3039,14 @@ var getServerStylisCache = isBrowser$1 ? undefined : weakMemoize(function () {
   });
 });
 var defaultStylisPlugins = [prefixer];
+
 var createCache = function createCache(options) {
   var key = options.key;
+
   if (process.env.NODE_ENV !== 'production' && !key) {
     throw new Error("You have to configure `key` for your cache. Please make sure it's unique (and not equal to 'css') as it's used for linking styles to your cache.\n" + "If multiple caches share the same key they might \"fight\" for each other's style elements.");
   }
+
   if (isBrowser$1 && 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)
@@ -2984,6 +3061,7 @@ var createCache = function createCache(options) {
       // 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;
       }
@@ -2991,20 +3069,23 @@ var createCache = function createCache(options) {
       node.setAttribute('data-s', '');
     });
   }
+
   var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
+
   if (process.env.NODE_ENV !== 'production') {
     // $FlowFixMe
     if (/[^a-z-]/.test(key)) {
       throw new Error("Emotion key must only contain lower case alphabetical characters and - but \"" + key + "\" was passed");
     }
   }
+
   var inserted = {};
   var container;
   var nodesToHydrate = [];
+
   if (isBrowser$1) {
     container = options.container || document.head;
-    Array.prototype.forEach.call(
-    // this means we will ignore elements which don't have a space in them which
+    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(' '); // $FlowFixMe
@@ -3012,18 +3093,24 @@ var createCache = function createCache(options) {
       for (var i = 1; i < attrib.length; i++) {
         inserted[attrib[i]] = true;
       }
+
       nodesToHydrate.push(node);
     });
   }
+
   var _insert;
+
   var omnipresentPlugins = [compat, removeLabel];
+
   if (process.env.NODE_ENV !== 'production') {
     omnipresentPlugins.push(createUnsafeSelectorsAlarm({
       get compat() {
         return cache.compat;
       }
+
     }), incorrectImportAlarm);
   }
+
   if (isBrowser$1) {
     var currentSheet;
     var finalizingPlugins = [stringify$1, process.env.NODE_ENV !== 'production' ? function (element) {
@@ -3040,11 +3127,14 @@ var createCache = function createCache(options) {
       currentSheet.insert(rule);
     })];
     var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
+
     var stylis = function stylis(styles) {
       return serialize$1(compile(styles), serializer);
     };
+
     _insert = function insert(selector, serialized, sheet, shouldCache) {
       currentSheet = sheet;
+
       if (process.env.NODE_ENV !== 'production' && serialized.map !== undefined) {
         currentSheet = {
           insert: function insert(rule) {
@@ -3052,29 +3142,39 @@ var createCache = function createCache(options) {
           }
         };
       }
+
       stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
+
       if (shouldCache) {
         cache.inserted[serialized.name] = true;
       }
     };
   } else {
     var _finalizingPlugins = [stringify$1];
+
     var _serializer = middleware(omnipresentPlugins.concat(stylisPlugins, _finalizingPlugins));
+
     var _stylis = function _stylis(styles) {
       return serialize$1(compile(styles), _serializer);
     }; // $FlowFixMe
 
+
     var serverStylisCache = getServerStylisCache(stylisPlugins)(key);
+
     var getRules = function getRules(selector, serialized) {
       var name = serialized.name;
+
       if (serverStylisCache[name] === undefined) {
         serverStylisCache[name] = _stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
       }
+
       return serverStylisCache[name];
     };
+
     _insert = function _insert(selector, serialized, sheet, shouldCache) {
       var name = serialized.name;
       var rules = getRules(selector, serialized);
+
       if (cache.compat === undefined) {
         // in regular mode, we don't set the styles on the inserted cache
         // since we don't need to and that would be wasting memory
@@ -3082,12 +3182,13 @@ var createCache = function createCache(options) {
         if (shouldCache) {
           cache.inserted[name] = true;
         }
-        if (
-        // using === development instead of !== production
+
+        if ( // using === development instead of !== production
         // because if people do ssr in tests, the source maps showing up would be annoying
         process.env.NODE_ENV === 'development' && serialized.map !== undefined) {
           return rules + serialized.map;
         }
+
         return rules;
       } else {
         // in compat mode, we put the styles on the inserted cache so
@@ -3105,6 +3206,7 @@ var createCache = function createCache(options) {
       }
     };
   }
+
   var cache = {
     key: key,
     sheet: new StyleSheet({
@@ -3136,33 +3238,44 @@ function murmur2(str) {
   var h = 0; // Mix 4 bytes at a time into the hash
 
   var k,
-    i = 0,
-    len = str.length;
+      i = 0,
+      len = str.length;
+
   for (; len >= 4; ++i, len -= 4) {
     k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
-    k = /* Math.imul(k, m): */
+    k =
+    /* Math.imul(k, m): */
     (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
-    k ^= /* k >>> r: */
+    k ^=
+    /* k >>> r: */
     k >>> 24;
-    h = /* Math.imul(k, m): */
-    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^ /* Math.imul(h, m): */
+    h =
+    /* Math.imul(k, m): */
+    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
+    /* Math.imul(h, m): */
     (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
   } // Handle the last few bytes of the input array
 
+
   switch (len) {
     case 3:
       h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
+
     case 2:
       h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
+
     case 1:
       h ^= str.charCodeAt(i) & 0xff;
-      h = /* Math.imul(h, m): */
+      h =
+      /* Math.imul(h, m): */
       (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
   } // Do a few final mixes of the hash to ensure the last few
   // bytes are well-incorporated.
 
+
   h ^= h >>> 13;
-  h = /* Math.imul(h, m): */
+  h =
+  /* Math.imul(h, m): */
   (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
   return ((h ^ h >>> 15) >>> 0).toString(36);
 }
@@ -3221,15 +3334,19 @@ var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your te
 var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
 var hyphenateRegex = /[A-Z]|^ms/g;
 var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
+
 var isCustomProperty = function isCustomProperty(property) {
   return property.charCodeAt(1) === 45;
 };
+
 var isProcessableValue = function isProcessableValue(value) {
   return value != null && typeof value !== 'boolean';
 };
+
 var processStyleName = /* #__PURE__ */memoize(function (styleName) {
   return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
 });
+
 var processStyleValue = function processStyleValue(key, value) {
   switch (key) {
     case 'animation':
@@ -3247,11 +3364,14 @@ var processStyleValue = function processStyleValue(key, value) {
         }
       }
   }
+
   if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
     return value + 'px';
   }
+
   return value;
 };
+
 if (process.env.NODE_ENV !== 'production') {
   var contentValuePattern = /(var|attr|counters?|url|element|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/;
   var contentValues = ['normal', 'none', 'initial', 'inherit', 'unset'];
@@ -3259,38 +3379,48 @@ if (process.env.NODE_ENV !== 'production') {
   var msPattern = /^-ms-/;
   var hyphenPattern = /-(.)/g;
   var hyphenatedCache = {};
+
   processStyleValue = function processStyleValue(key, value) {
     if (key === 'content') {
       if (typeof value !== 'string' || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '"' && value.charAt(0) !== "'")) {
         throw new Error("You seem to be using a value for 'content' without quotes, try replacing it with `content: '\"" + value + "\"'`");
       }
     }
+
     var processed = oldProcessStyleValue(key, value);
+
     if (processed !== '' && !isCustomProperty(key) && key.indexOf('-') !== -1 && hyphenatedCache[key] === undefined) {
       hyphenatedCache[key] = true;
       console.error("Using kebab-case for css properties in objects is not supported. Did you mean " + key.replace(msPattern, 'ms-').replace(hyphenPattern, function (str, _char) {
         return _char.toUpperCase();
       }) + "?");
     }
+
     return processed;
   };
 }
+
 var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';
+
 function handleInterpolation(mergedProps, registered, interpolation) {
   if (interpolation == null) {
     return '';
   }
+
   if (interpolation.__emotion_styles !== undefined) {
     if (process.env.NODE_ENV !== 'production' && interpolation.toString() === 'NO_COMPONENT_SELECTOR') {
       throw new Error(noComponentSelectorMessage);
     }
+
     return interpolation;
   }
+
   switch (typeof interpolation) {
     case 'boolean':
       {
         return '';
       }
+
     case 'object':
       {
         if (interpolation.anim === 1) {
@@ -3301,8 +3431,10 @@ function handleInterpolation(mergedProps, registered, interpolation) {
           };
           return interpolation.name;
         }
+
         if (interpolation.styles !== undefined) {
           var next = interpolation.next;
+
           if (next !== undefined) {
             // not the most efficient thing ever but this is a pretty rare case
             // and there will be very few iterations of this generally
@@ -3315,14 +3447,19 @@ function handleInterpolation(mergedProps, registered, interpolation) {
               next = next.next;
             }
           }
+
           var styles = interpolation.styles + ";";
+
           if (process.env.NODE_ENV !== 'production' && interpolation.map !== undefined) {
             styles += interpolation.map;
           }
+
           return styles;
         }
+
         return createStringFromObject(mergedProps, registered, interpolation);
       }
+
     case 'function':
       {
         if (mergedProps !== undefined) {
@@ -3333,8 +3470,10 @@ function handleInterpolation(mergedProps, registered, interpolation) {
         } else if (process.env.NODE_ENV !== 'production') {
           console.error('Functions that are interpolated in css calls will be stringified.\n' + 'If you want to have a css call based on props, create a function that returns a css call like this\n' + 'let dynamicStyle = (props) => css`color: ${props.color}`\n' + 'It can be called directly with props or interpolated in a styled call like this\n' + "let SomeComponent = styled('div')`${dynamicStyle}`");
         }
+
         break;
       }
+
     case 'string':
       if (process.env.NODE_ENV !== 'production') {
         var matched = [];
@@ -3343,21 +3482,27 @@ function handleInterpolation(mergedProps, registered, interpolation) {
           matched.push("const " + fakeVarName + " = keyframes`" + p2.replace(/^@keyframes animation-\w+/, '') + "`");
           return "${" + fakeVarName + "}";
         });
+
         if (matched.length) {
           console.error('`keyframes` output got interpolated into plain string, please wrap it with `css`.\n\n' + 'Instead of doing this:\n\n' + [].concat(matched, ["`" + replaced + "`"]).join('\n') + '\n\nYou should wrap it with `css` like this:\n\n' + ("css`" + replaced + "`"));
         }
       }
+
       break;
   } // finalize string values (regular strings and functions interpolated into css calls)
 
+
   if (registered == null) {
     return interpolation;
   }
+
   var cached = registered[interpolation];
   return cached !== undefined ? cached : interpolation;
 }
+
 function createStringFromObject(mergedProps, registered, obj) {
   var string = '';
+
   if (Array.isArray(obj)) {
     for (var i = 0; i < obj.length; i++) {
       string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
@@ -3365,6 +3510,7 @@ function createStringFromObject(mergedProps, registered, obj) {
   } else {
     for (var _key in obj) {
       var value = obj[_key];
+
       if (typeof value !== 'object') {
         if (registered != null && registered[value] !== undefined) {
           string += _key + "{" + registered[value] + "}";
@@ -3375,6 +3521,7 @@ function createStringFromObject(mergedProps, registered, obj) {
         if (_key === 'NO_COMPONENT_SELECTOR' && process.env.NODE_ENV !== 'production') {
           throw new Error(noComponentSelectorMessage);
         }
+
         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])) {
@@ -3383,6 +3530,7 @@ function createStringFromObject(mergedProps, registered, obj) {
           }
         } else {
           var interpolated = handleInterpolation(mergedProps, registered, value);
+
           switch (_key) {
             case 'animation':
             case 'animationName':
@@ -3390,11 +3538,13 @@ function createStringFromObject(mergedProps, registered, obj) {
                 string += processStyleName(_key) + ":" + interpolated + ";";
                 break;
               }
+
             default:
               {
                 if (process.env.NODE_ENV !== 'production' && _key === 'undefined') {
                   console.error(UNDEFINED_AS_OBJECT_KEY_ERROR);
                 }
+
                 string += _key + "{" + interpolated + "}";
               }
           }
@@ -3402,24 +3552,30 @@ function createStringFromObject(mergedProps, registered, obj) {
       }
     }
   }
+
   return string;
 }
+
 var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g;
 var sourceMapPattern;
+
 if (process.env.NODE_ENV !== 'production') {
   sourceMapPattern = /\/\*#\ssourceMappingURL=data:application\/json;\S+\s+\*\//g;
 } // this is the cursor for keyframes
 // keyframes are stored on the SerializedStyles object as a linked list
 
+
 var cursor;
 var serializeStyles = function serializeStyles(args, registered, mergedProps) {
   if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
     return args[0];
   }
+
   var stringMode = true;
   var styles = '';
   cursor = undefined;
   var strings = args[0];
+
   if (strings == null || strings.raw === undefined) {
     stringMode = false;
     styles += handleInterpolation(mergedProps, registered, strings);
@@ -3427,19 +3583,25 @@ var serializeStyles = function serializeStyles(args, registered, mergedProps) {
     if (process.env.NODE_ENV !== 'production' && strings[0] === undefined) {
       console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
     }
+
     styles += strings[0];
   } // we start at 1 since we've already handled the first arg
 
+
   for (var i = 1; i < args.length; i++) {
     styles += handleInterpolation(mergedProps, registered, args[i]);
+
     if (stringMode) {
       if (process.env.NODE_ENV !== 'production' && strings[i] === undefined) {
         console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
       }
+
       styles += strings[i];
     }
   }
+
   var sourceMap;
+
   if (process.env.NODE_ENV !== 'production') {
     styles = styles.replace(sourceMapPattern, function (match) {
       sourceMap = match;
@@ -3447,16 +3609,18 @@ var serializeStyles = function serializeStyles(args, registered, mergedProps) {
     });
   } // using a global regex with .exec is stateful so lastIndex has to be reset each time
 
+
   labelPattern.lastIndex = 0;
   var identifierName = '';
   var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
 
   while ((match = labelPattern.exec(styles)) !== null) {
-    identifierName += '-' +
-    // $FlowFixMe we know it's not null
+    identifierName += '-' + // $FlowFixMe we know it's not null
     match[1];
   }
+
   var name = murmur2(styles) + identifierName;
+
   if (process.env.NODE_ENV !== 'production') {
     // $FlowFixMe SerializedStyles type doesn't have toString property (and we don't want to add it)
     return {
@@ -3469,6 +3633,7 @@ var serializeStyles = function serializeStyles(args, registered, mergedProps) {
       }
     };
   }
+
   return {
     name: name,
     styles: styles,
@@ -3490,14 +3655,13 @@ function getRegisteredStyles(registered, registeredStyles, classNames) {
 }
 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
+
+  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
+  (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
@@ -3508,16 +3672,21 @@ var registerStyles = function registerStyles(cache, serialized, isStringTag) {
 var insertStyles = function insertStyles(cache, serialized, isStringTag) {
   registerStyles(cache, serialized, isStringTag);
   var className = cache.key + "-" + serialized.name;
+
   if (cache.inserted[serialized.name] === undefined) {
     var stylesForSSR = '';
     var current = serialized;
+
     do {
       var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
+
       if (!isBrowser && maybeStyles !== undefined) {
         stylesForSSR += maybeStyles;
       }
+
       current = current.next;
     } while (current !== undefined);
+
     if (!isBrowser && stylesForSSR.length !== 0) {
       return stylesForSSR;
     }
@@ -3529,14 +3698,18 @@ function insertWithoutScoping(cache, serialized) {
     return cache.insert('', serialized, cache.sheet, true);
   }
 }
+
 function merge(registered, css, className) {
   var registeredStyles = [];
   var rawClassName = getRegisteredStyles(registered, registeredStyles, className);
+
   if (registeredStyles.length < 2) {
     return className;
   }
+
   return rawClassName + css(registeredStyles);
 }
+
 var createEmotion = function createEmotion(options) {
   var cache = createCache(options); // $FlowFixMe
 
@@ -3544,21 +3717,27 @@ var createEmotion = function createEmotion(options) {
     if (process.env.NODE_ENV !== 'production' && this.ctr !== 0) {
       throw new Error('speedy must be changed before any rules are inserted');
     }
+
     this.isSpeedy = value;
   };
+
   cache.compat = true;
+
   var css = function css() {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
+
     var serialized = serializeStyles(args, cache.registered, undefined);
     insertStyles(cache, serialized, false);
     return cache.key + "-" + serialized.name;
   };
+
   var keyframes = function keyframes() {
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
+
     var serialized = serializeStyles(args, cache.registered);
     var animation = "animation-" + serialized.name;
     insertWithoutScoping(cache, {
@@ -3567,19 +3746,24 @@ var createEmotion = function createEmotion(options) {
     });
     return animation;
   };
+
   var injectGlobal = function injectGlobal() {
     for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       args[_key3] = arguments[_key3];
     }
+
     var serialized = serializeStyles(args, cache.registered);
     insertWithoutScoping(cache, serialized);
   };
+
   var cx = function cx() {
     for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
       args[_key4] = arguments[_key4];
     }
+
     return merge(cache.registered, css, classnames(args));
   };
+
   return {
     css: css,
     cx: cx,
@@ -3602,21 +3786,26 @@ var createEmotion = function createEmotion(options) {
     merge: merge.bind(null, cache.registered, css)
   };
 };
+
 var classnames = function classnames(args) {
   var cls = '';
+
   for (var i = 0; i < args.length; i++) {
     var arg = args[i];
     if (arg == null) continue;
     var toAdd = void 0;
+
     switch (typeof arg) {
       case 'boolean':
         break;
+
       case 'object':
         {
           if (Array.isArray(arg)) {
             toAdd = classnames(arg);
           } else {
             toAdd = '';
+
             for (var k in arg) {
               if (arg[k] && k) {
                 toAdd && (toAdd += ' ');
@@ -3624,26 +3813,30 @@ var classnames = function classnames(args) {
               }
             }
           }
+
           break;
         }
+
       default:
         {
           toAdd = arg;
         }
     }
+
     if (toAdd) {
       cls && (cls += ' ');
       cls += toAdd;
     }
   }
+
   return cls;
 };
 
 var _createEmotion = createEmotion({
-    key: 'css'
-  }),
-  cx = _createEmotion.cx,
-  css = _createEmotion.css;
+  key: 'css'
+}),
+    cx = _createEmotion.cx,
+    css = _createEmotion.css;
 
 const ShadowVariants = {
   xs: '0 1px 2px 0 rgb(0 0 0 / 0.05)',
@@ -3950,829 +4143,801 @@ const tokens = {
   }
 };
 
-var DoubleIndexedKV = /** @class */function () {
-  function DoubleIndexedKV() {
-    this.keyToValue = new Map();
-    this.valueToKey = new Map();
-  }
-  DoubleIndexedKV.prototype.set = function (key, value) {
-    this.keyToValue.set(key, value);
-    this.valueToKey.set(value, key);
-  };
-  DoubleIndexedKV.prototype.getByKey = function (key) {
-    return this.keyToValue.get(key);
-  };
-  DoubleIndexedKV.prototype.getByValue = function (value) {
-    return this.valueToKey.get(value);
-  };
-  DoubleIndexedKV.prototype.clear = function () {
-    this.keyToValue.clear();
-    this.valueToKey.clear();
-  };
-  return DoubleIndexedKV;
-}();
-
-var Registry = /** @class */function () {
-  function Registry(generateIdentifier) {
-    this.generateIdentifier = generateIdentifier;
-    this.kv = new DoubleIndexedKV();
-  }
-  Registry.prototype.register = function (value, identifier) {
-    if (this.kv.getByValue(value)) {
-      return;
-    }
-    if (!identifier) {
-      identifier = this.generateIdentifier(value);
+var DoubleIndexedKV = /** @class */ (function () {
+    function DoubleIndexedKV() {
+        this.keyToValue = new Map();
+        this.valueToKey = new Map();
     }
-    this.kv.set(identifier, value);
-  };
-  Registry.prototype.clear = function () {
-    this.kv.clear();
-  };
-  Registry.prototype.getIdentifier = function (value) {
-    return this.kv.getByValue(value);
-  };
-  Registry.prototype.getValue = function (identifier) {
-    return this.kv.getByKey(identifier);
-  };
-  return Registry;
-}();
-
-var __extends = undefined && undefined.__extends || function () {
-  var extendStatics = function (d, b) {
-    extendStatics = Object.setPrototypeOf || {
-      __proto__: []
-    } instanceof Array && function (d, b) {
-      d.__proto__ = b;
-    } || function (d, b) {
-      for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+    DoubleIndexedKV.prototype.set = function (key, value) {
+        this.keyToValue.set(key, value);
+        this.valueToKey.set(value, key);
     };
-    return extendStatics(d, b);
-  };
-  return function (d, b) {
-    if (typeof b !== "function" && b !== null) throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() {
-      this.constructor = d;
-    }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  };
-}();
-var ClassRegistry = /** @class */function (_super) {
-  __extends(ClassRegistry, _super);
-  function ClassRegistry() {
-    var _this = _super.call(this, function (c) {
-      return c.name;
-    }) || this;
-    _this.classToAllowedProps = new Map();
-    return _this;
-  }
-  ClassRegistry.prototype.register = function (value, options) {
-    if (typeof options === 'object') {
-      if (options.allowProps) {
-        this.classToAllowedProps.set(value, options.allowProps);
-      }
-      _super.prototype.register.call(this, value, options.identifier);
-    } else {
-      _super.prototype.register.call(this, value, options);
+    DoubleIndexedKV.prototype.getByKey = function (key) {
+        return this.keyToValue.get(key);
+    };
+    DoubleIndexedKV.prototype.getByValue = function (value) {
+        return this.valueToKey.get(value);
+    };
+    DoubleIndexedKV.prototype.clear = function () {
+        this.keyToValue.clear();
+        this.valueToKey.clear();
+    };
+    return DoubleIndexedKV;
+}());
+
+var Registry = /** @class */ (function () {
+    function Registry(generateIdentifier) {
+        this.generateIdentifier = generateIdentifier;
+        this.kv = new DoubleIndexedKV();
     }
-  };
-  ClassRegistry.prototype.getAllowedProps = function (value) {
-    return this.classToAllowedProps.get(value);
-  };
-  return ClassRegistry;
-}(Registry);
-
-var __read$3 = undefined && undefined.__read || function (o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = {
-      error: error
+    Registry.prototype.register = function (value, identifier) {
+        if (this.kv.getByValue(value)) {
+            return;
+        }
+        if (!identifier) {
+            identifier = this.generateIdentifier(value);
+        }
+        this.kv.set(identifier, value);
     };
-  } finally {
+    Registry.prototype.clear = function () {
+        this.kv.clear();
+    };
+    Registry.prototype.getIdentifier = function (value) {
+        return this.kv.getByValue(value);
+    };
+    Registry.prototype.getValue = function (identifier) {
+        return this.kv.getByKey(identifier);
+    };
+    return Registry;
+}());
+
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var ClassRegistry = /** @class */ (function (_super) {
+    __extends(ClassRegistry, _super);
+    function ClassRegistry() {
+        var _this = _super.call(this, function (c) { return c.name; }) || this;
+        _this.classToAllowedProps = new Map();
+        return _this;
+    }
+    ClassRegistry.prototype.register = function (value, options) {
+        if (typeof options === 'object') {
+            if (options.allowProps) {
+                this.classToAllowedProps.set(value, options.allowProps);
+            }
+            _super.prototype.register.call(this, value, options.identifier);
+        }
+        else {
+            _super.prototype.register.call(this, value, options);
+        }
+    };
+    ClassRegistry.prototype.getAllowedProps = function (value) {
+        return this.classToAllowedProps.get(value);
+    };
+    return ClassRegistry;
+}(Registry));
+
+var __read$3 = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
     try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-  }
-  return ar;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
 };
 function valuesOfObj(record) {
-  if ('values' in Object) {
-    // eslint-disable-next-line es5/no-es6-methods
-    return Object.values(record);
-  }
-  var values = [];
-  // eslint-disable-next-line no-restricted-syntax
-  for (var key in record) {
-    if (record.hasOwnProperty(key)) {
-      values.push(record[key]);
+    if ('values' in Object) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return Object.values(record);
+    }
+    var values = [];
+    // eslint-disable-next-line no-restricted-syntax
+    for (var key in record) {
+        if (record.hasOwnProperty(key)) {
+            values.push(record[key]);
+        }
     }
-  }
-  return values;
+    return values;
 }
 function find(record, predicate) {
-  var values = valuesOfObj(record);
-  if ('find' in values) {
-    // eslint-disable-next-line es5/no-es6-methods
-    return values.find(predicate);
-  }
-  var valuesNotNever = values;
-  for (var i = 0; i < valuesNotNever.length; i++) {
-    var value = valuesNotNever[i];
-    if (predicate(value)) {
-      return value;
+    var values = valuesOfObj(record);
+    if ('find' in values) {
+        // eslint-disable-next-line es5/no-es6-methods
+        return values.find(predicate);
+    }
+    var valuesNotNever = values;
+    for (var i = 0; i < valuesNotNever.length; i++) {
+        var value = valuesNotNever[i];
+        if (predicate(value)) {
+            return value;
+        }
     }
-  }
-  return undefined;
+    return undefined;
 }
 function forEach(record, run) {
-  Object.entries(record).forEach(function (_a) {
-    var _b = __read$3(_a, 2),
-      key = _b[0],
-      value = _b[1];
-    return run(value, key);
-  });
+    Object.entries(record).forEach(function (_a) {
+        var _b = __read$3(_a, 2), key = _b[0], value = _b[1];
+        return run(value, key);
+    });
 }
 function includes(arr, value) {
-  return arr.indexOf(value) !== -1;
+    return arr.indexOf(value) !== -1;
 }
 function findArr(record, predicate) {
-  for (var i = 0; i < record.length; i++) {
-    var value = record[i];
-    if (predicate(value)) {
-      return value;
+    for (var i = 0; i < record.length; i++) {
+        var value = record[i];
+        if (predicate(value)) {
+            return value;
+        }
     }
-  }
-  return undefined;
+    return undefined;
 }
 
-var CustomTransformerRegistry = /** @class */function () {
-  function CustomTransformerRegistry() {
-    this.transfomers = {};
-  }
-  CustomTransformerRegistry.prototype.register = function (transformer) {
-    this.transfomers[transformer.name] = transformer;
-  };
-  CustomTransformerRegistry.prototype.findApplicable = function (v) {
-    return find(this.transfomers, function (transformer) {
-      return transformer.isApplicable(v);
-    });
-  };
-  CustomTransformerRegistry.prototype.findByName = function (name) {
-    return this.transfomers[name];
-  };
-  return CustomTransformerRegistry;
-}();
+var CustomTransformerRegistry = /** @class */ (function () {
+    function CustomTransformerRegistry() {
+        this.transfomers = {};
+    }
+    CustomTransformerRegistry.prototype.register = function (transformer) {
+        this.transfomers[transformer.name] = transformer;
+    };
+    CustomTransformerRegistry.prototype.findApplicable = function (v) {
+        return find(this.transfomers, function (transformer) {
+            return transformer.isApplicable(v);
+        });
+    };
+    CustomTransformerRegistry.prototype.findByName = function (name) {
+        return this.transfomers[name];
+    };
+    return CustomTransformerRegistry;
+}());
 
 var getType$1 = function (payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
+    return Object.prototype.toString.call(payload).slice(8, -1);
 };
 var isUndefined = function (payload) {
-  return typeof payload === 'undefined';
-};
-var isNull = function (payload) {
-  return payload === null;
+    return typeof payload === 'undefined';
 };
+var isNull = function (payload) { return payload === null; };
 var isPlainObject$1 = function (payload) {
-  if (typeof payload !== 'object' || payload === null) return false;
-  if (payload === Object.prototype) return false;
-  if (Object.getPrototypeOf(payload) === null) return true;
-  return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
+    if (typeof payload !== 'object' || payload === null)
+        return false;
+    if (payload === Object.prototype)
+        return false;
+    if (Object.getPrototypeOf(payload) === null)
+        return true;
+    return (payload.constructor === Object &&
+        Object.getPrototypeOf(payload) === Object.prototype);
 };
 var isEmptyObject = function (payload) {
-  return isPlainObject$1(payload) && Object.keys(payload).length === 0;
+    return isPlainObject$1(payload) && Object.keys(payload).length === 0;
 };
 var isArray$1 = function (payload) {
-  return Array.isArray(payload);
+    return Array.isArray(payload);
 };
 var isString = function (payload) {
-  return typeof payload === 'string';
+    return typeof payload === 'string';
 };
 var isNumber = function (payload) {
-  return typeof payload === 'number' && !isNaN(payload);
+    return typeof payload === 'number' && !isNaN(payload);
 };
 var isBoolean = function (payload) {
-  return typeof payload === 'boolean';
+    return typeof payload === 'boolean';
 };
 var isRegExp = function (payload) {
-  return payload instanceof RegExp;
+    return payload instanceof RegExp;
 };
 var isMap = function (payload) {
-  return payload instanceof Map;
+    return payload instanceof Map;
 };
 var isSet = function (payload) {
-  return payload instanceof Set;
+    return payload instanceof Set;
 };
 var isSymbol = function (payload) {
-  return getType$1(payload) === 'Symbol';
+    return getType$1(payload) === 'Symbol';
 };
 var isDate = function (payload) {
-  return payload instanceof Date && !isNaN(payload.valueOf());
+    return payload instanceof Date && !isNaN(payload.valueOf());
 };
 var isError = function (payload) {
-  return payload instanceof Error;
+    return payload instanceof Error;
 };
 var isNaNValue = function (payload) {
-  return typeof payload === 'number' && isNaN(payload);
+    return typeof payload === 'number' && isNaN(payload);
 };
 var isPrimitive = function (payload) {
-  return isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+    return isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload);
 };
 var isBigint = function (payload) {
-  return typeof payload === 'bigint';
+    return typeof payload === 'bigint';
 };
 var isInfinite = function (payload) {
-  return payload === Infinity || payload === -Infinity;
+    return payload === Infinity || payload === -Infinity;
 };
 var isTypedArray = function (payload) {
-  return ArrayBuffer.isView(payload) && !(payload instanceof DataView);
-};
-var isURL = function (payload) {
-  return payload instanceof URL;
+    return ArrayBuffer.isView(payload) && !(payload instanceof DataView);
 };
+var isURL = function (payload) { return payload instanceof URL; };
 
-var escapeKey = function (key) {
-  return key.replace(/\./g, '\\.');
-};
+var escapeKey = function (key) { return key.replace(/\./g, '\\.'); };
 var stringifyPath = function (path) {
-  return path.map(String).map(escapeKey).join('.');
+    return path
+        .map(String)
+        .map(escapeKey)
+        .join('.');
 };
 var parsePath = function (string) {
-  var result = [];
-  var segment = '';
-  for (var i = 0; i < string.length; i++) {
-    var char = string.charAt(i);
-    var isEscapedDot = char === '\\' && string.charAt(i + 1) === '.';
-    if (isEscapedDot) {
-      segment += '.';
-      i++;
-      continue;
-    }
-    var isEndOfSegment = char === '.';
-    if (isEndOfSegment) {
-      result.push(segment);
-      segment = '';
-      continue;
+    var result = [];
+    var segment = '';
+    for (var i = 0; i < string.length; i++) {
+        var char = string.charAt(i);
+        var isEscapedDot = char === '\\' && string.charAt(i + 1) === '.';
+        if (isEscapedDot) {
+            segment += '.';
+            i++;
+            continue;
+        }
+        var isEndOfSegment = char === '.';
+        if (isEndOfSegment) {
+            result.push(segment);
+            segment = '';
+            continue;
+        }
+        segment += char;
     }
-    segment += char;
-  }
-  var lastSegment = segment;
-  result.push(lastSegment);
-  return result;
+    var lastSegment = segment;
+    result.push(lastSegment);
+    return result;
 };
 
-var __assign$1 = undefined && undefined.__assign || function () {
-  __assign$1 = Object.assign || function (t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-    }
-    return t;
-  };
-  return __assign$1.apply(this, arguments);
-};
-var __read$2 = undefined && undefined.__read || function (o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = {
-      error: error
+var __assign$1 = (undefined && undefined.__assign) || function () {
+    __assign$1 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
     };
-  } finally {
+    return __assign$1.apply(this, arguments);
+};
+var __read$2 = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
     try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-  }
-  return ar;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
 };
-var __spreadArray$2 = undefined && undefined.__spreadArray || function (to, from) {
-  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) to[j] = from[i];
-  return to;
+var __spreadArray$2 = (undefined && undefined.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
 };
 function simpleTransformation(isApplicable, annotation, transform, untransform) {
-  return {
-    isApplicable: isApplicable,
-    annotation: annotation,
-    transform: transform,
-    untransform: untransform
-  };
+    return {
+        isApplicable: isApplicable,
+        annotation: annotation,
+        transform: transform,
+        untransform: untransform
+    };
 }
-var simpleRules = [simpleTransformation(isUndefined, 'undefined', function () {
-  return null;
-}, function () {
-  return undefined;
-}), simpleTransformation(isBigint, 'bigint', function (v) {
-  return v.toString();
-}, function (v) {
-  if (typeof BigInt !== 'undefined') {
-    return BigInt(v);
-  }
-  console.error('Please add a BigInt polyfill.');
-  return v;
-}), simpleTransformation(isDate, 'Date', function (v) {
-  return v.toISOString();
-}, function (v) {
-  return new Date(v);
-}), simpleTransformation(isError, 'Error', function (v, superJson) {
-  var baseError = {
-    name: v.name,
-    message: v.message
-  };
-  superJson.allowedErrorProps.forEach(function (prop) {
-    baseError[prop] = v[prop];
-  });
-  return baseError;
-}, function (v, superJson) {
-  var e = new Error(v.message);
-  e.name = v.name;
-  e.stack = v.stack;
-  superJson.allowedErrorProps.forEach(function (prop) {
-    e[prop] = v[prop];
-  });
-  return e;
-}), simpleTransformation(isRegExp, 'regexp', function (v) {
-  return '' + v;
-}, function (regex) {
-  var body = regex.slice(1, regex.lastIndexOf('/'));
-  var flags = regex.slice(regex.lastIndexOf('/') + 1);
-  return new RegExp(body, flags);
-}), simpleTransformation(isSet, 'set',
-// (sets only exist in es6+)
-// eslint-disable-next-line es5/no-es6-methods
-function (v) {
-  return __spreadArray$2([], __read$2(v.values()));
-}, function (v) {
-  return new Set(v);
-}), simpleTransformation(isMap, 'map', function (v) {
-  return __spreadArray$2([], __read$2(v.entries()));
-}, function (v) {
-  return new Map(v);
-}), simpleTransformation(function (v) {
-  return isNaNValue(v) || isInfinite(v);
-}, 'number', function (v) {
-  if (isNaNValue(v)) {
-    return 'NaN';
-  }
-  if (v > 0) {
-    return 'Infinity';
-  } else {
-    return '-Infinity';
-  }
-}, Number), simpleTransformation(function (v) {
-  return v === 0 && 1 / v === -Infinity;
-}, 'number', function () {
-  return '-0';
-}, Number), simpleTransformation(isURL, 'URL', function (v) {
-  return v.toString();
-}, function (v) {
-  return new URL(v);
-})];
+var simpleRules = [
+    simpleTransformation(isUndefined, 'undefined', function () { return null; }, function () { return undefined; }),
+    simpleTransformation(isBigint, 'bigint', function (v) { return v.toString(); }, function (v) {
+        if (typeof BigInt !== 'undefined') {
+            return BigInt(v);
+        }
+        console.error('Please add a BigInt polyfill.');
+        return v;
+    }),
+    simpleTransformation(isDate, 'Date', function (v) { return v.toISOString(); }, function (v) { return new Date(v); }),
+    simpleTransformation(isError, 'Error', function (v, superJson) {
+        var baseError = {
+            name: v.name,
+            message: v.message
+        };
+        superJson.allowedErrorProps.forEach(function (prop) {
+            baseError[prop] = v[prop];
+        });
+        return baseError;
+    }, function (v, superJson) {
+        var e = new Error(v.message);
+        e.name = v.name;
+        e.stack = v.stack;
+        superJson.allowedErrorProps.forEach(function (prop) {
+            e[prop] = v[prop];
+        });
+        return e;
+    }),
+    simpleTransformation(isRegExp, 'regexp', function (v) { return '' + v; }, function (regex) {
+        var body = regex.slice(1, regex.lastIndexOf('/'));
+        var flags = regex.slice(regex.lastIndexOf('/') + 1);
+        return new RegExp(body, flags);
+    }),
+    simpleTransformation(isSet, 'set', 
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    function (v) { return __spreadArray$2([], __read$2(v.values())); }, function (v) { return new Set(v); }),
+    simpleTransformation(isMap, 'map', function (v) { return __spreadArray$2([], __read$2(v.entries())); }, function (v) { return new Map(v); }),
+    simpleTransformation(function (v) { return isNaNValue(v) || isInfinite(v); }, 'number', function (v) {
+        if (isNaNValue(v)) {
+            return 'NaN';
+        }
+        if (v > 0) {
+            return 'Infinity';
+        }
+        else {
+            return '-Infinity';
+        }
+    }, Number),
+    simpleTransformation(function (v) { return v === 0 && 1 / v === -Infinity; }, 'number', function () {
+        return '-0';
+    }, Number),
+    simpleTransformation(isURL, 'URL', function (v) { return v.toString(); }, function (v) { return new URL(v); }),
+];
 function compositeTransformation(isApplicable, annotation, transform, untransform) {
-  return {
-    isApplicable: isApplicable,
-    annotation: annotation,
-    transform: transform,
-    untransform: untransform
-  };
+    return {
+        isApplicable: isApplicable,
+        annotation: annotation,
+        transform: transform,
+        untransform: untransform
+    };
 }
 var symbolRule = compositeTransformation(function (s, superJson) {
-  if (isSymbol(s)) {
-    var isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
-    return isRegistered;
-  }
-  return false;
+    if (isSymbol(s)) {
+        var isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+        return isRegistered;
+    }
+    return false;
 }, function (s, superJson) {
-  var identifier = superJson.symbolRegistry.getIdentifier(s);
-  return ['symbol', identifier];
-}, function (v) {
-  return v.description;
-}, function (_, a, superJson) {
-  var value = superJson.symbolRegistry.getValue(a[1]);
-  if (!value) {
-    throw new Error('Trying to deserialize unknown symbol');
-  }
-  return value;
+    var identifier = superJson.symbolRegistry.getIdentifier(s);
+    return ['symbol', identifier];
+}, function (v) { return v.description; }, function (_, a, superJson) {
+    var value = superJson.symbolRegistry.getValue(a[1]);
+    if (!value) {
+        throw new Error('Trying to deserialize unknown symbol');
+    }
+    return value;
 });
-var constructorToName = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, Uint8ClampedArray].reduce(function (obj, ctor) {
-  obj[ctor.name] = ctor;
-  return obj;
+var constructorToName = [
+    Int8Array,
+    Uint8Array,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    Uint8ClampedArray,
+].reduce(function (obj, ctor) {
+    obj[ctor.name] = ctor;
+    return obj;
 }, {});
-var typedArrayRule = compositeTransformation(isTypedArray, function (v) {
-  return ['typed-array', v.constructor.name];
-}, function (v) {
-  return __spreadArray$2([], __read$2(v));
-}, function (v, a) {
-  var ctor = constructorToName[a[1]];
-  if (!ctor) {
-    throw new Error('Trying to deserialize unknown typed array');
-  }
-  return new ctor(v);
+var typedArrayRule = compositeTransformation(isTypedArray, function (v) { return ['typed-array', v.constructor.name]; }, function (v) { return __spreadArray$2([], __read$2(v)); }, function (v, a) {
+    var ctor = constructorToName[a[1]];
+    if (!ctor) {
+        throw new Error('Trying to deserialize unknown typed array');
+    }
+    return new ctor(v);
 });
 function isInstanceOfRegisteredClass(potentialClass, superJson) {
-  if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) {
-    var isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
-    return isRegistered;
-  }
-  return false;
+    if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) {
+        var isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+        return isRegistered;
+    }
+    return false;
 }
 var classRule = compositeTransformation(isInstanceOfRegisteredClass, function (clazz, superJson) {
-  var identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
-  return ['class', identifier];
+    var identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+    return ['class', identifier];
 }, function (clazz, superJson) {
-  var allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
-  if (!allowedProps) {
-    return __assign$1({}, clazz);
-  }
-  var result = {};
-  allowedProps.forEach(function (prop) {
-    result[prop] = clazz[prop];
-  });
-  return result;
+    var allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+    if (!allowedProps) {
+        return __assign$1({}, clazz);
+    }
+    var result = {};
+    allowedProps.forEach(function (prop) {
+        result[prop] = clazz[prop];
+    });
+    return result;
 }, function (v, a, superJson) {
-  var clazz = superJson.classRegistry.getValue(a[1]);
-  if (!clazz) {
-    throw new Error('Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564');
-  }
-  return Object.assign(Object.create(clazz.prototype), v);
+    var clazz = superJson.classRegistry.getValue(a[1]);
+    if (!clazz) {
+        throw new Error('Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564');
+    }
+    return Object.assign(Object.create(clazz.prototype), v);
 });
 var customRule = compositeTransformation(function (value, superJson) {
-  return !!superJson.customTransformerRegistry.findApplicable(value);
+    return !!superJson.customTransformerRegistry.findApplicable(value);
 }, function (value, superJson) {
-  var transformer = superJson.customTransformerRegistry.findApplicable(value);
-  return ['custom', transformer.name];
+    var transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return ['custom', transformer.name];
 }, function (value, superJson) {
-  var transformer = superJson.customTransformerRegistry.findApplicable(value);
-  return transformer.serialize(value);
+    var transformer = superJson.customTransformerRegistry.findApplicable(value);
+    return transformer.serialize(value);
 }, function (v, a, superJson) {
-  var transformer = superJson.customTransformerRegistry.findByName(a[1]);
-  if (!transformer) {
-    throw new Error('Trying to deserialize unknown custom value');
-  }
-  return transformer.deserialize(v);
+    var transformer = superJson.customTransformerRegistry.findByName(a[1]);
+    if (!transformer) {
+        throw new Error('Trying to deserialize unknown custom value');
+    }
+    return transformer.deserialize(v);
 });
 var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
 var transformValue = function (value, superJson) {
-  var applicableCompositeRule = findArr(compositeRules, function (rule) {
-    return rule.isApplicable(value, superJson);
-  });
-  if (applicableCompositeRule) {
-    return {
-      value: applicableCompositeRule.transform(value, superJson),
-      type: applicableCompositeRule.annotation(value, superJson)
-    };
-  }
-  var applicableSimpleRule = findArr(simpleRules, function (rule) {
-    return rule.isApplicable(value, superJson);
-  });
-  if (applicableSimpleRule) {
-    return {
-      value: applicableSimpleRule.transform(value, superJson),
-      type: applicableSimpleRule.annotation
-    };
-  }
-  return undefined;
+    var applicableCompositeRule = findArr(compositeRules, function (rule) {
+        return rule.isApplicable(value, superJson);
+    });
+    if (applicableCompositeRule) {
+        return {
+            value: applicableCompositeRule.transform(value, superJson),
+            type: applicableCompositeRule.annotation(value, superJson)
+        };
+    }
+    var applicableSimpleRule = findArr(simpleRules, function (rule) {
+        return rule.isApplicable(value, superJson);
+    });
+    if (applicableSimpleRule) {
+        return {
+            value: applicableSimpleRule.transform(value, superJson),
+            type: applicableSimpleRule.annotation
+        };
+    }
+    return undefined;
 };
 var simpleRulesByAnnotation = {};
 simpleRules.forEach(function (rule) {
-  simpleRulesByAnnotation[rule.annotation] = rule;
+    simpleRulesByAnnotation[rule.annotation] = rule;
 });
 var untransformValue = function (json, type, superJson) {
-  if (isArray$1(type)) {
-    switch (type[0]) {
-      case 'symbol':
-        return symbolRule.untransform(json, type, superJson);
-      case 'class':
-        return classRule.untransform(json, type, superJson);
-      case 'custom':
-        return customRule.untransform(json, type, superJson);
-      case 'typed-array':
-        return typedArrayRule.untransform(json, type, superJson);
-      default:
-        throw new Error('Unknown transformation: ' + type);
+    if (isArray$1(type)) {
+        switch (type[0]) {
+            case 'symbol':
+                return symbolRule.untransform(json, type, superJson);
+            case 'class':
+                return classRule.untransform(json, type, superJson);
+            case 'custom':
+                return customRule.untransform(json, type, superJson);
+            case 'typed-array':
+                return typedArrayRule.untransform(json, type, superJson);
+            default:
+                throw new Error('Unknown transformation: ' + type);
+        }
     }
-  } else {
-    var transformation = simpleRulesByAnnotation[type];
-    if (!transformation) {
-      throw new Error('Unknown transformation: ' + type);
+    else {
+        var transformation = simpleRulesByAnnotation[type];
+        if (!transformation) {
+            throw new Error('Unknown transformation: ' + type);
+        }
+        return transformation.untransform(json, superJson);
     }
-    return transformation.untransform(json, superJson);
-  }
 };
 
 var getNthKey = function (value, n) {
-  var keys = value.keys();
-  while (n > 0) {
-    keys.next();
-    n--;
-  }
-  return keys.next().value;
+    var keys = value.keys();
+    while (n > 0) {
+        keys.next();
+        n--;
+    }
+    return keys.next().value;
 };
 function validatePath(path) {
-  if (includes(path, '__proto__')) {
-    throw new Error('__proto__ is not allowed as a property');
-  }
-  if (includes(path, 'prototype')) {
-    throw new Error('prototype is not allowed as a property');
-  }
-  if (includes(path, 'constructor')) {
-    throw new Error('constructor is not allowed as a property');
-  }
+    if (includes(path, '__proto__')) {
+        throw new Error('__proto__ is not allowed as a property');
+    }
+    if (includes(path, 'prototype')) {
+        throw new Error('prototype is not allowed as a property');
+    }
+    if (includes(path, 'constructor')) {
+        throw new Error('constructor is not allowed as a property');
+    }
 }
 var getDeep = function (object, path) {
-  validatePath(path);
-  for (var i = 0; i < path.length; i++) {
-    var key = path[i];
-    if (isSet(object)) {
-      object = getNthKey(object, +key);
-    } else if (isMap(object)) {
-      var row = +key;
-      var type = +path[++i] === 0 ? 'key' : 'value';
-      var keyOfRow = getNthKey(object, row);
-      switch (type) {
-        case 'key':
-          object = keyOfRow;
-          break;
-        case 'value':
-          object = object.get(keyOfRow);
-          break;
-      }
-    } else {
-      object = object[key];
+    validatePath(path);
+    for (var i = 0; i < path.length; i++) {
+        var key = path[i];
+        if (isSet(object)) {
+            object = getNthKey(object, +key);
+        }
+        else if (isMap(object)) {
+            var row = +key;
+            var type = +path[++i] === 0 ? 'key' : 'value';
+            var keyOfRow = getNthKey(object, row);
+            switch (type) {
+                case 'key':
+                    object = keyOfRow;
+                    break;
+                case 'value':
+                    object = object.get(keyOfRow);
+                    break;
+            }
+        }
+        else {
+            object = object[key];
+        }
     }
-  }
-  return object;
+    return object;
 };
 var setDeep = function (object, path, mapper) {
-  validatePath(path);
-  if (path.length === 0) {
-    return mapper(object);
-  }
-  var parent = object;
-  for (var i = 0; i < path.length - 1; i++) {
-    var key = path[i];
+    validatePath(path);
+    if (path.length === 0) {
+        return mapper(object);
+    }
+    var parent = object;
+    for (var i = 0; i < path.length - 1; i++) {
+        var key = path[i];
+        if (isArray$1(parent)) {
+            var index = +key;
+            parent = parent[index];
+        }
+        else if (isPlainObject$1(parent)) {
+            parent = parent[key];
+        }
+        else if (isSet(parent)) {
+            var row = +key;
+            parent = getNthKey(parent, row);
+        }
+        else if (isMap(parent)) {
+            var isEnd = i === path.length - 2;
+            if (isEnd) {
+                break;
+            }
+            var row = +key;
+            var type = +path[++i] === 0 ? 'key' : 'value';
+            var keyOfRow = getNthKey(parent, row);
+            switch (type) {
+                case 'key':
+                    parent = keyOfRow;
+                    break;
+                case 'value':
+                    parent = parent.get(keyOfRow);
+                    break;
+            }
+        }
+    }
+    var lastKey = path[path.length - 1];
     if (isArray$1(parent)) {
-      var index = +key;
-      parent = parent[index];
-    } else if (isPlainObject$1(parent)) {
-      parent = parent[key];
-    } else if (isSet(parent)) {
-      var row = +key;
-      parent = getNthKey(parent, row);
-    } else if (isMap(parent)) {
-      var isEnd = i === path.length - 2;
-      if (isEnd) {
-        break;
-      }
-      var row = +key;
-      var type = +path[++i] === 0 ? 'key' : 'value';
-      var keyOfRow = getNthKey(parent, row);
-      switch (type) {
-        case 'key':
-          parent = keyOfRow;
-          break;
-        case 'value':
-          parent = parent.get(keyOfRow);
-          break;
-      }
+        parent[+lastKey] = mapper(parent[+lastKey]);
     }
-  }
-  var lastKey = path[path.length - 1];
-  if (isArray$1(parent)) {
-    parent[+lastKey] = mapper(parent[+lastKey]);
-  } else if (isPlainObject$1(parent)) {
-    parent[lastKey] = mapper(parent[lastKey]);
-  }
-  if (isSet(parent)) {
-    var oldValue = getNthKey(parent, +lastKey);
-    var newValue = mapper(oldValue);
-    if (oldValue !== newValue) {
-      parent["delete"](oldValue);
-      parent.add(newValue);
+    else if (isPlainObject$1(parent)) {
+        parent[lastKey] = mapper(parent[lastKey]);
     }
-  }
-  if (isMap(parent)) {
-    var row = +path[path.length - 2];
-    var keyToRow = getNthKey(parent, row);
-    var type = +lastKey === 0 ? 'key' : 'value';
-    switch (type) {
-      case 'key':
-        {
-          var newKey = mapper(keyToRow);
-          parent.set(newKey, parent.get(keyToRow));
-          if (newKey !== keyToRow) {
-            parent["delete"](keyToRow);
-          }
-          break;
+    if (isSet(parent)) {
+        var oldValue = getNthKey(parent, +lastKey);
+        var newValue = mapper(oldValue);
+        if (oldValue !== newValue) {
+            parent["delete"](oldValue);
+            parent.add(newValue);
         }
-      case 'value':
-        {
-          parent.set(keyToRow, mapper(parent.get(keyToRow)));
-          break;
+    }
+    if (isMap(parent)) {
+        var row = +path[path.length - 2];
+        var keyToRow = getNthKey(parent, row);
+        var type = +lastKey === 0 ? 'key' : 'value';
+        switch (type) {
+            case 'key': {
+                var newKey = mapper(keyToRow);
+                parent.set(newKey, parent.get(keyToRow));
+                if (newKey !== keyToRow) {
+                    parent["delete"](keyToRow);
+                }
+                break;
+            }
+            case 'value': {
+                parent.set(keyToRow, mapper(parent.get(keyToRow)));
+                break;
+            }
         }
     }
-  }
-  return object;
+    return object;
 };
 
-var __read$1 = undefined && undefined.__read || function (o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = {
-      error: error
-    };
-  } finally {
+var __read$1 = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
     try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-  }
-  return ar;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
 };
-var __spreadArray$1 = undefined && undefined.__spreadArray || function (to, from) {
-  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) to[j] = from[i];
-  return to;
+var __spreadArray$1 = (undefined && undefined.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
 };
 function traverse(tree, walker, origin) {
-  if (origin === void 0) {
-    origin = [];
-  }
-  if (!tree) {
-    return;
-  }
-  if (!isArray$1(tree)) {
-    forEach(tree, function (subtree, key) {
-      return traverse(subtree, walker, __spreadArray$1(__spreadArray$1([], __read$1(origin)), __read$1(parsePath(key))));
-    });
-    return;
-  }
-  var _a = __read$1(tree, 2),
-    nodeValue = _a[0],
-    children = _a[1];
-  if (children) {
-    forEach(children, function (child, key) {
-      traverse(child, walker, __spreadArray$1(__spreadArray$1([], __read$1(origin)), __read$1(parsePath(key))));
-    });
-  }
-  walker(nodeValue, origin);
+    if (origin === void 0) { origin = []; }
+    if (!tree) {
+        return;
+    }
+    if (!isArray$1(tree)) {
+        forEach(tree, function (subtree, key) {
+            return traverse(subtree, walker, __spreadArray$1(__spreadArray$1([], __read$1(origin)), __read$1(parsePath(key))));
+        });
+        return;
+    }
+    var _a = __read$1(tree, 2), nodeValue = _a[0], children = _a[1];
+    if (children) {
+        forEach(children, function (child, key) {
+            traverse(child, walker, __spreadArray$1(__spreadArray$1([], __read$1(origin)), __read$1(parsePath(key))));
+        });
+    }
+    walker(nodeValue, origin);
 }
 function applyValueAnnotations(plain, annotations, superJson) {
-  traverse(annotations, function (type, path) {
-    plain = setDeep(plain, path, function (v) {
-      return untransformValue(v, type, superJson);
+    traverse(annotations, function (type, path) {
+        plain = setDeep(plain, path, function (v) { return untransformValue(v, type, superJson); });
     });
-  });
-  return plain;
+    return plain;
 }
 function applyReferentialEqualityAnnotations(plain, annotations) {
-  function apply(identicalPaths, path) {
-    var object = getDeep(plain, parsePath(path));
-    identicalPaths.map(parsePath).forEach(function (identicalObjectPath) {
-      plain = setDeep(plain, identicalObjectPath, function () {
-        return object;
-      });
-    });
-  }
-  if (isArray$1(annotations)) {
-    var _a = __read$1(annotations, 2),
-      root = _a[0],
-      other = _a[1];
-    root.forEach(function (identicalPath) {
-      plain = setDeep(plain, parsePath(identicalPath), function () {
-        return plain;
-      });
-    });
-    if (other) {
-      forEach(other, apply);
+    function apply(identicalPaths, path) {
+        var object = getDeep(plain, parsePath(path));
+        identicalPaths.map(parsePath).forEach(function (identicalObjectPath) {
+            plain = setDeep(plain, identicalObjectPath, function () { return object; });
+        });
     }
-  } else {
-    forEach(annotations, apply);
-  }
-  return plain;
+    if (isArray$1(annotations)) {
+        var _a = __read$1(annotations, 2), root = _a[0], other = _a[1];
+        root.forEach(function (identicalPath) {
+            plain = setDeep(plain, parsePath(identicalPath), function () { return plain; });
+        });
+        if (other) {
+            forEach(other, apply);
+        }
+    }
+    else {
+        forEach(annotations, apply);
+    }
+    return plain;
 }
 var isDeep = function (object, superJson) {
-  return isPlainObject$1(object) || isArray$1(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
+    return isPlainObject$1(object) ||
+        isArray$1(object) ||
+        isMap(object) ||
+        isSet(object) ||
+        isInstanceOfRegisteredClass(object, superJson);
 };
 function addIdentity(object, path, identities) {
-  var existingSet = identities.get(object);
-  if (existingSet) {
-    existingSet.push(path);
-  } else {
-    identities.set(object, [path]);
-  }
+    var existingSet = identities.get(object);
+    if (existingSet) {
+        existingSet.push(path);
+    }
+    else {
+        identities.set(object, [path]);
+    }
 }
 function generateReferentialEqualityAnnotations(identitites) {
-  var result = {};
-  var rootEqualityPaths = undefined;
-  identitites.forEach(function (paths) {
-    if (paths.length <= 1) {
-      return;
-    }
-    var _a = __read$1(paths.map(function (path) {
-        return path.map(String);
-      }).sort(function (a, b) {
-        return a.length - b.length;
-      })),
-      shortestPath = _a[0],
-      identicalPaths = _a.slice(1);
-    if (shortestPath.length === 0) {
-      rootEqualityPaths = identicalPaths.map(stringifyPath);
-    } else {
-      result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
+    var result = {};
+    var rootEqualityPaths = undefined;
+    identitites.forEach(function (paths) {
+        if (paths.length <= 1) {
+            return;
+        }
+        var _a = __read$1(paths
+            .map(function (path) { return path.map(String); })
+            .sort(function (a, b) { return a.length - b.length; })), shortestPath = _a[0], identicalPaths = _a.slice(1);
+        if (shortestPath.length === 0) {
+            rootEqualityPaths = identicalPaths.map(stringifyPath);
+        }
+        else {
+            result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
+        }
+    });
+    if (rootEqualityPaths) {
+        if (isEmptyObject(result)) {
+            return [rootEqualityPaths];
+        }
+        else {
+            return [rootEqualityPaths, result];
+        }
     }
-  });
-  if (rootEqualityPaths) {
-    if (isEmptyObject(result)) {
-      return [rootEqualityPaths];
-    } else {
-      return [rootEqualityPaths, result];
+    else {
+        return isEmptyObject(result) ? undefined : result;
     }
-  } else {
-    return isEmptyObject(result) ? undefined : result;
-  }
 }
 var walker = function (object, identities, superJson, path, objectsInThisPath) {
-  var _a;
-  if (path === void 0) {
-    path = [];
-  }
-  if (objectsInThisPath === void 0) {
-    objectsInThisPath = [];
-  }
-  if (!isPrimitive(object)) {
-    addIdentity(object, path, identities);
-  }
-  if (!isDeep(object, superJson)) {
-    var transformed_1 = transformValue(object, superJson);
-    if (transformed_1) {
-      return {
-        transformedValue: transformed_1.value,
-        annotations: [transformed_1.type]
-      };
-    } else {
-      return {
-        transformedValue: object
-      };
+    var _a;
+    if (path === void 0) { path = []; }
+    if (objectsInThisPath === void 0) { objectsInThisPath = []; }
+    if (!isPrimitive(object)) {
+        addIdentity(object, path, identities);
+    }
+    if (!isDeep(object, superJson)) {
+        var transformed_1 = transformValue(object, superJson);
+        if (transformed_1) {
+            return {
+                transformedValue: transformed_1.value,
+                annotations: [transformed_1.type]
+            };
+        }
+        else {
+            return {
+                transformedValue: object
+            };
+        }
     }
-  }
-  if (includes(objectsInThisPath, object)) {
-    return {
-      transformedValue: null
-    };
-  }
-  var transformationResult = transformValue(object, superJson);
-  var transformed = (_a = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _a !== void 0 ? _a : object;
-  if (!isPrimitive(object)) {
-    objectsInThisPath = __spreadArray$1(__spreadArray$1([], __read$1(objectsInThisPath)), [object]);
-  }
-  var transformedValue = isArray$1(transformed) ? [] : {};
-  var innerAnnotations = {};
-  forEach(transformed, function (value, index) {
-    var recursiveResult = walker(value, identities, superJson, __spreadArray$1(__spreadArray$1([], __read$1(path)), [index]), objectsInThisPath);
-    transformedValue[index] = recursiveResult.transformedValue;
-    if (isArray$1(recursiveResult.annotations)) {
-      innerAnnotations[index] = recursiveResult.annotations;
-    } else if (isPlainObject$1(recursiveResult.annotations)) {
-      forEach(recursiveResult.annotations, function (tree, key) {
-        innerAnnotations[escapeKey(index) + '.' + key] = tree;
-      });
+    if (includes(objectsInThisPath, object)) {
+        return {
+            transformedValue: null
+        };
+    }
+    var transformationResult = transformValue(object, superJson);
+    var transformed = (_a = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _a !== void 0 ? _a : object;
+    if (!isPrimitive(object)) {
+        objectsInThisPath = __spreadArray$1(__spreadArray$1([], __read$1(objectsInThisPath)), [object]);
+    }
+    var transformedValue = isArray$1(transformed) ? [] : {};
+    var innerAnnotations = {};
+    forEach(transformed, function (value, index) {
+        var recursiveResult = walker(value, identities, superJson, __spreadArray$1(__spreadArray$1([], __read$1(path)), [index]), objectsInThisPath);
+        transformedValue[index] = recursiveResult.transformedValue;
+        if (isArray$1(recursiveResult.annotations)) {
+            innerAnnotations[index] = recursiveResult.annotations;
+        }
+        else if (isPlainObject$1(recursiveResult.annotations)) {
+            forEach(recursiveResult.annotations, function (tree, key) {
+                innerAnnotations[escapeKey(index) + '.' + key] = tree;
+            });
+        }
+    });
+    if (isEmptyObject(innerAnnotations)) {
+        return {
+            transformedValue: transformedValue,
+            annotations: !!transformationResult
+                ? [transformationResult.type]
+                : undefined
+        };
+    }
+    else {
+        return {
+            transformedValue: transformedValue,
+            annotations: !!transformationResult
+                ? [transformationResult.type, innerAnnotations]
+                : innerAnnotations
+        };
     }
-  });
-  if (isEmptyObject(innerAnnotations)) {
-    return {
-      transformedValue: transformedValue,
-      annotations: !!transformationResult ? [transformationResult.type] : undefined
-    };
-  } else {
-    return {
-      transformedValue: transformedValue,
-      annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
-    };
-  }
 };
 
 /**
@@ -4780,43 +4945,47 @@ var walker = function (object, identities, superJson, path, objectsInThisPath) {
  *
  * @param {*} payload
  * @returns {string}
- */
-function getType(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
+ */
+function getType(payload) {
+    return Object.prototype.toString.call(payload).slice(8, -1);
+}
 /**
  * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
  *
  * @param {*} payload
  * @returns {payload is PlainObject}
- */
-function isPlainObject(payload) {
-  if (getType(payload) !== 'Object') return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return prototype.constructor === Object && prototype === Object.prototype;
-}
+ */
+function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    const prototype = Object.getPrototypeOf(payload);
+    return prototype.constructor === Object && prototype === Object.prototype;
+}
 /**
  * Returns whether the payload is an array
  *
  * @param {any} payload
  * @returns {payload is any[]}
- */
-function isArray(payload) {
-  return getType(payload) === 'Array';
-}
-
-function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
-  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? 'enumerable' : 'nonenumerable';
-  if (propType === 'enumerable') carry[key] = newVal;
-  if (includeNonenumerable && propType === 'nonenumerable') {
-    Object.defineProperty(carry, key, {
-      value: newVal,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    });
-  }
-}
+ */
+function isArray(payload) {
+    return getType(payload) === 'Array';
+}
+
+function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
+    const propType = {}.propertyIsEnumerable.call(originalObject, key)
+        ? 'enumerable'
+        : 'nonenumerable';
+    if (propType === 'enumerable')
+        carry[key] = newVal;
+    if (includeNonenumerable && propType === 'nonenumerable') {
+        Object.defineProperty(carry, key, {
+            value: newVal,
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+    }
+}
 /**
  * Copy (clone) an object and all its props recursively to get rid of any prop referenced of the original object. Arrays are also cloned, however objects inside arrays are still linked.
  *
@@ -4826,140 +4995,126 @@ function assignProp(carry, key, newVal, originalObject, includeNonenumerable) {
  * @param {Options} [options = {}] Options can be `props` or `nonenumerable`
  * @returns {T} the target with replaced values
  * @export
- */
-function copy(target, options = {}) {
-  if (isArray(target)) {
-    return target.map(item => copy(item, options));
-  }
-  if (!isPlainObject(target)) {
-    return target;
-  }
-  const props = Object.getOwnPropertyNames(target);
-  const symbols = Object.getOwnPropertySymbols(target);
-  return [...props, ...symbols].reduce((carry, key) => {
-    if (isArray(options.props) && !options.props.includes(key)) {
-      return carry;
-    }
-    const val = target[key];
-    const newVal = copy(val, options);
-    assignProp(carry, key, newVal, target, options.nonenumerable);
-    return carry;
-  }, {});
-}
-
-var __assign = undefined && undefined.__assign || function () {
-  __assign = Object.assign || function (t) {
-    for (var s, i = 1, n = arguments.length; i < n; i++) {
-      s = arguments[i];
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-    }
-    return t;
-  };
-  return __assign.apply(this, arguments);
-};
-var __read = undefined && undefined.__read || function (o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o),
-    r,
-    ar = [],
-    e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = {
-      error: error
+ */
+function copy(target, options = {}) {
+    if (isArray(target)) {
+        return target.map((item) => copy(item, options));
+    }
+    if (!isPlainObject(target)) {
+        return target;
+    }
+    const props = Object.getOwnPropertyNames(target);
+    const symbols = Object.getOwnPropertySymbols(target);
+    return [...props, ...symbols].reduce((carry, key) => {
+        if (isArray(options.props) && !options.props.includes(key)) {
+            return carry;
+        }
+        const val = target[key];
+        const newVal = copy(val, options);
+        assignProp(carry, key, newVal, target, options.nonenumerable);
+        return carry;
+    }, {});
+}
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
     };
-  } finally {
+    return __assign.apply(this, arguments);
+};
+var __read = (undefined && undefined.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
     try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
     }
-  }
-  return ar;
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
 };
-var __spreadArray = undefined && undefined.__spreadArray || function (to, from) {
-  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) to[j] = from[i];
-  return to;
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
 };
-var SuperJSON = /** @class */function () {
-  function SuperJSON() {
-    this.classRegistry = new ClassRegistry();
-    this.symbolRegistry = new Registry(function (s) {
-      var _a;
-      return (_a = s.description) !== null && _a !== void 0 ? _a : '';
-    });
-    this.customTransformerRegistry = new CustomTransformerRegistry();
-    this.allowedErrorProps = [];
-  }
-  SuperJSON.prototype.serialize = function (object) {
-    var identities = new Map();
-    var output = walker(object, identities, this);
-    var res = {
-      json: output.transformedValue
+var SuperJSON = /** @class */ (function () {
+    function SuperJSON() {
+        this.classRegistry = new ClassRegistry();
+        this.symbolRegistry = new Registry(function (s) { var _a; return (_a = s.description) !== null && _a !== void 0 ? _a : ''; });
+        this.customTransformerRegistry = new CustomTransformerRegistry();
+        this.allowedErrorProps = [];
+    }
+    SuperJSON.prototype.serialize = function (object) {
+        var identities = new Map();
+        var output = walker(object, identities, this);
+        var res = {
+            json: output.transformedValue
+        };
+        if (output.annotations) {
+            res.meta = __assign(__assign({}, res.meta), { values: output.annotations });
+        }
+        var equalityAnnotations = generateReferentialEqualityAnnotations(identities);
+        if (equalityAnnotations) {
+            res.meta = __assign(__assign({}, res.meta), { referentialEqualities: equalityAnnotations });
+        }
+        return res;
     };
-    if (output.annotations) {
-      res.meta = __assign(__assign({}, res.meta), {
-        values: output.annotations
-      });
-    }
-    var equalityAnnotations = generateReferentialEqualityAnnotations(identities);
-    if (equalityAnnotations) {
-      res.meta = __assign(__assign({}, res.meta), {
-        referentialEqualities: equalityAnnotations
-      });
-    }
-    return res;
-  };
-  SuperJSON.prototype.deserialize = function (payload) {
-    var json = payload.json,
-      meta = payload.meta;
-    var result = copy(json);
-    if (meta === null || meta === void 0 ? void 0 : meta.values) {
-      result = applyValueAnnotations(result, meta.values, this);
-    }
-    if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {
-      result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
-    }
-    return result;
-  };
-  SuperJSON.prototype.stringify = function (object) {
-    return JSON.stringify(this.serialize(object));
-  };
-  SuperJSON.prototype.parse = function (string) {
-    return this.deserialize(JSON.parse(string));
-  };
-  SuperJSON.prototype.registerClass = function (v, options) {
-    this.classRegistry.register(v, options);
-  };
-  SuperJSON.prototype.registerSymbol = function (v, identifier) {
-    this.symbolRegistry.register(v, identifier);
-  };
-  SuperJSON.prototype.registerCustom = function (transformer, name) {
-    this.customTransformerRegistry.register(__assign({
-      name: name
-    }, transformer));
-  };
-  SuperJSON.prototype.allowErrorProps = function () {
-    var _a;
-    var props = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      props[_i] = arguments[_i];
-    }
-    (_a = this.allowedErrorProps).push.apply(_a, __spreadArray([], __read(props)));
-  };
-  SuperJSON.defaultInstance = new SuperJSON();
-  SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
-  SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
-  SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
-  SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
-  SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
-  SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
-  SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
-  SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
-  return SuperJSON;
-}();
+    SuperJSON.prototype.deserialize = function (payload) {
+        var json = payload.json, meta = payload.meta;
+        var result = copy(json);
+        if (meta === null || meta === void 0 ? void 0 : meta.values) {
+            result = applyValueAnnotations(result, meta.values, this);
+        }
+        if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {
+            result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+        }
+        return result;
+    };
+    SuperJSON.prototype.stringify = function (object) {
+        return JSON.stringify(this.serialize(object));
+    };
+    SuperJSON.prototype.parse = function (string) {
+        return this.deserialize(JSON.parse(string));
+    };
+    SuperJSON.prototype.registerClass = function (v, options) {
+        this.classRegistry.register(v, options);
+    };
+    SuperJSON.prototype.registerSymbol = function (v, identifier) {
+        this.symbolRegistry.register(v, identifier);
+    };
+    SuperJSON.prototype.registerCustom = function (transformer, name) {
+        this.customTransformerRegistry.register(__assign({ name: name }, transformer));
+    };
+    SuperJSON.prototype.allowErrorProps = function () {
+        var _a;
+        var props = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            props[_i] = arguments[_i];
+        }
+        (_a = this.allowedErrorProps).push.apply(_a, __spreadArray([], __read(props)));
+    };
+    SuperJSON.defaultInstance = new SuperJSON();
+    SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+    SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+    SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+    SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+    SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+    SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+    SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+    SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+    return SuperJSON;
+}());
 var serialize = SuperJSON.serialize;
 var stringify = SuperJSON.stringify;
 
@@ -5070,10 +5225,11 @@ function TanstackLogo() {
 // src/index.ts
 var FALLBACK = Symbol("fallback");
 function dispose(list) {
-  for (const o of list) o.dispose();
+  for (const o of list)
+    o.dispose();
 }
 function keyArray(items, keyFn, mapFn, options = {}) {
-  const prev = /* @__PURE__ */new Map();
+  const prev = /* @__PURE__ */ new Map();
   onCleanup(() => dispose(prev.values()));
   return () => {
     const list = items() || [];
@@ -5082,11 +5238,10 @@ function keyArray(items, keyFn, mapFn, options = {}) {
       if (!list.length) {
         dispose(prev.values());
         prev.clear();
-        if (!options.fallback) return [];
-        const fb2 = createRoot(dispose2 => {
-          prev.set(FALLBACK, {
-            dispose: dispose2
-          });
+        if (!options.fallback)
+          return [];
+        const fb2 = createRoot((dispose2) => {
+          prev.set(FALLBACK, { dispose: dispose2 });
           return options.fallback();
         });
         return [fb2];
@@ -5113,7 +5268,8 @@ function keyArray(items, keyFn, mapFn, options = {}) {
           result[i] = lookup.mapped;
           lookup.setIndex?.(i);
           lookup.setItem(() => item);
-        } else addNewItem(result, item, i, key);
+        } else
+          addNewItem(result, item, i, key);
       }
       for (const key of prevKeys) {
         prev.get(key)?.dispose();
@@ -5123,29 +5279,30 @@ function keyArray(items, keyFn, mapFn, options = {}) {
     });
   };
   function addNewItem(list, item, i, key) {
-    createRoot(dispose2 => {
+    createRoot((dispose2) => {
       const [getItem, setItem] = createSignal(item);
-      const save = {
-        setItem,
-        dispose: dispose2
-      };
+      const save = { setItem, dispose: dispose2 };
       if (mapFn.length > 1) {
         const [index, setIndex] = createSignal(i);
         save.setIndex = setIndex;
         save.mapped = mapFn(getItem, index);
-      } else save.mapped = mapFn(getItem);
+      } else
+        save.mapped = mapFn(getItem);
       prev.set(key, save);
       list[i] = save.mapped;
     });
   }
 }
 function Key(props) {
-  const {
-    by
-  } = props;
-  return createMemo(keyArray(() => props.each, typeof by === "function" ? by : v => v[by], props.children, "fallback" in props ? {
-    fallback: () => props.fallback
-  } : void 0));
+  const { by } = props;
+  return createMemo(
+    keyArray(
+      () => props.each,
+      typeof by === "function" ? by : (v) => v[by],
+      props.children,
+      "fallback" in props ? { fallback: () => props.fallback } : void 0
+    )
+  );
 }
 
 const _tmpl$$1 = /*#__PURE__*/template(`<span><svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M6 12L10 8L6 4" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"></path></svg></span>`, 6),
@@ -5571,118 +5728,117 @@ function useQueryDevtoolsContext() {
 }
 
 // src/index.ts
-var noop = () => {};
+var noop = () => {
+};
 function createListTransition(source, options) {
   const initSource = untrack(source);
-  const {
-    onChange
-  } = options;
+  const { onChange } = options;
   let prevSet = new Set(options.appear ? void 0 : initSource);
-  const exiting = /* @__PURE__ */new WeakSet();
-  const [toRemove, setToRemove] = createSignal([], {
-    equals: false
-  });
+  const exiting = /* @__PURE__ */ new WeakSet();
+  const [toRemove, setToRemove] = createSignal([], { equals: false });
   const [isTransitionPending] = useTransition();
-  const finishRemoved = options.exitMethod === "remove" ? noop : els => {
-    setToRemove(p => (p.push.apply(p, els), p));
-    for (const el of els) exiting.delete(el);
+  const finishRemoved = options.exitMethod === "remove" ? noop : (els) => {
+    setToRemove((p) => (p.push.apply(p, els), p));
+    for (const el of els)
+      exiting.delete(el);
   };
   const handleRemoved = options.exitMethod === "remove" ? noop : options.exitMethod === "keep-index" ? (els, el, i) => els.splice(i, 0, el) : (els, el) => els.push(el);
-  return createMemo(prev => {
-    const elsToRemove = toRemove();
-    const sourceList = source();
-    sourceList[$TRACK];
-    if (untrack(isTransitionPending)) {
-      isTransitionPending();
-      return prev;
-    }
-    if (elsToRemove.length) {
-      const next = prev.filter(e => !elsToRemove.includes(e));
-      elsToRemove.length = 0;
-      onChange({
-        list: next,
-        added: [],
-        removed: [],
-        unchanged: next,
-        finishRemoved
-      });
-      return next;
-    }
-    return untrack(() => {
-      const nextSet = new Set(sourceList);
-      const next = sourceList.slice();
-      const added = [];
-      const removed = [];
-      const unchanged = [];
-      for (const el of sourceList) {
-        (prevSet.has(el) ? unchanged : added).push(el);
-      }
-      let nothingChanged = !added.length;
-      for (let i = 0; i < prev.length; i++) {
-        const el = prev[i];
-        if (!nextSet.has(el)) {
-          if (!exiting.has(el)) {
-            removed.push(el);
-            exiting.add(el);
+  return createMemo(
+    (prev) => {
+      const elsToRemove = toRemove();
+      const sourceList = source();
+      sourceList[$TRACK];
+      if (untrack(isTransitionPending)) {
+        isTransitionPending();
+        return prev;
+      }
+      if (elsToRemove.length) {
+        const next = prev.filter((e) => !elsToRemove.includes(e));
+        elsToRemove.length = 0;
+        onChange({ list: next, added: [], removed: [], unchanged: next, finishRemoved });
+        return next;
+      }
+      return untrack(() => {
+        const nextSet = new Set(sourceList);
+        const next = sourceList.slice();
+        const added = [];
+        const removed = [];
+        const unchanged = [];
+        for (const el of sourceList) {
+          (prevSet.has(el) ? unchanged : added).push(el);
+        }
+        let nothingChanged = !added.length;
+        for (let i = 0; i < prev.length; i++) {
+          const el = prev[i];
+          if (!nextSet.has(el)) {
+            if (!exiting.has(el)) {
+              removed.push(el);
+              exiting.add(el);
+            }
+            handleRemoved(next, el, i);
           }
-          handleRemoved(next, el, i);
+          if (nothingChanged && el !== next[i])
+            nothingChanged = false;
         }
-        if (nothingChanged && el !== next[i]) nothingChanged = false;
-      }
-      if (!removed.length && nothingChanged) return prev;
-      onChange({
-        list: next,
-        added,
-        removed,
-        unchanged,
-        finishRemoved
+        if (!removed.length && nothingChanged)
+          return prev;
+        onChange({ list: next, added, removed, unchanged, finishRemoved });
+        prevSet = nextSet;
+        return next;
       });
-      prevSet = nextSet;
-      return next;
-    });
-  }, options.appear ? [] : initSource.slice());
+    },
+    options.appear ? [] : initSource.slice()
+  );
 }
 
-var isNonNullable = i => i != null;
-var filterNonNullable = arr => arr.filter(isNonNullable);
-var access = v => typeof v === "function" && !v.length ? v() : v;
-var asArray = value => Array.isArray(value) ? value : value ? [value] : [];
+var isNonNullable = (i) => i != null;
+var filterNonNullable = (arr) => arr.filter(isNonNullable);
+var access = (v) => typeof v === "function" && !v.length ? v() : v;
+var asArray = (value) => Array.isArray(value) ? value : value ? [value] : [];
 function handleDiffArray(current, prev, handleAdded, handleRemoved) {
   const currLength = current.length;
   const prevLength = prev.length;
   let i = 0;
   if (!prevLength) {
-    for (; i < currLength; i++) handleAdded(current[i]);
+    for (; i < currLength; i++)
+      handleAdded(current[i]);
     return;
   }
   if (!currLength) {
-    for (; i < prevLength; i++) handleRemoved(prev[i]);
+    for (; i < prevLength; i++)
+      handleRemoved(prev[i]);
     return;
   }
   for (; i < prevLength; i++) {
-    if (prev[i] !== current[i]) break;
+    if (prev[i] !== current[i])
+      break;
   }
   let prevEl;
   let currEl;
   prev = prev.slice(i);
   current = current.slice(i);
   for (prevEl of prev) {
-    if (!current.includes(prevEl)) handleRemoved(prevEl);
+    if (!current.includes(prevEl))
+      handleRemoved(prevEl);
   }
   for (currEl of current) {
-    if (!prev.includes(currEl)) handleAdded(currEl);
+    if (!prev.includes(currEl))
+      handleAdded(currEl);
   }
 }
 
-var defaultElementPredicate = item => item instanceof Element;
+var defaultElementPredicate = (item) => item instanceof Element;
 function getResolvedElements(value, predicate) {
-  if (predicate(value)) return value;
-  if (typeof value === "function" && !value.length) return getResolvedElements(value(), predicate);
+  if (predicate(value))
+    return value;
+  if (typeof value === "function" && !value.length)
+    return getResolvedElements(value(), predicate);
   if (Array.isArray(value)) {
     const results = [];
     for (const item of value) {
       const result = getResolvedElements(item, predicate);
-      if (result) Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+      if (result)
+        Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
     }
     return results.length ? results : null;
   }
@@ -5690,7 +5846,9 @@ function getResolvedElements(value, predicate) {
 }
 function resolveElements(fn, predicate = defaultElementPredicate, serverPredicate = defaultElementPredicate) {
   const children2 = createMemo(fn);
-  const memo = createMemo(() => getResolvedElements(children2(), predicate));
+  const memo = createMemo(
+    () => getResolvedElements(children2(), predicate)
+  );
   memo.toArray = () => {
     const value = memo();
     return Array.isArray(value) ? value : value ? [value] : [];
@@ -5717,21 +5875,13 @@ function nextFrame(fn) {
   requestAnimationFrame(() => requestAnimationFrame(fn));
 }
 function enterTransition(classnames, events, el, done) {
-  const {
-      enterClasses,
-      enterActiveClasses,
-      enterToClasses
-    } = classnames,
-    {
-      onBeforeEnter,
-      onEnter,
-      onAfterEnter
-    } = events;
+  const { enterClasses, enterActiveClasses, enterToClasses } = classnames, { onBeforeEnter, onEnter, onAfterEnter } = events;
   onBeforeEnter?.(el);
   el.classList.add(...enterClasses);
   el.classList.add(...enterActiveClasses);
   queueMicrotask(() => {
-    if (!el.parentNode) return done?.();
+    if (!el.parentNode)
+      return done?.();
     onEnter?.(el, () => endTransition());
   });
   nextFrame(() => {
@@ -5754,17 +5904,9 @@ function enterTransition(classnames, events, el, done) {
   }
 }
 function exitTransition(classnames, events, el, done) {
-  const {
-      exitClasses,
-      exitActiveClasses,
-      exitToClasses
-    } = classnames,
-    {
-      onBeforeExit,
-      onExit,
-      onAfterExit
-    } = events;
-  if (!el.parentNode) return done?.();
+  const { exitClasses, exitActiveClasses, exitToClasses } = classnames, { onBeforeExit, onExit, onAfterExit } = events;
+  if (!el.parentNode)
+    return done?.();
   onBeforeExit?.(el);
   el.classList.add(...exitClasses);
   el.classList.add(...exitActiveClasses);
@@ -5788,17 +5930,12 @@ function exitTransition(classnames, events, el, done) {
     }
   }
 }
-var TransitionGroup = props => {
+var TransitionGroup = (props) => {
   const classnames = createClassnames(props);
   return createListTransition(resolveElements(() => props.children).toArray, {
     appear: props.appear,
     exitMethod: "keep-index",
-    onChange({
-      added,
-      removed,
-      finishRemoved,
-      list
-    }) {
+    onChange({ added, removed, finishRemoved, list }) {
       const classes = classnames();
       for (const el of added) {
         enterTransition(classes, props, el);
@@ -5806,22 +5943,14 @@ var TransitionGroup = props => {
       const toMove = [];
       for (const el of list) {
         if (el.isConnected && (el instanceof HTMLElement || el instanceof SVGElement)) {
-          toMove.push({
-            el,
-            rect: el.getBoundingClientRect()
-          });
+          toMove.push({ el, rect: el.getBoundingClientRect() });
         }
       }
       queueMicrotask(() => {
         const moved = [];
-        for (const {
-          el,
-          rect
-        } of toMove) {
+        for (const { el, rect } of toMove) {
           if (el.isConnected) {
-            const newRect = el.getBoundingClientRect(),
-              dX = rect.left - newRect.left,
-              dY = rect.top - newRect.top;
+            const newRect = el.getBoundingClientRect(), dX = rect.left - newRect.left, dY = rect.top - newRect.top;
             if (dX || dY) {
               el.style.transform = `translate(${dX}px, ${dY}px)`;
               el.style.transitionDuration = "0s";
@@ -5831,7 +5960,7 @@ var TransitionGroup = props => {
         }
         document.body.offsetHeight;
         for (const el of moved) {
-          let endTransition2 = function (e) {
+          let endTransition2 = function(e) {
             if (e.target === el || /transform$/.test(e.propertyName)) {
               el.removeEventListener("transitionend", endTransition2);
               el.classList.remove(...classes.moveClasses);
@@ -5867,38 +5996,42 @@ function createStorage(props) {
   };
   const apis = props?.api ? Array.isArray(props.api) ? props.api : [props.api] : [globalThis.localStorage].filter(Boolean);
   const prefix = props?.prefix ? `${props.prefix}.` : "";
-  const signals = /* @__PURE__ */new Map();
-  const store = new Proxy({}, {
-    get(_, key) {
-      let node = signals.get(key);
-      if (!node) {
-        node = createSignal(void 0, {
-          equals: false
-        });
-        signals.set(key, node);
-      }
-      node[0]();
-      const value = apis.reduce((result, api) => {
-        if (result !== null || !api) {
-          return result;
+  const signals = /* @__PURE__ */ new Map();
+  const store = new Proxy(
+    {},
+    {
+      get(_, key) {
+        let node = signals.get(key);
+        if (!node) {
+          node = createSignal(void 0, { equals: false });
+          signals.set(key, node);
         }
-        try {
-          return api.getItem(`${prefix}${key}`);
-        } catch (err) {
-          handleError(err, `Error reading ${prefix}${key} from ${api["name"]}`);
-          return null;
+        node[0]();
+        const value = apis.reduce(
+          (result, api) => {
+            if (result !== null || !api) {
+              return result;
+            }
+            try {
+              return api.getItem(`${prefix}${key}`);
+            } catch (err) {
+              handleError(err, `Error reading ${prefix}${key} from ${api["name"]}`);
+              return null;
+            }
+          },
+          null
+        );
+        if (value !== null && props?.deserializer) {
+          return props.deserializer(value, key, props.options);
         }
-      }, null);
-      if (value !== null && props?.deserializer) {
-        return props.deserializer(value, key, props.options);
+        return value;
       }
-      return value;
     }
-  });
+  );
   const setter = (key, value, options) => {
     const filteredValue = props?.serializer ? props.serializer(value, key, options ?? props.options) : value;
     const apiKey = `${prefix}${key}`;
-    apis.forEach(api => {
+    apis.forEach((api) => {
       try {
         api.getItem(apiKey) !== filteredValue && api.setItem(apiKey, filteredValue);
       } catch (err) {
@@ -5908,14 +6041,14 @@ function createStorage(props) {
     const node = signals.get(key);
     node && node[1]();
   };
-  const remove = key => apis.forEach(api => {
+  const remove = (key) => apis.forEach((api) => {
     try {
       api.removeItem(`${prefix}${key}`);
     } catch (err) {
       handleError(err, `Error removing ${prefix}${key} from ${api.name}`);
     }
   });
-  const clear = () => apis.forEach(api => {
+  const clear = () => apis.forEach((api) => {
     try {
       api.clear();
     } catch (err) {
@@ -5932,7 +6065,7 @@ function createStorage(props) {
         }
       }
     };
-    apis.forEach(api => {
+    apis.forEach((api) => {
       if (typeof api.getAll === "function") {
         let values;
         try {
@@ -5944,8 +6077,7 @@ function createStorage(props) {
           addValue(key, values[key]);
         }
       } else {
-        let index = 0,
-          key;
+        let index = 0, key;
         try {
           while (key = api.key(index++)) {
             if (!result.hasOwnProperty(key)) {
@@ -5960,16 +6092,19 @@ function createStorage(props) {
     return result;
   };
   props?.sync !== false && onMount(() => {
-    const listener = ev => {
+    const listener = (ev) => {
       let changed = false;
-      apis.forEach(api => {
+      apis.forEach((api) => {
         try {
           if (api !== ev.storageArea && ev.key && ev.newValue !== api.getItem(ev.key)) {
             ev.newValue ? api.setItem(ev.key, ev.newValue) : api.removeItem(ev.key);
             changed = true;
           }
         } catch (err) {
-          handleError(err, `Error synching api ${api.name} from storage event (${ev.key}=${ev.newValue})`);
+          handleError(
+            err,
+            `Error synching api ${api.name} from storage event (${ev.key}=${ev.newValue})`
+          );
         }
       });
       changed && ev.key && signals.get(ev.key)?.[1]();
@@ -5978,21 +6113,25 @@ function createStorage(props) {
       globalThis.addEventListener("storage", listener);
       onCleanup(() => globalThis.removeEventListener("storage", listener));
     } else {
-      apis.forEach(api => api.addEventListener?.("storage", listener));
-      onCleanup(() => apis.forEach(api => api.removeEventListener?.("storage", listener)));
+      apis.forEach((api) => api.addEventListener?.("storage", listener));
+      onCleanup(() => apis.forEach((api) => api.removeEventListener?.("storage", listener)));
     }
   });
-  return [store, setter, {
-    clear,
-    error,
-    remove,
-    toJSON
-  }];
+  return [
+    store,
+    setter,
+    {
+      clear,
+      error,
+      remove,
+      toJSON
+    }
+  ];
 }
 var createLocalStorage = createStorage;
 
 // src/tools.ts
-var addClearMethod = storage => {
+var addClearMethod = (storage) => {
   if (typeof storage.clear === "function") {
     return storage;
   }
@@ -6006,7 +6145,7 @@ var addClearMethod = storage => {
 };
 
 // src/cookies.ts
-var serializeCookieOptions = options => {
+var serializeCookieOptions = (options) => {
   if (!options) {
     return "";
   }
@@ -6022,10 +6161,12 @@ var serializeCookieOptions = options => {
 };
 var cookieStorage = addClearMethod({
   _cookies: [globalThis.document, "cookie"],
-  getItem: key => cookieStorage._cookies[0][cookieStorage._cookies[1]].match("(^|;)\\s*" + key + "\\s*=\\s*([^;]+)")?.pop() ?? null,
+  getItem: (key) => cookieStorage._cookies[0][cookieStorage._cookies[1]].match("(^|;)\\s*" + key + "\\s*=\\s*([^;]+)")?.pop() ?? null,
   setItem: (key, value, options) => {
     const oldValue = cookieStorage.getItem(key);
-    cookieStorage._cookies[0][cookieStorage._cookies[1]] = `${key}=${value}${serializeCookieOptions(options)}`;
+    cookieStorage._cookies[0][cookieStorage._cookies[1]] = `${key}=${value}${serializeCookieOptions(
+      options
+    )}`;
     const storageEvent = Object.assign(new Event("storage"), {
       key,
       oldValue,
@@ -6035,28 +6176,34 @@ var cookieStorage = addClearMethod({
     });
     window.dispatchEvent(storageEvent);
   },
-  removeItem: key => {
+  removeItem: (key) => {
     cookieStorage._cookies[0][cookieStorage._cookies[1]] = `${key}=deleted${serializeCookieOptions({
-      expires: new Date(0)
+      expires:  new Date(0)
     })}`;
   },
-  key: index => {
+  key: (index) => {
     let key = null;
     let count = 0;
-    cookieStorage._cookies[0][cookieStorage._cookies[1]].replace(/(?:^|;)\s*(.+?)\s*=\s*[^;]+/g, (_, found) => {
-      if (!key && found && count++ === index) {
-        key = found;
+    cookieStorage._cookies[0][cookieStorage._cookies[1]].replace(
+      /(?:^|;)\s*(.+?)\s*=\s*[^;]+/g,
+      (_, found) => {
+        if (!key && found && count++ === index) {
+          key = found;
+        }
+        return "";
       }
-      return "";
-    });
+    );
     return key;
   },
   get length() {
     let length = 0;
-    cookieStorage._cookies[0][cookieStorage._cookies[1]].replace(/(?:^|;)\s*.+?\s*=\s*[^;]+/g, found => {
-      length += found ? 1 : 0;
-      return "";
-    });
+    cookieStorage._cookies[0][cookieStorage._cookies[1]].replace(
+      /(?:^|;)\s*.+?\s*=\s*[^;]+/g,
+      (found) => {
+        length += found ? 1 : 0;
+        return "";
+      }
+    );
     return length;
   }
 });
@@ -6066,34 +6213,21 @@ function makeResizeObserver(callback, options) {
   const observer = new ResizeObserver(callback);
   onCleanup(observer.disconnect.bind(observer));
   return {
-    observe: ref => observer.observe(ref, options),
+    observe: (ref) => observer.observe(ref, options),
     unobserve: observer.unobserve.bind(observer)
   };
 }
 function createResizeObserver(targets, onResize, options) {
-  const previousMap = /* @__PURE__ */new WeakMap(),
-    {
-      observe,
-      unobserve
-    } = makeResizeObserver(entries => {
-      for (const entry of entries) {
-        const {
-            contentRect,
-            target
-          } = entry,
-          width = Math.round(contentRect.width),
-          height = Math.round(contentRect.height),
-          previous = previousMap.get(target);
-        if (!previous || previous.width !== width || previous.height !== height) {
-          onResize(contentRect, target, entry);
-          previousMap.set(target, {
-            width,
-            height
-          });
-        }
+  const previousMap = /* @__PURE__ */ new WeakMap(), { observe, unobserve } = makeResizeObserver((entries) => {
+    for (const entry of entries) {
+      const { contentRect, target } = entry, width = Math.round(contentRect.width), height = Math.round(contentRect.height), previous = previousMap.get(target);
+      if (!previous || previous.width !== width || previous.height !== height) {
+        onResize(contentRect, target, entry);
+        previousMap.set(target, { width, height });
       }
-    }, options);
-  createEffect(prev => {
+    }
+  }, options);
+  createEffect((prev) => {
     const refs = filterNonNullable(asArray(access(targets)));
     handleDiffArray(refs, prev, observe, unobserve);
     return refs;
@@ -7935,4 +8069,4 @@ class TanstackQueryDevtools {
 }
 
 export { TanstackQueryDevtools };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.js.map